Battle action state machine

At a glance

Where

Battle overlay (PROT 0898, resident at slot A during fights); driver FUN_801E295C, the overlay’s largest function

State

One byte, ctx[7] in the battle context at 0x800EB654, dispatched through a 256-entry jump table with no default arm

Band key

The actor’s category byte +0x1DE, read once at the seed state 0x0C

Damage

Not in the state bodies - one power byte per animation hit event, through the battle formulas

Turn end

Done band 0x50..0x52, then the end gate 0x5A, which also detects a party or monster wipe

Confidence

Confirmed - every state body read from the disassembly; queue, summon loads and trigger tables capture-validated

Used by

battle loader, Arts browser, ROM patcher battle tuning

The state machine

The driver runs every frame from the battle main dispatcher. It resolves the active combatant through the 8-slot actor pointer table and pumps the action through three keys:

• Not a bytecode VM. No opcode table, no program counter. Each state body waits on a per-actor condition - animation matched, timer expired, range check passed - and writes the next state when ready.
• Magic and Item cross over. Magic seeds 0x28 but a low-class, low-id spell (class byte < 0x14 and id < 0x65) takes 0x3C; Item seeds 0x3C but items 0x98 / 0x99 take 0x28. Player Seru magic (0x81+) always takes 0x28. The choice picks animation and timing, not cost.
• The seed frames on the raw roll. The seed rolls a camera style (rand() % 4) and frames on it before the category arm narrows the byte (Magic stores 0), so a cast’s seed pass and its 0x28 pass can aim the camera at different yaws; a retail recording of Nova’s Scythe Wind shows the seed pass heading for one and 0x28 re-arming toward the other.
• Run. 0x64 rolls the escape. A failed run returns to 0x50 (turn consumed, battle continues); a success enters 0x66, which stages a 64-frame fade, raises the battle-end signal and parks.
• Wipe arm. The 0x5A victory arm stages the win pose off the acting actor’s party slot, re-picking a living member only when the actor is dead. Retail is safe because the wipe scan and the scheduler share one liveness predicate; the randomizer’s enemy-ally charm widens that mask and breaks it (charm softlock).
• Effects are indirect. The machine calls the UI-element spawner with an element id (0x07, 0x0F, 0x34, …) and the effect VM resolves it to sprite spawns. That path draws the 2D layer; the 3D summon is a separate mechanism below.
• Two known parks. The 0x51 HP-bar settle gate and the 0x19 attack-approach range poll can wait forever under the wrong seeding; both are dissected in the full doc and the Gaza write-up.
• A button press cuts two waits short. State 0x52 - entered from 0x51 only when the killing blow absorbed a Seru (ctx[+0x269]), countdown re-seeded to 0xB4 - holds the “acquired the power of” banner; a newly-pressed button (_DAT_8007B874, the pad’s press edge, not a screen-shake word) clamps its countdown to 0x13. The failed-run wait 0x65 zeroes its countdown on a new press or a button held through the pad pump’s 32-vsync ring (_DAT_8007B874 | _DAT_8007B938, 0x801E5978..0x801E59A0), and the level-up banner’s skip reads the same pair; the Seru-absorb skip takes the press alone. Because the frame driver draws rand() once a pass, these skips also move every later roll.

One attack, state by state

The attack band is the one most turns take. A party member's committed Attack plays out like this:

1. 0x14 Faceturn toward the target, range check; already in reach skips to the strike loop
2. 0x19 Close inhold until the range check passes (a monster walks via 0x15–0x18, its walk clip’s root motion carrying it)
3. 0x1E Strike loopone queue byte per swing clip: direction, art starter or art; a counterattack can redirect here
4. 0x1F Recoverrecover pose; wait for the advance-done flag to clear
5. 0x20 Returnhold for the last swing’s clip, then the target’s reaction; the pass the last art clip ends, every slot’s animation rate returns to normal (FUN_801E93C8)
6. 0x50–0x52 Doneauto-revive, Spirit +8, HUD teardown, Seru-absorb banner hold
7. 0x5A Gatewipe check, then the next actor or the round end

Every reaction turns the defender. When a melee strike commits its reaction (0x801EEC34..0x801EECBC), the defender’s heading is set to the bearing of the attacker, block included, and nothing turns it back: a struck monster keeps that heading until its own action recomputes it, and its knockback steps along it. The port does the same in World::commit_melee_reaction.

A struck body slides by what it played. The same commit flags the defender for an immediate re-commit, and its next animation tick cuts the clip it is leaving (FUN_80047430, 0x80047940): the body steps along its new heading by that clip’s end displacement (entry +0x0E), scaled by how far through the clip it got. A guarding member hit three times mid-block slides back a share of the block each time, and the attacker walks after it: in the Theeder strike film Vahn steps 140 units per hit, and Theeder follows him down the stage.

The slide starts on the defender’s own next tick. A clip’s root motion is stepped by the entry the body holds once its own tick has made its commits (the speed read at 0x80047D34), and the party’s bodies tick ahead of the monsters’. A monster’s blow therefore lands on a party member that has already stepped this frame on whatever it was playing: the block’s or flinch’s backstep begins a frame later, behind the cut. A monster struck by a party member ticks after its attacker and backs off on the blow’s own frame. In the Gilium Lv3 strike film Vahn’s block ends on the frame the fourth swing lands, so he stands on idle for that frame and slides from the next; the port (BattleState::anim_slice_roots) steps the entry each body ticked on.

A locked clip refuses the reaction. The cut skips an entry whose lock byte +0x76 is set (0x80047940), and that clip’s natural end then commits idle over the staged reaction (0x80047B44), so the reaction never plays. No flinch, block, knockdown or get-up entry is locked; the locked entries are some monsters’ walks and attack clips, so this is a body struck inside its own swing.

A hit only stages its reaction. Neither the strike kernel nor the damage primitive starts the struck body’s clip: each writes the reaction into the body’s staged-clip byte and raises its commit flags (0x801EEC6C..0x801EEC84, 0x80042118..0x80042170), and the body’s own next animation tick commits it, after that tick has advanced and walked the clip it is leaving. A party member struck by a monster has already ticked when the blow lands, so its flinch starts a frame later; a monster struck by a party member ticks after its attacker and flinches on the blow’s frame. The port holds the stage on the body (Actor::battle_reaction_stage) and commits it in that body’s slice of the animation walk.

A clip’s last tick still fires its late records. The cue, hit and effect walks read the animation cursor as that tick’s advance left it, before the natural-end test, so on the tick a clip ends they see the frame count, one past the last keyframe. A record gated there fires as the clip ends: a get-up’s dust, some monsters’ walk sparks once a cycle, and the effect a party member’s get-up and flinches spawn.

When the monster’s action table has no walk entry it falls back to the party’s 0x19 path, which has no movement code and no timeout: if nothing else closes the distance it waits forever - the root of the 0x19 park. On arrival a walking monster shoves its target back to the range boundary, not itself forward. A counterattack fires on the attacker’s first frame when the target chose Attack, carries the Counterattack passive and won the picker’s coin flip: the target becomes the active actor and swings first.

Seru-magic summons

When a character casts a Seru spell, the creature that appears is not in the battle overlay: the cast state pages a small per-summon code overlay off the disc into slot B (0x801F69D8, above the resident battle overlay) while the cast band waits. That is why every summon has its own PROT entry and why a mid-cast save state holds an extra chunk of code.

The loader resolves its argument in the raw TOC (+ 0x381), which is extraction entry + 0x37F (PROT). The player and enemy arms of the same spell ship separate stagers. What a stager contains:

• No mesh geometry. The meshes are the separately loaded 30-entry model library etmd.dat (extraction 0871) that the battle loader registers at battle init; the flame atlas etim.dat is 0870 (effect cluster).
• Part records - [i16 model_sel][u16 reserved][move-VM bytecode] - handed to the executable’s part-stager, which spawns a part-actor per record: model_sel ≥ 0 seats a library mesh, -1 is a transform node, 0x4000 / 0x4001 are special render modes. Parser legaia_overlay_images::summon_overlay.
• Motion is geometric. Gimard’s flame is eight RNG-seeded part-actors moving; the palette is byte-identical across animation-distinct frames.
• The player summon draws as an ordinary battle actor through the TRS-keyframe pipeline, like any monster; the part records drive the stager, not the draw. The port seats each summon’s own body and clips the same way on both hosts (summon::summon_spawn_asset), and streams the cast’s own summon.dat texture pages into VRAM when the stager arms.

The action queue and Tactical Arts triggers

What the player types on the D-pad becomes a flat list of action bytes before the machine sees it: the per-actor byte stream at actor[+0x1DF..+0x1F2]. Miracle Arts and Super Arts are pattern matches on that list, which is why the right arrows in the right order “upgrade” a chain into a named combo. The queue builder runs both passes, in this order, when the seed state commits the turn:

1. Miracle Art match. Two conditions, both required. The slot’s Miracle marker ctx[+0x25F + slot] has to be set — it is raised once per battle, when the party actor is seated, from the acting character’s Ra-Seru equipment byte, not by anything the player types. And the command string has to equal the character’s Miracle string (Vahn’s Craze: R D L U L U R D L). Then the whole queue becomes the replacement string: four directions, the SpecialStarter byte, then the arts.
2. Super Art tail replace. For each chained art the builder walks the character’s five Super find patterns; a match on the queue tail is replaced by the replace tail ending in the finisher. The match needs the find’s last art to be the queue’s last action, and every participating art to have paid AP.

Every string is capture-validated byte for byte against legaia_art’s tables, and a Vahn Tri-Somersault capture’s queue tail 19 27 0F 19 1F 0E 1A 2B 2B 2B equals its modelled replace. The Super pass applies once and takes the first matching row in resident-table order — not to a fixpoint, and not the longest match.

Why a saved chain is not enough. The connector direction after each art is per-combo data - Vahn’s 0x27 is followed by 0F in Tri-Somersault but 0E in Power Slash - so recognising a Super from a list of named arts means tokenising the arrows into arts first and tail-matching the art ordering, not comparing raw strings.

Strikes. The attack chain walks the queue one swing per animation clip. Each swing stages its own power byte, hit timing, hit cue and status effect; damage lands on the clip’s authored hit events through the melee kernel, never in the state body.

Spirit and Run

Spirit (category 4, states 0x46–0x48) is a gauge move, not an attack. 0x46 stages two targets off the actor’s own AGL and Spirit gauge: next turn’s arts bar becomes min(base AGL × 7/5 + 8, 288), and the Spirit gauge climbs by 32 (35 or 40 with the AP Boost passives), capped at 100. 0x47 grows both bars on screen; 0x48 finishes the ramp. The 0x300 hold 0x47 arms for the flush never holds it: 0x48’s compare is the other way round from a drain, so a hold at or above 8 × step is zeroed on the first pass. The pending category byte +0x1DE == 4 is also what the damage kernels read as the guard stance until the round’s sweep clears it.

Run (category 5) rolls the escape formula in 0x64. On success every downed party member is floored at 1 HP before the teardown - which is why fleeing cures Stone - and the battle ends with no loot. Chicken Heart (passive 0x34) scales the party roll ×1.5 and Chicken King (0x37) forces a tie, both only from living wearers; the scripted-fight flag ctx+0x287 blocks both.

In the port

engine-battle-vm::battle_action keeps one enum value per retail state byte (ActionState), so an engine transition trace lines up against a retail capture line by line. step(host, ctx) runs one frame of dispatch; BattleActionHost carries a callback per helper the state bodies call; validate_action ports the executable’s 18-arm action validator. engine-core::World composes it into the battle tick.

How we know

The full per-state table - every case body, what it runs and where it goes next - is in docs/subsystems/battle-action.md, along with the turn cursor ctx[+0x1A], the two park analyses, the Magic arm’s class discriminator and the battle voice cues.

See also