diff --git a/src/AcDream.App/Rendering/RetailPViewRenderer.cs b/src/AcDream.App/Rendering/RetailPViewRenderer.cs
index c2933870..f61a4f69 100644
--- a/src/AcDream.App/Rendering/RetailPViewRenderer.cs
+++ b/src/AcDream.App/Rendering/RetailPViewRenderer.cs
@@ -341,6 +341,26 @@ public sealed class RetailPViewRenderer
// (far→near), per portal_view slice. No drawableCells filter — a cell without a
// clip-slot falls through GetCellSlicesOrNoClip to NoClipSlice and draws unclipped
// (sealed; per-slice trim returns in Task 4).
+ //
+ // #113 (2026-06-10): the per-slice clip MUST actually clip. Retail clips drawn
+ // CELL geometry to the accumulated portal view — Render::set_view (:343750)
+ // installs the view polygon's edge planes and DrawEnvCell submits every cell
+ // polygon with planeMask=0xffffffff (:427922) through ACRender::polyClipFinish.
+ // Our equivalent (UseShellClipRouting → mesh_modern.vert gl_ClipDistance) was
+ // routed but INERT: gl_ClipDistance writes are ignored unless GL_CLIP_DISTANCEi
+ // is enabled, and no caller enabled it for this pass — so flooded interior cells
+ // drew WHOLE, painting interior geometry across exterior walls (the Holtburg
+ // meeting-hall phantom staircase, AAB3 0x100 stair cell coincident with the
+ // shell's west wall). Self-contained per feedback_render_self_contained_gl_state;
+ // no early-outs between enable and disable. Slot-0 slices (SSBO count=0) still
+ // pass-all — the assembler's >8-plane scissor fallback remains unimplemented
+ // (rare; Issue113MeetingHallFloodTests pins 0 such slices at the hall).
+ // Characters/statics stay unclipped (DrawCellObjectLists): retail's mesh path is
+ // viewcone-check + BoundingType handling, and hard-clipping slices characters at
+ // doorways (the original UseIndoorMembershipOnlyRouting observation).
+ for (int i = 0; i < ClipFrame.MaxPlanes; i++)
+ _gl.Enable(Silk.NET.OpenGL.EnableCap.ClipDistance0 + i);
+
foreach (var entry in IndoorDrawPlan.ShellPass(pvFrame))
{
uint cellId = entry.CellId;
@@ -354,6 +374,9 @@ public sealed class RetailPViewRenderer
_envCells.Render(WbRenderPass.Transparent, _oneCell);
}
}
+
+ for (int i = 0; i < ClipFrame.MaxPlanes; i++)
+ _gl.Disable(Silk.NET.OpenGL.EnableCap.ClipDistance0 + i);
}
private void DrawCellObjectLists(
@@ -396,10 +419,13 @@ public sealed class RetailPViewRenderer
private void UseIndoorMembershipOnlyRouting()
{
- // Retail's PView portal views decide which cells/objects are eligible,
- // but DrawMesh only performs portal-view visibility checks before drawing
- // the mesh. Feeding those 2D views into gl_ClipDistance slices characters
- // and cell shells at stair/door boundaries, which retail does not do.
+ // For MESHES (characters, statics) retail's DrawMesh performs portal-view
+ // visibility checks (Render::viewconeCheck on the drawing sphere) rather
+ // than hard per-poly clipping — feeding the 2D views into gl_ClipDistance
+ // slices characters at stair/door boundaries, which retail does not do.
+ // CELL SHELL geometry is different: retail clips it to the portal view
+ // (planeMask=0xffffffff per cell polygon, decomp :427922 + :343750) —
+ // DrawEnvCellShells enables exactly that (#113).
_envCells.SetClipRouting(null);
_entities.ClearClipRouting();
}
diff --git a/tests/AcDream.App.Tests/Rendering/Issue113MeetingHallFloodTests.cs b/tests/AcDream.App.Tests/Rendering/Issue113MeetingHallFloodTests.cs
new file mode 100644
index 00000000..8b63aedc
--- /dev/null
+++ b/tests/AcDream.App.Tests/Rendering/Issue113MeetingHallFloodTests.cs
@@ -0,0 +1,240 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Numerics;
+using AcDream.App.Rendering;
+using DatReaderWriter;
+using DatReaderWriter.Options;
+using Xunit;
+using Xunit.Abstractions;
+using DatEnvCell = DatReaderWriter.DBObjs.EnvCell;
+using DatEnvironment = DatReaderWriter.DBObjs.Environment;
+
+namespace AcDream.App.Tests.Rendering;
+
+///
+/// #113 phantom exterior staircase (2026-06-10): the Holtburg meeting hall
+/// (AAB3 building[0], model 0x010014C3 at AAB3-local (36,84,116)) shows its
+/// INTERIOR stair cells painted across the west exterior wall when viewed from
+/// outside. Attribution: retail clips drawn cell geometry to the accumulated
+/// portal aperture (Render::set_view portal scissor + polyClipFinish with
+/// planeMask=0xffffffff, decomp :343750/:427922); our DrawEnvCellShells routes
+/// per-cell clip planes via ClipFrameAssembler — but a slice whose aperture
+/// polygon exceeds the 8-plane budget falls back to slot 0 ("the renderer uses
+/// scissor for passes that need that fallback", ClipFrameAssembler.cs:13-15)
+/// and the shell pass never implemented that scissor → the cell draws fully
+/// unclipped. This harness replays the production outdoor per-building flood
+/// (PortalVisibilityBuilder.ConstructViewBuilding, the R-A2 path) + the
+/// production assembler from the user's click-time viewpoint and pins which
+/// hall cells draw and with what clip.
+///
+public class Issue113MeetingHallFloodTests
+{
+ private readonly ITestOutputHelper _out;
+ public Issue113MeetingHallFloodTests(ITestOutputHelper output) => _out = output;
+
+ private const uint Landblock = 0xAAB30000u;
+ private const uint EnvironmentFilePrefix = 0x0D000000u;
+
+ private static string? ResolveDatDir()
+ {
+ var fromEnv = Environment.GetEnvironmentVariable("ACDREAM_DAT_DIR");
+ if (!string.IsNullOrWhiteSpace(fromEnv) && Directory.Exists(fromEnv))
+ return fromEnv;
+ var def = Path.Combine(
+ Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+ "Documents", "Asheron's Call");
+ return Directory.Exists(def) ? def : null;
+ }
+
+ // Mirrors CornerFloodReplayTests.LoadCell (GameWindow.BuildLoadedCell shape).
+ private static LoadedCell LoadCell(DatCollection dats, uint cellId)
+ {
+ var envCell = dats.Get(cellId)
+ ?? throw new InvalidOperationException($"EnvCell 0x{cellId:X8} not found");
+ var environment = dats.Get(EnvironmentFilePrefix | envCell.EnvironmentId)
+ ?? throw new InvalidOperationException($"Environment 0x{envCell.EnvironmentId:X8} not found");
+ if (!environment.Cells.TryGetValue(envCell.CellStructure, out var cellStruct) || cellStruct is null)
+ throw new InvalidOperationException($"CellStruct {envCell.CellStructure} missing");
+
+ var cellTransform =
+ Matrix4x4.CreateFromQuaternion(envCell.Position.Orientation) *
+ Matrix4x4.CreateTranslation(envCell.Position.Origin);
+ Matrix4x4.Invert(cellTransform, out var inverse);
+
+ var boundsMin = new Vector3(float.MaxValue);
+ var boundsMax = new Vector3(float.MinValue);
+ foreach (var kvp in cellStruct.VertexArray.Vertices)
+ {
+ var v = kvp.Value;
+ var pos = new Vector3(v.Origin.X, v.Origin.Y, v.Origin.Z);
+ boundsMin = Vector3.Min(boundsMin, pos);
+ boundsMax = Vector3.Max(boundsMax, pos);
+ }
+ if (boundsMin.X == float.MaxValue) { boundsMin = Vector3.Zero; boundsMax = Vector3.Zero; }
+
+ var portals = new List();
+ var clipPlanes = new List();
+ var portalPolygons = new List();
+ var centroid = (boundsMin + boundsMax) * 0.5f;
+
+ foreach (var portal in envCell.CellPortals)
+ {
+ portals.Add(new CellPortalInfo(
+ portal.OtherCellId, portal.PolygonId, (ushort)portal.Flags, portal.OtherPortalId));
+
+ if (cellStruct.Polygons.TryGetValue(portal.PolygonId, out var poly)
+ && poly.VertexIds.Count >= 3
+ && cellStruct.VertexArray.Vertices.TryGetValue((ushort)poly.VertexIds[0], out var v0)
+ && cellStruct.VertexArray.Vertices.TryGetValue((ushort)poly.VertexIds[1], out var v1)
+ && cellStruct.VertexArray.Vertices.TryGetValue((ushort)poly.VertexIds[2], out var v2))
+ {
+ var p0 = new Vector3(v0.Origin.X, v0.Origin.Y, v0.Origin.Z);
+ var p1 = new Vector3(v1.Origin.X, v1.Origin.Y, v1.Origin.Z);
+ var p2 = new Vector3(v2.Origin.X, v2.Origin.Y, v2.Origin.Z);
+ var normal = Vector3.Normalize(Vector3.Cross(p1 - p0, p2 - p0));
+ float d = -Vector3.Dot(normal, p0);
+ float centroidDot = Vector3.Dot(normal, centroid) + d;
+ clipPlanes.Add(new PortalClipPlane
+ {
+ Normal = normal, D = d, InsideSide = centroidDot >= 0 ? 0 : 1,
+ });
+ }
+ else
+ {
+ clipPlanes.Add(default);
+ }
+
+ Vector3[] polyVerts = Array.Empty();
+ if (cellStruct.Polygons.TryGetValue(portal.PolygonId, out var portalPoly)
+ && portalPoly.VertexIds.Count >= 3)
+ {
+ polyVerts = new Vector3[portalPoly.VertexIds.Count];
+ bool allResolved = true;
+ for (int vi = 0; vi < portalPoly.VertexIds.Count; vi++)
+ {
+ if (cellStruct.VertexArray.Vertices.TryGetValue(
+ (ushort)portalPoly.VertexIds[vi], out var pv))
+ polyVerts[vi] = new Vector3(pv.Origin.X, pv.Origin.Y, pv.Origin.Z);
+ else { allResolved = false; break; }
+ }
+ if (!allResolved) polyVerts = Array.Empty();
+ }
+ portalPolygons.Add(polyVerts);
+ }
+
+ uint lbPrefix = cellId & 0xFFFF0000u;
+ var visibleCells = new List();
+ if (envCell.VisibleCells is not null)
+ foreach (var lowId in envCell.VisibleCells)
+ visibleCells.Add(lbPrefix | lowId);
+
+ return new LoadedCell
+ {
+ CellId = cellId,
+ WorldPosition = envCell.Position.Origin,
+ WorldTransform = cellTransform,
+ InverseWorldTransform = inverse,
+ LocalBoundsMin = boundsMin,
+ LocalBoundsMax = boundsMax,
+ Portals = portals,
+ ClipPlanes = clipPlanes,
+ PortalPolygons = portalPolygons,
+ VisibleCells = visibleCells,
+ SeenOutside = envCell.Flags.HasFlag(DatReaderWriter.Enums.EnvCellFlags.SeenOutside),
+ };
+ }
+
+ private static Dictionary LoadHall(DatCollection dats)
+ {
+ var cells = new Dictionary();
+ for (uint low = 0x0100u; low <= 0x0106u; low++)
+ {
+ uint id = Landblock | low;
+ cells[id] = LoadCell(dats, id);
+ }
+ return cells;
+ }
+
+ private static Matrix4x4 ViewProjFor(Vector3 eye, Vector3 lookAt)
+ {
+ var view = Matrix4x4.CreateLookAt(eye, lookAt, Vector3.UnitZ);
+ var proj = Matrix4x4.CreatePerspectiveFieldOfView(1.2f, 1280f / 720f, 0.1f, 5000f);
+ return view * proj;
+ }
+
+ ///
+ /// Replay the production outdoor flood + assembler from the user's
+ /// click-time viewpoint (player AAB3-local (24.4, 83.4, 116), chase eye
+ /// behind at eye height, looking at the hall's west door). Prints every
+ /// hall cell that enters the drawn set with its slice slot / plane count /
+ /// NDC AABB. The #113 defect signature: a hall cell drawn with a slice
+ /// that has Slot==0 AND zero planes (the assembler's scissor-fallback
+ /// contract) — DrawEnvCellShells draws that slice fully unclipped, so the
+ /// interior staircase paints across the exterior wall.
+ ///
+ [Fact]
+ public void WestApproach_HallCellSlices_HaveUsableClip()
+ {
+ var datDir = ResolveDatDir();
+ if (datDir is null) { _out.WriteLine("SKIP: dats unavailable"); return; }
+
+ using var dats = new DatCollection(datDir, DatAccessType.Read);
+ var cells = LoadHall(dats);
+ Func lookup = id => cells.TryGetValue(id, out var c) ? c : null;
+
+ // Chase-camera sweep along the west approach: player walked from the
+ // cottage (west) toward the hall; eye behind the player at z≈117.6,
+ // looking at the hall's west door (local (29.4, 84.0, 117.3)).
+ var lookAt = new Vector3(29.4f, 84.0f, 117.3f);
+ int unclippedDrawn = 0;
+ var report = new List();
+
+ for (int i = 0; i <= 20; i++)
+ {
+ float ex = 14f + i * 0.5f; // eye local x 14 → 24
+ var eye = new Vector3(ex, 83.4f, 117.6f);
+ var vp = ViewProjFor(eye, lookAt);
+
+ var frame = PortalVisibilityBuilder.ConstructViewBuilding(
+ cells.Values.ToList(), eye, lookup, vp, maxSeedDistance: 48f);
+
+ var clipFrame = ClipFrame.NoClip();
+ var assembly = ClipFrameAssembler.Assemble(clipFrame, frame);
+
+ string flood = string.Join(" ", frame.OrderedVisibleCells.Select(c => $"{c & 0xFFFFu:X3}"));
+ var lineParts = new List();
+ foreach (uint cellId in frame.OrderedVisibleCells)
+ {
+ if (!assembly.CellIdToViewSlices.TryGetValue(cellId, out var slices))
+ {
+ // No slices at all → DrawEnvCellShells falls to NoClipSlice → UNCLIPPED.
+ lineParts.Add($"0x{cellId & 0xFFFFu:X3}:NO-SLICES(unclipped)");
+ unclippedDrawn++;
+ continue;
+ }
+ foreach (var s in slices)
+ {
+ bool unclipped = s.Slot == 0 && s.Planes.Length == 0;
+ if (unclipped) unclippedDrawn++;
+ string tag = unclipped ? "(UNCLIPPED)" : "";
+ lineParts.Add(FormattableString.Invariant(
+ $"0x{cellId & 0xFFFFu:X3}:slot{s.Slot}/p{s.Planes.Length}[{s.NdcAabb.X:F2},{s.NdcAabb.Y:F2}..{s.NdcAabb.Z:F2},{s.NdcAabb.W:F2}]{tag}"));
+ }
+ }
+ report.Add(FormattableString.Invariant(
+ $"eyeX={ex,5:F1} flood=[{flood}] {string.Join(" ", lineParts)}"));
+ }
+
+ foreach (var line in report) _out.WriteLine(line);
+ _out.WriteLine($"unclipped-drawn slices across sweep: {unclippedDrawn}");
+
+ // Documents the defect when it fires; flips to 0 once the shell pass
+ // implements the assembler's scissor-fallback contract (or exact clip).
+ Assert.True(unclippedDrawn == 0,
+ $"#113: {unclippedDrawn} hall-cell slices would draw fully unclipped " +
+ "(slot 0, no planes, no scissor) — interior stair geometry paints " +
+ "across the exterior wall (the phantom staircase).");
+ }
+}
diff --git a/tests/AcDream.Core.Tests/Conformance/Issue113PhantomStairsDumpTests.cs b/tests/AcDream.Core.Tests/Conformance/Issue113PhantomStairsDumpTests.cs
new file mode 100644
index 00000000..1e704c35
--- /dev/null
+++ b/tests/AcDream.Core.Tests/Conformance/Issue113PhantomStairsDumpTests.cs
@@ -0,0 +1,815 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using DatReaderWriter;
+using DatReaderWriter.Options;
+using Xunit;
+using Xunit.Abstractions;
+using DatEnvCell = DatReaderWriter.DBObjs.EnvCell;
+using DatEnvironment = DatReaderWriter.DBObjs.Environment;
+using DatLandBlockInfo = DatReaderWriter.DBObjs.LandBlockInfo;
+
+namespace AcDream.Core.Tests.Conformance;
+
+///
+/// #113 diagnostic dump (2026-06-10): an A9B3 building near local (183, 81, 116)
+/// renders a phantom exterior staircase that retail does not show. Hypotheses:
+/// H1 — a misplaced interior EnvCell (parse/transform bug; would also explain the
+/// #112 containment gap at local (184.9, 82.5, 116.5) and missing object
+/// collision); H2 — the cell is placed exactly where the dat says (AC interiors
+/// legitimately overflow their shells) and the divergence is draw POLICY (retail
+/// only draws interior cells flagged SeenOutside / portal-visible from outdoors).
+/// This dump prints the raw dat facts that discriminate: building frames, every
+/// interior cell's Position + world AABB + SeenOutside flag + stair signature
+/// (distinct horizontal-face heights), and containment of the two key points.
+///
+public sealed class Issue113PhantomStairsDumpTests
+{
+ private readonly ITestOutputHelper _out;
+ public Issue113PhantomStairsDumpTests(ITestOutputHelper output) => _out = output;
+
+ private const uint Landblock = 0xA9B30000u;
+ private const uint EnvironmentFilePrefix = 0x0D000000u;
+
+ // User-observed phantom-stairs spot (A9B3-local frame; world y + 192).
+ private static readonly Vector3 StairsSpot = new(183.0f, 81.0f, 116.5f);
+ // #112 containment-gap point (A9B3-local, foot-center height).
+ private static readonly Vector3 GapPoint = new(184.915f, 82.464f, 116.48f);
+
+ [Fact]
+ public void DumpA9B3_Buildings_And_InteriorCells()
+ {
+ var datDir = ConformanceDats.ResolveDatDir();
+ if (datDir is null) { _out.WriteLine("dats unavailable — skipped"); return; }
+ using var dats = new DatCollection(datDir, DatAccessType.Read);
+
+ var lbi = dats.Get(Landblock | 0xFFFEu);
+ Assert.NotNull(lbi);
+ _out.WriteLine($"=== LandBlockInfo 0x{Landblock | 0xFFFEu:X8}: NumCells={lbi!.NumCells}, Buildings={lbi.Buildings?.Count ?? 0} ===");
+
+ // ---- load every interior cell ----
+ var cells = new Dictionary WorldVerts, Vector3 Min, Vector3 Max, List FlatHeights, int RampPolys)>();
+ for (uint low = 0x0100; low < 0x0100 + lbi.NumCells; low++)
+ {
+ uint id = Landblock | low;
+ var dc = dats.Get(id);
+ if (dc is null) { _out.WriteLine($" cell 0x{id:X8}: MISSING"); continue; }
+
+ var env = dats.Get(EnvironmentFilePrefix | dc.EnvironmentId);
+ if (env is null || !env.Cells.TryGetValue(dc.CellStructure, out var cs) || cs is null)
+ { _out.WriteLine($" cell 0x{id:X8}: env 0x{dc.EnvironmentId:X} struct {dc.CellStructure} MISSING"); continue; }
+
+ var world = ConformanceDats.WorldTransform(dc);
+ var verts = new List(cs.VertexArray.Vertices.Count);
+ var min = new Vector3(float.MaxValue);
+ var max = new Vector3(float.MinValue);
+ foreach (var kvp in cs.VertexArray.Vertices)
+ {
+ var p = Vector3.Transform(
+ new Vector3(kvp.Value.Origin.X, kvp.Value.Origin.Y, kvp.Value.Origin.Z), world);
+ verts.Add(p);
+ min = Vector3.Min(min, p);
+ max = Vector3.Max(max, p);
+ }
+
+ // Stair signature: per-polygon world normal via Newell; horizontal
+ // faces (|n.Z| > 0.9) binned by height; mid-slope faces counted.
+ var flatHeights = new List();
+ int rampPolys = 0;
+ foreach (var poly in cs.Polygons.Values)
+ {
+ if (poly.VertexIds.Count < 3) continue;
+ var pts = new List(poly.VertexIds.Count);
+ bool ok = true;
+ foreach (var vid in poly.VertexIds)
+ {
+ if (!cs.VertexArray.Vertices.TryGetValue((ushort)vid, out var v)) { ok = false; break; }
+ pts.Add(Vector3.Transform(new Vector3(v.Origin.X, v.Origin.Y, v.Origin.Z), world));
+ }
+ if (!ok) continue;
+ var n = Vector3.Zero;
+ for (int i = 0; i < pts.Count; i++)
+ {
+ var a = pts[i];
+ var b = pts[(i + 1) % pts.Count];
+ n.X += (a.Y - b.Y) * (a.Z + b.Z);
+ n.Y += (a.Z - b.Z) * (a.X + b.X);
+ n.Z += (a.X - b.X) * (a.Y + b.Y);
+ }
+ if (n.LengthSquared() < 1e-10f) continue;
+ n = Vector3.Normalize(n);
+ if (MathF.Abs(n.Z) > 0.9f)
+ flatHeights.Add(pts.Average(p => p.Z));
+ else if (MathF.Abs(n.Z) > 0.15f)
+ rampPolys++;
+ }
+
+ cells[id] = (dc, verts, min, max, flatHeights, rampPolys);
+ }
+
+ // ---- per-cell report ----
+ _out.WriteLine("");
+ _out.WriteLine("=== Interior cells (positions are A9B3-local; world y = local y - 192) ===");
+ foreach (var (id, c) in cells.OrderBy(k => k.Key))
+ {
+ var dc = c.Cell;
+ var o = dc.Position.Origin;
+ var q = dc.Position.Orientation;
+ var distinctHeights = c.FlatHeights.Select(h => MathF.Round(h, 1)).Distinct().OrderBy(h => h).ToList();
+ string stairSig = distinctHeights.Count > 3
+ ? $"STAIR? heights=[{string.Join(",", distinctHeights.Select(h => h.ToString("F1")))}]"
+ : $"heights=[{string.Join(",", distinctHeights.Select(h => h.ToString("F1")))}]";
+
+ _out.WriteLine(
+ $"cell 0x{id:X8} env=0x{dc.EnvironmentId:X4} struct={dc.CellStructure} " +
+ $"pos=({o.X:F2},{o.Y:F2},{o.Z:F2}) quat=(w{q.W:F3} x{q.X:F3} y{q.Y:F3} z{q.Z:F3}) " +
+ $"flags={dc.Flags} portals=[{string.Join(",", dc.CellPortals.Select(p => $"0x{p.OtherCellId:X3}({p.Flags})"))}] " +
+ $"vis={dc.VisibleCells?.Count ?? 0} statics={dc.StaticObjects?.Count ?? 0}");
+ _out.WriteLine(
+ $" AABB local=({c.Min.X:F1},{c.Min.Y:F1},{c.Min.Z:F1})..({c.Max.X:F1},{c.Max.Y:F1},{c.Max.Z:F1}) " +
+ $"rampPolys={c.RampPolys} {stairSig}");
+
+ bool nearStairs = AabbContains(c.Min, c.Max, StairsSpot, 1.5f);
+ bool hasGap = AabbContains(c.Min, c.Max, GapPoint, 0.0f);
+ if (nearStairs) _out.WriteLine($" *** AABB within 1.5m of phantom-stairs spot ({StairsSpot.X},{StairsSpot.Y},{StairsSpot.Z}) ***");
+ if (hasGap) _out.WriteLine($" *** AABB contains #112 gap point ({GapPoint.X},{GapPoint.Y},{GapPoint.Z}) ***");
+ }
+
+ // ---- buildings ----
+ _out.WriteLine("");
+ _out.WriteLine("=== Buildings ===");
+ int bIdx = 0;
+ foreach (var b in lbi.Buildings ?? new())
+ {
+ var o = b.Frame.Origin;
+ var q = b.Frame.Orientation;
+ var seeds = (b.Portals ?? new()).Where(p => p.OtherCellId != 0xFFFF)
+ .Select(p => (uint)(Landblock | p.OtherCellId)).Distinct().ToList();
+
+ // BFS through cell portals for the full cell set (mirrors BuildingLoader).
+ var set = new HashSet(seeds);
+ var queue = new Queue(seeds);
+ while (queue.Count > 0)
+ {
+ var cur = queue.Dequeue();
+ if (!cells.TryGetValue(cur, out var cc)) continue;
+ foreach (var p in cc.Cell.CellPortals)
+ {
+ if (p.OtherCellId == 0xFFFF) continue;
+ uint nid = Landblock | p.OtherCellId;
+ if (set.Add(nid)) queue.Enqueue(nid);
+ }
+ }
+
+ float dStairs = Vector2.Distance(new Vector2(o.X, o.Y), new Vector2(StairsSpot.X, StairsSpot.Y));
+ _out.WriteLine(
+ $"building[{bIdx}] model=0x{b.ModelId:X8} pos=({o.X:F2},{o.Y:F2},{o.Z:F2}) " +
+ $"quat=(w{q.W:F3} x{q.X:F3} y{q.Y:F3} z{q.Z:F3}) numLeaves={b.NumLeaves} " +
+ $"portals={b.Portals?.Count ?? 0} dist2D(stairsSpot)={dStairs:F1}m");
+ _out.WriteLine(
+ $" cells=[{string.Join(",", set.OrderBy(x => x).Select(x => $"0x{x & 0xFFFF:X3}"))}]");
+ bIdx++;
+ }
+
+ // ---- containment summary at the two key points ----
+ _out.WriteLine("");
+ _out.WriteLine("=== Containment (AABB-level) at key points ===");
+ foreach (var (label, pt) in new[] { ("stairsSpot", StairsSpot), ("gapPoint", GapPoint) })
+ {
+ var hits = cells.Where(kv => AabbContains(kv.Value.Min, kv.Value.Max, pt, 0f))
+ .Select(kv => $"0x{kv.Key & 0xFFFF:X3}").ToList();
+ _out.WriteLine($"{label} ({pt.X:F1},{pt.Y:F1},{pt.Z:F1}): AABB-contained by [{string.Join(",", hits)}]");
+ }
+ }
+
+ private static bool AabbContains(Vector3 min, Vector3 max, Vector3 p, float pad) =>
+ p.X >= min.X - pad && p.X <= max.X + pad &&
+ p.Y >= min.Y - pad && p.Y <= max.Y + pad &&
+ p.Z >= min.Z - pad && p.Z <= max.Z + pad;
+
+ ///
+ /// Round 2: the stair suspect must be either (a) a static object inside a
+ /// ground cell, (b) an outdoor stab, or (c) part of the shell GfxObj itself.
+ /// Dump all three + the shell AABB (TARDIS check: interior cells overflow
+ /// the shell?).
+ ///
+ [Fact]
+ public void DumpA9B3_Statics_OutdoorStabs_And_ShellModel()
+ {
+ var datDir = ConformanceDats.ResolveDatDir();
+ if (datDir is null) { _out.WriteLine("dats unavailable — skipped"); return; }
+ using var dats = new DatCollection(datDir, DatAccessType.Read);
+
+ var lbi = dats.Get(Landblock | 0xFFFEu);
+ Assert.NotNull(lbi);
+
+ _out.WriteLine("=== LandBlockInfo.Objects (outdoor stabs) ===");
+ foreach (var stab in lbi!.Objects ?? new())
+ {
+ var o = stab.Frame.Origin;
+ float d = Vector2.Distance(new Vector2(o.X, o.Y), new Vector2(StairsSpot.X, StairsSpot.Y));
+ _out.WriteLine($" stab model=0x{stab.Id:X8} pos=({o.X:F2},{o.Y:F2},{o.Z:F2}) dist2D(stairsSpot)={d:F1}m");
+ }
+
+ _out.WriteLine("");
+ _out.WriteLine("=== Per-cell StaticObjects (frame is CELL-LOCAL; world = cellPos + local here, identity quat) ===");
+ var cellPos = new Vector3(180f, 84f, 116f);
+ var staticModels = new HashSet();
+ for (uint low = 0x0100; low < 0x0100 + lbi.NumCells; low++)
+ {
+ uint id = Landblock | low;
+ var dc = dats.Get(id);
+ if (dc?.StaticObjects is null || dc.StaticObjects.Count == 0) continue;
+ foreach (var s in dc.StaticObjects)
+ {
+ var o = s.Frame.Origin;
+ var w = cellPos + o;
+ var q = s.Frame.Orientation;
+ float d = Vector2.Distance(new Vector2(w.X, w.Y), new Vector2(StairsSpot.X, StairsSpot.Y));
+ staticModels.Add(s.Id);
+ _out.WriteLine(
+ $" cell 0x{low:X3} static model=0x{s.Id:X8} local=({o.X:F2},{o.Y:F2},{o.Z:F2}) " +
+ $"world=({w.X:F2},{w.Y:F2},{w.Z:F2}) quat=(w{q.W:F3} z{q.Z:F3}) dist2D(stairsSpot)={d:F1}m");
+ }
+ }
+
+ _out.WriteLine("");
+ _out.WriteLine("=== Static/shell model AABBs (model-local) ===");
+ staticModels.Add(0x01000827u); // the shell
+ foreach (var mid in staticModels.OrderBy(m => m))
+ DumpModelAabb(dats, mid);
+
+ // TARDIS check: shell world AABB vs interior-cell envelope.
+ _out.WriteLine("");
+ _out.WriteLine("=== Shell stair-signature scan near the phantom spot ===");
+ // Shell model is placed at building frame (180,84,116), identity quat —
+ // model-local (3,-3,0..3) corresponds to local-frame (183,81,116..119).
+ DumpStairSignatureNear(dats, 0x01000827u, new Vector3(180f, 84f, 116f),
+ boxMin: new Vector3(181.0f, 77.0f, 115.5f), boxMax: new Vector3(186.5f, 83.5f, 121.0f));
+
+ _out.WriteLine("");
+ _out.WriteLine("=== Shell WHOLE-MODEL scan (does the shell contain stairs ANYWHERE?) ===");
+ DumpStairSignatureNear(dats, 0x01000827u, new Vector3(180f, 84f, 116f),
+ boxMin: new Vector3(-10000f), boxMax: new Vector3(10000f));
+
+ // Localize: roofs are big high slopes; stairs are a narrow low strip.
+ _out.WriteLine("");
+ _out.WriteLine("=== Shell ramp/low-flat poly localization (world local-frame, placed at 180,84,116) ===");
+ var shell = dats.Get(0x01000827u)!;
+ foreach (var kv in shell.Polygons)
+ {
+ var poly = kv.Value;
+ if (poly.VertexIds.Count < 3) continue;
+ var pts = new List();
+ bool ok = true;
+ foreach (var vid in poly.VertexIds)
+ {
+ if (!shell.VertexArray.Vertices.TryGetValue((ushort)vid, out var v)) { ok = false; break; }
+ pts.Add(new Vector3(180f + v.Origin.X, 84f + v.Origin.Y, 116f + v.Origin.Z));
+ }
+ if (!ok) continue;
+ var n = NewellNormal(pts);
+ if (n == Vector3.Zero) continue;
+ var c = pts.Aggregate(Vector3.Zero, (a, b) => a + b) / pts.Count;
+ bool ramp = MathF.Abs(n.Z) > 0.15f && MathF.Abs(n.Z) <= 0.9f;
+ bool lowFlat = MathF.Abs(n.Z) > 0.9f && c.Z < 120.5f;
+ if (!ramp && !lowFlat) continue;
+ _out.WriteLine(
+ $" poly {kv.Key,3} {(ramp ? "RAMP" : "FLAT")} c=({c.X:F1},{c.Y:F1},{c.Z:F2}) nZ={n.Z:F2} verts={pts.Count} " +
+ $"xy-span=({pts.Max(p => p.X) - pts.Min(p => p.X):F1},{pts.Max(p => p.Y) - pts.Min(p => p.Y):F1})");
+ }
+ }
+
+ ///
+ /// Rider (#112 residual): 0x104's exterior portal polygon + plane, and the
+ /// gap point's distance to it. Retail admits outside cells only when the
+ /// sphere STRADDLES this plane (|dist| < radius + 0.0002, pc:310090-310120).
+ ///
+ [Fact]
+ public void Dump_Cell104_ExteriorPortalPlane_Vs_GapPoint()
+ {
+ var datDir = ConformanceDats.ResolveDatDir();
+ if (datDir is null) { _out.WriteLine("dats unavailable — skipped"); return; }
+ using var dats = new DatCollection(datDir, DatAccessType.Read);
+
+ foreach (uint low in new uint[] { 0x0104, 0x0102, 0x0105, 0x0100 })
+ {
+ uint id = Landblock | low;
+ var dc = dats.Get(id);
+ if (dc is null) continue;
+ var env = dats.Get(EnvironmentFilePrefix | dc.EnvironmentId);
+ if (env is null || !env.Cells.TryGetValue(dc.CellStructure, out var cs) || cs is null) continue;
+ var world = ConformanceDats.WorldTransform(dc);
+
+ foreach (var p in dc.CellPortals)
+ {
+ if (p.OtherCellId != 0xFFFF) continue;
+ if (!cs.Polygons.TryGetValue(p.PolygonId, out var poly)) { _out.WriteLine($"cell 0x{low:X3}: portal poly {p.PolygonId} MISSING"); continue; }
+ var pts = new List();
+ foreach (var vid in poly.VertexIds)
+ if (cs.VertexArray.Vertices.TryGetValue((ushort)vid, out var v))
+ pts.Add(Vector3.Transform(new Vector3(v.Origin.X, v.Origin.Y, v.Origin.Z), world));
+ if (pts.Count < 3) continue;
+
+ var n = Vector3.Zero;
+ for (int i = 0; i < pts.Count; i++)
+ {
+ var a = pts[i]; var b = pts[(i + 1) % pts.Count];
+ n.X += (a.Y - b.Y) * (a.Z + b.Z);
+ n.Y += (a.Z - b.Z) * (a.X + b.X);
+ n.Z += (a.X - b.X) * (a.Y + b.Y);
+ }
+ n = Vector3.Normalize(n);
+ float dPlane = -Vector3.Dot(n, pts[0]);
+ float dist = Vector3.Dot(n, GapPoint) + dPlane;
+ _out.WriteLine(
+ $"cell 0x{low:X3} EXTERIOR portal poly={p.PolygonId} flags={p.Flags} " +
+ $"verts=[{string.Join(" ", pts.Select(v => $"({v.X:F2},{v.Y:F2},{v.Z:F2})"))}]");
+ _out.WriteLine(
+ $" plane n=({n.X:F3},{n.Y:F3},{n.Z:F3}) d={dPlane:F3} " +
+ $"dist(gapPoint)={dist:F3} | straddle@r=0.48: {(MathF.Abs(dist) < 0.48f + 0.0002f ? "YES — retail ADMITS outside cells here" : "NO — retail keeps curr_cell")}");
+ }
+ }
+ }
+
+ ///
+ /// Round 3: the issue112-gate1.log pick lines show the NPCs "behind the
+ /// stairs" live in AAB3 (world x 209–252) — the block EAST of A9B3. The
+ /// phantom staircase is likely on an AAB3 building. Dump AAB3's buildings
+ /// + per-model stair scan + cells near the user's viewpoint.
+ ///
+ [Fact]
+ public void DumpAAB3_Buildings_And_StairScan()
+ {
+ var datDir = ConformanceDats.ResolveDatDir();
+ if (datDir is null) { _out.WriteLine("dats unavailable — skipped"); return; }
+ using var dats = new DatCollection(datDir, DatAccessType.Read);
+
+ const uint lb = 0xAAB30000u;
+ // User stood at world (183, -111) = AAB3-local (-9, 81). NPCs at
+ // AAB3-local (17.7, 84.4) and (27.7, 83.6).
+ var viewer = new Vector2(-9f, 81f);
+
+ var lbi = dats.Get(lb | 0xFFFEu);
+ Assert.NotNull(lbi);
+ _out.WriteLine($"=== AAB3 LandBlockInfo: NumCells={lbi!.NumCells}, Buildings={lbi.Buildings?.Count ?? 0} ===");
+
+ int bIdx = 0;
+ foreach (var b in lbi.Buildings ?? new())
+ {
+ var o = b.Frame.Origin;
+ var q = b.Frame.Orientation;
+ float d = Vector2.Distance(new Vector2(o.X, o.Y), viewer);
+ var seeds = (b.Portals ?? new()).Where(p => p.OtherCellId != 0xFFFF)
+ .Select(p => p.OtherCellId).Distinct().OrderBy(x => x).ToList();
+ _out.WriteLine(
+ $"building[{bIdx}] model=0x{b.ModelId:X8} pos=({o.X:F2},{o.Y:F2},{o.Z:F2}) " +
+ $"quat=(w{q.W:F3} z{q.Z:F3}) portals={b.Portals?.Count ?? 0} " +
+ $"seedCells=[{string.Join(",", seeds.Select(s => $"0x{s:X3}"))}] dist(viewer)={d:F1}m");
+ bIdx++;
+ }
+
+ _out.WriteLine("");
+ _out.WriteLine("=== Per-building-model whole-shell stair scan ===");
+ foreach (var mid in (lbi.Buildings ?? new()).Select(b => b.ModelId).Distinct().OrderBy(m => m))
+ ScanModelStairs(dats, mid);
+
+ _out.WriteLine("");
+ _out.WriteLine("=== AAB3 LandBlockInfo.Objects (outdoor stabs) — sorted by dist to viewer ===");
+ var stabs = (lbi.Objects ?? new())
+ .Select(s => (s, d: Vector2.Distance(new Vector2(s.Frame.Origin.X, s.Frame.Origin.Y), viewer)))
+ .OrderBy(t => t.d).ToList();
+ foreach (var (s, d) in stabs)
+ {
+ var o = s.Frame.Origin; var q = s.Frame.Orientation;
+ _out.WriteLine($" stab model=0x{s.Id:X8} pos=({o.X:F2},{o.Y:F2},{o.Z:F2}) quat=(w{q.W:F3} z{q.Z:F3}) dist={d:F1}m [world=({o.X + 192f:F1},{o.Y - 192f:F1},{o.Z:F1})]");
+ }
+
+ _out.WriteLine("");
+ _out.WriteLine("=== Stair scan per stab model within 45m of viewer ===");
+ foreach (var mid in stabs.Where(t => t.d < 45f).Select(t => t.s.Id).Distinct().OrderBy(m => m))
+ ScanModelStairs(dats, mid);
+
+ _out.WriteLine("");
+ _out.WriteLine("=== AAB3 interior cells (ALL — no distance filter) ===");
+ for (uint low = 0x0100; low < 0x0100 + lbi.NumCells; low++)
+ {
+ var dc = dats.Get(lb | low);
+ if (dc is null) continue;
+ var env = dats.Get(EnvironmentFilePrefix | dc.EnvironmentId);
+ if (env is null || !env.Cells.TryGetValue(dc.CellStructure, out var cs) || cs is null) continue;
+ var world = ConformanceDats.WorldTransform(dc);
+ var min = new Vector3(float.MaxValue); var max = new Vector3(float.MinValue);
+ var flat = new List(); int ramps = 0;
+ foreach (var poly in cs.Polygons.Values)
+ {
+ if (poly.VertexIds.Count < 3) continue;
+ var pts = new List();
+ bool ok = true;
+ foreach (var vid in poly.VertexIds)
+ {
+ if (!cs.VertexArray.Vertices.TryGetValue((ushort)vid, out var v)) { ok = false; break; }
+ var p = Vector3.Transform(new Vector3(v.Origin.X, v.Origin.Y, v.Origin.Z), world);
+ pts.Add(p); min = Vector3.Min(min, p); max = Vector3.Max(max, p);
+ }
+ if (!ok) continue;
+ var n = NewellNormal(pts);
+ if (n.LengthSquared() < 1e-10f) continue;
+ if (MathF.Abs(n.Z) > 0.9f) flat.Add(pts.Average(p => p.Z));
+ else if (MathF.Abs(n.Z) > 0.15f) ramps++;
+ }
+ var c2 = new Vector2((min.X + max.X) / 2, (min.Y + max.Y) / 2);
+ float dist = Vector2.Distance(c2, viewer);
+ var heights = flat.Select(h => MathF.Round(h, 1)).Distinct().OrderBy(h => h).ToList();
+ string sig = (heights.Count > 3 || ramps > 0) ? $" <== STAIR-ISH ramps={ramps} heights=[{string.Join(",", heights.Select(h => h.ToString("F1")))}]" : "";
+ _out.WriteLine(
+ $"cell 0x{low:X3} env=0x{dc.EnvironmentId:X4} flags={dc.Flags} statics={dc.StaticObjects?.Count ?? 0} " +
+ $"AABB=({min.X:F1},{min.Y:F1},{min.Z:F1})..({max.X:F1},{max.Y:F1},{max.Z:F1}) dist={dist:F1}m{sig}");
+ }
+ }
+
+ ///
+ /// Round 4: the player stood at world (216.4,-108.6) (AAB3-local (24.4,83.4))
+ /// during the stairs-clicks — 10 m west of AAB3 building[0] (the watchtower,
+ /// model 0x010014C3 at local (36,84,116), quat −90° about Z). Discriminator:
+ /// if the rotated shell's openings align with the tower cells' exterior
+ /// portal polygons, our placement matches the dat's intent (retail must show
+ /// the same face); if a solid wall covers a doorway, our placement is wrong.
+ /// Also localize the model's ramps to know which face the stairs are on.
+ ///
+ [Fact]
+ public void DumpAAB3_Watchtower_DoorAlignment_And_RampFaces()
+ {
+ var datDir = ConformanceDats.ResolveDatDir();
+ if (datDir is null) { _out.WriteLine("dats unavailable — skipped"); return; }
+ using var dats = new DatCollection(datDir, DatAccessType.Read);
+
+ const uint lb = 0xAAB30000u;
+ var lbi = dats.Get(lb | 0xFFFEu);
+ Assert.NotNull(lbi);
+ var b = lbi!.Buildings![0];
+ var shellWorld =
+ Matrix4x4.CreateFromQuaternion(b.Frame.Orientation) *
+ Matrix4x4.CreateTranslation(b.Frame.Origin);
+ _out.WriteLine($"tower model=0x{b.ModelId:X8} frame=({b.Frame.Origin.X},{b.Frame.Origin.Y},{b.Frame.Origin.Z}) quat=(w{b.Frame.Orientation.W:F3} z{b.Frame.Orientation.Z:F3})");
+ _out.WriteLine($"bld portals: [{string.Join("; ", (b.Portals ?? new()).Select(p => $"other=0x{p.OtherCellId:X3} otherPortal={p.OtherPortalId} flags={p.Flags} stabs={p.StabList?.Count ?? 0}"))}]");
+
+ // -- tower model ramp localization (model-local, z bins) --
+ var gfx = dats.Get(b.ModelId)!;
+ var bins = new Dictionary();
+ foreach (var poly in gfx.Polygons.Values)
+ {
+ var pts = ResolveLocalPoly(gfx, poly);
+ if (pts is null) continue;
+ var n = NewellNormal(pts);
+ if (n == Vector3.Zero || MathF.Abs(n.Z) <= 0.15f || MathF.Abs(n.Z) > 0.9f) continue;
+ var c = pts.Aggregate(Vector3.Zero, (a, p) => a + p) / pts.Count;
+ string bin = c.Z < 4f ? "z<4 (ground stairs?)" : c.Z < 12f ? "z 4-12 (mid stairs?)" : "z>12 (roof)";
+ var e = bins.TryGetValue(bin, out var v) ? v : (N: 0, Sum: Vector3.Zero, MinZ: float.MaxValue, MaxZ: float.MinValue);
+ bins[bin] = (e.N + 1, e.Sum + c, MathF.Min(e.MinZ, c.Z), MathF.Max(e.MaxZ, c.Z));
+ }
+ _out.WriteLine("=== tower ramp polys by z-bin (model-local centroid mean) ===");
+ foreach (var (bin, v) in bins.OrderBy(k => k.Key))
+ {
+ var mean = v.Sum / v.N;
+ var w = Vector3.Transform(mean, shellWorld);
+ _out.WriteLine($" {bin}: n={v.N} meanLocal=({mean.X:F1},{mean.Y:F1},{mean.Z:F1}) z {v.MinZ:F1}..{v.MaxZ:F1} -> meanWorld=({w.X:F1},{w.Y:F1},{w.Z:F1}) [world abs=({w.X + 192f:F1},{w.Y - 192f:F1})]");
+ }
+
+ // -- low flat treads (model z < 9, |nZ|>0.9, small) = stair treads --
+ _out.WriteLine("=== tower small flat plates below z=9 (stair treads / landings) ===");
+ foreach (var kv in gfx.Polygons)
+ {
+ var pts = ResolveLocalPoly(gfx, kv.Value);
+ if (pts is null) continue;
+ var n = NewellNormal(pts);
+ if (n == Vector3.Zero || MathF.Abs(n.Z) <= 0.9f) continue;
+ var c = pts.Aggregate(Vector3.Zero, (a, p) => a + p) / pts.Count;
+ if (c.Z >= 9f || c.Z <= 0.05f) continue;
+ float sx = pts.Max(p => p.X) - pts.Min(p => p.X);
+ float sy = pts.Max(p => p.Y) - pts.Min(p => p.Y);
+ var w = Vector3.Transform(c, shellWorld);
+ _out.WriteLine($" poly {kv.Key,3} c-local=({c.X:F1},{c.Y:F1},{c.Z:F2}) span=({sx:F1},{sy:F1}) -> world=({w.X:F1},{w.Y:F1},{w.Z:F2})");
+ }
+
+ // -- tower cells + door alignment --
+ _out.WriteLine("=== tower cells (positions are AAB3-local) ===");
+ var shellVertPolys = new List>(); // world-space vertical shell polys
+ foreach (var poly in gfx.Polygons.Values)
+ {
+ var pts = ResolveLocalPoly(gfx, poly);
+ if (pts is null) continue;
+ var n = NewellNormal(pts);
+ if (n == Vector3.Zero || MathF.Abs(n.Z) > 0.15f) continue;
+ shellVertPolys.Add(pts.Select(p => Vector3.Transform(p, shellWorld)).ToList());
+ }
+
+ for (uint low = 0x0100; low < 0x0100 + lbi.NumCells; low++)
+ {
+ var dc = dats.Get(lb | low);
+ if (dc is null) continue;
+ var env = dats.Get(EnvironmentFilePrefix | dc.EnvironmentId);
+ if (env is null || !env.Cells.TryGetValue(dc.CellStructure, out var cs) || cs is null) continue;
+ var world = ConformanceDats.WorldTransform(dc);
+ var o = dc.Position.Origin; var q = dc.Position.Orientation;
+ _out.WriteLine($"cell 0x{low:X3} env=0x{dc.EnvironmentId:X4} pos=({o.X:F2},{o.Y:F2},{o.Z:F2}) quat=(w{q.W:F3} z{q.Z:F3}) flags={dc.Flags} portals=[{string.Join(",", dc.CellPortals.Select(p => $"0x{p.OtherCellId:X3}"))}]");
+
+ foreach (var p in dc.CellPortals)
+ {
+ if (p.OtherCellId != 0xFFFF) continue;
+ if (!cs.Polygons.TryGetValue(p.PolygonId, out var poly)) continue;
+ var rect = new List();
+ foreach (var vid in poly.VertexIds)
+ if (cs.VertexArray.Vertices.TryGetValue((ushort)vid, out var v))
+ rect.Add(Vector3.Transform(new Vector3(v.Origin.X, v.Origin.Y, v.Origin.Z), world));
+ if (rect.Count < 3) continue;
+ var c = rect.Aggregate(Vector3.Zero, (a, v2) => a + v2) / rect.Count;
+
+ // Sample interior points of the portal rect; count shell polys
+ // covering them (coplanar within 0.3 m + point inside 2D proj).
+ int covered = 0, samples = 0;
+ var pn = NewellNormal(rect);
+ foreach (var t in new[] { 0.5f, 0.25f, 0.75f })
+ {
+ var sample = Vector3.Lerp(rect[0], rect[2 % rect.Count], t);
+ samples++;
+ foreach (var wallPoly in shellVertPolys)
+ {
+ var wn = NewellNormal(wallPoly);
+ if (MathF.Abs(Vector3.Dot(wn, pn)) < 0.9f) continue; // not parallel
+ float dist = Vector3.Dot(wn, sample - wallPoly[0]);
+ if (MathF.Abs(dist) > 0.3f) continue; // not coplanar
+ if (PointInPolygonOnPlane(sample, wallPoly, wn)) { covered++; break; }
+ }
+ }
+ _out.WriteLine(
+ $" EXTERIOR portal rect c=({c.X:F2},{c.Y:F2},{c.Z:F2}) " +
+ $"verts=[{string.Join(" ", rect.Select(v2 => $"({v2.X:F1},{v2.Y:F1},{v2.Z:F1})"))}] " +
+ $"shell-coverage {covered}/{samples} {(covered > 0 ? "<== BLOCKED BY SHELL WALL (misalignment!)" : "(open — aligned)")}");
+ }
+ }
+ }
+
+ ///
+ /// Round 5: top-down ASCII map of the watchtower zone from the dat, two
+ /// z-bands, with the ACE Sentry patrol segment + Aun + user overlaid.
+ /// '#'=vertical wall poly, '/'=ramp, '_'=flat, 'S'=Sentry path, 'A'=Aun,
+ /// 'U'=user at clicks, '*'=outdoor stab. World-x left→right, world-y is
+ /// printed top→bottom DESCENDING (north up).
+ ///
+ [Fact]
+ public void DumpAAB3_Watchtower_TopDownMap()
+ {
+ var datDir = ConformanceDats.ResolveDatDir();
+ if (datDir is null) { _out.WriteLine("dats unavailable — skipped"); return; }
+ using var dats = new DatCollection(datDir, DatAccessType.Read);
+
+ const uint lb = 0xAAB30000u;
+ var lbi = dats.Get(lb | 0xFFFEu)!;
+ var b = lbi.Buildings![0];
+ var shellWorld =
+ Matrix4x4.CreateFromQuaternion(b.Frame.Orientation) *
+ Matrix4x4.CreateTranslation(b.Frame.Origin);
+ var gfx = dats.Get(b.ModelId)!;
+
+ // model AABB world-placed
+ var mmin = new Vector3(float.MaxValue); var mmax = new Vector3(float.MinValue);
+ foreach (var kvp in gfx.VertexArray.Vertices)
+ {
+ var w = Vector3.Transform(new Vector3(kvp.Value.Origin.X, kvp.Value.Origin.Y, kvp.Value.Origin.Z), shellWorld);
+ mmin = Vector3.Min(mmin, w); mmax = Vector3.Max(mmax, w);
+ }
+ _out.WriteLine($"tower WORLD AABB (AAB3-local frame): ({mmin.X:F1},{mmin.Y:F1},{mmin.Z:F1})..({mmax.X:F1},{mmax.Y:F1},{mmax.Z:F1}) [world abs x {mmin.X + 192f:F1}..{mmax.X + 192f:F1}, y {mmin.Y - 192f:F1}..{mmax.Y - 192f:F1}]");
+
+ foreach (var (zLo, zHi, label) in new[] { (115.5f, 119.5f, "GROUND band z 115.5-119.5"), (119.5f, 125.5f, "UPPER band z 119.5-125.5") })
+ {
+ // grid over AAB3-local x 8..52, y 66..102, 0.5 m cells
+ const float x0 = 8f, x1 = 52f, y0 = 66f, y1 = 102f, cs = 0.5f;
+ int W = (int)((x1 - x0) / cs), H = (int)((y1 - y0) / cs);
+ var grid = new char[H, W];
+ for (int r = 0; r < H; r++) for (int c = 0; c < W; c++) grid[r, c] = ' ';
+
+ void Plot(Vector3 p, char ch, bool force = false)
+ {
+ int c = (int)((p.X - x0) / cs), r = (int)((p.Y - y0) / cs);
+ if (c < 0 || c >= W || r < 0 || r >= H) return;
+ if (force || grid[r, c] == ' ' || (ch == '/' && grid[r, c] == '#')) grid[r, c] = ch;
+ }
+
+ foreach (var poly in gfx.Polygons.Values)
+ {
+ var ptsLocal = ResolveLocalPoly(gfx, poly);
+ if (ptsLocal is null) continue;
+ var pts = ptsLocal.Select(p => Vector3.Transform(p, shellWorld)).ToList();
+ var n = NewellNormal(pts);
+ if (n == Vector3.Zero) continue;
+ char ch = MathF.Abs(n.Z) > 0.9f ? '_' : MathF.Abs(n.Z) > 0.15f ? '/' : '#';
+ // rasterize edges by sampling
+ for (int i = 0; i < pts.Count; i++)
+ {
+ var a = pts[i]; var bb = pts[(i + 1) % pts.Count];
+ for (float t = 0; t <= 1f; t += 0.05f)
+ {
+ var p = Vector3.Lerp(a, bb, t);
+ if (p.Z < zLo || p.Z > zHi) continue;
+ Plot(p, ch);
+ }
+ }
+ }
+
+ // overlays (AAB3-local = world x-192, y+192)
+ foreach (var s in lbi.Objects ?? new()) Plot(s.Frame.Origin, '*', force: true);
+ for (float t = 0; t <= 1f; t += 0.1f) // Sentry path world (219.74,-108.40,117.2)->(217.10,-108.41,117.9)
+ Plot(new Vector3(219.74f - 192f + t * (217.10f - 219.74f), -108.40f + 192f, 117.5f), 'S', force: true);
+ Plot(new Vector3(209.683f - 192f, -107.560f + 192f, 116f), 'A', force: true);
+ Plot(new Vector3(216.436f - 192f, -108.644f + 192f, 116f), 'U', force: true);
+ Plot(new Vector3(b.Frame.Origin.X, b.Frame.Origin.Y, (zLo + zHi) / 2), 'O', force: true);
+
+ _out.WriteLine("");
+ _out.WriteLine($"=== {label} === (x {x0}..{x1} local = world {x0 + 192}..{x1 + 192}; y rows DESC from {y1 - 192f} to {y0 - 192f} world)");
+ for (int r = H - 1; r >= 0; r--)
+ {
+ var row = new char[W];
+ for (int c = 0; c < W; c++) row[c] = grid[r, c];
+ float wy = (y0 + r * cs) - 192f;
+ _out.WriteLine($"y{wy,7:F1} |{new string(row)}|");
+ }
+ }
+ }
+
+ private static List? ResolveLocalPoly(DatReaderWriter.DBObjs.GfxObj gfx, DatReaderWriter.Types.Polygon poly)
+ {
+ if (poly.VertexIds.Count < 3) return null;
+ var pts = new List(poly.VertexIds.Count);
+ foreach (var vid in poly.VertexIds)
+ {
+ if (!gfx.VertexArray.Vertices.TryGetValue((ushort)vid, out var v)) return null;
+ pts.Add(new Vector3(v.Origin.X, v.Origin.Y, v.Origin.Z));
+ }
+ return pts;
+ }
+
+ private static bool PointInPolygonOnPlane(Vector3 p, List poly, Vector3 n)
+ {
+ // Project onto the dominant plane axes and run 2D even-odd test.
+ Func proj;
+ var an = Vector3.Abs(n);
+ if (an.X >= an.Y && an.X >= an.Z) proj = v => new Vector2(v.Y, v.Z);
+ else if (an.Y >= an.Z) proj = v => new Vector2(v.X, v.Z);
+ else proj = v => new Vector2(v.X, v.Y);
+
+ var pt = proj(p);
+ bool inside = false;
+ for (int i = 0, j = poly.Count - 1; i < poly.Count; j = i++)
+ {
+ var a = proj(poly[i]); var bb = proj(poly[j]);
+ if (a.Y > pt.Y != bb.Y > pt.Y &&
+ pt.X < (bb.X - a.X) * (pt.Y - a.Y) / (bb.Y - a.Y) + a.X)
+ inside = !inside;
+ }
+ return inside;
+ }
+
+ private void ScanModelStairs(DatCollection dats, uint modelId)
+ {
+ if ((modelId & 0xFF000000u) == 0x01000000u)
+ {
+ ScanGfxStairs(dats, modelId, $"model 0x{modelId:X8}");
+ }
+ else if ((modelId & 0xFF000000u) == 0x02000000u)
+ {
+ var setup = dats.Get(modelId);
+ if (setup is null) { _out.WriteLine($"model 0x{modelId:X8}: Setup MISSING"); return; }
+ foreach (var partId in setup.Parts.Distinct())
+ ScanGfxStairs(dats, partId, $"model 0x{modelId:X8} part 0x{partId:X8}");
+ }
+ }
+
+ private void ScanGfxStairs(DatCollection dats, uint gfxId, string label)
+ {
+ var gfx = dats.Get(gfxId);
+ if (gfx is null) { _out.WriteLine($"{label}: GfxObj MISSING"); return; }
+ var flat = new List(); int ramps = 0; int polys = 0;
+ var min = new Vector3(float.MaxValue); var max = new Vector3(float.MinValue);
+ foreach (var poly in gfx.Polygons.Values)
+ {
+ if (poly.VertexIds.Count < 3) continue;
+ var pts = new List();
+ bool ok = true;
+ foreach (var vid in poly.VertexIds)
+ {
+ if (!gfx.VertexArray.Vertices.TryGetValue((ushort)vid, out var v)) { ok = false; break; }
+ var p = new Vector3(v.Origin.X, v.Origin.Y, v.Origin.Z);
+ pts.Add(p); min = Vector3.Min(min, p); max = Vector3.Max(max, p);
+ }
+ if (!ok) continue;
+ polys++;
+ var n = NewellNormal(pts);
+ if (n.LengthSquared() < 1e-10f) continue;
+ if (MathF.Abs(n.Z) > 0.9f) flat.Add(pts.Average(p => p.Z));
+ else if (MathF.Abs(n.Z) > 0.15f) ramps++;
+ }
+ var heights = flat.Select(h => MathF.Round(h, 1)).Distinct().OrderBy(h => h).ToList();
+ string verdict = (heights.Count > 4 || ramps > 2) ? " <== STAIR-ISH" : "";
+ _out.WriteLine(
+ $"{label}: polys={polys} ramps={ramps} AABB z {min.Z:F1}..{max.Z:F1} " +
+ $"flatHeights=[{string.Join(",", heights.Select(h => h.ToString("F1")))}]{verdict}");
+ }
+
+ private static Vector3 NewellNormal(List pts)
+ {
+ var n = Vector3.Zero;
+ for (int i = 0; i < pts.Count; i++)
+ {
+ var a = pts[i]; var b = pts[(i + 1) % pts.Count];
+ n.X += (a.Y - b.Y) * (a.Z + b.Z);
+ n.Y += (a.Z - b.Z) * (a.X + b.X);
+ n.Z += (a.X - b.X) * (a.Y + b.Y);
+ }
+ return n.LengthSquared() < 1e-10f ? Vector3.Zero : Vector3.Normalize(n);
+ }
+
+ private void DumpModelAabb(DatCollection dats, uint modelId)
+ {
+ if ((modelId & 0xFF000000u) == 0x01000000u)
+ {
+ var gfx = dats.Get(modelId);
+ if (gfx is null) { _out.WriteLine($" model 0x{modelId:X8}: GfxObj MISSING"); return; }
+ var (min, max, nVerts) = GfxAabb(gfx);
+ _out.WriteLine($" model 0x{modelId:X8} (GfxObj): verts={nVerts} AABB=({min.X:F1},{min.Y:F1},{min.Z:F1})..({max.X:F1},{max.Y:F1},{max.Z:F1}) span=({max.X - min.X:F1},{max.Y - min.Y:F1},{max.Z - min.Z:F1})");
+ }
+ else if ((modelId & 0xFF000000u) == 0x02000000u)
+ {
+ var setup = dats.Get(modelId);
+ if (setup is null) { _out.WriteLine($" model 0x{modelId:X8}: Setup MISSING"); return; }
+ var min = new Vector3(float.MaxValue); var max = new Vector3(float.MinValue);
+ int total = 0;
+ foreach (var partId in setup.Parts)
+ {
+ var gfx = dats.Get(partId);
+ if (gfx is null) continue;
+ var (pmin, pmax, n) = GfxAabb(gfx);
+ min = Vector3.Min(min, pmin); max = Vector3.Max(max, pmax); total += n;
+ }
+ _out.WriteLine($" model 0x{modelId:X8} (Setup, {setup.Parts.Count} parts, part frames NOT applied): verts={total} AABB≈({min.X:F1},{min.Y:F1},{min.Z:F1})..({max.X:F1},{max.Y:F1},{max.Z:F1})");
+ }
+ else _out.WriteLine($" model 0x{modelId:X8}: unknown namespace");
+ }
+
+ private static (Vector3 Min, Vector3 Max, int Count) GfxAabb(DatReaderWriter.DBObjs.GfxObj gfx)
+ {
+ var min = new Vector3(float.MaxValue); var max = new Vector3(float.MinValue);
+ int n = 0;
+ foreach (var kvp in gfx.VertexArray.Vertices)
+ {
+ var p = new Vector3(kvp.Value.Origin.X, kvp.Value.Origin.Y, kvp.Value.Origin.Z);
+ min = Vector3.Min(min, p); max = Vector3.Max(max, p); n++;
+ }
+ return (min, max, n);
+ }
+
+ private void DumpStairSignatureNear(DatCollection dats, uint gfxId, Vector3 placeAt, Vector3 boxMin, Vector3 boxMax)
+ {
+ var gfx = dats.Get(gfxId);
+ if (gfx is null) { _out.WriteLine($"GfxObj 0x{gfxId:X8} MISSING"); return; }
+
+ var flatHeights = new List();
+ int polysInBox = 0, ramps = 0;
+ foreach (var poly in gfx.Polygons.Values)
+ {
+ if (poly.VertexIds.Count < 3) continue;
+ var pts = new List();
+ bool ok = true;
+ foreach (var vid in poly.VertexIds)
+ {
+ if (!gfx.VertexArray.Vertices.TryGetValue((ushort)vid, out var v)) { ok = false; break; }
+ pts.Add(placeAt + new Vector3(v.Origin.X, v.Origin.Y, v.Origin.Z));
+ }
+ if (!ok) continue;
+ var c = pts.Aggregate(Vector3.Zero, (a, b) => a + b) / pts.Count;
+ if (!AabbContains(boxMin, boxMax, c, 0f)) continue;
+ polysInBox++;
+
+ var n = Vector3.Zero;
+ for (int i = 0; i < pts.Count; i++)
+ {
+ var a = pts[i]; var b = pts[(i + 1) % pts.Count];
+ n.X += (a.Y - b.Y) * (a.Z + b.Z);
+ n.Y += (a.Z - b.Z) * (a.X + b.X);
+ n.Z += (a.X - b.X) * (a.Y + b.Y);
+ }
+ if (n.LengthSquared() < 1e-10f) continue;
+ n = Vector3.Normalize(n);
+ if (MathF.Abs(n.Z) > 0.9f) flatHeights.Add(c.Z);
+ else if (MathF.Abs(n.Z) > 0.15f) ramps++;
+ }
+ var distinct = flatHeights.Select(h => MathF.Round(h, 2)).Distinct().OrderBy(h => h).ToList();
+ _out.WriteLine(
+ $"shell 0x{gfxId:X8} polys-in-box={polysInBox} ramps={ramps} " +
+ $"flat heights=[{string.Join(",", distinct.Select(h => h.ToString("F2")))}]");
+ _out.WriteLine(distinct.Count > 3
+ ? ">>> SHELL ITSELF HAS STAIR-LIKE GEOMETRY AT THE SPOT (multiple flat heights)"
+ : ">>> shell shows no stair signature at the spot");
+ }
+}