nine to die

The 9-to-5 is trying to kill you. Fight back, three seconds at a time.

Comment

Nine to Die

A roguelike deckbuilder where every card is a 2-second reflex microgame. Climb the tower. Find out who's really in charge.

Inspiration

Two ideas collided. The first was a deck where each card is a tiny skill check instead of a menu button. Rather than tapping "attack" and watching a number happen, you earn the hit in the moment. You mash a button, stop a spinning dial, trace a path, or hold steady for two seconds. Every card is a 1 to 3 second hands-on test, so you play combat instead of selecting it.

The second was the quiet horror of corporate life. I turned the office into a dungeon. You are a temp climbing a nine-floor tower, and the monsters are the meetings: a Reply-All Storm, a Micromanager who leans in and flicks your forehead, a "Wellness Policy" that attacks you, a company store that bleeds your gold one supply at a time. Waiting at the top is a boss whose identity is the run's mystery. Who is really running this place?

I wanted it to feel native to Reddit. It lives inside a post, remembers who you are, and turns a subreddit into an office where everyone is grinding the same daily shift.

What it does

  • Deckbuilder combat where the cards are the minigames. Every card (attack, block, buff, heal) resolves as a short touch skill check drawn from 15 distinct mechanics: mash, tap-timing, dial-stop, charge-release, directional sequence, balance, catch, flick, scribble, blink-timed quickdraw, path-trace, rhythm-stamp, sort, whack, and tracking-hold. Enemy attacks are the same minigames, played as a dodge.
  • A satirical corporate-hell roguelike map, with branching floors, shops, narrative events that carry real costs and rewards, a lockpicking treasure minigame, and department-flavored enemy families climbing toward that final-boss mystery.
  • The Hook is persistent, cross-device progression tied to your Reddit account. A rank ladder unlocks new cards and difficulties. Runs resume anywhere. Win streaks, run history, three leaderboards, and live community stats sit on the post itself, and a daily "today's shift" seed puts the whole subreddit in the same office.
  • A Reddit-native social loop. End a run and drop your auto-generated performance review into the thread as a real comment, which turns solo climbs into a back-and-forth.
  • Fully touch-first and entirely hand-drawn, with an original doodle art style and a mostly-original synthesized soundtrack. No keyboard, no placeholder art, no silence.

How I built it

Phaser 4 and TypeScript on Reddit's Devvit Web platform. The client is Phaser plus Vite. The server is Hono running on Devvit's Redis. Shared types and generated data live in one place that both import. A few decisions mattered most.

  • A scene-per-microgame architecture. Each of the 15 reflex games is its own Phaser scene with a shared verdict pipeline, so they stay isolated but feel like one game.
  • A data pipeline as the single source of truth. All content (cards, enemies, map, events, relics) is authored as JSON and compiled through a zod-validated build with schema, referential-integrity, and map-reachability checks, into one typed bundle the client and server both consume. Nothing drifts between what the UI shows and what the server resolves.
  • Server-authoritative everything. Identity, progression, stats, and scoring resolve from the trusted context.userId and never the client, because a leaderboard on Reddit will get poked at.
  • A deterministic daily run. Every content roll (event picks, shop stock, enemy rosters, relic grants) is reseeded from the same (date, node) key, so two players on the same day get the identical office:

$$s_{d,n} = H(\text{date}_d \, \Vert \, \text{node}_n)$$

  • An original, procedural art system. Every card, enemy, icon, and UI element is a hand-authored SVG "ballpoint doodle" rendered from a registry, with nothing photobashed or generated.
  • A bespoke verdict-animation layer I call flourishes. Every one of the game's 82 cards resolves with its own hand-inked win or fail beat, a success payoff and a failure break, choreographed in the same doodle style. A phone lights up and bonks you awake. A check tears in half and papercuts the target. A synergy buff's gears grind and jam on a whiff. I synthesized 20 sound effects from scratch with ffmpeg to sell them.
  • Original music. The combat and boss themes are chiptune I composed and rendered in-repo from raw oscillators. The map runs a mellow CC0 lounge loop, because the office soundtrack really is elevator music, which is the joke.

Challenges I faced

  • Rebuilding from an executable spec instead of porting. An earlier prototype of my own served only as a runnable reference, and I rewrote the combat and run-state logic as new TypeScript for the webview. Along the way I found and fixed real bugs baked into that spec: an inverted success condition on enemy attacks, an unreachable victory screen, a broken supply economy. I fixed them rather than reproducing them.
  • Balancing 15 different touch games to feel fair across three difficulty multipliers, with no shared physics or timing framework between them. Every one had to be hand-tuned for a phone screen.
  • Making the daily seed deterministic across every random subsystem, so the shared-shift promise actually holds.
  • The Reddit webview reality. Touch-only interaction, 44px-plus targets everywhere, a sub-3-second cold start, and a post-versioning model where a published post renders the build it was created under. All of that shaped how I ship and test.

What I learned

  • Adversarial self-review works as real QA. I ran per-feature and per-card review passes before shipping, each pass tasked with trying to break the build. That is how client-forged score exploits, resume-corruption edge cases, and a class of animation bugs (verdict beats that reset scale but left the card resting off its slot) got caught and closed.
  • A validated data pipeline pays for itself. Once the schema and integrity checks were in place, adding content stopped causing UI and server drift, and "impossible map" mistakes became build failures instead of playtest surprises.
  • You can build a lot from scratch. Original art, original music, and original sound effects were all synthesizable in-repo with no external assets, which kept the project CC0-clean and gave the game one coherent hand-drawn voice.
  • Devvit's deploy and version model rewards discipline. Verify on a dev subreddit first, promote deliberately, and know which changes ride an in-place upgrade versus which need a fresh post.

Accomplishments I'm proud of

  • 15 distinct, fully touch-native reflex minigames, each now with its own bespoke win/fail flourish and sound.
  • A persistent Hook system that is server-authoritative from day one, covering identity, resume, three leaderboards, streaks, and history.
  • An original hand-drawn art system and a mostly-original synthesized soundtrack, so the fiction, the visuals, and most of the audio are all mine.

What's next

Relic passive variety, deeper multi-phase bosses, and the accessibility pass (colorblind-safe palettes, adjustable minigame timers).

Built With

Share this project:

Updates

Submission history