- 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
```
- Introduce Balam (spriteIndex 16) and Steve (spriteIndex 17) as new opponents
- Include full speech configurations (intro, happy, upset, pick) for both characters
- 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.
Brian Fertig