acdream/tests/AcDream.Core.Tests/Input/PlayerMovementControllerTests.cs

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);
    }

    // ── Indoor doorway flap: render-position rest-snap (2026-06-08) ───────────
    //
    // Live pin (flap-churn.log, user at the cottage doorway): the physics body is
    // byte-stable at rest (rawPlayer = 1 distinct value), but the render position
    // (Lerp of the two physics-tick snapshots) jitters ~µm and the camera EYE
    // jitters ~1.3 mm — a ~1000x amplification by the grazing-doorframe camera-
    // collision sweep, which trips the portal clip → the standing-still flicker.
    // The dither is structural: at rest the tick snapshots (_prevPhysicsPos /
    // _currPhysicsPos) can lag the settled authoritative Position by microns (door-
    // frame edge-settle in the per-frame resolve), so Lerp(prev, curr, alpha) with a
    // per-frame-VARYING alpha sweeps a tiny segment instead of holding still. Fix:
    // at rest (velocity below epsilon) render AT the authoritative body position —
    // byte-identical and alpha-independent. Mirrors retail (a resting object renders
    // bit-stable) and the boom convergence snap (RetailChaseCamera.ApplyConvergenceSnap,
    // d2212cf), one layer earlier so the camera's pivot input is byte-stable too.
    //
    // The flat-terrain controller tests above CANNOT reproduce the doorframe-specific
    // prev!=curr-at-rest condition (flat terrain collapses prev==curr), so these test
    // the pure rest-snap function directly; the end-to-end acceptance is the live
    // doorway visual gate.
    [Fact]
    public void ComputeRenderPosition_AtRestWithStaleEndpoints_SnapsToAuthoritativePosition_NoAlphaDither()
    {
        // prev lags curr by 30 µm (the live doorframe edge-settle lag); body = the settled
        // authoritative position; velocity = 0 (at rest). Two different leftover-accumulator
        // alphas must BOTH return the authoritative position, byte-identical (no dither).
        var prev = new Vector3(155.525116f, 14.225600f, 94f);
        var curr = new Vector3(155.525146f, 14.225600f, 94f);
        var body = new Vector3(155.525146f, 14.225600f, 94f);

        var lowAlpha  = PlayerMovementController.ComputeRenderPosition(prev, curr, body, Vector3.Zero, alpha: 0.15f);
        var highAlpha = PlayerMovementController.ComputeRenderPosition(prev, curr, body, Vector3.Zero, alpha: 0.93f);

        Assert.Equal(body, lowAlpha);       // byte-identical to the authoritative position
        Assert.Equal(lowAlpha, highAlpha);  // alpha-independent at rest (no dither)
    }

    [Fact]
    public void ComputeRenderPosition_Moving_InterpolatesBetweenTickSnapshots()
    {
        // Guard the no-over-fire half: while moving (velocity well above the rest epsilon)
        // the render position must still interpolate smoothly between the tick snapshots.
        var prev = new Vector3(96.0f, 96f, 50f);
        var curr = new Vector3(96.3f, 96f, 50f);
        var moving = new Vector3(3.12f, 0f, 0f);  // walk speed

        var half = PlayerMovementController.ComputeRenderPosition(prev, curr, curr, moving, alpha: 0.5f);

        Assert.Equal(96.15f, half.X, precision: 3);  // midpoint — interpolation preserved
    }

    [Fact]
    public void Update_AtRest_BodyVelocityBelowRenderRestSnapThreshold()
    {
        // Precondition for the render-position rest-snap: a settled grounded body's velocity must
        // be below RestVelocityEpsilonSq, else ComputeRenderPosition's gate never fires at rest and
        // the doorway flicker persists. kill_velocity on grounded contact drives it to zero.
        var engine = MakeFlatEngine();
        var controller = new PlayerMovementController(engine);
        controller.SetPosition(new Vector3(96f, 96f, 50f), 0x0001);
        for (int i = 0; i < 60; i++) controller.Update(1f / 60f, new MovementInput());

        Assert.True(
            controller.BodyVelocity.LengthSquared() < PlayerMovementController.RestVelocityEpsilonSq,
            $"resting body velocity {controller.BodyVelocity.Length()} m/s must be below the rest-snap threshold");
    }

    [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);
    }
}