d4869154d2
The P2 cellar-lip lesson one loop deeper. CheckOtherCells takes footCenter by value and used it for every cell in the loop — but a mid-loop query can MOVE the sphere: at the Facility Hub cell boundaries the neighbor's ramp floor full-hits, step_sphere_up climbs the foot +0.6mm and returns OK, and the loop continued querying the REMAINING cells (including the under-room, portal-ring-3) at the pre-climb height — 0.4mm inside the double-faced floor slab, grazing its underside (the under-room's ceiling) within the near-miss window. That dispatched a neg-poly step-up with a DOWNWARD normal, whose failure funneled into slide_sphere's opposing branch -> synthetic reversed-movement collision -> Collided -> revert, every frame: the seam shake (and, pre-mechanism-2-fix, the original absorbing wedge's entry). Retail check_other_cells reads the LIVE sphere_path.global_sphere for every cell (each cell's find_collisions receives the transition itself, pc:272717+). Fix: re-read footCenter = sp.GlobalSphere[0].Origin at the top of each loop iteration. All three Issue137CorridorSeamReplayTests repros un-skipped: the snapshot-exact west-boundary crossing (capture tick 4101), the east deep-straddle, and the clean-run lifecycle all GREEN. Full suites: Core 2556 / App 713 / UI 425 / Net 385, 0 failures. Visual gate pending: corridor run + the purple seam flashing re-check (expected to be the render exposing the same per-frame oscillation). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
341 lines
16 KiB
C#
341 lines
16 KiB
C#
using System;
|
||
using System.IO;
|
||
using System.Numerics;
|
||
using DatReaderWriter;
|
||
using DatReaderWriter.DBObjs;
|
||
using DatReaderWriter.Options;
|
||
using AcDream.Core.Physics;
|
||
using Xunit;
|
||
using Xunit.Abstractions;
|
||
using Env = System.Environment;
|
||
using Plane = System.Numerics.Plane;
|
||
|
||
namespace AcDream.Core.Tests.Physics;
|
||
|
||
/// <summary>
|
||
/// #137 corridor-seam replay (2026-07-06) — dat-backed reproduction of the
|
||
/// Facility Hub phantom hit (launch-175-verify2.log:42858): running +X down
|
||
/// the corridor, crossing 0x8A02016E → 0x8A02017A at x≈85.25, the live
|
||
/// client recorded `ok=True hit=yes n=(−1.00,0.03,−0.03)` with full advance,
|
||
/// persisted the sliding normal, and every later forward resolve absorbed to
|
||
/// zero (`ok=False hit=no`).
|
||
///
|
||
/// <para>
|
||
/// Dat facts pinned by <see cref="Issue137CorridorSeamInspectionTests"/>:
|
||
/// neither corridor cell (nor any portal-adjacent neighbor) has a physics
|
||
/// polygon whose plane matches that normal near the hit point — the recorded
|
||
/// normal is SYNTHETIC (the negated movement direction), which is exactly
|
||
/// what slide_sphere's opposing-normals branch records. Retail
|
||
/// (<c>CSphere::slide_sphere</c> 0x00537440 @0x0053762c) returns
|
||
/// COLLIDED_TS from that branch; our port returned OK — letting the step
|
||
/// complete with full advance and the synthetic normal persisted.
|
||
/// </para>
|
||
///
|
||
/// <para>
|
||
/// This replay drives the real engine over the real dat cells with the
|
||
/// live-log positions and player dimensions, and pins: the seam crossing
|
||
/// must complete WITHOUT persisting a sliding normal, and continued forward
|
||
/// running must keep advancing (no absorbing wedge).
|
||
/// </para>
|
||
/// </summary>
|
||
public class Issue137CorridorSeamReplayTests
|
||
{
|
||
private readonly ITestOutputHelper _out;
|
||
public Issue137CorridorSeamReplayTests(ITestOutputHelper output) => _out = output;
|
||
|
||
private const uint SeamCellWest = 0x8A02016Eu;
|
||
private const uint SeamCellEast = 0x8A02017Au;
|
||
|
||
private static string? FindDatDir()
|
||
{
|
||
var datDir = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR")
|
||
?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile),
|
||
"Documents", "Asheron's Call");
|
||
return Directory.Exists(datDir) ? datDir : null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Hydrate the two seam cells + every portal-adjacent neighbor into a
|
||
/// PhysicsEngine, exactly as the streaming path does (CacheCellStruct
|
||
/// with the dat world transform).
|
||
/// </summary>
|
||
private static PhysicsEngine BuildCorridorEngine(DatCollection dats)
|
||
{
|
||
var engine = new PhysicsEngine();
|
||
engine.DataCache = new PhysicsDataCache();
|
||
|
||
var toLoad = new System.Collections.Generic.HashSet<uint> { SeamCellWest, SeamCellEast };
|
||
foreach (var seed in new[] { SeamCellWest, SeamCellEast })
|
||
{
|
||
var seedCell = dats.Get<EnvCell>(seed);
|
||
Assert.NotNull(seedCell);
|
||
foreach (var p in seedCell!.CellPortals)
|
||
toLoad.Add(0x8A020000u | p.OtherCellId);
|
||
}
|
||
|
||
// Expand three portal rings — the live collision cell array reaches
|
||
// cells three hops out (0x8A020166, the under-ramp room whose ceiling
|
||
// is the ramp slab's underside, is ring-3 in the 2026-07-06
|
||
// seam-shake trace; with only two rings the offline flood can never
|
||
// add it and the shake does not reproduce).
|
||
for (int ring = 0; ring < 3; ring++)
|
||
{
|
||
foreach (var known in new System.Collections.Generic.List<uint>(toLoad))
|
||
{
|
||
var cell = dats.Get<EnvCell>(known);
|
||
if (cell is null) continue;
|
||
foreach (var p in cell.CellPortals)
|
||
toLoad.Add(0x8A020000u | p.OtherCellId);
|
||
}
|
||
}
|
||
|
||
foreach (var cellId in toLoad)
|
||
{
|
||
var envCell = dats.Get<EnvCell>(cellId);
|
||
if (envCell is null) continue;
|
||
var environment = dats.Get<DatReaderWriter.DBObjs.Environment>(0x0D000000u | envCell.EnvironmentId);
|
||
if (environment is null) continue;
|
||
if (!environment.Cells.TryGetValue(envCell.CellStructure, out var cs)) continue;
|
||
|
||
var rot = new Quaternion(
|
||
envCell.Position.Orientation.X, envCell.Position.Orientation.Y,
|
||
envCell.Position.Orientation.Z, envCell.Position.Orientation.W);
|
||
var world = Matrix4x4.CreateFromQuaternion(rot)
|
||
* Matrix4x4.CreateTranslation(
|
||
envCell.Position.Origin.X, envCell.Position.Origin.Y, envCell.Position.Origin.Z);
|
||
|
||
engine.DataCache.CacheCellStruct(cellId, envCell, cs!, world);
|
||
}
|
||
|
||
return engine;
|
||
}
|
||
|
||
private static PhysicsBody GroundedBody()
|
||
{
|
||
var body = new PhysicsBody();
|
||
body.ContactPlaneValid = true;
|
||
// Corridor floor at world z = −6 → n·p + d = 0 with n = +Z, d = 6.
|
||
body.ContactPlane = new Plane(Vector3.UnitZ, 6f);
|
||
body.TransientState |= TransientStateFlags.Contact | TransientStateFlags.OnWalkable;
|
||
// The live session carried a walkable polygon (walkable=True on every
|
||
// [resolve] line) — seed the corridor floor slab so the transition's
|
||
// SetWalkable path runs like live.
|
||
body.WalkablePolygonValid = true;
|
||
body.WalkablePlane = new Plane(Vector3.UnitZ, 6f);
|
||
body.WalkableUp = Vector3.UnitZ;
|
||
body.WalkableVertices = new[]
|
||
{
|
||
new Vector3(75f, -41.67f, -6f),
|
||
new Vector3(85f, -41.67f, -6f),
|
||
new Vector3(85f, -38.33f, -6f),
|
||
new Vector3(75f, -38.33f, -6f),
|
||
};
|
||
return body;
|
||
}
|
||
|
||
private ResolveResult Resolve(PhysicsEngine engine, PhysicsBody body,
|
||
Vector3 from, Vector3 to, uint cellId)
|
||
=> engine.ResolveWithTransition(
|
||
currentPos: from,
|
||
targetPos: to,
|
||
cellId: cellId,
|
||
sphereRadius: 0.48f, // human player, PlayerMovementController:885
|
||
sphereHeight: 1.2f, // human player, PlayerMovementController:886
|
||
stepUpHeight: 0.4f, // PlayerMovementController defaults
|
||
stepDownHeight: 0.4f,
|
||
isOnGround: true,
|
||
body: body,
|
||
moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide);
|
||
|
||
/// <summary>
|
||
/// 2026-07-06 seam-shake repro, snapshot-exact (probe session
|
||
/// launch-137-seam-probes.log + resolve-137-seam-capture.jsonl tick 4101,
|
||
/// repeated ×46): running WEST across the x=75 boundary
|
||
/// (0x8A02016E → 0x8A020165, the ramp cell) from (75.287, −40.035, −6)
|
||
/// toward (74.685, −39.988, −6), the resolve blocks with the SYNTHETIC
|
||
/// reversed-movement normal (0.997, −0.078, −0.002) and out==in — every
|
||
/// frame — the "shaking at the seam" report.
|
||
///
|
||
/// <para>
|
||
/// Probe-traced chain: the foot sphere (tangent to the floor) crosses
|
||
/// onto 0165's ramp floor; the ramp slab is double-faced and the
|
||
/// UNDERSIDE face (poly 0, n=(−0.03,0,−1)) grazes the sphere within the
|
||
/// hit threshold → recorded as a foot near-miss → neg-poly step-up
|
||
/// dispatch with a downward normal → the nested step-up's walkable probe
|
||
/// rejects the exactly-tangent ramp floor ([walkable-nearest]
|
||
/// gap=−0.0000 overlapsSphere=False) → StepUpSlide →
|
||
/// slide_sphere(downward normal vs up-facing contact plane) → the
|
||
/// opposing-normals branch → Collided → revert. Repeat.
|
||
/// </para>
|
||
/// </summary>
|
||
[Fact]
|
||
public void SeamShake_WestBoundary_SnapshotExact_Advances()
|
||
{
|
||
var datDir = FindDatDir();
|
||
if (datDir is null)
|
||
{
|
||
_out.WriteLine("SKIP: dat directory not found");
|
||
return;
|
||
}
|
||
|
||
using var dats = new DatCollection(datDir, DatAccessType.Read);
|
||
var engine = BuildCorridorEngine(dats);
|
||
|
||
// Body seeded EXACTLY from the capture's bodyBefore (tick 4101).
|
||
var body = new PhysicsBody();
|
||
body.ContactPlaneValid = true;
|
||
body.ContactPlane = new Plane(Vector3.UnitZ, 6f);
|
||
body.ContactPlaneCellId = SeamCellWest;
|
||
body.TransientState |= TransientStateFlags.Contact | TransientStateFlags.OnWalkable;
|
||
body.WalkablePolygonValid = true;
|
||
body.WalkablePlane = new Plane(Vector3.UnitZ, 6f);
|
||
body.WalkableUp = Vector3.UnitZ;
|
||
body.WalkableVertices = new[]
|
||
{
|
||
new Vector3(75f, -38.33333f, -6f),
|
||
new Vector3(75f, -41.66667f, -6f),
|
||
new Vector3(78.33333f, -41.66667f, -6f),
|
||
new Vector3(78.33333f, -38.33333f, -6f),
|
||
};
|
||
|
||
var from = new Vector3(75.28674f, -40.03537f, -6f);
|
||
var to = new Vector3(74.6854f, -39.988018f, -6f);
|
||
|
||
// Emit the same step-level probes the live session logged so the
|
||
// offline trace can be line-diffed against launch-137-seam-probes.log
|
||
// — the first divergent line names the state the replay is missing.
|
||
var probeBuffer = new System.IO.StringWriter();
|
||
var prevOut = Console.Out;
|
||
ResolveResult r1;
|
||
try
|
||
{
|
||
Console.SetOut(probeBuffer);
|
||
PhysicsDiagnostics.ProbeStepWalkEnabled = true;
|
||
PhysicsDiagnostics.ProbePushBackEnabled = true;
|
||
PhysicsDiagnostics.ProbeIndoorBspEnabled = true;
|
||
|
||
r1 = engine.ResolveWithTransition(
|
||
currentPos: from,
|
||
targetPos: to,
|
||
cellId: SeamCellWest,
|
||
sphereRadius: 0.48f,
|
||
sphereHeight: 1.2f,
|
||
stepUpHeight: 0.6f, // live Setup values from the capture
|
||
stepDownHeight: 1.5f,
|
||
isOnGround: true,
|
||
body: body,
|
||
moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide);
|
||
}
|
||
finally
|
||
{
|
||
PhysicsDiagnostics.ProbeStepWalkEnabled = false;
|
||
PhysicsDiagnostics.ProbePushBackEnabled = false;
|
||
PhysicsDiagnostics.ProbeIndoorBspEnabled = false;
|
||
Console.SetOut(prevOut);
|
||
}
|
||
_out.WriteLine(probeBuffer.ToString());
|
||
|
||
_out.WriteLine($"r1: ok={r1.Ok} out=({r1.Position.X:F3},{r1.Position.Y:F3},{r1.Position.Z:F3}) " +
|
||
$"cell=0x{r1.CellId:X8} hit={r1.CollisionNormalValid} " +
|
||
$"n=({r1.CollisionNormal.X:F2},{r1.CollisionNormal.Y:F2},{r1.CollisionNormal.Z:F2}) " +
|
||
$"bodySliding={body.TransientState.HasFlag(TransientStateFlags.Sliding)}");
|
||
|
||
Assert.True(r1.Position.X < from.X - 0.3f,
|
||
$"The westward boundary crossing onto the ramp must advance " +
|
||
$"({from.X:F3} → {r1.Position.X:F3}, target {to.X:F3}); zero " +
|
||
$"advance with the reversed-movement normal = the seam shake.");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 2026-07-06 gate session repro (launch-137-corridor-gate.log): standing
|
||
/// at (84.851, −39.764, −6.000) — the foot sphere already straddling the
|
||
/// x=85 cell boundary by 0.33 m — the first move attempt toward
|
||
/// (85.453, −39.782) blocked with the synthetic reversed-movement normal
|
||
/// (−1.00, 0.03, −0.02), out==in, cp lost (cp=none), and repeated every
|
||
/// frame (the "shaking at the seam" report). The deeper straddle start is
|
||
/// what the original replay frame (84.638 → 85.253) didn't cover.
|
||
/// </summary>
|
||
[Fact]
|
||
public void SeamCrossing_FromDeepStraddleStart_Advances()
|
||
{
|
||
var datDir = FindDatDir();
|
||
if (datDir is null)
|
||
{
|
||
_out.WriteLine("SKIP: dat directory not found");
|
||
return;
|
||
}
|
||
|
||
using var dats = new DatCollection(datDir, DatAccessType.Read);
|
||
var engine = BuildCorridorEngine(dats);
|
||
var body = GroundedBody();
|
||
|
||
var from = new Vector3(84.851f, -39.764f, -6.000f);
|
||
var to = new Vector3(85.453f, -39.782f, -6.000f);
|
||
|
||
var r1 = Resolve(engine, body, from, to, SeamCellWest);
|
||
_out.WriteLine($"r1: ok={r1.Ok} out=({r1.Position.X:F3},{r1.Position.Y:F3},{r1.Position.Z:F3}) " +
|
||
$"cell=0x{r1.CellId:X8} hit={r1.CollisionNormalValid} " +
|
||
$"n=({r1.CollisionNormal.X:F2},{r1.CollisionNormal.Y:F2},{r1.CollisionNormal.Z:F2}) " +
|
||
$"bodySliding={body.TransientState.HasFlag(TransientStateFlags.Sliding)} " +
|
||
$"bodyCpValid={body.ContactPlaneValid}");
|
||
|
||
Assert.True(r1.Position.X > from.X + 0.2f,
|
||
$"The straddling-start seam crossing must advance " +
|
||
$"({from.X:F3} → {r1.Position.X:F3}); zero advance with a " +
|
||
$"reversed-movement normal = the 2026-07-06 seam shake.");
|
||
}
|
||
|
||
[Fact]
|
||
public void SeamCrossing_DoesNotPersistSyntheticSlidingNormal_AndRunContinues()
|
||
{
|
||
var datDir = FindDatDir();
|
||
if (datDir is null)
|
||
{
|
||
_out.WriteLine("SKIP: dat directory not found");
|
||
return;
|
||
}
|
||
|
||
using var dats = new DatCollection(datDir, DatAccessType.Read);
|
||
var engine = BuildCorridorEngine(dats);
|
||
var body = GroundedBody();
|
||
|
||
// ── The live hit frame verbatim (launch-175-verify2.log:42858) ──
|
||
var from = new Vector3(84.638f, -39.758f, -6.000f);
|
||
var to = new Vector3(85.253f, -39.776f, -6.000f);
|
||
|
||
var r1 = Resolve(engine, body, from, to, SeamCellWest);
|
||
_out.WriteLine($"r1: ok={r1.Ok} out=({r1.Position.X:F3},{r1.Position.Y:F3},{r1.Position.Z:F3}) " +
|
||
$"cell=0x{r1.CellId:X8} hit={r1.CollisionNormalValid} " +
|
||
$"n=({r1.CollisionNormal.X:F2},{r1.CollisionNormal.Y:F2},{r1.CollisionNormal.Z:F2}) " +
|
||
$"bodySliding={body.TransientState.HasFlag(TransientStateFlags.Sliding)} " +
|
||
$"slidingN=({body.SlidingNormal.X:F2},{body.SlidingNormal.Y:F2},{body.SlidingNormal.Z:F2})");
|
||
|
||
// The corridor is straight and open: the crossing must not leave the
|
||
// body carrying a sliding normal (there is no wall to slide on —
|
||
// Issue137CorridorSeamInspectionTests proved no polygon matches the
|
||
// live-recorded normal; retail's slide_sphere opposing branch returns
|
||
// COLLIDED and its validate handling never lets a synthetic
|
||
// reversed-movement normal survive a clean corridor run).
|
||
Assert.False(body.TransientState.HasFlag(TransientStateFlags.Sliding),
|
||
"Crossing the open corridor seam must not persist a sliding " +
|
||
"normal — the live wedge's entry state (#137 mechanism 2).");
|
||
|
||
// ── Keep running +X (the live session's held-W frames) ──────────
|
||
var pos = r1.Position;
|
||
var cell = r1.CellId;
|
||
for (int i = 0; i < 6; i++)
|
||
{
|
||
var step = new Vector3(0.13f, -0.004f, 0f); // ~run speed per tick, same heading
|
||
var r = Resolve(engine, body, pos, pos + step, cell);
|
||
_out.WriteLine($"r{i + 2}: ok={r.Ok} out=({r.Position.X:F3},{r.Position.Y:F3},{r.Position.Z:F3}) " +
|
||
$"cell=0x{r.CellId:X8} hit={r.CollisionNormalValid} " +
|
||
$"bodySliding={body.TransientState.HasFlag(TransientStateFlags.Sliding)}");
|
||
Assert.True(r.Position.X > pos.X + 0.05f,
|
||
$"Forward run must keep advancing through the open corridor " +
|
||
$"(frame {i + 2}: {pos.X:F3} → {r.Position.X:F3}) — zero advance " +
|
||
$"= the #137 absorbing wedge.");
|
||
pos = r.Position;
|
||
cell = r.CellId;
|
||
}
|
||
}
|
||
}
|