test: run tile-dependent tests on synthetic terrain instead of client files (#2725)

## Summary

About 114 tests skipped on CI because they needed the official client files (`tiledata.mul`, map and multi files). They gave CI no signal, and locally they ran against whichever client a developer had installed. The test hosts now build their own world instead, so every test runs on CI and runs the same on every machine. CI simulation: Server.Tests 837 passed, UOContent.Tests 1131 passed, **0 skipped**.

- **Generated tile data.** The fixtures write a pre-HS `tiledata.mul` from a small invented tile kit (`Server.Tests/Terrain/TestTiles`) and load it through the real `TileData.Load()`. The test hosts no longer read any client directory (`MODERNUO_CLIENT_PATH`, `MODERNUO_TEST_DATA_DIR` and `C:\Ultima Online Classic` are gone from test code). The file is written to `SyntheticData` in each test project's output, overwritten every run and removed by `dotnet clean`.
- **Injected terrain.** `TestTerrain` stamps land and statics into Felucca and Trammel, which share one terrain. Writes after startup must go in a `TestTerrain.Scope()`, which puts back every block it touched and keeps the step cache fresh.
- **Prefab scenes.** Seven named scenes (town, causeway, sewer walkway, coastline, deep sea, map-edge sea, an upstairs room with an L-shaped counter) replace the Britain coordinates the pathing, AI and fishing tests relied on. Each scene-based test asserts its scene is present first, so a missing scene fails instead of passing on flat ground. Stamping all seven takes 3-5 ms.
- **Multi footprints.** Contrived footprints for the three multi IDs content looks up (0x74, 0x7A, 0x0) are seeded through a new internal `MultiData.SetComponents`.
- **Fingerprint.** `StepCacheFile.HashTileDataFile` is extracted so a test can show that a one-flag change to the file changes the fingerprint, while runtime table mutation does not.

### Engine changes

- `TileMatrix.GetLandBlock`/`GetStaticBlock`: on a map without its files, return the block injected with `SetLandBlock`/`SetStaticBlock`, or the default when nothing was injected. Maps with files take the same path as before.
- `MultiData.SetComponents` (internal): registers a footprint without multi files.

### Test changes worth a look

- Values that were properties of real Britain terrain (probes at Z 10, a pinned plain walk mask of 0xC1) are re-pinned to the synthetic plain (Z 0, 0xFF).
- No tests were deleted. The multi walkability and boat-deck tests assert movement behaviour over a footprint, not what a real multi looks like, so they run on the contrived footprints.
- Maps 0 and 1 keep file indexes 0 and 1, and every stamp writes both, rather than sharing one file index. On a map without files the getters never consult the shared-file cache, and its patch bits would hide one facet's injection from the other.

## Test plan

- [x] `dotnet test -p:SolutionDir=... --filter "Category!=Manual"` with the client env vars pointed at an empty directory: 837 + 1131 passed, 0 skipped, 0 failed
- [x] Mutation check: removing the step-cache clear from `TestTerrain` makes the stale-cache tests fail
- [x] CI green on all platforms

Projects/Server.Tests/Tests/Maps/CanFitItemTests.cs

@@ -9,11 +9,6 @@ namespace Server.Tests.Maps;
 [Collection("Sequential Server Tests")]
 public class CanFitItemTests
 {
-    private void SkipIfNoTileData()
-    {
-        Skip.If(!ServerFixture.TileDataLoaded, "TileData not loaded - client files required");
-    }
-
     [Fact]
     public void CanFitItem_InternalMapReturnsFalse()
     {
@@ -33,8 +28,7 @@ public class CanFitItemTests
         Assert.False(map.CanFitItem(100, map.Height + 1, 0, 1));
     }
 
-    // Plain walkable land in the real Felucca map. Without map files every cell is the default land
-    // tile at Z 0 with no flags, which these tests treat the same way: a surface with nothing above it.
+    // The synthetic map's default ground: land ID 0 at Z 0 with no flags, a surface with nothing above it.
     private const int TestLandX = 1500;
     private const int TestLandY = 1600;
 
@@ -61,12 +55,9 @@ public class CanFitItemTests
         Assert.False(result, "No surface 50 units above land");
     }
 
-    [SkippableFact]
+    [Fact]
     public void CanFitItem_SurfaceImpassableMultiIsValidSurface()
     {
-        SkipIfNoTileData();
-        Skip.If(ServerFixture.SurfaceImpassableTileId == 0, "No Surface+Impassable tile found in TileData");
-
         var map = Map.Felucca;
         const int x = 1700;
         const int y = 1700;
@@ -94,12 +85,9 @@ public class CanFitItemTests
         }
     }
 
-    [SkippableFact]
+    [Fact]
     public void CanFitItem_CanFitDoesNotAllowSurfaceImpassable()
     {
-        SkipIfNoTileData();
-        Skip.If(ServerFixture.SurfaceImpassableTileId == 0, "No Surface+Impassable tile found in TileData");
-
         var map = Map.Felucca;
         const int x = 1750;
         const int y = 1750;
@@ -130,11 +118,9 @@ public class CanFitItemTests
         }
     }
 
-    [SkippableFact]
+    [Fact]
     public void CanFitItem_NonMovableWorldItemSurfaceWorks()
     {
-        SkipIfNoTileData();
-
         var map = Map.Felucca;
         const int x = 1800;
         const int y = 1800;
@@ -160,11 +146,9 @@ public class CanFitItemTests
         }
     }
 
-    [SkippableFact]
+    [Fact]
     public void CanFitItem_MovableWorldItemNotValidSurface()
     {
-        SkipIfNoTileData();
-
         var map = Map.Felucca;
         const int x = 1850;
         const int y = 1850;
@@ -192,11 +176,9 @@ public class CanFitItemTests
         }
     }
 
-    [SkippableFact]
+    [Fact]
     public void CanFitItem_ImpassableTileBlocksPlacement()
     {
-        SkipIfNoTileData();
-
         var map = Map.Felucca;
         const int x = 1900;
         const int y = 1900;

Projects/Server.Tests/Tests/Maps/CanSpawnMobileTests.cs

@@ -3,8 +3,8 @@ using Xunit;
 namespace Server.Tests.Maps;
 
 /// <summary>
-/// Tests for CanSpawnMobile that don't require TileData (client files).
-/// For tests that require client files, see CanSpawnMobileTileDataTests.
+/// Tests for CanSpawnMobile on the default ground.
+/// For tests over tile flags, see CanSpawnMobileTileDataTests.
 /// </summary>
 [Collection("Sequential Server Tests")]
 public class CanSpawnMobileTests
@@ -29,8 +29,8 @@ public class CanSpawnMobileTests
         Assert.False(map.CanSpawnMobile(100, map.Height + 1, -128, 127, false, false, out _));
     }
 
-    // Plain walkable land near Britain in the real Felucca map. Without map files every cell is the
-    // default land tile at Z 0 with no flags, which CanSpawnMobile treats the same way: walkable, not water.
+    // The synthetic map's default ground: land ID 0 at Z 0 with no flags, which CanSpawnMobile treats as
+    // walkable, not water.
     private const int TestLandX = 1500;
     private const int TestLandY = 1600;
 

Projects/Server.Tests/Tests/Maps/CanSpawnMobileTileDataTests.cs

@@ -4,23 +4,14 @@ using Xunit;
 namespace Server.Tests.Maps;
 
 /// <summary>
-/// Tests for CanSpawnMobile that require TileData (client files) to be loaded.
-/// These tests will be skipped if client files are not available.
-/// Configure client path via MODERNUO_CLIENT_PATH environment variable or place files at C:\Ultima Online Classic.
+/// Tests for CanSpawnMobile over tile flags, using tiles from the generated test kit.
 /// </summary>
 [Collection("Sequential Server Tests")]
 public class CanSpawnMobileTileDataTests
 {
-    private void SkipIfNoTileData()
-    {
-        Skip.If(!ServerFixture.TileDataLoaded, "TileData not loaded - client files required");
-    }
-
-    [SkippableFact]
+    [Fact]
     public void CanSpawnMobile_FindsLowestValidSurface()
     {
-        SkipIfNoTileData();
-
         var map = Map.Felucca;
         const int x = 1200;
         const int y = 1200;
@@ -44,11 +35,9 @@ public class CanSpawnMobileTileDataTests
         }
     }
 
-    [SkippableFact]
+    [Fact]
     public void CanSpawnMobile_ZRangeSelectsCorrectFloor()
     {
-        SkipIfNoTileData();
-
         var map = Map.Felucca;
         const int x = 1300;
         const int y = 1300;
@@ -72,11 +61,9 @@ public class CanSpawnMobileTileDataTests
         }
     }
 
-    [SkippableFact]
+    [Fact]
     public void CanSpawnMobile_LowCeilingBlocksSpawn()
     {
-        SkipIfNoTileData();
-
         var map = Map.Felucca;
         const int x = 1400;
         const int y = 1400;
@@ -99,11 +86,9 @@ public class CanSpawnMobileTileDataTests
         }
     }
 
-    [SkippableFact]
+    [Fact]
     public void CanSpawnMobile_HighCeilingAllowsSpawn()
     {
-        SkipIfNoTileData();
-
         var map = Map.Felucca;
         const int x = 1450;
         const int y = 1450;
@@ -124,11 +109,9 @@ public class CanSpawnMobileTileDataTests
         }
     }
 
-    [SkippableFact]
+    [Fact]
     public void CanSpawnMobile_BlockerOutsideZRangeIgnored()
     {
-        SkipIfNoTileData();
-
         var map = Map.Felucca;
         const int x = 1475;
         const int y = 1475;
@@ -150,11 +133,9 @@ public class CanSpawnMobileTileDataTests
         }
     }
 
-    [SkippableFact]
+    [Fact]
     public void CanSpawnMobile_WaterSurfaceForSwimmingMob()
     {
-        SkipIfNoTileData();
-
         var map = Map.Felucca;
         const int x = 1550;
         const int y = 1550;
@@ -176,11 +157,9 @@ public class CanSpawnMobileTileDataTests
         }
     }
 
-    [SkippableFact]
+    [Fact]
     public void CanSpawnMobile_WorldItemSurfaceWorks()
     {
-        SkipIfNoTileData();
-
         var map = Map.Felucca;
         const int x = 1650;
         const int y = 1650;

Projects/Server.Tests/Tests/Maps/StaticTileEnumeratorTests.cs

@@ -13,7 +13,7 @@ public class StaticTileEnumeratorTests
         var map = Map.Felucca;
         var location = new Point2D(200, 200);
 
-        // Real map files may have statics here; without them there are none. Either way the multi adds nothing.
+        // The synthetic map has no statics here; the multi must add nothing to the statics-only walk.
         var mapStatics = CollectTiles(map, location, includeStatics: true, includeMultis: false);
 
         TestMulti multi = null;

Projects/Server.Tests/Tests/Maps/TileMatrixInjectionTests.cs

@@ -0,0 +1,79 @@
+using Xunit;
+
+namespace Server.Tests.Maps;
+
+[Collection("Sequential Server Tests")]
+public class TileMatrixInjectionTests
+{
+    // Not registered in Map.Maps, and no data directory holds map96.mul, so this matrix has no file streams.
+    private static Map NewFilelessMap() => new(0x60, 0x60, 0x60, 64, 64, 0, "inject-test", MapRules.TrammelRules);
+
+    [Fact]
+    public void InjectedLandBlock_IsReturned_WithNoMapFile()
+    {
+        var tiles = NewFilelessMap().Tiles;
+        var block = new LandTile[64];
+        block[9] = new LandTile(0x10, 7);
+
+        tiles.SetLandBlock(1, 1, block);
+
+        var tile = tiles.GetLandTile(9, 9);
+        Assert.Equal(0x10, tile.ID);
+        Assert.Equal(7, tile.Z);
+    }
+
+    [Fact]
+    public void UninjectedLand_IsIdZeroAtZZero()
+    {
+        var tile = NewFilelessMap().Tiles.GetLandTile(30, 30);
+
+        Assert.Equal(0, tile.ID);
+        Assert.Equal(0, tile.Z);
+    }
+
+    [Fact]
+    public void InjectedStaticBlock_IsReturned_WithNoStaticFiles()
+    {
+        var tiles = NewFilelessMap().Tiles;
+        var block = new StaticTile[8][][];
+        for (var x = 0; x < 8; x++)
+        {
+            block[x] = new StaticTile[8][];
+            for (var y = 0; y < 8; y++)
+            {
+                block[x][y] = [];
+            }
+        }
+
+        block[1][1] = [new StaticTile(0x20, 5)];
+
+        tiles.SetStaticBlock(1, 1, block);
+
+        var cell = tiles.GetStaticBlock(1, 1)[1][1];
+        Assert.Single(cell);
+        Assert.Equal(0x20, cell[0].ID);
+        Assert.Equal(5, cell[0].Z);
+    }
+
+    [Fact]
+    public void ClearingABlock_RestoresTheDefault()
+    {
+        var tiles = NewFilelessMap().Tiles;
+        var block = new LandTile[64];
+        block[9] = new LandTile(0x10, 7);
+        tiles.SetLandBlock(1, 1, block);
+
+        tiles.SetLandBlock(1, 1, null);
+
+        Assert.Equal(0, tiles.GetLandTile(9, 9).ID);
+    }
+
+    [Fact]
+    public void OutOfRange_StillReturnsDefault()
+    {
+        var tiles = NewFilelessMap().Tiles;
+
+        Assert.Equal(0, tiles.GetLandBlock(-1, 0)[0].ID);
+        Assert.Equal(0, tiles.GetLandBlock(8, 0)[0].ID);
+    }
+}

Projects/Server.Tests/Tests/Network/Packets/Outgoing/ItemPacketTests.cs

@@ -9,7 +9,7 @@ public class ItemPacketTests : IDisposable
 {
     private const int TestItemId = 1;
 
-    // TileData is global and holds real client data when client files are loaded, so each test restores it.
+    // TileData is global, so each test restores it.
     private readonly ItemData _originalItemData;
 
     public ItemPacketTests()

Projects/Server.Tests/Tests/Terrain/SyntheticTileDataTests.cs

@@ -0,0 +1,59 @@
+using System.IO;
+using Xunit;
+
+namespace Server.Tests.Terrain;
+
+[Collection("Sequential Server Tests")]
+public class SyntheticTileDataTests
+{
+    [Fact]
+    public void GeneratedFile_IsPreHsSize()
+    {
+        Assert.Equal(1_036_288, SyntheticTileData.Build().Length);
+    }
+
+    // Inside the test host's output, rewritten every run, so runs leave nothing behind in the temp directory.
+    [Fact]
+    public void DataDirectory_IsTheOnlyDataDirectory_AndLivesInTheTestHost()
+    {
+        Assert.Equal(Path.Combine(Core.BaseDirectory, "SyntheticData"), SyntheticWorld.DataDirectory);
+        Assert.Equal([SyntheticWorld.DataDirectory], ServerConfiguration.DataDirectories);
+    }
+
+    [Fact]
+    public void KitIds_FitThePreHsTable()
+    {
+        for (var i = 0; i < TestTiles.Items.Count; i++)
+        {
+            Assert.True(TestTiles.Items[i].Id < 0x4000, $"{TestTiles.Items[i].Name} is outside the pre-HS item table");
+        }
+
+        for (var i = 0; i < TestTiles.Land.Count; i++)
+        {
+            Assert.True(TestTiles.Land[i].Id < 0x4000, $"{TestTiles.Land[i].Name} is outside the land table");
+        }
+    }
+
+    [Fact]
+    public void GeneratedFile_RoundTripsKitThroughLoad()
+    {
+        SyntheticTileData.LoadInto(SyntheticWorld.DataDirectory);
+
+        for (var i = 0; i < TestTiles.Items.Count; i++)
+        {
+            var tile = TestTiles.Items[i];
+            Assert.Equal(tile.Flags, TileData.ItemTable[tile.Id].Flags);
+            Assert.Equal((int)tile.Height, TileData.ItemTable[tile.Id].Height);
+            Assert.Equal(tile.Name, TileData.ItemTable[tile.Id].Name);
+        }
+
+        for (var i = 0; i < TestTiles.Land.Count; i++)
+        {
+            var tile = TestTiles.Land[i];
+            Assert.Equal(tile.Flags, TileData.LandTable[tile.Id].Flags);
+        }
+
+        Assert.Equal(TileFlag.None, TileData.ItemTable[0x2A0].Flags);
+        Assert.Equal(TileFlag.None, TileData.LandTable[3].Flags);
+    }
+}

Projects/Server.Tests/Tests/Terrain/TestMultisTests.cs

@@ -0,0 +1,33 @@
+using Xunit;
+
+namespace Server.Tests.Terrain;
+
+[Collection("Sequential Server Tests")]
+public class TestMultisTests
+{
+    [Theory]
+    [InlineData(TestMultis.GuildHouse)]
+    [InlineData(TestMultis.Tower)]
+    [InlineData(TestMultis.SmallBoatNorth)]
+    public void Seed_RegistersFootprint(int multiID)
+    {
+        Assert.NotEmpty(MultiData.GetComponents(multiID).List);
+    }
+
+    [Fact]
+    public void Footprints_DifferBetweenGuildHouseAndTower()
+    {
+        var house = MultiData.GetComponents(TestMultis.GuildHouse);
+        var tower = MultiData.GetComponents(TestMultis.Tower);
+        Assert.NotEqual(house.Width, tower.Width);
+    }
+
+    [Fact]
+    public void GuildHouse_HasAnOpenDoorway()
+    {
+        var house = MultiData.GetComponents(TestMultis.GuildHouse);
+        var doorway = house.Tiles[house.Center.X][house.Height - 1];
+        Assert.Single(doorway);
+        Assert.Equal(TestTiles.Floor, doorway[0].ID & TileData.MaxItemValue);
+    }
+}

Projects/Server.Tests/Tests/Terrain/TestTerrainTests.cs

@@ -0,0 +1,125 @@
+using System;
+using Xunit;
+
+namespace Server.Tests.Terrain;
+
+[Collection("Sequential Server Tests")]
+public class TestTerrainTests
+{
+    // Default ground outside the prefab region.
+    private const int X = 1400;
+    private const int Y = 1400;
+
+    [Fact]
+    public void StampingOneTile_KeepsTheRestOfTheBlock()
+    {
+        using var scope = TestTerrain.Scope();
+
+        TestTerrain.SetLand(X, Y, TestTiles.Grass, 3);
+        TestTerrain.SetLand(X + 1, Y, TestTiles.Dirt, 4);
+
+        Assert.Equal(TestTiles.Grass, Map.Felucca.Tiles.GetLandTile(X, Y).ID);
+        Assert.Equal(TestTiles.Dirt, Map.Felucca.Tiles.GetLandTile(X + 1, Y).ID);
+    }
+
+    [Fact]
+    public void StampingAnUninjectedBlock_DoesNotTouchOtherBlocks()
+    {
+        using var scope = TestTerrain.Scope();
+
+        TestTerrain.SetLand(X, Y, TestTiles.Grass, 3);
+
+        Assert.Equal(0, Map.Felucca.Tiles.GetLandTile(X + 64, Y + 64).ID);
+        Assert.Equal(0, Map.Felucca.Tiles.GetLandTile(X + 1, Y).ID);
+    }
+
+    [Fact]
+    public void Stamps_ReachBothFacets()
+    {
+        using var scope = TestTerrain.Scope();
+
+        TestTerrain.SetLand(X, Y, TestTiles.Grass, 3);
+        TestTerrain.AddStatic(X, Y, TestTiles.Wall, 3);
+
+        foreach (var map in (ReadOnlySpan<Map>)[Map.Felucca, Map.Trammel])
+        {
+            Assert.Equal(TestTiles.Grass, map.Tiles.GetLandTile(X, Y).ID);
+            var statics = map.Tiles.GetStaticBlock(X >> 3, Y >> 3)[X & 7][Y & 7];
+            Assert.Single(statics);
+            Assert.Equal(TestTiles.Wall, statics[0].ID);
+        }
+    }
+
+    [Fact]
+    public void ScopeDispose_RestoresBothFacets()
+    {
+        using (TestTerrain.Scope())
+        {
+            TestTerrain.SetLand(X, Y, TestTiles.Grass, 3);
+            TestTerrain.AddStatic(X, Y, TestTiles.Wall, 3);
+        }
+
+        foreach (var map in (ReadOnlySpan<Map>)[Map.Felucca, Map.Trammel])
+        {
+            Assert.Equal(0, map.Tiles.GetLandTile(X, Y).ID);
+            Assert.Empty(map.Tiles.GetStaticBlock(X >> 3, Y >> 3)[X & 7][Y & 7]);
+        }
+    }
+
+    [Fact]
+    public void ScopeDispose_RestoresAPrefabItOverwrote()
+    {
+        Prefabs.StampAll();
+        var coast = Prefabs.Coastline.Anchor;
+        var before = Map.Felucca.Tiles.GetLandTile(coast.X, coast.Y);
+
+        using (TestTerrain.Scope())
+        {
+            TestTerrain.SetLand(coast.X, coast.Y, TestTiles.RockLand, 40);
+        }
+
+        Assert.Equal(before.ID, Map.Felucca.Tiles.GetLandTile(coast.X, coast.Y).ID);
+        Assert.Equal(before.Z, Map.Felucca.Tiles.GetLandTile(coast.X, coast.Y).Z);
+        Prefabs.Coastline.AssertPresent();
+    }
+
+    [Fact]
+    public void NestedScopes_Throw()
+    {
+        using var scope = TestTerrain.Scope();
+
+        var error = Assert.Throws<InvalidOperationException>(() => TestTerrain.Scope());
+        Assert.Contains($"{nameof(TestTerrainTests)}.{nameof(NestedScopes_Throw)}", error.Message);
+    }
+
+    [Fact]
+    public void StampingOutsideAScope_Throws_OncePrefabsAreStamped()
+    {
+        Prefabs.StampAll();
+
+        Assert.Throws<InvalidOperationException>(() => TestTerrain.SetLand(X, Y, TestTiles.Grass, 0));
+    }
+
+    [Fact]
+    public void StampAll_PrefabsDoNotOverlap_AndAreAllPresent()
+    {
+        Prefabs.StampAll();
+
+        for (var i = 0; i < Prefabs.All.Count; i++)
+        {
+            Prefabs.All[i].AssertPresent();
+        }
+    }
+
+    [Fact]
+    public void AssertPresent_Throws_WhenThePrefabIsGone()
+    {
+        Prefabs.StampAll();
+        var coast = Prefabs.Coastline.Anchor;
+
+        using var scope = TestTerrain.Scope();
+        TestTerrain.SetLand(coast.X, coast.Y, 0, 0);
+
+        Assert.Throws<InvalidOperationException>(() => Prefabs.Coastline.AssertPresent());
+    }
+}