From 21425ffb223a0e8ee4af8d63b5c2433c37b89953 Mon Sep 17 00:00:00 2001 From: Erik Date: Fri, 8 May 2026 09:05:53 +0200 Subject: [PATCH] =?UTF-8?q?plan(N.1):=20scenery=20via=20WorldBuilder=20hel?= =?UTF-8?q?pers=20=E2=80=94=20implementation=20plan?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bite-sized TDD plan for Phase N.1. Eight tasks: 1. WbSceneryAdapter (LandBlock → TerrainEntry[] adapter) 2. ACDREAM_USE_WB_SCENERY feature flag scaffold 3. Per-helper conformance tests (Displace / OnRoad / GetNormalZ / RotateObj / ScaleObj) 4. Implement GenerateViaWb alternative path 5. Wire feature-flag dispatch in Generate() 6. Visual verification at landblock 0xA9B1 (manual) 7. Flip flag default-on 8. Delete legacy code paths + mark roadmap shipped Each task has explicit code blocks, exact dotnet commands, expected output, and a commit instruction. Conformance tests prove substitution is behavior-preserving before the dispatch is wired in. Spec: docs/superpowers/specs/2026-05-08-phase-n1-scenery-via-wb-helpers-design.md Co-Authored-By: Claude Opus 4.7 (1M context) --- ...6-05-08-phase-n1-scenery-via-wb-helpers.md | 1130 +++++++++++++++++ 1 file changed, 1130 insertions(+) create mode 100644 docs/superpowers/plans/2026-05-08-phase-n1-scenery-via-wb-helpers.md diff --git a/docs/superpowers/plans/2026-05-08-phase-n1-scenery-via-wb-helpers.md b/docs/superpowers/plans/2026-05-08-phase-n1-scenery-via-wb-helpers.md new file mode 100644 index 0000000..d6bae6f --- /dev/null +++ b/docs/superpowers/plans/2026-05-08-phase-n1-scenery-via-wb-helpers.md @@ -0,0 +1,1130 @@ +# Phase N.1 — Scenery via WorldBuilder Helpers Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Replace the in-line algorithm guts of `SceneryGenerator.Generate()` with calls to WorldBuilder's `SceneryHelpers` (Displace / RotateObj / ScaleObj / CheckSlope / ObjAlign) and `TerrainUtils` (OnRoad / GetNormal). Keep our data flow, our `ScenerySpawn` shape, and our renderer integration. Place behind a `ACDREAM_USE_WB_SCENERY=1` feature flag, prove equivalence with helper-level conformance tests, then flip default-on after visual verification at landblock `0xA9B1`. + +**Architecture:** Strangler-fig substitution. The 9×9 vertex loop, scene-selection hash, frequency roll, bounds check, building grid, and `BaseLoc.Z` handling stay identical. Only the five algorithm calls (displacement, road test, slope normal, rotation, scale) get replaced. A small adapter `WbSceneryAdapter.BuildTerrainEntries(LandBlock)` produces the `TerrainEntry[]` shape WB's helpers expect. + +**Tech Stack:** .NET 10 / C# 13, Silk.NET (transitively), `WorldBuilder.Shared` + `Chorizite.OpenGLSDLBackend` (project references already wired up in Phase N.0), DatReaderWriter for `LandBlock` / `Region` / `ObjectDesc` / `Scene` types, xUnit for tests. + +**Spec:** `docs/superpowers/specs/2026-05-08-phase-n1-scenery-via-wb-helpers-design.md` +**Parent design:** `docs/superpowers/specs/2026-05-08-phase-n-worldbuilder-migration-design.md` +**Inventory:** `docs/architecture/worldbuilder-inventory.md` + +**Prerequisite:** Phase N.0 already shipped (commit `c8782c9`) — `references/WorldBuilder/` is a git submodule pointing at `github.com/eriknihlen/WorldBuilder.git` `acdream` branch; `AcDream.Core.csproj` references `WorldBuilder.Shared` + `Chorizite.OpenGLSDLBackend`. + +--- + +## File Plan + +| File | Disposition | Responsibility | +|---|---|---| +| `src/AcDream.Core/World/WbSceneryAdapter.cs` | NEW | `LandBlock` (acdream's dat type) → `TerrainEntry[]` (WB's data shape). Stateless. | +| `src/AcDream.Core/World/SceneryGenerator.cs` | MODIFY | Add `UseWbScenery` feature-flag flag. Add `GenerateViaWb` private alternative path. Wire dispatch in `Generate()`. Keep legacy methods for now — deleted in final task. | +| `tests/AcDream.Core.Tests/World/WbSceneryAdapterTests.cs` | NEW | Verify field bit-packing round-trips (Road, Type, Scenery, Height) and bounds-check behavior. | +| `tests/AcDream.Core.Tests/World/SceneryWbConformanceTests.cs` | NEW | Five small tests proving WB's `Displace`/`OnRoad`/`GetNormal`/`RotateObj`/`ScaleObj` match our existing inline logic for representative inputs. | +| `tests/AcDream.Core.Tests/World/SceneryGeneratorTests.cs` | MODIFY | After Task 7 (legacy delete), prune the now-irrelevant `DisplaceObject_*` tests and update class doc. | + +**Why split adapter into its own file:** the adapter is a pure stateless utility. Putting it in its own file keeps `SceneryGenerator.cs` focused on the generator algorithm, and makes the adapter trivially reusable in N.2+ (terrain math helpers will need the same `TerrainEntry[]`). + +**Why combine conformance tests in one file:** all five tests share the same imports and fixtures, and they all measure the same thing (helper equivalence). Splitting would be over-decomposed. + +--- + +## Task 1: LandBlock → TerrainEntry[] adapter + +**Files:** +- Create: `src/AcDream.Core/World/WbSceneryAdapter.cs` +- Test: `tests/AcDream.Core.Tests/World/WbSceneryAdapterTests.cs` + +- [ ] **Step 1.1: Write the failing test** + +Create `tests/AcDream.Core.Tests/World/WbSceneryAdapterTests.cs`: + +```csharp +using AcDream.Core.World; +using DatReaderWriter.DBObjs; + +namespace AcDream.Core.Tests.World; + +/// +/// Tests for . The adapter converts our +/// LandBlock dat type (Terrain ushort[81] + Height byte[81]) into +/// WorldBuilder's [81] +/// shape, which WB's TerrainUtils / SceneryRenderManager consume. +/// +/// Bit layout in our LandBlock.Terrain[i] (ushort): +/// bits 0-1 : Road (2 bits, ACViewer convention) +/// bits 2-6 : TerrainType (5 bits) → WB calls this Texture +/// bits 11-15 : SceneType (5 bits) → WB calls this Scenery +/// Height comes from LandBlock.Height[i] (byte). +/// +public class WbSceneryAdapterTests +{ + [Fact] + public void BuildTerrainEntries_PreservesRoadTextureSceneryHeight() + { + var block = new LandBlock + { + Terrain = new ushort[81], + Height = new byte[81], + }; + + // Vertex 0: road=0x3, type=0x00, scenery=0x1F, height=42 + // raw layout: bits 0-1=11, bits 2-6=00000, bits 7-10=0000, bits 11-15=11111 + // = 0xF803 + block.Terrain[0] = 0xF803; + block.Height[0] = 42; + + // Vertex 80: road=0x0, type=0x1F, scenery=0x00, height=200 + // raw layout: bits 0-1=00, bits 2-6=11111, bits 11-15=00000 + // = 0x007C + block.Terrain[80] = 0x007C; + block.Height[80] = 200; + + var entries = WbSceneryAdapter.BuildTerrainEntries(block); + + Assert.Equal(81, entries.Length); + + Assert.Equal((byte)42, entries[0].Height); + Assert.Equal((byte)0x3, entries[0].Road); + Assert.Equal((byte)0x00, entries[0].Texture); + Assert.Equal((byte)0x1F, entries[0].Scenery); + + Assert.Equal((byte)200, entries[80].Height); + Assert.Equal((byte)0x0, entries[80].Road); + Assert.Equal((byte)0x1F, entries[80].Texture); + Assert.Equal((byte)0x00, entries[80].Scenery); + } + + [Fact] + public void BuildTerrainEntries_AllZeros_ProducesEmptyEntries() + { + var block = new LandBlock + { + Terrain = new ushort[81], + Height = new byte[81], + }; + var entries = WbSceneryAdapter.BuildTerrainEntries(block); + Assert.All(entries, e => + { + Assert.Equal((byte)0, e.Height); + Assert.Equal((byte)0, e.Road); + Assert.Equal((byte)0, e.Texture); + Assert.Equal((byte)0, e.Scenery); + }); + } + + [Fact] + public void BuildTerrainEntries_NullBlock_Throws() + { + Assert.Throws(() => + WbSceneryAdapter.BuildTerrainEntries(null!)); + } +} +``` + +- [ ] **Step 1.2: Run the test to verify it fails** + +Run: `dotnet test --no-restore tests/AcDream.Core.Tests/AcDream.Core.Tests.csproj --filter "WbSceneryAdapterTests" 2>&1 | tail -10` +Expected: BUILD ERROR or FAIL with "type or namespace 'WbSceneryAdapter' could not be found". + +- [ ] **Step 1.3: Implement the adapter** + +Create `src/AcDream.Core/World/WbSceneryAdapter.cs`: + +```csharp +using DatReaderWriter.DBObjs; +using WorldBuilder.Shared.Models; + +namespace AcDream.Core.World; + +/// +/// Bridges acdream's dat types into WorldBuilder's data shapes for the +/// Phase N rendering migration. See +/// docs/architecture/worldbuilder-inventory.md for the full strategy. +/// +internal static class WbSceneryAdapter +{ + private const int VerticesPerSide = 9; + private const int TerrainSize = VerticesPerSide * VerticesPerSide; // 81 + + /// + /// Builds a 9×9 = 81-entry array from a + /// 's packed terrain bits + height bytes. WB's + /// TerrainUtils.OnRoad / GetNormal / GetHeight + /// consume this shape. + /// + /// Bit layout in our LandBlock.Terrain[i] (ushort): + /// bits 0-1 : Road (2 bits) → WB Road + /// bits 2-6 : TerrainType (5 bits) → WB Texture + /// bits 11-15 : SceneType (5 bits) → WB Scenery + /// Height comes from LandBlock.Height[i] (byte). + /// + public static TerrainEntry[] BuildTerrainEntries(LandBlock block) + { + ArgumentNullException.ThrowIfNull(block); + if (block.Terrain.Length != TerrainSize) + throw new ArgumentException( + $"LandBlock.Terrain must be {TerrainSize} entries (9×9), got {block.Terrain.Length}", + nameof(block)); + if (block.Height.Length != TerrainSize) + throw new ArgumentException( + $"LandBlock.Height must be {TerrainSize} entries (9×9), got {block.Height.Length}", + nameof(block)); + + var entries = new TerrainEntry[TerrainSize]; + for (int i = 0; i < TerrainSize; i++) + { + ushort raw = block.Terrain[i]; + byte road = (byte)(raw & 0x3); + byte texture = (byte)((raw >> 2) & 0x1F); + byte scenery = (byte)((raw >> 11) & 0x1F); + byte height = block.Height[i]; + entries[i] = new TerrainEntry(height, texture, scenery, road, encounters: null); + } + return entries; + } +} +``` + +- [ ] **Step 1.4: Run the test to verify it passes** + +Run: `dotnet test --no-restore tests/AcDream.Core.Tests/AcDream.Core.Tests.csproj --filter "WbSceneryAdapterTests" 2>&1 | tail -5` +Expected: `Passed! - Failed: 0, Passed: 3` (or similar — three tests). + +- [ ] **Step 1.5: Commit** + +```bash +git add src/AcDream.Core/World/WbSceneryAdapter.cs tests/AcDream.Core.Tests/World/WbSceneryAdapterTests.cs +git commit -m "$(cat <<'EOF' +phase(N.1): add LandBlock → TerrainEntry[] adapter + +Phase N.1 step 1: WbSceneryAdapter.BuildTerrainEntries converts our +LandBlock dat type into the TerrainEntry[81] shape WorldBuilder's +TerrainUtils / SceneryRenderManager consume. + +Bit-pack mapping (ours → WB): + Terrain bits 0-1 (Road) → TerrainEntry.Road + Terrain bits 2-6 (TerrainType) → TerrainEntry.Texture + Terrain bits 11-15 (SceneType) → TerrainEntry.Scenery + Height byte → TerrainEntry.Height + +Spec: docs/superpowers/specs/2026-05-08-phase-n1-scenery-via-wb-helpers-design.md + +Co-Authored-By: Claude Opus 4.7 (1M context) +EOF +)" +``` + +--- + +## Task 2: Feature flag scaffold + +**Files:** +- Modify: `src/AcDream.Core/World/SceneryGenerator.cs` + +This task only adds the flag-read field. It changes no behavior and there is nothing to assert beyond "it compiles." The flag is consumed in Task 5. + +- [ ] **Step 2.1: Add the feature flag field** + +Open `src/AcDream.Core/World/SceneryGenerator.cs`. Find the line: + +```csharp + // AC landblock geometry — matches LandblockMesh. + private const int VerticesPerSide = 9; + private const float CellSize = 24.0f; + private const float LandblockSize = 192.0f; // 8 cells * 24 units +``` + +Immediately AFTER the `LandblockSize` constant, ADD: + +```csharp + + /// + /// Phase N.1 feature flag — when set to "1", scenery placement uses + /// WorldBuilder's SceneryHelpers + TerrainUtils instead of + /// our hand-ported algorithms. Default off until visual verification at + /// landblock 0xA9B1 confirms behavior. See + /// docs/superpowers/specs/2026-05-08-phase-n1-scenery-via-wb-helpers-design.md. + /// + internal static readonly bool UseWbScenery = + System.Environment.GetEnvironmentVariable("ACDREAM_USE_WB_SCENERY") == "1"; +``` + +- [ ] **Step 2.2: Verify build still passes** + +Run: `dotnet build src/AcDream.Core/AcDream.Core.csproj 2>&1 | tail -5` +Expected: `Build succeeded.` and `0 Error(s)`. + +- [ ] **Step 2.3: Verify all existing tests still pass** + +Run: `dotnet test --no-build tests/AcDream.Core.Tests/AcDream.Core.Tests.csproj --filter "SceneryGenerator|Wb" 2>&1 | tail -3` +Expected: `Passed!` with all scenery-area tests passing. + +- [ ] **Step 2.4: Commit** + +```bash +git add src/AcDream.Core/World/SceneryGenerator.cs +git commit -m "$(cat <<'EOF' +phase(N.1): add ACDREAM_USE_WB_SCENERY feature flag scaffold + +Phase N.1 step 2: read the env var into a static bool. No behavior +change yet — the flag is consumed in step 5 when GenerateViaWb is +wired in. + +Co-Authored-By: Claude Opus 4.7 (1M context) +EOF +)" +``` + +--- + +## Task 3: Per-helper conformance tests + +**Files:** +- Create: `tests/AcDream.Core.Tests/World/SceneryWbConformanceTests.cs` + +These five tests prove WB's `SceneryHelpers.Displace` / `TerrainUtils.OnRoad` / `TerrainUtils.GetNormal` / `SceneryHelpers.RotateObj` / `SceneryHelpers.ScaleObj` produce the same answers as the hand-ported logic currently inlined in `Generate()`. After this task, we have empirical evidence that the substitution is safe. + +If a test fails, that is the bug — investigate before proceeding to Task 4. + +- [ ] **Step 3.1: Write all five conformance tests** + +Create `tests/AcDream.Core.Tests/World/SceneryWbConformanceTests.cs`: + +```csharp +using System.Numerics; +using AcDream.Core.World; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; +using WB_TerrainUtils = WorldBuilder.Shared.Modules.Landscape.Lib.TerrainUtils; +using WB_SceneryHelpers = Chorizite.OpenGLSDLBackend.Lib.SceneryHelpers; + +namespace AcDream.Core.Tests.World; + +/// +/// Phase N.1 helper-level conformance tests. Each test compares an algorithm +/// in our existing path against WorldBuilder's +/// equivalent for representative inputs. Passing tests are empirical evidence +/// that swapping our inline logic for WB's helpers is behavior-preserving. +/// +/// If any of these fails the substitution would silently change rendered +/// scenery; investigate before proceeding to Task 4 (GenerateViaWb). +/// +/// Inputs are chosen to exercise: +/// - A non-edge vertex (gx=100, gy=100, j=0) — typical case +/// - The edge vertex at y=8 specifically (Issue #49 territory) +/// +public class SceneryWbConformanceTests +{ + private static ObjectDesc MakeObj( + float displaceX = 12f, + float displaceY = 12f, + float minScale = 1f, + float maxScale = 1f, + float maxRotation = 0f, + float minSlope = 0f, + float maxSlope = 1f, + int align = 0) + { + return new ObjectDesc + { + ObjectId = 0x02000258u, + DisplaceX = displaceX, + DisplaceY = displaceY, + MinScale = minScale, + MaxScale = maxScale, + MaxRotation = maxRotation, + MinSlope = minSlope, + MaxSlope = maxSlope, + Align = (uint)align, + BaseLoc = new Frame { Origin = new Vector3(0, 0, 0) }, + }; + } + + /// + /// Our DisplaceObject ↔ WB's SceneryHelpers.Displace must produce the + /// same Vector3 for the same (obj, ix, iy, iq). + /// + [Theory] + [InlineData(100u, 100u, 0u)] // typical + [InlineData( 50u, 50u, 1u)] // typical, j=1 + [InlineData( 4u, 8u, 0u)] // edge vertex y=8 + [InlineData( 8u, 4u, 0u)] // edge vertex x=8 + public void Displace_OursMatchesWb(uint ix, uint iy, uint iq) + { + var obj = MakeObj(); + var ours = SceneryGenerator.DisplaceObject(obj, ix, iy, iq); + var wb = WB_SceneryHelpers.Displace(obj, ix, iy, iq); + + Assert.Equal(ours.X, wb.X, precision: 4); + Assert.Equal(ours.Y, wb.Y, precision: 4); + Assert.Equal(ours.Z, wb.Z, precision: 4); + } + + /// + /// Our IsOnRoad ↔ WB's TerrainUtils.OnRoad must produce the same bool + /// for the same (lx, ly) when the underlying terrain bits match. + /// + [Theory] + [InlineData( 12.0f, 12.0f)] // cell (0,0) center + [InlineData( 85.08f, 190.97f)] // the 0xA9B1 edge-vertex bug location + [InlineData( 3.0f, 3.0f)] // near a road if r0 is set + [InlineData( 23.5f, 12.0f)] // edge of cell, between cells + public void OnRoad_OursMatchesWb_DiagonalRoad(float lx, float ly) + { + // Build a synthetic LandBlock with road bits at SW (0,0) and NE (1,1) + // of cell (0,0) — the diagonal pattern we saw at 0xA9B1. + var block = new LandBlock + { + Terrain = new ushort[81], + Height = new byte[81], + }; + // road bit at vertex (0,0) — index 0*9+0 = 0 + block.Terrain[0] = 0x0003; // road=3 + // road bit at vertex (1,1) — index 1*9+1 = 10 + block.Terrain[10] = 0x0003; + + bool ours = SceneryGenerator.IsOnRoad(block, lx, ly); + + var entries = WbSceneryAdapter.BuildTerrainEntries(block); + bool wb = WB_TerrainUtils.OnRoad(new Vector3(lx, ly, 0), entries); + + Assert.Equal(ours, wb); + } + + /// + /// Our SampleNormalZFromHeightmap ↔ WB's TerrainUtils.GetNormal(...).Z + /// must produce the same Z for representative slope inputs. + /// + [Theory] + [InlineData( 12.0f, 12.0f)] // cell center + [InlineData( 85.08f, 190.97f)] // the 0xA9B1 edge-vertex location + [InlineData( 3.0f, 188.0f)] // near a y-edge + public void GetNormalZ_OursMatchesWb_LinearTable(float lx, float ly) + { + // Heightmap with non-flat terrain so normals are non-trivial. + var heights = new byte[81]; + for (int x = 0; x < 9; x++) + for (int y = 0; y < 9; y++) + heights[x * 9 + y] = (byte)((x * 17 + y * 13) % 256); + + var heightTable = new float[256]; + for (int i = 0; i < 256; i++) heightTable[i] = i * 1.0f; + + const uint lbX = 0xA9, lbY = 0xB1; + + // Build a Region-shaped object with the LandHeightTable populated. + // (TerrainUtils.GetNormal calls region.LandDefs.LandHeightTable[height].) + // LandHeightTable is float[] (size 256) in DatReaderWriter — see + // src/AcDream.App/Rendering/GameWindow.cs:1306-1308 for the runtime check. + var region = new DatReaderWriter.DBObjs.Region + { + LandDefs = new LandDefs(), + }; + // If LandDefs default-initializes LandHeightTable to a non-null float[256], + // copy into it. If it's null, assign directly. The implementer should + // pick whichever pattern compiles in DatReaderWriter 2.1.7's API: + // Option A: region.LandDefs.LandHeightTable = heightTable; + // Option B: Array.Copy(heightTable, region.LandDefs.LandHeightTable, 256); + region.LandDefs.LandHeightTable = heightTable; + + var block = new LandBlock + { + Terrain = new ushort[81], + Height = heights, + }; + var entries = WbSceneryAdapter.BuildTerrainEntries(block); + + float ours = AcDream.Core.Physics.TerrainSurface.SampleNormalZFromHeightmap( + heights, heightTable, lbX, lbY, lx, ly); + float wb = WB_TerrainUtils.GetNormal(region, entries, lbX, lbY, + new Vector3(lx, ly, 0)).Z; + + Assert.Equal(ours, wb, precision: 4); + } + + /// + /// Our inline rotation logic ↔ WB's SceneryHelpers.RotateObj must + /// produce the same Quaternion for non-Align objects with MaxRotation. + /// + [Theory] + [InlineData( 100u, 100u, 0u, 360f)] + [InlineData( 4u, 8u, 0u, 360f)] + [InlineData( 200u, 250u, 1u, 180f)] + public void RotateObj_OursMatchesWb_NonAlign(uint gx, uint gy, uint j, float maxRot) + { + var obj = MakeObj(maxRotation: maxRot); + + // Our inline logic from SceneryGenerator.Generate (~lines 220-231): + Quaternion ours = obj.BaseLoc.Orientation; + if (ours.LengthSquared() < 0.0001f) ours = Quaternion.Identity; + if (obj.MaxRotation > 0f) + { + double rotNoise = unchecked((uint)(1813693831u * gy + - (j + 63127u) * (1360117743u * gy * gx + 1888038839u) + - 1109124029u * gx)) * 2.3283064e-10; + float degrees = (float)(rotNoise * obj.MaxRotation); + float yawDeg = -((450f - degrees) % 360f); + float yawRad = yawDeg * MathF.PI / 180f; + var headingQuat = Quaternion.CreateFromAxisAngle(Vector3.UnitZ, yawRad); + ours = headingQuat * ours; + } + + // WB's SceneryHelpers.Displace returns the localPos that RotateObj + // expects for its loc parameter (used only when SetHeading is called + // with non-zero matrix, but a stub Vector3 works since BaseLoc is identity). + var localPos = WB_SceneryHelpers.Displace(obj, gx, gy, j); + Quaternion wb = WB_SceneryHelpers.RotateObj(obj, gx, gy, j, localPos); + + Assert.Equal(ours.X, wb.X, precision: 4); + Assert.Equal(ours.Y, wb.Y, precision: 4); + Assert.Equal(ours.Z, wb.Z, precision: 4); + Assert.Equal(ours.W, wb.W, precision: 4); + } + + /// + /// Our inline scale logic ↔ WB's SceneryHelpers.ScaleObj must produce + /// the same float for representative inputs. + /// + [Theory] + [InlineData(100u, 100u, 0u, 0.5f, 1.5f)] + [InlineData( 4u, 8u, 0u, 1.0f, 1.0f)] + [InlineData(200u, 250u, 1u, 0.8f, 1.2f)] + public void ScaleObj_OursMatchesWb(uint gx, uint gy, uint j, float minScale, float maxScale) + { + var obj = MakeObj(minScale: minScale, maxScale: maxScale); + + // Our inline logic from SceneryGenerator.Generate (~lines 236-247): + float ours; + if (obj.MinScale == obj.MaxScale) + { + ours = obj.MaxScale; + } + else + { + double scaleNoise = unchecked((uint)(1813693831u * gy + - (j + 32593u) * (1360117743u * gy * gx + 1888038839u) + - 1109124029u * gx)) * 2.3283064e-10; + ours = (float)(Math.Pow(obj.MaxScale / obj.MinScale, scaleNoise) * obj.MinScale); + } + if (ours <= 0) ours = 1f; + + float wb = WB_SceneryHelpers.ScaleObj(obj, gx, gy, j); + if (wb <= 0) wb = 1f; + + Assert.Equal(ours, wb, precision: 4); + } +} +``` + +- [ ] **Step 3.2: Make our `IsOnRoad` accessible to the test** + +`IsOnRoad` is currently `private`. Bump to `internal` so the conformance test can call it. Open `src/AcDream.Core/World/SceneryGenerator.cs` and change: + +```csharp + private static bool IsOnRoad(LandBlock block, float lx, float ly) +``` + +to: + +```csharp + internal static bool IsOnRoad(LandBlock block, float lx, float ly) +``` + +- [ ] **Step 3.3: Run the conformance tests** + +Run: `dotnet test --no-restore tests/AcDream.Core.Tests/AcDream.Core.Tests.csproj --filter "SceneryWbConformance" 2>&1 | tail -10` +Expected: ALL TESTS PASS. + +If any test fails, **stop and investigate** — that's the bug WB is hiding from us. Report which assertion failed (e.g., "Displace at gx=4 gy=8 returns different Y") and confer with the user before proceeding. + +- [ ] **Step 3.4: Commit** + +```bash +git add tests/AcDream.Core.Tests/World/SceneryWbConformanceTests.cs src/AcDream.Core/World/SceneryGenerator.cs +git commit -m "$(cat <<'EOF' +phase(N.1): per-helper conformance tests for WB substitutions + +Phase N.1 step 3: prove our inline algorithms (Displace, IsOnRoad, +slope normal Z, RotateObj, ScaleObj) match WorldBuilder's helpers +for representative inputs including the 0xA9B1 edge-vertex case. + +Bumps IsOnRoad to internal so the test can call it directly. + +Co-Authored-By: Claude Opus 4.7 (1M context) +EOF +)" +``` + +--- + +## Task 4: Implement `GenerateViaWb` + +**Files:** +- Modify: `src/AcDream.Core/World/SceneryGenerator.cs` + +Add a new private method `GenerateViaWb` that produces `IReadOnlyList` using only WB helpers for the substituted algorithm calls. The 9×9 loop, scene selection, frequency check, bounds check, building grid, and `BaseLoc.Z` handling stay structurally identical to `Generate`. + +- [ ] **Step 4.1: Add the required `using` directives** + +Open `src/AcDream.Core/World/SceneryGenerator.cs`. The file currently has: + +```csharp +using System.Numerics; +using DatReaderWriter; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; + +namespace AcDream.Core.World; +``` + +Replace with: + +```csharp +using System.Numerics; +using Chorizite.OpenGLSDLBackend.Lib; +using DatReaderWriter; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; +using WorldBuilder.Shared.Modules.Landscape.Lib; + +namespace AcDream.Core.World; +``` + +- [ ] **Step 4.2: Add `GenerateViaWb` immediately after `Generate`** + +Find the closing `}` of `Generate(...)` in `SceneryGenerator.cs` (just before the `IsRoadVertex` method). Immediately AFTER `Generate`'s closing brace, ADD: + +```csharp + + /// + /// Phase N.1 alternative implementation that delegates the + /// algorithm calls to WorldBuilder's SceneryHelpers + + /// TerrainUtils. Structurally identical to + /// but with WB's tested ports doing the work. Selected by + /// . + /// + private static IReadOnlyList GenerateViaWb( + DatCollection dats, + Region region, + LandBlock block, + uint landblockId, + HashSet? buildingCells) + { + var result = new List(); + + if (region.TerrainInfo?.TerrainTypes is null || region.SceneInfo?.SceneTypes is null) + return result; + + // Build the TerrainEntry[] WB's helpers consume — once per landblock. + var terrainEntries = WbSceneryAdapter.BuildTerrainEntries(block); + + uint blockX = (landblockId >> 24) * 8; + uint blockY = ((landblockId >> 16) & 0xFFu) * 8; + uint lbX = landblockId >> 24; + uint lbY = (landblockId >> 16) & 0xFFu; + + for (int x = 0; x < VerticesPerSide; x++) + { + for (int y = 0; y < VerticesPerSide; y++) + { + int i = x * VerticesPerSide + y; + ushort raw = block.Terrain[i]; + + uint terrainType = (uint)((raw >> 2) & 0x1F); + uint sceneType = (uint)((raw >> 11) & 0x1F); + + if (terrainType >= region.TerrainInfo.TerrainTypes.Count) continue; + var sceneTypeList = region.TerrainInfo.TerrainTypes[(int)terrainType].SceneTypes; + if (sceneType >= sceneTypeList.Count) continue; + + uint sceneInfo = sceneTypeList[(int)sceneType]; + if (sceneInfo >= region.SceneInfo.SceneTypes.Count) continue; + + var scenes = region.SceneInfo.SceneTypes[(int)sceneInfo].Scenes; + if (scenes.Count == 0) continue; + + uint cellX = (uint)x; + uint cellY = (uint)y; + uint globalCellX = cellX + blockX; + uint globalCellY = cellY + blockY; + + // Scene-selection hash: identical to Generate. + uint cellMat = globalCellY * (712977289u * globalCellX + 1813693831u) + - 1109124029u * globalCellX + 2139937281u; + double offset = cellMat * 2.3283064e-10; + int sceneIdx = (int)(scenes.Count * offset); + if (sceneIdx >= scenes.Count || sceneIdx < 0) sceneIdx = 0; + + uint sceneId = (uint)scenes[sceneIdx]; + var scene = dats.Get(sceneId); + if (scene is null) continue; + + // Per-object frequency setup: identical to Generate. + uint cellXMat = unchecked(0u - 1109124029u * globalCellX); + uint cellYMat = 1813693831u * globalCellY; + uint cellMat2 = 1360117743u * globalCellX * globalCellY + 1888038839u; + + for (uint j = 0; j < scene.Objects.Count; j++) + { + var obj = scene.Objects[(int)j]; + if (obj.WeenieObj != 0) continue; + + double noise = unchecked((uint)(cellXMat + cellYMat - cellMat2 * (23399u + j))) * 2.3283064e-10; + if (noise >= obj.Frequency) continue; + + // ─── WB substitution: displacement ─────────────────── + var localPos = SceneryHelpers.Displace(obj, globalCellX, globalCellY, j); + + float lx = cellX * CellSize + localPos.X; + float ly = cellY * CellSize + localPos.Y; + + if (lx < 0 || ly < 0 || lx >= LandblockSize || ly >= LandblockSize) + continue; + + // ─── WB substitution: road check ────────────────────── + if (TerrainUtils.OnRoad(new Vector3(lx, ly, 0), terrainEntries)) + continue; + + // Building check: identical to Generate. + if (buildingCells is not null) + { + int dcx = Math.Clamp((int)(lx / CellSize), 0, CellsPerSide - 1); + int dcy = Math.Clamp((int)(ly / CellSize), 0, CellsPerSide - 1); + if (buildingCells.Contains(dcx * VerticesPerSide + dcy)) + continue; + } + + // ─── WB substitution: slope check ───────────────────── + Vector3 normal = TerrainUtils.GetNormal( + region, terrainEntries, lbX, lbY, + new Vector3(lx, ly, 0)); + if (!SceneryHelpers.CheckSlope(obj, normal.Z)) + continue; + + float lz = obj.BaseLoc.Origin.Z; + + // ─── WB substitution: rotation ──────────────────────── + Quaternion rotation; + if (obj.Align != 0) + rotation = SceneryHelpers.ObjAlign(obj, normal, lz, localPos); + else + rotation = SceneryHelpers.RotateObj(obj, globalCellX, globalCellY, j, localPos); + + // ─── WB substitution: scale ─────────────────────────── + float scale = SceneryHelpers.ScaleObj(obj, globalCellX, globalCellY, j); + if (scale <= 0) scale = 1f; + + result.Add(new ScenerySpawn( + ObjectId: obj.ObjectId, + LocalPosition: new Vector3(lx, ly, lz), + Rotation: rotation, + Scale: scale)); + } + } + } + + return result; + } +``` + +- [ ] **Step 4.3: Verify build** + +Run: `dotnet build src/AcDream.Core/AcDream.Core.csproj 2>&1 | tail -5` +Expected: `Build succeeded.` `0 Error(s)`. + +If you get an error like `'SceneryHelpers' is an ambiguous reference`, it's because both Chorizite.OpenGLSDLBackend.Lib and WorldBuilder.Shared expose helpers — fix by qualifying: `Chorizite.OpenGLSDLBackend.Lib.SceneryHelpers.Displace(...)`. + +- [ ] **Step 4.4: Verify existing tests still pass** + +Run: `dotnet test --no-build tests/AcDream.Core.Tests/AcDream.Core.Tests.csproj --filter "SceneryGenerator|WbSceneryAdapter|SceneryWbConformance" 2>&1 | tail -3` +Expected: all scenery-area tests pass (the ones added in Tasks 1 and 3, plus the original SceneryGeneratorTests). No behavior change yet for the live `Generate` path — `GenerateViaWb` is added but not called. + +- [ ] **Step 4.5: Commit** + +```bash +git add src/AcDream.Core/World/SceneryGenerator.cs +git commit -m "$(cat <<'EOF' +phase(N.1): implement GenerateViaWb alternative path + +Phase N.1 step 4: parallel implementation of Generate() that calls +WB's SceneryHelpers (Displace/CheckSlope/RotateObj/ObjAlign/ScaleObj) +and TerrainUtils (OnRoad/GetNormal) instead of the inline ports. + +Not yet wired in — Generate() still runs the legacy path. Step 5 +adds the dispatch. + +Per-helper conformance tests in step 3 prove this implementation is +behavior-equivalent to the legacy path. + +Co-Authored-By: Claude Opus 4.7 (1M context) +EOF +)" +``` + +--- + +## Task 5: Wire feature-flag dispatch + +**Files:** +- Modify: `src/AcDream.Core/World/SceneryGenerator.cs` + +- [ ] **Step 5.1: Add the dispatch at the top of `Generate`** + +In `src/AcDream.Core/World/SceneryGenerator.cs`, find the body of `Generate`: + +```csharp + public static IReadOnlyList Generate( + DatCollection dats, + Region region, + LandBlock block, + uint landblockId, + HashSet? buildingCells = null, + float[]? heightTable = null) + { + var result = new List(); + + if (region.TerrainInfo?.TerrainTypes is null || region.SceneInfo?.SceneTypes is null) + return result; +``` + +Immediately AFTER the opening `{` and BEFORE `var result = new List();`, ADD: + +```csharp + // Phase N.1: route to the WorldBuilder-backed implementation when + // ACDREAM_USE_WB_SCENERY=1. See + // docs/superpowers/specs/2026-05-08-phase-n1-scenery-via-wb-helpers-design.md. + if (UseWbScenery) + return GenerateViaWb(dats, region, block, landblockId, buildingCells); + +``` + +So the method's opening becomes: + +```csharp + public static IReadOnlyList Generate( + DatCollection dats, + Region region, + LandBlock block, + uint landblockId, + HashSet? buildingCells = null, + float[]? heightTable = null) + { + // Phase N.1: route to the WorldBuilder-backed implementation when + // ACDREAM_USE_WB_SCENERY=1. See + // docs/superpowers/specs/2026-05-08-phase-n1-scenery-via-wb-helpers-design.md. + if (UseWbScenery) + return GenerateViaWb(dats, region, block, landblockId, buildingCells); + + var result = new List(); + + if (region.TerrainInfo?.TerrainTypes is null || region.SceneInfo?.SceneTypes is null) + return result; +``` + +Note: `heightTable` is NOT passed to `GenerateViaWb` — the WB path uses `region.LandDefs.LandHeightTable` via `TerrainUtils.GetNormal`. The legacy path keeps the parameter for backward compatibility. + +- [ ] **Step 5.2: Verify build** + +Run: `dotnet build src/AcDream.Core/AcDream.Core.csproj 2>&1 | tail -5` +Expected: `Build succeeded.` + +- [ ] **Step 5.3: Verify all existing tests still pass with flag OFF (default)** + +Run: `dotnet test --no-build tests/AcDream.Core.Tests/AcDream.Core.Tests.csproj --filter "SceneryGenerator|WbSceneryAdapter|SceneryWbConformance" 2>&1 | tail -3` +Expected: all pass (the legacy path is still default, so behavior is unchanged). + +- [ ] **Step 5.4: Commit** + +```bash +git add src/AcDream.Core/World/SceneryGenerator.cs +git commit -m "$(cat <<'EOF' +phase(N.1): wire ACDREAM_USE_WB_SCENERY dispatch in Generate() + +Phase N.1 step 5: when the flag is set, Generate() delegates to +GenerateViaWb. Default off; flag flips to default-on in step 7 +after visual verification. + +Co-Authored-By: Claude Opus 4.7 (1M context) +EOF +)" +``` + +--- + +## Task 6: Visual verification — manual checkpoint + +This task is interactive. **You must work with the user.** They run the client, look at landblock `0xA9B1`, and confirm two things visually: + +1. The road-edge tree we have been chasing all session is **not present** in the WB-backed render. +2. The Issue #49 missing scenery (the trees the 9×9 loop expansion fixed) is **still visible**. + +- [ ] **Step 6.1: Make sure build is green** + +Run: `dotnet build 2>&1 | tail -3` +Expected: `Build succeeded.` + +- [ ] **Step 6.2: Tell the user how to launch with the flag set** + +Tell the user (paraphrase): "Set `$env:ACDREAM_USE_WB_SCENERY = '1'` in your launch terminal alongside the other env vars, then launch the client and navigate to Holtburg. Specifically check the road-edge area near coordinates (87, 191) in landblock 0xA9B1 — the tree we have been chasing all session should be gone now. Also confirm Issue #49's previously missing trees are still there." + +If `dotnet run` is the standard launch command, the full PowerShell launch is: + +```powershell +$env:ACDREAM_DAT_DIR = "$env:USERPROFILE\Documents\Asheron's Call" +$env:ACDREAM_LIVE = "1" +$env:ACDREAM_TEST_HOST = "127.0.0.1" +$env:ACDREAM_TEST_PORT = "9000" +$env:ACDREAM_TEST_USER = "testaccount" +$env:ACDREAM_TEST_PASS = "testpassword" +$env:ACDREAM_USE_WB_SCENERY = "1" +dotnet run --project src\AcDream.App\AcDream.App.csproj --no-build -c Debug 2>&1 | Tee-Object -FilePath "launch.log" +``` + +- [ ] **Step 6.3: Wait for user's verification report** + +The user will tell you "yes the offending tree is gone and Issue #49 is still fine" or "still wrong". If still wrong, do NOT proceed — investigate and report back. + +- [ ] **Step 6.4: Commit nothing** + +This task does not produce a code change. The commit happens in Task 7 once the flag is flipped to default-on. + +--- + +## Task 7: Flip default-on + +**Files:** +- Modify: `src/AcDream.Core/World/SceneryGenerator.cs` + +After visual verification passes in Task 6, the WB-backed path becomes the default. The env var still exists as an escape hatch (`ACDREAM_USE_WB_SCENERY=0` reverts to legacy) so that if a regression is reported the next day, we can flip back without redeploying. + +- [ ] **Step 7.1: Flip the flag default** + +In `src/AcDream.Core/World/SceneryGenerator.cs`, find: + +```csharp + internal static readonly bool UseWbScenery = + System.Environment.GetEnvironmentVariable("ACDREAM_USE_WB_SCENERY") == "1"; +``` + +Replace with: + +```csharp + /// + /// Phase N.1: scenery placement uses WorldBuilder's SceneryHelpers + /// + TerrainUtils by default. Set ACDREAM_USE_WB_SCENERY=0 + /// to restore the legacy in-line algorithms (escape hatch — to be deleted + /// in a follow-up commit once we have a few sessions of green visuals). + /// + internal static readonly bool UseWbScenery = + System.Environment.GetEnvironmentVariable("ACDREAM_USE_WB_SCENERY") != "0"; +``` + +- [ ] **Step 7.2: Verify build + tests** + +Run: `dotnet build 2>&1 | tail -3 && dotnet test --no-build tests/AcDream.Core.Tests/AcDream.Core.Tests.csproj --filter "SceneryGenerator|WbSceneryAdapter|SceneryWbConformance" 2>&1 | tail -3` +Expected: build green, all targeted tests pass. + +- [ ] **Step 7.3: Commit** + +```bash +git add src/AcDream.Core/World/SceneryGenerator.cs +git commit -m "$(cat <<'EOF' +phase(N.1): WB-backed scenery is now default-on + +Phase N.1 step 7: flips ACDREAM_USE_WB_SCENERY to default-on after +visual verification at Holtburg confirmed the road-edge tree at +0xA9B1 is gone and Issue #49 trees are still visible. + +ACDREAM_USE_WB_SCENERY=0 still reverts to the legacy path. Follow-up +commit will delete the legacy code entirely. + +Co-Authored-By: Claude Opus 4.7 (1M context) +EOF +)" +``` + +--- + +## Task 8: Delete the legacy code path + +**Files:** +- Modify: `src/AcDream.Core/World/SceneryGenerator.cs` +- Modify: `tests/AcDream.Core.Tests/World/SceneryGeneratorTests.cs` + +After at least one session of clean visuals on the default-on flag, remove the legacy code so we don't accumulate dead-code drift. + +- [ ] **Step 8.1: Delete the legacy `Generate` body and rename `GenerateViaWb`** + +In `src/AcDream.Core/World/SceneryGenerator.cs`: + +1. Delete the `UseWbScenery` field entirely. +2. Delete the entire body of `Generate` after its signature. +3. Replace it with a body that just calls `GenerateViaWb`'s logic (or rename `GenerateViaWb` to `Generate`'s body). + +The simplest approach: rename `GenerateViaWb` to `GenerateInternal` and have the public `Generate` call it. Then delete the legacy logic. Final shape: + +```csharp +public static IReadOnlyList Generate( + DatCollection dats, + Region region, + LandBlock block, + uint landblockId, + HashSet? buildingCells = null, + float[]? heightTable = null) +{ + // heightTable kept for backward compat; WB path uses + // region.LandDefs.LandHeightTable internally. + _ = heightTable; + return GenerateInternal(dats, region, block, landblockId, buildingCells); +} + +private static IReadOnlyList GenerateInternal( + DatCollection dats, + Region region, + LandBlock block, + uint landblockId, + HashSet? buildingCells) +{ + // ... body that was GenerateViaWb ... +} +``` + +4. Delete the now-unused private helpers: `IsOnRoad`, `DisplaceObject`, `RoadHalfWidth`, `CellsPerSide` (if only used by legacy path — keep if `GenerateInternal`'s building check still references it). + +Concretely, keep: +- `VerticesPerSide`, `CellSize`, `LandblockSize`, `CellsPerSide` constants (still used in `GenerateInternal`) +- `IsRoadVertex` (still useful as a tiny public predicate) +- `WbSceneryAdapter` (still used) + +Delete: +- `UseWbScenery` +- `IsOnRoad` (and its `RoadHalfWidth` dependency) +- `DisplaceObject` (now dead) + +- [ ] **Step 8.2: Update SceneryGeneratorTests.cs to remove now-irrelevant tests** + +In `tests/AcDream.Core.Tests/World/SceneryGeneratorTests.cs`, the existing +`DisplaceObject_EdgeVertex_CanProduceValidPosition` and +`DisplaceObject_InteriorVertex_AlwaysNearOrigin` tests reference the deleted +`SceneryGenerator.DisplaceObject` helper. Delete them. + +Keep: +- All `IsRoadVertex_*` tests (`IsRoadVertex` is preserved). + +The class doc comment at the top should be updated to reflect the new state: + +```csharp +/// +/// Tests for SceneryGenerator: the road-vertex predicate (only piece of +/// our own algorithm code remaining post Phase N.1). The displacement / +/// road / slope / rotation / scale algorithms now run through +/// WorldBuilder's helpers — see SceneryWbConformanceTests.cs for the +/// helper-level equivalence proof. +/// +``` + +- [ ] **Step 8.3: Update the SceneryWbConformanceTests now that legacy helpers are gone** + +`SceneryWbConformanceTests` currently calls `SceneryGenerator.DisplaceObject` and `SceneryGenerator.IsOnRoad`. Once those are deleted, the tests are now testing "WB matches WB" which is meaningless. + +Delete `SceneryWbConformanceTests.cs` entirely. The conformance tests served their purpose during the migration — they proved the substitution was safe. Now that we're committed to the WB path, they're vestigial. + +Run: `rm tests/AcDream.Core.Tests/World/SceneryWbConformanceTests.cs` + +- [ ] **Step 8.4: Verify build + tests** + +Run: `dotnet build 2>&1 | tail -3 && dotnet test --no-build tests/AcDream.Core.Tests/AcDream.Core.Tests.csproj --filter "SceneryGenerator|WbSceneryAdapter" 2>&1 | tail -3` +Expected: build green, tests pass (just the IsRoadVertex tests + WbSceneryAdapter tests). + +- [ ] **Step 8.5: Commit** + +```bash +git add src/AcDream.Core/World/SceneryGenerator.cs tests/AcDream.Core.Tests/World/SceneryGeneratorTests.cs tests/AcDream.Core.Tests/World/SceneryWbConformanceTests.cs +git commit -m "$(cat <<'EOF' +phase(N.1): delete legacy scenery code path; WB is the only path + +Phase N.1 step 8 (final): now that ACDREAM_USE_WB_SCENERY has been +default-on for a session with no regressions, remove the legacy +in-line algorithms so we don't accumulate dead-code drift. + +Deleted: +- SceneryGenerator.UseWbScenery (feature flag) +- SceneryGenerator.IsOnRoad / DisplaceObject / RoadHalfWidth (legacy ports) +- SceneryGeneratorTests.DisplaceObject_* (test the deleted method) +- SceneryWbConformanceTests.cs (purpose served — proved equivalence pre-migration) + +Renamed: +- GenerateViaWb → GenerateInternal (the only path now) + +Kept: +- IsRoadVertex (small predicate, still used by tests + may be useful elsewhere) +- WbSceneryAdapter (consumed by GenerateInternal; reusable in N.2) + +Phase N.1 complete. Issues #48, #49 are addressed via WB's tested +algorithms. Roadmap entry under Phase N can be marked shipped. + +Co-Authored-By: Claude Opus 4.7 (1M context) +EOF +)" +``` + +- [ ] **Step 8.6: Mark Phase N.1 shipped in the roadmap** + +In `docs/plans/2026-04-11-roadmap.md`, find the Phase N section (search for `### Phase N — WorldBuilder Rendering Migration`). Inside the sub-phases table find the row for **N.1**, currently: + +``` +- **N.1 — Scenery algorithm calls.** Replace `IsOnRoad` / + `DisplaceObject` / slope-normal calc / rotation / scale inside + `SceneryGenerator.Generate()` with calls to WB's `SceneryHelpers` + + `TerrainUtils`. Tiny adapter `LandBlock → TerrainEntry[]`. Keeps our + data flow + `ScenerySpawn` shape. Feature flag + `ACDREAM_USE_WB_SCENERY=1`. ~1-2 days. +``` + +Add a status marker at the start of the line: + +``` +- **✓ SHIPPED — N.1 — Scenery algorithm calls.** Shipped 2026-05-08. + Replaced `IsOnRoad` / `DisplaceObject` / slope-normal calc / rotation / + scale inside `SceneryGenerator.Generate()` with calls to WB's + `SceneryHelpers` + `TerrainUtils`. Adapter `WbSceneryAdapter` produces + `TerrainEntry[]`. Visual verification at Holtburg confirmed the + road-edge tree at 0xA9B1 is gone and Issue #49 trees are still visible. +``` + +Also: add a row to the top of the file's "Phases already shipped" table, in commit-shipped order: + +``` +| N.1 | WorldBuilder-backed scenery (Chorizite/WorldBuilder fork as submodule, SceneryHelpers + TerrainUtils replace our inline ports) | Live ✓ | +``` + +Then commit: + +```bash +git add docs/plans/2026-04-11-roadmap.md +git commit -m "$(cat <<'EOF' +docs(roadmap): mark Phase N.1 (scenery via WB helpers) shipped + +Co-Authored-By: Claude Opus 4.7 (1M context) +EOF +)" +``` + +--- + +## Done definition + +After all 8 tasks land cleanly: + +- [x] `dotnet build` and `dotnet test` (excluding the 8 pre-existing `DispatcherToMovementIntegrationTests` failures unrelated to this work) green. +- [x] Visual verification at Holtburg confirms: + - The road-edge tree near `0xA9B1` is **gone**. + - Issue #49's missing scenery is **still visible**. + - No new visual regressions in surrounding landblocks during a brief flight. +- [x] Phase N.1 marked shipped in `docs/plans/2026-04-11-roadmap.md`. +- [x] `SceneryGenerator.Generate` calls only WB helpers for displacement / road / slope / rotation / scale. +- [x] Issue #49 stays closed; no new related issues filed.