T6 (BR-7) C3: per-cell shadow architecture - flood registration, building channel, per-cell query; b3ce505 stopgap DELETED (closes #99)
The A6.P4 port, fused into one installment per the BR-2 half-port lesson
(registration and query are co-dependent: flood-registering shells under
the old radial query would re-open #98 through the vestibule).
REGISTRATION (ShadowObjectRegistry rewritten):
- Register/RegisterMultiPart/UpdatePosition compute the cell set via
CellTransit.BuildShadowCellSet (the C2 find_cell_list flood) seeded by
the entity's m_position cell id; the private 24m XY-grid rectangle and
its single-landblock clamp are deleted. Flood spheres follow retail's
CylSphere rule (base point + cyl radius, cap 10; BSP bounding-sphere
fallback - Ghidra 0x0052b9f0). Statics flood with the do_not_load
prune; dynamics (server spawns, isStatic:false) without.
- Keep-when-empty (SetPositionInternal num_cells gate, pc:283540): a
failed flood leaves the previous registration in place.
- RefloodLandblock: streaming-race hook re-runs the flood when a
landblock's cells hydrate (retail init_objects -> recalc_cross_cells,
Ghidra 0x0052b420/0x00515a30); wired at GameWindow's hydration tail.
- GameWindow sites pass the server position's full cell id as the seed
(spawn + UpdatePosition); the five static sites pass ParentCellId.
BUILDING CHANNEL (CSortCell.building shape):
- Building SHELLS are not shadow objects in retail (only caller of
find_building_collisions is CSortCell::find_collisions 0x005340aa;
one building per origin landcell, init_buildings 0x0052fd80 verified
verbatim + ACE cross-ref). IsBuildingShell entities skip the registry;
Transition.FindBuildingCollisions runs the shell part-0 BSP off
cache.GetBuilding(cellId) with bldg_check set around it
(find_building_collisions 0x006b5300), CollidedWithEnvironment on
non-Contact non-OK. BuildingPhysics.ModelId = pre-resolved part-0
GfxObj (0x02 Setups resolved at the CacheBuilding site).
- Placement/ethereal weakening: BSPQuery Path 1 passes center_solid=0
when BldgCheck && HitsInteriorCell (BSPTREE::find_collisions 0x0053a82e
+ placement_insert 0x005399d8) so doorway crossings don't hard-fail
against shell solids. SpherePath gains both retail fields;
HitsInteriorCell is rebuilt at every cell-array build
(build_cell_array reset 0x00509ef2 + find_cell_list/check_building_
transit set sites).
QUERY (retail per-cell order, transitional_insert 0x0050b6f0):
- TransitionalInsert per attempt: env -> building (LandCell only) ->
objects on the PRIMARY cell, then on OK the check_other_cells pass
(env -> building -> objects per OTHER overlapped cell) + the
carried-cell advance - the advance now happens AFTER all per-cell
object passes (the WF1 ordering divergence), with Adjusted/Slid
feeding the retry exactly like retail's OK_TS case.
- FindObjCollisionsInCell = CObjCell::find_obj_collisions (0x0052b750):
iterate ONLY the asked cell's list. DELETED: the radial 9-landblock
sweep, the +5m query pad, the b3ce505 indoor-primary gate, and the
isViewer exemption (the camera is bounded by interior cell-BSP env
collision - retail's own channel; CameraCornerSealReplayTests pins it
against real dat, and the new building-channel camera test pins the
outdoor stop).
TESTS: Core 1416/0/2 (was 1398 + 4 pre-existing #99-era fails + 1 skip),
App 225, UI 420, Net 294 - all green.
- 3 of the 4 #99-era reds flipped green as designed: the door apparatus
(Apparatus_Grounded_50cmOffCenter_FrontApproach_Blocks) and tick-13558
(indoor walkthrough) now assert the door BLOCKS; tick-22760 pins the
outdoor blocking invariant.
- The 4th (BSPStepUp D4) + 22760's lateral-slide delta are NOT cell-set
problems (probes prove the door is found + BSP-only dispatched;
BR-7 left both byte-identical) - filed as issue #116 (slide-response
family), D4 skipped with the issue reference.
- FindEnvCollisionsMultiCellTests migrated to the public entry (the A4
multi-cell halt now lives at the retail call site).
- New registry pins: per-cell query surface, outdoor-footprint-never-
indoor (#98 architectural), door-outdoor-cell membership, reflood.
- CameraCollisionIndoorTests rewritten against the building channel
(the isViewer-exemption pins died with the exemption).
Closes #99 (doors block both ways via registration-time cell membership
+ the straddle-spanning player cell array). #97 likely closed (the +5m
radial pad that produced phantom-collision candidates is gone) - verify
at T5. #98 stays closed ARCHITECTURALLY (outdoor footprints structurally
cannot reach interior cells; the cellar harness stays green).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Erik
parent
abf36e2743
commit
dbfbf8506c
15 changed files with 1109 additions and 856 deletions
|
|
@ -546,7 +546,14 @@ public class BSPStepUpTests
|
|||
/// every frame replays the same hard stop and the character hangs in falling
|
||||
/// animation until another correction breaks the loop.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
[Fact(Skip = "Issue #116 — slide-response divergence family (P1-era " +
|
||||
"slide_sphere work made the first airborne wall frame slide in-frame " +
|
||||
"to Z=1.92 instead of the L.2c-pinned hard stop at Z=2.0; the cached " +
|
||||
"sliding-normal mechanism retail seeds via get_object_info " +
|
||||
"(pc:279992, transient bit 4 → init_sliding_normal) only governs the " +
|
||||
"NEXT frame, so which first-frame response is retail-faithful needs " +
|
||||
"its own oracle read. NOT a cell-set problem — BR-7/A6.P4 left this " +
|
||||
"byte-identical. See docs/ISSUES.md #116.")]
|
||||
public void D4_AirborneMover_TallWall_PersistsSlidingNormalAcrossFrames()
|
||||
{
|
||||
var (root, resolved) = BSPStepUpFixtures.TallWall();
|
||||
|
|
|
|||
|
|
@ -1177,11 +1177,13 @@ public class CellarUpTrajectoryReplayTests : IDisposable
|
|||
landblockId: 0xA9B40000u,
|
||||
collisionType: ShadowCollisionType.BSP,
|
||||
scale: 1.0f,
|
||||
// Landblock-baked statics in production (GameWindow.cs:5899) use
|
||||
// `entity.ParentCellId ?? 0u` — the cottage building has no
|
||||
// ParentCellId (it's a top-level landblock static), so the
|
||||
// scope is landblock-wide (cellScope=0).
|
||||
cellScope: 0u);
|
||||
// BR-7: outdoor seed derived from the world position. (In
|
||||
// production the cottage SHELL no longer registers as a shadow
|
||||
// object at all — it dispatches via the per-LandCell building
|
||||
// channel; this fixture keeps the shadow registration to pin the
|
||||
// #98 regression shape: an outdoor-registered footprint must
|
||||
// stay invisible to fully-interior cellar queries.)
|
||||
seedCellId: 0u);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
|
|
|||
|
|
@ -87,9 +87,24 @@ public class DoorBugTrajectoryReplayTests
|
|||
var datDir = ResolveDatDir();
|
||||
if (datDir is null) return;
|
||||
|
||||
// BR-7 / A6.P4 (2026-06-11) — FLIPPED from match-the-capture to
|
||||
// assert-the-fix. The capture IS the #99 bug (live walked through:
|
||||
// cnValid=false, position == target past the slab). The per-cell
|
||||
// shadow architecture makes the door reachable from the indoor
|
||||
// side (the straddling sphere's cell array spans both threshold
|
||||
// cells; retail "covered twice", wf1-interior-collision.md), so
|
||||
// the replay must now BLOCK: a collision fires and the sphere
|
||||
// cannot cross the slab's BSP Y-range [16.848, 17.109].
|
||||
var (engine, _) = BuildEngineWithDoorFixture(datDir);
|
||||
var captured = LoadCapturedRecord(r => r.Tick == 13558);
|
||||
AssertCallMatchesCapture(engine, captured);
|
||||
var (result, _) = ReplayCapturedCall(engine, captured);
|
||||
|
||||
Assert.True(result.CollisionNormalValid,
|
||||
$"Door must block the indoor-side off-center approach (#99 closed); " +
|
||||
$"pos=({result.Position.X:F4},{result.Position.Y:F4},{result.Position.Z:F4})");
|
||||
Assert.True(result.Position.Y <= 17.0f,
|
||||
$"Sphere must not cross the slab; pos.Y={result.Position.Y:F4} " +
|
||||
$"(capture's walkthrough reached 17.2041)");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
|
@ -107,9 +122,28 @@ public class DoorBugTrajectoryReplayTests
|
|||
var datDir = ResolveDatDir();
|
||||
if (datDir is null) return;
|
||||
|
||||
// BR-7 / A6.P4 (2026-06-11) — narrowed from full-capture match to
|
||||
// the blocking invariant. The capture (the WORKING outdoor side)
|
||||
// blocked Y at 18.0183 and slid the tiny lateral component
|
||||
// (X -0.0357, cn=(0,+1,0)). The harness blocks Y identically but
|
||||
// LOSES the near-perpendicular lateral slide (degenerate-offset
|
||||
// guard in the slide response converts it to a hard stop,
|
||||
// cn=(0,0,1) from the post-stop ground refresh). That residual is
|
||||
// filed as issue #116 (slide-response, NOT a cell-set problem —
|
||||
// the [bsp-test]/[cyl-skip-bsp] probes show the door found +
|
||||
// BSP-only dispatched correctly; see
|
||||
// Diagnostic_Tick22760_DumpEngineInternals). The invariant this
|
||||
// pin protects: the door BLOCKS from the outdoor side.
|
||||
var (engine, _) = BuildEngineWithDoorFixture(datDir);
|
||||
var captured = LoadCapturedRecord(r => r.Tick == 22760);
|
||||
AssertCallMatchesCapture(engine, captured);
|
||||
var (result, _) = ReplayCapturedCall(engine, captured);
|
||||
|
||||
Assert.True(result.CollisionNormalValid,
|
||||
$"Door must block the outdoor-side approach; " +
|
||||
$"pos=({result.Position.X:F4},{result.Position.Y:F4},{result.Position.Z:F4})");
|
||||
Assert.True(result.Position.Y >= 17.95f,
|
||||
$"Sphere must not penetrate southward past the slab; " +
|
||||
$"pos.Y={result.Position.Y:F4} (live blocked at 18.0183)");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
|
@ -119,6 +153,63 @@ public class DoorBugTrajectoryReplayTests
|
|||
/// to see the engine's internal decisions on the failing tick.
|
||||
/// Always passes (diagnostic-only).
|
||||
/// </summary>
|
||||
/// <summary>
|
||||
/// BR-7 diagnostic twin for tick 22760 (outdoor-side block). Live slid
|
||||
/// along the door face (cn=(0,1,0), X free); the harness has historically
|
||||
/// hard-stopped with cn=(0,0,1). Always passes; read the console dump.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void Diagnostic_Tick22760_DumpEngineInternals()
|
||||
{
|
||||
var datDir = ResolveDatDir();
|
||||
if (datDir is null) return;
|
||||
|
||||
PhysicsDiagnostics.ProbeResolveEnabled = true;
|
||||
PhysicsDiagnostics.ProbeBuildingEnabled = true;
|
||||
PhysicsDiagnostics.ProbeIndoorBspEnabled = true;
|
||||
PhysicsDiagnostics.ProbePushBackEnabled = true;
|
||||
PhysicsDiagnostics.ProbeStepWalkEnabled = true;
|
||||
try
|
||||
{
|
||||
var (engine, _) = BuildEngineWithDoorFixture(datDir);
|
||||
var captured = LoadCapturedRecord(r => r.Tick == 22760);
|
||||
var body = SeedBodyFromSnapshot(captured.BodyBefore!);
|
||||
|
||||
Console.WriteLine("=== Replay tick 22760 (outdoor-side block) ===");
|
||||
var result = engine.ResolveWithTransition(
|
||||
currentPos: captured.Input.CurrentPos,
|
||||
targetPos: captured.Input.TargetPos,
|
||||
cellId: captured.Input.CellId,
|
||||
sphereRadius: captured.Input.SphereRadius,
|
||||
sphereHeight: captured.Input.SphereHeight,
|
||||
stepUpHeight: captured.Input.StepUpHeight,
|
||||
stepDownHeight: captured.Input.StepDownHeight,
|
||||
isOnGround: captured.Input.IsOnGround,
|
||||
body: body,
|
||||
moverFlags: (ObjectInfoState)captured.Input.MoverFlags,
|
||||
movingEntityId: captured.Input.MovingEntityId);
|
||||
|
||||
Console.WriteLine(string.Format(System.Globalization.CultureInfo.InvariantCulture,
|
||||
"=== Harness: pos=({0:F4},{1:F4},{2:F4}) cn=({3:F4},{4:F4},{5:F4}) cnValid={6} onGround={7} cell=0x{8:X8}",
|
||||
result.Position.X, result.Position.Y, result.Position.Z,
|
||||
result.CollisionNormal.X, result.CollisionNormal.Y, result.CollisionNormal.Z,
|
||||
result.CollisionNormalValid, result.IsOnGround, result.CellId));
|
||||
Console.WriteLine(string.Format(System.Globalization.CultureInfo.InvariantCulture,
|
||||
"=== Live: pos=({0:F4},{1:F4},{2:F4}) cn=({3:F4},{4:F4},{5:F4}) cnValid={6} onGround={7} cell=0x{8:X8}",
|
||||
captured.Result.Position.X, captured.Result.Position.Y, captured.Result.Position.Z,
|
||||
captured.Result.CollisionNormal.X, captured.Result.CollisionNormal.Y, captured.Result.CollisionNormal.Z,
|
||||
captured.Result.CollisionNormalValid, captured.Result.IsOnGround, captured.Result.CellId));
|
||||
}
|
||||
finally
|
||||
{
|
||||
PhysicsDiagnostics.ProbeResolveEnabled = false;
|
||||
PhysicsDiagnostics.ProbeBuildingEnabled = false;
|
||||
PhysicsDiagnostics.ProbeIndoorBspEnabled = false;
|
||||
PhysicsDiagnostics.ProbePushBackEnabled = false;
|
||||
PhysicsDiagnostics.ProbeStepWalkEnabled = false;
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Diagnostic_Tick13558_DumpEngineInternals()
|
||||
{
|
||||
|
|
@ -412,7 +503,7 @@ public class DoorBugTrajectoryReplayTests
|
|||
landblockId: DoorLandblockId,
|
||||
collisionType: ShadowCollisionType.BSP,
|
||||
scale: 1.0f,
|
||||
cellScope: 0u);
|
||||
seedCellId: 0u);
|
||||
|
||||
// Replay captured tick 3254 inputs exactly.
|
||||
var currentPos = new Vector3(133.65524f, 17.58999f, 94f);
|
||||
|
|
@ -480,7 +571,7 @@ public class DoorBugTrajectoryReplayTests
|
|||
landblockId: DoorLandblockId,
|
||||
collisionType: ShadowCollisionType.BSP,
|
||||
scale: 1.0f,
|
||||
cellScope: 0u);
|
||||
seedCellId: 0u);
|
||||
|
||||
// 2. Load cell 0xA9B40150 BSP into cache (the alcove walls).
|
||||
const uint AlcoveCellId = 0xA9B40150u;
|
||||
|
|
@ -1102,6 +1193,34 @@ public class DoorBugTrajectoryReplayTests
|
|||
CellarUpTrajectoryReplayTests.CaptureJsonOptions)!;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Replays one captured ResolveWithTransition call against
|
||||
/// <paramref name="engine"/>, seeded with bodyBefore, and returns the
|
||||
/// harness result for invariant-style assertions (BR-7 flips).
|
||||
/// </summary>
|
||||
private static (ResolveResult result, PhysicsBody body) ReplayCapturedCall(
|
||||
PhysicsEngine engine,
|
||||
ResolveCaptureRecord captured)
|
||||
{
|
||||
Assert.NotNull(captured.BodyBefore);
|
||||
var body = SeedBodyFromSnapshot(captured.BodyBefore!);
|
||||
|
||||
var result = engine.ResolveWithTransition(
|
||||
currentPos: captured.Input.CurrentPos,
|
||||
targetPos: captured.Input.TargetPos,
|
||||
cellId: captured.Input.CellId,
|
||||
sphereRadius: captured.Input.SphereRadius,
|
||||
sphereHeight: captured.Input.SphereHeight,
|
||||
stepUpHeight: captured.Input.StepUpHeight,
|
||||
stepDownHeight: captured.Input.StepDownHeight,
|
||||
isOnGround: captured.Input.IsOnGround,
|
||||
body: body,
|
||||
moverFlags: (ObjectInfoState)captured.Input.MoverFlags,
|
||||
movingEntityId: captured.Input.MovingEntityId);
|
||||
|
||||
return (result, body);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Replays one captured ResolveWithTransition call against
|
||||
/// <paramref name="engine"/>, seeded with bodyBefore, and reports
|
||||
|
|
|
|||
|
|
@ -209,8 +209,13 @@ public class DoorCollisionApparatusTests
|
|||
/// sphere walks through — exactly what the user reports in the
|
||||
/// live Holtburg session 2026-05-24.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// BR-7 / A6.P4 (2026-06-11) — FLIPPED from documents-the-bug to
|
||||
/// asserts-the-fix: with the per-cell shadow architecture the door is
|
||||
/// found from every overlapped cell and this approach now blocks.
|
||||
/// </remarks>
|
||||
[Fact]
|
||||
public void Apparatus_Grounded_50cmOffCenter_FrontApproach_DocumentsBug()
|
||||
public void Apparatus_Grounded_50cmOffCenter_FrontApproach_Blocks()
|
||||
{
|
||||
if (!TryBuildScenario(out var ctx)) return;
|
||||
|
||||
|
|
@ -282,19 +287,19 @@ public class DoorCollisionApparatusTests
|
|||
_out.WriteLine($"Final pos = ({pos.X:F3}, {pos.Y:F3}, {pos.Z:F3}) after {ticks + 1} ticks; blocked={blocked}");
|
||||
_out.WriteLine($"Grounded={isOnGround}");
|
||||
|
||||
// EXPECTED FAILURE (documents-the-bug): the grounded sphere walks
|
||||
// straight through, reaching the far side at Y > 12.30. When the
|
||||
// fix lands, flip this to Assert.True(blocked) — same shape as
|
||||
// the Path-6 apparatus tests above.
|
||||
// FLIPPED (BR-7 / A6.P4, 2026-06-11): this test documented the #99
|
||||
// walk-through; the per-cell shadow architecture closes it. The
|
||||
// grounded Path-5 approach must now BLOCK before the slab
|
||||
// (Y < 12.0) — the same shape as the Path-6 apparatus tests above.
|
||||
PhysicsDiagnostics.ProbeResolveEnabled = false;
|
||||
PhysicsDiagnostics.ProbeBuildingEnabled = false;
|
||||
Env.SetEnvironmentVariable("ACDREAM_DUMP_STEPUP", null);
|
||||
|
||||
Assert.True(pos.Y > 12.30f,
|
||||
$"This test documents the production bug. If this is failing " +
|
||||
$"because the sphere now blocks, the door fix worked — flip " +
|
||||
$"the assertion to Assert.True(blocked) and Assert.True(pos.Y < 12.0f). " +
|
||||
Assert.True(blocked,
|
||||
$"Door must block the grounded off-center approach (#99 closed). " +
|
||||
$"Current pos=({pos.X:F3},{pos.Y:F3},{pos.Z:F3}) blocked={blocked}");
|
||||
Assert.True(pos.Y < 12.0f,
|
||||
$"Sphere must stop before the slab; pos.Y={pos.Y:F3}");
|
||||
}
|
||||
|
||||
// ───────────────────────────────────────────────────────────────
|
||||
|
|
|
|||
|
|
@ -128,21 +128,22 @@ public class FindEnvCollisionsMultiCellTests
|
|||
stepUpHeight: 0.04f,
|
||||
cellId: VestibuleCellId);
|
||||
|
||||
// SetCheckPos sets the candidate position FindEnvCollisions evaluates.
|
||||
t.SpherePath.SetCheckPos(to, VestibuleCellId);
|
||||
|
||||
// ── Act ───────────────────────────────────────────────────────────
|
||||
// Call FindEnvCollisions directly (now internal). Bypasses
|
||||
// FindTransitionalPosition's sub-step iteration so we can assert on
|
||||
// the single result.
|
||||
var result = t.FindEnvCollisions(engine);
|
||||
// BR-7 / A6.P4 (2026-06-11): the other-cells pass moved from
|
||||
// FindEnvCollisions into TransitionalInsert Phase 2.5 (retail
|
||||
// transitional_insert's OK_TS case, Ghidra 0x0050b756: the primary
|
||||
// insert runs env → building → objects, THEN check_other_cells).
|
||||
// Drive the public entry so the full per-attempt order runs.
|
||||
t.FindTransitionalPosition(engine);
|
||||
|
||||
// ── Assert ────────────────────────────────────────────────────────
|
||||
// Pre-A4: empty vestibule BSP returns OK, interior is never queried,
|
||||
// result == OK (sphere walks through the wall).
|
||||
// Post-A4: CheckOtherCells iterates the interior cell, BSPQuery on
|
||||
// TallWall returns Slid (the wall-slide path matching B2), and
|
||||
// FindEnvCollisions returns Slid via ApplyOtherCellResult.
|
||||
Assert.NotEqual(TransitionState.OK, result);
|
||||
// and the sphere walks through the wall to x=0.7.
|
||||
// Post-A4 (now via Phase 2.5's CheckOtherCells): the interior cell's
|
||||
// TallWall halts/slides the sphere — its center cannot pass
|
||||
// wall-X (0.8 world) minus the sphere radius (0.2) = 0.6.
|
||||
Assert.True(t.SpherePath.CurPos.X <= 0.6f + PhysicsGlobals.EPSILON * 20f,
|
||||
$"Adjacent cell's wall must block the sphere at world x≈0.6; " +
|
||||
$"CurPos.X={t.SpherePath.CurPos.X:F4} (walked through = A4 regression).");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -114,49 +114,48 @@ public class ShadowObjectRegistryTests
|
|||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// GetNearbyObjects
|
||||
// Per-cell query surface (BR-7 / A6.P4 2026-06-11): GetObjectsInCell IS
|
||||
// the query — retail CObjCell::find_obj_collisions iterates only the
|
||||
// asked cell's shadow_object_list (Ghidra 0x0052b750). The former
|
||||
// radial GetNearbyObjects sweep is deleted; cell membership is the
|
||||
// broad phase.
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
[Fact]
|
||||
public void GetNearbyObjects_QueryCoversEntity_ReturnsIt()
|
||||
public void PerCellQuery_EntityCell_ReturnsIt()
|
||||
{
|
||||
var reg = new ShadowObjectRegistry();
|
||||
reg.Register(10u, 0x01000005u, new Vector3(30f, 30f, 50f), Quaternion.Identity, 1f, OffX, OffY, LbId);
|
||||
|
||||
var results = new List<ShadowEntry>();
|
||||
reg.GetNearbyObjects(new Vector3(30f, 30f, 50f), 5f, OffX, OffY, LbId, results);
|
||||
|
||||
// local (30,30) → landcell (1,1) → 1*8+1+1 = 10.
|
||||
var results = reg.GetObjectsInCell(LbId | 10u);
|
||||
Assert.Single(results);
|
||||
Assert.Equal(10u, results[0].EntityId);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetNearbyObjects_QueryFarFromEntity_ReturnsEmpty()
|
||||
public void PerCellQuery_FarCell_ReturnsEmpty()
|
||||
{
|
||||
var reg = new ShadowObjectRegistry();
|
||||
// Entity at local (12, 12) — cell (0,0).
|
||||
reg.Register(11u, 0x01000006u, new Vector3(12f, 12f, 50f), Quaternion.Identity, 1f, OffX, OffY, LbId);
|
||||
|
||||
var results = new List<ShadowEntry>();
|
||||
// Query at local (180, 180) — cell (7,7) — far away.
|
||||
reg.GetNearbyObjects(new Vector3(180f, 180f, 50f), 5f, OffX, OffY, LbId, results);
|
||||
|
||||
Assert.Empty(results);
|
||||
// Cell (7,7) — far away. No spatial radius can reach across cells.
|
||||
Assert.Empty(reg.GetObjectsInCell(LbId | 64u));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetNearbyObjects_EntityInMultipleCells_ReturnedOnce()
|
||||
public void PerCellQuery_EntityInMultipleCells_OncePerCellList()
|
||||
{
|
||||
// Entity spans cells 0,0 and 1,0 (local X≈24, radius=2).
|
||||
// Entity spans cells (0,0) and (1,0) (local X≈24, radius=2) via the
|
||||
// flood's boundary-neighbor adds. Each overlapped cell's list holds
|
||||
// the entry exactly once — retail tests an object once per iterated
|
||||
// cell (no cross-cell dedup exists in find_obj_collisions).
|
||||
var reg = new ShadowObjectRegistry();
|
||||
reg.Register(20u, 0x01000007u, new Vector3(24f, 12f, 50f), Quaternion.Identity, 2f, OffX, OffY, LbId);
|
||||
|
||||
var results = new List<ShadowEntry>();
|
||||
// Large query covers both cells; entity must appear exactly once.
|
||||
reg.GetNearbyObjects(new Vector3(24f, 12f, 50f), 10f, OffX, OffY, LbId, results);
|
||||
|
||||
Assert.Single(results);
|
||||
Assert.Equal(20u, results[0].EntityId);
|
||||
Assert.Single(reg.GetObjectsInCell(LbId | 1u), e => e.EntityId == 20u);
|
||||
Assert.Single(reg.GetObjectsInCell(LbId | 9u), e => e.EntityId == 20u);
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
|
|
@ -303,71 +302,151 @@ public class ShadowObjectRegistryTests
|
|||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// A6.P4 slice 1 — portalReachableCells set includes outdoor cells
|
||||
// when sphere straddles an exit portal (issue #99)
|
||||
// BR-7 / A6.P4 (2026-06-11) — registration-side architecture pins.
|
||||
// The former query-side compensations (the b3ce505 indoor gate, the
|
||||
// portalReachableCells expansion, the isViewer exemption) are deleted;
|
||||
// these pin the registration shapes that replaced them.
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
[Fact]
|
||||
public void GetNearbyObjects_PortalReachableSetIncludesOutdoorCell_IndoorPrimary_DoorReturned()
|
||||
public void Register_OutdoorSeed_DoorVisibleInItsOutdoorCell_NotInUnrelatedIndoorCell()
|
||||
{
|
||||
// A6.P4 slice 1 / issue #99 (2026-05-24): when the player's sphere is
|
||||
// in an indoor cell but its CellTransit.FindCellSet result includes
|
||||
// an outdoor cell (via AddAllOutsideCells triggered by the sphere
|
||||
// straddling an OtherCellId=0xFFFF exit portal), GetNearbyObjects
|
||||
// must return shadows registered in that outdoor cell. Doors are
|
||||
// server-spawned entities registered at GameWindow.cs:3139 with
|
||||
// default cellScope=0u → outdoor 24-m grid registration. Before this
|
||||
// fix, the loop filtered out outdoor cell ids ("skip outdoor ids")
|
||||
// AND #98's primaryCellId gate skipped the radial sweep — net result
|
||||
// was that doors at building thresholds were invisible to spheres
|
||||
// on the indoor side: walk-through.
|
||||
// Issue #99 architecture: a door registered at its outdoor cell is
|
||||
// found by iterating THAT cell's list — which the Transition reaches
|
||||
// from the indoor side when its sphere straddles the exit portal
|
||||
// (the cell array spans both cells at the threshold; retail
|
||||
// "covered twice" note, wf1-interior-collision.md). Without a
|
||||
// building bridge in the flood cache, the door floods outdoor-only.
|
||||
var reg = new ShadowObjectRegistry();
|
||||
|
||||
const uint doorEntityId = 0x000F4244u;
|
||||
reg.Register(doorEntityId, 0x020019FFu, new Vector3(12f, 12f, 50f),
|
||||
Quaternion.Identity, 1f, OffX, OffY, LbId,
|
||||
ShadowCollisionType.Cylinder, cylHeight: 2.5f);
|
||||
ShadowCollisionType.Cylinder, cylHeight: 2.5f,
|
||||
isStatic: false);
|
||||
|
||||
var results = new List<ShadowEntry>();
|
||||
uint doorOutdoorCellId = LbId | 1u; // outdoor cell where door sits
|
||||
uint vestibuleCellId = LbId | 0x0145u; // indoor cell on the other side
|
||||
|
||||
// Sphere is in the vestibule; FindCellSet added the doorway's outdoor
|
||||
// cell via AddAllOutsideCells. Both ids land in portalReachableCells.
|
||||
reg.GetNearbyObjects(
|
||||
new Vector3(12f, 12f, 50f), 5f, OffX, OffY, LbId, results,
|
||||
portalReachableCells: new[] { vestibuleCellId, doorOutdoorCellId },
|
||||
primaryCellId: vestibuleCellId);
|
||||
|
||||
Assert.Contains(results, e => e.EntityId == doorEntityId);
|
||||
Assert.Contains(reg.GetObjectsInCell(doorOutdoorCellId), e => e.EntityId == doorEntityId);
|
||||
Assert.DoesNotContain(reg.GetObjectsInCell(vestibuleCellId), e => e.EntityId == doorEntityId);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GetNearbyObjects_IndoorPrimary_IndoorOnlyPortalSet_OutdoorRadialStillSkipped()
|
||||
public void Register_OutdoorFootprint_NeverLandsInInteriorCells()
|
||||
{
|
||||
// Regression check for issue #98: when the FindCellSet result holds
|
||||
// only indoor cells (sphere not near an exit portal — e.g. deep in
|
||||
// a cellar), the radial outdoor sweep must stay skipped so the
|
||||
// landblock-baked cottage GfxObj (registered at outdoor cellScope=0)
|
||||
// is NOT returned to a sphere in the cellar EnvCell. Otherwise the
|
||||
// head sphere bumps the cottage's downward-facing floor poly from
|
||||
// below and caps the cellar ascent at world Z≈92.7.
|
||||
// The #98 shape, now closed at REGISTRATION: an outdoor-positioned
|
||||
// footprint (the old cottage GfxObj entry) floods into outdoor
|
||||
// landcells only — without a building-bridge admission its spheres
|
||||
// can never reach an interior cell's list, so a fully-interior
|
||||
// cellar query structurally cannot see it. (In production the
|
||||
// cottage SHELL additionally left the registry entirely — the
|
||||
// per-LandCell building channel owns it.)
|
||||
var reg = new ShadowObjectRegistry();
|
||||
|
||||
const uint cottageEntityId = 0xA9B47900u;
|
||||
reg.Register(cottageEntityId, 0x01000A2Bu, new Vector3(12f, 12f, 90f),
|
||||
Quaternion.Identity, 5.5f, OffX, OffY, LbId);
|
||||
|
||||
var results = new List<ShadowEntry>();
|
||||
uint cellarCellId = LbId | 0x0146u;
|
||||
Assert.Empty(reg.GetObjectsInCell(cellarCellId));
|
||||
|
||||
// Sphere is in the cellar; FindCellSet returned indoor-only set
|
||||
// (no exit portal nearby).
|
||||
reg.GetNearbyObjects(
|
||||
new Vector3(12f, 12f, 50f), 5.5f, OffX, OffY, LbId, results,
|
||||
portalReachableCells: new[] { cellarCellId },
|
||||
primaryCellId: cellarCellId);
|
||||
// And every cell it DID land in is outdoor.
|
||||
foreach (var entry in reg.AllEntriesForDebug())
|
||||
Assert.Equal(cottageEntityId, entry.EntityId);
|
||||
}
|
||||
|
||||
Assert.DoesNotContain(results, e => e.EntityId == cottageEntityId);
|
||||
[Fact]
|
||||
public void RefloodLandblock_RerunsFloodAfterCellsHydrate()
|
||||
{
|
||||
// The streaming race (spec §7 Q3 / retail init_objects →
|
||||
// recalc_cross_cells): an entity registered while its indoor seed
|
||||
// cell was unhydrated stays pinned to {seed}; once the cell (with a
|
||||
// portal neighbor) hydrates, RefloodLandblock re-runs the flood and
|
||||
// the neighbor appears in the set.
|
||||
var reg = new ShadowObjectRegistry();
|
||||
var cache = new PhysicsDataCache();
|
||||
reg.DataCache = cache;
|
||||
|
||||
const uint seedCell = 0xA9B40100u;
|
||||
const uint neighborCell = 0xA9B40101u;
|
||||
|
||||
reg.Register(77u, 0x01000009u, new Vector3(2.0f, 0f, 2.5f),
|
||||
Quaternion.Identity, 0.5f, OffX, OffY, LbId,
|
||||
seedCellId: seedCell, isStatic: false);
|
||||
|
||||
// Unhydrated seed → registered under the claimed cell only.
|
||||
Assert.Contains(reg.GetObjectsInCell(seedCell), e => e.EntityId == 77u);
|
||||
Assert.Empty(reg.GetObjectsInCell(neighborCell));
|
||||
|
||||
// Hydrate the seed (portal to the neighbor at x=2.5) + the neighbor
|
||||
// (leaf BSP admits the straddling sphere), then re-flood.
|
||||
cache.RegisterCellStructForTest(seedCell,
|
||||
BuildShadowCellSetTests_MakeCellWithPortalAtRightWall(Matrix4x4.Identity, 0x0101));
|
||||
cache.RegisterCellStructForTest(neighborCell,
|
||||
BuildShadowCellSetTests_MakeLeafCell(Matrix4x4.CreateTranslation(5f, 0f, 0f)));
|
||||
|
||||
reg.RefloodLandblock(LbId);
|
||||
|
||||
Assert.Contains(reg.GetObjectsInCell(seedCell), e => e.EntityId == 77u);
|
||||
Assert.Contains(reg.GetObjectsInCell(neighborCell), e => e.EntityId == 77u);
|
||||
}
|
||||
|
||||
// Local copies of the BuildShadowCellSetTests fixture helpers (kept
|
||||
// private per test class by repo convention).
|
||||
private static CellPhysics BuildShadowCellSetTests_MakeCellWithPortalAtRightWall(
|
||||
Matrix4x4 worldTransform, ushort otherCellId)
|
||||
{
|
||||
var portalPoly = new ResolvedPolygon
|
||||
{
|
||||
Vertices = new[]
|
||||
{
|
||||
new Vector3(2.5f, -2.5f, 0f),
|
||||
new Vector3(2.5f, 2.5f, 0f),
|
||||
new Vector3(2.5f, 2.5f, 5f),
|
||||
new Vector3(2.5f, -2.5f, 5f),
|
||||
},
|
||||
Plane = new System.Numerics.Plane(new Vector3(1, 0, 0), -2.5f),
|
||||
NumPoints = 4,
|
||||
SidesType = DatReaderWriter.Enums.CullMode.None,
|
||||
};
|
||||
|
||||
Matrix4x4.Invert(worldTransform, out var inv);
|
||||
return new CellPhysics
|
||||
{
|
||||
WorldTransform = worldTransform,
|
||||
InverseWorldTransform = inv,
|
||||
Resolved = new Dictionary<ushort, ResolvedPolygon>(),
|
||||
PortalPolygons = new Dictionary<ushort, ResolvedPolygon> { [10] = portalPoly },
|
||||
Portals = new[]
|
||||
{
|
||||
new PortalInfo(otherCellId: otherCellId, polygonId: 10, flags: 0),
|
||||
},
|
||||
CellBSP = new DatReaderWriter.Types.CellBSPTree
|
||||
{
|
||||
Root = new DatReaderWriter.Types.CellBSPNode
|
||||
{
|
||||
Type = DatReaderWriter.Enums.BSPNodeType.Leaf,
|
||||
},
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
private static CellPhysics BuildShadowCellSetTests_MakeLeafCell(Matrix4x4 worldTransform)
|
||||
{
|
||||
Matrix4x4.Invert(worldTransform, out var inv);
|
||||
return new CellPhysics
|
||||
{
|
||||
WorldTransform = worldTransform,
|
||||
InverseWorldTransform = inv,
|
||||
Resolved = new Dictionary<ushort, ResolvedPolygon>(),
|
||||
CellBSP = new DatReaderWriter.Types.CellBSPTree
|
||||
{
|
||||
Root = new DatReaderWriter.Types.CellBSPNode
|
||||
{
|
||||
Type = DatReaderWriter.Enums.BSPNodeType.Leaf,
|
||||
},
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue