Field locomotion

At a glance

Controller

FUN_801D01B0 in the field overlay (PROT 0897), shared by towns, dungeons and the overworld walk. Not the tile-board puzzle mode that shares the overlay.

Collision grid

Per scene, one byte per 128-unit tile: high nibble = four sub-cell wall bits, low nibble = floor tier. Streamed from the scene's .MAP file at load; scripts paint story-conditional changes on top.

Speed

480 units (3.75 tiles) per second walking, 720 running - counted in vsyncs, so the same on a busy frame as an empty one.

Height

A second controller after the walk: floor sampled from the grid's low nibble, or from per-tile ramp records; ledges trigger a scripted hop.

In the port

World::step_field_locomotion (engine-core); collision is retail by default, precise free-angle movement is an opt-in enhancement (below).

Confidence

Confirmed - runtime write-watchpoints on the player position, wall-press captures, disassembly (how we know).

How walking works

One pass of the controller, in order. Everything below the second step is about one question: may the player move two more units this way?

1. GateSkip everything while the player is held: an encounter queued, a cutscene or talk owns him (flag 0x80000). This also blocks the pause menu.
2. Camera remapRotate the held d-pad by the camera's eighth-turn so "up" means "away from the camera"; snap the heading to one of eight angles.
3. Wall slideIf the wanted direction is blocked, probe along the wall and add a perpendicular direction, so the player skids instead of sticking.
4. SpeedBase step (8 walk, 12 run) × the actor's multiplier × the frame scalar; halved on slow terrain, trimmed by a quarter on diagonals.
5. Step loopSpend the speed 2 units at a time, Z then X; each axis moves only if its collision probe is clear.
6. SettleRe-sample the floor height under the new position; hop a ledge if the floor ahead rises a step.
7. TriggersEntering a new tile checks the trigger block: teleports, door records, story beats, encounters.

• Direction. The remapped mask names axes: 0x1000 Z+, 0x4000 Z−, 0x2000 X+, 0x8000 X−. A diagonal is two axes resolved independently, so a diagonal into a wall still slides along the open axis.
• Wall slide. For a blocked cardinal, three probes 62 units ahead (centre, ±33 lateral) sweep an offset table across the travel axis and add the slide direction the sweep's sign picks. Pure diagonals and symmetric dead ends add nothing.
• Animation follows motion. A committed step selects the walk or run clip; no step selects idle. The pad is never consulted for the clip, and walking and wall contact are silent.
• Run is an exclusive or. The Field Move option sets the default and the held button inverts it, so with Run selected the button walks. The button is Cross | R1 (mask 0x48), seeded once at new game and never rewritten: retail cannot rebind it.

A walkability tile

The world is cut into 128-unit tiles, and each tile is split again into four 64-unit sub-cells. One byte per tile carries both a wall bit for each sub-cell and the tile's floor height.

• Two nibbles, two mappings. The collision probe maps world to sub-cell with a bias (Z floored then +2, X rounded up then −1), which pushes the half-tile-centred player onto the forward tile; the floor sampler reads the same bytes with plain indexing. A sweep that reads the whole byte as a wall mask calls every raised tile a wall.
• The grid wraps. Both the row and the column are masked to 7 bits, so a Z past the last row reads a real row rather than "no wall".
• Actors block too. Before the wall probes, three wider probes test other actors: a static prop blocks within ±80 units of its footprint, a moving NPC within ±40 of its live position. A hit links the pair, which is how a door's touch script fires on contact.

How fast is a frame?

Retail runs two clocks: the vsync (60/s) and the game tick, one pass of the master frame driver. A scratchpad byte, the frame scalar, says how many vsyncs the last tick spanned (1..4, floored at 2 in field scenes and 3 on the overworld). Every duration and velocity inside the tick is multiplied by it, so a cadence change moves the sample rate, never the speed.

The overworld step comes from a per-scene MAN flag set on exactly the three kingdom maps, and each kingdom's entry script also sets the player's multiplier to 0xC00, so the overworld walk is (5 × 0xC00) >> 12 = 3 units per vsync. Reading a per-frame number in the wrong clock is where "the player moves 1.67× too fast" comes from; the port ticks once per vsync with the scalar at 1.

The field buffer: where walls come from

Nothing in a town's script says "this is a wall". The scene loader streams the scene's .MAP file into a per-scene buffer, and the collision grid is one region of it.

The .MAP is the first 0x12000 bytes, streamed by CD-DMA at scene load; a write-watchpoint on the live grid catches only the DMA writer. Scripts then paint story-conditional rectangles on top with 4C 7s - Rim Elm's south gate stays painted shut until the story opens it.

Pressing the action button runs a separate probe: a radius-64 compass point in the facing sector against a ±72 NPC box. A hit engages the NPC's script and turns the player toward it. Props divide into two classes on one authored bit: doors open on body contact, cupboards (which run 31 1E in their spawn prologue) only on the button.

Height: two floor models

The walk controller only writes X and Z. After it commits, a second controller re-samples the floor under the new position and glides Y toward it; a third probes ahead along the last step and starts a scripted hop when the floor rises a ledge.

The kind-2 record replaces the bilinear branch; it is not a fast path on top of it. Rim Elm's shore ramps sit on sea-level nibbles and hold their whole elevation in kind-2 records; interpolating their nibbles walks the player under the drawn stairs.

Triggers: doors, beats and teleports

Crossing onto a new tile (tile = (world − 0x40) >> 7, compared against last frame's) looks the tile up in the trigger block. Scene entry marks the compare stale, so the arrival tile fires on the first tick.

A crossing made while a script holds the player - a cutscene, a conversation, a helper record - is spent, not deferred: the tile is stored and nothing is looked up. Deferring it instead fired the landing pad of rugi's warp pair on the first free frame and bounced the player between the two pads forever.

A beat that should play once self-latches: its script sets the very flag its gate lists, so it runs on the crossing that finds the flag clear and blocks itself afterwards. The gate bitmap is the field VM's own story-flag bank, so a set is visible to the next record immediately.

Walking into a house

A town house is not a scene change: the interior is a sub-area of the same 128×128 grid parked in an unused corner, and the door repositions the player. Two door mechanisms exist, and one house can use one of each.

Map doors are the larger class, and a MAN-only census cannot see them. Vahn's house is the mixed case: script door in, map door out.

A door teleport re-centres the placed-object window. The sub-area sweep keeps a list of the window-owned placements around the camera’s latched region box, and only a re-centre rebuilds it. A script door’s player arm (0x23 or 4C 51 aimed at the player) calls the re-centre on the landing tile, as do the kind-0 warp landing and the leader swap. Without it, leaving a house keeps the interior’s box and the street’s window-owned scenery stays hidden until something else re-centres. The port re-centres from the same arms, including the walk-touch teleport it decodes for a door with no prop.

Prop-door rides: lifts and swinging doors

A lift or door whose object has an animated prop rides on its own record: contact hands the touch to the prop runner, which executes the whole record - both doors, both walks and the jump between them. Sol Tower’s floor lifts show the shape; every pair is the same record with the partner id, the walk tiles and the landing changed.

Two engine shortcuts used to hide both doors: applying the record’s decoded teleport on the first contact frame put the player on the far floor before the near door moved, and stepping the partner ops on the record’s own context swung the near door twice and the partner never. A prop door’s record is now left to the runner; an interact-gated object, such as a lever, waits for the confirm press instead.

A door with no prop still takes the decoded teleport at contact, and the engine keeps the effect of the record’s own arrival bracket for it: the touch dispatch and the collision probe skip the partner until the player has stepped clear of it, and a landing the walls seal on every side carries the player past the platform. The same cross-object ops drive lifts, gondolas and gates in several other dungeons.

Talking through a stand-in

Pressing the action button probes a point ahead of the player against every actor's box, and the hit is a conversation when the actor carries the talk flag. An undrawn placement can stand in for a speaker the probe cannot reach: its record only marks another actor as touched, and the context runner then plays that actor's conversation. Conkram's gate guards (concnow) are spoken to this way. The port reads such stand-ins at scene entry and answers a hit on one with its target.

The ledge hop is its own little machine

When the floor ahead rises a ledge, the walk does not climb it: a setup routine spawns two helper actors, raises the movement lock and hands the player to an arc controller with its own cursor, separate from the clip system.

• The probe looks along the last step. The settle controller keeps the direction of the last committed step in two globals; the hop probe samples the floor a step ahead in that direction and posts the hop only when the rise is a ledge.
• The lock is the same bit a cutscene holds, which is why the pad opens no menu in mid-air. The take-off also raises the flag that hides the player's ground shadow (renderer).
• Retail never tests the landing. The probe checks the wall bits along the way, but nothing checks the cell the arc sets the player down in. A hop into an open sub-cell that is walled on every side leaves the player where all four directions are refused, and with no step committed the probe never runs again - one diagonal step-up in jouind lands exactly so. The port's landing guard refuses such a hop; it is an enhancement, on by default and off in the retail-faithful mode.

Touching and talking

Collision asks two questions at once: is there a wall, and is there somebody. Before the wall probes, each step tests three points against every other actor - a wider sweep than the wall edge, 64 units ahead and 32 to either side, because actors block with a body box. The same step then decides whether the contact means anything.

• Talking is not an opcode. A talk is this button probe posting an event to the actor it found; the actor's own script takes it from there (script VM).
• The event goes to the last actor hit, not the first. The list walk has no early exit and overwrites the partner pointer on every box hit. Scene init appends story actors before placed props, so a point inside both an NPC's box and a prop's box is delivered to the prop. It is an oversight a port has to keep to match which thing answers.
• All of it is off while the player is engaged - the same flag that gates movement - or while a dialog owns field control.

Where you stand when a scene starts

The locomotion controller never places the player. The scene initializer does, and it picks between two behaviours from a one-shot word the departing mode leaves behind and the initializer clears on its way out.

Retail never enters a scene without a door operand, but the port's scene picker can. A picker entry first tries the scene’s door arrivals - where other scenes’ scene-change ops land the party (engine) - and only when none qualifies does it synthesise a seat: retail's own fallback coordinate when it is standable, inside the scene's main walkable region and not on a teleport pad; otherwise a door-arrival anchor, then the region's centroid.

• The main region is not simply the largest. On the three kingdom maps the collision grid leaves the sea open - the coast is a closed wall ring and retail only arrives by door onto land - and the sea is about four times the continent. The rule excludes a region that reaches three or more map edges, which is exactly those three seas.
• A door arrival is never nudged. A standable tile is taken exactly as given, so every authored arrival lands byte-exact on its operand; only a derived tile the grid does not cover is moved to the nearest open sub-cell.

The camera turn is authored, not computed

The pad remap rotates the held direction by an eighth-turn index. Nothing in retail derives that index from the camera. Its writers across the whole disc are two, and both are content: a field-VM op that sets it to a literal, and the tile-board walker. A scene author picks the octant to match the fixed camera the same script installs; a bare tile crossing never changes it.

• The op turns the player with it. Under one condition the same arm rewrites the facing by the delta it applied, so the character keeps facing the same way on screen across a camera cut.
• The port departs here on purpose. Its camera can be dragged, so an authored constant goes stale the moment the view moves; it rounds the live camera azimuth to the nearest of the eight steps instead. On every axis-aligned camera the two agree.
• The slide is measured. A probe on the resolver's return in a retail town shows it answering the held direction on 261 of 276 calls and widening it on 15 - one held-left run down a wall, where “left” becomes “left and up”. Six of those rows are the pin the port's resolver is tested against.

The four base steps

The walk clip is chosen the same way the step is: no direction held is the idle base, a direction under the plain walk step is the walk base, and any other step is the run base. The run button word is one of four button masks the new-game init seeds into the save block; that init is their only writer anywhere, so retail has no way to rebind them.

NPCs: facing and glide speed

Initial facing

The placement record has no facing byte. At spawn the installer pre-runs the record's leading ops (a 0x24 / 0x25 marker up to the first 0x21), and two of them write the heading from the 8-direction LUT at SCUS 0x80073F04: the NPC move-to-tile op 4C 51 (operand +3, low nibble) and op 0x38's simple path. Town prologues route that leg through story-flag tests, so the fall-through branch is the fresh-game facing. Rim Elm's side-by-side villagers at tiles (29,22) / (30,22) derive indices 6 and 2 - they face each other.

Heading space: retail 0 = Z−, 0x400 = X−, 0x800 = Z+, 0xC00 = X+. After spawn, walking snaps the heading and the rotate ops ramp it; the last writer in the frame draws (motion VM).

Glide speed

An NPC's pace is not the player's walk step - the walk kernel never reads the speed multiplier. Both NPC walk kernels carry the base step in the walk op's own operands, on the ladder numerator >> (2 + bits) units per vsync.

Base steps run 32 / 16 / 8 / 4 / 2 / 1 for bits 0..5. There is no synthesised motion bytecode: the field VM parks the op's address on the actor and the walk kernel reads the record bytes in place each frame.

In the port

• Faithful path. World::step_field_locomotion rings the held pad around the same eight-direction compass, hands the remapped mask to the wall-slide resolver and walks the result through the same per-axis 2-unit collision with the three-probe edge and the actor boxes. Wall-press captures rest byte-exact. Retail picks its rotation step from scene data; a free-orbiting camera has none, so the port rounds the live camera azimuth to the nearest eighth.
• Enhancements. Free-angle movement (options::precise_movement, default off): continuous azimuth, true 45° diagonals at unit speed, analog stick angle. --no-edge-collision / --no-solid-npcs fall back to a centre test and walk-through NPCs.
• Floor. World::sample_field_floor_height carries both height models.
• Run button. The run mask defaults to the retail Cross | R1 plus Square; which key is which pad button is a host binding (legaia-engine config set --binding W=R1).

How we know

Full write-up, including the hop-arc controller, the door-swing clip binding, the timed warp and the scripted-scene actor programs: docs/subsystems/field-locomotion.md.

Details

See also