ANM animation container Confirmed

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. It is the same header bit that selects the clip tick's scaled step, so a clip either scales its step and blends, or does neither. The weight is the cursor's low nibble. The second entry is the same part one frame later; on the last frame it is the entry itself when the clamp bit +0x62 & 8 is set, else the part's frame-0 entry (the loop wrap).

Translations lerp as cur + (((next - cur) * frac) >> 4). Angles go through a wraparound-aware interpolator with the next frame as from: (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.

Each angle call adds its arc length to a counter and journals its pair. If the three arcs sum past 0xC00, the blender redoes the angles against the next frame's equivalent Euler triple (x + 0x800, -(y + 0x800), z + 0x800) - the same orientation by a shorter total path. Results land in scratchpad 0x1F8002C0 before the GTE load. A whole-frame cursor (fraction zero) poses exactly as the single-entry decode.

The same header bit slows the clip: a gated clip steps (rate*2 + div - 1) / div sixteenths a tick instead of the rate, so the common divisor-4 clips play at half speed - a live capture on Rim Elm matched that rule on every call it checked. In the port: PlayerAnmBundle::sample_bone (two-frame sampler), blend_bone_transform (blend with the flip retry), lerp_angle_12 (angle interpolator).

The scene's clip bundle rides type byte 0x05: the asset-type dispatcher allocates it with the move_malloc_err string into _DAT_8007B888, and the clip driver binds from that buffer. The dispatcher's anm_malloc_err arm is type 0x06, whose buffer _DAT_8007B7C8 holds the scene's CLUT-walk table, not clips - the enum labels and the contents are crossed.

FUN_80024CFC, long called play_anm_by_id, reads that type-6 buffer (_DAT_8007B7C8 + id*4 + 4), stores the entry in actor[+0x4C] and writes state 0xB to actor[+0x56]. State 0xB in the per-actor tick FUN_8001ADA4 is the CLUT-walk step: it advances a per-entry frame counter and issues a 16×1 MoveImage per frame. It spawns palette-cycling walkers, not animation clips (field ambient FX).

In RAM a loaded section 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.

For a kind-6 actor (actor[+0x5A] = 6, below), actor[+0x4C] points at a runtime record the tick rewrites every frame: a one-frame clip in the ordinary 8-byte encoding, followed by the two poses it is tweened from. N = *(actor[+0x44]) is the object count; total size 8 + 32N.

Per object the tick computes src + ((dst - src) * actor[+0x22]) >> 12 on five lanes and packs them (0x80022F0C..0x80023040): source +0x06 / +0x08 / +0x0A become T0 / T1 / T2, +0x02 >> 4 goes into both rot-X and rot-Z, +0x04 >> 4 into rot-Y; the halfwords at +0x00 / +0x0C are not read. crates/anm models the record as KeyframeReader / BoneKeyframe (infer_bone_count recovers N from the size), but its field order (src_pos, dst_pos, src_rot, dst_rot) and /256 factor do not match these lanes. Disc records whose size does not fit 16 + 8 × bones × frames are surfaced by anm scan-non-keyframe --histogram.

These are the kinds of the move-VM / ambient-effect actors the tick serves; none of them is the ordinary clip path, which is the clip driver FUN_800204F8. Only kind 6's second block reads actor[+0x4C]. The span 0x800228B8..0x80022B80 is the default motion block that kinds 3 and 5 branch past, not a kind handler.

In the port: engine-vm::DispatchByte and engine-vm::actor_tick (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, loads actor[+0x4C], calls the BIOS vector 0xA0/0x2F, then runs a 40-byte body at 0x801E2630..70 over that pointer and the return value; that body is not decoded.

Battle-actor animation state is not ANM: the battle actor record (0x2D4 bytes, slot 0 at 0x800EC9E8) points at a battle action entry with a 9-byte packed stream (monster animation owns the entry; the party's entries are in the battle data pack). A quiet-frame vs mid-strike save pair pins three actor regions:

The pointer names a battle action entry, not an ANM clip. The staged-anim commit FUN_8004AD80 tests its first byte - the entry's action tag - once per commit: 0x02 becomes 0x04 in place when the battle's first monster is 0xB3 / 0xB5 and the actor's HP is 0; 0x04 stages the get-up +0x1F2 into actor[+0x1DA] on a living actor, entry 7 on a dead party member, and clears +0x1DC; 0x05 / 0x08 OR 4 / 8 into actor[+0x1DC]; 0x07 stages entry 8; anything else raw playback. The captured mid-strike entry carries tag 0x18: raw playback.

Those are entry fields; the consumers also read actor-side fields: the position vectors +0x34 / +0x38 and +0x44 / +0x48 (copied into the render context), the loop-hold counter +0x176 (stamped entry[+0x84] << 4), the render flag set +0x1BA (copied to render-ctx +0x7A), the loop counter +0x21B, and the speed scale +0x21D (0 / 2 / 4 / 8 observed), which FUN_80047430 multiplies into the cursor step and FUN_80049348 reads as 8 / actor[+0x21D], the stride of its child-actor walk. Engine views: engine-vm::anim_vm::OpaqueAnimRecord, OpaqueRecordKind, ActorAnimState - which names +0x21D an LOD step; the battle player the hosts run is engine-battle::battle_anim, not these views.

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

Each 9-byte bone block packs six 12-bit values, a translation then an Euler rotation:

byte[0] | (byte[2] & 0x0F) << 8   → tx
byte[1] | (byte[2] & 0xF0) << 4   → ty
byte[3] | (byte[5] & 0x0F) << 8   → tz
byte[4] | (byte[5] & 0xF0) << 4   → rx
byte[6] | (byte[8] & 0x0F) << 8   → ry
byte[7] | (byte[8] & 0xF0) << 4   → rz

The decoder FUN_8004998C sign-extends the three translations (bit 11 set ORs in 0xF000) and masks the three angles with andi 0xfff (unsigned, 4096 = a full turn); engine-vm::anim_vm::BoneFrame sign-extends all six, which the decoder does not. 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.