Lead: the dash subtype’s
per-tick handler (state 3) Decoded 11-14
(movepar, M): the dash state (3) reads
no stick and changes no angle: the roll goes
along the body’s facing as it stood at the press
(after a locked turn start: the heading),
straight, no steering (FORMATS “Movement parity”
section 5). Rebuild: drop “along the stick”
Roll
evade without converted data
Status: PLACEHOLDER
Now: Our 4 m roll over 0.5
s when movement.json has no
evades
Where:movement.gd
EVADE_DASH_FALLBACK
Lead: re-run
skilldata.py(evade)
Evade
windup/landing hold on the capsule
Status: PLACEHOLDER
Now: No windup, no landing
hold without a converted character (they come
from its animation lengths)
Where:player.gd EVADE_TICKS_FALLBACK
Lead: load a character
Air control turn
rate
Status: MISSING
Now: Our body faces the
stick at once, so the air speed is the full run
speed
Where:player.gd air control
Lead: decoded (docs
11-09): the facing moves toward the stick
by at most the character’s turn rate per tick,
20° for the playable cast (FORMATS “Character
table”, “Turn step”); skilldata.py
doesn’t write the column yet Decoded
11-14 (movepar, M): per tick the turn
step (1820 angle units for the playable cast),
then the factor from the angle left after it,
then the move along the previous tick’s facing
at 20 / 10.8 u; no status speed scale in the air
(FORMATS “Movement parity” sections 3 and
5)
Air
control outside the evade jump
Status: MISSING
Now: Falls off ledges keep
the ground walk/run speeds
Where:player.gd
Lead: the air state is the
same for every jump: steer at run speed
11-14 (movepar): confirmed in
the handler: state 5 serves every jump and fall
(FORMATS “Movement parity” section 5)
Light/heavy
landings from falls root the character
Status: MISSING
Now: They give way to
movement; the evade landing roots (decoded
(evade))
Where:pd_character.gd,
player.gd
Lead: decoded: the landing
state lasts the slot’s length − 1 ticks and only
counts down 11-14 (movepar):
tick count: counter = slot length n − 1, the
stand starts n ticks after the landing tick, the
first move 2 ticks later; the windup is the same
bare countdown (FORMATS “Movement parity”
section 5)
Air
animations lift the hips up to 0.65 m
Status: INFERRED
Now: Not compensated: the
model is drawn with the animation’s own hips
height. Its x/z is not drawn: the root’s
ground-plane track is stripped from every
animation at load, so the drawn hips stay over
the body (measured 0.000 m at every air tick of
the evade, --shot-evade log and
autotest anim hop)
Where:pd_character.gd
Lead: decoded
(evade): the game moves the body only
by the root’s x/z delta, and not for
up/down/landing; whether its renderer draws the
hips’ height is our reading
Air
“up” rate of a body that doesn’t announce its
jump
Status: INFERRED
(jumparms)
Now: Bodies other than a
Player (no start_jump at launch)
stretch “up” over their first rising speed / g;
a Player passes the decoded launch speed
Where:pd_character.gdstep
Lead: only the jump routine
launches in the game (FORMATS “Kind, launch and
blends”); give every jumping body a
start_jump call
Evade
arm pose vs reference footage
Status: INFERRED → cause
decoded (armpose 11-14)
Now: The slots, rates and
joint maths are the game’s, but the character
data comes from the plain-named model file,
which the battle never loads; its “up” / “down”
raise and spread the arms, the loaded file keeps
the hands down in the rise and on the head from
the top to the landing (FORMATS “Pose mixer and
the character file the battle loads”, section 3,
with the hand heights for both files; the Xbox
strip matches the loaded file)
Where: converter data
command, main.gd character id,
pd_character.gd
Lead: convert the variant
file (row “Character source file”); then compare
a standing evade with the Xbox strip frame for
frame; no fall-height rule, no pose fix. The
engine does nothing to the arm joints after the
evaluator (mixer 0x140298020 read to the
matrices)
Character
source file (plain vs colour variant)
(armpose 11-14)
Status: PLACEHOLDER
Now: The protagonist is
converted from the plain-named .alr
(129 slots, 101 + 23 joints). The battle loads
the name plus the colour variant digit (130
slots, 115 + 23 joints; 110 slots have other
keys, 29 other lengths); every charaset record
has a variant count, so the plain file is never
loaded
Where: data command (pdconv
input), main.gdCHARACTER,
pd_character.gd joint constants,
tests that pin 129 slots / 101 joints
Lead: convert the variant
file for every character; re-derive joint
indices (root 20, hips 22, right hand 52 on the
protagonist), slot-length timings (evade “up” 13
frames, “down” and landing 12) and the pose
descriptions; rerun
check_anim_keys.py and
charpose.py on it
Colour
variants of a character (armpose
11-14)
Status: MISSING
Now: One look per
character
Lead: decoded: variant =
high word of the character id, 0 to count − 1
from the character select, picks the model file;
the protagonist’s four files share joints and
animation keys
Lead: decoded: up to four
layers, older layers frozen at their frame and
faded by 1 / blend per tick, weights normalised,
rotations slerped the short way, an un-keyed
joint takes its bind value, a cut clears all
layers (FORMATS “Pose mixer …” section 2); check
ours against it when blends are next
touched
Neck
and head look twist (armpose
11-14)
Status: MISSING
Now: Neck and head play
their keys only
Lead: located (M):
per-joint hooks 0x14025dc40 / 0x14025dde0 turn
the two joints toward a target while the
character’s look flag is set (clamped, 0x1C7
angle units per tick); target and clamps need a
short decode
Step-up
while falling (cut off past 3 ticks of
fall)
Status: PLACEHOLDER
Now: A body falling faster
than 3 ticks (now game ticks, 1/30 s) of gravity
from rest doesn’t step up onto a ledge it meets;
it falls past it (st07hop)
Where:player.gd HANG_TICKS
Lead: decoded: the game’s
floor test lifts a falling body onto a floor up
to half its height + 0.9 m above its feet
(FORMATS “Floor test”); whether its wall pass
stops the body at the ledge’s face first is not
traced (0x1401959c0) Decoded
11-10: the game has no such cut-off; a
falling body is stopped by a ledge only when the
ledge’s wall face reaches 0.75 m over its feet
(face/edge pass), otherwise the floor pick lifts
it. Rebuild: drop HANG_TICKS with the decoded
response (FORMATS “Movement collision
response”)
Play
camera: the wall rule’s attribute skip and
push-out (camtick; playfix 11-14)
Status: INFERRED (segment)
/ DECODED (push-out)
Now: The tick runs as
decoded (PdCamera, 15-bit angles, steps 3-7:
lock turn from the body, pitch snap on release,
ideal points, wall rule with the look-at point
moved along, smoothing, sticks / re-centre /
yaw-follow; snap on pit return and respawn).
playfix: the wall test now keeps every
attribute but 18 and 20
(PdData.MASK_CAMERA; it used the
sight mask, which drops 16 and keeps 18 / 20),
and the radius-1 push-out is the decoded
one-sided triangle resolve (0x140195f30) over
the stage’s own shape list
(SurfaceMarks.resolve_sphere;
Godot’s two-sided rest contact pushed the eye
through the st02 road deck). Still ours: the
segment is a Godot ray against the stage
colliders (st02 / most stages: the render mesh,
double-sided), attribute 31 kept for the camera
(probe group mask not read), stage objects are
not in the push-out
Lead: the camera segment
probe 0x1404bec70’s group mask; whether object
bodies are in the camera’s world
Camera look-at
anchor
Status: INFERRED
Now: The body position
(feet) plus our draw offset
Where:player.gd_update_camera
Lead: the game uses the
point behind a model point pointer (character +
0x13de0) when it is set, else the body position;
which point it is and who sets it is not traced
(SYSTEMS.md §10 leads)
Camera
invert options: where they are stored
(camtick)
Status: INFERRED
(menus)
Now: Decoded and used: dead
zone 13000 / 32767 per axis, linear to 1, x / y
invert (LocalInput). Menu sessions: the options
screen’s controller rows write options 0 / 1
through 0x2083 into LocalInput (and 0x2082 reads
them back). Mapped by the game’s own labels (the
controller screen’s 0x204F: nibble 1 = reverse,
0 = normal, both axes) and FORMATS’ rule “y is
negated unless option 1 is 1”: an axis is
inverted when player 1’s nibble is 1.
Default change (menus r3): the
profile screen writes the new-profile defaults
(x 0x00, y 0x11), so a menu session starts with
up / down reversed, as the game labels a new
profile (debug starts are unchanged: no invert
unless --invert-x /
--invert-y). INFERRED: the stick’s
raw sign against that rule is not confirmed in
the game. Not saved (the save layer is skipped:
row “Menu save data”)
Lead: the raw stick sign
against 0x140256710 (device check: a new
profile’s up / down in the game); saving the
options block
Camera
yaw-follow: which of our states is the game’s
action state 1 (camtick)
Status: DECODED
(movepar); walk and run both count
Now: Yaw-follow runs while
the body moves on the ground (walk or run, not
hopping, not dashing); the game gates it on
action state 1 (C + 0x12f04), and its ground
state picks walk or run inside one state
(FORMATS “Movement” mode table), so walk is
taken to count
Where:player.gd_run_state
Lead: read which action
state the walk speed runs in (0x14025b6fc)
Decoded 11-14 (movepar, H for the
table): the action state is the
movement machine’s state word; 1 is the forward
walk / run handler (both speeds). The locked
turn start is state 8, the air 5: neither
follows (FORMATS “Movement parity” section
2)
Spectator
camera for a player who is out (team
matches)
Status: MISSING
Now: None
Lead: decoded (docs
11-10): com/stNN/camdata.cam
spots (converter/camdata.py),
150-tick delay, spot pick and re-pick rules,
watched-player switch (FORMATS “Play camera”);
open: which flag a KO clears and what game modes
4 / 5 are
Now: Built:
Player.cast_pitch at cast start,
kept in cast_pitch_u (angle units,
positive = down) until the next cast. Locked:
atan2(caster centre y − target point y,
horizontal distance), unclamped, truncated;
unlocked player: camera pitch − rest pitch
(PdCamera.aim_pitch_u; a remote
body’s travels in PlayerInput v3); CPU
(VersusBot), defenses, other sets and the kinds
that keep the facing: 0. Our caster centre is
Defense.CENTRE_HEIGHT (0.9 m), not
the character record’s centre height (field
0x12)
Lead: FORMATS “Vertical aim
of a cast”; lead for the centre height:
character record field 0x12 (C + 0x12e98);
footage check (unlocked pitched shot, locked
shot up the stairs) to raise M to H
Turn
slots, status-mode idle/walk/run sets
Status: MISSING
Now: Not played
Where:pd_character.gd
Lead: mode table fields
3–10 (decoded location) Decoded 11-14
(movepar, M): fields 3–10 are one-shot
turn starts played from a locked stand when the
stick is more than 45° off the facing: action
state 8, full speed along the stick heading,
facing = heading ± 90° / 180° until the one-shot
ends (FORMATS “Movement parity” section 4).
Open: the drawn rotation of each one-shot,
status modes
Hit-reaction
root motion
Status: INFERRED
Now: During a reaction the
body moves by the animation’s root-joint ground
track (staggers push back, landings slide) on
top of the decoded throw slide
Lead: the exe routine that
applies root tracks (not located; the locomotion
loops keep the root in place, the reaction ones
move it)
Root joint of a
model
Status: INFERRED
Now: One rule for the hit
reactions and the evade: the parentless joint
with the most position tracks whose y stays 0
(joint 6 on pc00a, 0 on the enemy models). Its
track is stripped from every animation at load
(root motion never drawn; the roll slot carries
its whole path on it); the reactions apply it to
the body as root_velocity, the evade jump does
not (decoded)
Lead: the key format marks
it (translation code 2, xz only, FORMATS “Root
motion”): have pdconv write that joint into
animations.json; how the exe’s animation player
picks the joint it takes the x/z delta from
(0x257510) (armpose 11-14: in the variant
file the battle loads the protagonist’s root is
joint 20, not 6; the engine itself takes the
first joint with flag bit 0 and draws it at the
base matrix’s x and z, FORMATS “Pose mixer …”
step 6)
Hit during
the evade windup
Status: INFERRED
Now: The reaction cancels
the pending launch (the body never jumps while
it reacts)
Where:player.gd_evade_wait
Lead: the reaction dispatch
(0x24fd80 → 0x258690) sets the character state;
confirm it replaces the evade windup state
rather than letting it finish
Lying
pose after a thrown landing
Status: MISSING
Now: The pose of the fall’s
side: back fall → 60, others → 62
Where:pd_rules.gd thrown_landing
Lead: decoded (docs
11-09): picked per landing slot (50..55) by
the character table’s six lying flags, with a
stored turn per slot (FORMATS “Character table”,
“Lying pose”). For the playable cast our rule is
right only for the lightest landing of each
side; the two harder ones give the other pose.
Needs the flags in the converted data
Hit
direction of a reaction
Status: INFERRED
Now: From the hit’s push
(the shot came from −push)
Where:combatant.gd _react
Lead: the game uses the
shot’s position: pass it in take_hit
Now: Hit effect 45 is
played: the target goes to the attacker’s start
(spawn_point, the dummy’s
home) and starts the 0x74 action
row
(PdHitEffect.teleport_to_start)
Where:combatant.gd,
PdHitEffect
Lead:(step3
11-13) 0x140257e90 is the teleport routine
(FORMATS “Hit effect 45 is a teleport”).
(hurt 11-13) the hard-landing damage is
built: row “Thrown-landing health loss”
Thrown-landing
health loss
Status: DECODED (hurt
11-13: built)
Now: A thrown landing costs
0 / 1 / 2 health by its drop from the throw’s
peak (< 40 / 40–80 / > 80 units), versus
rules only; jump and fall landings never cost
health
Now: A fall of more than 80
units (not thrown) and every thrown landing send
one shot-type contact (one hit) to each stage
object in a sphere at the feet: radius 10
(fall), 10 / 15 / 20 (thrown, by severity); the
same probe makes the crater; host only
Now: Built from the decode:
the probe takes the first arena mesh in file
order with a triangle in range and that mesh’s
last triangle in range (so the Palace’s upper
level marks its underside, as in the game;
markprobe’s st03 points reproduced by
test_hurt); landing probes, blast
spheres and shot segments; attribute → kind 0 /
1 / none (none on attributes 4 and 24 on stages
ending in 8); 1 unit off the surface, random
spin; ring of 32; refused inside an existing
mark; removed when the camera enters its bounds;
host makes it, Ev.MARK carries it (whole-unit
position, normal × 10). Built (crater
11-15): the look is the kind’s model from
<stage>/crater/crater.json
(craterconv, all 19 versus stages converted),
drawn as the carve: Godot 4.7’s stencil only
replaces, so the game’s increment /
decrement-wrap count is made from the faces’
sides (entry faces in front of the scene set the
stencil, exit faces behind it draw with the
depth test inverted, then a clear pass), lit by
the stage’s own light shader; refusal radius and
camera box from the model’s bounds
(24.57 units on the Palace;
test_crater). INFERRED
(Godot draw order): Godot draws the
passes after characters (the game: right after
the stage), so scene points more than 0.5 units
above the mark’s surface plane are not carved
(characters standing in a crater;
gpu_crater: an opaque box 0.6 to
1.4 units above the plane keeps its colour, the
floor around it is carved); a stage surface
above that plane inside the volume (a stair
step) is not carved either.
PLACEHOLDER: a stage without
<stage>/crater/ installed, or
a mark kind with no model in it (st01’s
converted data has no mark models), draws no
mark and uses PLACEHOLDER_RADIUS 10
for radius / box (test_crater: a
missing crater.json, st01, and st07’s own 17.37
radius); st07 / st17 marks are animated in the
data (age 0.5 per tick, removed at the
animation’s end) but drawn unanimated and kept
like the Palace’s
Lead: Open: the draw’s
start check (0x14057f418); animated marks of
st07 / st17 (play the records, end at the
animation’s length); the mark material’s
specular bytes (not exported by craterconv)
Mark
effects: debris, one-shot models, dust, sound,
destroy contact
Now:Built (crater
11-15): one debris request every time
through the decoded manager (60 slots, first
free from the next index): debris kind 15’s
200-piece model moved by the decoded vertex
motion in a shader (launch 1.5 u/frame along the
normal + own velocity, 64-step tumbling, gravity
0.05 u/frame² scaled by 1 − 0.9 clamp(−n.y), 90
ticks: ends at frame 89 = life − 1, fade from
50), lit by the stage light shader
(test_crater: vertex positions at
frames 1 / 30 / 88, alpha at 50 / 70); the smoke
one-shot (0x45) on every request, also a refused
one; with an added mark the burst (st00 0x0E) at
twice the mark matrix and, for kind 1, the
facing’s fragment model (40-tick baked throw,
fade from 30); point sprites drawn as the
capsule form’s elements
(MarkOneShot,
CapsuleForm helpers). With an added
mark two dust sprites (StageSmoke.add_sprite:
velocity, wind, spin decoded; colour,
alpha and life PLACEHOLDERDUST_*), the material sound (table
decoded, bank INFERRED: the
common bank) and a radius-15 destroy contact to
stage objects. INFERRED: the
debris spin pair’s scale (/32767, craterconv);
the wall fragments’ turn (the model’s +Z onto
the flattened normal); fragments drawn without
culling (material: back faces culled); the
point-sprite smoke’s blend from its word 0x5400
(mixed) and the burst’s 0x1100 (added); the
debris / fragment materials do not follow the
stage’s point light updates after they are made
(lit_material shared = false)
Lead: Open: the dust
sprite’s colour / alpha / life bytes; the piece
pixel shader (not read: texture × stage light
used); the spin pair’s scale; the debris
manager’s request with no free slot (dropped
here)
Reaction
types 8 and 9 (frame range, jump)
Status: INFERRED
Now: The first animation
for its whole length
Where:pd_rules.gd reaction_slots
Lead: decoded frame range
a2..a3 (FORMATS); only special-character records
use them
Reaction
animations on netplay clients
Status: MISSING
Now: The client only gets
the host’s lockout time; remote bodies don’t
play reactions
Where:net/net_session.gd
Lead: send the reaction
(action id, side) with the hit event; (docs
11-10) the game sends action id and
animation frame with every position sample and
blends between the two newest (FORMATS “The
original network protocol”, Remote
characters)
Animation frame
rate
Status: INFERRED
Now: 30 fps assumed
Where:pdconv.cxx ANIM_FPS
Lead: the exe’s animation
player rate
Homing
percent of the cast event
Status: INFERRED
Now: 100 %
Where:data_skill.gd HOMING_PERCENT
Lead: the cast event’s
percent argument
Wall
collision response and step-up
Status: DECODED
(movecoll, M: code only) / MISSING (the
long-move back-off decoded by movepar, ours
differs; contact order and floor flag built,
playfix r3)
Now: Built:
PdBodyMove.resolve replaces the
CharacterBody3D slide and our STEP_MAX 0.45 m
step-up / step-down with the decoded passes on
the static triangles (the
collision.json set where converted,
the render-mesh colliders elsewhere): long-move
guard (> 12.5 u), segment guard + 2.5 u
sub-steps, round-arena limit (stages x1, 150 u),
face pass (three spheres r = w/2 at the centre
and ± (h/2 − w/2); floor faces lift by the
penetration, wall faces push along the full
normal), edge pass, the 0.75 m step-over (low
faces / edges dropped, the floor pick lifts the
body), one pass per tick, no velocity change;
then the decoded floor pick (0.75 m + move snap,
normal y > 0.643) and the 0.5 m leave-ground
drop. Body sizes from PdBodyTable (decoded per
model). The long move’s cast skips attribute 31,
and 20 in the jump (the passes’ skips; movecoll
r2). The floor pick takes a two-sided
(render-mesh fallback, 16 stages without
collision.json in COLLISION_STAGES)
face only from its front (normal y > 0.1), as
a one-sided face; it no longer flips an
underside into a floor (movecoll r2). INFERRED:
(1) a long move’s hit is backed off by the body
radius along the hit normal (the helper’s offset
is not followed;
LONG_BACKOFF_PLACEHOLDER); (2) the
contact list order: built (playfix r3) as
decoded, shapes in add order with each shape’s
triangles reversed; the stage objects against
the arena is its own INFERRED row (“Contact
order: stage objects against the arena”); (3)
built (playfix r3): the floor flag (mover +0x08)
is its own flag, 0 on every launch and on a
teleport, the floor pick’s result at the end of
each response (player.gd_floor_flag); the ground flag keeps
the 0.5 m leave-ground drop; a net snapshot
carries the floor flag (body flag 16, snapshot
v25, playfix r4: a client’s replay starts from
the host’s, tests/test_netledge.gd). Not built:
the “put back instead of walking off an edge” in
cast-like states; the blocking-wall flag
+0x12E8C’s readers
Where:pd_body_move.gd,
player.gd _move_body
Lead: (1) the long-move
helper’s returned offset (FORMATS “Movement
collision response” step 1); (2) the collision
world’s object list order; (3) where the jump
launch writes mover +0x08; the edge-stay states
(FORMATS “Leaving the ground”) Decoded
11-14 (movepar, M), all three: (1) the
long move’s hit position is hit point + the
triangle normal (1 u), and its cast skips
attribute 31 only, not 20; (2) contact order =
static shapes in add order with each shape’s
triangles reversed, then dynamic objects (head
inserts); (3) launches write 0 to mover + 0x08
and the ground flag together, and the routine
ends by storing the floor pick’s result there:
the floor flag is not the ground flag during the
0.5 m leave-ground drop (FORMATS “Movement
parity” section 6). Rebuild: replace
LONG_BACKOFF_PLACEHOLDER (the query
order and the separate floor flag are built,
playfix r3)
Decoded
collision per stage
Status: PLACEHOLDER (stages
not yet converted)
Now: st01, st03 and st07
build their colliders from
collision.json with the decoded
attribute layers (collattr); any other
stage keeps the render-mesh colliders until it
is converted and run through the suite
Where:pd_data.gd COLLISION_STAGES
Lead: convert the other
stage files (collconv.py already keeps every
mesh’s attribute) and add them to
COLLISION_STAGES with a suite run each
Stage
collision attribute 20: which of our states are
game states 5 / 7
Status: INFERRED
(collattr)
Now: The body’s mask drops
attribute 20 while _hopping (the
evade jump, in the air until it lands) = game
action state 5; state 7 (the float, entered from
5 when the jump button is held while falling,
animation slot 42) is not built; the roll evade
and a walk-off fall keep 20 solid
Lead: decoded (H): the body
skips 20 when the action state (character
+0x12F04) is 5 or 7 (0x140255400); state 5 → 7
at 0x14025a3b2 (slot 42 = float start in
Esper-RE’s animation enum), so 5 = jump. M: that
every frame of our hop is state 5 (the jump’s
state entry and the roll’s state number not
traced)
Shots
against the stage collision
Status: INFERRED
(barriers)
Now: Shots, beams, blasts,
drops and ground probes use the decoded shot
mask (layer 1: every attribute but 16, 18, 20,
31) (collattr); the players’ barrier
objects are tested by our Defense code, not by
the cast’s barrier step
Lead: decoded: the cast
tests the arena + stage objects then the active
barrier objects of the players in the shot’s
mask (0x140163680); which cast each skill kind
calls is not tabulated (use sites in FORMATS
“Collision attributes, groups and casts”)
Prop collision
by kind
Status: INFERRED
Now: Each layout prop uses
its kind’s state-0 collision list (kind = object
id; none = not solid); state changes (broken
props, lists 1 and 2) are not followed
Where:pd_data.gd place_props
Lead: decoded for the
structure class (0x1401fbbc0, lists from the
kind entry, FORMATS “Stage collision”); which
PS00 entries are other object classes, and the
break state switch
Body push
between characters
Status: DECODED
(movecoll, M formula / H place) /
INFERRED (netplay roles)
Now: Built:
PdBodyMove.push from
player.gd _body_push, at the
decoded place in the tick (on the wanted
position after the stick / skill move, before
gravity and the collision response): vertical
overlap of the centres (feet + h/2) under the
half heights’ sum, horizontal under (w_a +
w_b)/2, half each for two locally simulated
bodies, whole for the own body against a
network-driven one; no state gate; heights
untouched. Netplay (movecoll r2): each
peer pushes only its own body, as decoded
(“Where it runs”: a network-driven body runs no
push): the host’s body takes the whole overlap
against the client’s; the client’s body against
the host’s body as the client sees it, and that
push travels in its input (PlayerInput v4
body_push, mm), which the host’s
copy of the client’s body applies in place of a
push of its own (the client’s replay re-applies
it). Inputs the host drops when packets bunch
(NetInput MAX_QUEUED) add their push to the next
input applied; a held tick (no input arrived)
applies none, so that push lands one input
later, not lost (r3:
tests/test_netinput_push.gd). Both peers
still drive into each other after contact (the
push changes no velocity), so two bodies walking
head-on are held about R apart and then slide
around each other (net-movecoll: closest 0.82 m
on the host, ~0.18 m without the push).
INFERRED: our host still runs the collision
response for the client’s body from its inputs
(host-authoritative; in the game the client’s
own messages place it), so the push it applies
is the client’s but the walls are the host’s
(same geometry, same code: net-movecoll 0.000
m)
Lead: a host-authoritative
design has no game counterpart; revisit if
netplay moves to peer-owned bodies
(NETCOMPAT)
Locked
aim / lock target point
Status: INFERRED
(doc-body 11-12)
Now: The locked cast pitch
and shot steering aim at the target’s body
centre (feet + 0.9 m); (followups
11-15) the lock grade distance no longer
does (torso root to torso root, row “Target
record point”)
Where:player.gd cast_pitch,
data_skill.gd
Lead: decoded (H for the
node): the game aims at the target’s body point
= the torso root model node as posed this tick
(about 1.13–1.21 m up standing, lower when
crouched or lying), radius 0.5 m; the caster’s
end stays feet + 0.9 m. Rebuild: export the
joint by packed name in the converter and add
body_point() (FORMATS “Body point,
sight point and aim point”)
Touch
list in the movement step
Status: not a touch list
(movepar 11-14: see the lead
column)
Now: Not built
Lead: lead (L): virtual
slot 0x80 (0x140250cd0), run right after the
body push while the match phase is not 0: sphere
at the body point, radius C + 0x130, files
sphere-type world objects into 48 records at C +
0x4f0; what reads them was not followed stale
since 11-12: slot 0x80 is the consumer of the
stage attack bodies and the 48 records are the
character’s own skill objects (FORMATS “Stage
attack bodies and landings”); there is no touch
list. Row kept only until that consumer is
built
Per-character
body size, turn step
Status: DECODED body sizes
(movecoll: used) / MISSING turn
step
Now: Every character uses
the same engine values
Where:movement.gd,
player.gd
Lead: decoded (docs
11-09): charaset.dat record,
all columns (FORMATS “Character table”): height,
width, radius, centre height, turn rate, cast
blend. The playable cast differs only in height
(18–20 units) and evade; there is no
per-character speed column. Left: write the
columns from skilldata.py and use
them 11-12 (doc-body): the
numbers per character are tabled in FORMATS
“Body numbers per character” (height 1.8 / 1.9 /
2.0 m by model, width 1.0 m, centre 0.9 m, turn
20°/tick for all eleven playable models)
movecoll: the body height /
width / centre height are used by the collision
response and the body push
(pd_body_table.gd, per model); the
turn step is still ours 11-14
(movepar): how the turn step is applied
(order in the tick, the remaining-angle factor,
the one-tick lag of the move direction, where
the lock changes it): FORMATS “Movement parity”
sections 3–5
Ground
walk: order in the tick (movepar
11-14)
Status: MISSING
Now: The body faces the
stick at once and moves that tick
Where:player.gd simulate
Lead: decoded (M): turn
step, factor from the angle left after it, move
along the previous tick’s facing; no move on the
start tick, no slow-down on release; integer
angles and the float32 sine table (FORMATS
“Movement parity” sections 1–3)
Locked
turn starts (action state 8) (movepar
11-14)
Status: MISSING
Now: Not built: a locked
body turns like an unlocked one
Where:player.gd,
pd_character.gd
Lead: decoded (M): FORMATS
“Movement parity” section 4; open: the
one-shots’ drawn rotation, the C + 0x30
flag
Stick
length and run flag (movepar
11-14)
Status: INFERRED
Now: Our stick length is
clamped to 1
Where:net/local_input.gd,
player.gd
Lead: decoded (M): length =
sqrt(x² + y²) of the dead-zoned axes, unclamped
(to 1.414), run above 0.7, walk below 0.4, angle
truncated to 15-bit units (FORMATS “Movement
parity” section 1); check ours against it
Palace
benches walked over from the seat side
(movepar 11-14)
Status: INFERRED
Now: The body steps onto
the seat and passes the backrest, as the decoded
passes give for the bench’s own shape (placed
object kind 9, seat 5.3–6.0 u, back 10.9 u); the
climb-over from the seat side is observed in the
game (Rebirth, 11-15)
Where:pd_body_move.gd
Lead: seat-side climb-over
confirmed in the game (11-15); the back-of-bench
stop is still unchecked: record the bench cases
of the parity test (FORMATS “Movement parity”
sections 7 and 8) before changing the
response
Movement
parity test against the game’s position stream
(movepar 11-14)
Status: MISSING
Now: No replay test;
movement is checked by rule tests only
Where:godot/tests
Lead: plan: pad log +
loopback capture, replay through
Player.simulate, per-sample
comparison with tolerances (FORMATS “Movement
parity” section 8); the capture needs the
playtester
Practice
dummy’s body (movecoll r2)
Status: PLACEHOLDER
Now: The practice dummy
(dummy.gd) still moves with Godot’s
move_and_slide on a 0.4 m capsule,
not PdBodyMove; the Player’s body
push treats it by the default body (1.0 m wide,
PdBodyTable DEFAULT), so a pushed dummy is
separated to 1.0 m but walls stop it at 0.4
m
Where:dummy.gd
Lead: not game data (a
practice target of ours); move it through
PdBodyMove.resolve with the default
body if it ever walks into walls
Body
size without a character model
Status: PLACEHOLDER
Now: The capsule
placeholder visual (no converted model) gets the
smallest playable body, 1.8 m × 1.0 m, centre
0.9 m
Where:pd_body_table.gd DEFAULT
Lead: none: the game always
has a model; goes away with the capsule
visual
Lock-on:
which pad buttons are the lock (bit 0x800) and
switch (bit 0x400)
Now: RT locks, LT switches:
confirmed by the game’s button table
(0x1403dc710; FORMATS “Pad input: buttons to pad
bits”). Not yet taken from it: the evade / jump
is on L3 and LB, camera
re-centre on R3, triggers digital at 20 / 255;
Tab / R keyboard keys are ours
Where:local_input.gd bindings
Lead: the unread pad bits
(right shoulder, Start, Back, d-pad) and the
keyboard bindings
Lock-on:
target table order
Status: INFERRED
Now: Fighters sorted by
node name stand in for the game’s 32-entry
table; decoded (docs 11-10 rules): each
body record takes the lowest free index at
character set-up, so the order is player slot
order (FORMATS “Lock-on and targeting”, fill
order); not implemented
Where:lock_on.gd candidates()
Lead: confirm the set-up
order of the four slots; sort direction of the
distance-ordered switch option
Cast aim
without a target
Status: DECODED (pitch
built vaim 11-10, M) / PLACEHOLDER
(turn)
Now: A cast with no target
turns the body onto the camera yaw and fires
along it (set 0 or 2, outside behaviors 8, 16, 4
with parameter 2) at the camera’s aim pitch
(camera pitch − rest pitch; CPUs 0). Still ours:
the turn is at once instead of by the turn step
per tick, so the shot leaves along the cast yaw,
not along the facing reached at release
Lead: the turn step per
tick during the cast (0x14025bd53, 0x14025c0a9;
per-character table 0x1404c0240) and firing
along the facing at the release tick (FORMATS
“Vertical aim of a cast”)
Lock-on:
the status that forces a target, the non-default
options
Status: MISSING
Now: Slots 8 (untargetable)
and 9 (forced target, hit effect 40) are checked
in valid() (hitfx); slot 9 compares the
target’s player index, which is the side (team)
unless a combatant sets
player_index (INFERRED for more
than two players); the sorted switch style
(option 0x14052dfb8 ≠ 0) and lock mode 2 aren’t
implemented
Where:lock_on.gd valid(), tick()
Lead: FORMATS.md “Lock-on
and targeting”; the sort key at camera object +
0x90; the sorted style’s key is decoded
(docs 11-10): distance from the player
to each target (FORMATS “Play camera” tick step
9), sort direction not read
Locked
movement: sideways and back runs, turn onto the
camera at the character’s turn step
Status: MISSING
Now: While locked the body
snaps to face along the camera and plays its
forward run whatever the stick
(PdLockOn.strafe() has the decoded sectors)
Where:player.gd _face
Lead: 0x14025b6fc (run
start) / 0x14025ba2c (turn); the run animations
in the action table Turn step decoded (docs
11-09): 20° per tick for the playable cast
(FORMATS “Character table”)
How
a caster turns to its target at cast start
Status: PLACEHOLDER
(narrowed, melee 11-11)
Now: Snaps to face the
target; the melee kinds (set 0,
behaviours 3, 12, 13, 14) are decoded:
they turn by the character turn step during the
lunge wait, then by the record’s turn rate
(MeleeLunge)
Where:player.gd cast() /
_face(exact)
Lead: the cast-start code
at 0x140258180 onward for the other kinds
Camera shake
Status: MISSING
Now: None
Lead: decoded (docs
11-10): how it is applied (per-player
sideways / vertical amplitudes, largest wins,
±a/2 jitter of the look-at point each tick,
cleared after use) and the positional source’s
falloff and fade (FORMATS “Play camera”, Shake);
not decoded: who creates the sources and their
amplitudes, radius and pattern