Gate replay

At a glance

Question

Given the same hands on the pad, where do the port and retail spend a different number of frames, stand in a different place, or draw a different number of random values?

Engine side

One line a session tick from LEGAIA_DIAG_TICK_DIGEST (crates/engine-session/src/host_trace.rs), taken from a full-game ladder segment's pad pass

Retail side

scripts/pcsx-redux/autorun_gate_replay.lua under PCSX-Redux, started from a retail save state

Report

scripts/ci/gate-replay.py cuts the beats, runs the probe and prints the table. It gates nothing, like the walk film

Output

captures/gate-replay/. It is read from retail RAM and stays out of the repository

LEGAIA_FGL_ONLY=tetsu_spar LEGAIA_FGL_TRACE=1 LEGAIA_FGL_PIN_RETAIL=1 \
LEGAIA_FGL_RNG_SEED=0x1a1193df LEGAIA_DIAG_TICK_DIGEST=/path/digest.txt \
XMODIFIERS=@im=none cargo test -p legaia-engine-shell --profile release-test \
  --test integration full_game_ladder::part_b_ -- --nocapture --test-threads 1

scripts/ci/gate-replay.py s3_rimelm_freeroam --digest /path/digest.txt --until 3700

• Start both on one random stream. Read the state's seed word at 0x80009010 and pass it as LEGAIA_FGL_RNG_SEED, or the draw columns compare two different deals.
• Run the ladder as full_game_ladder::part_b_. The digest then holds the seated and pad passes of the one segment, and its last session is the pad pass. The unfiltered name also runs part C and leaves gigabytes of sessions ahead of it.
• A walk through encounter country parts at the first fight only one side rolls. To measure the field between fights, take the digest with LEGAIA_FGL_NO_ENCOUNTERS=1 and pass --no-encounters, which holds retail's setting byte 0x8007B5F8 at the value where the encounter routine skips its roll.

Beats and gates

A gate is a change of state both sides can see in their own memory: a script taking hold of the player, a battle opening, a dialogue page finishing its typing. A beat runs from one gate to the next. The engine's run is cut into beats first; retail then plays each beat's pad and the probe waits for the same gate before the next beat starts.

• Walks are gated on position, not time. A retail walk and an engine walk start a pass of position apart, and a door or a ledge fires on where the player stands. Each turn is therefore a gate on the spot, and the next leg's pad starts where retail really is.
• Levels, not edges. Where a gate is a level (engaged, battle, scene), retail matches the level, so two gates the sides reach in the other order read as a zero-length beat and not a stall. Pages, prompts and action starts are ordinals, so a page only one side shows costs one beat and not the rest of the run.
• A door holds retail's engaged bit from its trigger to its landing, where the engine's word stays clear. A retail engaged interval that contains a warp is that hold and does not satisfy an engaged=1 gate.
• Field gates are not cut inside a battle, where the field player record says nothing. An engaged run shorter than three ticks is a script pulse and is ignored (--min-dwell).
• The press that moves a battle surface closes its own beat. The engine's flow byte changes in the row of the press that caused it, so such a gate ends one tick later and keeps the press: it is what the beat repeats if it does not land.

Replaying a beat

Each beat's pad rows are timed from its opening gate. A press is held at least two ticks (--min-press), because a one-vsync press can fall between two of retail's game passes and be lost, and a widened press keeps one released tick after it so a run of pulses stays separate edges. What happens at the closing gate depends on who got there first:

Synthetic input is input the engine's log did not supply. Every one is a row in gate_events.csv with the press and what it found, so a run that needed help says where. Nothing is pressed while the action state machine owns the frame, or on a flow byte no surface reads the pad on.

Reading the table

A beat with a small gap and a matching position says the two sides agree there, whatever came before it. That is what the resynchronisation buys. A second table, page waits, has a row per page gate: when each side's pager finished the page, their difference (which carries the drift of the beats before it) and the part this page added.

What the Rim Elm run shows

The first run replays the walk to Tetsu, the talk and the sparring fight from a Rim Elm free-roam state. With every surface gated, the fight replays to its end.

• Engaged holds. Retail holds the player's engaged bit across a door's whole trigger-to-landing run, and across the talk to Tetsu from its first page to its last.
• The fight's opening. Retail's command flow walks 0xFD, 0x00, 0x0A, 0x0B, 0x14, 0x1E before the first round prompt. The action state machine passes through 0x5A after every action, between two actors of one round as well as at a round's end, so the prompt is gated on the command flow's 0x1E.
• One-vsync presses get lost. With one-tick presses two of the talk's page turns wait on a synthetic Cross and the first round prompt ignores six logged pulses; with two-tick presses the same turns close on the logged presses.
• The ring. Up in the command ring opens the item window on retail as on the engine. Both sides ignore the ring for about 16 ticks after entering it, and a mash merged into one solid hold gives retail a single edge that lands before the ring shows.
• Every surface holds the pad for its glide. The engine dispatches on the eighteenth tick after the flow byte moves and retail about two vsyncs later, on its two-vsync pass:

• Where the actions differ. A round's actions run the same states on both sides with the same dwell except at the close of each: 0x51 holds 62 ticks on the engine against 76 vsyncs on retail, and retail then walks 0x5A where the engine walks 0x00. The item band and the Spirit band are shorter on the engine.
• The boxes that close themselves. Retail's first-round box and its sign-off box wait for a press and otherwise close on their own hold: with no Cross offered, retail spends 364 vsyncs in 0x14 and 427 in 0xC8 before the fight closes. A press skips the long hold on both sides.
• The hits are one kernel. The thirteen melee hits of this fight, fed through the port's physical_rolls with retail's stats and retail's own rand() draws, give retail's raw and guarded damage on every hit. The two sides' damage differs only where the rolls and swing counts differ, and those follow the random stream, which parts in the first round.

See also