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

    [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

        var input = new MovementInput { Forward = true };
        var result = controller.Update(1.0f, input);  // 1 second

        // Should have moved ~4 units in +X (walk speed).
        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);
    }
}