Now: Fixed numbers;
KNOCKBACK only for records without reaction ids
(the others use the decoded reactions)
Where:data_skill.gd
COOLDOWN/RECOVERY/KNOCKBACK
Lead: cast code
Aura
card use doesn’t stop the player
Status: decoded
(auraglow)
Now: No recovery and no
cast state: the body keeps running (decoded H:
no cast state, no animation); the use plays cue
0x59 at the user and raises aura glow event 8
(the 30-tick flare) (auraglow build
11-14)
Lead: replace with data
skills as kinds get implemented
Skill
kinds still unplayed ((skills3b: erase and
special now played, levitate refused);
(skills3a: fast_rain and set 6 played);
(lobbed: parabola, fall, mine, burst, rain
now played, AreaKinds);
(autocrawl: auto, crawl, hole, hole_all,
moving, kinesis now played,
GroundKinds); envs:
environment now played)
Status: MISSING
Now: Not in the catalog.
Played: straight shots, (shotvar)
multishot (6) and ricochet (17), the close-range
kinds (melee, blade, pursuit; melee
11-11), (lobbed) parabola (1),
fall (2), mine (8), burst (9), rain (20)
(area_kinds.gd), (autocrawl
11-12) auto (4), crawl (5), hole (15),
hole_all (16), moving (10) and kinesis (11)
(ground_kinds.gd,
kinesis_shot.gd; refused there:
auto with 0x7C other than 0 / 2), defenses (set
2), status cards (set 4) and environments.
DataSkill.refusal() names why each
refused set-0 shot is refused: formula not
decoded, hold charge (0x46 = 2), a hit effect
not played, (skills3a) no cast profile
(the one 0-damage record without a ground
profile), does not move; (skills3a) the
card-field erasers, the 0-power hits and the
level costs are played
Where:data_skill.gd template_for,
refusal
Lead: decoded in FORMATS
“Skill kinds”; the kinesis cast side, the erase
set (field capsules) and the special set are in
“Skill casting leftovers”, whose coverage table
counts the records that are fully decoded per
kind (281 of 387). Set 6 has no handler: its 2
records must not be castable. Still open:
fast_rain’s motion (lobbed: refused
with its own reason, “fast rain (7): its
per-tick motion is not decoded”; the FORMATS
“Fast rain (7), partly” leads were not read
further) (step3 11-13) All 68 unplayed
records listed by reason
(tests/probe_unplayed.gd, FORMATS
“The last unplayed skill records”). Fast rain is
decoded (placement and drift as the holes, warn
mark, sight line, slot-2 column, swept segment
test). Set 6 is castable: it casts the
remembered attack (last released / last that
hit). The “no damage and no hit effect” refusal
is wrong: a 0-power hit still reacts, erases and
applies its effect (5 of its 6 records are
playable as they are) (skills3a 11-13)
Fast rain (7) played as decoded
(area_shot.gd mode “fast_rain”,
ground_kinds.gd): hole placement
and drift, the warn mark for 0x7C ticks, the
sight line from the column top on the first
strike tick (blocked: ends), the slot-2 column
scaled (R, H, R) × 0.1, the swept segment test
per strike tick; its card fields erase through
PdCardEraser. 21 records stay unplayed (probe 68
→ 21): sets 1 and 3 (erase / special set), deck
view 20, the aura record 0 (does not move) and
the one 0-damage record without a cast profile.
(merge skills3a + skills3b 11-14)
skills3b plays the erase and special sets
(InstantSets; levitate refused), so
of those 21 only deck view 20, the aura record 0
and the 0-damage record without a cast profile
stay unplayed, plus what
InstantSets.refusal refuses
Crawl floor push
Status: INFERRED
(autocrawl)
Now: One ray under the
sphere’s centre; the centre is moved out along
that face’s normal to one radius off it. The exe
pushes the sphere (radius at object +0x190) out
of every touched floor face (normal y >
0.643, attributes 16 / 18 / 20 / 31 skipped);
(r2, read) a face is touched when the
centre is in front of it at most one radius off
with its foot inside the triangle (0x140195f30),
else its edges are tested
Where:crawl_shot.gd floor_push
Lead: 0x140163cb0’s loop
over the contacts and the edge test after
0x140195f30
Hole drift
Status: INFERRED
(autocrawl)
Now: The spot drifts by the
target’s movement per tick at the cast (its real
velocity / tick rate). The exe takes target
+0x60 − target +0xa0; +0xa0 is read as the
previous position, not traced
Where:area_shot.gd place
Lead: the writer of
character +0xa0
Hole spot floor
probe
Status: INFERRED
(autocrawl r2)
Now: The hole / hole_all
spot is the nearest floor up to 200 m below the
target point (no floor: the spot stays at the
body point and the object loses its target). The
exe’s probe length is not read
Where:area_shot.gd FLOOR_PROBE_M
Lead: the floor query in
the hole init (not traced; the init is next to
the range clamp 0x140273d40)
Area
kinds: defense path and held block
Status: INFERRED
(autocrawl)
Now: The hole and moving
hit routines (0x14026c5b0, 0x14026c1c0) call the
defense check 0x14026dcb0; we run it on the path
from the character’s point to the spot / column
top padded by the area radius (as for melee),
and a holding block spares the holder while the
area goes on
Where:area_shot.gd _try
Lead: 0x14026dcb0’s
arguments in those two callers
Auto range test
(0x7C = 0)
Status: INFERRED
(autocrawl)
Now: With 0x7C = 0 the
object needs a target; the range test
0x140273c80 is not applied (no record the build
plays has 0x7C = 0)
Where:auto_attack.gd start
Lead: 0x140273c80
Kinesis hit
radius
Status: PLACEHOLDER
(autocrawl)
Now: The thrown object’s
hit sphere is the record’s own radius (5 u);
decoded: the object’s shape entry of type 2, its
float at +0x14 x 0.5 (centre offset +0x08)
Where:kinesis_shot.gd release
Lead: convert the stage
objects’ shape lists (type 2 entries)
Now: While it lifts, stage
geometry doesn’t end the shot (it starts resting
on the floor, inside its sphere); the throw
starts along the caster’s heading laid flat; the
turn has no cone; a broken object can’t be
picked. Not built: the branch that turns by a
fixed 5 deg instead (condition not
separated)
Lead: the lift’s hit test
and the 5 deg branch condition in the kinesis
update
Kinesis
grab: what stood on the object
Status: BUILT
(autocrawl; chain collapse 11-13)
Now: The taken object
leaves the stage (collision gone, model carried
by the shot, on the client too: SPAWN “kinesis”,
v17); since collapse round 3 take
also releases its dependants in the same call
(support chain, no impulse, on the host and on
the client’s take), tests
test_kinesis_chain.gd (host) and
net_collapse.gd (round 4: the
client’s take of st03 stand 37 brings down 10
and 11 in the take’s frame, the host’s chain);
the chain’s own open points are in row “Stage
object support links”
Now: A hole spot / moving
column whose record has no effect file is drawn
as a translucent disc / column in the shot
colour; the client ghost draws the same from the
SPAWN “area”
Where:area_shot.gd _ready,
ghost.gd
Lead: records with an
effect use slot 1, scaled as decoded
Damage formulas
Status: DECODED
(shotvar) / INFERRED (see rows
below)
Now: Every formula id in
the data is played: the card power (formula +
strength status + per-use step, minimum 0) is
computed once at the release and is each shot’s
damage and its strength against defenses;
(r2, after the melee merge) the
close-range cards (melee, blade, pursuit) take
the same card power for their hit. The
per-player used list (100 entries, cleared per
round), the aura paid per cast, record fields
0x10 (group), 0x2A (level cost) and 0x5C..0x60
are in skills.json
Lead: hold cards (0x46 = 2)
are refused, so the aura-paid hold term is not
played
Capsule
erasers (skill set 1)
Status: decoded
(skills3b 11-13)
Now: All 9 records play:
capsule target (first other-player capsule up
within 15 u of the point lowered 9 u), the 0x54
filter, take away / steal / reshuffle / turn
aura, slot 3 at each capsule; no HUD reticle
(the PC build has none)
Now: High jump (0), own
capsule / own start / other start teleports (2,
6, 7), bring a capsule (4), dash (8), jump (9)
play; the 2 levitate records (5) are
refused
Now: Played: the mine
stays, the button of its slot sets it off and
counts the use then, a new card filling the slot
removes it silently
(SkillMine.detonate_from,
remove_from_slot). INFERRED: the
press is taken before the skill-allowed check
and the recovery lock (a placed remote mine
always goes off on the press)
Lead: the press handling
around the slot-fill routine (0x140261a00) and
the mine end call 0x14026efa0: where in the cast
path the press is taken
Lobbed /
area release point (lobbed)
Status: INFERRED
Now: Parabola, fall, rain
and burst leave from the hand height 1.2 m, 0.6
m ahead along the facing, as our straight shots
(DataSkill._throw); the game uses
the body matrix of the cast
Where:area_kinds.gd release
Lead: the fire node of the
cast profile (as for straight shots)
Parabola
straight above its landing point
(lobbed)
Status: PLACEHOLDER
Now: Horizontal distance 0:
the game divides by zero (T = 0); we keep T at
0.001 ticks
Where:lobbed_shot.gd init_parabola
Lead: the float behaviour
of the init at d = 0 (only reachable with a
target right below)
CPU
sight line from a point on the stage
(lobbed)
Status: INFERRED
Now: The CPU’s stage-line
test (0x1401641b0, _segment_clear)
starts its ray 1 cm along the segment, so a mine
lying on the floor does not block its own line
(a Godot ray reports the face it starts on)
Where:cpu_input.gd_segment_clear
Lead: how 0x1401641b0
treats a segment starting on a face
Rain emitter
look (lobbed)
Status: PLACEHOLDER
Now: The effect’s slot 5 is
played once where the emitter starts; the game
keeps that instance on the emitter while it
follows the target
Where:rain_emitter.gd start
Lead: make the effect
instance follow its owner (PdEffect follow)
Rain drop
frame axes (lobbed)
Status: INFERRED
Now: The drop’s random yaw
/ pitch (engine angle units, positive pitch =
down) are turned into our forward / up axes with
the yaw about +Y from +Z; the drop offset is
along the frame’s up axis
Where:rain_emitter.gd _drop
Lead: the matrix build in
0x14026b8d0 (rotation order)
Rain
drop reach against characters (fixes
r2)
Status: INFERRED
Now: A drop meets
characters with a plain ray per tick
(LobbedShot._segment, the shot
mask): it reaches a body only within the body
capsule’s own radius (0.4 m) of the capsule
core, and ends on the first stage piece in its
path. FORMATS “Rain (20)” gives the drops a 5 u
radius, which this ray does not apply; the
autotest’s pass / miss sort follows the ray (the
dummy’s capsule read from its shape)
Lead: the drop update
0x14026bbd0: its hit test against characters
(sphere 5 u against the body point and radius
record + 0xb0, or a ray)
Lifetime
end flags 0x8030 (lobbed)
Status: INFERRED
Now: The rain emitter,
drops, parabola and fall end when their counter
reaches 0 (we take the flags 0x8030 that gate
the end as always set for these kinds)
Where:lobbed_shot.gd,
rain_emitter.gd
Lead: the writers of object
flags 0x8030
Fall reflect
(lobbed)
Status: INFERRED (M)
Now: A reflected fall
reruns its init from where it is, toward the new
target
Where:lobbed_shot.gd _reflect
Lead: the fall’s state-5
path in 0x140265470
Mine
/ rain ghost on the client
(lobbed)
Status: PLACEHOLDER
Now: A mine ghosts as the
flat trap disc (NetGhost.flat); the rain emitter
is not ghosted (its looks travel as effect
events, its drops as shots)
Where:net_session.gd _kind
Lead: — (the client draws
the record’s effect slots once ghosts carry
effects)
Defense
against explosions of other kinds
Status: DECODED
(lobbed)
Now: The explosions of
parabola, fall and rain shots (hit effect 5),
mines and bursts use the shared growing blast:
each character meets its defense on the path
from the blast centre
(respond("explosion")), a direct
hit of a lobbed shot meets it like any shot
(type 6 reflects parabola and fall, type 2
deflects)
Explode
on hit/block (hit effect 5) for data shots
Status: DECODED
(shotvar, r2: walls, lifetime end, look and
its scale formula; doc-answers: damage; fixes:
tick count, order)
Now: A data shot with hit
effect 5 turns into a blast where it hits a
character or a defense, and (straight and
multishot) where it meets stage geometry: radius
0x64 × 0.1 u, growing linearly over 30 ticks; it
reaches a character whose centre is within the
radius + 1 m (the character radius), with stage
line of sight, in player-list order, after the
defense check (a block takes the holder out of
the hit mask). Decoded in r2 (0x14026ca50 /
0x14026cd70): a ricochet never ends on a wall
(it bounces, so it never explodes there), and
the lifetime end (reason 0) skips the end
routine’s switch, so no shot explodes when its
lifetime runs out. Look: slot 2 of the shot’s
effect file with the shot’s matrix scaled by
0x64 × 0.02 (2 × the blast radius in metres; the
scale formula is DECODED, the size on screen is
a separate INFERRED row below), sent to the
client as an effect event. Decoded
(doc-answers, tick 0x14026ae10): every
character reached takes the full carried value,
no fall-off over the radius (as built).
(fixes) Built: tested on 31 ticks, r =
R × i / 30 for i = 0..30 (r = 0 on the first),
the characters by player index
(Projectile.blast_order:
PdHitEffect.player_index, i.e. the team where no
index is set); our own instant test burst
(blast.gd) has no fall-off
either
Now: Built: a blast started
on stage geometry (reason 1) clears its mask and
ignores the caster / team pass
(Projectile.blast_all), so the
caster and team-mates in reach are hit; one
started on a character keeps the shot’s mask
minus that character (as before). Decoded: blast
start 0x14026dbd0 sets all four player bits for
a stage start (H in code)
Where:projectile.gd _on_body,
_blast_tick
Lead: footage of a caster
caught by its own wall blast (M → H)
Explosion
look: size on screen
Status: DECODED (M,
doc-answers)
Now: The decoded scale
(0x64 × 0.1 × 0.2 on the shot’s matrix, 6 for
0x64 = 300) applied to the effect’s slot-2
meshes as we play them draws a ring 15–20 m
across for a 3 m blast. Followed
(doc-answers): the scaled matrix is
stored unchanged in the effect instance and the
hit-slot meshes use it; the lobbed effects’ core
sphere is authored so that the scale makes it
1.09 × the blast radius, and their larger
elements (and the full-size straight-shot
effect) come out 2–6 × the radius. No shrink
step found; the draw side was not re-read, hence
M
Lead: one footage frame of
the exploding straight shot / the exploding
ricochet (arsenal preview loops, pd-ref-library
INDEX) makes it H
Explosion
look without a linked effect (shotvar
r2)
Status: PLACEHOLDER
Now: A blast whose shot has
no effect file with a slot 2 (no own file and no
cast-profile effect) draws our translucent
sphere of the blast radius
(Effects.BURST). No played record
hits this today (16 has its own file, 341 its
profile’s)
Where:projectile.gd _start_blast
Lead: the record 0x20
effect (no profile) and the end routine’s slot
choice for such records
Shot
effect of a record without its own effect file
(shotvar r2)
Status: INFERRED
Now: A shot record whose
effect is not linked (skills.json:
no Effect/eft<text id>)
flies, ends and explodes with its ground cast
profile’s 0x04 effect (the effect the cast
spawns at its start, FORMATS “Cast animation
profiles”); e.g. 341 → eft0260. Where both exist
they agree for 298 of 301 records
Lead: the shot init’s write
of its flight effect handle (+0x30) vs the
cast’s effect instance (C + 0x13b20 /
0x13b24)
Shots
per cast (multishot, ricochet)
Status: INFERRED
(shotvar)
Now: One shot per fan step:
the pattern count (multishot 0x86, ricochet
0x88) when > 1, else 1
Where:data_skill.gd shots_per_cast
Lead: the game spawns one
object per numbered fire node of the cast effect
instance (0x14018a310); count those nodes in the
effect files
Multishot
flight: re-aim during the arc
Status: DECODED
(doc-answers, M; built fixes)
Now: Built
(Projectile.arc_step, host and net
ghost): during the arc ticks the shot turns by
the stored turn, then, with a live target within
2R, re-aims toward the tangent of the radius-R
arc that ends at the target’s current body point
(frame looking at it, rolled by the second
angle, turned by asin(d / 2R) to the first
angle’s side) by at most the homing rate (0x80 ×
0.1° × the homing percent); no cone; after the
arc it flies straight (no homing); a deflected
shot steers toward the opposite tangent at 5°
per tick during the arc. The arc length stays
the init’s (2 × trunc(b / ω) ticks), so a target
that moves far can still be missed (autotest
shotvar picks its sidesteps from the decoded
speed, homing rate and reach at the measured
cast distance: the smallest step the blind arc
misses but the re-aim reaches is hit, the
smallest step out of reach even with the full
re-aim is missed; at 13–17 m a 1.5 m sidestep is
still within reach)
Lead: FORMATS “Open
questions settled” 3; footage of a curving shot
at a moving target (M → H)
Multishot
init without the decoded branch
Status: MISSING
(shotvar)
Now: Only the branch read
is built (target point, or 200 u along the frame
when no target)
Where:data_skill.gd _spawn_shot
Lead: 0x1402666b0: the
other branch of the init
Hold
cards (0x46 = 2) and the aura-paid hold
term
Status: INFERRED
(skills3a: played; bof4 r2: pay order
decoded)
Now: Played: the count
rises by one per tick while the cast’s button is
held and the can-pay test 0x1402620e0 passes for
the next count, i.e. the still unpaid cast cost
plus that count’s extra (count / 10, status-30
scaled) fits in the aura. DECODED (bof4 r2,
0x1402626d0): nothing is paid during the hold;
the release sets the paid slot to cost + count /
10 (unscaled; formula 21 reads it), adds the
scaled extra to the cost, and the pay routine
0x1402621f0 takes cost + extra in one step.
Inferred: the loop starts at the ground
profile’s hold-loop start tick
(hold_loop[0]) inside the windup;
the animation does not loop its hold frames (it
plays on). No hold card in the data has a cost
(all 0), so the cost term only matters for
status 30 or a recalled card
Lead: the hold state on
cast state + 0x80 and where the cast animation
waits (profile 0x4E / 0x50)
Level costs
above 0 (0x2A > 0)
Status: DECODED
(skills3a: played)
Now: The can-pay test (aura
first, then level ≥ 0x2A;
DataSkill.cannot_pay) refuses the
cast, the payment takes 0x2A off the level
(_paid). The level is the aura cap,
so with the data’s costs the aura test always
refuses first
Now: A card replaced by a
pickup counts as used, like a spent one
Where:player.gd _card_leaves
Lead: the pickup path’s
slot release
Defense
add-ons erase_card / capture_card
Status: MISSING
Now: No effect
Where:projectile.gd apply_addon
Lead: decoded: add-on 3
erases the attacker’s card (0x140262fc0 on its
slot), 7 gives it to the defender
(0x140261a00)
Auto-shelter
pass list
Status: INFERRED
Now: A type-7 card in a
slot casts itself (aura and a use paid, no
animation; decoded guard test, including its
trigger rules: never for auto (4) attacks, for
piercing ones only when the attacker’s status
slot 31 is set) and blocks as a centred shelter
(type 1 rules)
Lead: the block check on
the new object (0x140271760) for type 7
Defense look
Status: PLACEHOLDER only
without converted data (effects1)
Now: Built: the defense
skill’s own effect: slot 0 at the cast, slot 4
looping on the holder while it is up (two
copies, the second half a length in), stop flag
+ slot 5 once at its end
(DefenseLook.start_loop /
end_loop); on a remote peer from
the defense event it already gets. The
see-through disc / shell is drawn only when the
skill has no converted effect with a slot 4
Where:defense_look.gd_placeholder
Lead: — (root of the loop:
row “Looping character effect root”)
Defense
reflect keeps the defense
Status: INFERRED
Now: A reflect leaves the
defense up
Where:projectile.gd _defended
Lead: the reflect path in
the defense check
Dummy keeps 5
aura
Status: PLACEHOLDER
Now: Practice convenience
for its shoot mode (playtester OK with the dummy
on the mode health)
Where:main.gd
Lead: none (sandbox
only)
Reactions
for hits without reaction ids
Status: PLACEHOLDER
Now: Tier placeholders
(PdRules FALLBACK, FLINCH_FALLBACK,
ANIM_FALLBACK) with the skill’s own push
Where:combatant.gd,
pd_rules.gd
Lead: only test skills and
beam/mine/strike lack ids; goes away with data
skills
Close-range
stage props (melee 11-11)
Status: MISSING
Now: Melee, blade and
pursuit do not hit breakable stage objects
Where:melee_attack.gd
Lead: decoded lead: melee
tests the props once (flag 0x400) at chest +
facing × 20 u (0x1401633b0), blade along its
segment once (FORMATS “Melee (13), blade (12)
and pursuit (3, 14)”)
Lunge wait
count (melee 11-11)
Status: INFERRED
Now: The lunge wait
(profile 0x52) counts down once per tick
Where:melee_lunge.gd tick
Lead: the game counts it
when the animation frame step passes (+0xd4 <
0 in 0x14025be40); at our animation speed that
is once per tick
Lunge move
skip (melee 11-11)
Status: MISSING
Now: The lunge always
moves
Where:melee_lunge.gd
Lead: 0x14024f9c0 skips the
move while 0x14024d4d0(C + 0x40, 4) is set:
which state sets it was not traced
Lunge
step near the target (melee 11-11)
Status: DECODED
(doc-answers: re-read, H in code) /
MISSING (end distance on main until
movecoll)
Now: Within one step of the
11 u stop the move is speed − (d − 11),
confirmed. The game’s end distance is then set
by the body push: 1.0–1.1 m centre to centre.
Main ends at 0.8 m (its 0.4 m capsules); branch
movecoll has the decoded push (1.0 m),
(fixes) the melee autotest’s floor is
now 1.0 m (the decoded end distance): it fails
on a head without movecoll’s push; the air-cast
check now measures the closest approach (the
hit’s knockback moves the dummy after it)
Where:melee_lunge.gd tick
Lead: FORMATS “Open
questions settled” 4
Gravity
during the lunge (melee 11-11)
Status: PLACEHOLDER
Now: The caster hangs in
the air during the cast (as every cast:
_recover_left)
Where:player.gd simulate
Lead: the lunge state
handler 0x14025be40 onward: the vertical move
was not followed
A
close-range cast cut by a hit (melee 11-11,
r2 11-12)
Status: INFERRED
Now: A caster that started
a reaction (or the pit return) at any time
between the cast start and the release spawns no
hit object, even when the reaction is already
over at the release (the reaction replaces the
cast state); its lunge stops on the reaction’s
first tick
Lead: the action-state
switch on a hit; not traced for this case
Close-range
attack point without a skeleton (melee r2
11-12)
Status: PLACEHOLDER
Now: A caster without a
hand bone (the test dummies only; every playable
character has one) attacks from 0.6 m ahead of
its chest
Where:melee_attack.gd FALLBACK_AHEAD
Lead: none needed for play:
the game’s characters all have the hand joint;
keep it ours
Close-range
hit lift (melee r2 11-12)
Status: PLACEHOLDER
Now: A close-range hit
without reaction ids pushes up by 1.5 m/s
(Projectile’s value); all 50 close-range records
have reaction ids, so in play the decoded
reaction moves the body and this lift is
unused
Where:melee_attack.gd HIT_LIFT
Lead: ours, as the shots’
push of id-less hits (PLACEHOLDERS “Reactions
for hits without reaction ids”)
Client
prediction of its own lunge (melee
11-11)
Status: PLACEHOLDER
Now: The client does not
predict its own body’s lunge; the host’s
snapshots move it (seen a round trip late)
Where:player.gd,
net_session.gd
Lead: ours (netcode): carry
the lunge in the motion state, a wire
change
Pursuit
use condition (melee 11-11)
Status: MISSING
Now: Pursuit cards hit any
target in reach
Where:melee_attack.gd
Lead: the records’ use
condition (FORMATS “Skill casting leftovers”,
use condition) is not applied to the close-range
cards
Client
prediction of push
Status: PLACEHOLDER
Now: Client predicts its
own push with the old stagger time; the host
runs the decoded reaction timers
Where:net_session.gd
Lead: sync the
reaction/down timers or predict them from the
decoded actions
KO grace
reference tick
Status: INFERRED
Now: A knocked-out player
keeps the team standing for 60 ticks counted
from now (decoded end check, FORMATS “Match
flow”); the game counts from the smallest of the
players’ tick values (status record +0x24),
whose writer was not traced
Where:match.gd KO_GRACE
Lead: the writer of status
record +0x24 (SYSTEMS.md §2)
Rounds and
custom rules
Status: MISSING
Now: One round per match.
The rematch (results, A) runs the decoded retry
phases 7 → 8 → 4 → 5 → 6; at ROUND_WAIT’s end it
redoes our match-start setup (decks dealt again
from their pre-shuffle order, empty slots, field
capsules, shots and mines gone, full health,
aura level back to the mode’s start), not the
game’s own battle-setup routine (not
traced)
Where:match.gd, main.gd
Lead: custom settings
0x1404bbed0, rounds left 0x1404bc9b0 (SYSTEMS.md
§2)
Load,
sync and intro phases (1–3), start effects
Status: MISSING
Now: The match starts in
battle once the scene has loaded (the decoded
first round has no ready phase); the two start
effects are not spawned
Where:match.gd, main.gd
Lead: intro object
0x14052ad98 waited on by 0x14012ab20, intro
event 0x1401ae8e0; the ids 0x2BC/0x2BD are
effect files 700/701, not sound cues (docs
11-10 audio)
Result display
Status: PLACEHOLDER
Now: The game’s
win/lose/draw logo sprite in END and RESULTS
(pd_hud.gd, row “HUD result logo
position”); HUD note “You win / You lose”, or
“Time up: draw” when the clock ran out with two
or more teams standing (result() picks a team
whenever none is standing, so there is no “no
one left” case), plus “A: again, Start: leave”;
the fighters stop during RESULTS (phase 9,
decoded)
Where:main.gd, match.gd
result_text, pd_hud.gd
Lead: Decoded (docs
11-10): battleend picks the
scene from the game kind and the result code (1
/ 3 win, 2 / 4 / 5 loss, 6 draw), shows two
banner sprites (a glow streak at centre (127,
150), the logo fading in over 85 ticks at centre
(513, 150), menu cue 37), then the results list
(FORMATS “Match-flow screens”). Left:
implementation; the loss / draw sprite pairs
(read with ssbdump.py)
Battle clock
display
Status: PLACEHOLDER
Now: The time left in
BATTLE as mm:ss (format from SYSTEMS.md §battle
HUD), whole seconds rounded up (INFERRED), plain
outlined text at the top center on the debug
HUD; the game HUD draws the decoded clock icon
(sprite 87 at (−37, 428), tint 0xfff54322) with
this text at x + 0x12 (row “HUD text font”);
hidden without a time limit and outside
BATTLE
Lead: Decoded (docs
11-10): seconds are truncated (clock / 30),
not rounded up; in the last minute the colour
pulses from black to the tint (FORMATS “HUD
status icons and clock”); the pulse counter’s
step is not traced
Match
start sequence (intro, ready, countdown)
Status: INFERRED
(menus)
Now: In a session through
the game’s menus: after the loading screen the
ready phase’s countdown runs (row “Countdown
cues and sprites”) while the world keeps ticking
like the game’s: the match holds in phase READY
(5) with its clock stopped, every combatant’s
input is off (an idle input source until tick
90; INFERRED: how the game gates input in phase
5 is not decoded), the bodies settle and the
battle camera follows the player; at tick 90 the
battle (6) starts. (fixes) No no-damage
timer at the match start any more
(Combatant.apply_mode and the
rematch’s new_round set 0): the
timer’s only writers in the executable are the
respawn (0x140251f80, called only at 0x140261e6f
in the message-18 routine 0x140261de0 and at
0x14027ce33 in a net message receiver), the pit
return (0x140251d80), the get-up (0x14025c447)
and net message 19 (0x14027ce84), none on the
battle-start path (M: the initial value is the
character’s zeroed set-up, not followed); the
Rebirth PC footage of 11-13 (private countdown
clip, every 30 fps frame) shows no blink during
“3, 2, 1”. So the body is drawn on every
countdown frame (test_menus). The intro (camera
fly-in) is still missing, and so is the whole
sequence for the debug / chooser / net starts,
which start at once
Where:scripts/menu/menu_flow.gd_ready_phase
Lead: phase machine values
0–4 (SYSTEMS.md §2); the intro phase; the input
gate of phase 5; the character set-up’s initial
timer value (zeroed allocation, not
followed)
Deck RNG seeding
Status: INFERRED
Now: Decoded shuffle and
draw (FORMATS “Capsules”, deck) with the UCRT
rand() generator, seeded with the host’s match
seed (Match.deck_rand), used only
for the deck shuffles
Where:pd_rand.gd,
match.gd
Lead: the generator is the
system UCRT’s (not in the package; read from its
import); the game seeds once at boot from the
clock and shares the stream with effects, so its
own sequences can’t be reproduced
Status
slots without an effect in Godot
Status: MISSING
Now: Slots are kept and
synced; played: strength, speed, homing, regen,
bound, skills locked, press damage, no lock-on,
forced target (9), pickups locked (12), button
locks (13..16), health per cast / capsule (17 /
18), pierce-all, damage / type / cost / school
bans (21..28, 38..45 through the one
skill-allowed check), hit immunity, inverted,
capsule delay; 8 / 11 / 12 cleared on every hit
taken and at a KO (hitfx). Not played:
levitate, health per aura particle (19, amount
not separated), no regen while moving (29), cost
scale (30), no bonuses (31, only its pierce
part), single use (32), the scramble’s button
redraw (36)
Where:pd_status.gd,
player.gd
Lead: FORMATS “Status
slots, hit effects and environments in full”; 7,
10, 46 are unused
Press damage
amount
Status: INFERRED
Now: Slots 6 and 17 each
cost 1 health when a cast goes off; slots 6 and
18 each 1 at a capsule pickup
(hitfx)
Where:player.gd cast, use_slot
Lead: decoded (docs
11-10): the amounts and the cast / pickup
sites (0x140262819, 0x14026288c, 0x140251b9b,
0x140251bca); our reading: the cast cost is
taken only for a cast that goes off (whether a
refused press also pays is not read). The small
reactions 0x28 / 0x29 (0x140258fb0) are not
played
Health
equalise on a KO’d side
Status: INFERRED
Now: Hit effect 46 does
nothing when either side is already out (this
hit’s damage KO’d the target); otherwise each
side’s new health goes through the normal health
loss / heal, so a drop to 0 is a KO (hitfx
review 2)
Where:pd_hit_effect.gd
health_equalise
Lead: read the equalise
case of the hit-effect switch: whether it writes
health through the health routine (0x14024d7a0)
and whether it checks the KO state first
Now: Effects 9, 16, 20, 23
(aura scale, give cards, deck view, team chat)
do nothing; a card with only those has no
template. Played: 17 sets status slot 37; 19
takes the newest used card back into the card’s
button and the 19 card skips the used pile; 21
puts value random used cards back
into the undrawn deck at random places (shared
generator, draw pointer − 1 each); 22 moves
every aura card of the undrawn deck in front of
the draw pointer (skipped); 11 / 15 the stances
(row “Stances”)
Where:data_skill.gd STATUS_PLAYED,
deck_effect
Lead: decoded (docs
11-10): 9 aura scale, 16 give cards, 23
invert; cue ids per effect (not played for
17–22). INFERRED (skills3a): effect
21’s two draws per card in the order used card,
then deck place (the pointer order of the
routine not followed)
Status on
death / respawn
Status: INFERRED
Now: A knocked-out
combatant’s reset() clears its status slots and
defenses
Where:combatant.gd reset
Lead: the respawn routine
(0x24e000 area)
Environments (set
5)
Status: INFERRED
(envs)
Now: Built as decoded: one
entry per player, a cast while one is active
stores nothing (card spent), the oldest active
one counts, its slot reads + value for everyone
(PdStatus.value), ends by 0x5A /
hit effects 38, 39 / capture / owner gone (start
+ 60) / a later live entry ended at once (net
rule 5, host-side), cues 0x5d / 0x5e / 0x58 /
0x57 (common bank); host decides, the client
mirrors (Ev.ENV, net v13). Inferred: “owner gone
or inactive” read as the owner’s node freed or
knocked out; the capture guard falls back to 450
(PLACEHOLDER, the decoded value of every record)
when skills.json lacks
capture_guard_ticks. Not built: the
forced environment (mode 5 field 0x1A,
0x1404bbed8) and match kind 5’s no-environment
rule (no such mode here); the draw countdown
restart (row “Draw countdown”)
Where:pd_environment.gd,
match.gd,
data_skill.gd
Lead: what “inactive” tests
on the owner in 0x14017b880
Hit
effects beyond status slots
Status: MISSING (hitfx:
narrowed)
Now: All 52 ids are one
table (converter HIT_EFFECTS, godot
PdHitEffect.ROWS) and applied after
the damage of a shot: aura / level changes,
steals, slot writes, button lock, forced target,
reset, invert, equalise, lowest level, capsule
counts, card copy. Not played: 18 (no handler in
the switch); (skills3a) 42 is played as
nothing (inert: no reader), 45 as the teleport
to the attacker’s start, 41’s button redraw (row
“Skill button scramble”); the cues 0x59..0x62
(row “Status cues …”). Steals are host-side (our
protocol syncs health / aura / level), not the
game’s 4-byte steal message
Where:pd_hit_effect.gd,
projectile.gd
Lead: effect 18’s handler;
the field 42 writes (step3) 45 =
teleport to the attacker’s start position
(decoded); 42 writes a field nothing reads
(inert in this build)
Skill
button scramble (slot 36, hit effect 41)
Status: MISSING
(hitfx)
Now: The slot is set and
synced; the buttons are not re-mapped
Where:pd_hit_effect.gd
Lead: the redraw with two
rand() values at 0x1402568a0 and its readers
0x140256920, 0x14025c7dd (mapping not
followed)
Environment
capture (pickup kind 3)
Status: MISSING (envs,
fixes: narrowed)
Now: Built: within 15 u of
the active one’s cast point after its 0x56
ticks, when no capsule is in reach, any player
(the owner too: the decoded search has no owner
test) ends it with a skill-button press; slots
5, 12, 13 + button refuse it; cue 0x58. Decoded
(doc-answers, H in code): the pressed
button then holds an aura card (slot fill with
card id 0, replacing its card), and the owner’s
own capture is an explicit branch.
(fixes) Built: the pressed button then
holds an AuraCard (its old card
leaves as at a capsule pickup: INFERRED, row
“Replaced card counts as left”; its mine goes).
Missing: the capture flash; the pickup’s health
costs (slots 6 / 18) are not taken for it (their
sites were read for the capsule pickup
only)
Where:player.gd use_slot,
pd_environment.gd
Lead: FORMATS “Open
questions settled” 6; the flash effect id
(0x14022e7d0)
Replaced
card counts as left
Status: INFERRED
(fixes: listed; the code comment predates
it)
Now: A capsule pickup or an
environment capture that replaces a button’s
card adds that card to the used list
(Player._card_leaves, which also
lets a winding card finish first). Decoded only
that the slot fill 0x140261a00 replaces the
card; whether it records the old one as used is
our reading
Where:player.gd use_slot,
_card_leaves
Lead: the slot fill
0x140261a00 and the card-set routine 0x140262670
(used-list writes)
Environment
visual object (guard countdown, the erase /
capture flash)
Status: MISSING
(envs)
Now: Nothing drawn for an
active environment; only its cast effect (the
skill’s own effect file) and its cues
Lead: the visual object in
the environment list (+8, 0x14017b770: start +
0x56 − now as a countdown); the flash of
0x14017ba00 / 0x14017be00
Used
pile (spent cards in order)
Status: DECODED, played
(step2 / skills3a)
Now:Combatant.used_cards (card_left on
release, the eraser’s slot clear); effects 19
and 21 read it
Status
cues, character effects and HUD status
icons
Status: MISSING (docs
11-10)
Now: Character effects
built (effects1): effect 518 / 519 /
521 slot 4 loops while slot 8 / 11 / 33 is on,
slot 5 at its end (status_look.gd;
remote bodies from the synced status list). Cues
and icons not played / not drawn (envs:
the environment cues 0x57 / 0x58 / 0x5d / 0x5e
are played)
Where:pd_sound.gd,
pd_hud.gd,
status_look.gd
Lead: decoded ids: cues
0x57..0x62 and 2, character effects 518 / 519 /
521 for slots 8 / 11 / 33, HUD sprite tables
0x1402f1200 / 0x1402f1298, the 16-tick button
flash (its draw side not followed). HUD icon row
fully decoded (docs 11-10): 25 px
pitch, tint 0xff854322, first sprite of a pair =
raised, each stat icon swaps once a second with
its signed number on plate 39 (FORMATS “HUD
status icons and clock”). Character effects
(docs 11-12 effects): slot 4 kept alive
on the character while the status is on, stop
flag + slot 5 once at its end
Teams,
2v2 and 4-player matches
Status: MISSING
Now: 1v1 only
Where:main.gd,
net/net_session.gd
Lead: decoded (docs
11-10 rules): game type 0 / 1 / 2
(free-for-all 4, team battle, 1v1), team = side
byte or slot index, game mode 4 / 5, friendly
fire on, host-dealt start codes (FORMATS “Versus
options, stage list, teams and start spots”);
open: the lobby’s side choice, respawn rules;
the original net model for 4 peers (mesh,
per-victim hits, tally message) is in FORMATS
“The original network protocol”
Versus start
spots
Status: INFERRED
Now: A fixed preferred CP00
set per stage, not the random set 5 or 6 with
shuffled slots
Where: converter start
export, main.gd
Lead: decoded (docs
11-10 rules): online versus uses CP00 set 5
or 6 (header 0xB8 / 0xBC) at random and shuffles
the four records among the slots, host-decided
(0x1401907a0, 0x1401d1da0); not implemented
Stage variant
per match
Status: INFERRED
Now: Not drawn at random by
the host as the game does
Where:main.gd
stage chooser
Lead: decoded (docs
11-10 rules): the host draws it uniformly
below the stage’s variant count from
stageset.dat (0x140213c00); 17
selectable versus stages;
stageset.py still writes the count
as kind
Versus game rules
0..11
Status: MISSING
Now: One rule (plus
--heavy)
Where:main.gd
Lead: decoded (docs
11-10 rules): rule = mode row + arsenal
requirement (one school, no duplicates, low /
high cost, pre-made decks, staked card); open:
rules 3, 5, 10, 11 beyond their mode row
Compatibility
with the original game’s netplay
Status: MISSING (docs
11-10)
Now: Ours is
host-authoritative (inputs, snapshots, seed);
the game is a peer-to-peer mesh where each
victim decides its hits. No shared packet, rate
or authority
Where:net/net_session.gd,
NETPLAY.md
Lead: battle side decoded
(26 messages, packet, reliability, clock stall);
(netcompat 11-12) mesh layer, wrapper,
header and lobby messages 0..10 / 21 decoded
(M), Rebirth’s EOS lobby and P2P mapping
described (converter/NETCOMPAT.md,
with the build task list); needs a second,
peer-authoritative net mode; (netcompat2
11-12) session control (join / reply /
member introduction / leave / keep-alive /
ping), card trade flow and the skill object net
classes decoded (M); nothing capture-verified
(checklist in NETCOMPAT.md section 7);
(netmsg 11-14)layers 2 to 6
verified on two live captures (every
datagram parses with
converter/netmsg.py; FORMATS
“Versus network messages”: corrections, start
burst, event timeline, what a peer must send);
the codec can be built from that table now; the
join / hello on the wire and the bridge side are
still unverified
Wire
codec of the original protocol (mesh header,
wrapper, game header, 26 messages,
acknowledges)
Status: DECODED
(netreplay 11-14)
Now: Built:
net/pd_wire.gd (PdWire) from
converter/netmsg.py’s tables;
round-trips every datagram of both private
recordings (41 614) and the made-up test packets
(tests/test_pd_wire.gd). Unused
bytes that are non-zero in the recordings (fire
0x08, object end 0x04 / 0x53, capsule 0x0B,
environment capture 0x0A) are kept verbatim,
their meaning not decoded
Where:net/pd_wire.gd,
net/pd_pcap.gd
Lead: the non-zero unused
bytes by meaning (row “Wire: non-zero unused
bytes”)
Start
burst and start hold of the original battle
(tick 0: capsules, stat slots × 3, ready
message; start when every ready is in)
Status: INFERRED
(netreplay 11-14)
Now: Sent by
PdCompatLocal as recorded: packet 0
= message 1 + the first status slot (no message
0), slots 0..3 three times round, the 3 dealt
capsules from packet 1, message 22 from packet
2. The hold is a fixed 52 packets at tick 0
(HOLD_PACKETS; recorded 51..54, 3.3..3.5 s), not
“until every present player’s 22 is in”. Our own
host-authoritative net mode is unchanged
Where:net/pd_compat_local.gd
Lead: the start condition:
wait for the peer’s 22 (needs a live peer)
Now:PdWirePeer.game_ack_quirk: every
acknowledge in a received packet is compared
against the first one’s sequence, so only equal
ones free their message; the rest are resent.
Reproduces every recorded resend (47 + 44) and
no extra one
Where:net/pd_wire_peer.gd
Lead: the game’s
acknowledge reader (FORMATS “Reliability and
timing”): confirm on the exe on the data
machine
Wire
reliability: pending list of 20 (netreplay
11-14)
Status: INFERRED
Now: Only sequences 0..19
of a type are kept for resending; later ones go
out once (PENDING_SLOTS)
Where:net/pd_wire_peer.gd
Lead: the pending list’s
size and index in the net manager
Now: A received reliable
message is acknowledged in our first packet
built at least one tick after it arrived (the
recordings’ 8 off-by-one acks of second Deck
battle 0 come from arrival timing)
Lead: the receive / send
order in the game’s net tick
Wire:
reliable messages that never reached the wire
(netreplay 11-14)
Status: MISSING
Now: The first Deck
recording’s battle 1 starts with sequences 8#0,
14#0, 14#1 missing; the peer test reproduces it
only by assuming two packets built and not sent
(unsent builds). Cause unknown (a
send failure, a bridge drop, a packet built
before the socket was ready)
Where:tests/test_pd_wire_peer.gd
Lead: a recording with a
lossy second battle, or the bridge’s send
path
Wire
local sender fields (netreplay
11-14)
Status: MISSING /
INFERRED
Now:PdCompatLocal fills what has no
decoded source as follows. Message 0 action /
frame 0 (MISSING: our animation state → the
game’s action ids); status mask = slots 4..46
with a value (bits 0..3, 47+ MISSING); draw_out
0. Message 8 at tick 0: tick 0 (MISSING: the
recordings hold a large stamp there). Message 2:
act_state 12 for every cast (INFERRED: all
recorded casts had 12). Message 3: the 4 × 4
spawn transform is the body’s own axes and
position (INFERRED: not the shot’s spawn point),
cast profile = the skill id for a skill
(INFERRED), 343 for an aura card (recorded),
0x52 = 100 and uses 0 (recorded, meaning
MISSING), 0x5A 0 (MISSING). Message 22: 1 from
player 0, 3 from player 1 (recorded, meaning
MISSING)
Where:net/pd_compat_local.gd
Lead: message 0 action ids
(FORMATS “Remote characters”); the cast
profile’s spawn offset; message 22’s first
value
Wire
local sender: events not sent (netreplay
11-14)
Status: MISSING
Now: Our own hits (5 / 20 /
24, 15 with health changes), erase and capture
requests (11 / 13 / 17), environments (9 / 10),
knockout (23), lead (header 0x10, every 30
packets), keep-alives / lobby / join: not sent.
The sender has no transport (shape test
only)
Where:net/pd_compat_local.gd
Lead: decoded in FORMATS
“Versus network messages”; needs the victim-side
hit logic and a transport (Rebirth’s bridge is
not in scope)
Wire
messages and lobby types not exercised
(netreplay 11-14)
Status: MISSING
Now: Battle messages 4, 12,
13, 16, 17, 18, 21, 25 and lobby types 5, 6, 9,
11..21 have codec layouts from the exe docs
only; no recording holds one. Join / join reply
/ intro bodies (wrapper 2 / 3 / 5) and the
hello’s name text are not in the recordings
either
Where:net/pd_wire.gd
Lead: a recording of a 2v2
/ capture / warp match and of a join
Wire:
non-zero unused bytes (netreplay
11-14)
Status: MISSING
Now: Kept verbatim by the
codec; meaning not decoded: fire 0x08 (95
messages), object end 0x04 (20) and 0x53 (26),
capsule 0x0B (14), environment capture 0x0A (1).
Our sender writes 0 there
Where:net/pd_wire.gd
Lead: the senders that fill
those structs in the exe
Remote
player playback from the original stream
(netreplay 11-14)
Status: INFERRED
Now:PdCompatRemote (replay harness
only): position / facing blended as FORMATS
“Remote characters” (16 samples, playback tick +
1 clamped, linear / short-way, no
extrapolation); facing 32768 units per turn
(median 1.6° off the walk direction in the
recordings); shot ghosts flown from the fire
transform with the record’s straight-shot speeds
(no curve kinds); action / frame not played (row
“Reaction animations on netplay clients”)
Victim-side
end of a shot (message 5 from the victim, reason
2 with the hit)
Status: MISSING (netmsg
11-14)
Now: Ours: the host ends
shots
Where:net/net_session.gd
Lead: seen in the capture
(H that it is sent; reasons 0, 1, 3 not named):
the compatible mode must send it with its hit
log and damage effect
Lobby
exchange as in the game (player info,
completeness, team change, start table)
Status: MISSING
(netcompat 11-12)
Now: Ours: our own lobby;
the host sends its settings and a seed
Where:net/net_session.gd
Lead: decoded (M): one
unreliable lobby packet per member every 3rd
frame, repeated until complete (FORMATS
“Session, mesh and lobby layers”); host-only
stage / variant / type / rule in the player
info; no deck or seed travels
Net
rematch (netrematch 11-15)
Status: INFERRED /
PLACEHOLDER
Now: Decoded (M): only the
host starts the next online match, from the
lobby, once every member is there with its info
complete for more than 20 lobby counts; the
client waits, can change character / arsenal or
leave; the start re-runs the full battle start.
Ours: no lobby screen; on the results the
client’s A = its step into the lobby
(REMATCH_READY; INFERRED: the game’s
all-complete check may also pass while a client
still sits on its result screens, not traced),
the host’s A starts once player 2 has been ready
for REMATCH_HOLD = 20 of our 30 Hz
ticks (INFERRED: the lobby script’s count rate
is not measured), then the local retry phases
and our round setup on both peers (row “Rounds
and custom rules”). PLACEHOLDER: the note texts
(“A: play again”, “waiting for the host”, …) are
ours. MISSING: character / arsenal / stage
change between matches, the host’s new start
order and stage variant, the lobby screen
itself
Lead: the lobby script’s
frame rate (counter 0x1405277c0’s caller);
whether battleend’s online scenes block the
lobby start; the lobby menus (FORMATS “Net
rematch”)
Start
order drawn by the host
Status: INFERRED
(netcompat 11-12)
Now: Start spots are
assigned by our own rule
Where:main.gd
Lead: decoded (M): the host
draws a random permutation of the four slots
(100 swaps, C library generator) and sends it in
the start table (lobby type 2); how the order
maps to the stage’s start set is in the rules
section
Mesh
keep-alive and hello of the original
transport
Status: MISSING
(netcompat 11-12)
Now: Not present (Godot’s
own transport)
Lead: decoded (M): 7-byte
message header, hello until answered and
heartbeat every 2048 ms, acknowledge on request;
only needed by the compatible net mode
Session
control messages of the original (join, member
list, leave)
Lead: decoded (M; FORMATS
“Session control, mesh leftovers, lobby values
and card trade”): type 2 join request, 3 reply
with the member id or refusal 5 / 6, 5 member
introductions from the host, 6 leave, 4
keep-alive after 15 silent ticks, 10 ping echo,
drop after 150 silent ticks, sender’s member id
in every wrapper; only needed by the compatible
net mode
Host leaving a
session
Status: MISSING
(netcompat2 11-12)
Now: Ours ends the match
when the host goes
Where:net/net_session.gd
Lead: decoded (M): the
game’s session layer has no host migration
(member 0 is the host for the session’s life);
the compatible mode must treat the session as
over; what the lobby script and the platform
handler do then is L
Skill
object net class (whose word ends a shot)
Status: MISSING
(netcompat2 11-12)
Now: Ours: the host decides
every end
Lead: decoded (M): class
1..5 by skill kind and owner, flags 0x1000
announce / 0x2000 wait for owner / 0x4000 take
anyone’s word (FORMATS, same section); needed
with NETCOMPAT task 2
Looping
character effects carried in the position
message (fields 0x1C / 0x1E)
Status: MISSING
(netcompat2 11-12)
Now: Not present
Lead: decoded (M): two
looping character effect ids (two instances /
one instance), started and stopped on remote
bodies when the sample’s id changes. (docs
11-12 effects): they are effect slots 4
(two copies, looped) and 5 (the end) of the
skill in use, started by 0x140259540 /
0x1402598d0
Card trade
Status: MISSING
(netcompat2 11-12)
Now: Not present (out of
scope)
Lead: decoded (M flow): own
session game type 11; a compatible peer never
joins one and ignores lobby types 11..20
Draw
countdown (no-contest timer that cuts the
clock)
Status: MISSING (docs
11-10)
Now: Not present
Where:main.gd
Lead: decoded (M): 3600
ticks, restarted by capsule takes, health
changes, environment events and hit effects; at
0 the clock is cut to 1800 if larger
(0x14012a6c0, 0x1404bc94c); start condition not
followed
Player
capture and revive (knocked-out player into a
button)
Status: MISSING (docs
11-10)
Now: Not present (1v1 has
no use for it)
Lead: net side decoded (M):
request to the captured player, first wins,
answer, revive on use (messages 16..18,
0x1402503f0, 0x140261cb0, 0x140251f80); the
pickup side not followed
Knockout
tally and hit log line
Status: MISSING (docs
11-10)
Now: No per-attacker tally,
no HUD hit log
Where:pd_hud.gd
Lead:
tally[attacker][victim] 0x1404bc970 kept by the
victim; hit log {skill, damage, attacker}
0x140157b80 (draw side not followed)
Lag
handling as in the game (stall when ahead, wait
for a peer 60 ticks behind)
Status: MISSING (docs
11-10)
Now: Ours: the host never
waits; the client interpolates snapshots
Where:net/net_session.gd
Lead: decoded (M): lead
report every 2 s, ahead / 4 against 4 / 8 / 16 /
32 ticks; ours by design unless a compatible
mode is built; (netmsg 11-14) the lead
word is in every packet (momentary value), the
receiver reads it only at tick / 2 mod 30 = 15;
no stall occurred in the captured match
Stage
gimmicks and throwables (jump pads,
falling/rolling objects, doors, kinesis)
Status: MISSING
Now: None
Lead: stage object classes
and .dat object chunks (SYSTEMS.md
§11, §14); (docs 11-10) what the
kinesis cast asks of an object: the “can be
thrown” method (vtable +0x98) and the grab
method (+0x90, returns matrix, a damage byte and
the shape list), FORMATS “Kinesis (11), cast
side”; (docs 11-10 stageobj2) decoded,
not built: jump pads, throwables (object side),
support links, timed falling platforms, floating
props, hazards per arena: FORMATS “Stage
objects: other families”; rows below
Pit floor
attribute
Status: INFERRED (st03) /
MISSING (other stages)
Now: The game also sends a
body back when its ground attribute is 0x11; the
decoded collision has per-mesh attributes now
(pd_attr on each body), but no st03
mesh has 0x11. On st03 only (PIT_FLOOR_STAGES,
PLACEHOLDER list), standing within
PIT_FLOOR_MARGIN (5 cm) of the kill height
counts as that floor (its model 0 plane at
height 0 lies under the pit). Every other stage
has only the decoded kill height until the
attribute is decoded
Lead: st03’s height-0 plane
is not in the decoded collision set (no mesh
lies at height 0), so with collision.json a body
falls through it to the decoded kill height and
this stand-in no longer triggers; drop it once
all stages run on collision.json. Other stages:
the ground attribute’s source (ground probe
0x140163b50, +0x12EC0, SYSTEMS.md §14)
Decoded 11-10: the ground
attribute is the attribute of the collision mesh
the floor pick grounds on, and attribute 0x11 is
in none of the 21 stage files (arena and object
lists): only the kill height sends a body back.
Rebuild: remove the PIT_FLOOR stand-in once st03
runs on collision.json; no
attribute rule is needed for this build’s
stages
Surface
sound by ground attribute
Status: MISSING (docs
11-10)
Now: The game plays a
positional sound picked by the ground attribute
(attributes 2–15, 21–30, 32 → sounds 61–69,
141–150; none on 1, 16–20, 31)
Lead: table decoded
(FORMATS “Collision attributes, groups and
casts”); the trigger (one use site 0x14025a1ba
in the reaction/landing code) not followed
Round arena
limit (stages x1)
Status: MISSING (docs
11-10)
Now: On stages whose number
ends in 1 the body is kept inside a circle of
radius 150 u minus its width around the stage
origin
Lead: decoded (0x1402559f0,
M); needed when st01/st11/st21 run on the
decoded response
Sight-line
blocking by attribute
Status: INFERRED (players
part)
Now: The camera probe and
the bots’ line-of-sight rays use the decoded
sight mask (blocked by every attribute but 16)
(collattr); lock-on has no sight test
(as decoded, lock_on.gd). The sight
cast’s second step over the players (two bit
masks) is not built
Lead: 0x1401641b0 player
loop, not read in full (M); which callers are
the camera’s is not mapped 11-12
(doc-body): the sight pair’s end points
are the two body points (torso root node),
FORMATS “Body point, sight point and aim
point”
Blocking-wall
flag
Status: MISSING (docs
11-10)
Now: The wall passes record
the most head-on wall of the tick (normal · move
direction < −0.643) and set a character flag
(+0x12E8C)
Lead: readers not followed
(lead: run-into-wall behaviour)
Pit return point
Status: INFERRED
Now: The decoded point is
the own slot’s start record placed on the
ground; we use the player’s
spawn_point (that start snapped to
the floor, + 0.1 m; main swaps in another start
when the first is blocked, tests may move
it)
Where:player.gd fall_back(),
main.gd
Lead: the placement routine
0x1401646d0
Reaction
state after the pit
Status: INFERRED
Now: Decoded: the pit
return 0x140251d80 calls the reaction state
setter 0x140259d10 (state at reaction object +
4, the switch at 0x140256f53) with state 0 and
the idle animation when health is left, else
state 0x12 (down) with lying pose 60. It applies
the −3 itself first (the health routine
0x14024d7a0 on character + 0x40, at
0x140251e17), then tests character + 0x4c.
Inferred: + 0x4c is that object’s health (+
0xc); the pit’s down state runs our DOWN_TIME
(30 ticks) and goes to the dead state like a
knockdown’s; our separate carry
(the throw’s slide) is zeroed with it
Where:combatant.gd fall() /
_pit_state()
Lead: the health object’s
layout (0x14024d7a0) and the down handler’s
timer for state 0x12 (switch 0x140256f53)
Per-stage kill
height
Status: MISSING
Now: Kill height 0 (−500
units on stages ending in 9) everywhere; the
stage object that sets its own (0x1401e2dd0) is
not read. st01 has floor at y = −1.0 m along its
west rim (x ≈ −22), below the kill height: a
body landing there is sent back
Where:pd_rules.gd kill_height()
Lead: which stage object
type 0x1401e2dd0 handles and which stages place
it (.dat layout)
Bot opponent AI
Status: PLACEHOLDER
(narrowed by cpuvm)
Now: Our simple
chase-and-shoot bot: the autotests’ opponent and
the local versus opponent without
--cpu (--versus), so
its changes reach the practice opponent too;
walks into the Palace pit. (followups
11-15) Presses a close-range attack only
inside 0.85 × its reach
(REACH_MARGIN, our choice; Strike’s
8 m lunge range, a data lunge skill at lock
grade 1) and walks in when those are its only
usable attacks
Where:versus_bot.gd
Lead: replaced by the
game’s own CPU with --cpu
(CpuInput, rows below)
CPU
script runner (interpreter + built-ins)
Status: INFERRED
(cpuvm)
Now: The player’s own AI
script runs every 30 Hz tick in PdScriptVm (all
32 opcodes as decoded; 50,000-instruction
budget; main restarted each tick).
Our reading: every instruction counts against
the budget (a few handlers in the game restore
the counter; not traced)
Where:pd_script_vm.gd,
cpu_input.gd
Lead: the budget-restoring
handlers in 0x1402aaa30
CPU
script built-ins: shot threat test 0x40BA
Status: DECODED (behaviours
0 / 11; lobbed: 1, 2, 9 and state 3
built; autocrawl: 15 / 16 built) /
PLACEHOLDER (the rest) (cpu2)
Now: Built for the straight
shots (behaviours 0 and 11): the ticks until a
live shot reaches the CPU (aimed at it: stage
line unless collision word 0x6A is 2 or 3,
within 60° of the heading, (distance − reach) /
speed; aimed at no one: the closest point of its
remaining straight path), 0 for a shot aimed at
someone else, the CPU’s own side, records
outside set 0, the melee kinds and behaviour 4.
PLACEHOLDER: behaviours 5, 6 and 10 still answer
0 (ricochet 17 answers 0 in the game too)
(lobbed 11-12: built parabola 1, fall
2, burst 9 and the blasting state 3 as read in
the row below, _parabola_threat,
_fall_threat,
_blast_threat; the fall answer
keeps the decoded sign, (reach − distance) /
speed; a data mine is no longer skipped as the
CPU’s own shot since it can hit its caster;
INFERRED: the parabola’s flight ticks left
+0x1d4 is int(T) at the init counted down by one
per tick, the update’s rewrite not followed;
still 0: 5, 6, 10; autocrawl: 15 / 16
built, tests/test_cpu_hole.gd;
skills3a: 7 (fast rain) built with the
hole rule, ticks left − 0x7E,
test_cpu_hole.gd --behavior=7); the
CPU point’s centre height (C + 0x12e98) is ours,
0.9 m (SHOT_CENTRE_Y)
Where:cpu_input.gd_shot_threat,
SHOT_CENTRE_Y
Lead:(autocrawl:
built, tests/test_cpu_hole.gd)
behaviours 15/16 (the hole kinds) answer the
shot’s ticks left minus record word 0x7e when
its caster is on another side, else 0; behaviour
6 answers the shot’s int at +0x1cc when the
shot’s target is the CPU, else 0 (+0x1cc’s
writer not traced). Still to read: the
per-behaviour entries of the jump table in
0x14020f9a0 (FORMATS “CPU opponents”);
0x14020f8c0; the character’s centre-height
column (charaset) Read 11-12 (M,
doc-body), not built: every remaining
entry (FORMATS “CPU opponents”, row 0x40BA):
parabola 1 (flight ticks left when aimed at the
CPU; a landing-point test against the blast
radius when aimed at no one), fall 2, crawl 5
and moving 10 (reach formulas; 5 and 10 need the
nav straight-walk flag), multishot 6 (+0x1cc =
arc ticks left, written by the multishot init,
counted down in its update), fast rain 7 (ticks
left − word 0x7e, other side only), burst 9 and
the blasting state 3 (blast taken to grow to its
radius over 30 ticks, min 1); ricochet 17
answers 0 in the game too (the table ends at
16). The CPU point is feet + centre height 9 u =
our 0.9 m SHOT_CENTRE_Y (now
decoded, same for all playable models), radius 5
u. To check in the build: the
reach formulas compute (reach − distance) /
speed, so the value is ≤ 0 outside reach; ours
returns it positive (the script only tests
non-zero and keeps it in variable 18)
CPU
script built-ins: 0x4035, 0x4087, 0x40E5,
0x41A9/0x41AA
Status: DECODED / INFERRED
(cpuvm; environment group 0x40C5–0x40C8 and
0x4086, then 0x4035, 0x4087, 0x40E5 decoded in
cpu2)
Now: 0x4035: with a dash
evade (set 3, subtype 8) the straight-walk test
to the evade’s end point at that heading, else 1
(decoded). 0x4087: the kinesis pick (decoded);
INFERRED: the object position is its placement
origin (the kinesis cast uses the same pick,
KinesisShot.pick), and the
handler’s gate (character word +0x10 = 0, else
−1) is taken as 0 for every player. 0x40E5(p,
n): n added to p’s health through the decoded
health change (clamped, out at 0); its gate, the
battle-mode global 0x1404bc9d4 ≠ 0, is decoded
as set in every versus battle (cpu2 round 3: the
battle start stores its mode argument there, and
every versus start passes a non-zero mode); the
per-player damage tally it also keeps is not
modelled. 0x41A9/0x41AA = −1 (the versus value).
Decoded earlier: 0x40C5–0x40C8, reach kind 3 of
0x40C2/0x40C3, 0x4086
Lead: 0x4087: the object
position reads (+0x1f8, +0x198) and C + 0x10;
0x40E5: the damage tally 0x1405b15f0 /
0x1405b15f8 (only for stats)
CPU
script built-ins: slot state word 0x4094 /
0x4096
Status: INFERRED
(cpuvm)
Now: Decoded part: the aura
bits of the slot object’s state word (cost above
the current aura → 2, plus 1 when the level is
below it; level below record word 0x2A → 1;
0x1402620e0). Our part: a cooldown or spent
skill stands for the other bits as 8
Where:cpu_input.gd_slot_state
Lead: bits 0x8 / 0x10 /
0x20 of 0x14026205f (0x140262470, 0x140262d80,
slot state 2)
CPU
script built-ins: casting slot 0x407D, coarse
state 0x407C
Status: INFERRED
(cpuvm)
Now: 0x407D: the CPU’s own
casting slot is the slot it pressed last, any
other player’s reads -1; 0x407C maps our body
state (recovering → 2, reacting/staggered → 4,
down → 5) onto the game’s action-state
classes
Where:cpu_input.gd
Lead: the action-state
numbers behind 0x407C (states 10–12, 17,
busy)
CPU
script built-ins: sight pair 0x4075
Status: INFERRED
(cpuvm)
Now: Decoded: 1 when the
segment between the two players is clear of the
stage (0x1401641b0, collision kind 0x10 passes).
Ours: a sight-layer ray 1.2 m up, tested on
demand instead of one pair per tick
Where:cpu_input.gd_sight
Lead: the player point C +
0xe0 is the translation of the body matrix
0x1402513a0 builds each tick from the model
joint the pointer C + 0x13dc0 names (entry 1 of
the joint pointer array at C + 0x13db8), turned
by the facing; which joint the setup stores
there is the lead (no direct writer of C +
0x13db8.. in the exe: it is filled through a
base pointer) Decoded 11-12 (H for the
node, doc-body): the point is the torso
root model node (packed id 0x4D1D1710, entry 2
of the node pointer array that starts at C +
0x13db0), posed, 11.1–12.1 u over the feet at
rest by model (table in FORMATS “Body point,
sight point and aim point”). Rebuild: cast
between the two characters’
body_point() (the converted joint),
not a fixed 1.2 m
CPU
navigation (areas, edges, stored routes)
Status: INFERRED
(cpuvm)
Now: Converted per stage
into
pd-data/<stage>/nav<N>.json
(converter/cpuexport.py, every versus stage
since cpu2: st02–st08, st12–st17, st22–st26;
st01 has only the compact file, not decoded, so
no CPU routes there). Decoded: area lookup, area
centre, stored routes, 0x403C. The variant
number is 0 in versus (INFERRED: the variant
global 0x1404c51f0 is written only on
story/mission paths); the st05 family’s files
are stale in the game data (areas whose edges
don’t name them). Ours: the floor height inside
an area (corner-triangle plane), the
nearest-area fallback by centre distance, the
straight-walk edge choice per step (edges are
portals: the shared part of two sides, so the
walk between two area centres can miss the
edge)
Status: PLACEHOLDER
(cpuvm; narrowed in review round
2)
Now: 0x4033 takes the
stored route of set 0 (set 2 first in movement
mode 2; sets 1, 3 when blocked). Follower,
decoded part: nothing while the way is straight
(0x140177838); with no route it plans the stored
route body area → destination area itself
(0x140178d00 with argument 0: set 2 then 0 in
movement mode 2, else 0); in the destination’s
area the goal is the destination; with no way
the body stands (0x140177b4e). Ours: on a route
the goal is the next route area’s centre (the
game aims at a point on the edge into it,
0x140177c15 on), the stored route is taken
without the planner’s pass over it (its edge
checks, 0x140178e20 loop), the route is re-taken
from the body’s area when the destination moved
or the body left it (the game: 0x1401792b0), the
off-nav recovery (0x140178470) isn’t built and
it never gives up (0x40EA = 0)
CPU
stage-object pass: which objects, their spheres,
body radius
Status: PLACEHOLDER
(cpuvm review 2)
Now: The decoded rule
(FORMATS “CPU opponents” step 4, 0x140177f60)
moves the goal beside a sphere ahead on the way.
Ours: every stage prop’s collision body
(prop_*_coll_*) takes part, as one
sphere around its bounds (centre of the box,
radius half its diagonal), centre used as the
object’s position; the body’s half width is our
capsule radius 0.4 m (4 units). Breakable stage
objects and players aren’t in the list
Where:cpu_input.gd_avoid_objects, BODY_RADIUS
Lead: the objects’ sphere
list (vtable + 0x1F0, the collision sphere list
0x1405302f0), the + 0x98 query with 4, the
charaset width (FORMATS “Character table”)
CPU
goal at the start, cannot-act flag, pause
Status: INFERRED
(cpuvm)
Now: The goal starts at the
body’s position; cannot-act = busy or off the
floor; the script doesn’t run outside the battle
phase
Where:cpu_input.gdpoll
Lead: the controller reset
and N+0x10 writer
CPU
strength and start health
Status: INFERRED
(cpuvm)
Now:enemyparam.epa converted
(cpu/enemyparam.json); the CPU uses record 20
(the versus battle’s): integer variables 30..38
from it and its health byte as start health (20,
the same as the mode’s). Reading the byte as
health points directly is ours
Where:cpu_input.gd,
main.gd
Lead: the health byte’s use
in the battle setup
CPU
lock (direct, graded by distance)
Status: INFERRED
(cpuvm)
Now: The script’s target
slot is turned into lock presses (lock / next)
through our PdLockOn, instead of the game
writing the lock index and state directly; same
target, same grades
Where:cpu_input.gdpoll
Lead: the direct write
(lock index, state from the pair-table distance:
80 / 300 units)
CPU
battle setup (character, deck)
Status: PLACEHOLDER
(cpuvm)
Now: The CPU deck comes
from com/deck (cpu/decks.json):
--cpu-deck=<file>, else the
deck with the most skills our build plays; aura
cards are card id 0 (skill record 0, exported as
decks.json “aura_card”). The character is our
opponent model
Where:cpu_input.gddeck_names, main.gd_make_cpu
Lead: decoded
(doc-answers, H): the game’s versus CPU
plays the arsenal of the ranked player picked on
the online ranking list (built-in 0x4293);
nothing offline to pull, so the deck choice
stays our extension (closest: let the user pick
a saved arsenal). FORMATS “Open questions
settled” 7
CPU
capsule stall: no skill card from ~5 s to ~26 s
(lobbed r2, known issue)
Status: INFERRED (our
behaviour, not compared with the game)
Now:test_cpu_opponent against a
standing player, seeds 2-18, on main fd737b4 and
on lobbed alike: the CPU takes its first three
capsules by ~5 s (all aura in these shuffles),
then has no capsule of its own up for ~10 s (avg
0.0-0.1 up at 10-15 s) while it walks to the
player, and when they are up again (~2.7-3 at
20-25 s) they lie ~50 m away; the first
affordable attack comes at 24.8-27.3 s on 9 of
17 seeds on each tree, 30.8 s on one, 51 s or
later (or never) on 5-7 (lobbed only: 2.3-2.4 s
on seeds 5 and 12). Its early-affordable check
passes on 0 of 17 seeds on main and 1 of 17 on
lobbed, so the suite pins seed + deck
(SEED, DECK_INDEX = 1,
the deck main picked before the lobbed kinds) to
the hand the check was written for
Where:tests/test_cpu_opponent.gd (the 20
s check), cpu_input.gd capsule
targeting, the capsule respawn
(capsule_form.gd / Match)
Lead: compare with a
recorded versus-CPU match (capsule respawn
timing for the CPU side, and whether the script
heads for the player or the capsules while its
hand is empty); a cpu run
Heavy mode
Status: INFERRED
Now:(menus) the
split-screen versus screen’s rule row 4 (0x201A
kind 6) now picks it too
(MenuFlow.heavy);
--heavy picks the 40-hp mode with
aura start 5 (mode row 4, the only such
row)
Where:main.gd
Lead: decoded (docs
11-10 rules, M): the lobby’s game rule is
the mode row, so heavy = game rule 4, stepped to
on the create-game screen; no lobby UI of ours
yet; (docs 11-10 menus): the rule row
is stepped by 0x4242 on liverulesel
(0..11, wraps) and written by 0x201A kind 6 on
the split-screen vsmenu
3-copies-per-skill
rule
Status: PLACEHOLDER
Now: Builder limits are
ours
Where:arsenal.gd
Lead: decoded (docs
11-10 rules): the editor refuses the 4th
copy (0x140159db0, limit 3 for every skill), an
arsenal is always 30 places with aura cards as
the empty ones, no aura-count rule (FORMATS
“Arsenal rules”); not implemented
Now: Native
ArsenalBuilder with the decoded
behaviour: grid 3 × 10 + 3 buttons and its move
table (fresh-press wraps, auto-repeat after the
menus’ decoded delay, no move while 0x33f0 is
held, cue 3), A opens the stock list on the
place’s type tab, Y adds a copy, X an aura card;
stock list 8 rows, up / down (fresh-press wrap),
LT / RT page 8, left / right type tab (empty
tabs skipped); the card of the highlighted skill
at (350, 324) every tick through the HUD’s card
routine. PLACEHOLDER: the grid cell size (184 ×
24), the list width and look, colours, our
button labels, the backdrop; INFERRED: A in the
stock list returns to the grid after adding,
sort order (aura first, then catalog order),
button 30 = our “Use”. MISSING: the detail panel
(type 8), the shop and laboratory stock screens
(story mode: not in our build),
arsenaledit on the interpreter
Where:godot/scripts/arsenal_builder.gd
Lead: type 17 / 12 / 8
drawing (0x14016f2c0, 0x1401710a0, 0x140173650,
0x14015c280); result code 3’s meaning; the sort
routine behind button 32
Arsenal school
capacity
Status: MISSING
Now: No school limit in the
builder; aura factor from the schools counted in
the deck
Where:arsenal.gd, aura regen
Lead: decoded (docs
11-10 rules): capacity 1..3 per arsenal
(deck + 0x50), editor refuses more schools than
that on leaving, and the aura factor follows the
capacity, not the count; open: where a new
arsenal’s capacity comes from
Capsule spawn
spots
Status: INFERRED
Now: Slot k at the decoded
CP00 point k of the owner’s start, refilled
there (decoded); snapped to the floor below the
point (the game uses the point’s height as
is)
Where:player.gd _orb_spot,
main.gd _capsule_spots
Lead: the start record
index offset per match; drop the floor snap once
the capsule height is decoded (row below)
Capsule
spots without decoded points
Status: PLACEHOLDER
Now: Floor 2–4 m around the
owner’s spawn point, spread from the match RNG
(stages without CP00 points,
--spawn, autotest test
grounds)
Where:player.gd CAPSULE_NEAR_MIN/MAX
Lead: none needed for real
stages
Capsule
move (stage condition)
Status: MISSING
Now: Capsules stay at their
points
Where:arsenal.gd
Lead: decoded: when the
stage global 0x1403e0304 % 10 == 1, a take moves
the slot to 0x14012a650’s point and a rising
level (0x1405315f4) takes capsules below it;
which stages that is and the level’s source not
traced (FORMATS “Capsules”, Move)
Capsule
hover height and bob
Status: decoded
(playtest1104-fix)
Now: At a decoded slot
point the orb is drawn at that point as is (the
CP00 start-record point, slot +8, no offset, no
floor test: 0x14014f0f3, draw 0x14021b840),
still, no lift and no bob
(Orb.still; about 1 m above the
floor on st03). The card reach is measured from
the same slot +8 point lowered 9 units
(0x14014f630)
Now: Only an orb on a floor
spot (no decoded points: --spawn,
test grounds, debug spawns) hovers 0.6 m ± 0.12
(HOVER, BOB)
Where:orb.gd
lift(), bob()
Lead: none needed for real
stages
Capsule take
reach origin
Status: INFERRED
(playtest1104-fix)
Now:Orb.PICK_RADIUS is measured from
the slot’s floor-snapped spot
(Orb.reach_from, as before this
branch), not from the drawn slot point (on st01
the slot points sit too high for the 1.6 m
reach: versus autotest took 0). The native take
paths (0x140134460, 0x140139de0) only check the
slot state (2) and are script-command thunks
with the slot index passed in, so the distance
test is in the calling script; the card test
(0x14014f630) uses the slot +8 point, so the
slot point is a candidate too
Where:orb.gd
in_reach, reach_from
Lead: the script that
issues the take command (its distance test and
point)
Capsule card
swap effects
Status: decoded
(skills3b 11-13)
Now: Reshuffle swaps with
deck[pointer + below(30 − pointer)]; random up
slot for the own-capsule teleport
Erase
steal: the card leaving and the stolen card’s
uses
Status: INFERRED
(skills3b)
Now: The old button card
leaves as a played card would; the stolen card
starts unused
Where:instant_sets.gd _steal
Lead: slot-fill
0x140261a00
The
take’s move effect (erase take away)
Status: MISSING
(skills3b)
Now: The capsule vanishes;
the slot refills as a take does
Where:arsenal.gd take_away
Lead: the take routine
0x14014fd10’s move-effect mode (system model
entry 3, cue 0x5c)
Status
word +0x34 required by special 2 / 4
Status: MISSING
(skills3b)
Now: Not checked:
own-capsule teleport and bring always run
Where:instant_sets.gd special
Lead: what +0x34 of the
character status holds
Teleport
hold and gravity in states 0x1E / 0x1F
Status: INFERRED
(skills3b)
Now: Velocity zero for the
10 ticks; action 78 holds max(10 ticks, its
length). A hit in state 0x1E cancels the warp:
decoded (the hit dispatch
0x140258690 sets its state with no check of the
running one; only the 0x1E tick 0x140257230
calls the position set 0x1402501d0); still
inferred: the hold’s zero velocity, and that the
warp’s remaining hold (our cast recovery)
outlives the reaction
Where:player.gd warp,
_physics_process
Lead: state handler
0x140257230
Special-set
game mode 0 branches
Status: MISSING
(skills3b)
Now: Versus only: mode-0
“teleport in place” not modelled
Where:instant_sets.gd
Lead: game mode
0x1404bc9d4
Special dash
direction
Status: MISSING
(movepar: decoded, ours differs)
Now: The stick, else the
facing (as the evade roll)
Where:player.gd skill_dash
Lead: 0x140259d10
Decoded 11-14 (movepar, M): the
same dash state as the roll: along the facing,
no stick (FORMATS “Movement parity” section 5);
the address in this column was the state
setter
Instant-set
objects per release
Status: INFERRED
(skills3b)
Now: One per cast (the fire
node count of the record is not read)
Where:data_skill.gd _cast
Lead: the skill object
spawn for sets 1 / 3
Destruction of
stage objects
Status: DECODED
(stageobj)
Now: Shots hit stage
objects (hits from the model joints, one hit per
contact, at most 8 contacts per tick, a burst
only breaks on the last hit); the break removes
the bodies, plays the break sound, makes pieces
(crumble: one per joint mesh minus
stays; (playfix 11-14)
roll: the state-2 model as ONE flying box, then
state 1 or removal) or removes the object;
pieces fly as the decoded 8-point box (launch
formula, gravity, 2 sub-steps, 28 constraints
×2, plane collision of corners / edge midpoints
/ face centres against the stage triangles only,
cumulative rest, removal at rest, 300-tick cap);
no respawn; net host sends hit/break
Where:stage_object.gd,
stage_objects.gd,
projectile.gd,
pd_data.gd place_props,
net_session.gd Ev.STAGE_OBJ (net
version 11, hello stage_objects;
test tests/net_stageobj.gd);
converter stageobj.py,
pdconv --split-joints
Lead: the rows below
Stage
object piece launch / gravity factors
Status: DECODED (climb
2, 11-13; built collapse r5)
Now:StageObjects.add reads
params[0] (launch) and
params[1] (gravity) of the first
type 31 effect of the definition’s state-0 list
(StageObject.factor_record), else
1.0 / 1.0; the launch factor multiplies the
launch after the jitter, before the 1.5 cap; the
gravity factor scales the piece gravity. Type 31
is never played (StageSmoke plays
types 2, 3, 8 only). Palace: definition 11
launch 0.5 / gravity 1.0, every other object 1.0
/ 1.0 (test_deck_sections.gd)
Status: DECODED
(stageobj; corrected climb 3, built collapse
r5)
Now: See row “Piece launch
jitter”: when L² < 0.1 the three jitter
values are added to the scaled launch (not put
in place of the impulse)
Where:stage_object.gd
launch_velocity
Stage
object piece vs collision spheres
Status: DECODED, built
(collapse r5; classes collapse 6)
Now: This is the object
pass (row “Piece object pass”): the response is
the ordinary corner push-out on the mesh’s
up-facing triangles
Where:stage_object.gd Piece._substep
Stage
object piece collision: skipped triangles
Status: INFERRED
(stageobj)
Now: The pieces pass over
stage meshes with attribute 16, 17, 18 or 20:
the grid record byte the piece loop tests is
read as the mesh attribute (same reading as the
character’s “Stage collision attribute 20”
row)
Where:stage_object.gd
PieceCollision.SKIP_ATTRS
Lead: what the first byte
of a grid record is
Stage
object piece second acceleration
Status: MISSING
(stageobj; corrected climb 3)
Now: Not built (never was:
no tick-mod-10 path exists in the build).
Decoded: only when the per-battle value at
0x1403e0304 ends in 5 (not a tick counter; a
stage number by its use, M) a
piece gets a random second acceleration (length
0.5) that replaces gravity after 30 ticks; never
on the Palace (st03)
Lead: 0x1401e9145: the
value’s source, and its random source
Now: A flying piece whose
joint float 0 is non-zero is an attack body
while its speed² > 1 unit per tick: each
character tests its body sphere (5 units)
against the piece sphere (0.3 × mean box-point
distance); a contact is a normal hit (swept
test, line of sight, defenses, guard and
invulnerability), damage = the value, filed
under the victim; values 1–2 need the piece to
approach and remove it, 3+ pierce shields and
stay; host only (clients get Ev.HIT)
Status: DECODED
(piecepose 11-13; built collapse
r4)
Now: Placement × the
joint’s bind matrix (pd_bind),
previous = current − launch velocity, stage
collision from the first tick (from tick 9 for
faller classes, row “Piece collision delay”):
this is what the game does (object matrix × the
pieces model’s armature chain, no animation, no
inverse bind; FORMATS “Broken pieces: the start
pose”). The Palace deck section 1 piece that
climbs (joint 5) starts with two corners behind
the tree’s faces in the game’s own pose too;
corrected climb 11-13: the pose and the
push-out stand, but the 36–44 unit climb is NOT
the game’s behaviour (footage: small pop, all
slabs down in ~2 s); see rows “Palace deck piece
climb”, “Palace deck section 1 high throw” (the
decoded rules still throw it 36.6 u: known gap)
and “Stage object piece launch / gravity
factors”
Where:stage_object.gd _make_pieces,
Piece.setup
Lead: footage checked 11-13
(private recording): V pose on the first frame
confirmed, no climb
Now: Built: 8-tick
collision delay, the jitter added after the
scaling (counter +2 per jittered piece, index =
placement number, H), the object pass (classes
as decoded), the game’s point numbering, the
28-entry constraint table, the game’s triangle
grid read back to front, rest ends a piece
touched or not. Measured on st03 (footage order,
test_deck_sections.gd): section 0
gone 1.9–2.57 s (one 3.57; port 1.9–2.6, one
3.6); section 1: see the next row; section 2:
two slabs rest on section 3 and go at 0.87 / 1.0
s, the others reach the floor at 2.1 / 4.7 s
(port: the same; footage ~2 s); section 3 gone
1.9–2.13 s, one 3.57 (port 1.9–2.1, one 3.5).
Not tuned. The round-5 / earlier climbs (25.6,
64, 36–44 u) were build errors
Lead: still not ported
exactly (FORMATS collapse 6): single precision
vs the port’s double, the object pass list’s
order after objects break; section 2’s last slab
(4.7 s floor) against the footage’s ~2 s
Palace
deck section 1 high throw
Status: INFERRED / gap,
shipped as a known gap (playtester 11-14;
collapse r7)
Now: Built as decoded; the
decode is still missing a cause. With every
decoded rule built, section 1’s joint 5 slab
(starts with two corners behind the tree’s faces
in the decoded pose) is pushed out and thrown up
36.6 u, never reaches the floor, is left at deck
height by the tree (last y 111) and is gone at
6.23 s; the collapse-6 port gives the same shape
(38.1 u, 7.3 s). Footage (private recording 2
notes, docs1110/climb, full): pieces “ARE thrown
up and sideways, a few units above deck level,
and one large piece is still airborne 1.5 s
after the hit leaving toward the camera side. So
a small pop exists; nothing rises tens of units
or stays on the tree”; from that angle deck
slabs and the pillar’s own pieces cannot be told
apart, and that pillar 2 is deck section 1 is
likely, not proven (M); private recording 9:
every slab on the floor ~1.1 s after the hit, at
rest within ~2 s. The 36.6 u throw and the slab
left at deck height CONTRADICT the private
recording 2 note (caveat: slab vs pillar pieces
and the section identity are not proven, M). No
hand tuning. test_deck_sections.gd
asserts the port’s shape as the known gap;
test_collapse_rise.gd caps it at 40
u (KNOWN_GAP, seam --inject=gapkick
FAILs above) Orchestrator note (review haiku
r7): the side-on private recording 9 (a
break at deck height, section 2 by the Palace
map, not proven) also shows the slab ends
tilting up a few units (the pop), and our
section 2 has no pop (≤ 0.06 u, round 5): the
build is short of the footage there in the other
direction. private recording 9 does not satisfy
the section 1 lead below. Footage times: floor
~1.0–1.5 s after the hit, rest ~1.8–2 s.
Where:stage_object.gd Piece /
PieceCollision (no special case),
tests/test_deck_sections.gd,
tests/test_collapse_rise.gd
KNOWN_GAP
Lead: leads: the push-out
of a corner that starts behind a face
(0x1401f7870, step 4) and whether the game
starts joint 5 behind the tree at all (pose /
box of deck 1 joint 5); the object pass list
order after breaks (0x1401fbdd0 / 0x1401fbf40);
the near-zero constraint branch; single vs
double precision; footage: a side-on recording
of pillar 5 / section 1 breaking from the open
floor at deck height
Piece object
pass
Status: DECODED (climb
3, 11-13; built collapse r5; classes collapse 6,
built r6, tested r7)
Now: After a corner’s stage
triangles, each corner is tested (same push-out)
against the up-facing triangles (normal y >
0, no attribute filter) of the state-0 collision
meshes of intact objects in the pass list, when
it lies inside the mesh’s stored bounding sphere
(collision.json sphere, collconv
r5); a hit sets touched; a touched
piece whose eight points rest stays active
(held) but does not move again and
is deleted by the same age rule (> 32) as an
inactive one (round 6, re-read of
0x1401fa567..0x1401fa5c8; round 5’s “a touched
piece does not go to rest” kept slabs to the
300-tick limit and was a misreading); the edge /
face passes and the delay as for the stage. In
the list (collapse 6 decode, built r6):
class flag bit 2
(StageObjects.FALLERS 2/22, 2/23,
2/26, 2/42, 2/43; on the Palace the four deck
sections) and bit 0 (PASS_FLOORS
2/12, 2/13, on no versus stage); the list runs
from the last-created object back (a group joins
at the head, 0x1401fbdd0); pieces of class 2/17
(class flag 0x80, st03 × 3) skip the pass
(PASS_SKIPPERS,
skips_pass);
test_deck_sections.gd _class_tables
drives the real StageObjects.add /
floor_meshes / tick
for each class (r7). Class flag 0x1000000: row
below (MISSING, not built)
Now: Built as decoded (row
“Piece object pass”), not checked against
footage: st03 object 170 (class 2/18, a prop
lying on deck section 3) rises 14.4 u when its
section breaks (0.06 u with the pass off; 14.0 u
in round 6 with the collapse-6 decode built).
Collapse 6 (H): class 2/18 has no class
flag, so its pieces do take the pass against the
intact deck sections; the height was not
recomputed by the port: its pieces slip under
the intact section’s top within the 2 u band and
are pushed up.
test_collapse_rise.gd
OBJECT_PASS_POP = [170] is the only object whose
rise the object pass may explain
Lead: needs decode: whether
a 14 u rise can come from the 2 u corner band
(port 170’s pieces with the collapse-6 rules;
which sections are still intact when 170 falls,
the order of breaks in one support chain);
footage of a prop on a breaking deck
Piece collision
delay
Status: DECODED (climb
3, 11-13; built collapse r5)
Now: Pieces of an object
with class flag bit 2 (classes 2/22, 2/23, 2/26)
skip all collision (stage grid and object pass)
for their first 8 ticks
(StageObject.FALLER_DELAY,
Piece.delay); 0 for every other
class
Where:stage_object.gd Piece
Piece launch
jitter
Status: DECODED (climb
3, 11-13; built collapse r5), seed M
Now: Added to ½ · (impulse
+ d̂ · L) · F when L² < 0.1, before the launch
factor and the 1.5 cap; a = low byte of (index +
counter), counter 0 at each break, +2 for each
piece that takes the jitter (a piece with an
impulse leaves it; corrected round 6,
0x1401e8f9c / 0x1401e8fde; the code already did
this, FORMATS said “per piece”; untested for a
mixed break: every Palace deck piece is
zero-impulse), components at +0 / +1 / +2 (game
axes: z mirrored into the rebuild’s space). Seed
= serial = the placement number
(that the played list is created first is
M)
Status: DECODED
(collapse 6, 11-14; built collapse
r6)
Now: The eight points are
numbered in the game’s axes: the z bit of a
corner is set for the game’s larger z = the
smaller z in our mirrored space
(Piece.corner); everything indexed
by point (corner loop, edge / face tables,
constraints, point 0 of the bounds test, the
drawn matrix from points 0–3 with the z edge
negated) uses it. Round 5 numbered by our z
(build 0–7 = game 3, 5, 4, 0, 2, 1, 7, 6).
test_deck_sections.gd checks the
numbering on a real Piece
Status: DECODED
(collapse 6, 11-14; built collapse
r6)
Now: The game’s 28-entry
table (12 edges, 4 body diagonals, one diagonal
per face twice; pairs 0x1403eebd0) in that
order, twice per sub-step, rest length per entry
(Piece.LINKS); near-zero length:
the stored velocities give the direction. Round
5: all 28 pairs in index order
Lead: the near-zero branch
is built from the doc’s description only (no
case seen on st03)
Piece
triangle order in a cell
Status: DECODED
(collapse 6, 11-14; built collapse
r6)
Now: The game’s grid (30 ×
20 × 30 cells from the lowest vertex in game
axes, int(extent / cell) + 1 per axis, truncated
index, nothing outside; a triangle in every cell
of its bounds grown by 0.5 whose box grown by
0.5 it overlaps, meshes with flag bits 0 and 1
only) and the read order back to front:
attribute records, then vertex sets
(collision.json vset, collconv r6),
then triangles in reverse file order
(PieceCollision._fill,
near). INFERRED: the cell overlap
test is a standard separating-axis triangle /
box test (0x1401d65a0 not compared line by
line)
Where:stage_object.gd PieceCollision
Lead: 0x1401d65a0 against
the SAT test on the edge cases
Piece rest
Status: DECODED
(collapse 6 and collapse r6 re-read, 11-14;
built collapse r6)
Now: When all eight points
rest the piece never moves again; untouched it
goes inactive, touched it stays active
(held, age + 2 per tick); either
way an ordinary piece is deleted once its age is
above 32 (0x1401fa567..0x1401fa5c8). Round 5
kept touched pieces to the 300-tick limit
(section 2: 10.0 s, now 0.87 / 1.0 s)
Where:stage_object.gd Piece
_substep, tick,
_idle
Class
flag 0x1000000 (object pass floors)
Status: MISSING, not
decoded (collapse 6, 11-14)
Now: Objects with this
class flag are floors of the object pass too; no
class constructor sets it as a constant and its
writer was not followed. None is assumed in the
build
Where:stage_objects.gd FALLERS / pass
list
Lead: find the writer of
base + 0x50 bit 24
Roll
break box and its gates (playfix
11-14)
Status: INFERRED
Now: Built from the decode
(FORMATS “The roll break: one flying box”):
piece state 2, target state 1 for every roll
class; launch √(1200 / max(size, 200)) × the
reversed contact direction (support loss: the
hash impulse), hash lift, factor, cap 1.5; start
spin (h · 0.0006 / 256 − 0.0003 per axis, first
four sub-steps, w × previous point). INFERRED:
the box is the union of the model’s stored index
buffer bounds (0x1401f7dd0 takes one bounds
record when its joint search finds one; which
record was not read). Not built: the
support-loss skip flag (roll byte +0x21 bit 1,
writer not found) and the global option at
0x140530ccc bit 1 that skips the box (setter not
traced)
Where:stage_object.gd_roll,
roll_box, Piece.spin
Lead: 0x1401f7dd0 joint
search (0x1401cb510 with callback 0x1401ebc90);
writers of the roll byte +0x21 and of
0x140530ccc
Piece triangle
grid
Status: DECODED (climb
11-13; built collapse r6)
Now: See row “Piece
triangle order in a cell”: the game’s 30 × 20 ×
30 grid is built (round 5 used our own 50-unit
grid in file order)
Where:stage_object.gd PieceCollision
Sink-then-crumble
objects (ACrmFT)
Status: MISSING (climb
11-13)
Now: Not built. A hit
starts a counter and the kind 3 effects, the
object sinks 5 / N units per tick for N ticks,
then breaks into pieces with no impulse. Which
class numbers and stages use it is not looked
up
Lead: find the class number
and N’s source (0x1401e9450, 0x1401e9550)
Broken piece box
Status: DECODED
(piecepose 11-13; built collapse
r4)
Now: The box is the stored
bounds of the joint’s first index buffer
(objects.json version 3 joint box,
converter stageobj.py), then the
decoded inset; the vertex bounds
(joint_box) only for a version 2
file. st03 deck 1 joint 11: size 1,990 (was
15,464)
Where:stage_object.gd stored_box /
_make_pieces
Which joints
become pieces
Status: INFERRED
(piecepose 11-13; built collapse r4: only
parent-0 joints fly)
Now: Only joints whose
parent is joint 0 and that are not stumps become
pieces (decoded, built). INFERRED: a deeper
joint’s mesh goes with the top of its parent
chain: it rides that piece, or stays with the
stump (model_35_j16); st03: 11
deeper nodes with drawn meshes (models 35,
47–52)
Where:stage_object.gd _make_pieces,
chain_top
Lead: what the game draws
for a deeper joint that is not under a stump
(entry flag bits 0x12, 0x1401e8960)
Piece launch
position
Status: DECODED
(piecepose 11-13; built collapse
r4)
Now: The launch direction
and distance are measured to the centre of the
piece’s box in the stage (slot 9, 0x1401f8440),
not the joint’s origin
Where:stage_object.gd _make_pieces
Object stored
point
Status: INFERRED
(piecepose 11-13; built collapse
r4)
Now: Built from the decode
(M): the centre of the union of the stored
bounds of all index buffers of the object’s
current model (objects.json version 3 state
bounds), without joint matrices,
through the placement (0x1401e81b0 →
0x1401fc4b0); launch centre of a support loss
and of the 2 / 23 break, their sound / effect
point and the attack sphere’s centre. INFERRED:
the current state’s model at the time of the
call (intact for a support loss). Note: st03
deck 1’s bounds have y −105…−3 (its drawn deck
is at y 94–115), so the point lies about 160 u
below the deck and the jitter launch leans
upward; version 2 files fall back to the
placement origin
Where:stage_object.gd stored_point
Lead: when it is refreshed
(the four places in 0x1401e5e20 that fill
it)
Stage
object hit / break effects
Status: MISSING, partly
built (stageobj, docs 11-12 effects,
effects1)
Now: Built
(effects1): smoke (types 2 / 3 / 8) of
the current state, kind 1 on a hit and kind 2 on
a break, at the contact point
(StageObject.play_effects,
stage_smoke.gd; also on a net
client from the hit / break event). Not played:
16 shake, 18 drips, 9 crash debris, 10 / 13
models from the object lists
Where:stage_object.gd,
stage_smoke.gd
Lead: 9 (crash debris, 384
records): the debris manager, kind parameters
and piece shader are decoded (docs 11-14 crater;
kinds 0–7 of the Palace converted in
crater.json), not built; 10 (model,
421) is decoded only to its record fields (M),
the model draw is not followed; 16 / 18 are
decoded (FORMATS) and only need spawning
Stage smoke
sprite
Status: PLACEHOLDER
(effects1)
Now: A soft round puff in
the record’s colour and alpha, alpha blended,
stands in for the sprite set’s frames; every
number of the smoke particle is decoded and
used
Where:stage_smoke.gd SHADER
Lead: the sprite set (base
+ b4: stage SP00 set n − 3) is not converted (UV
cells, texture slots), and the sprite draw
0x140205d60 and its blend were not followed
(hurt 11-13) now converted:
spritesets.py writes every loaded
slot (sprite id − 3 = slot) with frames, sheet
and blend mode (FORMATS “Stage sprite sets
(SP00)”). Rebuild: use it
Stage smoke
details
Status: INFERRED
(effects1)
Now: In a tick the live
sprites move before the emitters add new ones
(born at age 0); a local random generator for
the ±scale / 2 offset
Where:stage_smoke.gd
Lead: the order inside the
pool update 0x1402429a0
Stage
object break attack sphere
Status: DECODED (hurt
11-13: built)
Now: A break or support
loss of an object whose state 0 model’s first
joint has float 0 ≠ 0 makes a one-tick attack
sphere at the object’s point, radius 0.7 × the
state 0 box diagonal, value = that float (st06 /
st16 / st26 definition 16: 3, 13.4 units); it
hits like a piece of value ≥ 3 (no direction
test, pierces shields); test_hurt
and net-hurt
Now: The character’s body
point for the 0x400 test is fixed 1.2 m over the
feet (the CPU sight / lock height)
Where:stage_attack.gd
BODY_POINT_HEIGHT
Lead: the game uses the
animated torso root node (C + 0xe0, about 11–12
units standing)
Stage attack:
defense kind
Status: INFERRED (hurt
11-13)
Now: The records’ type 1 is
answered by defenses as the straight shot
Where:stage_attack.gd KIND_NAME
Lead: the defense kind test
on the two fixed records
Stage
attack: reflecting defense
Status: INFERRED (hurt
11-13)
Now: A reflect against a
stage body counts as a block (nothing to send
back)
Where:stage_attack.gd hit
Lead: the reflect path with
an ownerless object
Stage
attack: who counts as down (playfix
11-14)
Status: INFERRED
Now: Repeat hits are
decoded (FORMATS “Repeats and the knockdown”: a
staying piece hits every live tick; the second
hit throws). The game refuses the stage records
on reaction states 0xf, 0x11, 0x12 (state 0x10
is still hit); ours refuses
Combatant.downed (falling, thrown,
lying, getting up)
Where:stage_attack.gd test
Lead: map our React states
to the game’s 0xf..0x12 (which one is the
get-up); +0x63f4 (needs record flag 8) not
modelled
Stage
attack on a net client: removed piece
Status: INFERRED (hurt
11-13)
Now: A value 1–2 piece that
hits on the host is removed there; the client
keeps drawing its copy until it rests /
vanishes
Where:stage_objects.gd
Lead: net divergence,
cosmetic
Shot impact
marks
Status: INFERRED (hurt
11-13, r2 11-14)
Now: A plain shot that ends
on the stage (not a character, not a stage
object) sends the mark segment from its last
tick position to 1 m past its end; an exploding
shot makes one mark, its
blast’s sphere probe only (no segment probe as
well), and none when the record’s set is 0 with
collision 3
Lead: which shot kinds call
the segment probe: its three skill-object
callers 0x140269f5c / 0x14026a39b / 0x14026caeb,
and whether any of them runs for a shot that
starts a blast (state 3, 0x14026dc83)
Class 2 / 53
objects (st05 ×5)
Status: MISSING
(collapse 11-12)
Now: Treated as
support-only crumble. Decoded: no hit component
and no link test, never linked; what breaks them
is open
Lead: its class update
0x1401f3c40 and slot 29 (0x1401eac80)
Now: The mark routine
(0x14021d3f0) is not run on a stage object hit;
the hit sound is (no Palace row has one).
Decoded: on the hits-left > 1 path the
routine runs with the contact shape’s attribute
(debris, mark, dust, material sound) unless the
attacker’s callback kind is 1 (FORMATS “The mark
routine on a stage object hit”)
Lead: who writes the shot
callback’s kind words (which skills leave no
mark)
Stage
object classes outside table 2
Status: MISSING
(stageobj)
Now: Only table 2’s crumble
(3, 8, 18, 23, 28), roll (1, 2, 4, 17) and
(collapse 11-13) collapse (6, 26)
families break; other tables’ objects count hits
but a break only removes them (family NONE)
Where:stage_objects.gd FAMILIES
Lead:(stageobj2)
classes per table and stage are in FORMATS
“Stage objects: other families”; on the versus
stages only 1 / 4, 1 / 15 and 4 / 16 are outside
table 2; tables 3 and 4’s other classes are
town-only
Jump pads
Status: MISSING
(stageobj2)
Now: Pad objects (table 4,
class 16; st05–st08) are static props: standing
on one does nothing. Decoded: floor contact
within 7.5 units in reaction state 0 / 1 / 8 →
the normal jump with apex = placement phase byte
× 0.1 m, effect and sound
Lead: implementation; left
to decode: what jump kind 4 changes in the air
(0x140257b90)
Kinesis
throwables, object side
Status: DECODED
(stageobj2; built autocrawl 11-12; chain
collapse 11-13)
Now:KinesisShot.throwable /
damage_byte,
StageObject.take (autocrawl),
StageObject.grab /
StageObjects.grab (collapse).
Decoded: joint float 1 ≠ 0 on a class 2 / 3
state 0 model = throwable, its integer part is
added to the card power; a grab removes the
object for the battle and collapses what stood
on it: take now releases the
dependants in the same call (the support chain
of objects.jsonsupport_links, row “Stage object
support links”), on the host and on the client
applying the host’s grab
Where:kinesis_shot.gd,
stage_object.gd take / grab,
stage_objects.gd
release_dependants
Stage object
support links
Status: INFERRED
(collapse 11-13: built; one point and one
order inferred)
Now: Built:
objects.json version 2+
support_links of the active
placement list are taken in at stage setup (≤ 4
supporters / ≤ 16 dependants); a break or a grab
releases the dependants in the same call, depth
first in link order: each loses its bodies,
releases its own dependants, makes the break
attack sphere, queues its break sound and makes
pieces with no impulse (or is removed /
collapses); one lost supporter is enough, hits
ignored; only the first break is a net event,
every peer runs the chain from it (hello
stage_links count must match).
Palace: a pillar takes its deck section and
railings (tests test_collapse.gd,
test_collapse_stages.gd on all
converted stages, net_collapse.gd).
Pieces of a support-lost object launch with the
jitter only (
Where: v
Lead: ≤ 0.1·√3 = 0.17
u/tick since round 5, so they rise ≤ 0.5 u from
the launch); a piece whose box starts with
corners behind stage triangles is pushed out by
the stage collision step and can climb (Palace
deck section 1: one piece 64 u off the tree’s
attribute 10 / 31 faces with the decoded start
pose in round 4; 25.6 u in round 5 with the
delay, jitter and object pass built; 36.6 u in
round 6 with the collapse-6 decode built, the
port’s 38.1). The start pose is DECODED (row
“Broken piece start pose”); the earlier climbs
were build errors, and the decoded ~37 u throw
of section 1 is a known gap that contradicts the
footage (row “Palace deck section 1 high throw”,
INFERRED / gap); the attribute check in
test_collapse_rise.gd is a
self-consistency guard (copy of the production
skip list), its seams
(--inject=kick,
--inject=inside,
--inject=objkick) show the guard
catching a climb; since round 6 its “object” tag
explains a rise only for the objects of row
“Object-pass pop of a prop on an intact deck
section”. INFERRED: in a break the dependants
are released before the break sound is queued
(the doc gives this order for support lost
only)
Timed
falling platforms (st08)
Status: MISSING
(stageobj2)
Now: Class 2 / 58 objects
are static. Decoded: start second = word 4 of
the sound row, on the shared stage clock;
warning effects, sink, break effects, free fall,
deleted below −100 units
Lead: per-object sink step
/ count / acceleration and whether the collision
follows (0x1401f3780)
Floating props
(st05)
Status: MISSING
(stageobj2)
Now: Class 2 / 54 objects
are static. Decoded: vertical sine × 1.5 units
with a per-object phase; never break
Lead: the period and the
collision (0x1401f3c40, 0x1401df810)
Collapse
family, crumble variant, special object
Status: MISSING
(stageobj2; partly built in collapse
11-13)
Now: Built: class 2 / 23
pieces always drop about the object’s point with
no impulse, also on a direct break; the collapse
family (2 / 6, 2 / 26) on a break or support
loss switches to state 1 (its model and its
state 1 collision) with the start tick on the
stage clock (collapse_start).
PLACEHOLDER (collapse round 3):
a kind with no state 1 shape list (st02’s slabs
0-8, 2 / 26) would have no bodies in state 1, so
the real Player fell through a floor drawn
intact (test_stage_collapsed.gd);
such an object now keeps its state 0 model and
bodies and only the switch (state 1,
collapse_start,
collapse_kept_state0) is recorded,
until the state 1 animation (which presumably
takes the floor away) is exported. Missing: the
state 1 animation (OA stream, length at +8) is
not exported, so the state 1 model holds its
bind pose (on st02 it draws like the intact
floor, no artefacts: renders
proof/r2 of the collapse round 2),
its collision does not follow the joints and the
object is never deleted at the end (the
0xC3500000 keep rule is not applied). Whether
shots hit 2 / 6 and 2 / 26 (no AHit in their
component list) is open: they take hits like the
others. 1 / 15 only located (L)
Lead: collapse: state 1
animation export per joint and its length
(converter), then the joint-driven pose and
collision; 1 / 15: 0x1401e77b0, 0x1401eb800
Stage
object net events: tie rule and hit reaction
message
Status: INFERRED
(stageobj2)
Now: Our stage object event
is our own format. Decoded: a break carries a
stage clock stamp, the earliest stamp wins and
every peer breaks at that time; a second message
shows a hit reaction at a point on the other
peers
Where:stage_objects.gd net event
Lead: implementation of the
tie rule; the stamp multiplier at
0x1404bc9b4
Stage
object pieces state collision
Status: INFERRED
(stageobj)
Now: After a crumble break
into pieces no collision is added (the doc’s
step 2 removes the bodies; the pieces state’s
own list, present for some definitions, is not
used)
Where:stage_object.gd break_at
Lead: whether the state
switch at 0x1401e8960 adds the state-1 list
Stage
object placement list
Status: INFERRED
(stageobj)
Now: List 0 (layout.json)
is used; --placement-list=N picks
another; the per-battle variant setting that
picks list variant + 1 was not traced
Where:stage_objects.gd
placement_list
Lead:(stageobj2)
the setting is decoded by the rules run (FORMATS
“Versus options, stage list”: the host’s draw
over the stage record’s variant count); left:
implementation; the writer of 0x140531dcf;
(collapse 6, 11-14) decoded: exactly
one list is created (slot selector + 1, else
list 0) and object indices count its placements
from 0
Shot vs
stage objects: 0x6A variants
Status: MISSING
(playfix r2)
Now: The plain shot’s stage
test is built (FORMATS “Shot end on a stage
object”: ends at the nearest contact, every
object on the ending tick’s step is hit, segment
only). Not built: collision word 0x6A = 2 (flies
through objects, hitting each), 1 (stopped by
objects, no hit), 3 (no stage test), and the
remote-caster cast that stops without hitting
(our objects only take hits on the
authority)
Where:projectile.gd_crossed_objects,
breaks_props
Lead: read 0x6A per data
shot (DataSkill) and branch in
_physics_process
Shot
stage-object hits: after the physics step
(playfix r3)
Status: INFERRED
Now: The plain shot’s
stage-object hits (the ray’s crossed objects and
the nearest contact’s end,
_end_on_stage) run deferred, after
the physics step, as the old sphere signal’s
did, so a break’s pieces are first stepped by
the stage objects’ tick in the next tick (keeps
test_collapse_rise / test_deck_sections at the
decoded launch)
Where:projectile.gd_end_on_stage.call_deferred
Lead: the attack
post-update 0x14026e720 (stage test at
0x14026e80b) against the stage objects’ tick in
the game’s frame order: which runs first in a
tick
Contact
order: stage objects against the arena
(playfix r3, r4)
Status: INFERRED (the
climb-over it gives is observed in the game:
playtester playtest, Rebirth 11-15)
Now: The response’s contact
list is in add order (PdData stamps every
collision body, “pd_add”), each shape’s
triangles in reverse file order (decoded,
movepar 6.2). The placed stage objects come
before the arena’s collision set
(OBJECTS_AFTER_ARENA false),
ordered by their index in the active list and
then the body’s place in the object’s shape
list; (r4) an object keeps that place
when a state change re-adds its bodies
(_add_key keys stage objects by
index, not by the add stamp;
test_stage_collapsed checks st02’s re-added
slabs stay below the arena), since the game
re-registers each object every tick from its own
update. The game re-registers its bodies every
tick (lists double-buffered on a flag at
0x1405301e4, the flag flipped and the new lists
cleared at 0x1401d5838; objects register in
their update through 0x1401fda60, by their mode
word +0x134 into the list at 0x140530298 via
0x1401d4e90 or the one at 0x1405302f8): where
the arena registers against the objects was not
followed, nor whether objects register in
list-index order. With the objects after the
arena the Palace bench pairs give a
drop-and-put-back loop from the seat side
(59+58, 60+57: 15–17 put-backs in 60 ticks);
with them before, the run climbs over both.
Observed in the game
(playtester playtest, Rebirth 11-15): you can
walk over the benches between the escalators,
which matches the order built; the registration
order itself is still undecoded, and the stop at
a bench’s back is not yet
playtester-checked
Lead: who registers the
arena shapes each tick (0x1401d5cd0 path, list
by byte +0x40) and the frame order of that
against the stage objects’ updates
Stage object
burst growth
Status: PLACEHOLDER
(stageobj)
Now: A burst tests stage
objects once with its full radius (our bursts
are instant); the game’s explosion grows over 30
ticks. Characters are now taken nearest first
(the growth order, so a break-through’s lowered
carried value reaches the farther ones, decoded
M), but all in the same tick. (lobbed:)
data cards set breaks_props from
collision 0x6A (decoded: != 3,
AreaKinds.fill); only the test
blast skill still defaults to true
Where:projectile.gd _explode,
breaks_props
Lead: — (follows when
explosions grow); set breaks_props
from collision 0x6A when data shots get their
burst
Stage
object sound pass rate
Status: INFERRED
(stageobj)
Now: The object sound queue
pass (cooldown 30) runs once per game tick
Where:stage_objects.gd _sound_pass
Lead: caller of
0x140201d30
Stage
piece impact sound (sound row word 2)
Status: MISSING
(stagefx 11-15)
Now: Flying pieces are
silent; sound_row[0] is exported
but unused, and the cue table lacks values
36–39
Where:stage_object.gd,
stage_objects.gd
Lead: decoded: queued at
the piece centre when the last velocity² > 1
and the velocity change² > 1 (units per
tick), through the object sound queue; values
36–39 → cue pairs 191/192 … 197/198. Not checked
by ear
Broken pieces’
shadow
Status: PLACEHOLDER
(stageobj)
Now: Flying pieces and the
stump draw no shadow volume (the unsplit pieces
model’s volume is dropped)
Where:stage_object.gd _instance
Lead: the game’s shadow for
state-1 objects
Positional
and held sound flags
Status: DECODED
(ambient build 11-14)
Now:pdsound.py exports
soundparam.dat as the PC loader’s
groups (param_groups, a bank’s
param_group); flag 0x10 picks the
3-D path, 0x08 the held emitter mode, bits 0–1
the volume class; near / far / curve / spread
feed the 3-D sends
Where:pd_sound.gdparam()
Lead: — (rows “Positional
only with soundparam flag 0x10”, “Voice bank
parameter group”)
Now: Not read; every skill
can be used in any state and none chains
Where:skilldata.py,
arsenal.gd
Lead: the use condition
0x48/0x4A is now read in the executable
(0x140262470, a 9-way switch: health, aura,
cards left, aura = level, level; FORMATS “Card
power and the damage formulas”, 20 records); the
follow-up ids 0x32..0x44 (6 records) are still
from shared notes only, re-read before use