| using Repoverse.Core.Generation; |
| using Repoverse.Core.Model; |
| using Repoverse.Core.Voxels; |
| using static Repoverse.Core.WorldConstants; |
|
|
| namespace Repoverse.Core.Tests; |
|
|
| public class VoxelTests |
| { |
| [Fact] |
| public void Voxel_packs_type_material_and_state() |
| { |
| var v = new Voxel(BlockType.Window, MaterialFamily.Glass, 3); |
| Assert.Equal(BlockType.Window, v.Type); |
| Assert.Equal(MaterialFamily.Glass, v.Material); |
| Assert.Equal(3, v.State); |
| Assert.False(v.IsOpaque); |
| } |
|
|
| [Theory] |
| [InlineData(0, 0)] |
| [InlineData(31, 0)] |
| [InlineData(32, 1)] |
| [InlineData(-1, -1)] |
| [InlineData(-32, -1)] |
| [InlineData(-33, -2)] |
| public void Chunk_coordinates_floor_toward_negative_infinity(int voxel, int chunk) => |
| Assert.Equal(chunk, ChunkCoord.FloorDiv(voxel)); |
|
|
| [Fact] |
| public void Solid_box_meshes_to_six_quads() |
| { |
| var chunk = new Chunk(new ChunkCoord(0, 0, 0)); |
| for (int x = 4; x < 12; x++) for (int y = 4; y < 9; y++) for (int z = 4; z < 20; z++) |
| chunk[x, y, z] = new Voxel(BlockType.Wall); |
| var mesh = GreedyMesher.Build(chunk); |
| Assert.Equal(6, mesh.Quads.Count); |
| Assert.Equal(2 * (8 * 5 + 8 * 16 + 5 * 16), mesh.VisibleFaces); |
| } |
|
|
| [Fact] |
| public void Greedy_quads_cover_exactly_the_visible_faces() |
| { |
| var rng = new SeededRandom(99); |
| var chunk = new Chunk(new ChunkCoord(0, 0, 0)); |
| BlockType[] types = [BlockType.Air, BlockType.Air, BlockType.Wall, BlockType.Floor, BlockType.Window]; |
| for (int i = 0; i < ChunkVolume; i++) |
| chunk[i % ChunkSize, i / (ChunkSize * ChunkSize), i / ChunkSize % ChunkSize] = new Voxel(rng.Pick(types)); |
| var mesh = GreedyMesher.Build(chunk); |
| Assert.Equal(mesh.VisibleFaces, mesh.Quads.Sum(q => q.Width * q.Height)); |
| Assert.True(mesh.Quads.Count < mesh.VisibleFaces); |
| } |
|
|
| [Fact] |
| public void Faces_against_a_loaded_solid_neighbour_are_culled() |
| { |
| var chunk = new Chunk(new ChunkCoord(0, 0, 0)); |
| for (int y = 0; y < ChunkSize; y++) for (int z = 0; z < ChunkSize; z++) chunk[ChunkSize - 1, y, z] = new Voxel(BlockType.Wall); |
| var open = GreedyMesher.Build(chunk); |
| var closed = GreedyMesher.Build(chunk, (x, _, _) => x >= ChunkSize ? new Voxel(BlockType.Wall) : null); |
| Assert.Equal(open.VisibleFaces - ChunkSize * ChunkSize, closed.VisibleFaces); |
| } |
|
|
| [Fact] |
| public void Generated_chunks_are_deterministic_and_contain_buildings() |
| { |
| var manifest = ManifestBuilder.Build(TestRepos.Slice(), new Seed(5)); |
| var b = manifest.Buildings[0]; |
| var c = ChunkCoord.FromVoxel(b.Footprint.X + 2, GroundLevel + 1, b.Footprint.Z + 2); |
| var gen = new WorldGenerator(manifest); |
| var one = gen.Generate(c); |
| var two = new WorldGenerator(manifest).Generate(c); |
| Assert.True(one.Raw.SequenceEqual(two.Raw)); |
| var local = one[b.Footprint.X + 2 - c.OriginX, GroundLevel - c.OriginY, b.Footprint.Z + 2 - c.OriginZ]; |
| Assert.Equal(BlockType.Floor, local.Type); |
| } |
|
|
| [Fact] |
| public void Chunks_outside_the_world_height_are_empty() |
| { |
| var gen = new WorldGenerator(ManifestBuilder.Build(TestRepos.Slice(), new Seed(5))); |
| Assert.True(gen.Generate(new ChunkCoord(0, -1, 0)).IsEmpty); |
| Assert.True(gen.Generate(new ChunkCoord(0, WorldGenerator.MaxChunkY + 1, 0)).IsEmpty); |
| } |
|
|
| [Fact] |
| public async Task Streaming_memory_is_bounded_by_radius_while_travelling() |
| { |
| var manifest = ManifestBuilder.Build(TestRepos.Slice(), new Seed(5)); |
| var streamer = new ChunkStreamer(new WorldGenerator(manifest), new WorldEdits(), radius: 2); |
| int layers = WorldGenerator.MaxChunkY + 1; |
| int maxResident = (2 * (2 + StreamHysteresisChunks) + 1) * (2 * (2 + StreamHysteresisChunks) + 1) * layers; |
|
|
| for (int step = 0; step < 12; step++) |
| { |
| await streamer.SettleAsync(step * 3 * ChunkSize, 100); |
| Assert.InRange(streamer.Loaded.Count, 1, maxResident); |
| } |
| Assert.Equal(0, streamer.InFlight); |
| } |
|
|
| [Fact] |
| public async Task Player_edits_survive_chunk_unload_and_reload() |
| { |
| var manifest = ManifestBuilder.Build(TestRepos.Slice(), new Seed(5)); |
| var edits = new WorldEdits(); |
| var streamer = new ChunkStreamer(new WorldGenerator(manifest), edits, radius: 1); |
| edits.Set(5, GroundLevel + 3, 5, new Voxel(BlockType.Wall, MaterialFamily.Wood)); |
|
|
| await streamer.SettleAsync(0, 0); |
| Assert.Equal(BlockType.Wall, streamer.Sample(5, GroundLevel + 3, 5)!.Value.Type); |
| await streamer.SettleAsync(50 * ChunkSize, 0); |
| Assert.Null(streamer.Sample(5, GroundLevel + 3, 5)); |
| await streamer.SettleAsync(0, 0); |
| Assert.Equal(MaterialFamily.Wood, streamer.Sample(5, GroundLevel + 3, 5)!.Value.Material); |
| } |
|
|
| [Fact] |
| public void Generation_honours_cancellation() |
| { |
| var gen = new WorldGenerator(ManifestBuilder.Build(TestRepos.Slice(), new Seed(5))); |
| using var cts = new CancellationTokenSource(); |
| cts.Cancel(); |
| Assert.Throws<OperationCanceledException>(() => gen.Generate(new ChunkCoord(0, 0, 0), ct: cts.Token)); |
| } |
| } |
|
|
