Introduce a new single-player logic puzzle game where players flick jelly
blobs across a grid to slide and merge them into a single monster.
- PuddingMonstersLogic.js: pure slide-and-merge model with BFS solver,
no Phaser/DOM dependencies; shared by client and generator
- PuddingMonstersGame.js: Phaser scene with drag-to-flick, arrow keys,
undo/reset/hint, par tracking, star collection, death on spikes
- genPuddingMonsters.js: offline level generator using seeded RNG and
BFS solver; produces 40 levels across 5 difficulty tiers
- puddingmonsters.json: generated level data (40 levels, 5–7 grid sizes)
- Update main.js, GameRoomScene.js, PreloadScene.js, registry.js to
wire the new game into the app
- Update game-icons assets
- Register Hexsweeper game in server registry with icon frame 52
- Add HexsweeperGame import and scene configuration in main.js
- Add hexsweeper slug mapping in GameRoomScene.js
- Update game-icons sprite sheet with new icon
- Register Rush Hour game in server registry (logic category, single-player)
- Add "Logic & Puzzle" tab to game menu
- Integrate RushHourGame scene in client-side main.js and GameRoomScene
- Load rushhour.json game data in PreloadScene
- Add puzzle API routes for server-side puzzle management
- Configure tab icon frame for new logic category
- Register Freecell game in server registry with card game configuration
- Import and configure FreecellGame in main.js and GameRoomScene
- Update game-icons sprite sheet with new icon frame for Freecell
- Fix Triominoes to dim all tiles when no legal moves are available
Introduce Tri-Ominoes, a triangular grid tile-placement game for 2–4 players. The implementation includes a pure rules engine (`TriominoesLogic`), triangular grid geometry and data (`TriominoesData`), a Phaser scene (`TriominoesGame`), and a heuristic AI with 5 skill levels (`TriominoesAI`).
Key features:
- Corner-matching tile placement on an equilateral triangular grid
- Scoring with pip sums, hexagon-closing bonuses, and going-out rewards
- Draw-from-pool and pass mechanics with forced pass when blocked
- Animated AI tile placement from opponent portraits
- Board panning and re-centering for large play areas
- Game-over modal with final scores and history posting
Also updates the game registry, scene dispatch, opponent select skill controls, and adds two new character portraits (beth, blackwind).
- Add complete Monopoly implementation with pure state engine (MonopolyLogic.js),
static data (MonopolyData.js), AI (MonopolyAI.js), and Phaser scene (MonopolyGame.js)
- Implement full game rules: property buying, auctions, building houses/hotels,
mortgages, jail, chance/community chest cards, rent calculation, bankruptcy
- Add 5-level AI with configurable greed, blunder rate, and thinking delay
- Add spritesheet loading for monopoly pawns and cards with graceful fallbacks
- Register game in registry, main.js, and game room scene dispatcher
- Add spritesheet creation guide (sprites.md) and update game-icons.png
- Rename game from "Yatzi" to "Zahtzee" across UI and server registry
- Move game category from tabletop to cards
- Persist last selected menu category using _lastCategory
- Update game-icons asset files
- Implement Kiitos game logic: build-a-word mechanic with forced plays,
deviations, and pass resolution when stuck
- Add 3-round progression escalating rules (4+ words, prepend, super-Kiitos
insert-anywhere, double scoring)
- Create server-side dictionary engine with prefix trie, word validation,
and skill-aware AI move selection
- Build cozy Nordic café-themed Phaser scene with drag-and-drop letter cards
- Support 1 human + up to 3 AI opponents with turn-based play
- Integrate Kiitos into game menu, room scene, and opponent selection
- Add game icon to game-icons sheet
- Implement full Stratego rules, including hidden information, combat,
and flag capture mechanics
- Add 5-level AI with heuristic evaluation, unknown enemy reasoning,
and skill-scaled blunders/lookahead
- Create setup phase allowing piece swap and shuffle before battle
- Add detailed unit reference panel with scrollable ability notes
- Implement turn-based battle animations with sci-fi sound effects
- Integrate Stratego into game menu, room scene, and opponent selection
- Add spritesheet assets (stratego-pieces.png) and game menu icon
- Register Stratego in server game registry
- Rename "Farkel" to "Farkle" in UI title and server game registry
- Replace tumble animation with new animateDice method featuring:
- Dice thrown from elevated position with arc trajectory
- Random face cycling while airborne
- Bounce landing with per-die staggered timing
- Spin and scale animations
- Squash-bounce effect on final die
- Refactor die rendering to use containers for transform animations
- Add new Farkel dice game (2-4 players, tabletop category)
- Update Video Poker CRT screen from green phosphor to royal blue theme
- Refresh game-icons sprite sheet for new game assets
- Register Splendor in server game registry with metadata
- Import and register SplendorGame in frontend main.js
- Map 'splendor' slug to SplendorGame in GameRoomScene
- Preload splendor-cards spritesheet in PreloadScene
- Update game-icons assets for the new game
- Implement visual card rendering for Forbidden Island using a new spritesheet with procedural fallback
- Register and wire up the new "Solitaire Tour" game across client, server, and preload scenes
- Update game icon and card asset bundles
- Frontend: Phaser scene for grid/clue rendering, keyboard navigation, win detection, and difficulty selection.
- Logic: Pure helpers for slot mapping, cell validation, and answer checking.
- Backend: Puzzle engine, JSON bank of 15 puzzles across 3 difficulties, API route, and game registry.
- Integrates into existing game menu and routing.
- Implement client-side Phaser scene and pure scoring/rank logic for the honeycomb-style word game.
- Add server-side puzzle generation engine with difficulty bands (easy/normal/hard) and dictionary pre-filtering.
- Register game metadata, frontend scene routing, and backend API endpoint (`/words/spellingbee/start`).
- Implements NYT-style rules: 7 letters (1 required center), 4+ length words, pangram bonus, and tiered rank progression.
- Implement pure state engine for Blokus rules, move generation, and scoring
- Add board geometry, polyomino definitions, and orientation transforms
- Integrate heuristic single-ply AI with 5 skill levels (configurable noise/blunders)
- Create Phaser scene for board rendering, piece tray, ghost placement, and HUD
- Register game in server registry and update client routing/dispatch
- Implement core game logic, AI opponent with skill scaling, and Phaser UI
- Register game in server registry and wire into app routing
- Add card assets and sprites
- Replace `gameicons` spritesheet with `game-icons` and load it in PreloadScene
- Add `iconFrame` support to game registry and render icons next to menu buttons
- Introduce animated dock arrows in Battleship to improve ship placement UI
- Clean up arrow lifecycle management in Battleship scene
- Implement full Boggle frontend using Phaser, featuring a wooden tray UI, player word sheet, opponent cards, and an animated hourglass timer.
- Add AI scheduling system that simulates opponent word finds based on configurable skill levels and word length/rarity weighting.
- Introduce pure game logic for adjacency validation, path checking, and classic scoring with duplicate-word resolution.
- Add backend board generation and exhaustive solver using a dictionary trie, exposing `/api/words/boggle/start` for board setup.
- Register Boggle in the game registry, scene router, and opponent selection UI.
- Include tutorial assets for Parchisi.
- Register Connect 4 in server registry and frontend game config
- Add Connect 4 to slug dispatch and opponent select skill controls
- Update TutorialModal markdown parser to render embedded images
- Introduce core game logic, AI engine, and Phaser UI for a cyberpunk-themed Mastermind implementation.
- AI features 5 difficulty tiers using random, consistent, and Knuth minimax strategies.
- Implement turn-based duel mechanics where player and AI race to crack each other's secret codes.
- Add neon visuals, peg-fly animations, staggered feedback reveals, and 7 custom sound effects.
- Register game in server registry, update menu/room scenes, preload assets, and include tutorial docs.
- Introduce `hasTutorial` flag to game registry
- Add "?" button on game menu to open tutorial modals
- Implement shared hover tooltip on game menu
- Add tutorial modal CSS styling
- Register Battleship game with tutorial flag
- Load Battleship sound effects
- Implement pure game logic for Othello (8x8) and Go (9x9)
- Add configurable AI opponents (skill 1-5) using heuristic look-ahead and alpha-beta minimax
- Build Phaser scenes with polished UI, stone/disc rendering, capture/flip animations, territory scoring, and end-game panels
- Register games in server registry and update client routing, opponent selection, and scene registration
- Implement Phaser UI and client-side logic for gameplay
- Add server-side puzzle generator with 5 difficulty levels
- Register game in frontend router and backend registry
- Include hint system, score calculation, and notebook-themed design
- Implement Hangman game scene using Phaser with a sketch/paper-style UI
- Add pure logic module for word masking, wrong guess tracking, and win/loss conditions
- Create backend `/api/words/hangman/start` endpoint with curated word pools for easy, medium, and hard difficulties
- Register game in scene manager and route dispatcher for seamless menu integration
- Add score tracking and basic game state management
Implement a fully playable Ticket to Ride game featuring a pure logic engine,
heuristic AI opponent, and Phaser UI scene.
Key additions:
- Board geometry, route definitions, destination tickets, and train card data
- State management, turn flow, payment validation, and scoring (routes, tickets, longest path bonus)
- AI decision-making for claiming routes, drawing cards/tickets, and endgame strategy
- Frontend integration (scene registration, opponent count default, slug dispatch)
- Server game registry configuration (supports 2-5 players)
Follows the existing architecture separating data, logic, AI, and rendering.
- Integrate Word Search game into client and server registries
- Add API endpoints for puzzle generation and theme listing
- Update GameMenuScene to skip opponent selection and stop menu music for solo-only games
- Implement client and server logic for Ghost game (`GhostGame`, `GhostLogic`, `GhostAI`, `ghostEngine`).
- Add perfect-play search and 5-tier skill system to the server-side dictionary engine.
- Register Ghost in the game registry and route it through `GameRoomScene`.
- Add `playIntro` option to `Portrait.js` and `skipIntro` to Wordle to control intro speeches on round restarts.
- Improve Scrabble rack reordering layout and gap handling during drag-and-drop.
- Expose Ghost API endpoints (`/ghost/judge`, `/ghost/ai-move`) in `wordRoutes.js`.
- Implement `ScrabbleGame` scene with drag-and-drop, rack management, and animated tile placement.
- Add pure JS modules for Scrabble rules, scoring, and tile data (`ScrabbleLogic`, `ScrabbleTiles`).
- Create server-side dictionary trie and DFS-based move generator for AI (`scrabbleEngine`).
- Register game routes for move validation and AI move requests (`wordRoutes`).
- Update game registry, opponent selection, and preload scenes to support Scrabble.
- Include custom font (`YummyCupcakes`) for the scorepad UI.
- Register Wordle game in server registry under 'word' category
- Add `/api/words` API routes
- Update client to integrate WordleGame scene
- Adjust game menu layout to accommodate a new 'Word' category column
- Enable skill controls and game room dispatch for Wordle
- Implement Checkers and Chess with complete Phaser UI, pure logic modules, and alpha-beta minimax AI opponents featuring a 1-5 skill model.
- Extend opponent skill selector to support Checkers and Chess.
- Register new games in frontend routing and backend registry.
- Improve Dominion game UX: add persistent phase dials and turn arrow indicators, add confirmation prompts for ending actions/turns, and refine card animation timings.
- Update Dominion card asset files.
- Implement pure state engine (`DominionLogic.js`) with turn lifecycle, card effects queue, and pending decision resolution for complex interactions.
- Add card definitions and kingdom pool (`DominionCards.js`) supporting Standard and Random deck modes.
- Create AI logic (`DominionAI.js`) using Big Money/early engine strategies scaled by opponent skill.
- Build Phaser scene (`DominionGame.js`) with supply/hand rendering, turn drivers, modal prompts for pending decisions, and end-game scoring.
- Wire up game registry, routing, preload assets, and opponent selection UI to support the new mode.
- Implement core game logic in BaccaratLogic.js including shoe management,
hand evaluation, and betting resolution with standard rules (5% banker
commission, 8-to-1 tie payout).
- Create BaccaratGame.js Phaser scene with full UI: betting panel, chip
selection, seat portraits, and animated card dealing.
- Add BaccaratAI.js for opponent bet sizing and type selection (weighted
toward Banker).
- Introduce "Equation Ribbon" reveal sequence that walks through each card's
value, sums them, and performs a mod-10 reduction with visual flair.
- Register Baccarat in the server game registry and frontend scene dispatch.
Introduce a new Bingo game featuring a physics-driven drum with Matter.js,
AI opponents that auto-daub and claim wins with suspenseful delays, and a
"claim race" mechanic where the human can beat AI to the punch. Includes
complete game logic, UI components (drum, card, opponent panels, called
numbers board), and server registration for the new game slug.
- Update Holdem game configuration to allow 3-7 AI opponents (previously fixed at 3)
- Implement dynamic seat layout using an elliptical distribution for balanced positioning
- Add computeSeatLayout() to calculate positions based on opponent count, with special handling for side/diagonal corners
- Adjust portrait, card, and UI element positioning to adapt to different table sizes
- Update AI personality definitions to include 7 distinct profiles with varied aggression/bluff rates
- Modify AI decision logic to limp more frequently in unraised preflop scenarios
- Update hand summary modal to scale rows dynamically to fit 7+ players
- Update server game registry to reflect new max opponent count
feat(blackjack): expand player capacity to 7 and improve table visuals
- Increase maximum players from 5 to 7 (6 opponents) by updating seat positions, logic loops, and server registry.
- Add traditional felt table markings including curved text for rules ("Blackjack pays 3 to 2", "Insurance pays 2 to 1") and card/bet spot outlines.
- Refactor seat label rendering to use a consistent centered layout under portraits.
- Adjust bet circle positioning logic for the new seat layout.
```
- Replace static sea background with a radial gradient for a richer look.
- Redesign settlement and city graphics with drop shadows and white halos.
- Enhance road rendering with a white core for better visibility.
- Add VP badges and card count fans to opponent panels.
- Support card back sprites via `data.cardBack` for accurate card rendering.
- Mark Catan as a card game in the registry.
- Implement Hearts game logic (HeartsLogic.js) with classic rules: passing, trick-taking, scoring, and moon-shooting mechanics
- Add AI opponent logic (HeartsAI.js) with heuristic-based card selection for passing and playing
- Create HeartsGame.js Phaser scene with full UI: card rendering, animations, trick collection, score tracking, and game flow
- Register Hearts in game registry as a 4-player card game
- Integrate Hearts into game routing and menu dispatch
- Implement Mexican Train game logic, AI opponent, and Phaser UI scene
- Register Mexican Train in server game registry and client dispatch tables
- Add roulette spin sound effect and improved win/lose animations with fireworks
- Update preload scene and sound registry to support new audio assets
Implements a fully playable Roulette game with American double-zero rules, a spinning wheel animation, and a heuristic AI that assigns distinct betting personalities to opponents. Adds colored identity rings to player portraits in both Craps and Roulette for better visual distinction. Updates Craps to render AI bets directly on the felt with color-coded chips and names, and adjusts dice landing positions.
Brian Fertig