- Extract header into buildHeader() with black background panel and depth layering
- Add background panel to shelf area with accent border
- Adjust shelf dice positioning to align with new panel
- Show pending +selected score during awaitPick phase in scratch pad
- 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
- Replace generic card/place SFX with thematic water sounds (splash, sink, raise, dry)
- Preload new water sound effects in PreloadScene
- Introduce AI character speech via SpeechQueue on character reveal
- Clear speech queue when advancing past character selection
- Make trade modal panel height dynamic; wrap hand cards to second row if >4
- Refactor card fly animations to use Containers for correct border scaling
- Animate AI partner card placement to HUD thumbnails
- Add Waters Rise animation: card flies to meter, triggers water rise with segment fade and marker slide
- Introduce animated intro sequence, player role intros, and deck count displays.
- Replace direct treasure giving with a new Trade Modal for swapping cards between players.
- Add smooth Phaser animations for pawn movement, shore-ups, flood/treasure card draws, and card swaps.
- Improve state management during animations using immutable cloning and peek functions (`peekFloodDraw`, `peekTreasureDraw`).
- Update role definitions with detailed descriptions and remove 'messenger' from `ROLE_KEYS`.
- Change default difficulty to 'novice'.
- Implement cinematic noble claiming animation with fireworks and sound, shrinking to panel thumbnails
- Add hover ring highlight and gem sound effects for token selection zones
- Render claimed noble thumbnails in player panels with dynamic positioning
- Trigger happy emotion on player portraits when purchasing point cards
- Relocate Leave button to bottom-right and remove unused playIntro flag
- Exclude Splendor from card back selection in OpponentSelectScene
- Add 500ms hover-intent preview for reserve cards, temporarily hiding player portraits
- Dynamically calculate control bar panel height based on player count
- Adjust reserve button positioning and increase control bar background opacity
- Reposition turn label and remove redundant win condition subtitle
- Integrate audio feedback for card interactions (ui-attach) and achievement animations (firework)
- Implement card fly-to-center animation with fireworks for buy and reserve actions
- Add persistent bought-card thumbnails in player panels with automatic wrapping
- Build full card containers (costs, points, gem badges) for smooth scaling transitions
- Suppress reserve pills and buy animations in UI until transitions complete
- Apply animation triggers consistently for both human and AI turns
- Introduce portrait rendering for players and opponents via `buildPortraits`.
- Compact and right-align gem cells with updated sizing, spacing, and smaller fonts.
- Add divider and total row displaying combined bonus and token counts.
- Increase panel background opacity and fix reserved card interactivity checks.
- Add a dark background panel behind the token bank for better visual contrast.
- Introduce `animGemToSelection` and `animAITake` to animate gems flying from the bank to the selection bar and player panels.
- Update `onTokenClick` and `confirmTake` to trigger gem animations for human players.
- Integrate gem take animations into the AI turn sequence.
- Add `playerGemPos`/`humanGemPos` helpers for dynamic gem coordinate calculation.
- Adjust token count text, alignment, and depth layers in `drawBank` for cleaner rendering.
- Add `splendor-gems` spritesheet (6 frames, 64×64) for gem icons.
- Introduce `gemFrame` helper to map gem colors to spritesheet indices.
- Update gem rendering in player bars, card badges, and cost pips to use sprites when available.
- Add `hasGems` flag to gracefully fallback to vector circles when art is missing.
- Register new asset in PreloadScene.
- Blokus: Adjust tray coordinates and add a background panel for improved layout separation.
- Splendor: Integrate a 28-frame spritesheet for development cards, nobles, and deck backs.
- Refactor frame mapping to calculate indices dynamically based on tier and bonus color.
- Unify card rendering pipeline: draw tinted background, overlay spritesheet art (when available), then render vector overlays.
- Add hover preview panel for reserved cards.
- Document spritesheet layout and update preload scene asset comments.
Introduce a visual transition where AI pieces fly from their opponent
portrait to the board upon placement. Human player placements remain
instant with a flash effect. Implemented animateAIPiece to handle the
tweening and temporary graphics rendering.
Integrate portrait avatars into the Blokus score panels by increasing
panel height and adjusting the layout. Added portrait graphics with
colored strokes and repositioned text elements to accommodate the new
visual components.
Adjust button coordinates in buildControls() to update the control tray layout.
Pass, Rotate, and Flip buttons are moved lower and centered relative to the tray,
while New and Leave buttons are positioned at the bottom right.
- 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
- Animate initial card deal with staggered fly-in effect and block input during playback
- Replace instant card placement with flip-and-fly animation for stock draws across variants
- Add automatic foundation completion when Klondike is effectively won (stock empty, all face-up, foundation-only path exists)
- Adjust Sudoku notebook spiral binding to top-only and refine title positioning
- Extract generic drag-and-drop logic to support both Klondike and new Three Shuffles leg
- Implement "Three Shuffles and a Draw" game rules: build tableau down in suit, shuffle up to 2x, then draw one buried card
- Update Three Shuffles engine to handle pile-based tableau and foundation clearing
- Add UI controls for shuffle and draw actions in the new leg
- 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
Switch tile interaction from a manual container hit area to an invisible
centered child rectangle. This resolves a hitbox offset issue where the
previous implementation caused the hit area to be misaligned up and left.
Update game-icons assets.
- 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
- Replace custom-drawn Old Maid card with sprite frame (frame 13)
- Load oldmaid-cards.png spritesheet in PreloadScene
- Rename GOFISH_CARD_FRAME to OLDMAID_CARD_FRAME for clarity
- 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
Repositions ship pips and placement buttons to prevent overlap and improve visual alignment. Updates Y-coordinates for Randomize, Clear, and Ready buttons to fit within the game area, and shifts ship labels left for better spacing.
Introduces a per-peg feedback system where each marker corresponds to the specific slot's result (exact, partial, or none) instead of aggregate counts. Added `scoreGuessPerPeg` logic, updated UI rendering and sound triggers to handle per-peg data, and added a scene toggle for switching between Standard and Exact Placement modes.
- Relocate Leave button to the bottom of the game screen
- Extend peg reveal animation duration to 2.3s with smoother tick timing
- Introduce MASTERMIND_CALCULATE sound effect to play during the reveal
- Update audio preload and SFX registry to support the new sound
- 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
Hand-trace a more accurate US lower-48 + southern Canada outline with additional
points for Pacific NW, Great Lakes, Florida, and Gulf Coast. Update GREAT_LAKES
polygon to better match actual geography.
Introduce `ROUTE_CURVES` configuration and helper functions (`bezierPolyline`,
`polylineLength`, `pointAtDist`) to sample and measure polylines. Update
`routeSegments` and `routeMidpoint` to distribute cars and calculate midpoints
along curved paths instead of straight lines, improving board visual fidelity
and route alignment.
- Add custom card texture spritesheet and render cards using sprite frames
- Prevent AI from repeatedly asking for the same rank after a failed catch
- Track and exclude previously attempted (target, rank) pairs per turn to reduce redundant moves
- Load gofish-cards assets in preload scene
- 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
- Introduce muted palette and stroke outlines for unclaimed route segments so claimed routes pop
- Refactor busy state handling to toggle dim overlay and suppress hand render flicker during animations
- Improve modal layout using right-band centering, responsive font sizing, and word wrapping
- Block input briefly after modal close to prevent accidental clicks
- Add animated tab icons to the game menu with scale transitions and pulsing glow effects
- Load new tab-icons assets in the preload scene
- Generate a `ttr-train-car` texture and use images instead of procedural drawing for owned routes.
- Add `animateClaimRoute` to animate cards flying from hand to a lineup, transforming into train cars, then placing on the route.
- Update human and AI route claim flows to use the new animation.
- Add a pulsing turn indicator triangle that moves to the current player's portrait.
- Track `trainCarObjs` for proper cleanup during route re-renders.
- Implement `animateMarketSlideUp` to slide remaining cards up when one is drawn.
- Add `animateRefillMarketSlot` to animate a new card appearing from the deck.
- Update human and AI draw handlers to orchestrate card draw, slide, and refill animations.
- Introduce `marketSlotObjs` to track UI objects per slot for targeted tweens.
- Create `renderAllExceptMarket` to render the rest of the game while market animations play.
- Refactor `renderMarket` to group objects by slot index.
- Introduce mini face-down card fans below opponent portraits to show hand size.
- Modify AI draw animations to target specific slots within the mini hand fan.
- Adjust layout constants (OPP_STEP) and text positions to accommodate the new UI.
- Simplify opponent info text to remove redundant card counts.
- Implement `animateCardDraw` with a multi-phase animation: flip, fly to center,
fireworks particle effect, and fly to destination.
- Update human market and deck click handlers to play animations when drawing cards.
- Add card draw animations for AI turns, flying cards to opponent positions.
- Refactor turn logic to await animations before advancing game state.
- Add `handDestForColor` helper for calculating hand layout positions.
- Replace procedural card drawing with spritesheet images for better visuals
- Rotate cards to landscape orientation and adjust right-panel dimensions
- Reorganize opponent panels into a two-column grid for better screen utilization
- Add circular score badges above player and opponent portraits
- Display actual top card on discard pile instead of generic face-down graphic
- Move game log to bottom-right corner
- Update PreloadScene to load new card assets
- Replace column-based game list with a tabbed category interface and grid layout
- Add active state management to tabs and refactor Button component for consistent visual states
- Increase Dominion AI Platinum purchase threshold from 5 to 9 coins in Colony games
- Add Ticket to Ride card assets
- 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.
- Add gold hex resource picking phase with AI support
- Implement ship building mechanics and update build costs UI
- Introduce fog tiles that reveal terrain when roads/ships are built adjacent
- Replace robber token with pirate ship graphic
- Persist random tile frames for consistent hex visuals
- Update game state machine to handle gold pick queue and phase transitions
- Adjust UI layout (card positions, build panel) to accommodate Seafarers elements
- Decouple static board geometry from game state by introducing a board registry and `geoFor(state)` accessor. All AI and logic functions now dynamically resolve topology.
- Add support for Seafarers scenarios (New Shores, Four Islands, Oceania, Fog Island) with scenario-specific setup rules and victory conditions.
- Implement ship mechanics: players build maritime routes on coastal/sea edges that count toward the longest road.
- Introduce sea, gold, and fog terrain types. Update hex rendering, AI pathfinding, and placement rules to respect land vs. water constraints.
- Add pirate token rendering and logic, plus expansion scoring hooks for bonus victory points.
- Update lobby UI to allow expansion and scenario selection, passing configuration through to the game scene.
- Refactor `CatanBoard.js` geometry generation for O(1) edge lookups and dynamic port assignment.
- 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.
- Adjust Wordle AI skill profiles to lower win rates and increase blunder chances for better difficulty curve
- Center Wordle player portrait vertically with the playfield
- Add Steve's humorous tutorial for Settlers of Catan (markdown + assets)
- Update OpponentSelectScene to hide playfield options for word games and adjust scroll height
- Fix migration script to temporarily disable foreign keys to allow schema changes
- Add migration to extend games.category to include 'word'
- 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
- Add `_animPurchaseShowcase` for a dramatic card reveal with a dark overlay and animated comet border effect
- Refactor purchase and gain flows to use the new showcase animation before flying the card to its destination
- Update `addIconRow` to accept a width constraint, dynamically scale text/tokens, and fallback to colored bars when space is too limited
- Track deck/discard pile counts during animations for real-time UI updates
- Implement animated discard pile countdown when shuffling
- Dynamically show/hide deck and discard piles based on animation state
- Replace generic card SFX with specific sounds for buying treasures, purchasing, and dealing
- Update Dominion card assets to align with new UI/audio feedback
- Add a particle emitter effect to supply pile cards using a generated sparkle texture.
- Include a `coins.mp3` sound effect for purchase interactions.
- Implement `_clearSupplyFx` to manage emitter lifecycle during render cycles.
- Implement a visual effect using Phaser Graphics to draw animated "comet" trails along the perimeter of playable action and treasure cards.
- Add `perimPoint` helper to calculate coordinates along a rectangle's perimeter.
- Manage particle graphics and tweens via new `_handFxGraphics` and `_handFxTweens` arrays, ensuring proper cleanup during render cycles.
- Replace simple face highlighting with the new `_buildHandFxItem` method for enhanced visual feedback.
feat(dominion): add recommended kingdom presets and update deck mode UI
- Introduce four new recommended kingdom decks from the 2nd-edition rulebook: Size Distortion, Deck Top, Silver & Gold, and Helpful Actions.
- Refactor `kingdomFor` to use a `KINGDOM_PRESETS` mapping for cleaner extensibility.
- Update the Opponent Select Scene UI to display all deck mode options in a 3-column grid layout.
```
- 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 drag-and-drop reordering for the player's hand with a visual play drop zone.
- Add smooth, multi-phase animations for AI opponents (play, draw, cleanup, gain).
- Refactor hand rendering to preserve manual order and improve playability highlighting.
- Update card draw animations to target existing sprite coordinates directly.
- Add visual discard pile with card sprite and count badge
- Center action buttons and remove redundant Play Treasures button
- Track in-play cards for accurate animation source positions
- Refactor `setState` to handle discard, gain, and draw animations sequentially
- Add multi-phase discard animation (fly face-up, fold, unfold face-down)
- Add gain card animation to deck or discard pile
- Improve animation queue handling with `_animating` and `_pendingAnimState`
- Add face-down mini card sprites for opponents below their portraits
- Implement layout logic to center and space cards based on hand size
- Update card asset textures
- Replace text-only tooltip with a visual card preview popup
- Add background graphics and proper layout for card face and rules text
- Update popup dimensions and positioning logic
feat(dominion): add card draw animations and visual deck pile
- Implement animation system for drawing cards from deck to hand
- Add input blocking and state queuing during animations to prevent race conditions
- Replace text-only deck counter with a visual card pile and count badge
- Support face-down card rendering for animation start positions
- Ensure all human actions respect animation state
```
- Relocate prompt banner and buttons downward (Y: 500→720, 560→825)
- Replace card suit emoji with text 'C' in value labels
- Update `promptButton` call to pass label string directly instead of a function placeholder
- 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.
- Add a 10-second countdown timer between ball draws with a dedicated UI overlay
- Implement visual flash effect on opponent panels when their cards match the called number
- Play happy emotion animation on opponent portraits during matches
- Replace CASINO_WIN/LOSE sounds with CASINO_BLACKJACK for win/loss events
- Fix fullscreen toggle to properly handle exitFullscreen and requestFullscreen
- Add new video assets for opponent emotions (happy, idle, upset)
- Add `sfx-bingo-balls` audio asset and load it in PreloadScene
- Register `BINGO_BALLS` sound in the SFX constants
- Play the sound when the bingo ball spinning animation starts
- Reduce mini card dimensions from 125x125 to 90x90 pixels
- Adjust positioning coordinates from (px+54.5, py+34.5) to (px+28, py+8)
- Improves visual alignment and spacing of opponent's bingo card in the UI
- Update player card background border radius from 5 to 15 for smoother corners
- Change called numbers board background color from cream to black for better contrast
- Remove unnecessary whitespace in `init()` and physics calculation lines (code cleanup)
- Add cream white background behind the player's bingo card
- Add cream white background behind opponent mini-cards
- Add cream white background behind the called numbers board
- Adjust player card header position (HEADER_Y, ROW0_Y) to accommodate new layout
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.
Brian Fertig