Road Rage Overdrive

Inspiration

I wanted to take the classic 1980s top-down arcade driving formula — cross a map, grab trophies, outrun relentless chase cars, keep an eye on fuel and engine heat — and turn it into something built for Reddit: a daily event the whole community plays together, with a leaderboard you can actually trust. The "Games with a Hook" theme pushed me to make the hook competitive integrity — everyone races the identical world each day, and no score is taken on faith. I'd already shipped two daily Devvit games on that model, and I wanted to prove it works even on a fast, physics-y driving game, where verifying a run server-side is genuinely hard.

What it does

Road Rage Overdrive is a daily two-minute top-down driving sprint. Every day the whole community races the same procedurally-generated world from a shared seed:

• Grab trophies — each one raises your score; clear all 15 to end early and it becomes a time trial.
• Dodge two relentless chase cars and deadly obstacles — including the tombstones your own crashes leave behind.
• Manage fuel (refuel by driving over gas stations) and engine heat (sustained top speed overheats and caps your engine until it cools).
• No game over — a crash respawns you at the center and costs precious seconds. The clock is the enemy.
• Six real-world regions rotate day to day.
• Leaderboard + ghosts — your run is verified server-side, and you race translucent ghost cars of the day's top drivers on the exact same clock.
• Plus cosmetic extras: achievements, selectable control schemes, a procedural engine synth, and post-apocalyptic atmospheric weather.

How we built it

• Stack: Devvit Web (Hono serverless + Redis) · Phaser 4 webview · TypeScript.
• A pure, deterministic core. The entire simulation lives in a shared module with no DOM, no Phaser, no Math.random, no Date.now — so it runs bit-for-bit identically on the client and the server. The whole game is a pure function of (daily seed, recorded inputs) on a fixed 1/60s timestep.
• Server-verified scores. The client records your 4-button input every step; on finish it sends a packed replay. The server re-simulates that replay to compute the authoritative score — the client is never trusted. The leaderboard is a Redis sorted set with a composite key (trophies → time → first-come).
• Ghosts reuse the anti-cheat. The same replay system that verifies scores also redraws rival routes, so ghost racing is basically free.
• Cross-runtime determinism. To make the sim reproducible across two JS environments I replaced all trig in the enemy AI (atan2/sin/cos) with an integer 16-sector heading lookup, used squared distances for comparisons, baked the land/water map mask into a shipped data file (identical integer lookups on both sides), fixed the timestep, and consumed the seeded RNG in a strict order.
• Tests lock it down. Golden tests (same seed + inputs ⇒ identical result) and parity tests (a recorded client run re-simulates to the identical outcome server-side).
• Cosmetic layers never touch the sim: HUD/minimap/radar, particle trails (skid/dust/nitro), the Web Audio engine, achievements (localStorage), original music, and the weather FX.

Challenges we ran into

• Determinism on a fast, collision-heavy game. Floating point and trig are the enemies of reproducibility; getting a driving sim to agree to the bit across client and server meant redesigning the math (sector lookups instead of atan2, squared-distance compares, a baked integer map mask, a fixed timestep, ordered RNG).
• Server re-simulation cost. Enemy-vs-obstacle collision is O(cars × ~1,600 obstacles) per step, and the server re-runs the full two minutes on every submit — keeping that fast enough took care.
• Reddit's mobile webview mis-measures its own size at load, so I dropped Phaser's auto-scaling on mobile and own the canvas sizing myself for a clean portrait fill (no rotation), while desktop stays a letterboxed 4:3 stage.
• Phaser 4 is new — dual-camera setup so the HUD isn't scaled by the world zoom, plus particles and bitmap fonts.
• Design: compressing a full fuel/heat/enemy driving game into a tight, fair, un-cheatable two-minute daily.

Accomplishments that we're proud of

• A genuinely tamper-proof daily leaderboard for a real-time driving game — every score is re-simulated server-side, not trusted from the client.
• Bit-for-bit determinism across client and server, proven by golden + parity tests.
• One replay system doing double duty: anti-cheat verification and ghost racing.
• Shipping it polished, solo, on a brand-new engine version — six rotating maps, achievements, a procedural engine synth, original music, and cosmetic weather.

What we learned

• Designing for determinism from line one changes everything: no clocks, no RNG, no trig hiding in your systems — a pure core you can test to the bit.
• How far Devvit's server + Redis model can carry a competitive game that needs real integrity.
• Hands-on Phaser 4 (cameras, particles) and the quirks of the Reddit webview.

What's next for Road Rage Overdrive

• Race your own best (a personal self-ghost) alongside rival ghosts.
• More regions and daily themes, and tying the atmospheric weather to the daily seed so it's shared and fair for everyone.
• Seasonal leaderboards and a weekly difficulty ramp.
• More control schemes and further mobile polish.
• Performance: a spatial grid to speed up server re-simulation as the world grows.

Built With

• aseprite
• devvit
• eslint
• hono
• html5
• javascript
• localstorage
• node.js
• phaser.js
• reddit
• redis
• typescript
• vite
• vitest
• web-audio-api