Methods and checks

Answer and scope

We tested five presets in RocketSim. We used isolated car-ball physics for no-flip hits and airborne dodges, then genuine Soccar collision meshes for ground-start flips and carry/flicks. We have not reproduced these shot speeds in Rocket League.

In the no-flip search, we found Breakout's fastest accepted shot at 118.067 kph, 0.491 kph above Octane. We started the car at 82.8 kph and the ball approaching at 36 kph. Breakout's stationary-ball lead was 0.054 kph; Dominus led the awake near-stationary control. A larger search may change these rankings.

We freeze the ranking after the search and the stated transfer stage. We report later execution-error tests apart from that ranking, including any higher valid speeds. Some perturbations, such as changing A's fixed initial orientation, fall outside the nominal setup.

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.

We use Plank for the 2016 Batmobile and list Hybrid as a physics preset. The no-flip approaching and stationary columns use matched initial conditions across presets. We calculate each delta against Octane in the same test.

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. We end a contact episode 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. We measure contact offset and rotational recoil alongside forward reach.

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. For grounded B/C, we shift the 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. Each of the five highlighted no-flip winners has two adjacent callbacks and one additional impulse.

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.

Grounded results

We ran 6,000 candidates per preset in each grounded test, then transferred the five winning schedules across presets. We kept the original search winners and saved transfer improvements apart from them.

Ground-start flip setup

We start each car on its measured wheel-rest pose at 64.8 kph, with 100 boost and zero angular velocity. The ball starts 3 m above the field with zero spin and a downward velocity of 0.001 uu/s to keep it awake. We search initial distance, lateral position and yaw, first-jump timing, hold/release, dodge direction, air controls, boost duration and steering. We require a directional dodge before the first contact and one completed contact episode.

Carry and flick setup

We start car and ball at 43.2 kph. We place the ball 2 uu above the roof tangent at the hitbox center. We search carry duration and throttle, then jump, dodge, air controls and boost; boost begins with the first jump. We require six grounded roof-contact ticks before that jump, at least two separated episodes, and a flipped final contact. The control family has 11 parameters; it does not cover every possible 240-tick input sequence.

We stop both grounded tests before the ball reaches an unrelated world bounce, even if the car has not touched it. We reject initial overlaps, unfinished episodes and contacts close enough to the floor or a car-body world collision to risk a pinch. We use the same forward cone as the no-flip tests.

Launch-contact measurements

For flicks, we report the first flipped callback in the final episode. Earlier carry contacts can change the incoming ball speed and car rotation. The full CSV keeps those earlier contacts.

Grounded execution sensitivity

We keep these perturbations outside the ranking stage. Their valid peaks can exceed the selected nominal result.

Contacts later in the dodge

We also selected the fastest accepted original-search candidates whose first contact came at least two ticks after the dodge, with incoming car speed at or below 82.8 kph. We did not run a separate optimization for this subset.

Arena extraction and setup checks

We extracted 16 Soccar collision meshes from DFH Stadium Day through Proton, using Rocket League's official anti-cheat-disabled launch mode. We changed the dumper's process lookup to Wine's implemented Unicode API and ran it inside the game's existing runtime. An initial capture returned 10 meshes; a later capture passed the unchanged 16-mesh Soccar classifier. We matched all 16 RocketSim reference hashes and recorded SHA256 hashes for the file bytes. We keep the game assets private.

We checked wheel settling for all five presets, a floor bounce and a corner-mesh bounce. We cache each measured rest pose as state data and load it into a fresh arena for each trial. Ten before/after checks matched trajectories and contacts when we added this cache. The cache does not retain the settling arena's solver history.

We also added a carry regression check: a sequence with only four grounded roof-contact ticks before jumping now fails, even if it touches the ball more often during the jump. The grounded pilot and test logs record these checks.

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)

We found the highest accepted airborne-dodge speed with Breakout: 132.448 kph, after the search and equal-budget transfers. We keep this test apart from ground-start flips.

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. We calculate the angular term as (omega × contact_offset) · normal and add pivot velocity for total contact velocity. Contact locations/normals are geometry-reconstructed and cross-checked against the actual sphere-side callback, as in A.

We measured incoming car speeds above the usual 82.8 kph cap on the dodge-input tick. RocketSim applies the dodge impulse in _UpdateDoubleJumpOrFlip, processes collisions, then clamps car speed in _FinishPhysicsTick. All five selected airborne shots contact on that tick. Their pre-impact spin comes from earlier air controls; the new flip torque has not yet built rotation. We have not verified this transient-speed behavior in Rocket League or optimized a delayed-contact airborne variant. The normal car cap and 216 kph ball cap remain unchanged. The timing-error table records the cost of missing this tick.

We improved several presets by transferring another preset's winning sequence. The table retains the original search peaks alongside the transfer-pooled values.

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

Run benchmark.py run --category B_air --budget 6000, then rank_air_transfers.py, audit_replays.py and visualize.py. This category needs no arena meshes. For B/C, use the verified Soccar assets and the grounded setup below.

Geometry diagrams

Open the convergence, transfer and sensitivity charts.