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

fix(anim): Phase L.1b route motion commands

Browse source
This commit is contained in:
Erik 2026-04-28 10:46:22 +02:00
parent 1c69670392
commit 460f95cb42
6 changed files with 218 additions and 53 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -2435,57 +2435,20 @@ public sealed class GameWindow : IDisposable
dr.LastServerPosTime = (refreshedTime - System.DateTime.UnixEpoch).TotalSeconds;
}
// Route the Commands list — one-shot Actions, Modifiers, and
// ChatEmotes (mask classes 0x10, 0x20, 0x13 per r03 §3). These
// live in the motion table's Links / Modifiers dicts, not
// Cycles, and are played on top of the current cycle via
// PlayAction which resolves the right dict and interleaves the
// action frames before the cyclic tail.
//
// A typical NPC wave looks like:
// ForwardCommand=0 (Ready) + Commands=[{0x0087=Wave, speed=1.0}]
// [{0x0003=Ready, ...}]
// Each item runs through PlayAction (for 0x10/0x20 mask) or the
// standard SetCycle path (for 0x40 SubState). We leave SubState
// commands to fall through to the next UpdateMotion; that's how
// retail handles transition sequences (Wave → Ready).
// Route command-list entries through the shared Core router.
// Retail/ACE send these as 16-bit MotionCommand lows in
// InterpretedMotionState.Commands[]; the router reconstructs the
// class byte and chooses PlayAction for actions/modifiers/emotes
// or SetCycle for persistent substates.
if (update.MotionState.Commands is { Count: > 0 } cmds)
{
foreach (var item in cmds)
{
// Restore the 32-bit MotionCommand from the wire's 16-bit
// truncation by OR-ing class bits. The class is encoded
// in the low byte's high nibble via command ranges:
// 0x0003, 0x0005-0x0010 — SubState class (0x40xx xxxx)
// 0x0087 (Wave), 0x007D (BowDeep) etc — ChatEmote (0x13xx xxxx)
// 0x0051-0x00A1 — Action class (0x10xx xxxx)
//
// The retail MotionCommand enum carries the class byte in
// bits 24-31. DatReaderWriter's enum values match. For
// broadcasts, servers emit only low 16 bits (ACE
// InterpretedMotionState.cs:139). We reconstruct via a
// range-based lookup. See MotionCommand.generated.cs.
uint fullCmd = AcDream.Core.Physics.MotionCommandResolver.ReconstructFullCommand(item.Command);
if (fullCmd == 0) continue;
// Action class: play through the link dict then drop back
// to the current cycle. Modifier class: resolve from the
// Modifiers dict and combine on top. SubState: cycle
// change; route through SetCycle so the style-specific
// cycle fallback applies.
uint cls = fullCmd & 0xFF000000u;
if ((cls & 0x10000000u) != 0 || (cls & 0x20000000u) != 0
|| cls == 0x12000000u || cls == 0x13000000u)
{
ae.Sequencer.PlayAction(fullCmd, item.Speed);
}
else if ((cls & 0x40000000u) != 0)
{
// Substate in the command list — typically the "and
// then return to Ready" item. Update the cycle.
ae.Sequencer.SetCycle(fullStyle, fullCmd, item.Speed);
}
// else: Style / UI / Toggle class — not animation-driving.
AcDream.Core.Physics.AnimationCommandRouter.RouteWireCommand(
ae.Sequencer,
fullStyle,
item.Command,
item.Speed);
}
}
return;

97
src/AcDream.Core/Physics/AnimationCommandRouter.cs Normal file
View file

@ -0,0 +1,97 @@
namespace AcDream.Core.Physics;
/// <summary>
/// Central routing for full retail MotionCommand values after the wire's
/// 16-bit command id has been reconstructed.
///
/// Retail/ACE split motion commands by class mask:
/// - Action and ChatEmote commands play through link/action data.
/// - Modifier commands play through modifier data.
/// - SubState commands become the new cyclic state.
/// - Style/UI/Toggle commands do not directly drive an animation overlay here.
///
/// References:
/// CMotionTable::GetObjectSequence 0x00522860,
/// CMotionInterp::DoInterpretedMotion 0x00528360,
/// ACE MotionTable.GetObjectSequence, and
/// docs/research/deepdives/r03-motion-animation.md section 3.
/// </summary>
public static class AnimationCommandRouter
{
private const uint ActionMask = 0x10000000u;
private const uint ModifierMask = 0x20000000u;
private const uint SubStateMask = 0x40000000u;
private const uint ClassMask = 0xFF000000u;
/// <summary>
/// Classifies a reconstructed full MotionCommand.
/// </summary>
public static AnimationCommandRouteKind Classify(uint fullCommand)
{
if (fullCommand == 0)
return AnimationCommandRouteKind.None;
uint cls = fullCommand & ClassMask;
if (cls == 0x12000000u || cls == 0x13000000u)
return AnimationCommandRouteKind.ChatEmote;
if ((fullCommand & ModifierMask) != 0)
return AnimationCommandRouteKind.Modifier;
if ((fullCommand & ActionMask) != 0)
return AnimationCommandRouteKind.Action;
if ((fullCommand & SubStateMask) != 0)
return AnimationCommandRouteKind.SubState;
return AnimationCommandRouteKind.Ignored;
}
/// <summary>
/// Reconstructs and routes a 16-bit wire command.
/// </summary>
public static AnimationCommandRouteKind RouteWireCommand(
AnimationSequencer sequencer,
uint currentStyle,
ushort wireCommand,
float speedMod = 1f)
{
uint fullCommand = MotionCommandResolver.ReconstructFullCommand(wireCommand);
return RouteFullCommand(sequencer, currentStyle, fullCommand, speedMod);
}
/// <summary>
/// Routes a full MotionCommand to the matching sequencer API.
/// </summary>
public static AnimationCommandRouteKind RouteFullCommand(
AnimationSequencer sequencer,
uint currentStyle,
uint fullCommand,
float speedMod = 1f)
{
var route = Classify(fullCommand);
switch (route)
{
case AnimationCommandRouteKind.Action:
case AnimationCommandRouteKind.Modifier:
case AnimationCommandRouteKind.ChatEmote:
sequencer.PlayAction(fullCommand, speedMod);
break;
case AnimationCommandRouteKind.SubState:
sequencer.SetCycle(currentStyle, fullCommand, speedMod);
break;
}
return route;
}
}
public enum AnimationCommandRouteKind
{
None = 0,
Action,
Modifier,
ChatEmote,
SubState,
Ignored,
}

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

@ -72,12 +72,20 @@ public static class MotionCommand
/// regular SetCycle transition.
/// </summary>
public const uint FallDown = 0x10000050u;
/// <summary>0x10000057 — Dead.</summary>
public const uint Dead = 0x10000057u;
/// <summary>0x40000011 - persistent dead substate.</summary>
public const uint Dead = 0x40000011u;
/// <summary>0x10000057 - Sanctuary death-trigger action.</summary>
public const uint Sanctuary = 0x10000057u;
/// <summary>0x41000012 - crouching substate.</summary>
public const uint Crouch = 0x41000012u;
/// <summary>0x41000013 - sitting substate.</summary>
public const uint Sitting = 0x41000013u;
/// <summary>0x41000014 - sleeping substate.</summary>
public const uint Sleeping = 0x41000014u;
/// <summary>0x41000011 — Crouch lower bound for blocked-jump check.</summary>
public const uint CrouchLowerBound = 0x41000011u;
/// <summary>0x41000014 — upper bound of crouch/sit/sleep range.</summary>
public const uint CrouchUpperBound = 0x41000014u;
/// <summary>0x41000015 - exclusive upper bound of crouch/sit/sleep range.</summary>
public const uint CrouchUpperExclusive = 0x41000015u;
}
/// <summary>
@ -819,7 +827,7 @@ public sealed class MotionInterpreter
/// if WeenieObj != null AND WeenieObj.CanJump(JumpExtent) returns false:
/// return 0x49
/// uVar1 = InterpretedState.ForwardCommand
/// if uVar1 == 0x40000008 (Fallen) OR uVar1 == 0x10000057 (Dead):
/// if uVar1 == 0x40000008 (Fallen) OR uVar1 == 0x40000011 (Dead):
/// return 0x48
/// if 0x41000011 &lt; uVar1 &lt; 0x41000015 (crouch/sit/sleep range):
/// return 0x48
@ -850,7 +858,7 @@ public sealed class MotionInterpreter
return false;
// Crouch / sit / sleep range (0x41000011 < fwd < 0x41000015).
if (fwd > MotionCommand.CrouchLowerBound && fwd < MotionCommand.CrouchUpperBound)
if (fwd > MotionCommand.CrouchLowerBound && fwd < MotionCommand.CrouchUpperExclusive)
return false;
// Need Gravity flag + Contact + OnWalkable for ground-based motion.