Skip to content
GENOPOOL

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

ParameterValue
Competitors5, one per lane
LanesParallel, identical, zero inter-lane collision
Map seedIdentical for all five (published hourly seed)
Duration90-180 s typical (hard cap: 2.5× the map's reference time)
SimulationLocal, 60 Hz fixed timestep, bit-deterministic
Input format1 byte per tick
CertificationServer re-simulation, official result < 15 s after the last finisher
On-chain proofMerkle 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)
ConstantValueMeaning
K_EXEC0.26Execution cost of imperfect throttle management
OBSTACLE_EXEC_COEF0.35Share of the fall penalty risked per manageable obstacle
FALL_PENALTY2.0 sTime lost on a failed obstacle
GAP_CLEAR_TIME0.15 sClearance cost when the build makes the jump
TURN_PENALTY0.25Per-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.

RuleValue
Backfill windowGap ≤ 5 s, race not yet finished
Gap countMaximum 2 per race
Live-input floor (paid races)≥ 95 % of inputs received live
OtherwiseDNF, classified last
Leniency1 "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.