erik/acdream
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

fix(R4): #161 remote landing stuck in falling pose - apply-pass params decode

Browse source 
Retail's apply_interpreted_movement (0x00528600) does NOT dispatch with
ctor-default MovementParameters: the BN decomp smears the bitfield store
into the mush expression at raw 305778 - (word & 0x37ff) | cancelMoveTo<<15
| disableJump<<17 - which CLEARS SetHoldKey/ModifyInterpretedState/
CancelMoveTo. ACE MotionInterp.cs:444-449 confirms independently. Three
legs fixed, all retail decode, no adaptations added:

1. ApplyInterpretedMovement now builds the pass params retail actually
   uses (ModifyInterpretedState=false is load-bearing): no dispatch in the
   pass writes InterpretedState, so the airborne Falling substitution
   PRESERVES the wire's forward command and HitGround's re-apply
   dispatches it - the motion table plays the Falling->X landing link.
   The W6 entry-cache (built on the wrong "retail self-heals via hoisted
   registers" theory) is deleted; live reads are retail semantics. Raw
   arg3 decoded as DisableJumpDuringLink -> every (N,0) caller means
   allowJump=true; all 9 caller polarities fixed. copy_movement_from's
   current_style copy (raw 0051e757) added to the UM flat-copy.

2. Both GameWindow landing blocks cleared the Gravity state bit BEFORE
   Motion.HitGround(), whose verbatim state&0x400 gate then no-opped the
   whole retail re-apply; the UP-driven landing block never called
   HitGround at all. Both now run HitGround (minterp then moveto,
   MovementManager::HitGround 0x00524300 order) with Gravity still set,
   then do the DR bookkeeping clear (register row AP-81 added for the
   remaining flag dance, retire in R6).

3. K-fix17's forced SetCycle (both copies) deleted: it executed every
   landing but read the leg-1-clobbered ForwardCommand (0x40000015) and
   re-set the very Falling cycle it meant to clear.

Tests: new HitGround_AfterFall_RedispatchesPreservedForward_ExitsFalling
lifecycle pin; AirborneBody state assertion flipped (it had pinned the
bug value). Suite 3,964 green incl. the 183-case retail-observer trace.
Filed #164 (action-replay Autonomous bit, no current consumer).

Awaiting live verify: stand-still landing must exit the falling pose with
zero wire input.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Erik 2026-07-03 17:00:03 +02:00
parent 790938392f
commit b1cf01029a
6 changed files with 280 additions and 199 deletions
Download patch file Download diff file Expand all files Collapse all files

74
src/AcDream.App/Rendering/GameWindow.cs
View file

@ -5403,27 +5403,30 @@ public sealed class GameWindow : IDisposable
{
rmState.Airborne = false;
rmState.Body.Velocity = System.Numerics.Vector3.Zero;
rmState.Body.State &= ~AcDream.Core.Physics.PhysicsStateFlags.Gravity;
rmState.Body.TransientState |= AcDream.Core.Physics.TransientStateFlags.Contact
| AcDream.Core.Physics.TransientStateFlags.OnWalkable;
rmState.Interp.Clear();
rmState.Body.Position = worldPos;
// Reset the sequencer out of Falling — see matching block in
// TickAnimations Step 5 (env-var path) for rationale.
// #161: retail landing = MovementManager::HitGround
// (minterp → moveto, 0x00524300) with the Gravity state
// bit STILL SET (CMotionInterp::HitGround gates on
// state&0x400). The re-apply dispatches the PRESERVED
// pre-fall forward command → landing link → cycle. This
// replaces the forced SetCycle, which read the
// then-clobbered ForwardCommand (Falling) and re-set the
// pose it meant to clear. See the twin block in
// TickAnimations (VU.land).
if (_animatedEntities.TryGetValue(entity.Id, out var aeForLand)
&& aeForLand.Sequencer is not null)
{
uint style = aeForLand.Sequencer.CurrentStyle != 0
? aeForLand.Sequencer.CurrentStyle
: 0x8000003Du;
uint landingCmd = rmState.Motion.InterpretedState.ForwardCommand;
if (landingCmd == 0)
landingCmd = AcDream.Core.Physics.MotionCommand.Ready;
float landingSpeed = rmState.Motion.InterpretedState.ForwardSpeed;
if (landingSpeed <= 0f) landingSpeed = 1f;
aeForLand.Sequencer.SetCycle(style, landingCmd, landingSpeed);
EnsureRemoteMotionBindings(rmState, aeForLand, update.Guid);
}
rmState.Motion.HitGround();
rmState.MoveTo?.HitGround();
// DR bookkeeping only (partner of the jump-start
// `State |= Gravity`).
rmState.Body.State &= ~AcDream.Core.Physics.PhysicsStateFlags.Gravity;
return;
}
@ -10045,9 +10048,22 @@ public sealed class GameWindow : IDisposable
rm.Airborne = false;
rm.Body.TransientState |= AcDream.Core.Physics.TransientStateFlags.Contact
| AcDream.Core.Physics.TransientStateFlags.OnWalkable;
rm.Body.State &= ~AcDream.Core.Physics.PhysicsStateFlags.Gravity;
rm.Body.Velocity = new System.Numerics.Vector3(
rm.Body.Velocity.X, rm.Body.Velocity.Y, 0f);
// #161: HitGround MUST run with the Gravity state
// bit still set — CMotionInterp::HitGround
// (0x00528ac0) gates on state&0x400 (retail never
// clears GRAVITY on landing; it's a persistent
// object property). Clearing it first made this
// re-apply a silent no-op, which is why the
// falling pose never exited. The re-apply
// dispatches the PRESERVED pre-fall forward
// command through the funnel → the motion table
// plays the Falling→X landing link. (The old
// K-fix17 forced SetCycle is deleted: it read the
// then-clobbered InterpretedState.ForwardCommand
// — 0x40000015 — and re-set the very Falling
// cycle it meant to clear.)
rm.Motion.HitGround();
// R4-V5 (closes the V4 wiring-contract gap the
// adversarial review caught): retail order —
@ -10057,34 +10073,10 @@ public sealed class GameWindow : IDisposable
// without it a chasing NPC that lands stalls
// until ACE's ~1 Hz re-emit.
rm.MoveTo?.HitGround();
// K-fix17 (2026-04-26): reset the sequencer cycle
// from Falling back to whatever the interpreted
// motion state says they should be doing now.
// Without this, the remote stays in the Falling
// pose forever (legs folded) until the next
// server-sent UpdateMotion arrives. Use the
// sequencer's current style (preserved across
// jump) and pick the cycle from
// InterpretedState.ForwardCommand: Ready
// (idle), WalkForward, RunForward, WalkBackward.
// SideStep / Turn aren't strict locomotion
// priorities — the next UM the server sends will
// refine the cycle if the player is mid-strafe
// when they land; this just gets the legs out
// of Falling immediately.
if (ae.Sequencer is not null)
{
uint style = ae.Sequencer.CurrentStyle != 0
? ae.Sequencer.CurrentStyle
: 0x8000003Du;
uint landingCmd = rm.Motion.InterpretedState.ForwardCommand;
if (landingCmd == 0)
landingCmd = AcDream.Core.Physics.MotionCommand.Ready;
float landingSpeed = rm.Motion.InterpretedState.ForwardSpeed;
if (landingSpeed <= 0f) landingSpeed = 1f;
ae.Sequencer.SetCycle(style, landingCmd, landingSpeed);
}
// DR bookkeeping only (partner of the jump-start
// `State |= Gravity`): stops the per-tick gravity
// integration for the grounded body.
rm.Body.State &= ~AcDream.Core.Physics.PhysicsStateFlags.Gravity;
if (Environment.GetEnvironmentVariable("ACDREAM_DUMP_MOTION") == "1")
Console.WriteLine($"VU.land guid=0x{serverGuid:X8} Z={rm.Body.Position.Z:F2}");

203
src/AcDream.Core/Physics/MotionInterpreter.cs
View file

@ -1749,11 +1749,14 @@ public sealed class MotionInterpreter : IMotionDoneSink
bool isThePlayer = WeenieObj is null || WeenieObj.IsThePlayer();
if (isThePlayer && PhysicsObj.LastMoveWasAutonomous)
{
apply_raw_movement(cancelMoveTo: false, allowJump: false);
// Raw (0, 0): arg3 is DisableJumpDuringLink → allowJump: true
// (#161 polarity decode; consumed since the apply-pass params
// became real).
apply_raw_movement(cancelMoveTo: false, allowJump: true);
return;
}
ApplyCurrentMovementInterpreted(cancelMoveTo: false, allowJump: false);
ApplyCurrentMovementInterpreted(cancelMoveTo: false, allowJump: true);
}
// ── FUN_00528920 / FUN_00528970 — SetWeenieObject / SetPhysicsObject ───────
@ -1800,11 +1803,13 @@ public sealed class MotionInterpreter : IMotionDoneSink
bool isThePlayer = weenie is null || weenie.IsThePlayer();
if (isThePlayer && PhysicsObj.LastMoveWasAutonomous)
{
apply_raw_movement(cancelMoveTo: true, allowJump: false);
// Raw (1, 0): cancelMoveTo set, DisableJumpDuringLink clear →
// allowJump: true (#161 polarity decode).
apply_raw_movement(cancelMoveTo: true, allowJump: true);
return;
}
ApplyCurrentMovementInterpreted(cancelMoveTo: true, allowJump: false);
ApplyCurrentMovementInterpreted(cancelMoveTo: true, allowJump: true);
}
/// <summary>
@ -1848,11 +1853,12 @@ public sealed class MotionInterpreter : IMotionDoneSink
bool isThePlayer = WeenieObj is null || WeenieObj.IsThePlayer();
if (isThePlayer && physicsObj.LastMoveWasAutonomous)
{
apply_raw_movement(cancelMoveTo: true, allowJump: false);
// Raw (1, 0) → allowJump: true (#161 polarity decode).
apply_raw_movement(cancelMoveTo: true, allowJump: true);
return;
}
ApplyCurrentMovementInterpreted(cancelMoveTo: true, allowJump: false);
ApplyCurrentMovementInterpreted(cancelMoveTo: true, allowJump: true);
}
// ── FUN_00527a50 — jump_charge_is_allowed ─────────────────────────────────
@ -2506,7 +2512,8 @@ public sealed class MotionInterpreter : IMotionDoneSink
JumpExtent = 0f;
RemoveLinkAnimations?.Invoke();
apply_current_movement(cancelMoveTo: false, allowJump: false);
// Raw (0, 0) → allowJump: true (#161 polarity decode).
apply_current_movement(cancelMoveTo: false, allowJump: true);
}
// ── FUN_00528ac0 — HitGround ──────────────────────────────────────────────
@ -2551,7 +2558,11 @@ public sealed class MotionInterpreter : IMotionDoneSink
return;
RemoveLinkAnimations?.Invoke();
apply_current_movement(cancelMoveTo: false, allowJump: false);
// Raw (0, 0) → allowJump: true (#161 polarity decode). The
// re-apply dispatches the PRESERVED interpreted forward command
// (the apply pass never writes it — ModifyInterpretedState=false)
// — this IS the falling-pose exit on landing.
apply_current_movement(cancelMoveTo: false, allowJump: true);
}
// ── FUN_00528c80 — enter_default_state ────────────────────────────────────
@ -2638,7 +2649,8 @@ public sealed class MotionInterpreter : IMotionDoneSink
if (runKeyUp != notCurrentlyRun)
{
RawState.CurrentHoldKey = holdingRun ? HoldKey.Run : HoldKey.None;
apply_current_movement(cancelMoveTo: interrupt, allowJump: false);
// Raw (arg3, 0) → allowJump: true (#161 polarity decode).
apply_current_movement(cancelMoveTo: interrupt, allowJump: true);
}
}
@ -2694,13 +2706,14 @@ public sealed class MotionInterpreter : IMotionDoneSink
if (current == HoldKey.Run)
{
RawState.CurrentHoldKey = HoldKey.None;
apply_current_movement(cancelMoveTo, allowJump: false);
// Raw (arg3, 0) → allowJump: true (#161 polarity decode).
apply_current_movement(cancelMoveTo, allowJump: true);
}
}
else if (key == HoldKey.Run && current != HoldKey.Run)
{
RawState.CurrentHoldKey = HoldKey.Run;
apply_current_movement(cancelMoveTo, allowJump: false);
apply_current_movement(cancelMoveTo, allowJump: true);
}
}
@ -2815,6 +2828,11 @@ public sealed class MotionInterpreter : IMotionDoneSink
bool allowJump = MotionAllowsJump(InterpretedState.ForwardCommand) == WeenieError.None;
// copy_movement_from — flat overwrite, no per-field presence checks.
// current_style is the FIRST copied field (raw 0051e757) — it is
// what HitGround/LeaveGround re-applies as the style dispatch
// (#161: previously omitted, so the landing re-apply read a stale
// interpreted style).
InterpretedState.CurrentStyle = ims.CurrentStyle;
InterpretedState.ForwardCommand = ims.ForwardCommand;
InterpretedState.ForwardSpeed = ims.ForwardSpeed;
InterpretedState.SideStepCommand = ims.SideStepCommand;
@ -2872,24 +2890,31 @@ public sealed class MotionInterpreter : IMotionDoneSink
/// </para>
///
/// <para>
/// <b>R3-W4 (closes J11's param-plumbing leg):</b> <paramref name="cancelMoveTo"/>/
/// <paramref name="allowJump"/> are retail's <c>arg2</c>/<c>arg3</c> —
/// threaded through NOW per the plan (every real caller already has an
/// opinion: <see cref="apply_current_movement"/>'s dual-dispatch tail
/// passes its own args through unchanged; <see cref="MoveToInterpretedState"/>
/// passes <c>(true, motion_allows_jump(OLD forward_command) == 0)</c> per
/// the Adjacent finding). Their ONLY retail consumer in this function is
/// the garbled tail expression at raw 305778
/// (<c>(((arg3&amp;1)&lt;&lt;2)|(arg2&amp;1))&lt;&lt;0xf</c> feeding an
/// uninitialized-local byte test before conditionally calling
/// <c>InterpretedMotionState::RemoveMotion(0x6500000d)</c> a SECOND time)
/// — a BN x87/uninit-local artifact class, not a readable retail
/// algorithm. TODO(W5): resolve that tail against a clean decompile (or
/// cdb capture) once <c>MovementParameters</c> flows through this
/// funnel end to end; until then the params are accepted and preserved
/// for signature parity but do not change this function's control flow
/// (matches the funnel's existing "no MovementParameters yet" posture,
/// e.g. <see cref="DispatchInterpretedMotion"/>'s own TODO(W5)).
/// <b>#161 (2026-07-03, closes R3-W4's TODO(W5)):</b> retail builds ONE
/// <c>MovementParameters</c> for the whole pass
/// (<c>MovementParameters::MovementParameters(&amp;var_2c)</c> @305719)
/// and then rewrites its bitfield: the "garbled tail expression" at raw
/// 305778 is the BN decompiler smearing that store into its single read
/// site — <c>(word &amp; 0x37ff) | (arg2&amp;1)&lt;&lt;15 |
/// (arg3&amp;1)&lt;&lt;17</c> clears bits 11/14/15 (<c>SetHoldKey</c> /
/// <c>ModifyInterpretedState</c> / <c>CancelMoveTo</c>), re-sets bit 15
/// from <c>arg2</c> (= <paramref name="cancelMoveTo"/>) and bit 17 from
/// <c>arg3</c> (= <c>DisableJumpDuringLink</c>, so
/// <paramref name="allowJump"/> = <c>arg3 == 0</c>). ACE
/// MotionInterp.cs:444-449 confirms independently. The load-bearing bit
/// is <c>ModifyInterpretedState = false</c>: NO dispatch issued by this
/// pass writes <see cref="InterpretedState"/> — the airborne Falling
/// substitution leaves the wire's forward command intact, which is what
/// lets <see cref="HitGround"/>'s re-apply dispatch the PRESERVED
/// pre-fall command (the motion table then plays the Falling→X landing
/// link — the falling-pose exit needs no wire input). The previous
/// revision dispatched with ctor-default params
/// (<c>ModifyInterpretedState = true</c>) — the #161 stuck-falling-pose
/// root cause, and the true mechanism behind the W6 "press W and stop
/// instantly" regression (the style dispatch could never have clobbered
/// forward_command in retail; the entry-cache workaround this body used
/// to carry is deleted — with no mid-pass state writes possible, live
/// field reads ARE retail's semantics).
/// </para>
/// </summary>
public void ApplyInterpretedMovement(
@ -2898,67 +2923,61 @@ public sealed class MotionInterpreter : IMotionDoneSink
{
if (PhysicsObj is null) return;
// cancelMoveTo/allowJump: accepted for signature parity (see the
// TODO(W5) above) — not yet consumed by this function's body.
_ = cancelMoveTo;
_ = allowJump;
// ENTRY-CACHE all axis values BEFORE the style dispatch (W6 stop-bug
// fix, 2026-07-03). The style dispatch's success path runs
// InterpretedMotionState::ApplyMotion(style), whose style branch
// resets forward_command to Ready UNCONDITIONALLY (raw 0051ea6c —
// verbatim). Retail SELF-HEALS because its compiled apply pass reads
// the axis fields into registers before the style call, so the fwd
// dispatch re-applies the pre-reset command (proven by our own
// 183-case live-retail observer trace: the fwd dispatch carries the
// wire's RunForward after the style dispatch on the same UM — the
// BN pseudo-C's apparent post-style field reads at 0x528687 are
// decompiler rendering of hoisted registers, the same artifact
// class as the A1 polarity). A live-field read here dispatched
// READY after every style apply, leaving the field permanently
// Ready — the "press W and stop instantly" W6 regression.
uint entryFwdCmd = InterpretedState.ForwardCommand;
float entryFwdSpeed = InterpretedState.ForwardSpeed;
uint entrySideCmd = InterpretedState.SideStepCommand;
float entrySideSpeed = InterpretedState.SideStepSpeed;
uint entryTurnCmd = InterpretedState.TurnCommand;
float entryTurnSpeed = InterpretedState.TurnSpeed;
if (entryFwdCmd == MotionCommand.RunForward)
MyRunRate = entryFwdSpeed;
DispatchInterpretedMotion(currentStyle, 1.0f, sink);
if (!contact_allows_move(entryFwdCmd))
// Retail's rewritten var_2c (raw 305778 decoded; ACE 444-449):
// Speed is re-set per axis below, everything else rides the pass.
var p = new MovementParameters
{
DispatchInterpretedMotion(MotionCommand.Falling, 1.0f, sink);
SetHoldKey = false,
ModifyInterpretedState = false,
CancelMoveTo = cancelMoveTo,
DisableJumpDuringLink = !allowJump,
};
if (InterpretedState.ForwardCommand == MotionCommand.RunForward)
MyRunRate = InterpretedState.ForwardSpeed;
p.Speed = 1.0f;
DoInterpretedMotion(currentStyle, p, sink);
if (!contact_allows_move(InterpretedState.ForwardCommand))
{
p.Speed = 1.0f; // raw 305728: var_18_2 = 0x3f800000
DoInterpretedMotion(MotionCommand.Falling, p, sink);
}
else if (StandingLongJump)
{
DispatchInterpretedMotion(MotionCommand.Ready, 1.0f, sink);
DispatchStopInterpretedMotion(MotionCommand.SideStepRight, sink);
p.Speed = 1.0f;
DoInterpretedMotion(MotionCommand.Ready, p, sink);
StopInterpretedMotion(MotionCommand.SideStepRight, p, sink);
}
else
{
DispatchInterpretedMotion(entryFwdCmd, entryFwdSpeed, sink);
if (entrySideCmd == 0)
DispatchStopInterpretedMotion(MotionCommand.SideStepRight, sink);
p.Speed = InterpretedState.ForwardSpeed;
DoInterpretedMotion(InterpretedState.ForwardCommand, p, sink);
if (InterpretedState.SideStepCommand == 0)
{
StopInterpretedMotion(MotionCommand.SideStepRight, p, sink);
}
else
DispatchInterpretedMotion(entrySideCmd, entrySideSpeed, sink);
{
p.Speed = InterpretedState.SideStepSpeed;
DoInterpretedMotion(InterpretedState.SideStepCommand, p, sink);
}
}
if (entryTurnCmd != 0)
if (InterpretedState.TurnCommand != 0)
{
DispatchInterpretedMotion(entryTurnCmd, entryTurnSpeed, sink);
p.Speed = InterpretedState.TurnSpeed;
DoInterpretedMotion(InterpretedState.TurnCommand, p, sink);
return; // retail early return — no idle-stop this call
}
// Tail (raw 305766-305786): unconditional StopInterpretedMotion(TurnRight,
// params) — the merged StopInterpretedMotion ITSELF performs the
// add_to_queue(context, Ready, 0) + RemoveMotion(TurnRight) on
// success, so no separate AddToQueue call is needed here anymore
// (R3-W5 moves this bookkeeping into the merged function body).
DispatchStopInterpretedMotion(MotionCommand.TurnRight, sink);
// add_to_queue(context, Ready, 0) on success; with the pass params'
// ModifyInterpretedState=false the RemoveMotion(TurnRight) state
// clear does NOT fire (retail identical — ACE 497-498).
StopInterpretedMotion(MotionCommand.TurnRight, p, sink);
}
/// <summary>
@ -3263,33 +3282,17 @@ public sealed class MotionInterpreter : IMotionDoneSink
}
/// <summary>
/// R3-W5 internal per-axis dispatch primitive
/// (<c>DispatchInterpretedMotion</c>, formerly the S2a funnel's public
/// surface). <see cref="ApplyInterpretedMovement"/>'s four
/// <c>DoInterpretedMotion</c>-shaped calls (style, forward-or-Falling,
/// sidestep, turn) each need to dispatch through an EXPLICIT per-call
/// <paramref name="sink"/> (a remote entity's own sink, threaded in from
/// <see cref="MoveToInterpretedState"/>) — retail's own
/// <c>apply_interpreted_movement</c> calls <c>CMotionInterp::DoInterpretedMotion</c>
/// directly (the SAME function
/// <see cref="DoInterpretedMotion(uint,MovementParameters,IInterpretedMotionSink?)"/>
/// implements) with a fresh local <c>MovementParameters</c> per axis —
/// this wraps that shape with a throwaway params object carrying only
/// <c>Speed</c> (ctor default for everything else, matching retail's own
/// local <c>var_2c</c>).
/// R3-W5 internal dispatch primitive (formerly the S2a funnel's public
/// surface), now used ONLY by <see cref="MoveToInterpretedState"/>'s
/// action-replay loop — retail's action dispatches (raw 305983) use the
/// UM apply's ctor-default <c>var_2c</c> (notably
/// <c>ModifyInterpretedState = true</c>, so replayed actions DO enter the
/// interpreted actions list via <c>InterpretedMotionState::AddAction</c>),
/// unlike the apply pass's rewritten params (see
/// <see cref="ApplyInterpretedMovement"/>). Known residual gap: retail
/// also sets the params' <c>Autonomous</c> bit (0x1000) per action (raw
/// 305982) — not yet threaded (tracked in ISSUES, #161 follow-up note).
/// </summary>
private WeenieError DispatchInterpretedMotion(uint motion, float speed, IInterpretedMotionSink? sink)
=> DoInterpretedMotion(motion, new MovementParameters { Speed = speed }, sink);
/// <summary>
/// R3-W5 internal per-axis STOP primitive — the
/// <see cref="StopInterpretedMotion(uint,MovementParameters,IInterpretedMotionSink?)"/>
/// analogue of <see cref="DispatchInterpretedMotion"/>, used by
/// <see cref="ApplyInterpretedMovement"/>'s sidestep-stop/turn-stop tail
/// calls (raw 305739/305748/305770 — retail's own
/// <c>CPhysicsObj::StopInterpretedMotion</c> calls with a fresh local
/// <c>MovementParameters</c>).
/// </summary>
private WeenieError DispatchStopInterpretedMotion(uint motion, IInterpretedMotionSink? sink)
=> StopInterpretedMotion(motion, new MovementParameters(), sink);
}