Document GP-DOC-11: Racing
Race Format & Piloting
A Genopool race is a contest of skill against the clock, run in parallel. Five handlers, five lanes, one circuit. Every element that could differ between competitors has been removed by construction; what remains is the genome you chose to field and the way you pilot it.
The format
| Parameter | Value |
|---|---|
| Competitors | 5, one per lane |
| Lanes | Parallel, identical, zero inter-lane collision |
| Map seed | Identical for all five (published hourly seed) |
| Duration | 90-180 s typical (hard cap: 2.5× the map's reference time) |
| Simulation | Local, 60 Hz fixed timestep, bit-deterministic |
| Input format | 1 byte per tick |
| Certification | Server re-simulation, official result < 15 s after the last finisher |
| On-chain proof | Merkle root of all replay hashes, published hourly |
Two properties define the format:
- Symmetry of randomness. All five lanes run the same seed, therefore the same segments, the same hazards at the same coordinates. Nobody draws a better track.
- No inter-lane interaction. Lanes never touch: no collision, no drafting, no blocking. Each of the five simulations is fully independent, which is what makes local simulation, ghosts, and per-participant re-simulation possible at all.
The map is revealed before registration: segment list, terrain types, lengths. Choosing which creature from your stable to field on this circuit is the first layer of skill, and it is exercised with complete information. See Terrain × Morphology for how circuits price stats.
Netcode in one paragraph
Each client simulates its own creature locally at a fixed 60 Hz timestep with a seeded
PRNG: no wall-clock deltas, no Math.random anywhere in the simulation path. Opponents
are rendered by re-simulating their input streams; since the simulation is
bit-deterministic and lanes do not interact, inputs are sufficient: no positions ever
cross the wire. Each input is one byte: bits 0-3 encode the effort throttle (16
quantized levels), bit 4 jump, bit 5 brake/impulse. A network outage does not interrupt
your race; it only delays what your opponents' lanes display.
The energy model
Piloting is resource management under a hard budget. On each segment the pilot selects an
effort e:
v = v0 · √e // speed on the segment
cost = e0 · e^1.5 // energy burn (ENERGY_EXPONENT = 1.5)
S = STM × 1000 // total budget (STAMINA_SCALE)
e ∈ [0.05, 1.5] // E_MIN (walking floor) … E_MAX (overdrive)
Pushing harder costs super-linearly: doubling effort buys ~41 % more speed for ~183 %
more energy. Exhaust the budget S and the creature drops to ×0.5 speed
(EXHAUSTION_FACTOR) for the remainder: a deliberate burn on the final straight is a
legitimate line; an accidental one is a lost race.
The optimal allocation has a closed form (Lagrange over the segment sequence):
e_i ∝ 1 / √(v0_i · cost_i) // then scaled to saturate the budget S
Push where the track is efficient, conserve where it is not. Stamina builds run flat-out on long circuits; sprinters must ration: circuit length is itself a meta lever.
The skill layer: deterministic by design
The gap between a perfect pilot and a real one is modeled without a single roll of chance:
time = optimal_time · (1 + (1 - skill) · K_EXEC) + obstacle_exposure · (1 - skill)
| Constant | Value | Meaning |
|---|---|---|
K_EXEC | 0.26 | Execution cost of imperfect throttle management |
OBSTACLE_EXEC_COEF | 0.35 | Share of the fall penalty risked per manageable obstacle |
FALL_PENALTY | 2.0 s | Time lost on a failed obstacle |
GAP_CLEAR_TIME | 0.15 s | Clearance cost when the build makes the jump |
TURN_PENALTY | 0.25 | Per-length turn cost, scaled by agility deficit |
Moving from median piloting (skill 0.5) to perfect piloting is worth roughly 8-15 % of final time, large enough that the pilot is the dominant factor, small enough that the mount matters. Two identical genomes, better pilot: better time, every time, deterministically. The race outcome contains no RNG whatsoever.
Certification & anti-cheat
The official trace is the live stream: the server assembles each participant's input trace from packets received in real time, then re-simulates every trace on the exact engine build and compares finish tick and state hashes.
- A packet arriving more than 2 ticks ahead of the server's reconstructed clock is rejected: you cannot send the future, which closes the tool-assisted-run vector.
- A mismatched trace is rejected: its author is classified DNF and flagged.
- Every replay hash is accumulated and the Merkle root is published on-chain once per hour; the full trace stays downloadable, so anyone can re-simulate and verify. See Provably Fair.
Disconnections
Because the simulation is local, a network cut does not stop your race: the client keeps simulating and buffers inputs.
| Rule | Value |
|---|---|
| Backfill window | Gap ≤ 5 s, race not yet finished |
| Gap count | Maximum 2 per race |
| Live-input floor (paid races) | ≥ 95 % of inputs received live |
| Otherwise | DNF, classified last |
| Leniency | 1 "technical incident" per 24 h: ticket refunded if the cut occurs before 30 % of the race with ≥ 4 racers remaining |
An abandoned race is never silently refunded outside the bounded leniency: an open-ended refund on quit would be a collusion vector.
Formats, entry gates and prize structures are specified in Official Brackets & Matchmaking.