acdream/tests/AcDream.Core.Tests/Physics/Motion/RemoteChaseEndToEndHarnessTests.cs

using System;
using System.Collections.Generic;
using System.Numerics;
using System.Text;
using AcDream.Core.Physics;
using AcDream.Core.Physics.Motion;
using DatReaderWriter.DBObjs;
using DatReaderWriter.Types;
using Xunit;
using Xunit.Abstractions;

using DRWMotionCommand = DatReaderWriter.Enums.MotionCommand;
using CorePosition = AcDream.Core.Physics.Position;

namespace AcDream.Core.Tests.Physics.Motion;

// ─────────────────────────────────────────────────────────────────────────────
// #170 "sustain the run" — full-stack remote-chase harness.
//
// The R4-V2 MoveToManagerHarness scripts Heading directly (setHeading writes
// the scalar) and drains pending_motions synthetically, so the two legs where
// the live #170 residual actually lives have ZERO coverage:
//
//   1. the PHYSICAL turn: _DoMotion(TurnRight) → MotionTableDispatchSink.
//      TurnApplied → ObservedOmega → per-tick quaternion integration →
//      MoveToMath.GetHeading → HandleTurnToHeading's HeadingGreater test;
//   2. the REAL drain: MotionTableManager pending_animations countdown fed by
//      CSequence AnimDone hooks (link-anim completions), popping
//      CMotionInterp.pending_motions via the MotionDoneTarget seam.
//
// This harness wires a real MotionInterpreter + AnimationSequencer +
// MotionTableDispatchSink + MoveToManager EXACTLY like GameWindow's
// EnsureRemoteMotionBindings (GameWindow.cs:4251) and ticks them in
// GameWindow.TickAnimations' per-entity order for the grounded branch=MOVETO
// path (GameWindow.cs:9697 HandleTargetting → 9994 TickRemoteMoveTo →
// 10024 get_state_velocity refresh → 10050 manual omega integration →
// 10247 Sequencer.Advance → 10306 AnimationDone per AnimDoneHook →
// 10309 Manager.UseTime). Wire events (aggro stance UM, mt-6 arms, attack
// UMs) replay the exact live sequence captured in launch-drainq.log
// (2026-07-04, guid 0x80000BE5, Mite Scamp chasing the fleeing player).
//
// Retail acceptance bar (live cdb, 2026-07-04 session): BeginMoveForward ≈
// MoveToObject arms (21/22), pending_motions add == MotionDone exactly, the
// chase turn completes within a couple of seconds and the run SUSTAINS
// between attack swings.
// ─────────────────────────────────────────────────────────────────────────────

internal sealed class ChaseLoader : IAnimationLoader
{
    private readonly Dictionary<uint, Animation> _anims = new();
    public void Register(uint id, Animation anim) => _anims[id] = anim;
    public Animation? LoadAnimation(uint id) =>
        _anims.TryGetValue(id, out var a) ? a : null;
}

/// <summary>
/// The full-stack per-entity pipeline replica. Field-for-field mirror of the
/// GameWindow wiring for one grounded remote NPC (branch=MOVETO), plus a
/// scripted stand-in for the TargetManager voyeur delivery (SetTarget →
/// synchronous first delivery + one delivery per quantum thereafter — the
/// live cadence observed in launch-drainq.log: HandleUpdateTarget directly
/// after the arm, then sparse).
/// </summary>
internal sealed class RemoteChaseHarness
{
    // Styles / substates (full command words, as the wire produces them).
    public const uint NonCombat = 0x8000003Du;
    public const uint Combat = 0x8000003Cu;      // the aggro stance in the live capture
    public const uint Ready = 0x41000003u;
    public const uint Walk = 0x45000005u;
    public const uint Run = 0x44000007u;
    public const uint TurnRight = 0x6500000Du;
    public const uint AttackAction = 0x10000063u; // one of the live scamp swings

    public const uint CreatureGuid = 0x80000BE5u;
    public const uint PlayerGuid = 0x5000000Au;

    public const float Dt = 1f / 60f;

    // Field-for-field mirror of GameWindow's RemoteMotion construction
    // (GameWindow.cs:592-618): Contact+OnWalkable+Active, InWorld=true (the
    // R4-V5 door fix — without it the interp's detached-object guard strips
    // every dispatched transition link), and the R4-V5 #160 RemoteWeenie
    // (null weenie degrades run-rate to 1.0).
    public readonly PhysicsBody Body = new()
    {
        State = PhysicsStateFlags.ReportCollisions,
        TransientState = TransientStateFlags.Contact
                       | TransientStateFlags.OnWalkable
                       | TransientStateFlags.Active,
        InWorld = true,
    };
    public readonly MotionInterpreter Interp;
    public readonly AnimationSequencer Seq;
    public readonly MotionTableDispatchSink Sink;
    public readonly MoveToManager Mgr;

    /// <summary>GameWindow's RemoteMotion.ObservedOmega twin.</summary>
    public Vector3 ObservedOmega;

    /// <summary>Scripted player (chase target) world position.</summary>
    public Vector3 PlayerPos;
    public Vector3 PlayerVelocity;

    // Scripted targeting stand-in (GameWindow: EntityPhysicsHost/TargetManager).
    private bool _targetArmed;
    private double _lastDeliveryTime = double.NegativeInfinity;
    private double _quantum = 0.5;
    public double Now;

    // Counters (the live-probe equivalents).
    public int BeginTurnBlocked;
    public int BeginTurnUnblocked;
    public int RunInstalls;      // substate transitions INTO RunForward/Walk fwd
    public int TicksInRun;
    public int TicksInWalkFwd;
    public int TotalTicks;
    public int MaxRunStreak;
    private int _runStreak;
    private uint _prevSubstate;

    public readonly List<string> Trace = new();
    private readonly ITestOutputHelper? _log;

    public RemoteChaseHarness(ITestOutputHelper? log = null)
    {
        _log = log;
        var (setup, mtable, loader) = BuildFixture();
        Seq = new AnimationSequencer(setup, mtable, loader);

        // ── GameWindow spawn path (OnLiveEntitySpawnedLocked ~3781) ──
        Seq.InitializeState();
        Seq.SetCycle(NonCombat, Ready);

        Body.Orientation = MoveToMath.SetHeading(Quaternion.Identity, 0f); // face North
        Interp = new MotionInterpreter(Body)
        {
            WeenieObj = new RemoteWeenie(),
        };

        // ── EnsureRemoteMotionBindings (GameWindow.cs:4251) verbatim ──
        Sink = new MotionTableDispatchSink(Seq)
        {
            TurnApplied = (turnMotion, turnSpeed) =>
            {
                float signed = (turnMotion & 0xFFu) == 0x0E
                    ? -MathF.Abs(turnSpeed)
                    : turnSpeed;
                ObservedOmega = new Vector3(0f, 0f, -(MathF.PI / 2f) * signed);
            },
            TurnStopped = () => ObservedOmega = Vector3.Zero,
        };
        Interp.DefaultSink = Sink;
        Interp.RemoveLinkAnimations = Seq.RemoveAllLinkAnimations;
        Interp.InitializeMotionTables = () => Seq.Manager.InitializeState();
        Interp.CheckForCompletedMotions = Seq.Manager.CheckForCompletedMotions;

        Mgr = new MoveToManager(
            Interp,
            stopCompletely: () => Interp.StopCompletely(),
            getPosition: () => new CorePosition(1u, Body.Position, Body.Orientation),
            getHeading: () => MoveToMath.GetHeading(Body.Orientation),
            setHeading: (h, _) => Body.Orientation =
                MoveToMath.SetHeading(Body.Orientation, h),
            getOwnRadius: () => 0f,
            getOwnHeight: () => 0f,
            contact: () => Body.OnWalkable,
            isInterpolating: () => false,
            getVelocity: () => Body.Velocity,
            getSelfId: () => CreatureGuid,
            setTarget: (ctx, tlid, radius, q) =>
            {
                _targetArmed = tlid == PlayerGuid;
                // TargetManager delivers the FIRST info synchronously on
                // SetTarget (live log: HandleUpdateTarget printed directly
                // after the arm, same network phase).
                DeliverTargetInfo();
            },
            clearTarget: () => _targetArmed = false,
            getTargetQuantum: () => _quantum,
            setTargetQuantum: q => _quantum = q,
            curTime: () => Now);

        Interp.InterruptCurrentMovement =
            () => Mgr.CancelMoveTo(WeenieError.ActionCancelled);

        // ── The anim-loop MotionDone binding (GameWindow.cs:10266) ──
        Seq.MotionDoneTarget = (m, ok) => Interp.MotionDone(m, ok);

        _prevSubstate = Seq.Manager.State.Substate;
    }

    // ── Wire events ─────────────────────────────────────────────────────────

    /// <summary>mt-0 UM (funnel apply): interrupt + unstick head, then
    /// MoveToInterpretedState — GameWindow.cs:4893 + 5008.</summary>
    public void UmInterpreted(uint stance, uint forward, float forwardSpeed = 1f,
        params InboundMotionAction[] actions)
    {
        Interp.InterruptCurrentMovement?.Invoke();
        Interp.UnstickFromObject?.Invoke();

        var ims = new InboundInterpretedState
        {
            CurrentStyle = stance,
            ForwardCommand = forward,
            ForwardSpeed = forwardSpeed,
            SideStepCommand = 0u,
            SideStepSpeed = 1f,
            TurnCommand = 0u,
            TurnSpeed = 1f,
        };
        if (actions.Length > 0)
            ims.Actions = new List<InboundMotionAction>(actions);

        Interp.MoveToInterpretedState(ims, Sink);
    }

    /// <summary>mt-6 UM (MoveToObject arm): interrupt + unstick head, then the
    /// RouteServerMoveTo MovementStruct — GameWindow.cs:4483-4508. Params match
    /// the live scamp chase (spd 2.08, threshold 15, object distance 0.6).</summary>
    public void UmMoveToObject(
        float speed = 2.08f,
        float distanceToObject = 0.6f,
        float walkRunThreshold = 15f)
    {
        Interp.InterruptCurrentMovement?.Invoke();
        Interp.UnstickFromObject?.Invoke();

        var mp = new MovementParameters
        {
            CanWalk = true,
            CanRun = true,
            CanCharge = true,
            CanSidestep = false,
            CanWalkBackwards = false,
            Speed = speed,
            DistanceToObject = distanceToObject,
            WalkRunThreshhold = walkRunThreshold,
            FailDistance = float.MaxValue,
            UseSpheres = false,
        };
        var ms = new MovementStruct
        {
            Type = MovementType.MoveToObject,
            ObjectId = PlayerGuid,
            TopLevelId = PlayerGuid,
            Pos = new CorePosition(1u, PlayerPos, Quaternion.Identity),
            Params = mp,
        };
        Mgr.PerformMovement(ms);
    }

    private void DeliverTargetInfo()
    {
        if (!_targetArmed) return;
        _lastDeliveryTime = Now;
        var pos = new CorePosition(1u, PlayerPos, Quaternion.Identity);
        Mgr.HandleUpdateTarget(new TargetInfo
        {
            ObjectId = PlayerGuid,
            Status = TargetStatus.Ok,
            TargetPosition = pos,
            InterpolatedPosition = pos,
        });
    }

    // ── The per-tick pipeline (GameWindow.TickAnimations order) ────────────

    public void Tick()
    {
        Now += Dt;
        TotalTicks++;

        // Player (chase target) moves per its scripted velocity.
        PlayerPos += PlayerVelocity * Dt;

        // 1. Voyeur delivery (player host HandleTargetting → this entity's
        //    HandleUpdateTarget; GameWindow.cs:8094 runs before the per-remote
        //    loop, 9697 in-loop).
        if (_targetArmed && Now - _lastDeliveryTime >= _quantum)
            DeliverTargetInfo();

        // 2. MoveToManager drive (TickRemoteMoveTo, GameWindow.cs:9994).
        Mgr.UseTime();

        // 3. get_state_velocity → body velocity (the d2ccc80e refresh,
        //    GameWindow.cs:10024).
        if (Body.OnWalkable)
            Body.set_local_velocity(Interp.get_state_velocity(), false);

        // 4. Manual omega integration (GameWindow.cs:10050-10058 verbatim).
        if (ObservedOmega.LengthSquared() > 1e-8f)
        {
            float omegaMag = ObservedOmega.Length();
            var axis = ObservedOmega / omegaMag;
            float angle = omegaMag * Dt;
            var deltaRot = Quaternion.CreateFromAxisAngle(axis, angle);
            Body.Orientation = Quaternion.Normalize(
                Quaternion.Multiply(Body.Orientation, deltaRot));
        }

        // 5. Position integration (UpdatePhysicsInternal, simplified: grounded,
        //    no gravity participation for this scenario).
        Body.Position += Body.Velocity * Dt;

        // 6. Anim loop (GameWindow.cs:10247-10309): advance, drain AnimDone
        //    hooks into the manager countdown, zero-tick sweep.
        Seq.Advance(Dt);
        var hooks = Seq.ConsumePendingHooks();
        for (int i = 0; i < hooks.Count; i++)
        {
            if (hooks[i] is DatReaderWriter.Types.AnimationDoneHook)
                Seq.Manager.AnimationDone(success: true);
        }
        Seq.Manager.UseTime();

        // ── Observables ──
        uint substate = Seq.Manager.State.Substate;
        if (substate == Run) TicksInRun++;
        if (substate == Walk) TicksInWalkFwd++;
        bool inFwd = substate == Run || substate == Walk;
        if (inFwd)
        {
            _runStreak++;
            if (_runStreak > MaxRunStreak) MaxRunStreak = _runStreak;
        }
        else
        {
            _runStreak = 0;
        }
        if (inFwd && _prevSubstate != Run && _prevSubstate != Walk)
            RunInstalls++;
        _prevSubstate = substate;
    }

    public float Heading => MoveToMath.GetHeading(Body.Orientation);
    public float DistToPlayer => Vector3.Distance(Body.Position, PlayerPos);

    public void Snapshot(string tag)
    {
        string line = FormattableString.Invariant(
            $"t={Now,6:F2} {tag,-14} mt={Mgr.MovementTypeState,-14} substate=0x{Seq.Manager.State.Substate:X8} heading={Heading,6:F1} dist={DistToPlayer,6:F2} pending={Interp.MotionsPending()} omega.Z={ObservedOmega.Z,6:F3}");
        Trace.Add(line);
        _log?.WriteLine(line);
    }

    // ── Fixture ─────────────────────────────────────────────────────────────

    private static Animation MakeAnim(int numFrames)
    {
        var anim = new Animation();
        for (int f = 0; f < numFrames; f++)
        {
            var pf = new AnimationFrame(1u);
            pf.Frames.Add(new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity });
            anim.PartFrames.Add(pf);
        }
        return anim;
    }

    private static MotionData MakeMd(uint animId, float framerate = 30f,
        Vector3? velocity = null, Vector3? omega = null)
    {
        var md = new MotionData();
        QualifiedDataId<Animation> qid = animId;
        md.Anims.Add(new AnimData
        {
            AnimId = qid,
            LowFrame = 0,
            HighFrame = -1,
            Framerate = framerate,
        });
        if (velocity is { } v)
        {
            md.Velocity = v;
            md.Flags |= DatReaderWriter.Enums.MotionDataFlags.HasVelocity;
        }
        if (omega is { } o)
        {
            md.Omega = o;
            md.Flags |= DatReaderWriter.Enums.MotionDataFlags.HasOmega;
        }
        return md;
    }

    private static void AddLink(MotionTable mt, uint style, uint from, uint to, MotionData md)
    {
        int outer = (int)((style << 16) | (from & 0xFFFFFFu));
        if (!mt.Links.TryGetValue(outer, out var cmd))
        {
            cmd = new MotionCommandData();
            mt.Links[outer] = cmd;
        }
        cmd.MotionData[(int)to] = md;
    }

    /// <summary>
    /// Two-stance creature table shaped like the Mite Scamp's: NonCombat +
    /// Combat styles (default substate Ready in both), Walk/Run cycles with
    /// entry/exit links (15 frames @30fps = 0.5 s links, the realistic stop/
    /// start durations), a stance-transition link, an attack action link, and
    /// a global TurnRight physics-only modifier.
    /// </summary>
    private static (Setup, MotionTable, ChaseLoader) BuildFixture()
    {
        const uint ReadyAnimNC = 0x200u;
        const uint ReadyAnimC = 0x201u;
        const uint WalkAnim = 0x202u;
        const uint RunAnim = 0x203u;
        const uint ReadyToWalk = 0x204u;
        const uint WalkToReady = 0x205u;
        const uint ReadyToRun = 0x206u;
        const uint RunToReady = 0x207u;
        const uint StanceLink = 0x208u;   // NonCombat.Ready → Combat (draw)
        const uint AttackLink = 0x209u;   // Combat.Ready → attack swing
        const uint TurnAnim = 0x20Au;

        var setup = new Setup();
        setup.Parts.Add(0x01000000u);
        setup.DefaultScale.Add(Vector3.One);

        var loader = new ChaseLoader();
        loader.Register(ReadyAnimNC, MakeAnim(30));
        loader.Register(ReadyAnimC, MakeAnim(30));
        loader.Register(WalkAnim, MakeAnim(30));
        loader.Register(RunAnim, MakeAnim(30));
        loader.Register(ReadyToWalk, MakeAnim(15));
        loader.Register(WalkToReady, MakeAnim(15));
        loader.Register(ReadyToRun, MakeAnim(15));
        loader.Register(RunToReady, MakeAnim(15));
        loader.Register(StanceLink, MakeAnim(15));
        loader.Register(AttackLink, MakeAnim(45)); // 1.5 s swing
        loader.Register(TurnAnim, MakeAnim(30));

        var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombat };
        mt.StyleDefaults[(DRWMotionCommand)NonCombat] = (DRWMotionCommand)Ready;
        mt.StyleDefaults[(DRWMotionCommand)Combat] = (DRWMotionCommand)Ready;

        static int CycleKey(uint style, uint substate)
            => (int)((style << 16) | (substate & 0xFFFFFFu));

        mt.Cycles[CycleKey(NonCombat, Ready)] = MakeMd(ReadyAnimNC);
        mt.Cycles[CycleKey(Combat, Ready)] = MakeMd(ReadyAnimC);
        foreach (uint style in new[] { NonCombat, Combat })
        {
            mt.Cycles[CycleKey(style, Walk)] =
                MakeMd(WalkAnim, velocity: new Vector3(0f, 3.12f, 0f));
            mt.Cycles[CycleKey(style, Run)] =
                MakeMd(RunAnim, velocity: new Vector3(0f, 4.0f, 0f));
            AddLink(mt, style, Ready, Walk, MakeMd(ReadyToWalk));
            AddLink(mt, style, Walk, Ready, MakeMd(WalkToReady));
            AddLink(mt, style, Ready, Run, MakeMd(ReadyToRun));
            AddLink(mt, style, Run, Ready, MakeMd(RunToReady));
        }
        AddLink(mt, NonCombat, Ready, Combat, MakeMd(StanceLink));
        AddLink(mt, Combat, Ready, NonCombat, MakeMd(StanceLink));
        AddLink(mt, Combat, Ready, AttackAction, MakeMd(AttackLink));

        // Global (unstyled) TurnRight modifier — physics-only in Branch 4.
        mt.Modifiers[(int)(TurnRight & 0xFFFFFFu)] = MakeMd(TurnAnim);

        return (setup, mt, loader);
    }
}

public sealed class RemoteChaseEndToEndHarnessTests
{
    private readonly ITestOutputHelper _out;
    public RemoteChaseEndToEndHarnessTests(ITestOutputHelper output) => _out = output;

    private const float Dt = RemoteChaseHarness.Dt;

    private static int Seconds(float s) => (int)MathF.Round(s / Dt);

    /// <summary>
    /// The core chase cycle: aggro stance change, one mt-6 arm at a target
    /// 90° off the creature's facing, 15 m away, stationary. Retail bar: the
    /// stance links play out (~1 s), the chase turn starts, completes at the
    /// turn rate (90° at π/2·2.08 rad/s ≈ 0.5 s), and BeginMoveForward
    /// installs the forward cycle. Total budget: 4 s of ticks is generous.
    /// </summary>
    [Theory]
    [InlineData(90f)]    // target to the East → TurnRight path
    [InlineData(270f)]   // target to the West → TurnLeft path
    [InlineData(170f)]   // near-reversal → long right turn
    public void SingleArm_TurnCompletes_AndForwardInstalls(float bearingDeg)
    {
        var h = new RemoteChaseHarness(_out);

        float rad = (90f - bearingDeg) * MathF.PI / 180f; // compass → math angle
        h.PlayerPos = new Vector3(MathF.Cos(rad), MathF.Sin(rad), 0f) * 15f;
        h.PlayerVelocity = Vector3.Zero;

        // settle spawn state
        for (int i = 0; i < Seconds(0.5f); i++) h.Tick();
        h.Snapshot("spawned");

        // aggro: stance UM (the live capture's mt-0 stance=0x3C fwd=Ready)
        h.UmInterpreted(RemoteChaseHarness.Combat, RemoteChaseHarness.Ready);
        for (int i = 0; i < Seconds(1.5f); i++) h.Tick();
        h.Snapshot("post-stance");

        // the arm
        h.UmMoveToObject();
        h.Snapshot("armed");

        int installTick = -1;
        for (int i = 0; i < Seconds(6f); i++)
        {
            h.Tick();
            if (installTick < 0
                && (h.Seq.Manager.State.Substate == RemoteChaseHarness.Run
                    || h.Seq.Manager.State.Substate == RemoteChaseHarness.Walk))
            {
                installTick = i;
                h.Snapshot("fwd-install");
            }
            if (i % Seconds(0.5f) == 0) h.Snapshot("tick");
        }
        h.Snapshot("end");

        Assert.True(installTick >= 0,
            $"forward cycle never installed within 6 s of the arm (bearing {bearingDeg}°); " +
            $"final: mt={h.Mgr.MovementTypeState} substate=0x{h.Seq.Manager.State.Substate:X8} " +
            $"heading={h.Heading:F1} pending={h.Interp.MotionsPending()} omega.Z={h.ObservedOmega.Z:F3}");
        Assert.True(installTick <= Seconds(4f),
            $"forward cycle took {installTick * Dt:F2} s to install (bearing {bearingDeg}°) — " +
            "retail installs within the turn duration (~1-2 s)");
    }

    /// <summary>
    /// The live failure scenario: the player FLEES at 4 m/s and ACE re-arms
    /// mt-6 every 2 s (launch-drainq.log cadence). Retail bar: BeginMoveForward
    /// ≈ one per arm (21/22 in the live cdb trace) and the run is SUSTAINED —
    /// the forward substate holds for most of the chase.
    /// </summary>
    [Fact]
    public void FleeingTarget_RunSustainedAcrossRearms()
    {
        var h = new RemoteChaseHarness(_out);

        h.PlayerPos = new Vector3(0f, 10f, 0f);       // dead ahead, 10 m
        h.PlayerVelocity = new Vector3(0f, 4f, 0f);   // fleeing straight away

        h.UmInterpreted(RemoteChaseHarness.Combat, RemoteChaseHarness.Ready);
        for (int i = 0; i < Seconds(1.5f); i++) h.Tick();

        int arms = 0;
        int chaseTicks = Seconds(12f);
        for (int i = 0; i < chaseTicks; i++)
        {
            if (i % Seconds(2f) == 0)
            {
                h.UmMoveToObject();
                arms++;
                h.Snapshot($"arm#{arms}");
            }
            h.Tick();
            if (i % Seconds(1f) == 0) h.Snapshot("tick");
        }
        h.Snapshot("end");

        int fwdTicks = h.TicksInRun + h.TicksInWalkFwd;
        float fwdFraction = fwdTicks / (float)chaseTicks;
        _out.WriteLine(FormattableString.Invariant(
            $"arms={arms} installs={h.RunInstalls} fwdTicks={fwdTicks}/{chaseTicks} ({fwdFraction:P0}) maxStreak={h.MaxRunStreak * Dt:F2}s"));

        Assert.True(h.RunInstalls >= arms - 1,
            $"run installed only {h.RunInstalls}× across {arms} arms — " +
            "retail reinstalls per arm (21/22)");
        Assert.True(fwdFraction > 0.5f,
            $"forward substate held only {fwdFraction:P0} of the chase — the run is not " +
            "sustained (live #170 symptom: short bursts + idle glide)");
    }

    /// <summary>
    /// Attack interleave: mid-chase, an attack UM (mt-0, action list carrying
    /// the swing, fwd=Ready — the wire shape from the live capture) interrupts
    /// the moveto (retail-faithful), the swing plays, and the next mt-6 re-arm
    /// must reinstall the run. Also asserts the #170 drain criterion:
    /// pending_motions fully empties after the swing (add == done — the retail
    /// cdb invariant).
    /// </summary>
    [Fact]
    public void AttackUm_ThenRearm_RunReinstalls_AndQueueDrains()
    {
        var h = new RemoteChaseHarness(_out);

        h.PlayerPos = new Vector3(0f, 12f, 0f);
        h.PlayerVelocity = Vector3.Zero;

        h.UmInterpreted(RemoteChaseHarness.Combat, RemoteChaseHarness.Ready);
        for (int i = 0; i < Seconds(1.5f); i++) h.Tick();

        h.UmMoveToObject();
        for (int i = 0; i < Seconds(3f); i++) h.Tick();
        h.Snapshot("chasing");

        // the swing: interrupt + action (stamp 1, autonomous false)
        h.UmInterpreted(RemoteChaseHarness.Combat, RemoteChaseHarness.Ready, 1f,
            new InboundMotionAction(RemoteChaseHarness.AttackAction, Stamp: 1,
                Autonomous: false, Speed: 1f));
        for (int i = 0; i < Seconds(2.5f); i++) h.Tick();
        h.Snapshot("post-swing");

        Assert.False(h.Interp.MotionsPending(),
            "pending_motions did not fully empty after the swing — the #170 " +
            "residual (retail: add_to_queue == MotionDone exactly)");

        // the player breaks away (out of attack range), then ACE re-arms —
        // the run must come back
        h.PlayerPos += new Vector3(0f, 10f, 0f);
        h.UmMoveToObject();
        int installTick = -1;
        for (int i = 0; i < Seconds(5f); i++)
        {
            h.Tick();
            if (installTick < 0
                && (h.Seq.Manager.State.Substate == RemoteChaseHarness.Run
                    || h.Seq.Manager.State.Substate == RemoteChaseHarness.Walk))
            {
                installTick = i;
            }
        }
        h.Snapshot("post-rearm");

        Assert.True(installTick >= 0,
            $"run did not reinstall after the post-swing re-arm; " +
            $"mt={h.Mgr.MovementTypeState} substate=0x{h.Seq.Manager.State.Substate:X8} " +
            $"pending={h.Interp.MotionsPending()}");
    }
}