Save Screen

At a glance

Lives in

The menu overlay (PROT 0899) - the same code chunk as the shop, inn and status screens. There is no save overlay of its own.

Driver

FUN_801DC6B4: a 9-state outer machine that fades in, dispatches one sub-screen from a 33-entry function table, and fades out.

Card I/O

A 5-state machine over Sony's libcd (FUN_801E3294), sequenced by a per-frame ticker; BIOS bu device calls underneath.

Block

One card block, 0x2000 bytes: SC header + icon, then 0x1A18 bytes copied verbatim from RAM 0x80084140; checksum word at +0x1FFC.

In the port

engine-menus::save_select (session + card machine), save_subscreen (the screen graph), legaia_save (block layout, round-trip).

Confidence

Confirmed - overlay captures, disassembly, GP0 draw-list pins (how we know).

The flow, screen by screen

A third id lives in the filename: retail files a save as BASCUS-94254PRO-nn where nn is the list position it was standing on, and lets the BIOS put the file in any free block. The grid index, the port and that number are three different spaces.

Three layers of code

The entry context (_DAT_8007B450) is what a field script parks when it opens the menu; its first byte decides where the save UI opens.

Rules a player runs into

• Save is overworld-only. The Save row is gated by a per-scene byte seeded from the scene MAN's header bit; across the disc that bit is set only on the three kingdom world maps. A field save comes through a script's save point instead, which opens the card driver directly.
• "Now checking" ends when the card answers - or after 120 frames. The per-frame poll tests four card event handles in order (last one wins) and forces a timeout status on the 121st poll; timeout and a stray complete event both tear the read down.
• A foreign save is never offered as free. The directory walk clears every slot to "unreadable", stamps "Legaia save" on each filename matching BASCUS-94254PRO- (JP: BISCPS-10059PRO-), and only then spends the card's reported free-block count marking the rest free. A slot the walk cannot afford to call free stays unreadable.
• The block is checksummed. The compose path zeroes a 0x2000 buffer, copies 0x1A18 bytes of live state over the front, sums the first 0x7FF words and stores the sum at +0x1FFC; the load path re-sums and routes a mismatch to "Damaged data."
• A damaged save is refused after the read, not on the grid. The grid classifies a block by its directory filename, so a save with a bad sum still shows its cell and preview; only the checksum verify behind a Load turns it away, with a box that waits for a button.
• Both directions ask first. Confirming a block raises a Yes / No box opening on No: a Load asks to load, a Save asks to save on a free block and to overwrite on anything else. A Yes then holds the screen through the write or read under its own panel - a sliding box with the block number and a progress tube - and a result line, and the panel parks on black. A load holds its panel for at least 128 sixtieth-second units even when the card answers sooner; a save waits on the card alone.
• A cell that takes no confirm still answers. Only a readable Legaia save (on a Load) or a Legaia save or free block (on a Save) raises the Yes / No; any other cell takes the press without a prompt but sounds the confirm cue 0x20. The card screen has no buzz at all.
• The card screen waits for the pause menu to leave. The Load and Save drivers open with the close-all display script, so the card screen starts only after the pause menu's windows have slid off - twelve frames of the window-slide lock, which the port's Load and Save rows wait out too.
• Continue belongs to the title, not the pause menu. The title's own front-end state machine runs it: confirming its second row fades into the card manager, which walks the port pick, the read and the grid and ends in a launch fade that writes the game mode on its load route. No field runs underneath, so nothing that blocks the pause menu - a conversation, a lock, a script's save point holding the Load row - can stand in its way. Both play hosts run it as one shared Continue screen, ContinueScreen, over the same Load screen; backing out returns to the title card.
• The options come back with the save. Field Move, Select Attack, Battle Command, Battle Camera, Field HP Display, Sound and the vibration rows sit in the live-state window the block copies, so loading a save made with Run on resumes running. In the port both play hosts adopt them on load, except a row the session overrides (a command-line or capture pin), whose override stands.
• The records count every battle and every escape. Two words of the live-state window, so of the save, hold the records screen's "No. of Battles" and "No. of Escapes": the battle-scene setup adds one to the first each fight, and the Run roll adds one to the second on a successful flee - but not when the special-battle word's 0x100 bit is up, so a forced flee is no escape on the records. New Game zeroes both. The port counts them in the same two places and carries them in its own save files too.
• A blank card takes the first save. A formatted card with nothing on it answers the directory read like any other card. The pause menu reaches the screen through a short wipe: the field darkens before any window exists and comes back after the menu closes.

What the block holds

The game-data region is a linear copy of RAM from 0x80084340: any live field lands at block + 0x200 + (addr − 0x80084340).

Two stores share the name "story flags" and never sync: the bitmap above persists; the field VM's 32-bit scratchpad word at 0x1F800394 (opcodes 0x2E/0x2F/0x30) does not, and is re-seeded from the mode table on mode init.

The second label is not the previous scene. Every name-based scene change copies the label buffer into it only after the resolver has already overwritten that buffer with the destination, so every retail block holds the active scene twice. The port seats it on scene entry the same way. The live-state copy also carries the minigame purses - fishing points, the dance hall best and the dance free play's song counter among them - which the port lifts from a retail block and writes back.

What the screen is drawn from

Every sprite on the Continue / Load screen is pinned to a source texture and palette row by reading the GPU's own draw list out of a capture.

In the port

engine-menus::save_select models the screen and the card machine; the host decides what a “port” is - the browser mounts the player's own card images, and the native window mounts its own card, a raw 128 KiB memcard1.mcr in the save directory, read and written through the same kernels (port 2 is a card image given on the command line). A directory with no card yet gets a freshly formatted one, seeded once from any engine-format slot files an older build left there; the first save creates the save folder itself, writes the card beside the old one and renames it over, and a card file that no longer reads is kept aside as memcard1.unreadable.mcr rather than left in the way. On the browser page the saves on its own card show in the save bar, so a save made at a save point is there to resume after a reload. Every save on both play hosts goes through this screen - a gate checks that no host writes save bytes around it - and the load confirm (opening on No, with retail's pointing hand on the row), the overwrite question, the write and read panels and the damaged-block refusal all follow retail. The directory walk, the status poll and the checksum are line-for-line ports of the routines above, and legaia_save patches a real retail block in place and restamps its checksum, so an edited card save still loads on a PlayStation. The options screen's nine words travel the same way: the lift reads them, a load applies them to the world and then to the host's own options (a session-pinned row keeps its override), and every save writes the live ones back. The play clock travels both ways: a retail block lifts as whole seconds and an engine-written block stores seconds × 60 back, so its time prints on retail's own screen. The clock itself counts the way retail’s does: retail adds the vsyncs each game frame took, so the port counts one per game tick on both play hosts, under the pause menu and the title as well as on the field, and a paused or backgrounded game counts nothing. A disc-gated test runs every save on the library memory cards through Load, play, Save and Load again on the shared kernels and requires the two readings to agree field for field and land in the same scene and track. The engine's own richer save container (LGSF) is described on the engine page.

How we know

Full write-up, including the debug character editor and sub-screen 0x15: docs/subsystems/save-screen.md.

See also