American Keno

Implementation Notes

This demo is a compact client for an American Keno prototype. It demonstrates a small PixiJS-powered grid UI with client-side selection, animated draw presentation, and integration with a backend game service.

Frontend

• Layout: Tailwind CSS for quick responsive layout and UI primitives.
• Rendering: PixiJS renders the grid and animated balls for smooth visual updates.
• Interaction: Client toggles selections and calls backend endpoints to persist selections and trigger draws.

Backend (technical overview)

The backend is implemented as a NestJS service that exposes a small set of REST endpoints backing the UI. Key endpoints used by this demo:

• /api/new (POST) — creates a new ephemeral game session and returns a gameId.
• /api/info (GET) — returns game metadata (grid/draw sizes, paytable/rules).
• /api/select (POST) — accepts { gameId, numbers } to persist the player's selections server-side.
• /api/bet (POST) — updates the bet amount for the session.
• /api/draw (POST) — performs the draw on the server and returns drawn numbers, hit calculation and payout information.
• /api/paytable (POST) — returns paytable rows for the selected count or full paytable.

Server design notes

• Session model: small ephemeral sessions stored with fields like gameId, selectedNumbers, betAmount, and createdAt. This allows auditing and replaying draws for debugging.
• Draw RNG: draw logic runs server-side to avoid client-side manipulation; server uses a cryptographically-sound RNG for production (e.g., Node's crypto or a vetted RNG library).
• Validation & security: all inputs (numbers, bet) are validated and rate-limited; responses include only what is necessary to render the UI. CORS and auth (if added) sit at the API gateway level.
• Scaling: stateless draw operations can be horizontally scaled; persistent sessions are stored in MongoDB and ephemeral caches (Redis) can be used for high-throughput scenarios.

Core Game Engine (American Keno)

At the heart of this demo is the main game engine, which handles number selection, draws, and win evaluation. Conceptually, here’s how it works:

• Rules: Players pick 2-10 numbers from 1–80; the game draws 20 random numbers.
• Grid & Cells: 80 cells representing numbers 1–80. Each cell has a state: empty, selected, hit, or both selected & hit.
• Game Flow: Create session → set bet → player selects numbers → call draw() → server returns draw results and calculates wins.
• Win Evaluation: Matches between selected numbers and draw numbers are counted, and payouts are determined from the paytable, multiplied by the bet.
• Key Methods: constructor(), setBet(bet), setSelection(numbers), draw(), getScreen(), getState().
• RNG & Security: Draw is done server-side to prevent tampering, using a secure RNG. Client receives only results needed to animate the draw.

Notes: this demo is intentionally simplified for a portfolio.