6c3a96b26e
The 2026-06-08 AM "physics rest micro-jitter" diagnosis is refuted with primary
evidence (door-recheck 216K standstill records: 0 position re-snaps; player
byte-stable during the flap). Two adversarial verification sub-agents confirmed:
- Retail roots the render at the camera viewer_cell (swept from the player via
SmartBox::update_viewer 0x453ce0; DrawInside(viewer_cell) 0x453aa0) and toggles
DrawInside / LScape::draw -- so acdream's eye-cell rooting + inside/outside
toggle are RETAIL-FAITHFUL. The locked-design "root at player cell" is wrong.
- The flap is render membership instability, eye-motion-driven: the visible-cell
set oscillates (8<->3) as the eye sweeps monotonically. Root = the
re-enqueue-on-growth DRIFT (PortalVisibilityBuilder.cs:322, MaxReprocessPerCell
=16) re-clipping each grown cell every round -> sub-cm eye jitter flips membership.
Fix (spec, not yet implemented): verbatim port of retail's enqueue-once flood
(ConstructView + AddViewToPortals): enqueue once on first discovery, clip each
cell's portals once, union late growth in place (AddToCell) + draw-reorder
(FixCellList), never re-enqueue. Kills the drift; rooting/camera/seal untouched.
This commit lands VERIFIED GROUNDWORK + design only:
- spec: docs/superpowers/specs/2026-06-08-portal-flood-enqueue-once-port-design.md
- findings: docs/research/2026-06-08-flap-physics-diagnosis-REFUTED-its-render-membership.md
- [pv-input] probe gains rawPlayer + yaw (disambiguates the varying input)
- 4 GREEN physics rest-stability tests (prove rest is bit-stable -> flap not physics)
- apparatus: launch-flap-capture.ps1, analyze_flap_live.py, find_burst.py
- captured fixtures: tests/.../Fixtures/flap-doorway/0xA9B4017{0..5}.json
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
362 lines
16 KiB
C#
362 lines
16 KiB
C#
using System;
|
||
using System.Numerics;
|
||
using AcDream.App.Input;
|
||
using AcDream.Core.Physics;
|
||
using Xunit;
|
||
|
||
namespace AcDream.Core.Tests.Input;
|
||
|
||
public class PlayerMovementControllerTests
|
||
{
|
||
private static PhysicsEngine MakeFlatEngine()
|
||
{
|
||
var engine = new PhysicsEngine();
|
||
var heights = new byte[81];
|
||
Array.Fill(heights, (byte)50);
|
||
var heightTable = new float[256];
|
||
for (int i = 0; i < 256; i++) heightTable[i] = i * 1f;
|
||
var terrain = new TerrainSurface(heights, heightTable);
|
||
engine.AddLandblock(0xA9B4FFFFu, terrain, Array.Empty<CellSurface>(),
|
||
Array.Empty<PortalPlane>(), worldOffsetX: 0f, worldOffsetY: 0f);
|
||
return engine;
|
||
}
|
||
|
||
[Fact]
|
||
public void Update_NoInput_PositionUnchanged()
|
||
{
|
||
var engine = MakeFlatEngine();
|
||
var controller = new PlayerMovementController(engine);
|
||
controller.SetPosition(new Vector3(96f, 96f, 50f), 0x0001);
|
||
|
||
var result = controller.Update(0.016f, new MovementInput());
|
||
|
||
Assert.Equal(96f, result.Position.X, precision: 1);
|
||
Assert.Equal(96f, result.Position.Y, precision: 1);
|
||
}
|
||
|
||
// ── Indoor-flap root cause: resting-body bit-stability ────────────────────
|
||
//
|
||
// The indoor render "flap" (textures battling at the cottage doorway) is
|
||
// portal-flood membership instability. PortalVisibilityBuilder.Build is a
|
||
// proven-deterministic pure function, so the membership can only flip if its
|
||
// INPUT (the camera eye, derived from the player RenderPosition) varies.
|
||
// Live 6-dp capture (pvinput.log:54) shows the player RenderPosition carries
|
||
// a perpetual ~1-ULP flicker at rest (Z 94.000000 <-> 93.999992 — exactly one
|
||
// float mantissa step). ComputeRenderPosition is Vector3.Lerp(_prevPhysicsPos,
|
||
// _currPhysicsPos, alpha), and Lerp(a, a, t) == a exactly, so a jittering
|
||
// RenderPosition at rest means the physics body's resting Position is NOT
|
||
// bit-stable between ticks. Retail's authoritative local position is bit-stable
|
||
// at rest (validate_transition -> kill_velocity on every grounded contact), so
|
||
// retail never flaps.
|
||
//
|
||
// This test pins the physics-side invariant: a grounded body with no input
|
||
// must hold a byte-identical position across many frames. It PASSES — which
|
||
// is itself the evidence: the physics resting position is bit-stable, so the
|
||
// doorway flap is NOT a physics-rest jitter. See
|
||
// docs/research/2026-06-08-flap-physics-diagnosis-REFUTED-its-render-membership.md
|
||
// (the flap is render-side portal-flood membership instability at the grazing
|
||
// doorway portal under a sweeping camera eye). Kept as a regression guard.
|
||
[Fact]
|
||
public void Update_AtRestNoInput_RenderPositionBitStableAcrossManyFrames()
|
||
{
|
||
var engine = MakeFlatEngine();
|
||
var controller = new PlayerMovementController(engine);
|
||
var rest = new Vector3(96f, 96f, 50f);
|
||
controller.SetPosition(rest, 0x0001);
|
||
|
||
// Settle one frame so the resolver establishes its rest state, then
|
||
// capture the baseline the body must hold.
|
||
var settled = controller.Update(1f / 60f, new MovementInput());
|
||
Vector3 baselineRender = settled.RenderPosition;
|
||
Vector3 baselinePhysics = settled.Position;
|
||
|
||
// Hold still for ~10 s of 60 Hz frames (crosses MinQuantum every ~2
|
||
// frames, so the 30 Hz physics tick fires throughout — same cadence as
|
||
// live). Any deviation, even one ULP, is the flap's root cause.
|
||
float maxRenderDev = 0f;
|
||
float maxPhysicsDev = 0f;
|
||
for (int i = 0; i < 600; i++)
|
||
{
|
||
var r = controller.Update(1f / 60f, new MovementInput());
|
||
maxRenderDev = MathF.Max(maxRenderDev, (r.RenderPosition - baselineRender).Length());
|
||
maxPhysicsDev = MathF.Max(maxPhysicsDev, (r.Position - baselinePhysics).Length());
|
||
}
|
||
|
||
Assert.True(
|
||
maxRenderDev == 0f && maxPhysicsDev == 0f,
|
||
$"resting body drifted: render={maxRenderDev * 1e6f:F3} µm, " +
|
||
$"physics={maxPhysicsDev * 1e6f:F3} µm; expected byte-identical rest");
|
||
}
|
||
|
||
// After walking then releasing input, the body must SETTLE to a
|
||
// byte-identical resting position — not keep blipping a residual velocity.
|
||
// This models the live flap: the player walks to the cottage doorway and
|
||
// stops, and the eye then carries a ~1-ULP jitter that flips portal-flood
|
||
// membership. Flat-terrain variant: if even this drifts, the residual-after-
|
||
// motion path is the root and it is not indoor-specific.
|
||
[Fact]
|
||
public void Update_WalkThenStop_SettlesToBitStableRest()
|
||
{
|
||
var engine = MakeFlatEngine();
|
||
var controller = new PlayerMovementController(engine);
|
||
controller.SetPosition(new Vector3(96f, 96f, 50f), 0x0001);
|
||
controller.Yaw = 0f;
|
||
|
||
// Walk forward ~0.5 s, then release.
|
||
for (int i = 0; i < 30; i++)
|
||
controller.Update(1f / 60f, new MovementInput(Forward: true));
|
||
// Let velocity decay / state settle.
|
||
for (int i = 0; i < 30; i++)
|
||
controller.Update(1f / 60f, new MovementInput());
|
||
|
||
var settled = controller.Update(1f / 60f, new MovementInput());
|
||
Vector3 basePos = settled.Position;
|
||
Vector3 baseRender = settled.RenderPosition;
|
||
|
||
float maxPos = 0f, maxRender = 0f;
|
||
for (int i = 0; i < 600; i++)
|
||
{
|
||
var r = controller.Update(1f / 60f, new MovementInput());
|
||
maxPos = MathF.Max(maxPos, (r.Position - basePos).Length());
|
||
maxRender = MathF.Max(maxRender, (r.RenderPosition - baseRender).Length());
|
||
}
|
||
|
||
Assert.True(maxPos == 0f && maxRender == 0f,
|
||
$"post-walk rest drifted: pos={maxPos * 1e6f:F3} µm, render={maxRender * 1e6f:F3} µm");
|
||
}
|
||
|
||
[Fact]
|
||
public void Update_ForwardInput_MovesInFacingDirection()
|
||
{
|
||
var engine = MakeFlatEngine();
|
||
var controller = new PlayerMovementController(engine);
|
||
controller.SetPosition(new Vector3(96f, 96f, 50f), 0x0001);
|
||
controller.Yaw = 0f; // facing +X
|
||
|
||
// L.5 physics-tick gate (235de33, 2026-04-30): Update() integrates
|
||
// only one MinQuantum (~0.033s) per MaxQuantum (~0.1s) tick, matching
|
||
// retail's 30Hz physics. A single Update(1.0f) only advances one
|
||
// MaxQuantum step (~0.312m at walk speed 3.12 m/s). Drive the
|
||
// controller one MaxQuantum at a time for ~1s to accumulate real
|
||
// forward motion (8 × 0.1s = 0.8s × 3.12 m/s ≈ 2.5m).
|
||
var input = new MovementInput { Forward = true };
|
||
MovementResult result = default;
|
||
int ticks = (int)MathF.Ceiling(1.0f / PhysicsBody.MaxQuantum) + 1; // ~11 ticks
|
||
for (int i = 0; i < ticks; i++)
|
||
result = controller.Update(PhysicsBody.MaxQuantum, input);
|
||
|
||
// Should have moved >2 units in +X (walk speed over ~1s).
|
||
Assert.True(result.Position.X > 96f + 2f, $"X={result.Position.X} should have moved forward");
|
||
}
|
||
|
||
[Fact]
|
||
public void Update_SubQuantumFrame_InterpolatesRenderPositionWithoutAdvancingPhysicsPosition()
|
||
{
|
||
var engine = MakeFlatEngine();
|
||
var controller = new PlayerMovementController(engine);
|
||
var start = new Vector3(96f, 96f, 50f);
|
||
controller.SetPosition(start, 0x0001);
|
||
controller.Yaw = 0f;
|
||
|
||
var firstTick = controller.Update(PhysicsBody.MinQuantum, new MovementInput(Forward: true));
|
||
Assert.True(firstTick.Position.X > start.X, "Physics tick should advance the authoritative body position");
|
||
Assert.Equal(start.X, firstTick.RenderPosition.X, precision: 4);
|
||
|
||
var halfFrame = controller.Update(PhysicsBody.MinQuantum * 0.5f, new MovementInput(Forward: true));
|
||
|
||
Assert.Equal(firstTick.Position.X, halfFrame.Position.X, precision: 4);
|
||
Assert.True(halfFrame.RenderPosition.X > start.X, "Render position should move between physics ticks");
|
||
Assert.True(halfFrame.RenderPosition.X < firstTick.Position.X,
|
||
$"Render X={halfFrame.RenderPosition.X} should stay between {start.X} and {firstTick.Position.X}");
|
||
|
||
float expectedMidpoint = start.X + ((firstTick.Position.X - start.X) * 0.5f);
|
||
Assert.Equal(expectedMidpoint, halfFrame.RenderPosition.X, precision: 3);
|
||
}
|
||
|
||
[Fact]
|
||
public void SetPosition_ResnapsRenderInterpolationEndpoints()
|
||
{
|
||
var engine = MakeFlatEngine();
|
||
var controller = new PlayerMovementController(engine);
|
||
controller.SetPosition(new Vector3(96f, 96f, 50f), 0x0001);
|
||
controller.Yaw = 0f;
|
||
|
||
controller.Update(PhysicsBody.MinQuantum, new MovementInput(Forward: true));
|
||
controller.Update(PhysicsBody.MinQuantum * 0.5f, new MovementInput(Forward: true));
|
||
|
||
var snapped = new Vector3(120f, 80f, 50f);
|
||
controller.SetPosition(snapped, 0x0001);
|
||
var result = controller.Update(PhysicsBody.MinQuantum * 0.5f, new MovementInput());
|
||
|
||
Assert.Equal(snapped, result.Position);
|
||
Assert.Equal(snapped, result.RenderPosition);
|
||
}
|
||
|
||
[Fact]
|
||
public void Update_HugeQuantumDiscard_ResnapsRenderInterpolationEndpoints()
|
||
{
|
||
var engine = MakeFlatEngine();
|
||
var controller = new PlayerMovementController(engine);
|
||
controller.SetPosition(new Vector3(96f, 96f, 50f), 0x0001);
|
||
controller.Yaw = 0f;
|
||
|
||
var moved = controller.Update(PhysicsBody.MinQuantum, new MovementInput(Forward: true));
|
||
var stale = controller.Update(PhysicsBody.HugeQuantum + 0.1f, new MovementInput(Forward: true));
|
||
|
||
Assert.Equal(moved.Position.X, stale.Position.X, precision: 4);
|
||
Assert.Equal(stale.Position, stale.RenderPosition);
|
||
}
|
||
|
||
[Fact]
|
||
public void Update_LeftoverAboveMinQuantum_ClampsRenderAlphaToCurrentPhysicsPosition()
|
||
{
|
||
var engine = MakeFlatEngine();
|
||
var controller = new PlayerMovementController(engine);
|
||
controller.SetPosition(new Vector3(96f, 96f, 50f), 0x0001);
|
||
controller.Yaw = 0f;
|
||
|
||
var result = controller.Update(
|
||
PhysicsBody.MaxQuantum + PhysicsBody.MinQuantum,
|
||
new MovementInput(Forward: true));
|
||
|
||
Assert.Equal(result.Position.X, result.RenderPosition.X, precision: 4);
|
||
Assert.Equal(result.Position.Y, result.RenderPosition.Y, precision: 4);
|
||
Assert.Equal(result.Position.Z, result.RenderPosition.Z, precision: 4);
|
||
}
|
||
|
||
[Fact]
|
||
public void Update_RunForward_MoveFasterThanWalk()
|
||
{
|
||
var engine = MakeFlatEngine();
|
||
var controller = new PlayerMovementController(engine);
|
||
controller.SetPosition(new Vector3(96f, 96f, 50f), 0x0001);
|
||
controller.Yaw = 0f;
|
||
|
||
var walkInput = new MovementInput { Forward = true };
|
||
var walkResult = controller.Update(1.0f, walkInput);
|
||
float walkDist = walkResult.Position.X - 96f;
|
||
|
||
controller.SetPosition(new Vector3(96f, 96f, 50f), 0x0001);
|
||
|
||
var runInput = new MovementInput { Forward = true, Run = true };
|
||
var runResult = controller.Update(1.0f, runInput);
|
||
float runDist = runResult.Position.X - 96f;
|
||
|
||
Assert.True(runDist > walkDist, $"Run ({runDist}) should be faster than walk ({walkDist})");
|
||
}
|
||
|
||
[Fact]
|
||
public void Update_TurnInput_ChangesYaw()
|
||
{
|
||
var engine = MakeFlatEngine();
|
||
var controller = new PlayerMovementController(engine);
|
||
controller.SetPosition(new Vector3(96f, 96f, 50f), 0x0001);
|
||
float initialYaw = controller.Yaw;
|
||
|
||
var input = new MovementInput { TurnRight = true };
|
||
controller.Update(0.5f, input);
|
||
|
||
Assert.NotEqual(initialYaw, controller.Yaw);
|
||
}
|
||
|
||
[Fact]
|
||
public void MotionStateChanged_WhenStartingToWalk()
|
||
{
|
||
var engine = MakeFlatEngine();
|
||
var controller = new PlayerMovementController(engine);
|
||
controller.SetPosition(new Vector3(96f, 96f, 50f), 0x0001);
|
||
|
||
// First frame: idle (no input).
|
||
controller.Update(0.016f, new MovementInput());
|
||
|
||
// Second frame: start walking.
|
||
var input = new MovementInput { Forward = true };
|
||
var result = controller.Update(0.016f, input);
|
||
|
||
Assert.True(result.MotionStateChanged);
|
||
}
|
||
|
||
[Fact]
|
||
public void Update_JumpOnFlatTerrain_BecomesAirborne()
|
||
{
|
||
var engine = MakeFlatEngine();
|
||
var controller = new PlayerMovementController(engine);
|
||
controller.SetPosition(new Vector3(96f, 96f, 50f), 0x0001);
|
||
|
||
// Charged jump: hold for a full charge (1s dt), then release to fire.
|
||
// A full charge gives enough Vz that the player clears the 0.05-unit
|
||
// ground-snap threshold within the same integration frame.
|
||
controller.Update(1.0f, new MovementInput(Jump: true)); // full charge
|
||
controller.Update(0.016f, new MovementInput(Jump: false)); // release → jump fires
|
||
|
||
Assert.True(controller.IsAirborne);
|
||
Assert.True(controller.VerticalVelocity > 0f);
|
||
}
|
||
|
||
[Fact]
|
||
public void Update_AirborneFrames_ZRiseThenFalls()
|
||
{
|
||
var engine = MakeFlatEngine();
|
||
var controller = new PlayerMovementController(engine);
|
||
controller.SetPosition(new Vector3(96f, 96f, 50f), 0x0001);
|
||
|
||
// Charged jump: hold for a full charge, then release.
|
||
controller.Update(1.0f, new MovementInput(Jump: true)); // full charge
|
||
controller.Update(0.016f, new MovementInput(Jump: false)); // release → jump fires
|
||
float z1 = controller.Position.Z;
|
||
|
||
// A few frames of rising
|
||
controller.Update(0.1f, new MovementInput());
|
||
float z2 = controller.Position.Z;
|
||
Assert.True(z2 > z1, "Should be rising");
|
||
|
||
// Many frames — should come back down.
|
||
// DefaultJumpVz = 10 m/s → full flight time ≈ 2.04s, so run 50 × 50ms = 2.5s
|
||
// to ensure the player has definitely landed.
|
||
for (int i = 0; i < 50; i++)
|
||
controller.Update(0.05f, new MovementInput());
|
||
|
||
Assert.False(controller.IsAirborne, "Should have landed");
|
||
Assert.Equal(50f, controller.Position.Z, precision: 1);
|
||
}
|
||
|
||
[Fact]
|
||
public void Update_WalkOffLedge_BecomesFalling()
|
||
{
|
||
// Build terrain with a sharp cliff: grid x<5 = Z50, grid x>=5 = Z20.
|
||
// heights[x*9+y] is indexed x-major; heightTable[i]=i*1f so
|
||
// byte value == Z value directly.
|
||
var heights = new byte[81];
|
||
for (int x = 0; x < 9; x++)
|
||
for (int y = 0; y < 9; y++)
|
||
heights[x * 9 + y] = (byte)(x < 5 ? 50 : 20);
|
||
|
||
var heightTable = new float[256];
|
||
for (int i = 0; i < 256; i++) heightTable[i] = i * 1f;
|
||
|
||
var engine = new PhysicsEngine();
|
||
var terrain = new TerrainSurface(heights, heightTable);
|
||
engine.AddLandblock(0xA9B4FFFFu, terrain, Array.Empty<CellSurface>(),
|
||
Array.Empty<PortalPlane>(), worldOffsetX: 0f, worldOffsetY: 0f);
|
||
|
||
// Position the player just before the cliff edge (localX=118 ≈ grid x=4.92).
|
||
// At this point terrain Z is ~51.7 (bilinear interpolation near the high side).
|
||
// One step at walk speed will cross into the low region where terrain drops
|
||
// ~28 units — more than StepUpHeight=5, triggering the ledge-fall.
|
||
var controller = new PlayerMovementController(engine);
|
||
controller.SetPosition(new Vector3(118f, 96f, 50f), 0x0001);
|
||
controller.Yaw = 0f; // facing +X
|
||
|
||
// Single step — should trigger airborne state because terrain drops sharply.
|
||
controller.Update(0.05f, new MovementInput(Forward: true));
|
||
|
||
Assert.True(controller.IsAirborne, "Player should be airborne after stepping off the cliff");
|
||
|
||
// Simulate enough frames to fall and land on the Z=20 floor.
|
||
for (int i = 0; i < 60; i++)
|
||
controller.Update(0.05f, new MovementInput(Forward: true));
|
||
|
||
Assert.False(controller.IsAirborne, "Player should have landed");
|
||
Assert.Equal(20f, controller.Position.Z, precision: 1);
|
||
}
|
||
}
|