From 00c8a4feb5f87a9605bed833b36be549781e99a3 Mon Sep 17 00:00:00 2001 From: Erik Date: Sun, 19 Apr 2026 16:22:35 +0200 Subject: [PATCH] fix(anim): stop ACE echo from clobbering player's speedMod; synthesize sequencer velocity MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two related bugs in the motion/animation pipeline: 1. Player's local animation was getting reset to speedMod=1.0 every ~100ms. ACE's BroadcastMovement echoes the player's own motion back via UpdateMotion. When ACE's ForwardSpeed == 1.0, the ForwardSpeed flag is omitted (InterpretedMotionState.BuildMovementFlags), so our wire parser returns null and we default to speedMod=1.0 — clobbering the locally-authoritative 2.375 × runRate that UpdatePlayerAnimation just set. Legs would crank up to full cadence for one frame then get slammed back to walking rate. Fix: for the player's own guid, skip the wire-echo SetCycle entirely. UpdatePlayerAnimation is the authoritative driver for the local player's animation; the server echo is only useful for observers of other characters. User-confirmed: legs now hold their full cadence. 2. Remote entities teleported between UpdatePositions because the sequencer's CurrentVelocity was always zero (Humanoid dat ships every locomotion MotionData with Flags=0x00, so EnqueueMotionData leaves CurrentVelocity at Vector3.Zero). Dead-reckoning's Priority 1 (sequencer velocity) never triggered, falling through to EMA which has bootstrap lag + gets polluted by teleport-class server snaps. Fix: synthesize CurrentVelocity in SetCycle from the retail locomotion constants (WalkAnimSpeed=3.12, RunAnimSpeed=4.0, SidestepAnimSpeed=1.25) × speedMod, matching the decompiled get_state_velocity (FUN_00528960) which uses these same constants directly instead of MotionData.Velocity. The dat's HasVelocity field is reserved for non-locomotion motions (kick-off velocities, flying creatures, etc). Diag confirmed synthesis fires and DR picks it up with src=seq and correct magnitude. More visual polish may still be needed for the "lagging remote" symptom — see follow-up. Also adds `PlayerMovementController.BodyVelocity` utility getter for HUD/ debug use, and `ACDREAM_ANIM_SPEED_SCALE` env var as a tunable knob for visual pacing overrides. All 717 tests green. Co-Authored-By: Claude Opus 4.7 (1M context) --- .../Input/PlayerMovementController.cs | 3 + src/AcDream.App/Rendering/GameWindow.cs | 42 +++++++++++- .../Physics/AnimationSequencer.cs | 67 +++++++++++++++++++ 3 files changed, 110 insertions(+), 2 deletions(-) diff --git a/src/AcDream.App/Input/PlayerMovementController.cs b/src/AcDream.App/Input/PlayerMovementController.cs index f533b4c..38dcb58 100644 --- a/src/AcDream.App/Input/PlayerMovementController.cs +++ b/src/AcDream.App/Input/PlayerMovementController.cs @@ -117,6 +117,9 @@ public sealed class PlayerMovementController /// public float VerticalVelocity => _body.Velocity.Z; + /// Full 3D world-space velocity of the physics body. Exposed for diagnostic logging. + public Vector3 BodyVelocity => _body.Velocity; + // Jump charge state. private bool _jumpCharging; private float _jumpExtent; diff --git a/src/AcDream.App/Rendering/GameWindow.cs b/src/AcDream.App/Rendering/GameWindow.cs index c5453fd..0e50e1a 100644 --- a/src/AcDream.App/Rendering/GameWindow.cs +++ b/src/AcDream.App/Rendering/GameWindow.cs @@ -1661,7 +1661,32 @@ public sealed class GameWindow : IDisposable // No-op if same; the sequencer's fast path guards against that. uint priorMotion = ae.Sequencer.CurrentMotion; - ae.Sequencer.SetCycle(fullStyle, fullMotion, speedMod); + + // CRITICAL: for the local player, UpdatePlayerAnimation is the + // authoritative driver of the sequencer. ACE's BroadcastMovement + // echoes the player's own motion back, but: + // (a) ACE's own ForwardSpeed is `creature.GetRunRate()`, which + // may differ from our locally-computed runRate (ACDREAM_RUN_SKILL + // vs real server-side skills). + // (b) ACE omits the ForwardSpeed flag when speed == 1.0 (per + // InterpretedMotionState.BuildMovementFlags). When omitted, + // our wire parser returns null and we'd default to 1.0 — + // clobbering our locally-authoritative 2.375 × animScale + // and leaving the legs at 30 fps cadence regardless of + // actual run rate. + // So: for the player's own guid, skip the wire-echo SetCycle. + // UpdatePlayerAnimation has already set the correct cycle with + // our locally-chosen speedMod, and that value should persist + // until the next local motion change. + if (update.Guid == _playerServerGuid) + { + // Still update the stance echo (_playerMotionTableId, etc) via + // the paths above, but don't stomp the animation sequencer. + } + else + { + ae.Sequencer.SetCycle(fullStyle, fullMotion, speedMod); + } // CRITICAL: when we enter a locomotion cycle (Walk/Run/etc), // stamp the _remoteLastMove timestamp to "now". Without this, @@ -4063,7 +4088,20 @@ public sealed class GameWindow : IDisposable { animSpeed = fs; } - ae.Sequencer.SetCycle(fullStyle, animCommand, animSpeed); + // ACDREAM_ANIM_SPEED_SCALE: optional visual-pacing knob. Retail's + // animation framerate scales linearly with speedMod (r03 §8.3), + // and our speedMod = runRate. If the visual feel doesn't match + // retail, override via env var (default 1.0 = no change). + float animScale = 1.0f; + if (float.TryParse( + Environment.GetEnvironmentVariable("ACDREAM_ANIM_SPEED_SCALE"), + System.Globalization.NumberStyles.Float, + System.Globalization.CultureInfo.InvariantCulture, + out var s) && s > 0f) + { + animScale = s; + } + ae.Sequencer.SetCycle(fullStyle, animCommand, animSpeed * animScale); } // Legacy path: update the manual slerp fields (for entities without sequencer) diff --git a/src/AcDream.Core/Physics/AnimationSequencer.cs b/src/AcDream.Core/Physics/AnimationSequencer.cs index 4d77ef2..0a8249f 100644 --- a/src/AcDream.Core/Physics/AnimationSequencer.cs +++ b/src/AcDream.Core/Physics/AnimationSequencer.cs @@ -426,8 +426,75 @@ public sealed class AnimationSequencer CurrentStyle = style; CurrentMotion = motion; CurrentSpeedMod = speedMod; + + // ── Synthesize CurrentVelocity for locomotion cycles ────────────── + // The Humanoid motion table ships every locomotion MotionData with + // Flags=0x00 (no HasVelocity), so EnqueueMotionData leaves + // CurrentVelocity at Vector3.Zero. That matches the literal retail + // dat, but retail's body physics uses CMotionInterp::get_state_velocity + // (FUN_00528960) which returns RunAnimSpeed × ForwardSpeed for + // RunForward, independent of the dat's HasVelocity flag. The dat + // velocity is a separate additive source (kick-off velocity, flying + // creatures, etc) not the primary locomotion drive. + // + // For our sequencer's to be usable by + // consumers (local-player get_state_velocity via Option B, remote + // dead-reckoning in GameWindow) it must carry the retail-constant + // locomotion value when the dat is silent. Synthesize it here, + // post-EnqueueMotionData, only when the cycle is a locomotion cycle + // AND the dat didn't populate it. + // + // Constants match etc — + // decompiled from _DAT_007c96e0/e4/e8. The velocity is body-local + // (+Y = forward, +X = right); consumers rotate into world space via + // the owning entity's orientation. + if (CurrentVelocity.LengthSquared() < 1e-9f) + { + float yvel = 0f; + float xvel = 0f; + // Low byte of the ORIGINAL (non-adjusted) motion tells us which + // intent the caller signalled. adjust_motion may have remapped + // TurnLeft → TurnRight / SideStepLeft → SideStepRight / + // WalkBackward → WalkForward, encoding the sign into adjustedSpeed. + // The speed sign is preserved in adjustedSpeed so we multiply by + // it rather than re-deriving per-case. + uint low = motion & 0xFFu; + switch (low) + { + case 0x05: // WalkForward + yvel = WalkAnimSpeed * adjustedSpeed; + break; + case 0x06: // WalkBackward — adjust_motion remapped to WalkForward + // with speedMod *= -0.65f, so adjustedSpeed already + // carries the factor. But the motion arg we see + // here is the original (pre-adjust) 0x06, so we + // still use WalkAnimSpeed — the negative sign of + // adjustedSpeed flips the direction correctly. + yvel = WalkAnimSpeed * adjustedSpeed; + break; + case 0x07: // RunForward + yvel = RunAnimSpeed * adjustedSpeed; + break; + case 0x0F: // SideStepRight + xvel = SidestepAnimSpeed * adjustedSpeed; + break; + case 0x10: // SideStepLeft — remapped to SideStepRight with + // negated speed; same handling as backward walk. + xvel = SidestepAnimSpeed * adjustedSpeed; + break; + } + if (yvel != 0f || xvel != 0f) + CurrentVelocity = new Vector3(xvel, yvel, 0f); + } } + // Retail locomotion constants — mirror of MotionInterpreter.RunAnimSpeed + // etc. Kept here to keep AnimationSequencer self-contained for the + // synthesize-velocity path above. Values decompiled from _DAT_007c96e0/e4/e8. + private const float WalkAnimSpeed = 3.12f; + private const float RunAnimSpeed = 4.0f; + private const float SidestepAnimSpeed = 1.25f; + /// /// Scale every cyclic node's framerate by , mirroring /// ACE's Sequence.multiply_cyclic_animation_framerate