erik/acdream
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

Revert "feat(core): UCG W2 Task 3 — stab-list doorway hysteresis in ResolveCellId"

Browse source 
This reverts commit 2acd8f9e1d.
This commit is contained in:
Erik 2026-06-02 14:09:42 +02:00
parent 3e1d502101
commit d23d1f40dc
2 changed files with 0 additions and 246 deletions
Download patch file Download diff file Expand all files Collapse all files

43
src/AcDream.Core/Physics/PhysicsEngine.cs
View file

@ -1,6 +1,5 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
namespace AcDream.Core.Physics;
@ -52,27 +51,6 @@ public sealed class PhysicsEngine
float WorldOffsetX,
float WorldOffsetY);
/// <summary>
/// UCG W2b doorway-hysteresis band (metres) added to the foot-sphere radius when deciding
/// whether to HOLD the previous indoor cell at the indoor→outdoor seam. Must exceed the
/// ~10 cm push-back oscillation at the threshold (handoff §5: front-door 0170↔0031) while
/// still releasing on a genuine step-out. The single value the visual gate may tune.
/// </summary>
private const float DoorwayHoldMargin = 0.2f;
/// <summary>
/// UCG W2b: does the foot-sphere (at <paramref name="worldPos"/>, inflated to
/// <paramref name="radius"/>) overlap <paramref name="cell"/>'s containment BSP? Returns false
/// when the cell has no containment BSP (can't test ⇒ release, never hold forever).
/// Retail: CCellStruct::sphere_intersects_cell (acclient_2013_pseudo_c.txt:317666).
/// </summary>
private static bool SphereOverlapsEnvCell(World.Cells.EnvCell cell, Vector3 worldPos, float radius)
{
if (cell.ContainmentBsp?.Root is null) return false;
var local = Vector3.Transform(worldPos, cell.InverseWorldTransform);
return BSPQuery.SphereIntersectsCellBsp(cell.ContainmentBsp.Root, local, radius);
}
/// <summary>
/// Register a landblock with its terrain surface, indoor cells, portal
/// planes, and world-space origin offset.
@ -399,27 +377,6 @@ public sealed class PhysicsEngine
}
}
// UCG W2b — retail find_cell_list do_not_load_cells prune
// (acclient_2013_pseudo_c.txt:308829-308867). Retail drops from the candidate
// cell-array any cell that is neither the current cell nor in its stab list
// (VisibleCells). Adapted here as doorway hysteresis at the indoor→outdoor seam:
// if the previous membership answer is an indoor cell and the outdoor candidate
// is NOT in its stab list (outdoor landcells never are), HOLD the indoor cell
// while the foot-sphere still overlaps that cell's containment BSP expanded by
// DoorwayHoldMargin. The strict overlap check at the indoor branch (~line 340)
// just released (the center was pushed past the wall), but the expanded test holds
// us across the ~10 cm push-back oscillation at the threshold (handoff §5:
// 0170↔0031). Releases on a genuine step-out — by then the bare overlap is also
// false, so CheckBuildingTransit won't re-grab the cell next tick. Anti-ping-pong
// the #98 saga never had; fires only at the front-door seam (the cellar has no
// exit portal → it never falls through here → #98 cellar-up is untouched).
if (DataCache?.CellGraph.CurrCell is World.Cells.EnvCell prevCell
&& !prevCell.StabList.Contains(outdoorCellId)
&& SphereOverlapsEnvCell(prevCell, worldPos, sphereRadius + DoorwayHoldMargin))
{
return SetCurrAndReturn(prevCell.Id);
}
return SetCurrAndReturn(outdoorCellId);
}
}

203
tests/AcDream.Core.Tests/Physics/CellGraphMembershipTests.cs
View file

@ -1,13 +1,10 @@
using System;
using System.Collections.Generic;
using System.Numerics;
using AcDream.Core.Physics;
using AcDream.Core.World.Cells;
using DatReaderWriter.Enums;
using DatReaderWriter.Types;
using Xunit;
using DatEnvCell = DatReaderWriter.DBObjs.EnvCell;
using UcgCellPortal = AcDream.Core.World.Cells.CellPortal;
namespace AcDream.Core.Tests.Physics;
@ -39,204 +36,4 @@ public class CellGraphMembershipTests
Assert.Equal(result, cache.CellGraph.CurrCell!.Id);
Assert.Equal(0xA9B40174u, cache.CellGraph.CurrCell!.Id);
}
// ── UCG W2 Task 3 — stab-list doorway hysteresis tests ───────────────────
//
// Geometry: indoor cell 0xA9B40175 with a CellBSP splitting plane at Y=3.5,
// normal (0,-1,0). The interior is Y ≤ 3.5 (positive side of the plane).
//
// SphereIntersectsCellBsp with radius=0.3 fails (returns false) when:
// dist = dot((0,-1,0), center) + 3.5 = 3.5 - center.Y < -(0.3 + 0.01) = -0.31
// i.e. center.Y > 3.81
//
// SphereIntersectsCellBsp with expanded radius=0.3+0.2=0.5 fails when:
// center.Y > 3.5 + 0.51 = 4.01
//
// So the hysteresis band is Y ∈ (3.81, 4.01]:
// - Strict check failed (falls through to outdoor)
// - Expanded check passes (hold the indoor cell)
//
// Test positions:
// Y=3.9 → strict fails, expanded holds → hysteresis HOLD
// Y=4.5 → both fail → genuine step-out, RELEASE
//
// The landblock is registered at worldOffset=(0,0) so localX=worldPos.X,
// localY=worldPos.Y. At X=0, Y=3.9: cx=0, cy=0 → lowCellId=1 →
// outdoorCellId = 0xA9B40001.
//
// Retail anchor: CObjCell::find_cell_list do_not_load_cells prune
// (acclient_2013_pseudo_c.txt:308829-308867).
private const uint DoorwayIndoorId = 0xA9B40175u;
private const uint DoorwayLbId = 0xA9B40000u;
private const float SphereRadius = 0.3f;
// Y at which strict check fails but expanded (margin=0.2) still holds.
private static readonly Vector3 HoldPos = new(0f, 3.9f, 95f);
// Y at which both strict and expanded fail (genuine step-out).
private static readonly Vector3 ReleasedPos = new(0f, 4.5f, 95f);
/// <summary>
/// Builds the engine+cache+prevCell fixture shared by the three hysteresis tests.
/// <paramref name="stabList"/> controls whether the outdoor candidate is in the stab list.
/// <paramref name="setCurrCell"/> controls whether CellGraph.CurrCell is pre-set to prev.
/// Returns the engine, cache, and the EnvCell registered as the previous indoor membership.
/// </summary>
private static (PhysicsEngine engine, PhysicsDataCache cache, EnvCell prev)
BuildDoorwayFixture(IReadOnlyList<uint> stabList, bool setCurrCell = true)
{
var cache = new PhysicsDataCache();
var engine = new PhysicsEngine { DataCache = cache };
// ── CellBSP: plane at Y=3.5 with normal (0,-1,0) ─────────────────
// Interior is at Y ≤ 3.5 (positive-side leaf).
// SphereIntersectsCellBsp(root, center, r) checks:
// dist = dot((0,-1,0), center) + 3.5 = 3.5 - center.Y
// if dist < -(r + 0.01) → sphere is fully outside → return false
var cellBspLeaf = new CellBSPNode { Type = BSPNodeType.Leaf };
var cellBspRoot = new CellBSPNode
{
SplittingPlane = new Plane(new Vector3(0f, -1f, 0f), 3.5f),
PosNode = cellBspLeaf,
};
var cellBsp = new CellBSPTree { Root = cellBspRoot };
// ── CellPhysics registered for the indoor sphere-check branch ─────
// This is what ResolveCellId's indoor branch looks up via GetCellStruct.
// We set CellBSP to cellBsp so the overlap test uses it.
var indoorCell = new CellPhysics
{
BSP = new PhysicsBSPTree { Root = new PhysicsBSPNode { Type = BSPNodeType.Leaf } },
WorldTransform = Matrix4x4.Identity,
InverseWorldTransform = Matrix4x4.Identity,
Resolved = new Dictionary<ushort, ResolvedPolygon>(),
CellBSP = cellBsp,
Portals = Array.Empty<PortalInfo>(),
PortalPolygons = new Dictionary<ushort, ResolvedPolygon>(),
VisibleCellIds = new System.Collections.Generic.HashSet<uint>(),
};
cache.RegisterCellStructForTest(DoorwayIndoorId, indoorCell);
// ── EnvCell in the CellGraph with the same ContainmentBsp ─────────
// This is what the hysteresis prune reads from CellGraph.CurrCell.
// We use the SAME cellBsp instance so the test geometry is consistent.
var prev = new EnvCell(
id: DoorwayIndoorId,
worldTransform: Matrix4x4.Identity,
inverseWorldTransform: Matrix4x4.Identity,
localBoundsMin: new Vector3(-20f, -20f, -20f),
localBoundsMax: new Vector3(20f, 20f, 20f),
portals: Array.Empty<UcgCellPortal>(),
stabList: stabList,
seenOutside: true,
containmentBsp: cellBsp);
cache.CellGraph.Add(prev);
if (setCurrCell)
cache.CellGraph.CurrCell = prev;
// ── Stub landblock: terrain far below, worldOffset=(0,0) ──────────
// worldPos.X, worldPos.Y map directly to localX, localY.
// At X=0, Y=3.9: cx=0, cy=0 → lowCellId=1 → outdoorCellId=0xA9B40001.
var heights = new byte[81];
var heightTable = new float[256];
for (int i = 0; i < 256; i++) heightTable[i] = -1000f;
var stubTerrain = new TerrainSurface(heights, heightTable);
engine.AddLandblock(
landblockId: DoorwayLbId,
terrain: stubTerrain,
cells: Array.Empty<CellSurface>(),
portals: Array.Empty<PortalPlane>(),
worldOffsetX: 0f,
worldOffsetY: 0f);
return (engine, cache, prev);
}
/// <summary>
/// UCG W2 Task 3 — HOLD (the RED→GREEN test).
///
/// Position Y=3.9 is inside the hysteresis band:
/// - The strict overlap check (radius=0.3) fails → indoor branch falls through to outdoor.
/// - The expanded check (radius=0.3+0.2=0.5) still passes → hold the indoor cell.
/// - The outdoor candidate (0xA9B40001) is NOT in the stab list → prune fires.
///
/// Expected: ResolveCellId returns 0xA9B40175 (held indoor).
/// Before the fix: returns 0xA9B40001 (outdoor — ping-pong side).
/// After the fix: returns 0xA9B40175 (held indoor — anti-ping-pong).
///
/// Retail anchor: CObjCell::find_cell_list do_not_load_cells prune
/// (acclient_2013_pseudo_c.txt:308829-308867).
/// </summary>
[Fact]
public void ResolveCellId_DoorwayHysteresis_HoldsIndoorWhenInsideMargin()
{
var (engine, _, _) = BuildDoorwayFixture(
stabList: Array.Empty<uint>(),
setCurrCell: true);
uint result = engine.ResolveCellId(HoldPos, SphereRadius, DoorwayIndoorId);
Assert.Equal(DoorwayIndoorId, result);
}
/// <summary>
/// UCG W2 Task 3 — RELEASE when fully outside (genuine step-out).
///
/// Position Y=4.5 exceeds the expanded margin (4.01) — both the strict
/// and expanded overlap checks fail. The prune must NOT hold — the player
/// genuinely stepped out.
///
/// Expected: ResolveCellId returns an outdoor cell id (low 16 bits &lt; 0x100)
/// that is NOT 0xA9B40175.
/// </summary>
[Fact]
public void ResolveCellId_DoorwayHysteresis_ReleasesWhenFullyOutside()
{
var (engine, _, _) = BuildDoorwayFixture(
stabList: Array.Empty<uint>(),
setCurrCell: true);
uint result = engine.ResolveCellId(ReleasedPos, SphereRadius, DoorwayIndoorId);
// Must be an outdoor cell (low 16 bits < 0x100) and not the indoor cell.
Assert.NotEqual(DoorwayIndoorId, result);
Assert.True((result & 0xFFFFu) < 0x100u,
$"Expected an outdoor cell (low 16 < 0x100), got 0x{result:X8}");
}
/// <summary>
/// UCG W2 Task 3 — RELEASE when candidate is visible (stab-list gate).
///
/// The prune only fires when the outdoor candidate is NOT in the previous
/// indoor cell's stab list. If the candidate IS in the stab list (genuinely
/// visible from the indoor cell), the transition should proceed normally —
/// hysteresis must not block it.
///
/// Expected: ResolveCellId returns the outdoor cell id even though Y=3.9
/// is inside the hysteresis band.
/// </summary>
[Fact]
public void ResolveCellId_DoorwayHysteresis_ReleasesWhenCandidateIsInStabList()
{
// Step 1: determine the outdoor id the engine picks at Y=3.9
// by running with CurrCell=null (no hysteresis).
var (engineNull, _, _) = BuildDoorwayFixture(
stabList: Array.Empty<uint>(),
setCurrCell: false);
uint outdoorId = engineNull.ResolveCellId(HoldPos, SphereRadius, DoorwayIndoorId);
// Sanity: must be outdoor (low 16 < 0x100).
Assert.True((outdoorId & 0xFFFFu) < 0x100u,
$"Expected outdoor fallback id (low 16 < 0x100), got 0x{outdoorId:X8}");
// Step 2: build a fresh fixture with the outdoor id IN the stab list.
var (engine, _, _) = BuildDoorwayFixture(
stabList: new uint[] { outdoorId },
setCurrCell: true);
uint result = engine.ResolveCellId(HoldPos, SphereRadius, DoorwayIndoorId);
// Stab-list gate: outdoor candidate is visible → prune must NOT hold.
Assert.Equal(outdoorId, result);
}
}