RocketSim hitbox benchmark — simulations, not game validation

72,000 no-flip search trials across five presets. Airborne flip supplement below; grounded flip/flick results unavailable: arena meshes missing. See full Markdown report, CSV table, and matched conditions.

Measured comparison

Airborne flip results — isolated simulation

Within-tick caveat: legal dodge impulses can produce pre-clamp car speeds above 82.8 kph at impact. Ground-start flips remain untested. Protocol, contact vectors, caveats and controls.

Octane airborne dodge

Dominus airborne dodge

Plank airborne dodge

Breakout airborne dodge

Hybrid airborne dodge

No-flip controlled hits

Centered baseline

Front face versus edges and corners

Contact measurements

Sensitivity

Simulation replays: fastest nominal no-flip condition

Octane

Stationary-ball replay

Dominus

Stationary-ball replay

Plank

Stationary-ball replay

Breakout

Stationary-ball replay

Hybrid

Stationary-ball replay

RocketSim hitbox benchmark — executed results

Answer and scope

No universal fastest hitbox established. The airborne-dodge supplement below runs without arena meshes; ground-start flip/flick experiments remain blocked. Arena collision assets are absent. Experiment A ran in RocketSim's supported THE_VOID with standard Soccar car–ball physics; grounded B/C were not executed. Their legal-control search paths exist but remain integration-untested until meshes are supplied.

Among nominal search-stage candidates, Breakout produced the highest forward no-flip speed found within the tested conditions: 3279.633 uu/s = 118.067 km/h, 0.491 kph (0.418%) above Octane. Conditions: initial car speed 2300 uu/s, ball velocity (−1000, 0, 0) uu/s, isolated aerial front-face strike, one contact episode. Its stationary-ball lead was only 0.054 kph (0.046%). The almost-stationary awake-ball condition instead favored Dominus. These are finite-search outcomes, not upper bounds or evidence of a universal advantage.

Ranking stages are not pooled. The table reports optimization candidates obeying A's zero initial orientation. Held-out execution diagnostics allow ±0.5° orientation errors and approach-phase changes, sometimes exceed nominal search speed, and can lie outside search initialization bounds. Their higher measured speeds and validity are separately published below; they are not silently discarded or mislabeled as new zero-orientation optima.

Seven named bodies plus Hybrid preset: five configurations

Octane, Fennec, Harbinger and Scarab are represented by exactly the same CarConfig.OCTANE object definition. Their ties are by construction, not independent simulated measurements. Epic's indexed help article and current search results corroborate the requested mapping; direct article retrieval hit a Cloudflare challenge. Saved source snippets and retrieval limitations are in ../evidence/. Visual-model fit is unmeasured.

Plank is already represented by the 2016 Batmobile; Hybrid is added as a physics preset, without inventing a cosmetic body. Best straight above compares the five presets under identical approaching-ball initial conditions; the stationary column provides the controlled zero-ball-speed comparison. Percent changes are within category relative to Octane; unexecuted categories have no percentages.

Executed design

- Target world +X. Optimize total outgoing speed with |horizontal yaw| ≤5° and elevation in [0°,30°]. CLI cone bounds configurable; protocol.json records actual values. Report +X velocity separately. 120 Hz, default gravity (0,0,−650) uu/s², default 2300 car / 6000 ball speed caps, masses 180/30, ball radius 91.25 uu, ball drag 0.03. No modified impulses, restitution, friction, car inertia, or angular caps. Ball orientation integration enabled (no_ball_rot=False); physical spin retained. No other cars or arena surfaces exist in A.
- A starts with zero car orientation, zero angular velocity, zero ball spin, 100 boost, all controls neutral. Ball starts at (0,0,1100). Car speeds: 1000,1800,2300. Ball velocities: (0,0,0), (−1000,0,0), (+1000,0,0), and (0,0,−0.001) uu/s. These are matched initial velocities; actual incoming velocities include drag, gravity and speed clamping and are recorded, not assumed equal.
- First candidate is centered front-face (lateral=vertical=approach angle=0; nominal lead=6 ticks). Sweep contact lateral/vertical coordinates relative to hitbox center, normalized by half-width/half-height, over [−1.8,1.8]; sweep velocity approach heading over [−20°,20°] while initial orientation remains identity. Lead-time search spans 4–8 ticks. Align sphere/rounded-box tangency using offsets and margins, then back up along relative velocity; compensate nominal differential falling displacement. Actual Bullet contact is measured, not snapped onto a face. baselines.csv, conditions.csv and raw trials retain edge/corner trials and rejected candidates.
- Stationary-ball anomaly: RocketSim puts an exactly zero-velocity, zero-spin ball to sleep every tick. Its airborne position stays fixed until touched, despite nonzero gravity. We preserve and expose this stock behavior; do not call it a realistic falling ball. The −0.001 uu/s vertical control starts almost stationary, remains awake and falls normally. No fake gravity impulse or per-tick repositioning was used. Incoming-ball velocities measure the difference.
- Reject initial geometric interpenetration with Bullet's rounded-box convention. Save pre-solver contact callback states; classify surface from geometry. Python exposes the actual sphere-side callback point, not the car-side Bullet manifold point. Reconstruct the car contact point and normal from the rounded-box surface at that state; reconstruct the independent callback normal from the rotated local sphere point to quantify agreement. Contact velocity uses that geometry-reconstructed car point, not an unexposed exact manifold coordinate. A contact episode ends after a callback-free physics tick with signed separation >1 uu. Callback count is not episode count; positive-gap callback impulses are retained and flagged. A/B reject multiple episodes and unfinished episodes. Observe A for all 96 ticks (0.8 seconds), not just until a convenient speed peak. Measure ball velocity at the end of the final contact-callback tick, before any unrelated bounce.
- 72,000 no-flip search evaluations: 5 presets ×12 initial-velocity conditions ×1200 candidates. One seed, 20260909, identical bounds/budget for every preset. Each condition: 316 coarse evaluations (including baseline), 24 additional random population members, then 860 differential-evolution candidates; population 48 starts with 24 coarse elites plus 24 seeded uniform candidates; DE/rand/1/bin F=0.7, CR=0.8, immediate updates. No independent multi-seed uncertainty estimate. Every candidate saved, RNG/population/checkpoint every 128 candidates. Search runtime 275.10s, excluding pilot/replay/visuals. Pilot: 120 trials, see pilot.json. Best-so-far convergence retained in each checkpoint.
- Every one of the 60 no-flip condition winners replayed from the exact serialized inputs to SetState, avoiding lossy UU↔Bullet readback. Every tick's complete neutral input schedule saved; nominal physical trajectories and contacts audited by audit_replays.py. Cross-preset transfer reuses controls, approach parameters and normalized geometric alignment, not tuned target-specific offsets: cross_preset.json (25 transfers per highlighted condition; airborne flips kept in their own category).

Centered baseline versus contact placement

Stock-maximum car speed, exactly stationary ball:

Centered faces are not equally high relative to the COM. Moving contact closer to COM height substantially narrows the initial difference. This supports examining contact offset and rotational recoil, not simply assuming a longer forward reach transfers proportionally more speed.

Surface-specific highest valid search candidates at initial car speed2300 (not separately budgeted optimizations for each surface):

All-condition surface counts and peaks are in surface_peaks.csv; absent valid candidates are not zero-speed results.

Contact measurements: fastest nominal no-flip conditions

All vectors below share world axes except explicitly local contact positions. Displayed velocity components are kph; angular velocities rad/s; contact positions uu. Cross products are computed consistently in uu/s before display conversion. Full raw uu/s vectors, contact locations, normal directions, first/last callback data and extra velocity impulses: contacts.csv and each winner.json.

Initial angular velocity at first contact is exactly zero for every A winner. Rotation measured at the second callback was generated by collision response, not supplied as a flip. Every highlighted shot has two callbacks in one continuous episode. Discrete-step penetration at impact is possible despite a nonpenetrating initial state; gap measurements are saved. The additional impulse is applied on the first callback tick, not again on the adjacent second tick.

Pivot geometry: calculations, not fitted visual models

Local X=forward, Y=right, Z=up. CarState.pos is Bullet rigid-body origin/COM, the rotation reference; hitbox center is offset from it. front_reach=L/2+offset_x, rearward reach magnitude L/2−offset_x. Bullet dimensions already include face margins: do not add a second margin to length. The box constructor subtracts margin from inner half-extents; sphere/box contact rounds edges with that margin. Margin is min(2 uu, 10% of smallest half-extent). Edge/corner distances below refer to nominal sharp-box top/bottom edge midpoints and front-side corners, not the inward-rounded physical corner. Bottom front edges are closest to these winning contacts. Actual contact offsets are measured independently.

Breakout's forward reach is 7.240% longer than Octane's, not a 7.240% ball-speed gain. Measured stationary search-stage difference is 0.046%; approaching-ball difference 0.418%. Winning contact positions are near the COM height, not the furthest front-top corner.

At each callback, v_contact = v_pivot + omega × (contact_point − pivot_position) in world coordinates; the benchmark records its dot product with the car-to-ball contact normal. For an unrotated front-face normal +X and pure pitch omega=(0,ωy,0), the rotational contribution is (ωy*r_z, 0, −ωy*r_x): more forward reach directly changes vertical contact motion, not automatically the forward component. A has zero pre-impact rotation, so a rotational-lever explanation for its first impact is unsupported.

Mechanistic interpretation, not a causal ablation: changing presets also changes inertia and contact height relative to COM, affecting recoil/rotation and effective collision mass. RocketSim then adds its own velocity impulse based on relative linear speed, COM-to-ball direction, Z scaling 0.35, forward-direction adjustment 0.65, and a speed-dependent factor curve (0:0.65, 500:0.65, 2300:0.55, 4600:0.30), capped at relative speed 4600 before scaling. It suppresses an extra impulse on consecutive ticks. The measured ~1456 uu/s extra impulse is not all of the final ~3280 uu/s velocity; incoming ball momentum, the Bullet solver, friction, inertia and gravity also contribute. No lever-only collision law replaces this logic.

Execution sensitivity (not simulator-accuracy uncertainty)

Every condition winner receives 14 one-at-a-time errors: ±2 uu car position on each world axis; ±0.5° initial yaw, pitch and roll; and ±1 tick timing. A has no timed controls, so timing means shifting the initial car by ±v_initial/120 while fixing the initial ball. Grounded B/C would shift the entire control schedule by a tick. Nominal plus 14 samples determine peak/median/range; valid fraction excludes nominal and uses all 14 errors. This deterministic stencil is not a random human-error model or confidence interval. No-contact/interpenetration cases count invalid, with speed zero. Below: all-condition nominal winners. Stationary diagnostics are separate in stationary_sensitivity/.

Many invalid perturbations still have high speeds but slightly negative elevation. Cone compliance, especially at the zero-elevation boundary, matters more than tiny headline speed differences. Diagnostic peak can exceed nominal peak; the table explicitly separates valid and invalid peaks. Initial-angle perturbations are outside A's zero-orientation ranking constraint. Repeating one sequence on another preset also changes direction; no guarantee a high-speed transfer remains a forward shot.

Geometry-derived normal versus callback sphere normal differs by at most 0.00751 in vector norm across the no-flip search (GJK/numerical corner behavior); highlighted winners have much smaller errors. Some callbacks occur at positive separation (maximum 1.835 uu across no-flip trials), and the additional impulse can be applied there. This stock contact-proximity behavior is retained, not interpreted as a new hit or proof of real-game accuracy. Every highlighted winner receives only one extra impulse within its two adjacent callbacks.

All speed infographics use kph, including an absolute Δkph versus Octane chart. Kph and km/h denote the same unit; raw uu/s remain in the measurement files for reproducibility.

No highlighted winner saturates the 6000 uu/s (216 km/h) ball cap. No Rocket League replay validation was performed. RocketSim itself describes its accuracy as approximate; numerical/contact-callback behavior and the sleeping-ball shortcut limit real-game inference. Execution robustness within this simulator is not uncertainty about simulator fidelity.

Blocked B and C: what remains

Ground-start B (forward and diagonal dodge/TAS shots) and C (controlled carry, multi-contact flick) were not executed: SOCCAR construction raises No arena meshes found for gamemode soccar. No invented results or zero-speed stand-ins. Source paths include searches, replay, contact/forward/pinch filters and sensitivity; their full physical integration still requires assets.

B protocol: settle actual wheel suspension for 120 ticks away from the ball; use that rest pose in a fresh arena, zero angular velocity, initial car speed 1800, boost100; fixed ball (0,0,300), v=0, spin=0. Initial horizontal position is 200–1800 uu behind geometric front tangency and lateral ±250; yaw ±15°, rest pitch/roll. Window 240 ticks. Optimize ground steering, first-jump tick 0–80, hold 3–24, release-to-dodge 2–65, forward/diagonal dodge angle ±60°, pre-dodge pitch/yaw/air roll ±1, boost duration0–160, post-dodge pitch/cancel ±1. Throttle fixed1; handbrake false. Rotation comes only from controls and physics. A collision must occur after a real directional dodge; exactly one episode allowed. Input controls are all within legal [−1,1] ranges.

C protocol: same settled/fresh-arena process, speed1200 for car and ball, boost100, car pivot X=−1200; ball initially 2 uu above the roof-tangent sphere position at the hitbox-center X/Y, zero spin and car angular velocity. No initial penetration. First-jump timing12–80 ticks, hold3–24, release-to-dodge2–65, dodge angle±180°, pre-dodge pitch/yaw/roll±1, boost0–160, steering/cancel±1. Requires at least six distinct pre-flip contact ticks and at least two separated car–ball episodes, with a post-flip contact. Record full sequence; never put C in single-hit rankings. Both grounded searches use 6000 evaluations/preset when enabled. B coarse432; C coarse216. These template families are bounded TAS searches, not all possible 240-tick control combinations.

To unblock: on Windows, launch Rocket League, enter standard Soccar free play, run [RLArenaCollisionDumper](https://github.com/ZealanL/RLArenaCollisionDumper). Copy its entire collision-meshes/ directory here, including soccar/*.cmf. Do not fabricate or substitute arbitrary meshes. Run benchmark.py probe, then B and C with the commands in ../README.md. This Linux host has no running Windows Rocket League process; a legitimate arena dump cannot be generated from the simulator alone. Recheck mapping/physics after any future game update.

Artifacts and sources

- cars.csv/json/md: seven bodies plus Hybrid preset; conditions.csv: all 60 no-flip matched groups; baselines.csv: centered front-face baselines.
- measurements.csv.gz: all candidates; per-group trials.jsonl.gz: full records; checkpoint.json: seeds/RNG/population/runtime/convergence; winner.json: complete initial states, controls, contacts, trajectory.
- contacts.csv, cross_preset.json, all per-group sensitivity.json; environment.json, protocol.json, assets.json, pilot.json, aggregate.json.
- *.png: charts/pivot/contact diagrams. simulation_*.gif: approaching-ball winners; stationary_*.gif: stationary winners. Wireframe physics boxes, not car-body meshes; simulations, 0.2× playback, first 0.3 s shown. Full 0.8 s trajectories remain in JSON.
- Simulator installation and accuracy: https://github.com/ZealanL/RocketSim . Inspected upstream HEAD c2baacb8f4b441dd8505e63c2aeb5a1679b60b02.
- Installed Python binding 2.2.1: https://github.com/mtheall/RocketSim at 2da51b1dac7b8127127613a5ff30e490bdd70dd8 (tag v2.2.1), merging upstream f80f9d90f922315c5877a81987845d3242ff1780. Published Linux x86_64 wheel SHA256 2f9518e9895447d2480680b7825866e881981102c66365c1d9fea62589a0dd9d; extension SHA256 c1f246a531eb7a9b957e39acb8d61d740ec9d1d3befca05d2c05777c543ee023. Wheel matches installed extension. This is published-wheel/tag provenance, not an independently reproduced binary build.
- Installed implementation reads: vendor/python/src/Sim/Car/CarConfig/CarConfig.cpp, Car.cpp (offset compound shape and child-box inertia), src/Sim/Ball/Ball.cpp (additional hit impulse), src/RLConst.h, src/Sim/Arena/Arena.cpp (sleep/contact processing), bundled Bullet3-3.24 btBoxShape.cpp, btSphereBoxCollisionAlgorithm.cpp.
- Binding getter issue: ArenaConfig.max_pos returns minPos in 2.2.1; actual default max bounds come from source (5600,6000,2200). The incorrect getter value and correct source default are both recorded; no broadphase settings patched.
- Mapping source: https://www.epicgames.com/help/c-Category_RocketLeague/c-RocketLeague_Gameplay/rocket-league-car-hitboxes-a000084362?lang=en-US . Search evidence retrieved 2026-09-09; full article was challenge-blocked. Supplemental indexed per-car sources saved under ../evidence/.
- Conversion: Rocket League uu treated as centimeters; 1 uu/s =0.01m/s ×3.6 =0.036 km/h. These are ball velocities, not the rounded in-game goal-speed display.

## Executed airborne-flip supplement (B_air)

Breakout has the highest nominal speed found in this bounded airborne-dodge search plus equal-budget cross-preset transfers: 132.448 kph. This is not a ground-start jump/flip result, a rigorous optimum, or Rocket League validation. Plank and Hybrid are both included; Plank is the existing 2016 Batmobile preset.

### How the flip is legal without arena meshes

Use THE_VOID with unmodified Soccar car/ball physics. Start in a nonpenetrating airborne state with an unused air dodge: is_on_ground=False, has_jumped=False, has_double_jumped=False, has_flipped=False, zero angular velocity, initial car velocity (1800,0,0) uu/s (64.8 kph) and 100 boost. This is an airborne state of the kind available after leaving a surface without jumping or obtaining a flip reset; its prehistory is not simulated or validated in Rocket League. No wheel-ground contact, fake platform, first-jump impulse, or angular velocity is injected. Winner audits also verify no suspension-wheel contacts through first impact and no post-tick car speed exceeding the stock cap. The jump button is pressed for one tick with directional pitch/yaw, so RocketSim itself creates the dodge impulse and rotation; earlier pitch/yaw/roll controls can orient/spin the car legally.

The ball is fixed initially at (0,0,1100) uu with v=(0,0,−0.001) uu/s and zero spin. This tiny nonzero initial falling speed prevents the known stationary-ball sleeping shortcut; gravity remains −650 uu/s². Every preset shares the same ball, initial car velocity and boost. Geometric alignment uses the rotated front-face-center tangent, followed by identical world-axis search displacements.

Twelve bounded parameters: additional X gap50–800 uu, lateral±80 uu, ball-above-hitbox-center displacement±150 uu, initial yaw±15°/pitch±30°/roll0°, dodge tick0–50, direction±60° (0=forward), pre-dodge pitch±1 and yaw/roll±0.5, boost duration0–120 ticks, post-dodge pitch/cancel±1. Throttle1; steering/handbrake0 in air. Window≤240 ticks (2 s), ended earlier if either body leaves conservative central airspace. This boundary is an observation limit, not a physical wall. First contact must occur after the dodge input has taken effect; exactly one completed contact episode, horizontal±5° and elevation0–30° required. All input schedules and exact initial states are saved.

30,000 independent search candidates = 5 presets ×6000; seed20260909, 243 coarse candidates plus the same DE optimizer as A, 212.58s search runtime. Then 25 transfer evaluations (five original winning schedules per target, including its own replay) form a second ranking stage. Promote only valid improvements, save them separately in B_air_transfer_*/winner.json, replay exactly, and run sensitivity around the promoted states. Original independent search winners remain unchanged; air_transfer_selection.json preserves all transfer proposals. The coarse grid includes 0° and ±45° dodges equally. Reported direction buckets are descriptive: near-forward |direction|≤10°, diagonal >10°; these are not independently optimized categories. Every winner is replayed, receives ±1 tick/±2 uu/±0.5° errors, and transfers to every other preset with only documented geometric realignment. air_results.csv, air_measurements.csv.gz, per-condition JSON and cross_preset.json preserve measurements.

### Pivot motion and important speed-clamp caveat

Vectors use world axes, except where explicitly marked; velocity display is kph, raw JSON calculations use uu/s. Rotation before impact comes from controls, not state injection. The angular term is measured as (omega × contact_offset) · normal; total contact speed also includes pivot velocity. Contact locations/normals are geometry-reconstructed and cross-checked against the actual sphere-side callback, as in A.

Stock RocketSim may temporarily exceed the 2300 uu/s (82.8 kph) car cap inside a dodge tick. _UpdateDoubleJumpOrFlip applies its immediate impulse before collision solving; _FinishPhysicsTick clamps speed afterwards. The table exposes above-cap incoming callback speeds and dodge/contact timing. In this run, every selected winner hits on the dodge-input tick. _UpdateAirTorque runs before the new dodge is registered, so the first-contact angular velocity was built by earlier air controls, not by a completed flip rotation. These are legal dodge-assisted hits, not proof that the rotational phase of a flip supplies the observed gain. A separately optimized study requiring contact at least two ticks after the dodge has not been executed. This makes ±1-tick timing sensitivity particularly important. Such shots are legal in this simulator but depend on this within-tick ordering; they are not evidence the same transient collision exists identically in Rocket League. The cap was not raised or disabled. Ball cap remains216 kph. Approach-speed differences, contact orientation, extra car-ball impulses and inertia prevent attributing every speed difference to hitbox reach or rotation alone.

Transfer results undermine a simplistic hitbox ranking: the original Plank search sequence also produces a faster valid shot on Breakout than Breakout's independent optimizer found. Several other presets improve using another preset's sequence. The final table includes these measured improvements; it does not claim an intrinsic Plank/Breakout advantage or that the remaining search gap is irreducible.

A's winning no-flip conditions and B_air have different initial ball/car velocities and setup bounds. Compare presets within each category; do not interpret A-to-B_air gains as a clean causal effect of flipping.

### Execution sensitivity and no-dodge control

Median/range use nominal plus all14 errors; valid fraction excludes nominal. Some errors miss the same-tick dodge/contact coincidence or violate the cone. A shift earlier than tick0 cannot reproduce a dodge before the defined initial state; it is outside the available input window. Sensitivity is not simulator-accuracy uncertainty. Higher valid diagnostic speeds are published separately and not silently substituted for optimization-stage winners.

This removes only the jump input from each exact winning sequence, keeping its initial state and other controls. It is an unoptimized control ablation, not a fair best-no-flip ranking; the no-dodge ball can leave the forward cone and is not a valid B_air candidate.

### Running it, or switching to ground-start flips

.venv/bin/python benchmark.py run --category B_air --budget 6000 works now without meshes. Follow with .venv/bin/python rank_air_transfers.py, then audit_replays.py and visualize.py to reproduce the transfer-pooled ranking and visuals. For ground-start jump/dodge timing, dump genuine Soccar meshes on Windows with RLArenaCollisionDumper and run --category B --meshes collision-meshes --budget 6000. Grounded B and carry/flick C remain unexecuted; no airborne result is labeled as either.