ANM animation container Confirmed

Earlier prose placed high4(T2) in the high nibble of byte 4. The instruction sequence lbu v0,0x4(t3); andi v0,v0,0xf; sll v0,v0,0x8 at 0x8001BF30..0x8001BF3C reads the low nibble, and the parser always did. See do-not-re-walk.

The entry decoder reads two entries and blends them when the gate header[+1] & 1 is set; otherwise the current frame is emitted as-is. Translations lerp as a + (((b - a) * frac) >> 4). Angles go through a wraparound-aware interpolator: (to + ((from - to) * frac >> 4)) & 0xFFF, with the pair first brought onto the short arc by two sequential guards - add a turn to to when from - to >= 0x800, then to from when the updated to - from >= 0x800. Inputs exactly half a turn apart fire both guards, which cancel, so that case resolves forward. Results land in scratchpad 0x1F8002C0 before the GTE load.

BoneTransform::decode models the un-interpolated arm; player_anm::lerp_angle_12 is the angle half of the blend for consumers chasing frame-exact parity. Retail also accumulates |from - to| into a global and journals the pair into a slot table; neither affects the transform and the port omits both.

play_anm_by_id(id, actor) primes an actor: allocate, read the record offset from the loaded container at _DAT_8007B7C8 + id*4 + 4, store base + offset in actor[+0x4C], write 0xB to state byte actor[+0x56] and 100 to the cursor. The actor tick reads +0x4C whenever dispatch byte actor[+0x5A] is 2 or 6. Field-VM op 0x34 sub-op 3 is the sibling path into the same slot.

In RAM the loaded container carries a 16-byte allocator preamble the disc form lacks (back_ptr, forward_ptr, forward_ptr_2, expanded_size); crates/anm::peel_preamble strips it. The scene bundle tags the section 0x05 ("MOVE" in AssetType) while the loader that allocates it is the labelled ANM dispatch - the runtime case selector and the enum label disagree.

Records consumed via animation opcode 0x06 carry a per-bone src/dst keyframe table the actor tick interpolates in place, with the bone count taken from the actor's mesh context. Total size 8 + 32N.

The tick multiplies (dst - src) by the per-actor interpolation factor actor[+0x22] and writes the packed result to the output slots. crates/anm::KeyframeReader is the typed accessor; infer_bone_count recovers N from the record size. Records whose body is empty are placeholder slots the tick skips; bodies not a multiple of 32 are opcode-specific layouts with no known interpreter (anm scan-non-keyframe --histogram lists them).

engine-vm::DispatchByte exposes the values; the per-arm physics tick is ported in crates/engine-vm/src/actor_tick.rs (see the per-arm breakdown). A second, overlay-resident path in the field-VM dispatcher (FUN_801DE840, sub-dispatch table 0x801CEF88) gates on actor[+0x5C] > 0, calls the clip driver, then completes frame selection in a 40-byte body at 0x801E2630..70 that is untraced.

In battle a different consumer poses actors, but per-actor state still lives in the 0x2D4-byte battle actor record (slot 0 at 0x800EC9E8). A quiet-frame vs mid-somersault save pair pins three regions:

The pointer names a runtime control struct, not bytecode. The per-frame consumer FUN_8004AD80 dispatches on its first byte: 0x02 handshake (advance to 0x04 when the global action byte is -0x4D / -0x4B), 0x04 action engaged (actor[+0x1DA] = 7 or copy of +0x1F2), 0x05 / 0x08 OR 4 / 8 into actor[+0x1DC], 0x07 actor[+0x1DA] = 8, anything else raw playback. The captured somersault record is kind 0x18: raw playback.

actor[+0x21D] is a per-actor LOD step (8 / max(v, 1)) used to skip child actors during the render pass. Engine views: engine-vm::anim_vm::OpaqueAnimRecord, OpaqueRecordKind, ActorAnimState.

The buffer at struct[+0x88] carries the bone keyframes the battle renderer interpolates each tick.

Each 9-byte bone block packs six sign-extended 12-bit values as two [i16; 3] vectors:

byte[0] | (byte[2] & 0x0F) << 8   → vec_a.x
byte[1] | (byte[2] & 0xF0) << 4   → vec_a.y
byte[3] | (byte[5] & 0x0F) << 8   → vec_a.z
byte[4] | (byte[5] & 0xF0) << 4   → vec_b.x
byte[6] | (byte[8] & 0x0F) << 8   → vec_b.y
byte[7] | (byte[8] & 0xF0) << 4   → vec_b.z

Bit 11 set ORs in 0xF000. The cursor actor[+0x68] holds the frame index in bits 4..15 and a sub-frame factor in bits 0..3; with a non-zero factor the renderer lerps toward the next frame (a + (b - a) * frac >> 4), where "next" is the loop target, N - 1 on the terminal frame, or frame + 1. Validated against FUN_8004AD80, FUN_80048A08, FUN_8004998C, FUN_80047430. Engine accessors: engine-vm::anim_vm::NestedFrameData, BoneFrame, ActorAnimState.