@pompidup/kingdomino-engine 3.6.0 → 3.7.0

package/README.md

@@ -42,15 +42,19 @@ while (isGameWithNextAction(game)) {
   const { nextLord, nextAction } = game.nextAction;
 
   if (nextAction === "pickDomino") {
-    const domino = game.currentDominoes.find((d) => !d.picked);
-    if (domino) {
-      game = engine.chooseDomino({ game, lordId: nextLord, dominoPick: domino.domino.number });
-    }
+    const [dominoPick] = engine.getValidDominoPicks({ game });
+    game = engine.chooseDomino({ game, lordId: nextLord, dominoPick });
   } else if (nextAction === "placeDomino") {
     const lord = game.lords.find((l) => l.id === nextLord);
     const player = game.players.find((p) => p.id === lord?.playerId);
     if (lord?.dominoPicked && player) {
-      const placements = engine.getValidPlacements({ kingdom: player.kingdom, domino: lord.dominoPicked });
+      // maxKingdomSize: 5, or 7 for a 7x7 kingdom (The Mighty Duel, Neolithic,
+      // QueenDomino and AgeOfGiants-QueenDomino at 2 players)
+      const placements = engine.getValidPlacements({
+        kingdom: player.kingdom,
+        domino: lord.dominoPicked,
+        maxKingdomSize: game.rules.basic.maxKingdomSize,
+      });
       if (placements.length > 0) {
         game = engine.placeDomino({ game, lordId: nextLord, position: placements[0].position, rotation: placements[0].rotation });
       } else {
@@ -71,12 +75,12 @@ console.log(results.result);
 | Mode | Description |
 |------|-------------|
 | **Classic** | Original Kingdomino rules. 1-4 players, 5x5 kingdom, terrain-based scoring. |
-| **QueenDomino** | Full Queendomino expansion with buildings, coins, knights, the Queen and the Dragon. |
+| **QueenDomino** | Full Queendomino expansion with buildings, coins, knights, the Queen and the Dragon. 2-4 players (7x7 kingdom with the 48 dominoes at 2 players). |
 | **KingdominoOrigins-Discovery** | Origins expansion — volcanoes, fire tokens, fire-based scoring. |
 | **KingdominoOrigins-Totem** | Origins — Discovery + wooden resources + totem majority tiles. |
 | **KingdominoOrigins-Tribe** | Origins — Discovery + resources + cave board + cavemen recruitment. |
 | **AgeOfGiants** | Age of Giants extension — giants, quest tiles, 5-player support, 12 new dominos on Classic. |
-| **AgeOfGiants-QueenDomino** | Age of Giants combined with QueenDomino. |
+| **AgeOfGiants-QueenDomino** | Age of Giants combined with QueenDomino (7x7 kingdom with the 60 dominoes at 2 players). |
 
 ```typescript
 let game = engine.createGame({ mode: "Classic" });
@@ -92,11 +96,12 @@ See [Game Modes](docs/game-modes.md) for rules, player counts, and extra rules d
 The QueenDomino mode adds significant new mechanics to the base game:
 
 - **Construction squares** on some domino tiles where buildings can be placed
-- **Coins** (7 starting) used to purchase buildings or use the Dragon
-- **Knights** (max 3) placed on dominos to collect tax from construction squares
-- **Buildings** (18 types) purchased from the Builders Board, granting crowns, towers, and end-game bonuses
-- **The Queen** goes to the player with the most towers, granting +1 crown to the best territory
-- **The Dragon** burns a building tile from the Builders Board
+- **Coins** (7 starting) used to purchase buildings or bribe the Dragon; 1 point per 3 unused coins at the end of the game
+- **Knights** (1 at the start, more from building bonuses) placed on the domino just placed, up to 2 per turn, collecting 1 coin per square of the territory
+- **Buildings** purchased from the 6-spot Builders Board (spots costing 5 to 0 coins), granting crowns, towers, and end-game bonuses
+- **The Queen** hosted by the player who reaches the most towers (even on a tie): -1 coin on her host's constructions, +1 crown on their largest territory at the end
+- **The Dragon** burns a building tile from the Builders Board for 1 coin
+- **2 players**: 7x7 kingdoms with all 48 dominoes (official rule)
 
 The turn flow is extended with optional actions after placing a domino:
 
@@ -147,10 +152,13 @@ if (nextAction === "placeGiant") {
   game = engine.placeGiant({ game, lordId: nextLord, position });
 }
 if (nextAction === "sendGiant") {
-  game = engine.sendGiant({ game, lordId: nextLord, giantIndex, targetPlayerId, targetCrownPosition });
+  // The targeted opponent chooses the crown the giant covers
+  game = engine.sendGiant({ game, lordId: nextLord, giantIndex, targetPlayerId });
 }
 ```
 
+After `sendGiant`, a single free crown of the opponent is covered automatically. With several free crowns, `game.ageOfGiants.pendingGiant` is set and the game waits for a `placeGiant` played by a lord of the **targeted** player (`getValidGiantPositions` lists its crowns). `targetCrownPosition` is still accepted for backward compatibility.
+
 See [Age of Giants Guide](docs/age-of-giants.md) for the complete rules and mechanics.
 
 ## Extra Rules
@@ -159,13 +167,16 @@ See [Age of Giants Guide](docs/age-of-giants.md) for the complete rules and mech
 |------|-------------|-------------|
 | **The Middle Kingdom** | +10 points if castle is centered | — |
 | **Harmony** | +5 points if no dominos were discarded | — |
-| **The Mighty Duel** | All 48 dominos, 7x7 kingdom | 2 players only |
+| **The Mighty Duel** | All 48 dominos, 7x7 kingdom | 2 players only (QueenDomino already plays 7x7 at 2 players: accepted, without further effect) |
 | **Dynasty** | Play 3 games, highest total wins | — |
 
+Origins has its own equivalents: **Empire of Fire**, **Homo Habilis**, **Neolithic** (2 players, 7x7, and the first pick of each line takes the dominoes 1 & 4 or 2 & 3 — see [Origins Guide](docs/origins.md#neolithic-2-players)) and **Dynasty**.
+
 ```typescript
 game = engine.addExtraRules({ game, extraRules: ["The middle Kingdom", "Harmony"] });
 
-// Dynasty: aggregate results from multiple games
+// Dynasty: aggregate results from multiple games (grouped by player id: pass
+// the same stable ids to addPlayers in every game, e.g. { id: "alice", name: "Alice" })
 const dynastyResults = engine.getDynastyResults({ games: [game1, game2, game3] });
 ```
 
@@ -202,6 +213,8 @@ const engine = createGameEngine({
 | `calculateScore` | Calculate score for any kingdom |
 | `getValidPlacements` | Find all valid placements for a domino |
 | `canPlaceDomino` | Check if any placement exists |
+| `getValidDominoPicks` | Dominoes the lord to play may pick (Neolithic reservations included) |
+| `calculatePlayerScore` | Mode-aware live (or final) score of one player, with its breakdown |
 | `serialize` / `deserialize` | Save and restore game state |
 | `getDynastyResults` | Aggregate scores from multiple games |
 
@@ -211,7 +224,7 @@ const engine = createGameEngine({
 |--------|-------------|
 | `placeKnight` | Place a knight and collect tax |
 | `constructBuilding` | Buy and place a building |
-| `useDragon` | Destroy a building tile from the board |
+| `useDragon` | Destroy a building tile from the board (1 coin) |
 | `skipOptionalAction` | Skip the current optional action |
 
 ### Origins Methods
@@ -228,6 +241,10 @@ const engine = createGameEngine({
 | `placeGiant` | Place a giant on a crown in your kingdom |
 | `sendGiant` | Send a giant to an opponent's kingdom |
 
+### Valid targets
+
+`getValidFireTokenPositions`, `getValidKnightPositions`, `getValidBuildingPositions`, `getAffordableBuildings`, `getValidDragonTargets`, `getValidCavemanPlacements`, `getValidGiantPositions`, `getValidGiantTargets` and `canSkipOptionalAction` list what the extension actions accept, with the same checks as the actions (see [Valid targets](docs/api-reference.md#valid-targets-for-extension-actions)).
+
 See [API Reference](docs/api-reference.md) for complete method signatures, types, and error codes.
 
 ## Additional Features
@@ -235,7 +252,7 @@ See [API Reference](docs/api-reference.md) for complete method signatures, types
 - **Bot / AI**: 4 built-in strategies (`randomStrategy`, `greedyStrategy`, `advancedStrategy`, `expertStrategy`) with `playBotTurn()` helper; mode-aware (they evaluate with the mode-aware score and play the Queendomino, Origins and Age of Giants actions — see [Bot Strategies](docs/api-reference.md#bot-strategies))
 - **Mixed games**: Human and bot players in the same game via `bot: { strategyName }` on player input
 - **Undo / Redo**: Snapshot-based history with `createGameHistory()`, `pushState()`, `undo()`, `redo()`
-- **Action Log**: Immutable log via `wrapWithActionLog(engine)` for replay with `replayActions()`
+- **Action Log**: Immutable log via `wrapWithActionLog(engine)` for replay with `replayActions()`; format v2 records the seed and the game, player and lord ids, so a replay gives a strictly identical state (v1 logs remain replayable)
 - **Events**: Callbacks via `EngineConfig.events` (`onDominoPlaced`, `onGameEnd`, etc.)
 - **Debug Mode**: `wrapWithDebug(engine)` with 3 verbosity levels
 - **Seeded games**: Deterministic shuffle via `createGame({ mode, seed: "my-seed" })`

package/dist/index.d.ts

@@ -73,6 +73,13 @@ type RevealsDomino = {
     lordId: string | null;
     /** Display position in the revealed set (for UI ordering) */
     position: number;
+    /**
+     * Id of the player this domino is reserved for (Kingdomino Origins
+     * "Neolithic" rule): set on the whole line by its first pick, the pair
+     * 1 & 4 or 2 & 3 going to that lord's player and the two other dominoes to
+     * the opponent. Only lords of this player can pick it. Absent otherwise.
+     */
+    reservedFor?: string;
 };
 
 /**
@@ -424,7 +431,12 @@ type BuildingTile = {
     id: number;
     /** Display name */
     name: string;
-    /** Cost in coins to purchase */
+    /**
+     * Intrinsic cost of the tile. On a Builders Board with `slotCosts` (every
+     * game started since the official 6-spot board), the price is carried by
+     * the spot the tile occupies instead (see `BuildersBoard.slotCosts`); this
+     * value is only used by boards without `slotCosts` (older saved games).
+     */
     cost: number;
     /** Immediate bonus when constructed (optional) */
     immediateBonus?: ImmediateBonus;
@@ -441,12 +453,26 @@ type BuildingTile = {
 type BuildingSlot = BuildingTile | null;
 /**
  * The Builders Board holding available building tiles for purchase.
+ *
+ * Official board: 6 spots whose construction cost is printed below them
+ * (5, 4, 3, 2, 1 and 0 coins, from the draw pile to the cheapest spot). At
+ * each new round the remaining tiles slide to the cheapest spots and the
+ * empty spots are filled from the draw pile.
  */
 type BuildersBoard = {
-    /** Visible building tiles available for purchase (4 slots) */
+    /**
+     * Visible building tiles available for purchase, one per spot (6 spots; 4 in
+     * games started before the official board). `null` is an empty spot.
+     */
     slots: BuildingSlot[];
     /** Remaining building tiles in the draw pile */
     drawPile: BuildingTile[];
+    /**
+     * Construction cost of each spot, aligned with `slots` (`[5, 4, 3, 2, 1, 0]`).
+     * Absent in games started before the official board: the price is then the
+     * tile's own `cost`.
+     */
+    slotCosts?: number[];
 };
 /**
  * A building that has been placed on a player's kingdom.
@@ -603,6 +629,12 @@ type Rules = {
     basic: Record<number, BasicRules>;
     /** Age of Giants basic rules indexed by player count (2-5) */
     aogBasic?: Record<number, BasicRules>;
+    /**
+     * Basic rules specific to one game mode, indexed by mode name then player
+     * count. They take precedence over `basic` / `aogBasic` for that mode and
+     * player count (e.g. Queendomino at 2 players: 7x7 kingdom, 48 dominoes).
+     */
+    modeBasic?: Record<string, Record<number, BasicRules>>;
     /** Available extra rules */
     extraRules: ExtraRule[];
 };
@@ -641,6 +673,7 @@ declare const ErrorCode: {
     readonly CANNOT_PICK: "CANNOT_PICK";
     readonly CANNOT_PLACE: "CANNOT_PLACE";
     readonly DOMINO_ALREADY_PICKED: "DOMINO_ALREADY_PICKED";
+    readonly DOMINO_RESERVED: "DOMINO_RESERVED";
     readonly UNDO_UNAVAILABLE: "UNDO_UNAVAILABLE";
     readonly REDO_UNAVAILABLE: "REDO_UNAVAILABLE";
     readonly CANNOT_PLACE_KNIGHT: "CANNOT_PLACE_KNIGHT";
@@ -755,6 +788,7 @@ declare const TranslationKey: {
     readonly ERROR_CANNOT_PICK: "error.cannotPick";
     readonly ERROR_CANNOT_PLACE: "error.cannotPlace";
     readonly ERROR_DOMINO_ALREADY_PICKED: "error.dominoAlreadyPicked";
+    readonly ERROR_DOMINO_RESERVED: "error.dominoReserved";
     readonly ERROR_INVALID_PLAYER_COUNT: "error.invalidPlayerCount";
     readonly ERROR_INVALID_PLAYER_NAME: "error.invalidPlayerName";
     readonly ERROR_EXTRA_RULE_NOT_AVAILABLE: "error.extraRuleNotAvailable";
@@ -842,6 +876,7 @@ declare const TranslationKey: {
     readonly ERROR_INVALID_PLAYER_ID: "error.invalidPlayerId";
     readonly SCORE_QUEEN: "score.queen";
     readonly SCORE_BUILDING: "score.building";
+    readonly SCORE_WEALTH: "score.wealth";
     readonly SCORE_TOTEM_MAMMOTH: "score.totemMammoth";
     readonly SCORE_TOTEM_FISH: "score.totemFish";
     readonly SCORE_TOTEM_MUSHROOM: "score.totemMushroom";
@@ -997,6 +1032,8 @@ declare const scoreBonusTypes: {
     readonly queen: "queen";
     /** Queendomino: end-game scoring of one constructed building */
     readonly building: "building";
+    /** Queendomino: Wealth, 1 point per 3 unused coins */
+    readonly wealth: "wealth";
     /** Age of Giants: one quest tile */
     readonly quest: "quest";
     /** Origins Totem: one totem held by the player */
@@ -1373,6 +1410,8 @@ type GetValidKnightPositionsCommand = GetValidActionTargetsCommand;
 type GetValidBuildingPositionsCommand = GetValidActionTargetsCommand;
 /** Command for `getAffordableBuildings` (Queendomino `constructBuilding`). */
 type GetAffordableBuildingsCommand = GetValidActionTargetsCommand;
+/** Command for `getValidDragonTargets` (Queendomino `useDragon`). */
+type GetValidDragonTargetsCommand = GetValidActionTargetsCommand;
 /** Command for `getValidCavemanPlacements` (Origins Tribe `recruitCaveman`). */
 type GetValidCavemanPlacementsCommand = GetValidActionTargetsCommand;
 /** Command for `getValidGiantPositions` (Age of Giants `placeGiant`). */
@@ -1382,6 +1421,12 @@ type GetValidGiantTargetsCommand = GetValidActionTargetsCommand;
 /** Command for `canSkipOptionalAction` (`skipOptionalAction`). */
 type CanSkipOptionalActionCommand = GetValidActionTargetsCommand;
 
+/**
+ * Command for `getValidDominoPicks` (`chooseDomino`): any game state and an
+ * optional lord (default: the lord that must play).
+ */
+type GetValidDominoPicksCommand = GetValidActionTargetsCommand;
+
 /**
  * Command to get all valid placements for a domino on a kingdom.
  */
@@ -1661,6 +1706,15 @@ type GameEngine = {
      * @returns True if at least one valid placement exists
      */
     canPlaceDomino: (command: CanPlaceDominoCommand) => boolean;
+    /**
+     * Numbers of the revealed dominoes `chooseDomino` accepts for the lord
+     * (default: the lord to play): the dominoes not picked yet and, with the
+     * Origins "Neolithic" rule, not reserved for the other player (the first
+     * pick of each line takes the pair 1 & 4 or 2 & 3 for the lord's player).
+     * @param command - Contains game state and optional lord ID
+     * @returns Domino numbers, or [] when the game does not wait for this lord to pick
+     */
+    getValidDominoPicks: (command: GetValidDominoPicksCommand) => number[];
     /**
      * Serializes the game state to a JSON string for persistence.
      * @param command - Contains the game state to serialize
@@ -1739,7 +1793,8 @@ type GameEngine = {
     getValidFireTokenPositions: (command: GetValidFireTokenPositionsCommand) => Position[];
     /**
      * Squares where `placeKnight` accepts a knight: squares of the domino just
-     * placed, within the knight limit, one knight per territory (Queendomino).
+     * placed holding no knight yet, while the player still has a knight
+     * available (Queendomino).
      * @param command - Contains game state and optional lord ID
      * @returns Valid positions, or [] when placeKnight is not the current action
      */
@@ -1758,6 +1813,15 @@ type GameEngine = {
      * @returns Buildings to pass to constructBuilding, or [] when none applies
      */
     getAffordableBuildings: (command: GetAffordableBuildingsCommand) => BuildingTile[];
+    /**
+     * Buildings of the Builders Board that `useDragon` accepts to burn
+     * (Queendomino): every building of the board when the Dragon is still in
+     * its cave this round, the lord does not host the Queen and can pay its
+     * 1 coin.
+     * @param command - Contains game state and optional lord ID
+     * @returns Buildings to pass to useDragon, or [] when the Dragon cannot be used
+     */
+    getValidDragonTargets: (command: GetValidDragonTargetsCommand) => BuildingTile[];
     /**
      * Valid `recruitCaveman` arguments: recruitable cavemen with every valid
      * resource payment, and the squares for the caveman (Origins Tribe).
@@ -1917,6 +1981,19 @@ type GameEventCallbacks = {
         lordId: string;
         dominoNumber: number;
     }) => void;
+    /**
+     * Called after the first pick of a line chose the Neolithic pair (Origins,
+     * 2 players): `dominoNumbers` (pair 1 & 4 or 2 & 3) are reserved for the
+     * picking lord's player, `opponentDominoNumbers` for the other player.
+     * Emitted after `onDominoPicked`.
+     */
+    onNeolithicPairChosen?: (event: {
+        game: GameState;
+        lordId: string;
+        playerId: string;
+        dominoNumbers: number[];
+        opponentDominoNumbers: number[];
+    }) => void;
     /** Called after a lord places a domino on their kingdom */
     onDominoPlaced?: (event: {
         game: GameState;
@@ -2646,4 +2723,4 @@ type UseDragonUseCase = (game: GameWithNextAction, lordId: string, buildingId: n
  */
 declare const createGameEngine: (config: Partial<EngineConfig>) => GameEngine;
 
-export { ACTION_LOG_VERSION, type ActionEntry, ActionExecutionError, type ActionPayloadMap, type ActionType, type AddExtraRulesCommand, type AddPlayersCommand, type AgeOfGiantsState, type BasicRules, type BotExtensionChoices, type BotStrategy, type BuildersBoard, type BuildingChoice, type BuildingContext, type BuildingSlot, type BuildingTile, type BuildingsRepository, type CalculatePlayerScoreCommand, type CalculatePlayerScoreUseCase, type CalculateScoreCommand, type CanPlaceDominoCommand, type CanSkipOptionalActionCommand, type CaveBoard, type CavemanChoice, type CavemanContext, type CavemanKind, type CavemanRecruitmentOption, type CavemanTile, type CavemenRepository, type ChooseDominoCommand, type ConstructBuildingCommand, type ConstructBuildingUseCase, type CreateGameCommand, type Crown, type DebugLogEntry, type DebugLogLevel, type DebugLogger, type DebugOptions, type DeserializeGameCommand, type DiscardDominoCommand, type DomainError, DomainException, type Domino, type DominoesRepository, type DragonContext, type DynastyGroupBy, type DynastyResult, type EmptyGround, type EmptyTile, type EndGameScoring, type EndGameScoringType, type EngineConfig, ErrorCode, type ErrorCodeType, type ExtensionContext, type ExtraRule, type FinalResult, type FireTokenContext, type FireTokenPool, GRIDSIZE, GROUND, type Game, type GameActionLog, type GameEngine, type GameEventCallbacks, type GameHistory, type GameMode, type GameSavePoint, type GameState, type GameStateResult, type GameStateSummary, type GameSteps, type GameWithNextAction, type GameWithNextStep, type GameWithResults, type GetAffordableBuildingsCommand, type GetDynastyResultCommand, type GetExtraRulesCommand, type GetModesCommand, type GetResultCommand, type GetValidActionTargetsCommand, type GetValidBuildingPositionsCommand, type GetValidCavemanPlacementsCommand, type GetValidFireTokenPositionsCommand, type GetValidGiantPositionsCommand, type GetValidGiantTargetsCommand, type GetValidKnightPositionsCommand, type GetValidPlacementsCommand, type GiantPositionContext, type Ground, type HunterGathererKind, type HunterGathererTile, type ImmediateBonus, type ImmediateBonusType, InvalidStepError, type Kingdom, type Knight, type KnightContext, type Logger, type Lord, MAX_KINGDOM_SIZE, type ModeRepository, type NextAction, type NextStep, NotFoundError, type ObjectValues, type OriginsState, type OriginsSubMode, type PendingFireToken, type PendingGiant, type PickContext, type PlaceContext, type PlaceDominoCommand, type PlaceFireTokenCommand, type PlaceFireTokenUseCase, type PlaceGiantCommand, type PlaceGiantUseCase, type PlaceKnightCommand, type PlaceKnightUseCase, type PlacedBuilding, type PlacedCaveman, type PlacedFireToken, type PlacedGiant, type Player, type PlayerActions, type PlayerInput, type PlayerPayload, type PlayerScore, type Players, type PlayersPayload, type Position, type QueenDominoState, type QuestTile, type QuestTilesRepository, type QuestType, type RecruitCavemanCommand, type RecruitCavemanUseCase, RedoError, type Resource, type ResourceType, type RevealsDomino, type Rotation, type RuleRepository, type Rules, type Score, type ScoreBonus, type ScoreBonusType, type ScoreBreakdown, type ScoreResult, type ScoreTerritory, type SelectedRules, type SendGiantChoice, type SendGiantCommand, type SendGiantContext, type SendGiantUseCase, type SerializeGameCommand, type ShuffleMethod, type SkipOptionalActionCommand, type SkipOptionalActionUseCase, type StartGameCommand, StepExecutionError, type StrategyName, type SupportedLocale, type Tile, type TotemBonus, type TotemState, TranslationKey, type TranslationKeyType, type Translator, UndoError, type UseDragonCommand, type UseDragonUseCase, type UuidMethod, type ValidActionTargetsUseCase, type ValidCavemanPlacements, type ValidGiantTargets, type ValidPlacement, ValidationError, type ValidationIssue, type ValidationSeverity, WARRIOR_POWER, type WarriorTile, type WarriorType, advancedStrategy, appendAction, canRedo, canUndo, cavemanKindToTranslationKey, cavemanKinds, clearHistory, createActionLog, createDomainError, createGameEngine, createGameHistory, createSavePoint, createTranslator, defaultTranslations, defaultTranslator, deserializeGame, englishTranslations, errorCodeToTranslationKey, expertStrategy, extraRuleNameToTranslationKey, frenchTranslations, gameSteps, getActions, getActionsByTurn, getActionsByType, getHistorySize, getStrategy, getStrategyNames, greedyStrategy, groundToTranslationKey, hunterGathererKindToTranslationKey, hunterGathererKinds, isBotTurn, isGameWithNextAction, isGameWithNextStep, isGameWithResults, isHunterGathererTile, isSkippableAction, isWarriorTile, localeTranslations, modeNameToTranslationKey, originsSubModes, playBotTurn, playBotTurns, playerActionToTranslationKey, playerActions, pushState, questTypeToTranslationKey, questTypes, randomStrategy, redo, replayActions, resourceToTranslationKey, resourceTypes, restoreFromSavePoint, scoreBonusTypes, serializeGame, summarizeGameState, supportedLocales, totemToTranslationKey, translateErrorCode, undo, validateGameState, warriorTypeToTranslationKey, warriorTypes, wrapWithActionLog, wrapWithDebug, wrapWithEvents };
+export { ACTION_LOG_VERSION, type ActionEntry, ActionExecutionError, type ActionPayloadMap, type ActionType, type AddExtraRulesCommand, type AddPlayersCommand, type AgeOfGiantsState, type BasicRules, type BotExtensionChoices, type BotStrategy, type BuildersBoard, type BuildingChoice, type BuildingContext, type BuildingSlot, type BuildingTile, type BuildingsRepository, type CalculatePlayerScoreCommand, type CalculatePlayerScoreUseCase, type CalculateScoreCommand, type CanPlaceDominoCommand, type CanSkipOptionalActionCommand, type CaveBoard, type CavemanChoice, type CavemanContext, type CavemanKind, type CavemanRecruitmentOption, type CavemanTile, type CavemenRepository, type ChooseDominoCommand, type ConstructBuildingCommand, type ConstructBuildingUseCase, type CreateGameCommand, type Crown, type DebugLogEntry, type DebugLogLevel, type DebugLogger, type DebugOptions, type DeserializeGameCommand, type DiscardDominoCommand, type DomainError, DomainException, type Domino, type DominoesRepository, type DragonContext, type DynastyGroupBy, type DynastyResult, type EmptyGround, type EmptyTile, type EndGameScoring, type EndGameScoringType, type EngineConfig, ErrorCode, type ErrorCodeType, type ExtensionContext, type ExtraRule, type FinalResult, type FireTokenContext, type FireTokenPool, GRIDSIZE, GROUND, type Game, type GameActionLog, type GameEngine, type GameEventCallbacks, type GameHistory, type GameMode, type GameSavePoint, type GameState, type GameStateResult, type GameStateSummary, type GameSteps, type GameWithNextAction, type GameWithNextStep, type GameWithResults, type GetAffordableBuildingsCommand, type GetDynastyResultCommand, type GetExtraRulesCommand, type GetModesCommand, type GetResultCommand, type GetValidActionTargetsCommand, type GetValidBuildingPositionsCommand, type GetValidCavemanPlacementsCommand, type GetValidDominoPicksCommand, type GetValidDragonTargetsCommand, type GetValidFireTokenPositionsCommand, type GetValidGiantPositionsCommand, type GetValidGiantTargetsCommand, type GetValidKnightPositionsCommand, type GetValidPlacementsCommand, type GiantPositionContext, type Ground, type HunterGathererKind, type HunterGathererTile, type ImmediateBonus, type ImmediateBonusType, InvalidStepError, type Kingdom, type Knight, type KnightContext, type Logger, type Lord, MAX_KINGDOM_SIZE, type ModeRepository, type NextAction, type NextStep, NotFoundError, type ObjectValues, type OriginsState, type OriginsSubMode, type PendingFireToken, type PendingGiant, type PickContext, type PlaceContext, type PlaceDominoCommand, type PlaceFireTokenCommand, type PlaceFireTokenUseCase, type PlaceGiantCommand, type PlaceGiantUseCase, type PlaceKnightCommand, type PlaceKnightUseCase, type PlacedBuilding, type PlacedCaveman, type PlacedFireToken, type PlacedGiant, type Player, type PlayerActions, type PlayerInput, type PlayerPayload, type PlayerScore, type Players, type PlayersPayload, type Position, type QueenDominoState, type QuestTile, type QuestTilesRepository, type QuestType, type RecruitCavemanCommand, type RecruitCavemanUseCase, RedoError, type Resource, type ResourceType, type RevealsDomino, type Rotation, type RuleRepository, type Rules, type Score, type ScoreBonus, type ScoreBonusType, type ScoreBreakdown, type ScoreResult, type ScoreTerritory, type SelectedRules, type SendGiantChoice, type SendGiantCommand, type SendGiantContext, type SendGiantUseCase, type SerializeGameCommand, type ShuffleMethod, type SkipOptionalActionCommand, type SkipOptionalActionUseCase, type StartGameCommand, StepExecutionError, type StrategyName, type SupportedLocale, type Tile, type TotemBonus, type TotemState, TranslationKey, type TranslationKeyType, type Translator, UndoError, type UseDragonCommand, type UseDragonUseCase, type UuidMethod, type ValidActionTargetsUseCase, type ValidCavemanPlacements, type ValidGiantTargets, type ValidPlacement, ValidationError, type ValidationIssue, type ValidationSeverity, WARRIOR_POWER, type WarriorTile, type WarriorType, advancedStrategy, appendAction, canRedo, canUndo, cavemanKindToTranslationKey, cavemanKinds, clearHistory, createActionLog, createDomainError, createGameEngine, createGameHistory, createSavePoint, createTranslator, defaultTranslations, defaultTranslator, deserializeGame, englishTranslations, errorCodeToTranslationKey, expertStrategy, extraRuleNameToTranslationKey, frenchTranslations, gameSteps, getActions, getActionsByTurn, getActionsByType, getHistorySize, getStrategy, getStrategyNames, greedyStrategy, groundToTranslationKey, hunterGathererKindToTranslationKey, hunterGathererKinds, isBotTurn, isGameWithNextAction, isGameWithNextStep, isGameWithResults, isHunterGathererTile, isSkippableAction, isWarriorTile, localeTranslations, modeNameToTranslationKey, originsSubModes, playBotTurn, playBotTurns, playerActionToTranslationKey, playerActions, pushState, questTypeToTranslationKey, questTypes, randomStrategy, redo, replayActions, resourceToTranslationKey, resourceTypes, restoreFromSavePoint, scoreBonusTypes, serializeGame, summarizeGameState, supportedLocales, totemToTranslationKey, translateErrorCode, undo, validateGameState, warriorTypeToTranslationKey, warriorTypes, wrapWithActionLog, wrapWithDebug, wrapWithEvents };