Battle internals

At a glance

Roster

8 × u32 actor pointers at 0x801C9370; slots 0..2 party, 3..7 monsters

Context

One struct at 0x800EB654, reached through the global pointer 0x8007BD24

Formation

Four monster-id cells at 0x8007BD0C, a 3-byte party roster at 0x8007BD10, per-battle flags byte 0x8007BD60

Character record

0x414 bytes per member at 0x80084708 + n*0x414 (the save-file block)

Monster record

Decoded archive slot (PROT 867), stat head at +0x00, mesh at +0x04, texture pool at +0x08

Heap

One ~1.23 MB best-fit heap; ~145 KB workable for distinct monster blocks

Parser

legaia_actor_formats::monster_archive (monster records); engine mirrors in engine-core (battle_seats, MonsterMesh)

Confidence

Roster, context cursors, seats, camera, heap ledger, wipe path: Confirmed. A few actor-struct fields (+0x3C/+0x40 mid-battle role): Inferred

Roster and actor struct

Every combatant is one actor struct. Slots are filled at setup in formation order; empty seats hold a null pointer. The fields other routines read:

The range check between two slots is a euclidean distance from the live positions plus the sum of both size bytes, clamped to a per-actor cap. Slot pointers are the only way any battle routine names a combatant.

Battle context struct

One struct describes the fight in progress. Two byte cursors inside it hand the round back and forth: the menu machine walks +0x06, the action machine walks +0x07. Only the first 32 bytes vary between captures; beyond +0x40 is text-rendering scratch.

Formation cells

Three small globals beside the context carry the formation from the trigger to every later stage:

The heap ledger

Everything the loader places lives in one best-fit heap of 1,263,616 bytes (1234 KiB, arena 0x80091800..0x801C6000). The malloc wrapper returns NULL on exhaustion and the monster streamer copies through that pointer unchecked, so an over-budget formation writes a decoded block over kernel RAM and the machine locks. Neither VRAM (each seat owns its own texture column) nor the AI bounds a formation - the heap does. Stage init re-initialises the heap at battle entry, so nothing from the field survives into the fight.

Every node resident once the fight has settled, from an allocator-breakpoint trace with each caller resolved (formation [108,3], Mad Ogre + Demon Fly, on the Karisto world map, one-member party):

Transient during the load: the party-mesh decode temp (0x19000) and the LZS decoder's 0x1014 ring, taken and freed around every decode. After the last allocation the free ring is one node of 17,472 bytes (17.1 KiB), and the nodes, headers and free space sum to the arena exactly.

164,412 bytes (160.6 KiB) remain when the first monster block allocates and the tail after the blocks takes 19,576 bytes (19.1 KiB), so two distinct monster blocks fit in about 141.4 KiB. Retail's largest authored formations cost 124.4 KiB; the three Delilas blocks cost 81-84 KiB each, so any two together overshoot by 22-25 KiB - which is why the Delilas Challenge fields them one per round. Instruments: autorun_battle_heap_ledger.lua (the attributed trace) with battle-heap-ledger.py, autorun_delilas_battle_load.lua (formation install + free-ring walk), battle-heap-walk.py (offline from a save-state).

Where each block lands. The monster loader walks ids in ascending order and the allocator carves each block from the top of the free node, so the blocks stack downward from a fixed end: 0x800B9A50 with one party member seated, 0xA8 (one render node) lower per further member. A block's address is a function of the seated count, the formation's ids and each block's +0x08 cost - 145 placements across 86 retail battle states match - and it decides the byte a four-slot event list reads (monster animation).

Camera and seats

The orbit camera (game mode 0x15) projects a world vertex as screen = H · (R · v + TR) / Z, with the constants below. The base matrix holds 16384 · I - a 4x uniform world scale composed under each actor, which is what makes the small battle meshes project at retail size against the same deep translation the backdrop uses at 1x.

The scale belongs to the battle mode, not to the stage: the backdrop is one more actor drawn through the same base matrix, so a fight whose stage stream does not resolve still draws its actors and effects at 4x under the phase camera. Both play hosts take the scale from one decision, battle_fx::battle_world_scale.

Seats are two static tables of [i16 x, y, z, pad] entries selected by combatant count (party table 0x800775C8, stride 0x18; monster table 0x80077608, stride 0x20, alternate family four rows up). The values are on the main page.

The frame step

Every per-frame battle path - the camera walker, the effect waits, the root-motion term - scales by the frame step DAT_1F800393, and the frame driver FUN_80016B6C rebuilds that byte every frame from what frames cost. The newest frame time (an hblank count) goes into a sixteen-entry ring at 0x80084098; the step is the ring’s maximum binned at 0xF1 / 0x1FF / 0x2D1 into 1 / 2 / 3, else 4, raised to the floor at 0x8007B9D8. A frame of 0x2D0 hblanks or more is stored as 0x2BC but compared raw, so 0x2D0 still reads 3 and anything longer 4.

The battle’s floor is 1, so the step is the load alone, not a property of the game state: most battle captures read 2, while summon close-ups, module casts and the arts input read 3. The port ticks once a vsync, which keeps every per-vsync rate whatever the step, and groups the ticks into frames (BattleFrameClock, two vsyncs by default) for the root-motion carry and the camera; a tween armed over n frames lands in n / step steps. A replay that knows retail’s step for a state installs it, which is how the retail comparison drives summon close-ups.

Outside a summon band the port runs the frame driver’s own law over a cost: a state’s measured base plus what the frame draws. Each live effect part adds about 2 hblanks, each live effect-pool sprite about 1.6, and each after-image ghost a whole re-draw of its body, about .092 hblanks a triangle of the monster’s mesh, so a lone member struck by a special clip with two ghosts and a four-hit spark burst climbs to step 3 as retail’s does. A boss’s ghosts are what decide its breath: Caruban’s 842-triangle body puts a lone Vahn’s Fire Breath frames on the step-3 edge and the flames carry them over, so the camera turns at retail’s rate and the stage’s horizon mist sweeps across the view at the end of the turn as it does in retail. The step a pass raises opens the next frame, never its own.

On PCSX-Redux a battle CD-XA clip an item or a Spirit cues holds the ring at its clamp for the clip’s whole read span, the stop watch below. A summon module’s own voice clip does not: the summon films run frames of 250 to 460 hblanks while it plays, so the arms the arm table leaves to the ring, and the Done band after them, run step 2 or 3 as retail’s do rather than 4.

What a frame costs depends on the machine. The frame end reads the hblanks since its last VSync wait twice: once when the CPU has finished (gp+0x3A8) and once after DrawSync (gp+0x3AC, the ring’s entry). The GPU spends that time drawing the table the pass before built, so the entry is the longer of the CPU’s work and the GPU’s. PCSX-Redux draws for free and reads the CPU alone. Mednafen draws in time, and a model of the GPU built on the v2 GPU’s measured costs, with no constant fitted to either emulator, reads its waits to within 8 hblanks at the median. The GPU binds mostly on a lone member and in a summon’s light arms. The two emulators still disagree on the CPU: PCSX-Redux charges two cycles an instruction, and its CD command waits hold Guilty Cross’s arms at about 1650 hblanks where mednafen’s read 650.

The CD wait is a stop watch. While a voice clip plays, the clip sequencer polls the drive from inside the CD interrupt, issuing the next position query the moment the last one answers, until the head passes the clip’s end. PCSX-Redux answers every command 0x800 cycles after it, so the polls take about two thirds of its CPU and a voiced summon arm costs three times its own work, step 4. A console answers in 0xC4E1 cycles on average, so the same polls take about a sixteenth. Read that way, the summon arms agree with mednafen’s steps on .69 of the band’s vsyncs, against .13 for the PCSX-Redux table. On mednafen’s recorded sound Cort’s Guilty Cross then plays its cues at .98 correlation against .86. The port keeps PCSX-Redux’s timing by default and offers the console’s as an opt-in (LEGAIA_BATTLE_CD_TIMING=console): the recordings the films score against are PCSX-Redux’s, and under the console’s timing the full-game ladder deals its rolls again. Five enemy casts lost sound cues under it, and none to a cue test on the frame step: longer frames change how many passes draw before an arm’s roll, so the roll is dealt again, and held on retail’s draws the cues play again. Of the other two, Glare now keeps its cue, and Aluru Cannon lands one a tick outside the score’s window (battle stage and camera).

The port can price its own frames the same way. An opt-in switch (LEGAIA_BATTLE_GPU_COST=1) has the native window cost every triangle and screen primitive it drew on that GPU model and pushes the longer of that and the CPU table into the ring. It stays off: against the PCSX-Redux films the source can only part the port from retail, since that emulator’s GPU is free, and it does so on the summon flash, where a lone caster’s close-up holds step 2 into it; against mednafen’s own steps it agrees less, because the port draws geometry retail never links (the stage and bodies under the summon flash, 626 polygons against retail’s 48) and lifts light arms over the step-2 line. What separates the port’s summon arms from mednafen’s is the CPU half.

Character record (battle fields)

The party side of the roster is the persistent per-character record - the same 0x414-byte block the save file stores. Battle reads stats, equipment and learned spells from it and writes HP / MP back when the fight ends. The full layout is on save record; the battle-relevant fields:

A per-frame aggregator caps each member's stats at 999 and ORs the abilities block into the global bitmask that every other system reads through one bit-test helper - accessories work by flipping bits, not by editing stats.

Monster record

Each species is one LZS slot of 0x14000 bytes in the monster archive at (id − 1) × 0x14000. The decoded block opens on a stat head; the loader copies stats into the actor and keeps the block pointer in a side table at 0x801C9348 so the spoils routine reads rewards without copying them.

Widths are schematic. The pool is 15 × 16 BGR555 CLUTs (0x1E0 bytes), then a 4bpp page 128 or 256 texels wide × 256 rows.

• Action entries. Each entry's first byte is a tag: 2/3/4/5/0xB are the hit-reaction clips (their slot indices land in actor +0x1EF..+0x1F3), 0x0C..0x1F are castable attacks, 0x23 is special; the AGL cost sits at entry +0x74. The three global ids at +0x21 are what appear on screen; the local entry ids only gate the pose.
• Texture pool. Uploaded to CLUT row 484 + slot and page column (320 + slot × 64, 256), where the slot is the rank of the monster’s id among the formation’s distinct ids, not its seat; a repeated species shares its slot, and slot 2 is the one a summoned Seru’s texture overwrites. The on-disc CBA / TSB words are nominal and relocated per slot. Width is 128 texels unless the wide flag is set: width = (pool_len − 0x1E0) / 256 × 2.
• Steal data is not here - it is a static SCUS table (steal table). The monster viewer reproduces the same relocation.

Status bits

Every ailment is a bit in the actor's status halfword. Two overlay legs set them - the hit leg (kind byte at art descriptor +0x7A) and the cast leg (spell descriptor byte +0x0A) - sharing one kind-to-bit map. Nothing wears a bit off with time: every store that clears one is a cure, a strip or a scripted arm, so Venom, Toxic, Rot and Curse last until cured (round loop). The turn counts the port still keeps on Numb, Sleep and Confuse are its own.

Bit 0x400 has one setter on the disc, in a cast image: PROT 0955's Kiss of Death miss arm (ori v0,v0,0x400 at 0x801F8CFC). Every other write that touches it is a clear (accessory cure, the per-round waker, item cures, the on-hit strip, battle exit). Rot (kind 5 in the art-record space) sets one random bit of 0x38, greying out the rolled limb's attack command. Full writer inventory: battle.md.

Capture-class cast modules

A spell whose class byte is 'c' is too elaborate for the battle overlay to choreograph itself. The action machine pages a small dedicated module - one PROT entry from 0935..0966, chosen by the record's +1 sub-id - into the side overlay window and re-enters it every frame until it reports done.

Module anatomy and the patcher mirror are on cast-module.md.

The party-wipe path

The battle always exits the same way - into MAIN INIT - and the wipe fork lives one mode later. Three latches decide where MAIN INIT sends the game:

1. DetectThe end-of-action gate counts living, non-petrified party members; none sets the end signal 0xFE and wipe cause 5, and clears the survived latch · FUN_801E295C state 0x5A
2. ExitThe exit selector writes game_mode = 2 (MAIN INIT) wipe or no wipe, with the back-from-battle marker set; it never reads the wipe cause · FUN_80046A20
3. ForkWith the survived latch and story flag 0 both clear, MAIN INIT writes game_mode = 0x16 (CARD), entry context 1: the title screen, cursor on Continue · FUN_8003AEB0

Scripts reach the same hand-off directly through a helper twin of the gate body, called by the field-VM op 4C EA. The mode-18/19 game-over artwork overlay (PROT 0902, 29 TIMs) has no static writer and exits to the debug menu: a dev harness around dev art. Nothing on the reachable path draws "GAME OVER".

How we know

The save-state diffs behind the roster window and residency claims are on capture notes.

See also