Last Bit Standing

Start Page - 1
Start Page - 2
Start Page - 3
Start Page - 4
Rules on the Start Page
Game Start
Accusation system
Accusation outcomes
Bot Elimination System - Bot is eliminated once it is out of its 3 lives.
Help provided in the game at the top right, stops round timer when used.
First Hint - Indirect guidance to correct answer
Second Hint - Direct Guidance to the correct answer
Third Hint - Reveals the correct answer
Winner screen
Leaderboard updates with each player's turn. Manual Reset button for every time new game has to be started between players.

Inspiration

We began with a simple ambition: take the core ideas of computer science and turn them into something genuinely fun to learn. Not a quiz. Not a slide deck. Not another formula to memorize.

Our first idea was a full 2D platformer. The setup: an AI assistant named ARIA (Adaptive Reasoning & Inference Agent) gets pulled inside GEN, a crashed, hallucinating language model that’s still running. Still generating entire worlds and absolutely delighted with everything it produces. GEN doesn’t realize anything is wrong; it thinks it’s just having a great time making stuff.

We scoped five levels and built two. A sunny suburb made of dialogue‑bubble houses and quotation‑mark fences. A museum where every historical fact is confidently almost correct, patrolled by Incorrect Historians who give ARIA a migraine on contact. A maze. A vibe zone with a roped‑off EXISTENTIAL DREAD section containing a single rubber duck. A chair named Gerald who was convinced it was a dog and followed ARIA everywhere.

The story ended on a blank white screen with a blinking cursor. The message ARIA had been trying to deliver the whole time finally appeared:

“Can you help me with my daughter’s homework? I’ve been trying to explain long division and nothing seems to be working and she’s getting frustrated with me and I don’t want her to think I’m useless at this.”

We adored it. But building that level of detail and complexity in a hackathon weekend wasn’t realistic.

Then one of our teammates built a prototype.

It wasn’t a platformer at all; it was a card table. Six seats, five bots, seven cards in your hand, and a prompt sitting in the middle of the felt. We played one round, and it immediately snapped into place: it was already the same universe. GEN’s Incorrect Historians reappeared as Clippy, confidently slapping down the number 42. GEN’s museum of almost‑facts turned into a hand where six of your seven cards are traps. The broken, hallucinating model became the table itself. Agents that are nearly correct, and yours to call out.

It had everything we were chasing:

--> Just enough gamification: stakes, lives, accusations, a timer

--> Mystery: distinct bot personalities and flavor text that hints without overexplaining

--> Real educational value: you can’t bluff your way through 00001

The escape room became the bots’ personalities. The museum became the question bank. Gerald became the vibe. And we leaned in.

Last Bit Standing is what happens when the prototype turns out to be the game you were trying to build all along.

What it does

Last Bit Standing is a browser‑based, last‑player‑standing encoding card game.

You sit at a virtual table with five bots: Clippy, Hexa, Bitwise, ASCII‑8, and NullPtr. Every round gives each player 3 lives and a hand of 7 cards. A prompt lands on the felt: binary, hex, ASCII, or 5‑bit letter codes. You choose a card to play. The timer isn’t lethal; it’s a score multiplier. Base points are 5 for easy, 10 for medium, and 15 for hard. Answer within 15 seconds and you earn 2×. Under 30 seconds gives 1.5×. Under 60 seconds gives 1.25×. Anything slower scores at base.

Then comes the accusation phase. Tap a bot whose card is wrong and they lose a life. Make two correct accusations back‑to‑back and you regain one. But accuse a bot who was right or play an incorrect card yourself and you lose a life instead.

Three shared hint lamps last the entire table and never recharge. On a single question they escalate first a walkthrough, then a sharper nudge, then the answer. Opening a hint pauses the clock. A question mark button opens a help overlay teaches binary, hex, octal, and ASCII (A = 65, a = 97) and also freezes the round. The last player with any life left wins.

How we built it

--> Next.js 16 App Router + React 19 + TypeScript for the full-stack-shell.

--> Tailwind CSS 4 + shadcn/ui for the card table UI.

--> A 75-prompt bank in src/data/questions.json (easy / medium / hard) with a hand-written three-step hint per question: hint, hint2, and reveal fields on every prompt.

--> A deal engine that guarantees the bank answer is always in the player's 7 cards, with six shuffled distractors around it.

--> Bot seats with individually tuned accuracy, notice, panic, speed, and offByOne stats:

NullPtr sits at accuracy: 0.90 and plays slowly.
Clippy sits at accuracy: 0.34 and plays fast.

--> /api/voice → xAI Grok TTS (eve), with a browser SpeechSynthesis fallback so the table always talks.

--> /api/scores → leaderboard ranked by wins, then points, lives, rounds, and correct calls.

--> Optional SpacetimeDB card / prompt / score tables; a local seed means it runs on Vercel with no extra service

--> Tests across deal.test.ts, game.test.ts, and announce.test.ts that fail the build if the correct card ever leaves the player's hand.

Challenges we ran into

--> Coherent card generation per prompt.

Every question loads a unique correct answer, but the six distractor cards around it had to feel plausible without being obvious. A bad distractor is either a giveaway or unfair — finding that balance across 73 playable prompts in three encoding formats took real iteration.

--> Filling bot hands believably.

Each bot needed to play a card that reflected their personality and stats — Hexa (accuracy: 0.74) reliable at hex, Clippy (accuracy: 0.34) confidently wrong, NullPtr (accuracy: 0.90, speed: 0.28) cautiously almost right. The bot answer logic had to feel like a character, not a random pick, while still being wrong often enough to be callable.

--> The hint system.

Three lamps for the whole table, never refilling, escalating on the same question from walkthrough to nudge to answer. Writing hint, hint2, and reveal for every single prompt in the bank — hints that teach without giving it away on step one, and that never auto-select a card for the player.

--> The clock as a multiplier, not a punishment.

Most games use a countdown as a life drain. We wanted the clock to reward speed without penalizing thinking. Getting the multiplier thresholds (≤15s ×2, ≤30s ×1.5, ≤60s ×1.25) to feel fair across easy (60s), medium (90s), and hard (135s) prompts — and pausing it correctly for hints and the ? overlay without desyncing the score — required careful state management throughout.

--> 1000 in hex is not 1000 in binary.

00001 is A, not ASCII 65. Those look nearly identical on a card, and they are not the same game. Keeping that distinction legible at a glance across card design, prompt wording, and bot answers was a constant design fight.

Accomplishments that we're proud of

--> A complete, playable table: six seats, lives, accusations, scoring, win/lose, voice, and a question bank that isn't lorem ipsum.

--> Hints hand-written per-prompt, not generated on the fly — three escalating steps for all 73 playable questions.

--> A help overlay a non-CS player can actually use (A = 65, a = 97, slot values 8 4 2 1).

--> Bots that feel distinct by design: NullPtr is careful and slow, Clippy is overconfident and fast, Bitwise is quick but off-by-one.

--> A full test suite across dealing, game logic, and announcements that fails the CI if the correct card ever leaves the hand

What we learned

Encoding is easier to feel than to lecture. Putting 8, 4, 2, 1 on the table as "slots that hold a 1" teaches binary faster than a conversion formula. Making the bots wrong on purpose is the mechanic — calling a hallucination is how you take a life, not a bug.