Non-Reforged movement accuracy

The measured original movement model, and where this engine still differs from it.

Reference for the non-Reforged movement model, which reproduces the original Jazz Jackrabbit 2. Every original figure was measured with the trajectory probe (How this was measured). The constants live in Jazz2::Actors::Player, prefixed Legacy and gated on !IsReforged().

Three fixes are bugs in shared collision code and so are live in Reforged too:

The camera (The camera) is local and purely visual, so it is gated on its own preference, Jazz2::PreferencesCache::EnableReforgedCamera, not on the gameplay setting.

Columns used by most tables below:

ColumnMeaning
3.8.0The engine before this work (commit 35eb085c), hand-tuned by feel.
OriginalJazz Jackrabbit 2 with JJ2+ Beta v6.6h, measured at 70.021 ticks/s.
NowCurrent state, converted from the Original column.
How far … was offAgainst the Now column, i.e. against the original converted to 60 Hz.

Units and the frame-rate conversion

The original runs at a fixed 70 ticks/s, while this engine's timeMult has a 60 Hz baseline:

  • velocity (px/tick) × 70/60 = 1.166667
  • acceleration (px/tick²) × (70/60)² = 1.361111
  • duration (ticks) ÷ 70/60

This preserves jump height and real-time duration at once, so no further tuning factor belongs in these constants. 3.8.0's (×1.05 ground speed, ×0.94 vertical velocity, ×0.94² rise gravity, ×0.977 fall gravity) are gone. The original works in 1/65536 px, so a correct measurement lands on a clean fraction of 65536.

The headline finding

The original applies one acceleration table to everything. Ground and air are identical, and the acceleration follows the input direction regardless of movement: no skid factor, no separate airborne rate, no momentum loss on reversal. 3.8.0's ground skid (LegacyRunBrakeScale 0.4 / LegacyWalkBrakeScale 0.7) and every airborne variant were inventions and are deleted.

Ground movement

Quantity3.8.0Original (70 Hz)Now (60 Hz)How far 3.8.0 was offHow far Now is off
Walk speed cap4.9004.04.6667+5.0%exact
Dash speed cap9.80016.018.6667−47.5%exact
Acceleration, no Run0.3800.18311 (12000/65536)0.24924+52.5%exact
Acceleration, Run held0.3800.36621 (24000/65536)0.49847−23.7%exact
Deceleration, walking0.1540.12207 (8000/65536)0.16616−7.3%exact
Deceleration, in dash state—0.42725 (28000/65536)0.58155(absent)exact
Turn-around skid multiplier×0.4 / ×0.7none1.0(invented)exact

3.8.0 used one acceleration for both, but the original doubles it with Run held. Full stop times, measured independently, agree with the deceleration constants:

FromOriginalPredicted by the applied constants
Walk cap33 ticks (0.47 s)4.0 / 0.12207 = 32.8 ✔
Dash cap49 ticks (0.70 s)16 grace ticks + 33 ✔

The dash is a timed state, not a cap

Holding Run raises both cap and acceleration. After release the player keeps full dash speed for 16 ticks (13.71 of ours), then is clamped to the walk cap in one tick (16.0000 → 4.0000), in mid-air as on the ground. Absent in 3.8.0. See Jazz2::Actors::Player::LegacyDashGraceTicks.

The keys steer the tick they are read on

The original reads the keys, changes the speed and then moves by the new speed, all in one tick. Ours moved first and steered afterwards, so every step was the previous tick's speed. That costs nothing at a constant speed but shows twice on a turn: one frame of overshoot at the old speed, then one frame behind at the new one. Measured with one JJ2+ script run in both games at /max-fps:70 (one frame per tick):

TurnOriginal peakBefore (peak / end)Now (peak / end)
Walk, reversed (tn_walk)179.82+0.47 / +7.70+0.29 / +3.51 (3.68 of it one stalled frame)
Dash, reversed with Run (tn_dash)650.60+4.73 / +11.33+0.63 / −0.84
Dash, reversed without Run (tn_dash_nr)561.93−2.91 / −3.51+0.90 / −0.06

The same order applies to the dash state, which is updated after the speed:

  • Run takes effect on the next tick. The first tick with Run held still accelerates at the walk rate (0.1831), the dash rate (0.3662) follows. Seen from a standstill (tn_dash, g_dash) and on a turn with Run pressed with it (tn_walk_runturn).
  • The end of the grace snaps after the brake, so the snap tick reads exactly 4.0000 and the brake starts from there (g_dash_rel: 4.0000 then 3.8779). Ours braked in the same tick and stayed one step behind for the whole turn (tn_dash_nr ended 7.9 px short).
  • A frozen player's 31/32 friction also comes before the move (fz_p_walk 0.58 → 0.29 px).
  • Over a frame the move uses the average of the tick speeds, not the last one. Per tick the original adds the acceleration and moves by the new speed, so from rest it covers a·t(t+1)/2; doing the same once per frame of Δ ticks covers a·t(t+Δ)/2, which is only right at 70 FPS. A walk from rest was 0.32 px out at 60 FPS and 2.58 px at 30. The move now subtracts Δv·(Δ−1)/(2Δ) of the frame's speed change, which is exactly the original at any frame rate: g_walk 0.15, 0.16 and 0.11 px at 30, 60 and 144 FPS. Horizontal only; the vertical axis keeps its fitted velocity-Verlet step.

The jump had the same phase: both games set the launch speed on the same tick (−11.0 on tn_walk_air's tick 41), but the original moves by it that tick and ours moved a tick later. Crouch, jump, the rev-up, swimming and the modifiers are now read before the move as well (Jazz2::Actors::Player::HandleVerticalInput()); only firing stays after it, and the bird keeps its own measured order (The two birds).

Applied-movement cap

The original caps applied movement at 8 px/tick on both axes. A dash reports xSpeed 16 but travels 8. The excess is momentum that still counts wherever speed is read, which is why a dashing jump launches at −14. 3.8.0 capped only the vertical axis (LegacyRiseSpeedCap, correct at 8). The horizontal cap removed 300–570 px of error per dash scenario.

Slopes

Slopes have no effect on horizontal speed or acceleration. Up or down, xs stays 4.0, x advances 4/tick and y moves 4/tick. The acceleration curve is unchanged (10.8032 at the same tick both ways). The engine already matched.

Jumping into a 45-degree slope

The airborne branch of Jazz2::Actors::ActorBase::TryMoveSubstep() retries a blocked horizontal step with an increasing upward offset so a mostly-horizontal move rides up an incline. Its gate, abs(stepX) > abs(stepY), failed for a dashing jump against a 45-degree face (8 across, 8 up at the applied cap): the step was ground down, HitWall reported and Jazz2::Actors::Player::OnHitWall() zeroed the speed. Fixed, also in Reforged.

ScenarioOriginalBeforeAfter
sl_up45_jhold (dash + jump)16.0000 throughout0.997718.6667 throughout
sl_up45_run (dash, no jump)16.000018.666718.6667
sl_up45_jwalk (walk + jump)4.00004.66674.6667

Crossing a gap: there is no ledge hop

The original gives no upward boost off a ledge (gaps of 1–4 tiles): ys goes straight into fall gravity (0, 0.125, 0.250, 0.375, …). A dash crosses four tiles having dropped under 10 px because 8 px/tick outruns the fall. A walk drops into a three-tile gap. The engine's former "original-style ledge hop" and its last two hand-tuned scale factors are removed. Matching the reach then took two fixes:

  • Slope search over a gap (also in Reforged). Jazz2::Actors::ActorBase::TryMoveSubstep() takes the first free slope angle from the most downward. Over a gap all are free, so the actor dropped by the whole search range, deeper the faster it ran (17 px in one dash tick, into the far wall). A downward candidate now needs ground under it.
  • Landing tolerance: how far below a ledge's surface the player may arrive and still land on it. The original clears a two-tile walk (6.25 px below) and a five-tile dash (18.1 px) but fails a three-tile walk (20.25 px) and a six-tile dash (27.6 px): between 18.1 and 20.25 px, so Jazz2::Actors::Player::LegacyLandingTolerance is 20 (the engine had only the airborne climb, abs(stepX) + 2.5, about 6 px). Opt-in per actor (ActorBase::_landingTolerance, 0 by default). Only the non-Reforged player sets it.
  • Footing and walls: how far past the edge a standing player stays up, and how close it gets to a wall. Measured by placing the player still at every offset from a ledge on both sides (one script run in both games): the original holds 12 px past a right-hand edge and 11 px before a left-hand one. Walking and running into walls on both sides of one floor gives the same box: the original stops 12.2-12.4 px from a wall on its left and 11.2-11.4 px from one on its right. Ours used a 20 px box and stopped about 2 px too close on the left, so the hitbox is now 12 px left and 11 px right of the centre (Reforged too), see Jazz2::Actors::Player::HitboxLeft. Ours now stops at 12.0 on the left and 11.9 on the right, the right side keeps about a pixel more than the box because of how a blocked move ends.

All twelve scenarios (gaps of 1–6 tiles, each with a full run-up) now agree:

ApproachOriginalOurs
Walking (4 px/tick)clears 1 and 2, falls into 3same
Dashing (8 px/tick applied)clears 1 to 5, falls into 6same

Residual: the original keeps more speed after landing, so a run taking the four-tile gap and then the five-tile one clears it there and not here.

Jumping and air movement

Quantity3.8.0Original (70 Hz)Now (60 Hz)How far 3.8.0 was offHow far Now is off
Jump launch, standing−10.967−10.0−11.6667−6.0%exact
Launch bonus per unit of xSpeedmax(0, abs(xs) − 4) * 0.3abs(xs) / 4, no thresholdabs(xs) / 4wrong shapeexact
Rise gravity, jump held0.451010.3750.51042−11.6%exact
Rise gravity, jump released(speed clamped to −4.387)0.8751.19097wrong mechanismexact
Rise gravity, released, last px/tick(as above)0.6250.85069(absent)exact
Fall gravity0.166230.1250.17014−2.3%exact
Underwater gravity0.018790.015625 (1024/65536)0.02127−11.6%exact
Applied rise cap9.33338.09.3333correctexact
Terminal fall speed13.16012.014.0−6.0%exact
Air acceleration0.380 + skidsame as groundsame as ground(invented)exact
Standing jump height (end to end)(not measured)132.0 px132.0 px—exact

Releasing jump switches the rise gravity (0.375 → 0.875) from that tick on. It does not clamp the speed. That gives a tap hop its own arc and Spaz's double jump its hold-duration control.

Measured arcs (original): standing jump 132.0 px (4.13 tiles, apex at +27 ticks, airtime ~73 ticks), tap jump 72.9 px, walking jump 153.4 px (dx 312 px) and dashing jump 217.0 px (dx 752 px).

The rise, tick by tick

From ap_r01..ap_r30, thirty standing jumps released one tick apart. In the original's units, per tick:

if (ys < 0) {                                   // still rising
    brake = held ? 0.25
                 : (abs(ys) > 1.0 ? 0.75        // ... and the released rate eases off
                                  : 0.5);       //     for the last pixel per tick
    if (ys + brake > 0.125) ys = 0;             // the rise ENDS rather than overshooting
    else                    ys += brake;
}
ys += 0.125;                                    // gravity, every tick, rising or falling
y  += max(ys, -8);                              // the applied rise cap

This reproduces all thirty peaks to 0.01 px (58.87, 63.62, 68.00 … saturating at 132.00 from ap_r27). Its three non-obvious parts:

  • Two released rates: 0.875 while faster than 1 px/tick, 0.625 below (step 0.875 at ys = −1.125, 0.625 at −1.000). The held rate has no such band (379 samples).
  • No overshoot past one tick of gravity: from −0.375 a released rise lands on +0.250, from −0.250 and −0.125 on +0.125 (not +0.375 / +0.500). An overshoot would offset the whole descent.
  • The applied cap flattens the first six ticks: exactly −8.0 while ys reads −10.000 to −8.125, worth 6.375 px of the 132.

Gravity before the move

The standing jump used to peak at 128.0 px against 132.0, at every frame rate including 144 FPS. That ruled out the time step. The cause was the order of the update. The original applies each tick's gravity first and then moves by the new speed. The launch tick is the one exception, because the jump assigns its speed after that tick's gravity. A smooth integration of the same speeds, which is what the velocity-Verlet half step gives, peaks at the continuous limit instead: 8 × 16/3 + 8² / (2 × 0.375) = 128.0 px. The sum the original takes is 132.0.

Two changes make the engine take the same sum at any frame length:

  • In flight, the applied speed gets another half tick of gravity on top of the half frame. Over a frame of n ticks that moves the player by n·v + g·n(n + 1)/2, which is the original's per-tick sum with n read as a real number. See Jazz2::Actors::ActorBase::TryStandardMovement().
  • A jump or double jump launches one tick of gravity stronger, so the frame's first tick of gravity lands on the speed the original assigns. The speed logged after the launch is then the original's −10.000, −9.625, … exactly. See Jazz2::Actors::Player::BeginStandardJump().
  • The fall is capped before the move, as the rise already was. The original moves exactly 12 a tick at terminal speed and 10 in a buttstomp. The half steps used to carry the move past the cap, which was only applied to the speed afterwards: 12.125 and 10.13 a tick, +3.5 px over 24 ticks of a long fall. See Jazz2::Actors::Player::GetLegacyFallCap().

The standing jump now peaks at 131.98 px at 60 FPS (a_jump, ap_r30). The double jump reaches 217.1 against 217.4, and a fall from rest agrees to 0.02 px over 40 ticks (sp_copter_deep). Jumps released early still read 1.5 to 2.5 px low at 60 FPS (ap_r05, ap_r10). The probe's press and release land on frame starts, which shortens a five-tick hold to about 4.3 ticks.

What refuses the copter

Reported: pressing jump too early removed the copter for the whole jump. cp_tap* tap every six ticks from a start and never stop. cp_kill47..cp_kill80 press once, then nothing until a tap train from tick 80. cp_sj_* do the same from a two-tick jump instead of a five-tick one.

ScenarioEarly pressLater pressOriginal
cp_tap55taps from 55, never stops—never engages
cp_tap60taps from 60, never stops—never engages
cp_tap65nonefirst tap at 65engages at 66
cp_kill80nonetap train from 80never engages
cp_kill47inside the jump's own hold, no fresh presstap train from 80never engages
cp_kill52one tap at 52, during the risetap train from 80engages at 81
cp_kill58one tap at 58, during the risetap train from 80engages at 81
cp_sj_earlytaps from 50, never stops—never engages
cp_sj_latenonefirst tap at 60engages at 61
cp_sj_holdkey never released—never engages

There is no one-attempt-per-airtime rule (rows 6 and 7 disprove it). The cause is the ordinary jump cooldown, where even a press that does nothing pushes the window out: a tap train holds it open for the whole airtime, a single tap then silence lets it expire. Rows 4 and 5 fail the speed bound instead, nineteen ticks into the fall.

The window is re-armed by a press, not by holding. Both fit the table (every scenario taps), but re-arming on hold leaves a one-frame window per press — the reported copter that "gets ignored very often". Re-armed by a press, holding Jump opens the window 12.5 ticks in and keeps it open, so the copter can start on the way down. Rows 1, 2 and 8 stay refused. Re-measured: 18 of 20 cp_* within 25 px/s, median 6.0 (5.8 before).

The length is bracketed: 11 ticks after the key was last down is refused, 14 and 16 accepted, so Jazz2::Actors::Player::LegacyJumpCooldown is 12.5. The engine's own 10 frames (11.67 ticks) sits on the refused edge.

Air turn-around

With one shared table an air turn is symmetric, keeps its momentum, and is slow.

Swimming

3.8.0 had no water table: the walk cap horizontally, the Reforged MaxRunningSpeed unscaled vertically, and Run did nothing — twice the original's speed with nothing held, no faster with Run.

Quantity3.8.0Original (70 Hz)Now (60 Hz)How far 3.8.0 was offHow far Now is off
Swim cap, no Run4.0 horiz / 4.0 vert (unscaled)2.0 (both axes)2.3333+100% / +71%exact
Swim cap, Run heldunchanged4.0 (×2)4.6667−50%exact
Horizontal accelerationLegacyWalkAccel = 0.18310.0625 (the same with Run)0.0851+193%exact
Vertical acceleration0.2 (unscaled)0.125 (×2 with Run)0.1701+37%exact
Holding nothingdecayed to zerosinks at 1/64 for eversinkswrong shapeexact
Float-up field, submergedforce towards −6, then decayedys = -8, as in air−9.3333wrong shapeexact

Water is the vine rule, on both axes

Half the walk cap, the full walk cap with Run — the vine rule from Poles obey two different laws. The wt_swim_* caps read 2.0625 px/tick right and 2.1094 up, 4.0625 and 4.2344 with Run, because the original tests the cap before adding instead of clamping after: minus one acceleration step they are exactly 2 and 4. Land has no such overshoot (g_walk tops at 4.0000, g_dash at 16.0000), so it is reproduced for water only. The step is one tick's acceleration taken as a speed: ours used to add it at the acceleration scale and settled at 2.0723 and 2.1270 (4.0717 and 4.2722 with Run), 0.5–0.9% fast. The steering lag of The keys steer the tick they are read on had hidden that in the travel.

Horizontal acceleration is the same with Run, vertical doubles: wt_swim_right and wt_swim_right_run share one 0.0625 ladder for 32 ticks until the slower stops at 2, while wt_swim_up and wt_swim_up_run diverge on the second tick.

The pull is always there, and the stroke is added to it

Jazz2::Actors::Player::LegacyWaterGravity makes the vertical caps differ: 2.109375 px/tick climbing vs 2.140625 sinking, the stroke minus and plus 1/64. Build the cap from the net acceleration, not the stroke, or the asymmetry is lost.

Holding nothing, the original sinks at 1/64 a tick for ever (tail of wt_float_up). 3.8.0 decayed to zero and hung motionless. Standing on the bottom it reads ys = 0.0000 on every tick of wt_swim_down. This engine let the pull accumulate there invisibly, handed over on walking off a ledge, because Jazz2::Actors::Player::OnHandleWater() clears Jazz2::Actors::ActorState::ApplyGravitation for a swimmer and with it the landing path that would reset it.

A float-up field works underwater, and it beats every input

The original crosses a submerged ten-tile float-up column at a flat −8.0 px/tick, as in air, on every tick of all four wt_float_up* scenarios (swimming up, down, and with Run). The field overrides input.

The engine's legacy assignment was gated on ApplyGravitation, which water clears, so it fell through to a decayed force towards −6: a tenth of the speed, stalling 76 px short of the surface the original reaches in 53 ticks. Merely excluding the field from the water model is not enough: the generic branch's Deceleration then shaves the assignment to 7.811 px/tick (−2.4%).

The two birds

The original has two birds, JJ2+'s CHAR::BIRD (Jazz2::PlayerType::Bird) and CHAR::BIRD2 (Jazz2::PlayerType::Bird2), and only its JJMORPH cycle (Jazz - Spaz - Lori - Bird - Frog - Bird2) or a script reaches either (jjmorph cycles the same way). Here the Bird morph monitor gives the second one, the bird that shoots, and the first one is drawn with the yellow bird's sprites to tell them apart. Measured with the bd_* and b2_* sets, the two fly identically — xs and ys agree on every tick of all ten paired scenarios — and differ only in what Fire does. The flight is used in both modes. Reforged keeps its own walk cap as the bird's cap, which is the relation the original's figure has to its own walk.

QuantityFirst version (legacy / Reforged)Original (70 Hz)Now (60 Hz, legacy / Reforged)
Cap, both axes4.6667 / 4.04.0, clamped every tick4.6667 / 4.0
Horizontal accelerationthe walk's, 0.2492 / 0.20.125 (8192/65536), wound up over 4 ticks0.1701
Brake, no direction heldthe walk's, 0.1662 / 0.220.0625 (4096/65536), linear0.0851
Turning roundacceleration plus brakeno braking of its ownas the original
Up or Jumpaccelerated to the cap−1.0 assigned, flat from the first tick−1.1667
Nothing vertical heldbraked to a stoppulled down at 1/64 (1024/65536), unbraked0.0213
Downaccelerated to the cappulled down at 3/128 (1536/65536)0.0319
Runnothingnothingnothing

So the cap was right and everything about getting there was not: the original takes 34 ticks to reach it from rest (0.49 s, ours 0.31) and 64 to lose it (0.91 s, ours 0.47), and it climbs at a quarter of the cap where ours flew vertically as fast as horizontally — 70 px/s against 280.

The acceleration is eased, and letting go resets it

JJ2+ exposes the acceleration as xAcc, and it moves 1/32 px/tick² a tick towards ±1/8: bd_right reads 1/32, 1/16, 3/32, then 1/8 to the cap at tick 34. Reversing at the cap winds it over through zero the same way, so the speed holds at 4.0 for four ticks and then comes down on the same ramp (bd_right_rev, −4.0 at tick 170). Letting go zeroes it at once: bd_rev_tap releases for two ticks and the re-press starts again at 1/32. With no direction held the speed falls a flat 1/16 a tick.

The vertical axis is a pull, not steering

Up assigns −1.0 on its first tick whatever the speed was, and Jump is the same key (bd_jump is bd_up to the last tick). With nothing held the bird is pulled down at 1/64 px/tick² with no brake, so letting go of Up is a fall that only a floor ends — bd_up_rel lands at 1.47 px/tick — and Down only adds another 1/128. A bird on the floor keeps pressing into it: the original's y creeps down 1/64 px a tick and is put back every 32. bd_clamp writes 10 onto both speeds in mid-air and reads 4.0 and 4.0 on the next tick. Landing at 4.0 zeroes ys with no bounce.

A bird perches on its own

There is no landing as such. A bird still on the floor perches 37 ticks after its last movement — JJ2+'s idle counts them — in bd_idle2, bd_right_rel, bd_up_rel and bd_up_down alike. Moving takes it off on the same tick. Down, which cannot move it, does not (bd_down). The perched poses play at 7 ticks a frame, one whole animation at a time: idle, a look to the left or right (turn, look a few times, turn back), the worm, idle again. How often each repeats varies between runs, so UpdateBirdPerchPose() fits its odds to the counts. A perched bird stands where a rabbit does — every bird sprite's coldspot is 20 px under its hotspot — while the flying box ends 12 px down, so EnterBirdPerch() lifts it 8 px as the pose changes.

The two attacks

BirdFire doesMeasured on
BIRDNo shot, no round spent. Held while flying faster than 2 px/tick, the beak charge (below). Held at all, it keeps the bird from perching. JJ2+'s canHurt defaults to false for birds, so the beak does no damage. Ours hurts in Reforged only.bd_fire*, bd_perch_fire, bd_ch_*
BIRD2Two shots of the current weapon per press, none while held: straight and 0.2 rad below (1.957 / 0.398 for a Seeker), with the bird's horizontal speed added, one round for the pair. A press wakes a perched bird, holding does not keep it awake.b2_fire*, b2_perch_fire, b2_fire_turtle

Hurt is the same for both: a heart lost and the bird kept, thrown at the cap away from its facing and 4 upwards on top of its own ys, the rise then decaying at 17/64 px/tick² until it turns. The hurt pose lasts 70 ticks, 11 frames.

The beak charge needs speed, and cannot be slowed down

Reported from play as needing some minimum speed and as impossible to slow down once started. Both are true. Measured with the bd_ch_* set: Fire pressed at known speeds, from rest, in mid-air, coasting, leftwards, and then everything that can be done to a charge already under way.

QuantityFirst versionOriginal (70 Hz)Now (60 Hz, legacy / Reforged)
Starts whenFire held with a directionFire held and the speed above 2 px/tick, strictly, with or without a directionabove 2.3333 / 2.0, half the cap either way
Speed from then onthe speed it hadthe cap, put back every tick, so 2.06 becomes 4.0 in one tick4.6667 / 4.0
Vertical speed00, or −4 / +4 with Up (or Jump) / Down held, assignedthe cap, up or down
Direction let go, or reversedbraked, or turned roundno braking: each tick's move comes up 1/16 px short, or up to 1/8 reversed, and the speed reads 4.0 throughoutas the original
Facingturned with the directionthe way it flies, even with the other direction heldas the original
EndsFire or the direction let goFire let go, or the speed no longer above 2 — which only a wall doesas the original
Cooldownnonenone, a re-press two ticks later charges at oncenone

The threshold is tested on the speed the tick's own steering leaves, not the one the tick started with: a coast passes through 2.0625, exactly 2.0 and 1.9375 after the brake on three consecutive ticks, and Fire pressed on each charges on the first only (bd_ch_c70, bd_ch_c71, bd_ch_c72). It is a level and not an edge: Fire held from rest charges on the tick the speed passes 2 whether Fire or the direction went down first (bd_ch_rest, bd_ch_fire_first, bd_ch_f06..bd_ch_f14 all on tick 18), on the floor or in mid-air (bd_ch_air), and with no direction at all once the bird is fast enough (bd_ch_coast). Leftwards is the exact mirror (bd_ch_left_rest).

What makes it impossible to slow down is the order. The original steers and brakes as usual, moves the bird, and only then puts the charge's speeds back — so the brake and the reversed acceleration get one tick's say over each move and are then undone, and the climb and the pull never apply at all: Up pressed during a charge moves 0 px that tick and 4 the next (bd_ch_up, bd_ch_jump, bd_ch_down). HandleBirdMovement() does the same across two frames, deciding the charge at the end of one and carrying it out at the start of the next, once that frame's move has happened. The shortfall the steering leaves is converted as the speed it is, one tick's worth, rather than as the rate it is everywhere else, which would have flown a released charge at 3.926 instead of 3.9375 and made it depend on the frame length. The charge flies the way the bird is going rather than the way it faces: Fire pressed while turning round charges on in the old direction and turns the bird back to it (bd_ch_turn).

Against a wall the speed drops to 0, which ends the charge, and the original zeroes JJ2+'s xAcc there as well, held at 0 with the direction still pressed (bd_ch_wall). Our collision only reports a wall in OnHitWall() when nothing else was hit that frame, and a bird pressing into the floor hits that every frame, so in a floor-level corner the speed used to wind up against the wall — past the threshold, and a charge diving into such a corner never ended. The bird now looks a pixel ahead for a wall tile itself and takes both away.

The three poses are the set's first three animations, charge_diag_downright, charge_ver and charge_diag_upright (332, 333 and 334 in JJ2+'s numbering), and they share the flight pose's frame counter: JJ2+'s frameID carries straight across every switch between the four, so a charge starts on whichever frame the wings were on.

Not measured: whether the charge changes the hitbox, and what it does to an enemy when a script turns canHurt on.

The wings beat at one rate

The flight pose is a flat 7 ticks a frame at the cap, climbing, falling, braking and sitting with Fire held — there is no speed-dependent beat. Outside Reforged ours is that flat rate ("FrameRate": 6.25, from 5 * 70.021 / (8 * 7)). Reforged keeps a slower beat at rest, as asked for from play, up to that rate at the cap. The three charge poses, the perched poses and the hurt run at 7 ticks a frame too.

Objects

Quantity3.8.0Original (70 Hz)Now (60 Hz)How far 3.8.0 was offHow far Now is off
Spring, red — both axes7.090 vert / 11.111 horiz16.018.6667−62% / −40%exact
Spring, green — both axes7.847 / 11.11124.028.0−72% / −60%exact
Spring, blue — both axes9.774 / 11.11132.037.3333−74% / −70%exact
Vertical pole launch4*sign + entry*1.4, ×2.515.625 + abs(entry)18.229 + abs(entry)wrong shapeexact
Horizontal pole launch10*sign + entry*0.2 + force 10min(abs(entry) + 8, 20)min(abs(entry) + 9.333, 23.333)wrong shapeexact
Vine cap, no Run2.02.02.3333−14.3%exact
Vine cap, Run held3.2 (×1.6)4.0 (×2)4.6667−31.4%exact
Push speed (solid object)0.6 × timeMult0.3750.4375frame-rate dependentexact

Springs set the speed outright

No formula, no added external force: only the colour matters, with the same figure on both axes. The colours differ in how long they push, not in visible speed: the applied cap holds all three to 8 px/tick.

_verticalSpeedLimit is the original's 32 px/tick, i.e. 37.33 here — exactly a blue spring's launch, so a spring passes untouched while a pole is still clamped. The same figure bounds the horizontal axis. (32.0 cut a blue launch by 5.33 and a spring-fed pole came out 380 px low, while 64 never clamped a pole.)

Heights (the original's are linear in launch speed, +170.7 px per +8):

SpringOriginalOursDifference
Red (16)267.5 px282.1+14.6 (5.5%)
Green (24)438.4 px452.5+14.1 (3.2%)
Blue (32)609.0 px597.3−11.7 (1.9%)

The original holds the launch speed for two ticks before gravity, but this engine does not. A capped rise decaying at 0.375 predicts 256, 426.7 and 597.3: the original sits ~11.5 px above all three, ours matches it for blue. Adding the hold alone would fix blue and worsen red and green equally, so it is not applied.

Float-up areas hold a speed, they do not push

An EventType::AreaFloatUp assigns ys = -8 every tick the player is inside it — not an acceleration or force: a ten-tile column reads exactly −8.0000 on all 43 ticks, decaying only after leaving. It lifts a grounded player with no jump (pressing nothing traces identically to jumping).

3.8.0Original (70 Hz)Now (60 Hz)How far 3.8.0 was offHow far Now is off
force -2*g*timeMultys = -8 while insideys = -9.333wrong shapeexact

The test level's diagonal ladder now climbs 520.7 px against the original's 520.3 (the old force: 149.8).

A buttstomp re-asserts its own speed, so the original instead caps the movement at Jazz2::Actors::Player::LegacyFloatUpFallCap while the speed keeps climbing underneath:

WhereOriginal's ysOriginal's movementThis engine, beforeNow
Above the field1010 px/tick10 px/tick10 px/tick
Entering124 px/tick10 px/tick4.08 px/tick
Crossing164 px/tick10 px/tick4.08 px/tick

On fu_col_butt the original moves exactly 4.00 px every tick. The 176 px column takes 44 ticks against ours

  1. Entry speeds 6, 12 and 16 all give 4, so the lift is not simply subtracted. The cap applies to the buttstomp only. An ordinary fall touches it for one tick that the rise assignment overwrites anyway. A double jump needs no change: 261.1 px against 257.2 in a column.

No gravity on a tick inside the field. The original travels exactly the 8.0 it assigns. Ours travelled 7.79 because the velocity-Verlet half-step is folded in before the rise cap clamps it. Other launches are assigned above the cap and lose the half-step to the clamp, but this one equals it (Jazz2::Actors::Player::LegacyFloatUpSpeed and Jazz2::Actors::Player::LegacyRiseSpeedCap are both 8). Jazz2::Actors::Player::GetGravityModifier() returns zero inside one, before and after the move.

A sucker tube re-arms while you are inside it

The tube assigns a speed on each axis outright, and both games agree exactly (8 reads 8.0000, 20 reads 20.0000). A 30-tile row carries the player the whole length, so it re-assigns every tick inside. Single tubes hold 20 ticks at 8 px/tick and 18 at 20 — the difference being the extra ticks spent in the tile. Hence Jazz2::Actors::Player::LegacyTubeControlTime = 16 ticks, re-armed while inside. The window suppresses horizontal friction but not gravity: a vertical tube holds only while the player is in the tile, then decays at ordinary rise gravity.

Quantity3.8.0Original (70 Hz)Now (60 Hz)How far 3.8.0 was offHow far Now is off
Speed assignedxs = paramsamesameexactexact
Hold window10 ticks, fixed16, re-armed inside13.71 frames−38%exact
Speed on releasekept in fullclamped to the walk capclampedwrong shapeexact
Speed on release, Run heldkept in fullclamped to 16clampedwrong shapeexact

Without the release clamp a 20 px/tick tube carried the player 1066.9 px against 407.5. The Run row is inert for a tube but is one rule shared with the accelerating belt and the sidekick, Jazz2::Actors::Player::LegacyCarryExitRunSpeed. The walk-cap clamp alone cost tb_right_run 166.4 px against 222.9 (now 219.9). Wait Time is still a TODO. At 3 it changes nothing in either game.

Vertical hold position: Jazz2::Actors::Player::LegacyTubeSnapY. On tb_row the original sits at y = 1327.000 throughout, 15 px into the tile (ours used 8). The horizontal branch uses the tile centre. The ride matches to the digit.

The flying carrot is two accelerations

Scripted Jump does nothing while jjPLAYER.fly reads FLYCARROT (the flight reads the raw key, like the rev-up), so it was measured from hand-played recordings.

QuantityOriginalOurs before
RisingUp held, accelerating 0.25 px/tick to the 32 capno rise at all, Jump ignored
Still rising, Jump heldbrakes at 0.25—
Still rising, nothing heldbrakes at 0.75, clamped at zero—
Then fallingaccelerates 0.0625 to a terminal of 12hovers, no gravity whatever
Climb actually travelled8 px/tick, the ordinary applied cap—
Down helda fixed 1.0625 px/tick, assigned outrightfixed 3.429 px/tick
Horizontallyordinary ground movement — 4 walking, 16 with Run4
Durationuntil a Fly Off area or a deathten seconds
  • Travel is capped at 8 px/tick like a spring or dash (ys −27 while y moves 8). Climb rate 8.035 vs 8.000. Steps are clean: 934 ticks of exactly −0.25, 1243 of +0.0625.
  • A jump into the carrot decays at the ordinary 0.375 for the six ticks it is still a jump, then 0.25 once the flight animation takes over. Jumping while flying launches at −10.
  • Down assigns 1.0625 (from a 3.3125 fall, held 734 ticks). Releasing resumes normal fall acceleration from that speed. Not Jazz2::Actors::Player::LegacyCopterDescentSpeed (1.0078).

Ours: 0.2502 vs 0.25 held, 0.7507 vs 0.75 released, 0.0625 exact, a flat 1.0625 on Down, and the rise-to-fall crossing clamped to exactly zero.

The slide tile swaps the brake

A MODIFIER_SLIDE tile changes no speed: it replaces the no-direction deceleration, so a released player coasts further (EventType::ModifierSlide used to be read by nothing). Its 2-bit Strength scales both brakes linearly:

StrengthWalk brakeDash brake
— (no slide)800028000
0400012000
132009500
224007000
316004500

Units: 65536ths of a px per tick squared (4000 - 800*s and 12000 - 2500*s). Strength 0 halves the walk brake but takes the dash brake to 3/7, so no single "slide factor" fits both.

StrengthOriginalOursBefore
0645.7 px653.5587.8 (no slide at all)
1678.5 px686.2—
2733.1 px740.7—

Travel after letting go. The ~1.2% residual is ordinary deceleration discretisation. See Jazz2::Actors::Player::LegacySlideWalkDecel.

Wind and belts move the player, the accelerating belt drives them

Wind and belts move the player by position (the original's xs stays 0.0000), while the accelerating belt works on the speed.

Quantity3.8.0Original (70 Hz)Now (60 Hz)How far 3.8.0 was offHow far Now is off
Wind, per unit of strength0.7 px/tick0.50.5833+20%0.2%
Belt, per unit0.7 px/tick1.01.1667−30%0.1%
Belt strength, no parameter322+50%exact
Accelerating belt, per unitxs += 0.1, uncapped1.5 px/tick, held1.75wrong shapeexact
Acc. belt step, per unit0.1/frame, unscaled0.5 px/tick^20.6806frame-rate dependentexact
Acc. belt strength, no parameter344−25%exact

Fitted on two strengths each: wind 8 → 4.0 and 4 → 2.0, belt 8 → 8.0 and parameterless → 2.0. Wind and belts share an event type here but not a strength: a belt pulls twice as hard as a wind of the same number.

Steady speed and cap are exact at both strengths. Travel is within 1.4-3.7%, the rest being the first two or three ramp ticks, where ours runs a third of a tick ahead.

The exit clamp has two targets: with Run, 18 and 24 snap to exactly 16 and decay at the dash brake, while without, 6 and 12 snap to 4 at the walk brake. A tube (8) and Spaz's kick (15.88) never reach

  1. All three share Jazz2::Actors::Player::LegacyCarryExitRunSpeed.

With Run the original also travels less than it reports, and it is a ceiling, not a subtraction: on bl_acc_right_run travel follows xs (5.145, 6.719, 8.291, 9.863) and then flattens at 10 while xs goes on to 18. The ceiling is the belt's strength plus the walk cap, Run bonus excluded (ours used to be exempt):

StrengthRunReportsTravelsCeiling (strength + 4)
4—6610, never binds
8—121216, never binds
4held181010
8held241616

A one-way floor is passable to the body and solid to the jump

Both games let a rising player through a one-way platform and catch a falling one frame for frame (ow_hop: same tick, rest 2 px apart). Down never drops through (ow_down, ow_down_fall). The difference is the jump test: the platform still counts as ground, so crossing one with jump held launches a fresh jump (on ow_jump the rise resets to exactly −10 at rows 31 and 29), and a ladder of them climbs by holding the key.

QuantityBeforeOriginal (70 Hz)NowBefore was off byNow off by
Rise through onepassespassespassesexactexact
Fall onto onelandslandslandsexactexact
Down while standing on onestaysstaysstaysexactexact
Down through the fall onto onelandslandslandsexactexact
Jump held, climbing the ladder1 launch, row 297 launches, row 10.45row 10.514.5 tiles short2 px
  • Jazz2::Actors::ActorState::CanJump cannot carry this: it is cleared whenever _speed.Y < 0 and selects the ground-bound slope path in Jazz2::Actors::ActorBase::TryMoveSubstep(), which would snap a rising player onto the platform. Only the relaunch reads Jazz2::Actors::Player::IsOnLegacyOneWayFloor(): the grounded box below the feet, tested with and without Downwards. Solid only with it means one-way (a single test would also catch the floor a jump just left and relaunch every frame).
  • The relaunch runs at the end of the update, not in Jazz2::Actors::Player::HandleJump(), since the original tests where its move ended. No _jumpTime gate: the original's gaps are 7, 9 and 12 ticks and the 10-frame (11.7-tick) cooldown would swallow two.

Poles obey two different laws

So poles compound. Heights against a single pole's 268.6 px:

SetupHeightLaunch
2 poles chained440.6 px (13.8 tiles)−23.375
3 poles611.1 px (19.1 tiles)−24.5
5 poles951.4 px (29.7 tiles)−26.75
Blue spring → 1 pole804.5 px (25.1 tiles)−40.125

Grab to launch takes ~140 ticks, so the probe gives pole scenarios a longer window.

EntryOriginal launchOurs beforeOurs now
0−8.00.0−8.0
4+12.0+12.0+12.0
16+20.0 (clamped)+20.0+20.0

At zero it launches left whatever the facing or arrival side: Jazz2::Actors::Player::LegacyHPoleLaunchBonus plus a strictly-greater comparison on the entry force. Without them the player sticks on the pole for ever (_lastPoleTime excludes the tile for only 10 ticks, a re-grab every 70).

What a pole launch decays at

A pole launch (−22.25 in the original) decays by exactly 0.875 a tick over 25 ticks — the released rise gravity, even with jump held — at 8.00 travel under the applied cap. This engine used 0.375 and the error compounded down chains. The launch now hands over in the released state:

SetupOriginalBefore the ascent fixesNow
1 pole270.4 px480.7270.6
2 poles440.6 px772.6442.7
3 poles611.1 px932.5614.8
5 poles951.4 px529.21009.0 (+6.1%)
Blue spring → 1 pole804.5 px539.4806.3

The spring-fed row was fixed by _verticalSpeedLimit (Springs set the speed outright). The five-pole residual is grab timing (below), and 951.4 px is the clean reference, not the old 1011.2.

Five-pole chain, launch by launch:

PoleOriginal launchOursDifference
1−22.250−21.2461.004
2−23.375−22.5650.810
3−24.500−23.8840.616
4−25.625−25.2030.422
5−26.750−26.5220.228

The original grows exactly +1.125 a pole, ours +1.319, converging to 0.85% by the fifth. Spacing (160 px) and the final free ascent (205 vs 204 px, 0.875, 8 px cap) match.

The residual is when the pole is grabbed. The original jumps at −10, rises at 0.375 with the 8 px cap, is at y = 1253.75 doing −6.625 the tick before the grab, then snaps to y = 1231.00 (the tile centre) with 6.625 as entry speed. Ours grabs ~a tick later, 5.7 px higher at 5.62, so one pole launches 4.5% weak. The fix is in shared event-detection geometry relative to the hitbox, not a movement constant.

Push speed was frame-rate dependent

3.8.0 computed pushSpeedX * 1.2 * timeMult, making pushing 2.5× faster at 24 FPS than at 60. The original is a flat 0.375, player and object together, and Run makes no difference (walking into a box and dashing into a rock push at the same rate).

Special moves

Quantity3.8.0Original (70 Hz)Now (60 Hz)How far 3.8.0 was offHow far Now is off
Buttstomp descent10.96710.0 (all three characters)11.6667−6.0%exact
Buttstomp descent, held(accelerated)governed: 10.0 every tick11.6667 every tickran away to the fall capexact
Buttstomp sideways drift0.2 * movement, ×2.6 Run0.18311, ×2 Run0.21362 / 0.42725−6.4%, Run ×1.3 too strongexact
Copter descent1.51.0 (Jazz = Lori)1.16667+28.6%exact
Copter horizontal(unrestricted)walk accel and walk capsame(uncapped)exact
Uppercut launch−2.4127 + external force −1.4476−6.59375 of travel−7.6927wrong mechanismexact
Uppercut gravity while driving(ordinary rise gravity)0.03125 (2048/65536)0.042535~12× too heavyexact
Uppercut driven length(until the rise decayed to −2)30 ticks25.7 frames(absent)exact
Uppercut height (end to end)189.4 px228.3 px228.5 px−16.4%+0.1%
Spaz double jump launch−0.6 + internal force −1.15−8.0−9.3333wrong mechanismexact
Spaz double jump horizontalclamp(x * 0.4, -1, 1)00damped, not droppedexact
Spaz double jump window(none)falling, ≤ 29 ticks after the release≤ 25.7 frames(absent)exact
Spaz sidekick speed14.416.018.6667−22.9%exact
Spaz sidekick driven distance~1728 px (timeout 120)440 px, then coasts to 504440 px, coasts to 503.2+243%−0.3%
Lori kick speed9.3 flat(n/2)² ramp, peak 42.25ramp, peak 49.29wrong shapeexact
Lori kick distance~372 px (timeout 40)204.75 px204.8 px+82%+0.02%
Lori kick period(input-paced)45 ticks44–45 ticks(absent)−2% to 0%
Special move asked for mid-slidefull uppercut/sidekickrefused, 8 px hop, then buttstomprefused, 3.5 px hop, then buttstomp201 px of rise, 700 px of kickhop −56%
Shot fired while looking up, slidingfiresfiresfires(agrees)(agrees)
Kick against a pushable, Lori(stops dead)4.5 px per kick, 12 ticks4.7 px, 12 ticksno push at all+4%
Kick against a pushable, Spaz(stops dead)19.1 px, 51 ticks21.2 pxno push at all+11%
Pushed object's own rate0.4286 (a per-frame 0.5)0.375, the player's own0.375+14%exact
RF blast throw speed(one-off force 4)8.09.3333wrong mechanismexact
RF blast hold before friction(none)30 ticks25.7 frames(absent)exact
RF blast upward kick, airborne(none)12.014.0(absent)exact
RF blast reach~52 pxblasts at 36, not at 4832 pxtoo generousfitted
RF blast travel (end to end)(a few px)~302 px304.9 px−99%+1.0%

Buttstomp drift bypasses the speed

The original moves the position directly and keeps xSpeed at zero for the whole stomp. A hold phase (ys = 0.0625 for ~30 ticks) precedes the descent.

Powerup monitors

Both games agree that walking into a monitor pushes it (pu_walk: 289.6 px here, 290.6 there), a buttstomp breaks it in neither (the player stands on it), and an uppercut beside one does nothing. Differences:

  • A resting monitor sits at y 1968.9 here, 1975.0 there (floor surface 1984): 6 px higher, an object height difference. Still open.
  • A monitor spawned above the player stays there in the original (mb_stomp: the morph box holds at its authored y 1903 on the head of a player at 1970). Ours drops to 1968.9, overlapping the player at 1968.5. Possibly the reported "morph box floating" (not established).

A warp hands control back almost at once

The original lands on tick 73, shows one frame of the warp-out pose on 74, and walks on 75. Ours waited out the whole Jazz2::AnimState::TransitionWarpOut animation (38 ticks). Now the pose and its idempotent callback still run, but Jazz2::Actors::Player::LegacyWarpOutControlTime returns control, invulnerability and gravity first.

  • Jazz2::Actors::Player::SetPlayerTransition() with removeControl zeroes _controllableTimeout: arm the timeout after the transition.
  • A frozen exit keeps control away (Freeze() in the callback). The checkpoint respawn shares the path and also returns control promptly, deliberately.

Result: 5 ticks against 3, the rest frame quantisation. wp_walk drift went from 305 px to 90.

A special move wants the player stopped, but the crouch does not

The crouch engages as soon as no direction is held, keeping the remaining speed (a run ends in a slide, and the crouched gunspot fires low and moving). The special move does not follow during that slide: the original's specialMove stays 0 (all three characters, Down held through a dash, Jump 4 ticks later) and an ordinary jump launches at −13.08 with 12.33 px/tick under it (Jazz2::Actors::Player::LegacyJumpSpeed plus the usual quarter-of-horizontal-speed boost). Down is still held, so a buttstomp follows: hold at 0.0625, descent at 10, landing, crouch.

Ours now hands over to the standard jump and re-arms the Down edge (_wasDownPressed, set when the crouch engaged, would swallow the stomp). The boundary is Jazz2::Actors::Player::StopSettleSpeed rather than 0, since our 60 Hz decay reaches 0 on a different frame. Residual: hop 3.5 px against 8, travel 39.6 against 48. The sequence and the 10 px/tick descent match, only the one tick of rise before the stomp is short.

Spaz's double jump

A straight speed assignment like the first jump (3.8.0 used a small speed plus internal force, too weak). Height depends on how long the key is held, via the same released-gravity switch.

The horizontal speed is thrown away: a dashing double jump leaves at zero and rebuilds from air acceleration. sp_dj_a_dash reads xs = 16.0000 before the press and 0.3662 (one dash acceleration step) after. Walking, a 0.1831 step. 3.8.0 only damped it (clamp(_speed.X * 0.4, -1, 1)).

The trigger window is a timer, not a band of fall speeds. Both conditions are required:

  • The player must be falling, read from the vertical speed at the start of the frame: the original applies gravity after the test, so a press at the exact apex reads ys = 0.0000 and is refused.

  • The press must come within Jazz2::Actors::Player::LegacyDoubleJumpWindowTime (30 ticks) of the jump key being let go: set on the release tick, decremented at the top of each later tick, tested for "above zero", so 29 ticks later is the last press accepted.
First press released atDelays that fireDelays that do nothingScenarios
tick 5015, 25, 2930, 35sp_dj_r50_*, sp_dj_hold and the direction family
tick 602830sp_dj_r60_*
tick 725, 10, 20, 22, 25, 28, 2930, 40sp_dj_d*, sp_dj_a_*
tick 8510, 20, 25—sp_dj_r85_*

sp_dj_r60_d28 fires at a fall speed of 3.00 where sp_dj_hold is refused at the same 3.00. Release at 85 fires at ~4.0 and 4.6 px/tick. Height above ground (accepts at 81 px, refuses at 85) and time since the apex (accepts at 27, refuses at 20) are ruled out too.

Pinball paddles and bumpers

So the paddle carries the player itself at surfaceY = pos.Y + 0.3 * (distance - 16), removing their vertical speed, except while a launch is in flight. That also reproduces the original's from below case: the player appears on the surface one tick later, 27 px higher.

The launch is assigned, linear in the distance from the mount on both axes, with a floor (original units):

Distance from mount243240485664
Right paddle, ys−7−15−23−31−39off the end
Left paddle, ys−9−17−25−33−41off the end
Right paddle, xs−0.4688−0.7188−0.9688−1.2188−1.4688—
Left paddle, xs+0.5313+0.7813+1.0313+1.2813+1.5313—

So ys = -max(4, d - 16) and xs = ±max(0.5, (d - 8) / 32), away from the mount. The paddles differ by a constant 2 units vertically and 1/16 horizontally (mirrored pivot pixel). One mirrored formula, ours, is within a unit of both everywhere.

The player stays in the sucker tube's curled-up ball the whole time they are on a paddle, chosen in UpdateAnimation() with the lift poses (anything the paddle assigns directly is overwritten next frame).

speed = (playerPos - bumperPos + 1) / 4      // both axes

Every hit fits to four decimals: centre drop caught 36 px up → −8.75, 16 px aside and 28 px up → (−3.75, −6.75), from below 47.25 px down → +12.0625, and offset (0.134, −38.12) → (0.2834, −9.2803). 3.8.0 used a normalised radial impulse × 15: wrong shape, 35% weak.

The +1 is what lets a player escape. Without it a centre drop is a fixed point (ours bounced 13 times in 800 ticks). The original throws the player clear after about eight bounces, ours now in six.

Open: the catch point sets the strength, 36 px above centre in the original and 30 here (−8.75 against −7.25), and the original's trigger is not quite a radius (28 px up at 16 px aside). Needs a slow-drift scenario.

Hitting your head on a ceiling

Bays 2 tiles wide clearing 2 to 6 tiles. A standing jump rises ~132 px. A strike stops the ascent at the tile and the fall starts there. Nothing else changes.

ClearanceOriginal riseOursStruck
2 tiles40.0 px40.7 pxyes
3 tiles70.1 px72.7 pxyes
4 tiles104.2 px104.6 pxyes
5 tiles132.0 px128.2 pxclears
6 tiles132.0 px128.2 pxclears

The clearing rows show only the usual standing-jump residual (as in sp_jazz_dj). Walking and dashing agree (apex 345.1 against 347.4, 366.5 against 366.3), read heading west. Spaz's double jump agrees at 2 to 4 tiles (see Spaz's double jump for 5 and 6).

Lori's kick accelerates

Speed is exactly (n/2)² px per original tick (6.25, 9, 12.25, 16, 20.25, 25, 30.25, 36, 42.25): a 13-tick ramp summing to 204.75 px, and the only move exempt from the applied cap (its last tick travels 42 px). Spaz's is a flat 16 travelled at the capped 8. A flat speed matching the distance covers it in a third of the time: endpoints hide a wrong curve.

She kicks repeatedly while Down and Jump are worked: 45 ticks apart (t48, 93, 138, 183, …) against a press every 15. That is just the move's length. Holding control for it and requiring the crouch before the next press gives ours t42, 86, 131, 176. Do not add a cooldown (one stretched the gaps to 75).

Spaz's sidekick drives, then coasts

A flat 16.0 (8.00 px/tick travelled, the applied cap) from t56 to t110, then a drop to about 4 and decay at ~0.122/tick, the plain walk deceleration. The constant is the driven part only, 440 px. Ending the move snaps him to the walk cap (Lori zeroes instead, as coasting from 42.25 would go tiles too far) on the tick the countdown runs out. Total 503.2 px against 504.5, coasting 4.17 → 3.34 → 2.84 → 1.67 → 0.84 → 0 as in the original.

With Run held (sp_side_run) he leaves at 15.88 and decays at the dash brake 0.4273, 664 px against 456. With a direction too, he keeps dashing at 16. The snap's second target, 16, only matters for the accelerating belt (carry 18 and 24). All three sites clamp to Jazz2::Actors::Player::LegacyCarryExitRunSpeed, kick unmoved at 660.0 px.

A kick shoves a pushable, at walking pace

Both kicks push a pushable rock in the original at the ordinary Jazz2::Actors::Player::LegacyPushSpeed, 0.375 px per original tick, the player creeping along with a speed column of zero (position-driven). _controllable and _isActivelyPushing used to block it. Pushing is now allowed while the kick has budget left, not during the recovery after it:

  • Lori spends her 204.75 px in twelve ticks, then recovers: 4.5 px per kick, 96 px over 22 kicks.
  • Spaz runs out as his move ends: 4 ticks of drive plus 51 of pushing (55 = 440 px at 8 px/tick), 19 px.

A blocked kick spends its budget on what it meant to travel: billing the actual crawl makes it never end. Also fixed:

Result: 22 bursts against 22 on the same ticks (76, 111, 146, …, 741, 776), 4.7 px against 4.5, the rock ending at 2891 against 2882.

Deliberately not reproduced: the original drives the player into the object (Spaz 21 px, Lori to 4.7 px from its centre), a collision bug. Single-kick scenarios therefore stay a few tiles short on distance. Do not close that gap.

Bouncing off a wall onto a ledge

Dash at the wall at the right end of the upper floor, jump, and turn back onto the platform six tiles up: a combined check of the air-turn and launch-bonus constants. Distance from the wall decides it: flat against it there is no speed bonus and the jump reaches 132 px instead of 209.

JumpOriginal peakOursOriginal outcomeOurs
8 tiles out706.3707.1over the platform, falls past itsame
5 tiles out709.9708.6lands, then walks off the edgelands, stays
2 tiles out710.3706.9lands on the platformlands on the platform
flat against the wall782.5784.5no speed bonus, falls shortsame
walking, near the wall761.8764.1falls shortsame

The 5-tile case lands within 2 px of the original on the platform's edge. Walking off it is a knife edge.

Jazz's uppercut is nearly weightless

An impulse under very low gravity (ys never reads below −7.5, yet it climbs 228 px):

  • Wind-up: about 14 ticks without moving.
  • Driven climb: exactly 30 ticks at gravity 2048/65536 = 0.03125, a twelfth of the rise gravity.
  • Ordinary gravity from the end of the move, with about 5.7 of rise left.

3.8.0 (small speed + external force, ending at −2) was 16% short, now 228.5 px against 228.3. Unresolved: the original reports ys −7.5 → −6.59 while travelling 6.59 → 5.69 per tick, a ~0.84 offset. Jazz2::Actors::Player::LegacyUppercutSpeed follows the travel.

A ceiling ends the move at once: Jazz2::Actors::Player::OnHitCeiling() calls Jazz2::Actors::Player::EndDamagingMove(). Reforged needs no cancel, as it ends once the rise passes −2. A shot from the last phase takes the pose: see A shot needs a shooting pose on screen.

Bouncing off an enemy you buttstomped

On the level's own tube turtle, dropped from 420 px: the stomp arrives at 10 px/tick, leaves at a flat −13, and decays at exactly 0.875/tick with travel capped at 8 px.

Quantity3.8.0Original (70 Hz)Now (60 Hz)How far 3.8.0 was offHow far Now is off
Bounce speed-0.6 * impact13.0 flat15.1667wrong mechanismexact
Bounce decay(held rate)0.875 (released)1.19097wrong rateexact
Rise after the bounce~48 px78.4 px82.2 px−39%+4.8%

The bounce exceeds the always-10 impact, so no impact factor works. The +4.8% is discretisation: ours hits the analytic 82.3 px, while the original's stepping loses ~4 px.

  • Use an enemy the level contains. One spawned with jjAddObject is inert in the original. Both probes find the level's own object by scanning the event map at prime (as for pushables).
  • The ascent decays at the released rate, like a pole launch and unlike a spring, so _jumpReleased is set. See What a pole launch decays at.

Blasting yourself off a wall with an RF shot

An RF fired into a nearby wall snaps the horizontal speed to exactly 8.0 (the applied cap) and holds it 30 ticks with friction and direction keys suppressed, even on the ground. Then it snaps to the walk cap and decelerates at the walking rate like the sidekick, ~302 px in all. Airborne it also assigns ys = −12, and the rise decays at the released rate even with jump held. See Jazz2::Actors::Player::LegacyRFBlastSpeed and Jazz2::Actors::Player::ApplyBlastKnockback(). Ours: 304.9 px against ~302 (3.8.0: a force of 4, a few px).

  • Direction comes from the shot's travel, not positions: point blank it can rest behind the player.
  • Reach is one tile: thrown at 24 and 36 px, not at 48 or 64. The engine's box search reached ~52 px, so the distance is re-tested against Jazz2::Actors::Player::LegacyRFBlastReach.
  • Measure from a standstill: a dashing shot inherits the speed and detonates at a different distance.

Re-run at whole tiles with ammo logged (to tell "no blast" from "not fired"):

DistanceOriginal pushOursPeak speed, originalOurs
1 tile (32 px)−299.5 px−306.2 px560.2 px/s560.0 px/s
2 to 6 tilesnothingnothing——

The airborne blast matches every constant (wb_rf_j0): ys = −12.0 (−14.0 here), decay 0.875 (1.1921 here), the jump before it at the held 0.375, fired on tick 169 on both sides. The peaks (original 168.6 px, ours 101.4) differed only because ours detonated on the firing tick and the original's nine ticks later: shot flight time in RFShot, not knockback.

Features the original does not have must not read the legacy constants

The ledge climb is this engine's own: one assigned speed, gravity off, so height = speed × animation length. A frame of gravity once added to its -1.4 made it frame-rate dependent, and folding that in as GetGravityModifier() instead of the level gravity used the original's rise gravity, 3 to 5 times heavier:

Rise folded inValueClimb speedHeight
Intended (level gravity)0.24−1.1644 px
GetGravityModifier(), jump held0.51042−0.89034 px
GetGravityModifier(), jump released1.19097−0.2098 px

_jumpReleased is set by nearly every approach, so the climb rose 8 px and missed the ledge. It now reads the level gravity: −1.16 non-Reforged, −1.10 Reforged, 44 px at 24, 60 and 144 FPS.

The camera

Both probes log camx / camy (the camera's offset from the player) on every scenario, so the whole matrix is camera coverage too, and there is no cm_* family. The camera is gated on Jazz2::PreferencesCache::EnableReforgedCamera, not EnableReforgedGameplay, because it is local and purely visual. A configuration written before the split derives it from the gameplay setting.

QuantityReforgedOriginal (70 Hz)Now (60 Hz)How far Reforged is off
Horizontal lead, walking80.3 px28.0 (32 from a tick ago)27.6–28.0+187%
Horizontal lead, dashing143.6 px120.0 (128 from a tick ago)119.4–120.0+20%
What the lead is aimed atthe speed8 × the speed, in the direction heldthe samewrong input
Step towards iteased, 0.04/frameeases halfway to a limit each tick, at most half the gapthe samewrong shape
Limit of the step—1 held, 2 released or behind, 4 held against the travelthe same(absent)
Following the playerlocked ona tick behind, on both axesthe same(absent)
Vertical lead±24 px deadzonenone, except the buttstompthe samewrong mechanism
Lead during a sidekick117 px and climbing0 (−8 of lag)the same(invented)

Against the original's traces the 70 FPS medians are 0.55 px horizontally and 0.70 vertically, the remainder being whole-pixel snapping (std::round on the lead, std::floor on the camera). A scenario's camera depends on the one before it, so compare only scenarios that start in the same state on both sides; the probes' settles do not guarantee that.

The lead follows the input, not the speed

Reforged computes its lead from GetSpeed(), while the original aims it at the direction being held:

  • g_dash_rel releases the direction while coasting at 9.6 px/tick: the lead collapses to zero.
  • g_dash_relrun releases only Run: the lead grows on to 65 px and closes only once Jazz2::Actors::Player::UpdateDashState() clamps the speed to the walk cap. The target's size follows the dash, while its existence follows the key.
  • A sidekick carries 16 px/tick with nothing pressed, so the original does not pan (sp_spaz_side_rel reads a flat -8.00, one tick's travel behind). Reading the speed ran the lead to 117 px and back, the reported forward lurch. The same applies to any move carrying speed the player did not ask for.

Held against a wall the original's lead returns to zero at its 1 px/tick limit (an_side_cancel: +69.6 px at contact, then −0.997 a tick). That needs no rule of its own: against a wall the speed is zero, so the target is.

How the lead gets there

Read in the lead from the player's previous position, L = camx + dx, the original is one rule per axis, once per tick:

dir  = sign(target - L);
step = (step + dir * limit) / 2;           // the step eases halfway towards the limit...
if (dir * step > abs(target - L) / 2)
    step = (target - L) / 2;               // ...but never takes more than half of what is left
L += step;

Horizontally the target is 8 × the speed (px/tick) with the direction held and the speed going that way, and 0 otherwise. The limit is 1 with the direction held, 2 with nothing held while moving or with the lead on the wrong side of zero for the key, 4 with the key held against the travel, and 1 standing with nothing held. Both the key and the speed are read a tick late. The flat 28/120 of the previous model were this target at the two speed caps, with the 1 px limit hiding the rest. The dash start shows it: a lead inherited from the scenario before shrinks until 8 × the speed overtakes it, and it went −4.59, −2.79, −1.90, −1.45, −1.23, −1.09, then −0.04, +0.48, +0.74, all of which the rule reproduces.

The difference that showed in play is the turn. Reversing out of a dash, the original's lead collapses at 4 px/tick and sits one tick's travel behind until the player moves the new way, then ramps out. Ours ramped towards the new direction through the whole skid: g_dash_opp was 13.7 px off and is now 1.1.

Vertically the camera is the player, a tick late

Through a jump the original's camy is exactly minus that tick's dy (+7.75 at the launch, −4.38 falling at 4.5 px/tick), so it is the player's position a tick earlier, with no deadzone and no lead. The buttstomp drop is the same rule as horizontally, aimed at 60 px, with a limit of 4 for its first 16 px and 2 after that, and 4 on the way back.

Reforged's ±24 px deadzone holds a stale offset: an offset acquired inside the band is never corrected below Jazz2::Rendering::PlayerViewport::VerticalRecenterThreshold. A probe scenario inherits 21 px from the previous one and keeps it. Through a jump it swings from +21 to −22.

The run-in-place rev-up

Tapping Run on the spot winds the player up and launches them into a run. It was missing entirely, so unlike the rest of this page it is live in both modes.

QuantityOriginal (70 Hz)Now (60 Hz)How far Now is off
Launch speed, full charge16.0 (the dash cap exactly)18.6667exact
Launch speed, minimum~7.08.1667within ~0.5
Time to full charge~90 ticks77 frames±1 tick on the launch
Launch delay after the last tap~20 ticks18 frames2 ticks
Tap gap that sustains the wind-up≤ ~16 ticks≤ 21 ticks(see gaps)
Hold before the speed drops**~320 ticks**, then a single-tick snap to the walk cap274 framesexact

The wind-up is entered on a charge, not a tap count: a press adds a fixed amount, holding adds more up to a cap per press, and it bleeds away while the key is up.

ObservationWhat the accumulator says
Two taps never start it, however spacedTwo presses reach 8.9 against a threshold of 14
Three do, if the last is held longerThree reach 12.6, and holding the last adds up to 4 more
Four do without holdingFour reach 16.4
Gaps of ~20 ticks or more never start itThe decay outruns the gain between presses
Tapping faster reaches it soonerLess decay between presses
Holding Run alone never starts itOne press is capped at 4 + 4 = 8
There is a grace in which a tap resumes a wind-upThe charge has not decayed to nothing yet
  • A separate timer decides the launch, refreshed by each press and by holding, running only once the wind-up is up.
  • Charge follows time, not taps: 15 taps over 75 ticks launched at 15.87, while 12 over 106 reached 16.0.
  • The launch is not steerable: it goes the way the player faces, whatever direction is held. The hold ends in a single-tick snap to the walk cap (the dash grace's behaviour), so the launch arms _dashGraceLeft as well as _keepRunningTime.

Replaying the recording

The rt_rec scenario replays the twenty tap offsets of one recorded burst verbatim, each press held five ticks as recorded, so the traces compare tick for tick:

QuantityOriginalOurs
Launch, ticks after the first tap227229
Launch speed16.000018.6667 (= 16.0 converted)
Animation order53 → 54 → 55 → 60RevUpStart → RevUp → RevUpEnd → Dash

The animations are the original's revup_start / revup / revup_end, already exported for all three characters but with no Jazz2::AnimState until now. Both transitions must be non-cancellable: UpdateAnimation() changes the base state on the next frame, which would cut each to a single frame.

Sliding to a halt is a chain of three

Releasing the direction key, the original shows three animations on the way down:

  1. walk_stop — the skid, played once for its own 12 ticks, from any speed.
  2. dash_stop — looping while the speed is at or above Jazz2::Actors::Player::LegacyStopWalkSpeed (1 px/tick), entered only if the speed is still that high when the skid ends.
  3. run_stop — once, 32 ticks, then standing, although the speed hit zero about 24 ticks in.
ScenarioReleased atSkidThen
an_slide_stop16 px/tickticks 91–102dash_stop 103–130, run_stop 131–162, standing 163
g_walk_rel20421–32dash_stop 33–44, run_stop 45–76, standing 77
sd_walk (on a slide tile, so it decays half as fast)446–57dash_stop from 58
tb_right1.838–49nothing (the skid's last frame held to tick 52, standing 53)

The skid is twelve ticks at every speed and on a half-deceleration tile. Speed only decides how much of the chain follows. Ours reproduces all four within a tick of entry lag.

Implementation details:

The stop poses run at 4, 7 and 4 ticks per frame, not the sprites' JJ2 frame rate 10 (the original drives them from code). Each Player<Character>.res stores them via AnimDuration = 5 / FrameRate, per character since frame counts differ.

Speeding up is three bands

The spinning-feet animation between walking and dashing is a speed band, not a transition. an_run_start, Right and Run pressed at tick 20:

BandOriginalOurs
runtick 22, up to 4 px/tick23
dash_start (spinning feet)tick 32, 4 to 8 px/tick33
dashtick 43 (23 ticks after the key)44 (24)

As Jazz2::AnimState::TransitionRunToDash on entering Jazz2::AnimState::Dash it played all eight frames (34 ticks), so dash arrived 47 ticks after the key. The band is Jazz2::Actors::Player::LegacyDashAnimSpeed, and the transition is now Reforged-only.

The run animations play at the speed of the player

A run-animation frame lasts max(1, 12 - |speed|) ticks in the original. The assets do not encode it (run.aura, dash_start.aura, dash.aura carry the converter's flat fallback: 0.5 s, 0.4531 for Lori). Measured across all committed original traces, both characters agreeing:

Speed (px/tick)23491011 and up
Ticks per frame1098321

Whole loops agree: walking (8 frames at 8 ticks) is the 63-tick loop of g_walk, dashing (4 at 1) the 4-tick loop of g_dash. Ours were 42.0 and 17.1. Implemented by Jazz2::Actors::Player::UpdateLegacyRunAnimSpeed() with Jazz2::Actors::Player::LegacyRunAnimFrameTicks and Jazz2::Actors::Player::LegacyRunAnimMinFrameTicks.

  • Rescale the duration, never assign it: the frame shown is AnimTime / AnimDuration, so changing the duration alone teleports the animation. Scaling the time by the same factor keeps the phase.
  • Reforged's rule is turned off, not overridden: the "adjust walking animation speed" line at the end of Jazz2::Actors::Player::OnHandleMovement() stamps AnimDuration for Jazz2::AnimState::Walk after Jazz2::Actors::Player::UpdateAnimation(). Left in, the phase compounded 46% a frame and the walk ran nine times too fast.

At 60 FPS one frame is 1.167 original ticks, so a one-tick cadence is impossible and g_dash measures 4.69 ticks against 4.00. At 144 FPS it is reachable.

The spring pose plays at the speed of the launch

The vertical-spring pose follows the same 12 - speed rule as The run animations play at the speed of the player, off the vertical speed. It used to play at a flat 4.38 ticks a frame (Jazz, Spaz), less than half the original's rate on a strong launch. Hold of each frame of the original's pose 65 against its entry ys, across the three colours:

Entry ys17.4 … 9.99.49.18.258.06.46.13.4
Ticks held23355888

A hold is the integral of the rate as the speed decays, not 12 - speed at entry. Setting the duration every frame reproduces every row (entering at 8.25 crosses a frame in 5 ticks, 9.375 in 3, 6.375 in 8 once capped). Floor 2 (ten measurements, entries 9.9 to 17.4) and ceiling 8 (entry 3.375, where the formula predicts nine) are real limits. Blue now runs 1-2-2-2-1-2-2-1-2-2-4-5-6-8 against the original's 1-2-2-2-2-2-2-2-2-2-2-2-3-5-8-7, green 1-4-6-8 against 1-3-5-8.

The falling animation was 22% too slow

The fall pose is a flat 9 ticks per frame, three frames, at every speed from 0.125 to 7.875 px/tick (ours was 11.67). Fixed in the metadata, so in both modes: "FrameRate": 12.97 on each character's Fall, from 5 / (3 * 9 / 70.021), Lori included (the rate is per frame and all have three). a_jump now holds 8-10-9-8-9 against the original's 9-9-9-9, where it held 11-11-11-12.

The double-jump pose lasts the rise, not the animation

Spaz's double jump shows spring for 11 ticks (an_dj_len, ticks 63 to 73), yielding to the falling pose on the tick the vertical speed turns positive. Ours ran all eight frames over 34 ticks. The cadence (4 ticks per frame) was right, so it is now cut where the original cuts it.

Down and Jump on the same tick

An uppercut or sidekick right after a shot is weakened not by the shot but by pressing Down and Jump on the same tick:

ScenarioShot firstDown pressedOriginalOurs
sp_jazz_upperno20 ticks early, heldrises 226 px228 (matches)
sp_upper_downholdno20 ticks early, Jump tappedrises 201.5 px208
sp_upper_jumpholdnowith Jump, Jump heldrises 132 px228
sp_upper_tapnowith Jump, both tappedrises 8 px208
an_shoot_upperyeswith Jump, both tappedrises 8 px208
sp_spaz_sideno20 ticks early, heldtravels 507 px503 (matches)
sp_spaz_side_relno20 ticks early, released latertravels 507 px503 (matches)
sp_side_tapnowith Jump, both tappedtravels 0 px503
an_shoot_sideyeswith Jump, both tappedtravels 0 px503

The shooting rows match their shotless twins to the pixel: the original wants the crouch established before Jump.

Listed in the gaps table as Down and Jump pressed on the same tick, deliberately not implemented: three of four cases are partial (201.5, 132, 8 px of 226), a strength curve rather than a gate, needing a sweep with Jump held for a range of lengths.

A shot needs a shooting pose on screen

The muzzle is read off whatever animation is current when firing (Jazz2::Actors::Player::GetGunspotOffset() from Jazz2::Actors::Player::GetFirePointAndAngle()), so a pose without a State | Shoot variant made the shot leave from its hotspot — e.g. Jazz's uppercut, from the middle of the player.

Jazz2::Actors::Player::SetShootingAnimation() drops the bits saying what the player is doing, most specific first, until one has a shooting variant with a muzzle. What remains (airborne, crouched, on a vine) always has one.

  • A pose with a muzzle of its own is left alone: swapping away from Lori's kick, which re-applies its pose every frame, gave sp_lori_kick_fire 39 animation segments against the original's 4. The uppercut is dropped anyway, because the original shows the shot there.
  • TransitionUppercutEnd (Jazz's uppercut and the sidekick's ending) is non-cancellable, so it is in Jazz2::Actors::Player::ShouldCancelTransitionOnFire() with the four shot endings, and Jazz2::Actors::Player::BeginStandardJump() drops it by hand likewise.

Hanging on a vine is not a static pose

While hanging still, the original alternates vine_idle_flavor with the one-frame vine_idle, 70 ticks each, for ever. On ob_vine_low (800 ticks) the original changes at ticks 28, 96, 165, 236, 305, 376, 445, 516, 585, 656 and 725. Ours at 30, 100, 170, 240, 310, 380, 450, 520, 590, 660 and 730 (the grab lands two ticks later).

The flourish loops inside its half: Jazz's is five frames at 8 ticks, going round nearly twice before being cut mid-loop (frames held 7, 8, 8, 8, 8, 8, 8, 8, 6). It loops through the finish callback, like the stop poses, and is shared with Reforged. Spaz's flourish is seven frames and Lori's twenty-eight. Only Jazz's cadence is measured, the others get the same 8 ticks per frame.

Frame-rate independence

The whole scenario set is re-run at 24, 30, 60 and 144 FPS whenever the model changes. All four rates are scored against the captured original and against each other (Tools/CompareFrameRates.ps1). The second comparison is the one that answers the frame-rate question.

1. Against the original, the score broadly improves with the frame rate and the median does not move:

 24 FPS30 FPS60 FPS144 FPS
Scenarios within 25 px/s352 / 405350 / 405363 / 405375 / 405
Median speed-distribution error0.1 px/s0.1 px/s0.1 px/s0.1 px/s

(Four full sweeps of one build, 2026-09-17, each holding its target rate to within 0.4 ms of the median frame. "Broadly": 24 edges 30 by two scenarios, which is inside the chaotic scenarios' run-to-run swing.)

1b. Do the four rates agree with each other? Positions are compared on a shared tick grid, with two runs at the same rate as the control:

ComparedMedian worst per-tick differenceAgree within 1 px
Same rate, two runs0.34 px324 / 406
144 vs 602.70 px153 / 406
60 vs 302.84 px149 / 406
30 vs 244.13 px140 / 406
144 vs 2411.22 px124 / 406
All four12.70 px119 / 406

The disagreement has three sources, and only the third is a defect:

  • Scenarios that are chaotic at any rate and differ between two identical runs too (pb_bump_*, sl_up45_jhold, sp_dj_a_dashflip, sp_chain).
  • Scenarios decided by an input window shorter than a frame. At 24 FPS one frame is 2.92 of the original's ticks (sp_slide_* reads 3.8 / 9.2 / 18.7 / 0.3 against the original's 9.6).
  • Mechanics sampled once a frame when they should be swept along the path. The float-up area was one. It is now resolved (see A float-up area was sampled once a frame under Known remaining gaps).

2. Frame-rate-invariant quantities, engine only, so the spread is pure frame-rate dependence:

 24 FPS30 FPS60 FPS144 FPSSpread
Standing jump height (ap_r30, original 132.0)131.8132.1132.0132.00.2%
Plain jump height (a_jump, original 132.0)131.8132.1132.0132.00.2%
Vertical pole rise (ob_vpole)270.3270.9270.6272.20.7%
One-way ladder climb (ow_hold)704.0704.3704.1704.10.0%
Walking jump height149.3149.2149.3149.30.1%
Dashing jump height213.9213.6213.3213.30.3%
Blue spring height (original 609.0)609.6609.3609.3609.30.0%
Float-up ladder rise520.8520.7520.5520.90.1%
Push distance142.0142.3142.0142.30.2%
Belt travel799.2798.4801.1801.40.4%
Sidekick distance499.8500.9503.2504.60.9%
Walk distance @ 3 s790.2792.0794.9799.11.1%
Dash distance @ 3 s1580.61584.31589.61598.01.1%
Double jump height198.2200.5202.1201.91.9%
Uppercut height237.1228.0228.3227.44.1%
Tap jump height81.576.276.277.36.5%
Swim distance @ 11 s1619.11618.01622.41623.40.3%
Swim distance, Run held3116.43113.93122.33124.50.3%

The two jump rows and the blue spring were re-measured after Gravity before the move and the spring hold. The other rows predate them. At 70 FPS, where a frame is a tick, the standing jump reads 132.00, ap_r10 98.67 against 98.62 and ap_r20 125.79 against 125.75.

A velocity-Verlet gravity correction brought the jump heights in line. It folds half a step of gravity into the applied speed before the move, in Jazz2::Actors::ActorBase::TryStandardMovement(), and is live in Reforged too. At 24 FPS it moved the standing jump from +5.95% to −3.05%, the walking jump from +5.08% to −2.67% and the dashing jump from +3.57% to −1.84%. Every rate then sat on the same −3%. That residual was the order of the update, not the rate, and the extra half tick described under Gravity before the move removes it.

Verification

Comparing endpoints hides a wrong curve: Lori's kick once passed a distance check while being three times too fast. The routine check is therefore the sorted distribution of speeds each build visits. It catches wrong magnitudes and wrong shapes while ignoring few-tick timing offsets. Tools/CompareTraces.ps1 in the harness runs this check. Against the captured original run:

Compared 328 scenarios present in both traces.
Median speed-distribution error: 0.3 px/s
Scenarios within 25 px/s: 286 / 328

Outside that band:

  • Twenty-five of the twenty-eight do not measure the same thing on both sides. The original's frozen spring never fires without a Freezer shot. sp_spaz_side has a held-jump re-jump at the end that this engine does not do. The pushable sits at a different spot in the two copies of the level. Seven wall- or slope-contact scenarios differ only in where in the tick each probe samples the speed. Sources/Jazz2/Tests/README.md lists all of these under scenarios that do not measure the same thing on both sides. Check that list before treating a new outlier as a regression. The remaining three (the uppercut, the copter and the standing jump's 3%) are in the gaps tables.
  • Most of the pinball family reaches the top of the level. pb_pad_x1, pb_pad_d24, pb_lpad_x1, pb_pad_hold and pb_lpad_hold report a rise of exactly 400.0 on the original's side, which is the drop height and not a trajectory. A held key pumps every bounce higher, and the chamber cannot be made tall enough to avoid the ceiling (a −39 launch alone needs about 550 px). Read the first launch instead.

Spaz's double jump is now inside the band in 57 of its 58 scenarios (sp_dj_a_dashflip is the exception, on an 800-tick bounce chain whose travel agrees to 0.06%). The 22 scenarios that test whether it fires agree on the tick. All thirty ap_r* score exactly 0.0 px/s. See Spaz's double jump and The rise, tick by tick.

Passing -Baseline compares two engine runs instead, which answers whether anything changed at all. The same build run twice scores 0 on every scenario, so any non-zero figure is a real change. Its position columns are noisy for a separate reason, explained in the harness README.md.

Known remaining gaps

The open differences come first, then items that look like gaps but are not, then every resolved item with its final fact.

Open

GapMeasured differenceStatus / what would fix it
Speed kept through a landingReported: a run that takes the four-tile gap and then the five-tile one clears it in the original and not here.Not reproducible. Each lh_* gap has its own run-up, so no scenario chains two gaps. All twelve lh_* are within 0.5% on travel except lh_g4_walk (3148.8 against 3099.1, 1.8%). lh_g4_dash and lh_g5_dash travel 6186 against 6153, and the fall depths agree to a pixel. Needs a chained scenario.
Copter riseShort by about 4 px: cp_tap55 77.3 against 81.5, sp_copter_lrl 77.3 against 80.5, sp_copter_late 128.0 against 132.0. sp_spaz_copter reads 107.7 against 107.4, and 9 of the 15 copter scenarios agree within 0.3%.The copter never engages in sp_copter_late, so the residual is the standing jump's 4 px, not a copter constant. Re-read once that is settled.
Breaking the surfaceThe four wt_* scenarios that stay submerged score 0.0–0.7 px/s. The same four, run long enough to exit, score 32–45. Ours climbs 14–38 px higher out of the water, so every bob after that differs.Partly fixed. The original has no push out of the water: swimming starts 12 px below the surface and stops 4 px below it (Jazz2::Actors::Player::LegacyWaterEnterDepth, Jazz2::Actors::Player::LegacyWaterExitDepth), and above the water line the ordinary air rules apply, so the 0.875 is the released rise and the 0.125 the fall. Median position error: wt_swim_up_run 16.0 → 5.5 px, wt_swim_up 11.4 → 9.3, wt_float_up_u 10.3 → 7.9. Still open: a jump pressed while swimming near the surface, and scenarios that start the player well below it.
Swimming posesRiding a submerged float-up field for 11 s, the original cycles its swim sprites 53 times and ours changes pose 11 times. Ordinary swims are close: 26 against 31 and 32 against 55.Jazz2::Actors::Player::OnHandleWater() already drives AnimDuration from the speed. It is not established whether the rate or the pose selection is wrong. The two anim columns do not compare numerically, so this needs a pose-by-pose reading.
Run-in-place: when the wind-up pose appearsThe sustained pose appears 24 ticks after the first tap here, against 41 in the recording (the original's fifth tap rather than its third).The escalation rule is not pinned: across nine recorded bursts the pose appears anywhere from the third tap to about ten ticks after the fourth. A full charge launches the same either way. Next step: record deliberate, evenly spaced taps at two or three fixed cadences.
Pinball paddle: repeated bounces compoundA single launch matches: pb_pad_fall and pb_pad_tap rise 171 and 172 px against 172 and 172, at ys −4 on both sides. pb_pad_d56, pb_pad_x2 and pb_pad_x3 and their left-paddle twins agree to 0.1 px. With Jump held, pb_pad_hold climbs from y 572 to 0 in the original (the top of the level, reached at tick 740) and to 294 here.The target is a per-bounce ratio. Once the first two chaotic bounces are past, the original runs −7.136, −9.715, −12.923, −16.977, −22.218, −29.187 (×1.31) and reaches the top on its eighth bounce. Ours runs −4.595, −5.744, −6.893, −8.042, −9.197, −10.511, −12.025, −13.784 (×1.145), after four bounces repeating −3.999. The first bounce is −4.000 on both sides. Scenarios that hold Jump report the strongest bounce in the window, so they measure the pumping, not the paddle. Mostly fixed: the original leaves the launch's sideways drift unbraked for four ticks (PinballPaddle::LegacyDriftHoldTicks), which is what carries the player further out each bounce. Median position error: pb_pad_hold 105 → 15 px, pb_pad_dj 78 → 37, pb_pad_xm16 138 → 56, pb_lpad_hold 133 → 97. The left paddle still lags.
A monitor above the player rests on their headA monitor at rest sits 6 px higher here. In the original, a monitor that spawns above the player stays there: mb_stomp holds the morph box at its authored row, on the player's head. Ours drops it to the floor, overlapping the player. Pushing it agrees (289.6 px against 290.6), a buttstomp breaks it in neither game, and an uppercut beside it does nothing in either.Not implemented: the original's rule is unknown, and it is not established that this is the reported "morph box floating". See Powerup monitors.
Animation structure across the two gamesThe CompareTraces.ps1 animation pass finds 71 of 355 scenarios passing through a materially different number of poses. The largest are fu_col_none and fu_col_rel (46 against 75), tb_gap5 (22/7), tb_up (42/29) and sp_side_run (8/25). All of them match on travel.Read which poses differ by hand, one family at a time, as was done for the stop chain. Two comparison rules apply. Fold the playing transition into our anim before comparing it with the original's curAnim (g_dash_rel reads 4 against 7 without this, 7/7 with it). Drop poses shorter than 4 ticks, because the two traces have different row counts. With both rules, plain scenarios agree exactly (g_walk 1/1, g_dash 3/3, a_jump 7/7).
Sidekick stalls after breaking a row of monitorsReported from play as about 3 s in the sidekick pose at zero speed. Not reproduced. pu_side_chain (Spaz kicking right through all six monitors, Down only, no Run, a second kick to finish the row) agrees to about a pixel. The original's sm runs from t = 201 to 399 over x 528.9 → 1470.6, and ours from t = 202 to 403 over 529.3 → 1471.5. From on top of the first monitor: 68 against 71 ticks, 508.5 against 504.1 px.The candidate mechanism is in Jazz2::Actors::Player::CheckEndOfSpecialMoves(), which bills the kick against distance actually travelled. Anything that holds the player at zero speed without setting _kickPushedThisFrame freezes the budget. Scenario traps: the monitors are events on row 59 and fall to row 61, so delay the kick (to tick 200) or it passes under them. Log their positions with objx. The column walks 528, 624, 720, 848, 976, 1136 and then −1. An internal freeze is also ruled out: the probe clock runs off timeMult, and the worst ms frame is 24.5 ms against a 16.7 ms median.
No pose for riding a tube or a poletb_down holds animation 58 (the original's curled ball) for all 800 ticks, while ours shows 7 (Walk, Run and Jump together) for all 1641 rows. tb_right runs 66/37/36 against our 0/7, ob_vpole 82/58/16 against 8/4/0, and tb_row 36.Judged acceptable in play, so nothing is planned unless it is reported. Implementing it would need an Jazz2::AnimState, metadata for all three characters, and a measured rule for which pose each tube gets. The id readings are in the harness README.md. The pinball paddle should hold the same ball.
What the bird scenarios did not reachThe second bird was measured with a Seeker only, and nothing pressed Up and Down together or reversed below the cap. The beak charge is measured (bd_ch_*, see The beak charge needs speed, and cannot be slowed down) except for its hitbox and what it does with canHurt turned on.Assumed rather than measured: weapons other than the five bullet ones fire a pair of blaster shots, Up wins over Down when both are held (in a charge as in ordinary flight), and a reversal below the cap carries on accelerating the old way until the eased acceleration turns over (what xAcc predicts). The perched poses' odds are fitted to the loop counts. See The two birds.
Boosting a player standing on youCannot be measured here, because both probes drive a single player.Changed from a report. Reforged bumps the lower player sideways. Non-Reforged hands the rise upward at Jazz2::Actors::Player::LegacyJumpSpeed, with the rise gravity stated explicitly (see What a pole launch decays at). Stacking is Cooperation-only and unaffected.
Pressed against a wall in the airAt the end of the same run the original keeps reporting −16 px/tick against the wall and rests 10 px closer to it than ours (x −1712 against −1701.9), which reports 0. The reported speed is invisible; the 10 px is not.Unmeasured. On the ground wb_wallfind stops within 0.2 px, so this is airborne-only.

Not gaps: read before chasing

ItemFinding
Firing during Lori's kick does not lengthen itAn earlier reading had the original travel 289.9 px with a four-tick shot inside the kick. The committed traces do not show it: sp_lori_side_fire travels 204.5 px and sp_lori_side_rel 205.4, tick for tick the same kick, against 206.0 here for both. The kick's speed is a quarter of the tick number squared for its ticks 2 to 13 (1.00, 2.25, 4.00 up to 42.25 px/tick), then zero.
A flying bird sits 8 px lower than the original'sDeliberate. The flying box ends 12 px under the hotspot so the wings beat through the floor, where the original's bird always stands on its sprites' coldspot at 20, as a rabbit does. So in flight ours rests and skims 8 px lower, lands a frame or so apart (the bd_up_rel family's 3.9 px/s), and a bird morphed in mid-air sinks the 8 px before its 37 perch ticks start. A perched bird stands at the original's height (EnterBirdPerch()). Compare the bird scenarios by speed and by steps, not by y.
Scripted input lands about two ticks lateTwo of those ticks were the harness and are gone: the engine read the keys after the move (see The keys steer the tick they are read on), and the probe floored its tick counter, so at 60 FPS every key edge landed on average 0.58 ticks late (a constant 4 px after a walking turn). It now rounds, which leaves a frame's quantisation either way but no bias; the ftick column carries the true time. What follows is the history. This engine's probe wrote input on the frame its tick counter reached the step, about two original ticks behind the original probe (ow_jump launches at tick 22 against 21, and every later event carries that offset). A release tick near a key-decided event can flip the outcome: one ow_jump released at 50 with the original crossing a platform at 49 and ours at 52, which read as a 50 px error. Keep key edges several ticks clear of the event, or hold the key throughout as ow_hold does.
Reported versus travelled speedThree places report a speed that does not match the distance moved: the uppercut by a constant 0.84, the RF blast fired against a wall by 1.6875, and a pole launch by 4.5%. No single mechanism explains them. All three are matched on travel.
Pole grab timingThe reported launch is −22.25 against −21.25 (4.5%), but the travel matches: ob_vpole 270.6 px against 270.2, ob_vpole_adjx 270.6 against 270.4, ob_vpole_x2 442.8 against 440.5, ob_hpole 3636.9 against 3636.8, and ob_hpole_x3 exactly. The rise cap of 8 governs the ascent. The two probes capture the entry speed on opposite sides of the step into the tile.
Repeated kick: the 8% is terrain, not cadenceBoth sides kick every 45 ticks. Kicks 1–12 travel 204.8 px against 204.5 (the same +0.15% a single kick shows). The whole difference is kicks 13 and 14, where the original snags on terrain about 7000 px from the start (162.3 and 71.0 px instead of 204.5). Read per-kick figures, not the end-to-end one. The first kick fires 4 ticks earlier here, but every gap after it is identical.
Copter scenarios diverge after the first flightsp_jazz_copter_fwd and sp_lori_copter_fwd engage twice in the original (at 76 and 159) and once here. This is not a rule about a flight recharging: by tick 149 ours has landed (y = 1328.7) while the original has jumped again (1277). Read the positions before treating a difference in event counts as a difference in rules.
A buttstomp landing hops in six scenarios of nineA rule keyed on the height of the stomp, and implemented (Jazz2::Actors::Player::LegacyButtstompHopDepth). sp_spaz_butt, sp_lori_butt and sp_jazz_butt hit at 10.0 px/tick, read a flat −4.0 and hop 9 px. sp_butt_high, sp_butt_hold_r and sp_butt_tap_r go straight to ys 0.0000. The hoppers end their last step inside the floor (y 1330.69 against a resting 1329.94), and the others land exactly on it (1329.189). The descent moves in whole 10 px steps, and the player hops at −4 when the last step would end 6 px or more past the floor, so four start heights of ten hop. The three sp_butt_high scenarios land 0.19 px inside the no-hop band in the original, while our hover starts 2 px higher and hops: a knife edge on the start height, not a different rule.
Spring re-triggers under a resting playerThe original re-fires springs under a resting player and we match it (ob_spring_red at 109 and 216 against our 104 and 210, ob_spring_green 148 against 144, ob_spring_blue 185 against 181). In ob_spring_vpole the pole drops the player 15 px aside (x = 4527 against 4512), and only our spring reaches that far. That is a pixel or two of trigger width, the knife-edge case Results/README.md warns against fitting. Left alone deliberately.
Lori's kick cannot be started in mid-airAlready matches. The move needs the crouch, which cannot be entered off the ground, so an airborne Down+Jump becomes a buttstomp in both games (sp_lori_butt: 226, 204, 176, 225, 177, never 229).
Ordinary fall terminalRecorded for later checks. In clear air the original accelerates by one Jazz2::Actors::Player::LegacyFallGravity per tick and levels off at exactly 12 px/tick (sp_copter_deep, ticks 100–120), the same terminal the flying carrot uses.
Tapping Run on the spot (superseded)Scripted jjPLAYER.keyRun does not reach the mechanic. rt_hold, rt_b2, rt_b4, rt_b8, rt_b16, rt_b8_long and rt_b8_jump tap Run at cadences from 2 to 16 and then stop. The original gives xs = 0.0000 at every cadence, and its 36 → 66 → 37 → 66 animation is the idle/bored cycle. Implemented anyway at the user's request, in both modes, with named RevUp* constants (not Legacy*) because the values are invented. See Jazz2::Actors::Player::UpdateRevUp() and the resolved Tapping Run on the spot.

Resolved

GapFinal fact
A crouching player walks off a ledgeOn an_crouch_gap the original comes to rest at x = 10768.5, 16.5 px past the last solid tile, and drops with no horizontal speed. Ours used to carry 47 px into the fall and land at 10816. The committed traces now end at 10769.3 against 10768.5, and 1808.7 against 1810.5 down.
Landing cost the original a tick of travelA landing made by the air floor snap keeps its fall speed for one more tick. When that speed is above the step height (4 px plus the sideways speed in px/tick), the next tick's whole move is refused: on lh_g6_walk the original lands at tick 372 still reporting 12 px/tick, does not move at all on tick 373, and walks on from 374. A dash is immune, because its step height is above any fall speed. See ActorBase::_landingStall. lh_g5_walk 3.9 → 0.3 px, lh_g6_walk 3.9 → 0.3, lh_g4_walk 8.8 → 4.9.
The standing jump was 3% short128.0 px against 132.0 at every frame rate. The original applies each tick's gravity before that tick's move, and a jump assigns its speed after the launch tick's gravity. A smooth integration of the same speeds peaks at the continuous limit, 128.0. The applied speed now carries another half tick of gravity in flight, and a jump or double jump launches one tick of gravity stronger. a_jump and ap_r30 peak at 131.98, a_djump at 217.1 against 217.4. An earlier attempt moved by the speed from before the tick's gravity instead. That gives the same positions on a straight stretch but applies every rate change a tick late, so released hops and springs overshot (ap_r05 81.3 against 77.1). See Gravity before the move.
Spring hold before decayThe original holds an upward spring's speed for two ticks (−32.0000 on ticks 0, 1 and 2) and decays from tick 3. Ours decayed from tick 0, and once the gravity order was right all three springs read the same 15.7 px low, which is the shape a hold gives: two more ticks at the 8 px/tick cap. See Jazz2::Actors::Player::LegacySpringRiseHoldTicks. Red 268.0 against 267.8, green 438.7 against 438.4, blue 609.3 against 609.0. The speed error went from 30–36 px/s to 5–7.
A fall moving sideways missed a floor just belowMeasured with a fixed fall and horizontal speed: from 2 px/tick across, the original lands whenever the floor is less than 8 px under where the tick's move leaves it (1 px/tick never snaps). While dashing the reach is the horizontal speed plus 4, so 20 px at 16, which is the 20.9 px drop cl_dash_j showed on tick 68. See Jazz2::Actors::Player::LegacyAirFloorSnap and Jazz2::Actors::Player::LegacyAirFloorSnapDashExtra. cl_dj_walk 185 → 42 px median position error, cl_walk_j 113 → 22, cl_dash_j 73 → 33.
A crouch carried off a ledge did not stompCrouching sets the pressed-Down latch, so the air branch never saw a fresh press. The original turns the held crouch into a buttstomp on the tick the player leaves the floor (speed to 0, then the hover). an_crouch_gap 47.5 → 1.3 px, an_crouch_gap_j 47.5 → 1.2, an_crouch_gap_run 54 → 3.9.
The buttstomp dived 5 ticks early and hovered stillThe original hovers 39 ticks from the press to the first descending tick, after a jump or a fall alike, sinking 1/16 px a tick; ours took the metadata's shorter start transition and held at zero. The transition is now re-timed like the ground-move wind-ups (Jazz2::Actors::Player::LegacyButtstompHoldTime, Jazz2::Actors::Player::LegacyButtstompHoverSpeed). sp_butt_high 17.3 → 4.0 px, sp_butt_moving 13.9 → 2.3, sp_butt_right_run 31.6 → 9.3, each character's own stomp 0.93 → 0.35.
Walking off a ledge started the fall 7 px earlyTwo rules, both measured: a 24 px footing (standing still at set offsets), now the width of the whole hitbox (Jazz2::Actors::Player::HitboxLeft), and footing judged where the player stood a tick earlier, so the fall starts on the tick after it is lost (ActorBase::_footingGrace, written in ticks so it holds at any frame rate). All seven lh_* onsets now land on the original's tick, within 1–2 px, and lh_g1_dash crosses its one-tile gap without dipping, as the original does.
The original-style camera led too far through a dash turnIts target is 8 × the speed in the direction held, approached by a step that eases halfway to a limit of 1, 2 or 4 px/tick each tick, a tick behind the player on both axes. g_dash_opp 13.7 → 1.1 px, a_djump_opp83 49 → 1.6. See The camera.
Turning round overshoots and then lagsOurs moved before it steered, so each step was the previous tick's speed: a reversal overshot by a frame at the old speed and trailed by a frame at the new one, 7.7 px walking and 15.6 px dashing (2 × the step). Horizontal steering now runs before the move, and the dash state after the speed change. A same-script run in both games then matches tick for tick, and the C++ sweep's median speed error goes 0.3 → 0.1 px/s (526 → 539 of 599 within 25 px/s). See The keys steer the tick they are read on.
A carry that ends does not clamp, so a pole or spring runs the player far too farWhen a run-along carry ends, the original snaps the speed to the walk cap (_keepRunningTime: a pole launch, a spring, the rev-up). On an_crouch_carry it goes from 17.70 to 3.88 and the player stops 35 ticks later, while ours coasted 853 px further. The carry now applies Jazz2::Actors::Player::LegacyCarryExitRunSpeed, like the spring hold, sucker tube, accelerating belt and sidekick exit already did. 5971.9 px against 5948.2 (was 6801.5), and ob_hpole_z0 and ob_hpole_zr each land 197 px closer. Holding a direction and Run hid it, because the dash cap converges on the same 16.
The crouch survives a fall, and an uppercut can be started in mid-airOnly releasing Down cleared Jazz2::AnimState::Crouch. In Jazz2::Actors::Player::HandleLookupAndCrouch() a held Down flips to the buttstomp binding, so the bit stayed set through the fall, and Jazz2::Actors::Player::IsSpecialMoveCrouchReady() read it. On an_crouch_gap_j ours uppercut 110 px back out of the hole, while the original keeps falling at 10 px/tick with sm at 0. The bit now clears the instant the player leaves the ground (the original's anim goes 65 → 17 on that tick), and IsSpecialMoveCrouchReady() tests the ground explicitly. an_crouch_gap_run re-crouches normally on landing.
Shooting during the skid repeats the skidFiring cancels the skid. On an_slide_fire the original switches to the speed band's ordinary pose on the fire tick (dash_start at 13.86 px/tick, run at 4.00, the standing pose once stopped) and never returns. Ours drew the skid over Jazz2::AnimState::Shoot for 40 ticks. Fixed in Jazz2::Actors::Player::IsSlidingToHalt(), keyed on _fireFramesLeft.
The run animation does not quicken with speedThe original runs at max(1, 12 - abs(speed)) ticks per frame: the dash loop is 4.00 ticks against our 17.1, and our walk was half again too fast. See The run animations play at the speed of the player, including the Reforged-only line in OnHandleMovement() that must be turned off with it (left in, it made the walk nine times too fast).
A float-up area was sampled once a frameIt was tested only at the frame's end position. At 24 FPS (2.92 ticks a frame) a 12 px/tick fall moves 35 px between samples and skips the tile. On fu_jump_right_rel the field registered on 41, 34, 17 and 2 rows at 144, 60, 30 and 24 FPS. It now walks the same half-tile samples as the trigger events (Jazz2::Actors::Player::OnHandleAreaEvents()) and stops at the first hit. 24 FPS: 176.6 → 513.8 px, hits 2 → 15 against the original's 18, and fu_butt 176.6 → 200.0. 60 FPS is unchanged (0.16 px median, 394 of 406 within a pixel). ow_jump (224.5 / 224.7 / 225.6 / 202.3) is input quantisation instead, not a missed tile: the launch ticks are 20, 22, 23 and 23 against the original's 21.
Pole ascent after a springThe decay rate depends on how the player reached the pole: ob_vpole (jumped onto) decays at 0.875, ob_spring_vpole (sprung onto, no key pressed) at 0.375. NextPoleStage() now derives _jumpReleased from !_poleEnteredOnSpring, captured at the grab. _isSpring clears during the ~140-tick hold, so it cannot be used. Was 535 px against 804, while the speed-distribution check scored 0.0.
Pole launch is clamped a tick laterThe original assigns −40.125 and reads −32.00 on the next tick, so its vertical limit is 32 original units. That is Jazz2::Actors::Player::LegacyVerticalSpeedLimit, 37.33 here, exactly a blue spring's launch: springs pass untouched while poles are clamped. (32 engine units truncated springs, while 64 never clamped poles.)
Spring heightsAn internal speed limit sat below the launch it had to carry. The "green below red" figures came from a contaminated probe run. See Springs set the speed outright.
Seeker knockback is inventedThe original's Seeker moves the player by nothing at one, two or three tiles (the ammo count proves the shot was fired), and TNT does nothing at any range. SeekerShot's AddExternalForce(±8, 0) is now Reforged-only. See Blasting yourself off a wall with an RF shot.
RF shot flight timeThe shot starts at the player's leading edge minus half its own width, because it detonates when its box meets the wall. In RFShot, LegacyBlastDelay is the fixed 9-tick fuse and LegacyFlightSpeed is 3 px/tick, half the engine's 6 px/frame. True-gap readings (taken from wb_wallfind, not from the scenario names): 0.6 px → 9 ticks, 11.7 → 13, 20.6 → 16, 23.7 → 17, nothing at 35.7. Flight is now 9, 10, 13, 17 and 18 ticks against the original's 9, 9, 13, 16 and 17. wb_rf_r48 moves the player 1.2 px against 0.9 (it was 306). Jazz2::Actors::Player::LegacyRFBlastReach was lowered from 40 to 32. At the intermediate stage wb_rf_j0 rose 104.2 → 127.9 px against the original's 168.6.
RF ground liftFitted, because the mechanism is not in evidence (likely the shot falling as it flies). Original lift by true gap: −0.75 at 0.6 px, −2.75 at 11.7, −4.25 at 20.6, −4.75 at 23.7, nothing at 35.7. The lift grows with range while the horizontal component saturates at 8. -(0.646 + 0.1732 * range) fits all four to within 0.08 (Jazz2::Actors::Player::LegacyRFBlastLiftSlope), and LegacyRFBlastReach cuts off the fifth. Jazz2::Actors::Player::ApplyBlastKnockback() gets only a distance and a side. Rises: wb_rf_r36 10.6 against 12.6, wb_rf_r24 2.8 against 4.1, wb_rf_r48 and wb_rf_r64 nothing against nothing (each was 0.1). Point blank is about a pixel generous.
Buttstomp bounce off an enemyA flat −13, not a fraction of the impact, and the ascent decays at the released rate. The launch is exact, but the rise is 4.8% long from discretisation. See Bouncing off an enemy you buttstomped.
Double jump pressed within a frame of the apexThe check reads _frameStartSpeedY (the speed before gravity), as the original does: sp_spaz_dj_hold went from 166.8 → 128.4 against 132.1. There is no fall-speed cap. The window closes on a 30-tick timer started by releasing jump, and the original fires at 4.0 and 4.6 px/tick (sp_dj_r85_d20, sp_dj_r85_d25). The old (0, 3.75) band was an artefact of every scenario releasing on the same tick. Nine spurious double jumps are gone. See Spaz's double jump.
Double jump kept its horizontal speedThe original discards it. sp_dj_a_dash reads xs 16.0000 → 0.3662 (one dash acceleration step). Walking cases drop to 0.1831. Keeping the speed was worth 1925 px on sp_dj_a_dashflip.
Rise deceleration overshoots the apexFrom the ap_r01..ap_r30 sweep: the released rate is 0.875 above 1 px/tick and 0.625 below, and the rise ends at zero. All thirty peaks match to 0.01 px and score exactly 0.0 px/s. Removing up to +0.94 of spurious apex fall speed moved sp_dj_r50_d25 from −11.2 to +1.1 px and sp_dj_r50_d29 from −6.4 to +1.9, and every fu_col_* improved. See The rise, tick by tick. The standing jump's 3% is separate (open table).
The copter descends at a flat speedJazz2::Actors::Player::LegacyCopterDescentSpeed is a ceiling approached at Jazz2::Actors::Player::LegacyCopterWindUp (1/128 a tick). cp_tap65 engages at 0.625 and climbs 0.633, 0.641, 0.648, 0.656, still only 0.977 after 45 ticks. Engaging above the ceiling caps the speed (cp_tap70: 1.250 → 1.0078 in one tick). The ceiling is 1.0078125 = 129/128, not 1 (sp_jazz_copter reads 1.008 against 1.008). Gravity is forced off every copter frame, because the copter survives a warp and Jazz2::Actors::Player::DoWarpOut() hands gravity back.
A warp ended the copterJazz2::Actors::Player::WarpToPosition() no longer clears _copterFramesLeft. On wp_walk the original leaves the warp still coptering (animation 30) and falls at 0.008, 0.016, 0.023, 0.031, which is the wind-up from a standstill. Gravity is not handed back at warp-out while coptering. Otherwise the ramp restarts from 0.42. Residual: ours starts the ramp at 0.265 where the original starts at 0.
The slide tile does nothing at allNothing read EventType::ModifierSlide. It now replaces the no-direction brake, scaled linearly by its 2-bit Strength. All four strengths are within 1.2% on travel. See The slide tile swaps the brake.
Sucker tube: Reforged rode the old implementationThe tube is now shared by both modes, because its speed comes from the level in original units. For Reforged this fixed a speed conversion 14% slow, a fixed 10-tick window (the original re-arms 16), a snap 7 px too high, a missing release clamp, and the 16 px/frame hard clamps that would truncate stronger tubes. LegacyTubeControlTime and LegacyTubeSnapY lost their prefix (Features the original does not have must not read the legacy constants). The applied rise cap is deliberately not shared.
Sucker tube: how long it holds, and what ends itThe original re-arms a 16-tick window on every tick inside a tube tile and clamps to the walk cap on release. Ours used a fixed 10 ticks and kept the full speed. A 30-tile row, plus the two-tick difference between 8 px/tick and 20 px/tick tubes, separated the window from the exit condition. The Wait Time parameter is still unread and changes nothing in either game at 3. See A sucker tube re-arms while you are inside it.
Spring parameters were unmeasuredOrientation-down cuts a 132 px jump to 92.6 against 94.4. Reverse throws the player back 1031 against 989. Keep X and Delay both launch 360.7 against 360.0. Keep Y launches in neither game with this geometry, which is an agreement, not a measurement. Probe traps: a spring spawns from its event only when its region is first scanned, so write it about 40 tiles east of the origin, and a spring spawned on top of the player never fires.
Accelerating belt above the applied capFour faults. The step had no ceiling and no timeMult. The applied horizontal cap clipped a strength-8 belt's 12 px/tick to 8. The step ran before the brake instead of after it. Leaving the belt had no walk-cap clamp. Steady speed and cap are now exact and travel is within 1.4–3.7%. 2–3 ticks of ramp remain where a per-frame reading meets a per-tick one. See Wind and belts move the player, the accelerating belt drives them.
Wind and belt speedsA shared 0.7 factor is now 0.5 for wind (was 20% fast) and 1.0 for belts (was 30% slow). Parameterless belts default to 2 and 4 (were 3). Each is fitted on two strengths. See Wind and belts move the player, the accelerating belt drives them.
Float-up areas barely liftedThey assign a fixed rise speed while the player is inside. Ours applied a force that oscillated around zero. Ladder rise went from 149.8 to 520.7 against 520.3. See Float-up areas hold a speed, they do not push.
Float-up: gravity during the held riseThe original travels exactly the assigned 8.0 px/tick, with no gravity. Jazz2::Actors::Player::LegacyFloatUpSpeed equals the applied rise cap, so the Verlet half-step showed through (7.79, 2.7% short). Jazz2::Actors::Player::GetGravityModifier() now returns zero, which covers both the half-step and the post-move gravity. Its flag is sampled in Jazz2::Actors::Player::OnHandleAreaEvents() at frame end, matching the order the speed is written and read in.
Float-up: which rise gravity the exit decays atOn exit the original decays at 0.875 whenever jump is not held, including when it was never pressed (ours used 0.375). This is a fifth launch source for What a pole launch decays at. _riseFromFloatUp reads the live key only for a float-up rise. _jumpReleased could not be reused, because springs and poles share it and measure 0.375 with nothing pressed. fu_col_none decays at 0.876 against 0.875 and eases at 0.626 against 0.625. Its peak went from 35 px above the original to 13.6 px below. The remainder is where the player leaves the column.
Swimming had no model of its ownBoth axes follow the vine rule: half the walk cap alone, the walk cap with Run. The caps are one acceleration step past round figures, because the cap is tested before the add: 2.0625 and 4.0625 horizontally, 2.1094 and 4.2344 vertically. Land clamps at exactly the cap (g_walk 4.0000, g_dash 16.0000), so the overshoot belongs to water only. Horizontal acceleration is 1/16 and does not change with Run, while vertical is 1/8 and doubles with it. wt_swim_right now travels 1622.6 against 1614.9 and wt_swim_right_run 3122.9 against 3115.9. Before, an unpressed swim ran at twice the original's speed (3155.2 against 1614.9). See Swimming.
Holding nothing in water hung motionlessThe original sinks at Jazz2::Actors::Player::LegacyWaterGravity indefinitely. The same term makes the vertical caps differ (2.109375 climbing against 2.140625 sinking), so it is folded into the acceleration before the cap. It is applied in Jazz2::Actors::Player::HandleWaterAndModifierMovement() because Jazz2::Actors::Player::OnHandleWater() clears ApplyGravitation for a swimmer. wt_swim_down and wt_swim_down_run score exactly 0.0 px/s.
Float-up areas did nothing useful under waterIn water the original crosses a field at the same flat −8.0 px/tick as in air, overriding every input, in all four wt_float_up* scenarios. The legacy assignment is no longer gated on ApplyGravitation. It is excluded from the water model and from the generic branch's Deceleration, which shaved it to 7.811. Ours used to stall 76 px short of the surface, which the original reaches in 53 ticks. wt_float_up_u and wt_float_up_d now track within a few px.
Bolly's chain cannot be shotImplemented from a report, because bosses are out of the harness's reach. Jazz2::Actors::Bosses::Bolly::ChainBallHealth is 1. Only balls take shots, and the pieces between them let shots pass. Only the ball at the free end can be hit, so the chain shortens but is never cut. A ball takes its two pieces with it (the layout is [piece, piece, ball] repeating). Destroyed parts explode and shred in BollyPart::OnPerish() and are killed rather than dropped. Jazz2::Actors::EnemyBase::OnPerish() only adds a score.
The run-in-place is not synchronised in online multiplayerThe remote side receives only the pose. The charge (_revUp.ChargeTime / RevUpFullChargeTime) is a pure function of how long the pose has been up, so Jazz2::Actors::Multiplayer::RemoteActor counts the frames the pose has been drawn and drives speed and sparks from that, with no protocol change. It is guarded on the metadata having the spark animation. Not measured against the original: the evidence is an argument, not a trace.
Shooting from a pinball paddleThe original refuses the shot: on pb_pad_fire the ammo stays 50 and the pose stays 58 (the curled ball) for the whole ride. Ours fired six shots and showed Dash + Jump + Shoot. The shot is now blocked, non-Reforged only. The riding pose is still a stand-in (see No pose for riding a tube or a pole).
Spaz freezes in the air at the end of a sidekickA float-precision floor. The kick is billed for distance travelled, a difference of float coordinates whose resolution near x ~ 4000 is ~0.0005 px. A remainder below that never pays down, so the player hangs until _controllableTimeout (2 s). It happens in the air because gravity is off, and only over a gap, because the ground path moves more than the resolution. Jazz2::Actors::Player::SidekickDistanceEpsilon is 1/64 px (1/28000 of the kick). A deterministic probe cannot hit the coin flip. The fix is neutral on the whole sidekick family.
Lori can shoot freely through her kickEach kick allows exactly one shot, taken at the first opportunity (table below). The allowance is spent when the shot leaves, not when the key is read, so a press refused by the cooldown does not count. sp_lori_kick_fire shoots at tick 31, the kick starts at 41, and the original's next shot is at 76. Ours reproduces that gap at 46 against 45. Two residuals are unrelated to the kick. Fire held while standing gives 6 against 1, a probe artefact: the original's script writes keyFire = true every tick. Fire tapped while standing gives 64 against 49, because the original's weapon cooldown is longer than the 12-tick tap period. The weapon constants are unmeasured.
The spring launch animation is too slowThe pose follows 12 - speed on the vertical speed, floored at 2 and capped at 8 ticks per frame (ours played a flat 4.38). Blue now runs 1-2-2-2-1-2-2-1-2-2-4-5-6-8 against the original's 1-2-2-2-2-2-2-2-2-2-2-2-3-5-8-7. See The spring pose plays at the speed of the launch.
The falling animation is 22% too slowThe original holds each of the three fall frames for a flat 9 ticks at every speed from 0.125 to 7.875 px/tick (ours used 11.67). Fixed in the metadata, so it applies to both modes. See The falling animation was 22% too slow.
Lori's kick cannot change directionHer facing follows the direction key during the kick, and the drive is re-derived from the facing every live tick (canWalk no longer blocks SetFacingLeft()). The sp_lori_turn* scenarios press Left at ticks 44, 60 and 74 of a 35-tick cycle that starts at 41. Mid-kick: −177 against −178 px by tick 60. The next kick turns: −62 against −59 by tick 120.
The copter is denied after any early pressThere is no one-attempt-per-airtime rule (this page had invented it). The refusal is the ordinary jump cooldown, re-armed while the key is down, so a tap every 6 ticks holds it shut. cp_kill52 and cp_kill58 press once during the rise and copter at tick 81. Ten of twelve scenarios match engagement tick for tick. See What refuses the copter.
The rise gravity is latched at the releaseThe original checks whether jump is down on this tick, so pressing again mid-rise restores the held 0.375 (cp_kill52's apex is 7.4 px higher). This applies only to rises a jump owns. A spring holds the light rate with nothing pressed, an enemy bounce and an RF blast hold the heavy rate with jump held, and a pole depends on how it was reached.
Horizontal spring moved the playerOnHitSpring() no longer pulls the player halfway to the spring's centre. This matters only when falling onto one (10 px). On the Diamondus 3 spring chain it was the difference between escaping and looping forever: 204.5 px/s before, 0 after. See Springs set the speed outright.
Horizontal pole entered at zero speedThe launch is floored at 8 and goes left at zero entry speed. Without that, a player dropping onto the pole re-grabs it every 70 ticks forever. See Poles obey two different laws.
Above the top of the levelOnly the position is bounded. On sp_pole_loop the original sits at y = 0 for 69 ticks while ys keeps decaying at the ordinary rise gravity (−26.00, −25.625, −25.25), then falls once it turns positive. Do not zero the speed. The clamp is applied after the move, next to Jazz2::Actors::Player::TryLegacyOneWayRejump(). The bounds block in Jazz2::Actors::Player::OnUpdatePhysics() runs before the step, which left a 9.3 px overshoot. sp_pole_loop, pb_pad_x1, pb_bump_left, pb_lpad_d40, pb_pad_d24 and pb_pad_below now read exactly 0.0 (they were −13 to −469), and sp_pole_loop's error went from 12.8 to 0 px/s.
Adjacent poles ignoredA V-Pole directly above another chains, launching −22.25 then −37.38 for 406.7 px. InitialPoleStage() now excludes only the exact tile (it used to exclude two tiles): 401.0 against 406.7. Side-by-side poles never chain in either game.
Jump while Down is heldNot a crouch gate. A special move that ends with Jump held starts a fresh action on the next tick. Spaz's sm returns to 0 at tick 110 and he jumps at −13.939 (Jazz2::Actors::Player::LegacyJumpSpeed plus a quarter of the kick's 15.88). Lori's sm restarts at 2, 3, 4… because her kick repeats, so no tick is left free for a jump. The jump fires from Jazz2::Actors::Player::CheckEndOfSpecialMoves() before the exit snap, so the boost uses the kick speed: the original's trace reads 15.88, then 4.00 on the launch tick. Ground is asked of Jazz2::Actors::Player::HasLegacyFloorBelow(), not CanJump(), because the dash clears ActorState::CanJump (with CanJump() it still measured 0.4 px). sp_spaz_side 213.3 against 216.3, sp_side_run 213.3 against 216.3, sp_spaz_side_rock 130.0 against 133.8 (all were ≤ 0.4 px). The residual is the standing jump's 4 px. At 24 / 30 / 60 / 144 FPS sp_spaz_side reads 213.6 / 213.4 / 213.8 / 213.3.
Run held as a level starts sometimes did not runWith ToggleRunAction, _isRunPressed was seeded from the live key on the first Jazz2::Actors::Player::OnHandleMovement() frame, before input was sampled, and latched false. It now latches only once the key is seen down and follows the key until then.
Crouching while still slidingNon-Reforged now crouches on input rather than speed, sharing the 0.4 dead zone with Jazz2::Actors::Player::HandleHorizontalMovement(). Reforged deliberately still waits for abs(_speed.X) == 0. Crouch animation ids are 10 (Jazz), 88 (Spaz) and 170 (Lori). On sp_slide_* the original crouches at xs = 14.04, ours at 14.58. Second half: Down pressed after the release left the skid playing over the crouch, so Jazz2::Actors::Player::IsSlidingToHalt() now excludes a crouching player. an_crouch_slide crouches on tick 49 at 10.62 in the original and on tick 50 at 10.97 here, an_crouch_late 4.99 against 4.82 and an_crouch_walk 2.86 against 2.90. Look-up is untouched (it already matched).
Vine: a second vine higher up is missedAlready fixed by Jazz2::Actors::Player::VineDropCooldown, so the entry was stale. ScanVineTiles finds four vines at tiles 25–26 on rows 36, 39, 42 and 45, plus a 14-tile run on row 50. ob_vine_low_hold grabs at y 1456 and 1360 against 1458 and 1362, and climbs to 1040 against 1034. Reading trap: with Jump held, the grab and the jump share a frame, so susp is already 0 when the row is logged. Identify the grab by anim = 12, y snapping to the hang height, and ys exactly −10.00.
A vine hung at the wrong height when grabbed fastThe hang height was 1456 for a tapped jump and 1452 for a held one, while the original always hangs at 1458. Jazz2::Actors::Player::CheckSuspendState() now walks the player down onto the vine first, and abandons the grab if nothing is within a tile.
Jumping off a vine started 4 px too highSuperseded. Removing the 4 px nudge was the wrong fix (see Jumping off a vine rose 10 px short).
Dropping off a vine fell past the next one downThe Down-side drop used a hardcoded 12-frame cooldown (14 original ticks). A release at Jazz2::Actors::Player::LegacyVineDropSpeed reaches a vine 64 px below in about 13 ticks, so the grab was missed. The drop now takes Jazz2::Actors::Player::VineDropCooldown. After the 4 px step down, the grab box clears the released vine's mask by y = 1407. On ob_vine_down (vines at (28,43) and (28,45)), a quick Down lands at 1456 against 1458, and holding Down falls to 1520.7 against 1521.8. Both score 0.0 px/s.
Jumping off a vine rose 10 px shortThe original lifts the player 12 px on the release tick, then moves 8 px a tick under Jazz2::Actors::Player::LegacyAppliedSpeedCap. ob_vine_up shows it three times: 1443 → 1431, 1437 → 1425, 1299 → 1287. See Jazz2::Actors::Player::LegacyVineJumpLift. Vines four tiles apart exposed it: ours stopped 13 px under the upper vine. The vine mask is not the tile. The pair at (22,44) and (22,40) has its suspend bands at y 1424–1439 and 1285–1295, so the gap is 129 px, not 128 (ScanVineTiles sweeps a column to report this).
A vine climbed while jump was heldThe jump-side drop in Jazz2::Actors::Player::HandleJump() moved the player 4 px up but never cleared _suspendType. With continuous jump on, it re-fired every frame (y 1452 → 1448 → 1444), and Jazz2::Actors::Player::CheckSuspendState() re-zeroed the speed. It now detaches, takes the cooldown, and clears _jumpTime so the jump can fire. anim = 12 is the suspended pose, which outlives the state, so read susp instead.
A rev-up launch showed the skid poseJazz2::Actors::Player::IsSlidingToHalt() now excludes _keepRunningTime, which covers every carry (a spring, a pole, a wall bounce). On rt_b8, rt_b16, rt_t3 and rt_rec, TransitionDashToIdle dropped from 319 ticks to 50, starting at tick 488 when the carry ends. Travel was identical either way (2641.9 against 2643.1), which is why CompareTraces.ps1 now compares the animation columns.
Tapping Run on the spotMeasured from a hand-played recording. See The run-in-place rev-up.
A frozen spring launched the player 452 pxA probe fault. spawnSpring() left params[2] at zero, so ob_spring_frozen measured a plain green spring, while Spring::Activate() always refused to fire while frozen. It is now inert on both sides.
No idle animation on a vinevine_idle_flavor alternates with the static pose for 70 ticks each, and the flourish loops inside its half. See Hanging on a vine is not a static pose.
Shooting from a vine has no start transitionThe original has none either. On an_vine_shoot it goes straight from hanging to the shooting pose (sprite 819, held 19 ticks), then plays a 3-frame return (817 → 818 → 816, 6 + 6 + 2 ticks) and is hanging again at tick 94. That matches our pose → TransitionHookShootToHook → hang. Residuals: ours holds the pose 26 ticks against 19 (the general shoot cooldown) and advances to a second frame at tick 78. The up-aimed variant cannot be scripted: neither probe has an Up key, and JJ2+ has no keyUp.
Sucker tube rode 7 px highThe vertical snap is 15 px down (one above the centre), not the quarter point. tb_row holds y = 1327.000, matching digit for digit. See A sucker tube re-arms while you are inside it.
Flying carrot was essentially unimplementedMeasured from a hand-played recording. Vertically: Up climbs at 0.25 px/tick to the 32 cap. Releasing brakes the climb at 0.75 down to zero, after which it falls at 0.0625 to a terminal 12. The climb travels 8 px/tick whatever the speed reads. Horizontally it is ground movement: 4 walking, 16 with Run. It flies until a Fly Off area or a death, and EventType::AreaFlyOff now cancels it (it used to cancel only the airboard). Ours hovered, descended at a fixed 3.429 on Down, ignored Jump, and expired after 10 s. See The flying carrot is two accelerations.
fc_carrot measured a dead carrotA scenario fix. The Fly Off events lie on row 49, tiles 0–15, and the carrot is at tile 18. The leftward first leg crossed x = 512 at tick 93 and switched the flight off. The scenario now climbs first. Both probes were reordered and both need re-running.
Camera kept its lead against a wallThe lead needs actual travel, not just a held key. Against a wall the original returns it to zero at its 0.997 px/tick step, while ours held +119.4. It is keyed on travel because ours reads a phantom 0.4989 px/tick against a wall. See The lead follows the input, not the speed.
One-way floorsCollision already matched: rising through, landing on, and refusing to drop through with Down held. ow_hop agrees frame for frame. The jump test differed. The platform's mask counts as ground, so holding jump climbs a ladder of platforms. The test level's ladder is seven 3-tile platforms at tiles 27..29 on rows 33, 31, 29, 26, 23, 19 and 15, located with ScanTileEvent(). ow_hold now reaches 336.6 against 334.5 (ours used to stop at row 29). The relaunch reads Jazz2::Actors::Player::IsOnLegacyOneWayFloor(), not Jazz2::Actors::ActorState::CanJump. See A one-way floor is passable to the body and solid to the jump.
Does the walk-cap snap belong to Run everywhere?The snap has two targets: the walk cap with nothing held, 16 px/tick with Run. All three sites now apply Jazz2::Actors::Player::LegacyCarryExitRunSpeed. On the accelerating belt, 18 and 24 px/tick snap to 16 and decay at Jazz2::Actors::Player::LegacyDashDecel, while 6 and 12 snap to 4 and decay at Jazz2::Actors::Player::LegacyWalkDecel. The sidekick (15.88) and the tube (8) are below 16, so the snap is inert there. The RF blast is excluded because its own launch already differs. Travel: the tube −25.4% → −1.3%, the strength-4 belt −12.6% → +1.2%, the strength-8 belt +2.8%. The plain belt and both sidekick scenarios did not move.
An accelerating belt is faster while Run is heldWith Run, the belt's target is 18 px/tick at strength 4 and 24 at strength 8 (6 and 12 without): 1.5 per unit of strength plus a flat 12. Two strengths were needed to fit this. The ramp step is unchanged, but the brake becomes the dash brake (step 1.573 instead of 1.878). See Jazz2::Actors::Player::LegacyAccBeltRunBonus.
Applied movement on an accelerating beltA cap of the belt's strength plus the walk cap, excluding the Run bonus. 6 and 12 travel in full, while 18 and 24 are held to 10 and 16. On bl_acc_right_run travel tracks xs up the ramp (5.145, 6.719, 8.291, 9.863) and then flattens at 10, so it is a cap, not a subtraction. Ours was exempt.
Copter engaged from a held jumpThe "falling" test reads the start-of-frame vertical speed, as the double jump's does. A press exactly at the apex reads 0.0000 and is refused. On sp_jazz_dj the fall is 128.3 px against 132. Ours had coptered at 1.0 px/tick for 80 ticks. The tapped copter is unaffected.
Sidekick ending with Run heldThe walk-cap snap belongs to releasing Run. With Run held, the original leaves the kick at 15.88 and decays at a flat 0.4273 (the dash brake), covering 664 px (the snap gave 456). With a direction held as well, it carries on as a dash at 16 indefinitely. sp_side_run 660 against 664, sp_side_run_dir 3636.8 against 3636.5.
Down and Jump pressed on the same tickIt is a gate. sp_upper_jh08, sp_upper_jh16 and sp_upper_jh24 give 8.0 px each, the same as a tap: the move never fires and the player just jumps. The earlier 8 against 132 was a tapped jump against a held one. Jazz2::Actors::Player::IsSpecialMoveCrouchReady() reads the crouch from before Jazz2::Actors::Player::HandleLookupAndCrouch(), which runs just before Jazz2::Actors::Player::HandleJump(). A refused move must still jump: gating the branches alone gave 0 px. Now 9.3 against 8.0 for all four taps, and 128.3 against 132.0 held. Moves that should fire are untouched: sp_upper_downhold 207.6, sp_jazz_upper 228.2, and sidekicks within 4 px. This replaces the reading that the shooting pose refuses the move (see Down and Jump on the same tick).
Spinning feet took twice too longdash_start is a speed band between 4 and 8 px/tick, not a transition. The dash pose now arrives after 23 ticks, matching the original (it took 47). See Speeding up is three bands.
The double-jump pose held a third of the way downThe original shows it only for the rise: 11 ticks, ending when the vertical speed turns positive. Ours ran 34. See The double-jump pose lasts the rise, not the animation.
Sliding to a halt showed no animationThree faults. The chain had two poses where the original has three. The assets were chosen by name, not by what the original plays (walk_stop is the skid, not the last pose). And an unconditional _inIdleTransition cancel cut whatever was playing to one tick. See Sliding to a halt is a chain of three.
The lizard copter hovered instead of flyingJJ2's COPTER (0xE2) at (236,26). Vertical: holding Up adds exactly 0.25 px/tick and holding nothing falls by exactly 0.0625 (75 and 154 samples). These are Jazz2::Actors::Player::LegacyFlyRiseAccel and Jazz2::Actors::Player::LegacyFlyFallAccel, the flying carrot's constants. The branch in Jazz2::Actors::Player::HandleWaterAndModifierMovement() was gated on Modifier::Copter alone, so cp_mod_right hovered at y 832.000 and cp_mod_get hung for 1199 ticks. Both now share the branch. Horizontal: 4.0 and 16.0 with Run (4.6667 and 18.6667 here). Read per-tick speeds, not displacement totals. Duration: 279 ticks from a freshly spawned copter, in all eight scenarios whatever is held (ours was 210). See Jazz2::Actors::Player::LegacyLizardCopterDuration. Animation: the original loops seven frames (1368–1374) at 8 ticks each, which is vine_idle_flavor (FrameRate 6.25). Ours froze on Jazz2::AnimState::Hook's one-frame vine_idle. Jazz2::Actors::Player::UpdateHookIdleAnimation() now loops it. Shooting uses three animations: the hang loop (105), a single frame while firing (107, frame 1378) and a three-frame return (106, 1375–1377). Three fixes: the four ShootTo return transitions are now in Jazz2::Actors::Player::ShouldCancelTransitionOnFire(), the flourish stands aside on _fireFramesLeft, and both flight branches carry Jazz2::AnimState::Shoot, because they assign their state instead of compositing it. cp_mod_fire now matches an_vine_shoot step for step, and Modifier::Copter (CopterShoot, TransitionCopterShootToCopter) is fixed too. Probe: time from the tick the player is actually on the copter, not from a schedule. Stop Jump immediately, because pressing it lets go. Detect the ride with the object's STATE::EXTRA (it drops to STATE::DONE at the end). jjPLAYER.helicopter does not work (it is the copter ears and reads 0), and neither does position.
The sidekick's ending pose was never seenJazz2::Actors::Player::EndDamagingMove() clears the move before the ending is issued. The stop chain therefore started on the same frame and replaced it (sp_spaz_side_rel: Jazz2::AnimState::TransitionUppercutEnd and Jazz2::AnimState::TransitionWalkToIdle both at tick 113). Jazz2::Actors::Player::IsSlidingToHalt() now yields to it. The original holds the ending 12 ticks, and ours now plays both frames over ticks 113–118. Do not make it cancellable: Jazz2::Actors::ActorBase::SetAnimation() drops a cancellable transition on the next base-state change. A jump force-cancels it in Jazz2::Actors::Player::BeginStandardJump() (sp_spaz_side_jump: 3 ticks against our 5).
The stop was shorter the slower you were goingThe skid lasts exactly 12 ticks at release speeds of 16, 4, 4 on a slide tile, and 1.8 px/tick. The first link is timed, and only the second boundary depends on speed. See Sliding to a halt is a chain of three.
Jumping into a 45-degree slopeThe airborne up-slope climb in Jazz2::Actors::ActorBase::TryMoveSubstep() required abs(stepX) > abs(stepY). A dashing jump into a 45-degree face has exactly equal steps, so the condition is now >=. On sl_up45_jhold the original holds 16.0 px/tick. Ours dropped to 0.9977 and now holds 18.6667 (16.0 converted). Live in Reforged too. See Jumping into a 45-degree slope.
A stop pose rode through the loss of controlWhen the player is not controllable, Jazz2::Actors::Player::UpdateAnimation() returns early. It dropped _stopPhase without cancelling the transition on screen, and now performs the same cancel as the controllable path. On tb_gap5 the stop chain ran nine times across the tube crossing, while the original holds one pose. The animation comparison found it while every position and speed was in band.
The bored idle animation almost never playedThe original plays a flourish every 140 ticks, counted from when the previous one finishes. Ours waited 600 frames (700 ticks). bl_acc_right, bl_right and tb_right show 141 sampled ticks between flourishes, with flourish lengths of 104, 136, 189 and 216 (randomly picked). Counting from the start instead gave gaps of 93 and 299. bl_right now reads 142 against 141. Non-Reforged only (see Jazz2::Actors::Player::LegacyIdleBoredTime).
A special move begun while still slidingThe crouch begins as soon as no direction is held, but the move needs the speed gone (Jazz2::Actors::Player::StopSettleSpeed). The original performs an ordinary jump at −13.08 (Jazz2::Actors::Player::LegacyJumpSpeed plus a quarter of 12.33), then a buttstomp in place. Ours fired the full move (201 px of uppercut, a 700 px sidekick). Now hands over to the standard jump and re-arms the Down edge. Residual: the hop is 3.5 px against 8. See A special move wants the player stopped, but the crouch does not.
Copter: when it engages, not how fast it descendsOnce engaged, the descent holds 1.0078 px/tick (Jazz2::Actors::Player::LegacyCopterDescentSpeed). Engagement is refused once the fall passes about 2 px/tick. Jazz2::Actors::Player::LegacyCopterEngageMaxSpeed = 2.0 is a round figure inside the measured bracket of 1.875 engaging (sp_jazz_copter, 15 ticks into the fall) and 2.375 refused (cp_tap80). cp_tap55..cp_tap80 share one jump (rising at tick 46, falling from 61). Taps from 65 engage 4 ticks into the fall, and taps from 70 engage at 9. sp_jazz_copter and sp_lori_copter went from three engagements in 800 ticks to one. The "one attempt per airtime" half once recorded here was wrong (see The copter is denied after any early press).
Lori's kick does not repeatIt repeats on a timer. On sp_lori_side_hold the original kicks at 41, 76, 111, 146 … 566: 22 kicks in 800 ticks, every 35 (Jazz2::Actors::Player::LegacyLoriKickPeriod). A single kick already matched (204.75 against 204.5, so Jazz2::Actors::Player::LegacyLoriKickRamp was right). Both sides now kick 22 times on identical ticks and finish within 0.2 px. sp_lori_side: 204.8 → 1228.5 against 1227.0.
Lori's kick flew off slopes instead of following themOutside Reforged, Jazz2::Actors::Player::BeginLoriKick() no longer clears Jazz2::Actors::ActorState::CanJump and Jazz2::Actors::ActorState::ApplyGravitation. Jazz2::Actors::ActorBase::TryMoveSubstep() follows a slope only with both set. On sp_lori_side_hold (the slope at tiles 193–210) ours ran 133 px above the original by tick 340. Now y stays within 2.4 px with no falling ticks (the original shows animation 229 throughout). A real gap needs no special case, because Jazz2::Actors::ActorBase::TryStandardMovement() clears CanJump by itself. She does not kick through the air.
Lori's kick was sliced into three animationsThe original plays one animation: sidekick.aura, id 229, nine frames at about 4 ticks each, lasting 35 ticks (the repeat period). The drive covers the first four frames (xs 1.0 → 42.25). A new SidekickFull is bound to Jazz2::AnimState::TransitionSidekick, non-Reforged only. Reforged keeps SidekickA, Sidekick and SidekickC. The duplicate TransitionUppercutEnd is suppressed for her. Frames step at 41, 45, 49, 53, 58, 61, 66, 69, 74 and wrap at 76, against 41, 43, 47, 51, 55, 59, 63, 67, 71 and 76.
Lori's kick bounced her off a pushablestd::copysign(ramp, _speed.X) reads +0 as rightward. After anything stopped her, the next tick relaunched the ramp rightwards: on sp_lori_side_rock_left, +48.15 threw her to 2859.5 where the original stays at 2816.3. Only leftward kicks are affected. sp_lori_side_rock and sp_lori_side_rock_far approach from the left. The direction now comes from her facing, as in Jazz2::Actors::Player::BeginLoriKick(). She ends at 2811.4 against 2816.3.
Lori's kick does not push a pushableShe pushes at Jazz2::Actors::Player::LegacyPushSpeed (0.375 px per tick) while the speed column reads zero. The push is allowed while the kick still has budget, not during the recovery. A blocked kick spends its budget on the travel it intended, or it would never end. 22 bursts against 22, on the same ticks. Each 12-tick burst moves 4.7 px against 4.5. See A kick shoves a pushable, at walking pace.
Spaz's kick against a pushable is unmeasuredHe pushes for the whole move: 19.1 px in one kick, against our 21.2 (4 ticks of drive, then 51 of pushing). Probe trap: the reset does not restore facing, so every sidekick scenario now taps its direction for two ticks first.
Shooting during Lori's kickThe original spends a round at tick 43 (45 → 44 on sp_lori_side_fire). Jazz2::Actors::Player::OnHandleMovement()'s non-controllable early return sat before HandleWeaponFire(). A non-Reforged sidekick is now excused from it, while _controllableExternal still blocks firing during cutscenes and warps. Both probes must agree on what objx logs per scenario: once, one logged the ammo and the other a pushable.
Warp control delayThe original shows one frame of the warp-out pose and is walking on the next tick (two ticks in all). Ours waited for the whole TransitionWarpOut, 38 ticks. Now 5 against 3, the rest being frame quantisation. See A warp hands control back almost at once.
A special move started on top of a monitor drops the playerJazz2::Actors::Player::CanBreakSolidObjects() returned true for any special move, so the monitor underfoot broke on the first tick. The uppercut and sidekick now wait until the move's budget is armed by its launch callback. The buttstomp was already excepted. Lori's kick arms at the trigger, so it still breaks what it kicks. On pu_stand_upper the original holds its height through the 14-tick wind-up, where ours sank 13.3 px. Sidekick −505.9 against −508.5, uppercut 204.6 against 201.5. Standing on a monitor already gave Spaz his double jump back in both games (121.6 against 120.8).
Dropping off a vine accelerates too slowlyOn ob_vine_drop the original assigns 4 px/tick (4.125 two ticks later, then one Jazz2::Actors::Player::LegacyFallGravity per tick). Ours started from rest (0.17) and took 48 ticks to reach the floor against 16. See Jazz2::Actors::Player::LegacyVineDropSpeed. This applies to the Down-side drop only. The jump side uses Jazz2::Actors::Player::LegacyVineJumpLift.
Double jump out of a horizontal springA spring-specific rebuild: the launch speed divided by Jazz2::Actors::Player::LegacySpringRebuildTicks. Red (16) rebuilds at 0.50 px/tick², green (24) at 0.75, and blue (32) was predicted and measured at 1.00. The ceiling is a flat Jazz2::Actors::Player::LegacyDashSpeed. Ordinary carried speed rebuilds at 0.18 (sp_dj_dash). The marker must survive landing, because a horizontal spring leaves the player grounded. It must also be consumed on arming, otherwise it re-arms and overshoots by +462 px. Rates are now 0.517 / 0.775 / 1.034. The end-to-end gap went from −302.7 to −39.3 px, and the other two springs are within ±72 on a 3170 px run.
A horizontal spring's launch speed is never clampedThe original holds 16, 24 or 32 for exactly four ticks, then clamps to Jazz2::Actors::Player::LegacyCarryExitRunSpeed (ob_spring_green_h and ob_spring_blue_h, ticks 31–35). See Jazz2::Actors::Player::LegacySpringHoldTicks. Red is already at the cap. No position changes, because the applied cap holds travel at 8. Only the speed a jump boost reads changes.
Leaving a horizontal poleThe timing already matched (ob_spring_hpole: grab at 55 against 53, a 70-tick hold, release at 125 against 123, a 70-tick carry, then the walk-cap snap). The pole launch is travelled in full: it reports 20 px/tick and moves 20, where ours was held to Jazz2::Actors::Player::LegacyAppliedSpeedCap (8). That is 840 px over the carry, against the 831 measured. This is pole-specific, since a horizontal spring reports 32 and still moves 8. The launch curve is v + 8 capped at 20, not 3v clamped between 8 and 20. See the callout under Poles obey two different laws.

Lori's shots against the kick, from Lori can shoot freely through her kick (each scenario stocks a finite weapon and is read off the ammo column):

ScenarioOriginalBeforeAfter
Fire held, standing1 shot6, every 1406, every 140
Fire tapped every 12, standing49, every 1264, every 1264, every 12
Fire held, kicking22, every 356, every 14022, every 35
Fire tapped every 12, kicking21, every 3664, every 1223, every 36

These changes are most likely to feel wrong even though they measure right. Know them before playtesting:

  • the dash's actual ground speed is halved (the rest of it is momentum, not motion)
  • Lori's kick is a 13-tick ramp rather than a flat burst
  • the buttstomp drift is much slower than 3.8.0's and its descent no longer accelerates, so a stomp entered from a long fall arrives 20% slower
  • bouncing off a stomped enemy is more than twice as strong (−910 px/s against 3.8.0's −420), the largest single change in how a manoeuvre reads
  • a spring always sends the player its full distance (before, a released jump on the way in cost a third of it)
  • the camera leads far less (28 px at a walk against Reforged's 80), on a straight ramp that stops, rather than easing in over two seconds. This is the most visible change on the page, and it is exact. Expect it to read as "the camera stopped working" at first
  • speed the player did not ask for no longer pans the view, the sidekick most of all

How this was measured

A trajectory probe drives the player through a fixed matrix of ~145 scenarios with scripted input. It logs position, speed and input every tick in both games, so runs can be compared row for row. The whole harness lives in Sources/Jazz2/Tests: both probes, the test level, captured runs of each game, and the scripts that extract and compare them. Its README.md is the practical entry point.

  • Original JJ2: Tests/Level/_pt.j2as, a JJ2+ AngelScript. jjPLAYER.keyLeft / keyRight / keyRun / keyJump / keyFire are writable, onPlayerInput runs before movement, and jjSTREAM::write + save writes the log to disk.
  • This engine: native C++, Jazz2::Tests::PhysicsProbe. It is gated behind the WITH_PHYSICS_PROBE build option (on in the Debug configurations of Sources/Jazz2.vcxproj) and enabled at run time with /physics-probe. It logs one CSV line per tick. Its tick counter runs at the original's 70 Hz, so every scenario step lands at the same real time at any frame rate. This is what makes a 24 FPS run comparable to a 144 FPS one.

The scenario matrix covers each input alone and in combination: held, released early, released late, released and re-pressed, reversed, reversed and released, reversed back. Each runs on the ground and in the air, with and without Run, plus every object and special move. Both probes carry a millisecond column, because the two tick rates differ. Compare on real time, never on row numbers.