@pompidup/kingdomino-engine 3.6.0 → 3.7.0

package/dist/index.universal.js

@@ -164,6 +164,12 @@ var wrapWithDebug = (engine, options) => {
       logger,
       level
     ),
+    getValidDominoPicks: wrapMethod(
+      "getValidDominoPicks",
+      engine.getValidDominoPicks,
+      logger,
+      level
+    ),
     serialize: wrapMethod("serialize", engine.serialize, logger, level),
     deserialize: wrapMethod("deserialize", engine.deserialize, logger, level),
     getDynastyResults: wrapMethod(
@@ -224,6 +230,12 @@ var wrapWithDebug = (engine, options) => {
       logger,
       level
     ),
+    getValidDragonTargets: wrapMethod(
+      "getValidDragonTargets",
+      engine.getValidDragonTargets,
+      logger,
+      level
+    ),
     getValidCavemanPlacements: wrapMethod(
       "getValidCavemanPlacements",
       engine.getValidCavemanPlacements,
@@ -269,6 +281,23 @@ var wrapWithEvents = (engine, callbacks) => {
       callbacks.onGameEnd?.({ game: after });
     }
   };
+  const emitNeolithicPair = (before, after, lordId) => {
+    if (!callbacks.onNeolithicPairChosen) return;
+    if (before.currentDominoes.some((d) => d.reservedFor !== void 0)) return;
+    const playerId = before.lords.find((l) => l.id === lordId)?.playerId;
+    const reserved = after.currentDominoes.filter(
+      (d) => d.reservedFor !== void 0
+    );
+    if (!playerId || reserved.length === 0) return;
+    const numbersFor = (own) => reserved.filter((d) => d.reservedFor === playerId === own).map((d) => d.domino.number);
+    callbacks.onNeolithicPairChosen({
+      game: after,
+      lordId,
+      playerId,
+      dominoNumbers: numbersFor(true),
+      opponentDominoNumbers: numbersFor(false)
+    });
+  };
   const gameplay = (run, emit) => (cmd) => {
     const game = run(cmd);
     emit(game, cmd);
@@ -282,6 +311,7 @@ var wrapWithEvents = (engine, callbacks) => {
     calculateScore: (cmd) => engine.calculateScore(cmd),
     getValidPlacements: (cmd) => engine.getValidPlacements(cmd),
     canPlaceDomino: (cmd) => engine.canPlaceDomino(cmd),
+    getValidDominoPicks: (cmd) => engine.getValidDominoPicks(cmd),
     serialize: (cmd) => engine.serialize(cmd),
     deserialize: (cmd) => engine.deserialize(cmd),
     getResults: (cmd) => engine.getResults(cmd),
@@ -290,6 +320,7 @@ var wrapWithEvents = (engine, callbacks) => {
     getValidKnightPositions: (cmd) => engine.getValidKnightPositions(cmd),
     getValidBuildingPositions: (cmd) => engine.getValidBuildingPositions(cmd),
     getAffordableBuildings: (cmd) => engine.getAffordableBuildings(cmd),
+    getValidDragonTargets: (cmd) => engine.getValidDragonTargets(cmd),
     getValidCavemanPlacements: (cmd) => engine.getValidCavemanPlacements(cmd),
     getValidGiantPositions: (cmd) => engine.getValidGiantPositions(cmd),
     getValidGiantTargets: (cmd) => engine.getValidGiantTargets(cmd),
@@ -320,11 +351,14 @@ var wrapWithEvents = (engine, callbacks) => {
     // Gameplay methods — specific event, then derived turn / game-end events
     chooseDomino: gameplay(
       (cmd) => engine.chooseDomino(cmd),
-      (game, cmd) => callbacks.onDominoPicked?.({
-        game,
-        lordId: cmd.lordId,
-        dominoNumber: cmd.dominoPick
-      })
+      (game, cmd) => {
+        callbacks.onDominoPicked?.({
+          game,
+          lordId: cmd.lordId,
+          dominoNumber: cmd.dominoPick
+        });
+        emitNeolithicPair(cmd.game, game, cmd.lordId);
+      }
     ),
     placeDomino: gameplay(
       (cmd) => engine.placeDomino(cmd),
@@ -3857,6 +3891,29 @@ var rules_default = {
       dominoesDiscardedPerTurn: 0
     }
   ],
+  modes: {
+    QueenDomino: [
+      {
+        playersLimit: 2,
+        lordsPerPlayer: 2,
+        maxDominoes: 48,
+        dominoesPerTurn: 4,
+        maxTurns: 12,
+        maxKingdomSize: 7
+      }
+    ],
+    "AgeOfGiants-QueenDomino": [
+      {
+        playersLimit: 2,
+        lordsPerPlayer: 2,
+        maxDominoes: 60,
+        dominoesPerTurn: 5,
+        maxTurns: 12,
+        maxKingdomSize: 7,
+        dominoesDiscardedPerTurn: 1
+      }
+    ]
+  },
   extra: [
     {
       name: "The middle Kingdom",
@@ -3970,6 +4027,24 @@ var jsonRules = () => {
       };
     });
   }
+  const modeRules = rules_default.modes ?? {};
+  for (const [modeName, modeEntries] of Object.entries(modeRules)) {
+    rules.modeBasic ??= {};
+    const byPlayers = {};
+    modeEntries.forEach((rule) => {
+      byPlayers[rule.playersLimit] = {
+        lords: rule.lordsPerPlayer,
+        maxDominoes: rule.maxDominoes,
+        dominoesPerTurn: rule.dominoesPerTurn,
+        maxTurns: rule.maxTurns,
+        maxKingdomSize: rule.maxKingdomSize,
+        ...rule.dominoesDiscardedPerTurn !== void 0 && {
+          dominoesDiscardedPerTurn: rule.dominoesDiscardedPerTurn
+        }
+      };
+    });
+    rules.modeBasic[modeName] = byPlayers;
+  }
   extraRules.forEach((rule) => {
     rules.extraRules.push({
       name: rule.name,
@@ -4029,6 +4104,7 @@ var ErrorCode = {
   CANNOT_PICK: "CANNOT_PICK",
   CANNOT_PLACE: "CANNOT_PLACE",
   DOMINO_ALREADY_PICKED: "DOMINO_ALREADY_PICKED",
+  DOMINO_RESERVED: "DOMINO_RESERVED",
   // History errors
   UNDO_UNAVAILABLE: "UNDO_UNAVAILABLE",
   REDO_UNAVAILABLE: "REDO_UNAVAILABLE",
@@ -4165,6 +4241,7 @@ var TranslationKey = {
   ERROR_CANNOT_PICK: "error.cannotPick",
   ERROR_CANNOT_PLACE: "error.cannotPlace",
   ERROR_DOMINO_ALREADY_PICKED: "error.dominoAlreadyPicked",
+  ERROR_DOMINO_RESERVED: "error.dominoReserved",
   ERROR_INVALID_PLAYER_COUNT: "error.invalidPlayerCount",
   ERROR_INVALID_PLAYER_NAME: "error.invalidPlayerName",
   ERROR_EXTRA_RULE_NOT_AVAILABLE: "error.extraRuleNotAvailable",
@@ -4265,6 +4342,7 @@ var TranslationKey = {
   // hunter-gatherers reuse the CAVEMAN_* keys)
   SCORE_QUEEN: "score.queen",
   SCORE_BUILDING: "score.building",
+  SCORE_WEALTH: "score.wealth",
   SCORE_TOTEM_MAMMOTH: "score.totemMammoth",
   SCORE_TOTEM_FISH: "score.totemFish",
   SCORE_TOTEM_MUSHROOM: "score.totemMushroom",
@@ -4299,6 +4377,7 @@ var defaultTranslations = {
   [TranslationKey.ERROR_CANNOT_PICK]: "Cannot pick a domino now",
   [TranslationKey.ERROR_CANNOT_PLACE]: "Cannot place a domino now",
   [TranslationKey.ERROR_DOMINO_ALREADY_PICKED]: "Domino has already been picked",
+  [TranslationKey.ERROR_DOMINO_RESERVED]: "This domino is reserved for the other player (Neolithic: pairs 1 & 4 and 2 & 3)",
   [TranslationKey.ERROR_INVALID_PLAYER_COUNT]: "Invalid number of players (1-4 required)",
   [TranslationKey.ERROR_INVALID_PLAYER_NAME]: "Player name must be at least 3 characters",
   [TranslationKey.ERROR_EXTRA_RULE_NOT_AVAILABLE]: "Extra rule is not available for this game mode or number of players",
@@ -4397,6 +4476,7 @@ var defaultTranslations = {
   // Score breakdown labels
   [TranslationKey.SCORE_QUEEN]: "Queen",
   [TranslationKey.SCORE_BUILDING]: "Building: {{name}}",
+  [TranslationKey.SCORE_WEALTH]: "Wealth",
   [TranslationKey.SCORE_TOTEM_MAMMOTH]: "Mammoth totem",
   [TranslationKey.SCORE_TOTEM_FISH]: "Fish totem",
   [TranslationKey.SCORE_TOTEM_MUSHROOM]: "Mushroom totem",
@@ -4432,6 +4512,7 @@ var frenchTranslations = {
   [TranslationKey.ERROR_CANNOT_PICK]: "Impossible de choisir un domino maintenant",
   [TranslationKey.ERROR_CANNOT_PLACE]: "Impossible de placer un domino maintenant",
   [TranslationKey.ERROR_DOMINO_ALREADY_PICKED]: "Ce domino a d\xE9j\xE0 \xE9t\xE9 choisi",
+  [TranslationKey.ERROR_DOMINO_RESERVED]: "Ce domino est r\xE9serv\xE9 \xE0 l'autre joueur (N\xE9olithique : paires 1 et 4, 2 et 3)",
   [TranslationKey.ERROR_INVALID_PLAYER_COUNT]: "Nombre de joueurs invalide (1 \xE0 4 requis)",
   [TranslationKey.ERROR_INVALID_PLAYER_NAME]: "Le nom du joueur doit contenir au moins 3 caract\xE8res",
   [TranslationKey.ERROR_EXTRA_RULE_NOT_AVAILABLE]: "Cette r\xE8gle optionnelle n'est pas disponible pour ce mode ou ce nombre de joueurs",
@@ -4530,6 +4611,7 @@ var frenchTranslations = {
   // Score breakdown labels
   [TranslationKey.SCORE_QUEEN]: "Reine",
   [TranslationKey.SCORE_BUILDING]: "B\xE2timent : {{name}}",
+  [TranslationKey.SCORE_WEALTH]: "Richesse",
   [TranslationKey.SCORE_TOTEM_MAMMOTH]: "Totem mammouth",
   [TranslationKey.SCORE_TOTEM_FISH]: "Totem poisson",
   [TranslationKey.SCORE_TOTEM_MUSHROOM]: "Totem champignon",
@@ -4641,6 +4723,7 @@ var errorCodeToTranslationKey = {
   [ErrorCode.CANNOT_PICK]: TranslationKey.ERROR_CANNOT_PICK,
   [ErrorCode.CANNOT_PLACE]: TranslationKey.ERROR_CANNOT_PLACE,
   [ErrorCode.DOMINO_ALREADY_PICKED]: TranslationKey.ERROR_DOMINO_ALREADY_PICKED,
+  [ErrorCode.DOMINO_RESERVED]: TranslationKey.ERROR_DOMINO_RESERVED,
   [ErrorCode.UNDO_UNAVAILABLE]: TranslationKey.ERROR_UNDO_UNAVAILABLE,
   [ErrorCode.REDO_UNAVAILABLE]: TranslationKey.ERROR_REDO_UNAVAILABLE,
   [ErrorCode.CANNOT_PLACE_KNIGHT]: TranslationKey.ERROR_CANNOT_PLACE_KNIGHT,
@@ -5666,6 +5749,8 @@ var scoreBonusTypes = {
   queen: "queen",
   /** Queendomino: end-game scoring of one constructed building */
   building: "building",
+  /** Queendomino: Wealth, 1 point per 3 unused coins */
+  wealth: "wealth",
   /** Age of Giants: one quest tile */
   quest: "quest",
   /** Origins Totem: one totem held by the player */
@@ -5733,7 +5818,7 @@ var addExtraRulesUseCase = (deps) => (game, rules) => {
   }
   let updatedBasic = game.rules.basic;
   let updatedDominoes = game.dominoes;
-  const hasLargeKingdomRule = newExtraRules.some(isLargeKingdomExtraRule);
+  const hasLargeKingdomRule = newExtraRules.some(isLargeKingdomExtraRule) && game.rules.basic.maxKingdomSize < 7;
   if (hasLargeKingdomRule) {
     updatedBasic = {
       ...updatedBasic,
@@ -5784,7 +5869,10 @@ var isFootprintDomino = (domino) => (domino.left.hasFootprint ?? false) || (domi
 
 // src/core/domain/entities/economy.ts
 var STARTING_COINS = 7;
-var MAX_KNIGHTS = 3;
+var STARTING_KNIGHTS = 1;
+var DRAGON_COST = 1;
+var QUEEN_DISCOUNT = 1;
+var COINS_PER_WEALTH_POINT = 3;
 var addCoins = (player, amount) => ({
   ...player,
   coins: (player.coins ?? 0) + amount
@@ -5803,7 +5891,8 @@ var addBonusKnights = (player, amount) => ({
   ...player,
   bonusKnights: (player.bonusKnights ?? 0) + amount
 });
-var getMaxKnights = (player) => MAX_KNIGHTS + (player.bonusKnights ?? 0);
+var getMaxKnights = (player) => STARTING_KNIGHTS + (player.bonusKnights ?? 0);
+var getWealthPoints = (player) => Math.floor(Math.max(0, player.coins ?? 0) / COINS_PER_WEALTH_POINT);
 
 // src/core/domain/entities/domino.ts
 var isGround = (ground) => {
@@ -6158,7 +6247,7 @@ var addPlayersUseCase = (deps) => (game, players) => {
     newPlayers.push(newPlayer.value);
   }
   const rules = ruleRepository.getAll();
-  const basicRules = isAoG && rules.aogBasic ? rules.aogBasic[newPlayers.length] : rules.basic[newPlayers.length];
+  const basicRules = rules.modeBasic?.[game.mode.name]?.[newPlayers.length] ?? (isAoG && rules.aogBasic ? rules.aogBasic[newPlayers.length] : rules.basic[newPlayers.length]);
   if (!basicRules) {
     return err(ErrorCode.STEP_EXECUTION_FAILED);
   }
@@ -6417,7 +6506,15 @@ var calculateOriginsFireBonus = (kingdom, placedFireTokens) => {
 };
 
 // src/core/domain/entities/queen.ts
-var determineQueenHolder = (players, currentHolderId) => {
+var determineQueenHolder = (players, currentHolderId, actingPlayerId) => {
+  if (actingPlayerId !== void 0) {
+    const acting = players.find((p) => p.id === actingPlayerId);
+    if (!acting) return currentHolderId;
+    const towers = getTowerCount(acting);
+    const others = players.filter((p) => p.id !== actingPlayerId);
+    const reachesMost = towers > 0 && others.every((p) => getTowerCount(p) <= towers);
+    return reachesMost ? actingPlayerId : currentHolderId;
+  }
   let maxTowers = 0;
   let leaderId = null;
   let isTied = false;
@@ -6929,6 +7026,12 @@ var queendominoBonuses = (game, player, provisional) => {
       provisional
     });
   }
+  bonuses.push({
+    type: "wealth",
+    label: TranslationKey.SCORE_WEALTH,
+    points: getWealthPoints(player),
+    provisional
+  });
   for (const placed of player.buildings ?? []) {
     if (!placed.building.endGameScoring) continue;
     bonuses.push({
@@ -7124,31 +7227,58 @@ var calculateScoreUseCase = (kingdom, giantPositions) => {
 };
 
 // src/core/domain/entities/building.ts
-var BOARD_SLOTS = 4;
+var BUILDERS_BOARD_SLOT_COSTS = [5, 4, 3, 2, 1, 0];
+var BOARD_SLOTS = BUILDERS_BOARD_SLOT_COSTS.length;
 var createBuildersBoard = (tiles, shuffle) => {
   const shuffled = shuffle([...tiles]);
   const slots = shuffled.slice(0, BOARD_SLOTS);
+  while (slots.length < BOARD_SLOTS) slots.push(null);
   const drawPile = shuffled.slice(BOARD_SLOTS);
   return {
     slots,
-    drawPile
+    drawPile,
+    slotCosts: [...BUILDERS_BOARD_SLOT_COSTS]
   };
 };
 var refillBuildersBoard = (board) => {
-  const newSlots = [...board.slots];
   const newDrawPile = [...board.drawPile];
-  for (let i = 0; i < newSlots.length; i++) {
-    if (newSlots[i] === null && newDrawPile.length > 0) {
-      newSlots[i] = newDrawPile.shift();
+  if (!board.slotCosts) {
+    const newSlots2 = [...board.slots];
+    for (let i = 0; i < newSlots2.length; i++) {
+      if (newSlots2[i] === null && newDrawPile.length > 0) {
+        newSlots2[i] = newDrawPile.shift();
+      }
     }
+    return { slots: newSlots2, drawPile: newDrawPile };
   }
-  return { slots: newSlots, drawPile: newDrawPile };
+  const remaining = board.slots.filter(
+    (slot) => slot !== null
+  );
+  const empty = board.slots.length - remaining.length;
+  const newSlots = [
+    ...Array.from({ length: empty }, () => null),
+    ...remaining
+  ];
+  for (let i = empty - 1; i >= 0 && newDrawPile.length > 0; i--) {
+    newSlots[i] = newDrawPile.shift();
+  }
+  return { ...board, slots: newSlots, drawPile: newDrawPile };
 };
 var startNewQueenDominoRound = (state) => ({
   ...state,
   buildersBoard: refillBuildersBoard(state.buildersBoard),
   dragonUsedThisRound: false
 });
+var getSlotCost = (board, slotIndex) => {
+  const building = board.slots[slotIndex];
+  if (!building) return null;
+  return board.slotCosts?.[slotIndex] ?? building.cost;
+};
+var getConstructionCost = (board, slotIndex, isQueenHost) => {
+  const cost = getSlotCost(board, slotIndex);
+  if (cost === null) return null;
+  return Math.max(0, cost - (isQueenHost ? QUEEN_DISCOUNT : 0));
+};
 var findBuildingOnBoard = (board, buildingId) => {
   for (let i = 0; i < board.slots.length; i++) {
     const slot = board.slots[i];
@@ -7163,12 +7293,17 @@ var removeBuildingFromBoard = (board, slotIndex) => {
   newSlots[slotIndex] = null;
   return { ...board, slots: newSlots };
 };
-var purchaseBuilding = (board, player, buildingId) => {
+var purchaseBuilding = (board, player, buildingId, queenHolderId = null) => {
   const found = findBuildingOnBoard(board, buildingId);
   if (!found) return null;
   const { building, slotIndex } = found;
-  if (!canAfford(player, building.cost)) return null;
-  let updatedPlayer = removeCoins(player, building.cost);
+  const cost = getConstructionCost(
+    board,
+    slotIndex,
+    queenHolderId !== null && queenHolderId === player.id
+  );
+  if (cost === null || !canAfford(player, cost)) return null;
+  let updatedPlayer = removeCoins(player, cost);
   if (building.immediateBonus) {
     switch (building.immediateBonus.type) {
       case "coins":
@@ -7192,7 +7327,7 @@ var purchaseBuilding = (board, player, buildingId) => {
     updatedPlayer = addTowers(updatedPlayer, building.towers);
   }
   const updatedBoard = removeBuildingFromBoard(board, slotIndex);
-  return { updatedBoard, updatedPlayer, building };
+  return { updatedBoard, updatedPlayer, building, cost };
 };
 var isValidConstructionPosition = (kingdom, placedBuildings, position) => {
   const tile = kingdom[position.y]?.[position.x];
@@ -7218,9 +7353,9 @@ var placeBuildingOnKingdom = (kingdom, building, position) => {
 var destroyWithDragon = (board, buildingId, player) => {
   const found = findBuildingOnBoard(board, buildingId);
   if (!found) return null;
-  const { building, slotIndex } = found;
-  if (!canAfford(player, building.cost)) return null;
-  const updatedPlayer = removeCoins(player, building.cost);
+  const { slotIndex } = found;
+  if (!canAfford(player, DRAGON_COST)) return null;
+  const updatedPlayer = removeCoins(player, DRAGON_COST);
   const updatedBoard = removeBuildingFromBoard(board, slotIndex);
   return { updatedBoard, updatedPlayer };
 };
@@ -7339,6 +7474,30 @@ var nextOriginsAction = (currentAction, isTribe) => {
   return sequence[index + 1];
 };
 
+// src/core/domain/entities/neolithic.ts
+var NEOLITHIC_RULE_NAME = "Neolithic";
+var NEOLITHIC_PAIRS = [
+  [1, 4],
+  [2, 3]
+];
+var NEOLITHIC_LINE_SIZE = 4;
+var isNeolithicGame = (game) => game.players.length === 2 && game.rules.extra.some((rule) => rule.name === NEOLITHIC_RULE_NAME);
+var neolithicPairOf = (position) => NEOLITHIC_PAIRS.find((pair) => pair.includes(position));
+var isNeolithicPairChoice = (game, line) => isNeolithicGame(game) && line.length === NEOLITHIC_LINE_SIZE && line.every((domino) => !domino.picked && domino.reservedFor === void 0);
+var canLordPickRevealed = (lord, domino) => !domino.picked && (domino.reservedFor === void 0 || domino.reservedFor === lord.playerId);
+var reserveNeolithicPairs = (game, line, lord, pickedNumber) => {
+  if (!isNeolithicPairChoice(game, line)) return line;
+  const picked = line.find((domino) => domino.domino.number === pickedNumber);
+  const pair = picked && neolithicPairOf(picked.position);
+  const opponent = game.players.find((player) => player.id !== lord.playerId);
+  if (!pair || !opponent) return line;
+  return line.map((domino) => ({
+    ...domino,
+    reservedFor: pair.includes(domino.position) ? lord.playerId : opponent.id
+  }));
+};
+var pickableDominoNumbers = (line, lord) => line.filter((domino) => canLordPickRevealed(lord, domino)).map((domino) => domino.domino.number);
+
 // src/core/useCases/chooseDomino.ts
 var chooseDominoUseCase = (game, lordId, dominoPick) => {
   const currentLord = game.lords.find(
@@ -7362,7 +7521,15 @@ var chooseDominoUseCase = (game, lordId, dominoPick) => {
   if (selectedDomino.picked) {
     return err(ErrorCode.DOMINO_ALREADY_PICKED);
   }
-  const updatedCurrentDominoes = game.currentDominoes.map(
+  if (selectedDomino.reservedFor !== void 0 && selectedDomino.reservedFor !== currentLord.playerId) {
+    return err(ErrorCode.DOMINO_RESERVED);
+  }
+  const updatedCurrentDominoes = reserveNeolithicPairs(
+    game,
+    game.currentDominoes,
+    currentLord,
+    dominoPick
+  ).map(
     (domino) => domino.domino.number === dominoPick ? { ...domino, picked: true, lordId: currentLord.id } : domino
   );
   const isTribe = isTribeMode(game.mode.name);
@@ -7472,7 +7639,8 @@ var constructBuildingUseCase = (game, lordId, buildingId, position) => {
   const purchaseResult = purchaseBuilding(
     queendomino.buildersBoard,
     currentPlayer,
-    buildingId
+    buildingId,
+    queendomino.queenHolderId
   );
   if (!purchaseResult) {
     return err(ErrorCode.CANNOT_AFFORD_BUILDING);
@@ -7494,7 +7662,8 @@ var constructBuildingUseCase = (game, lordId, buildingId, position) => {
   );
   const newQueenHolder = determineQueenHolder(
     updatedPlayers,
-    queendomino.queenHolderId
+    queendomino.queenHolderId,
+    currentPlayer.id
   );
   const nextAction = nextQueenDominoAction(playerActions.constructBuilding);
   return ok({
@@ -8024,55 +8193,18 @@ var getResultUseCase = (game) => {
 };
 
 // src/core/domain/entities/knight.ts
-var countConstructionSquaresInTerritory = (kingdom, position) => {
-  const rows = kingdom.length;
-  const cols = kingdom[0]?.length ?? 0;
+var countTerritorySquares = (kingdom, position) => {
   const startTile = kingdom[position.y]?.[position.x];
   if (!startTile || startTile.type === "empty" || startTile.type === "castle") {
     return 0;
   }
-  const terrainType = startTile.type;
-  const visited = kingdom.map((row) => row.map(() => false));
-  const queue = [[position.x, position.y]];
-  visited[position.y][position.x] = true;
-  let count = 0;
-  const directions = [
-    [-1, 0],
-    [1, 0],
-    [0, -1],
-    [0, 1]
-  ];
-  while (queue.length > 0) {
-    const [cx, cy] = queue.pop();
-    const tile = kingdom[cy][cx];
-    if (tile.type !== "empty" && tile.type !== "castle" && "hasConstructionSquare" in tile && tile.hasConstructionSquare) {
-      count++;
-    }
-    for (const [dx, dy] of directions) {
-      const nx = cx + dx;
-      const ny = cy + dy;
-      if (nx >= 0 && ny >= 0 && nx < cols && ny < rows && !visited[ny][nx] && kingdom[ny][nx].type === terrainType) {
-        visited[ny][nx] = true;
-        queue.push([nx, ny]);
-      }
-    }
-  }
-  return count;
-};
-var getTerritoryTerrain = (kingdom, position) => {
-  const tile = kingdom[position.y]?.[position.x];
-  if (!tile || tile.type === "empty" || tile.type === "castle") return null;
-  return tile.type;
-};
-var territoryHasKnight = (kingdom, position, knights) => {
-  const terrain = getTerritoryTerrain(kingdom, position);
-  if (!terrain) return false;
   const rows = kingdom.length;
   const cols = kingdom[0]?.length ?? 0;
+  const terrain = startTile.type;
   const visited = kingdom.map((row) => row.map(() => false));
   const queue = [[position.x, position.y]];
   visited[position.y][position.x] = true;
-  const territoryPositions = /* @__PURE__ */ new Set();
+  let count = 0;
   const directions = [
     [-1, 0],
     [1, 0],
@@ -8081,7 +8213,7 @@ var territoryHasKnight = (kingdom, position, knights) => {
   ];
   while (queue.length > 0) {
     const [cx, cy] = queue.pop();
-    territoryPositions.add(`${cx},${cy}`);
+    count++;
     for (const [dx, dy] of directions) {
       const nx = cx + dx;
       const ny = cy + dy;
@@ -8091,10 +8223,9 @@ var territoryHasKnight = (kingdom, position, knights) => {
       }
     }
   }
-  return knights.some(
-    (k) => territoryPositions.has(`${k.position.x},${k.position.y}`)
-  );
+  return count;
 };
+var calculateKnightTax = (kingdom, position) => countTerritorySquares(kingdom, position);
 var canPlaceKnight = (player, kingdom, position, allowedPositions) => {
   const knights = player.knights ?? [];
   if (knights.length >= getMaxKnights(player)) return false;
@@ -8103,13 +8234,17 @@ var canPlaceKnight = (player, kingdom, position, allowedPositions) => {
   }
   const tile = kingdom[position.y]?.[position.x];
   if (!tile || tile.type === "empty" || tile.type === "castle") return false;
-  if (territoryHasKnight(kingdom, position, knights)) return false;
+  if (knights.some(
+    (k) => k.position.x === position.x && k.position.y === position.y
+  )) {
+    return false;
+  }
   return true;
 };
 var placeKnight = (player, kingdom, position) => {
   const knight = { playerId: player.id, position };
   const knights = [...player.knights ?? [], knight];
-  const taxAmount = countConstructionSquaresInTerritory(kingdom, position);
+  const taxAmount = calculateKnightTax(kingdom, position);
   const updatedPlayer = addCoins({ ...player, knights }, taxAmount);
   return updatedPlayer;
 };
@@ -8445,7 +8580,15 @@ var placeKnightUseCase = (game, lordId, position) => {
   const updatedPlayers = game.players.map(
     (p) => p.id === currentPlayer.id ? updatedPlayer : p
   );
-  const nextAction = nextQueenDominoAction(playerActions.placeKnight);
+  const canPlaceAnother = allowedPositions.some(
+    (square) => canPlaceKnight(
+      updatedPlayer,
+      updatedPlayer.kingdom,
+      square,
+      allowedPositions
+    )
+  );
+  const nextAction = canPlaceAnother ? playerActions.placeKnight : nextQueenDominoAction(playerActions.placeKnight);
   return ok({
     ...game,
     players: updatedPlayers,
@@ -8653,6 +8796,74 @@ var advanceToNextLordOrResult2 = (game) => {
   });
 };
 
+// src/core/useCases/useDragon.ts
+var resolveDragon = (game, lordId) => {
+  const currentAction = game.nextAction;
+  if (currentAction.nextLord !== lordId) {
+    return err(ErrorCode.NOT_YOUR_TURN);
+  }
+  if (currentAction.nextAction !== playerActions.useDragon) {
+    return err(ErrorCode.INVALID_OPTIONAL_ACTION);
+  }
+  if (!game.queendomino) {
+    return err(ErrorCode.INVALID_OPTIONAL_ACTION);
+  }
+  if (!game.queendomino.dragonAvailable || game.queendomino.dragonUsedThisRound) {
+    return err(ErrorCode.DRAGON_UNAVAILABLE);
+  }
+  const currentLord = game.lords.find((l) => l.id === lordId);
+  if (!currentLord) return err(ErrorCode.LORD_NOT_FOUND);
+  const currentPlayer = game.players.find((p) => p.id === currentLord.playerId);
+  if (!currentPlayer) return err(ErrorCode.PLAYER_NOT_FOUND);
+  if (game.queendomino.queenHolderId === currentPlayer.id) {
+    return err(ErrorCode.QUEEN_HOLDER_CANNOT_USE_DRAGON);
+  }
+  return ok({ player: currentPlayer, queendomino: game.queendomino });
+};
+var useDragonUseCase = (game, lordId, buildingId) => {
+  const context = resolveDragon(game, lordId);
+  if (isErr(context)) {
+    return context;
+  }
+  const { player: currentPlayer, queendomino } = context.value;
+  const result = destroyWithDragon(
+    queendomino.buildersBoard,
+    buildingId,
+    currentPlayer
+  );
+  if (!result) {
+    return err(ErrorCode.BUILDING_NOT_FOUND);
+  }
+  const { updatedBoard, updatedPlayer } = result;
+  const updatedPlayers = game.players.map(
+    (p) => p.id === currentPlayer.id ? updatedPlayer : p
+  );
+  const maxTurns = game.rules.basic.maxTurns;
+  const isLastTurn = game.turn === maxTurns;
+  if (isLastTurn && allLordsHavePlayed(game.lords)) {
+    return ok({
+      ...game,
+      players: updatedPlayers,
+      queendomino: {
+        ...queendomino,
+        buildersBoard: updatedBoard,
+        dragonUsedThisRound: true
+      },
+      nextAction: { type: "step", step: gameSteps.result }
+    });
+  }
+  return ok({
+    ...game,
+    players: updatedPlayers,
+    queendomino: {
+      ...queendomino,
+      buildersBoard: updatedBoard,
+      dragonUsedThisRound: true
+    },
+    nextAction: nextLordWithAction(game.lords)
+  });
+};
+
 // src/core/useCases/getValidActionTargets.ts
 var turnFor = (game, action, lordId) => {
   if (!isGameWithNextAction(game) || game.nextAction.nextAction !== action) {
@@ -8703,13 +8914,24 @@ var getConstructionOptions = (game, lordId) => {
     )
   );
   const buildings = board.slots.filter(
-    (slot) => slot !== null && purchaseBuilding(board, player, slot.id) !== null
+    (slot) => slot !== null && purchaseBuilding(board, player, slot.id, queendomino.queenHolderId) !== null
   );
   if (positions.length === 0 || buildings.length === 0) return noConstruction();
   return { positions, buildings };
 };
 var getValidBuildingPositionsUseCase = (game, lordId) => getConstructionOptions(game, lordId).positions;
 var getAffordableBuildingsUseCase = (game, lordId) => getConstructionOptions(game, lordId).buildings;
+var getValidDragonTargetsUseCase = (game, lordId) => {
+  const turn = turnFor(game, playerActions.useDragon, lordId);
+  if (!turn) return [];
+  const context = resolveDragon(turn.game, turn.lordId);
+  if (isErr(context)) return [];
+  const { player, queendomino } = context.value;
+  const board = queendomino.buildersBoard;
+  return board.slots.filter(
+    (slot) => slot !== null && destroyWithDragon(board, slot.id, player) !== null
+  );
+};
 var noRecruitment = () => ({
   options: [],
   positions: []
@@ -8789,6 +9011,18 @@ var getValidGiantTargetsUseCase = (game, lordId) => {
 };
 var canSkipOptionalActionUseCase = (game, lordId) => isGameWithNextAction(game) && isOk(resolveSkip(game, lordId ?? game.nextAction.nextLord));
 
+// src/core/useCases/getValidDominoPicks.ts
+var getValidDominoPicksUseCase = (game, lordId) => {
+  if (!isGameWithNextAction(game) || game.nextAction.nextAction !== playerActions.pickDomino) {
+    return [];
+  }
+  const id = lordId ?? game.nextAction.nextLord;
+  if (id !== game.nextAction.nextLord) return [];
+  const lord = game.lords.find((l) => l.id === id);
+  if (!lord || !canPick(lord)) return [];
+  return pickableDominoNumbers(game.currentDominoes, lord);
+};
+
 // src/core/useCases/placeDomino.ts
 var findVolcanoInDomino = (game, position, rotation) => {
   const lord = game.lords.find((l) => l.id === game.nextAction.nextLord);
@@ -9097,66 +9331,6 @@ var startGameUseCase = (deps) => (game) => {
   return ok(newState);
 };
 
-// src/core/useCases/useDragon.ts
-var useDragonUseCase = (game, lordId, buildingId) => {
-  const currentAction = game.nextAction;
-  if (currentAction.nextLord !== lordId) {
-    return err(ErrorCode.NOT_YOUR_TURN);
-  }
-  if (currentAction.nextAction !== playerActions.useDragon) {
-    return err(ErrorCode.INVALID_OPTIONAL_ACTION);
-  }
-  if (!game.queendomino) {
-    return err(ErrorCode.INVALID_OPTIONAL_ACTION);
-  }
-  if (!game.queendomino.dragonAvailable || game.queendomino.dragonUsedThisRound) {
-    return err(ErrorCode.DRAGON_UNAVAILABLE);
-  }
-  const currentLord = game.lords.find((l) => l.id === lordId);
-  if (!currentLord) return err(ErrorCode.LORD_NOT_FOUND);
-  const currentPlayer = game.players.find((p) => p.id === currentLord.playerId);
-  if (!currentPlayer) return err(ErrorCode.PLAYER_NOT_FOUND);
-  if (game.queendomino.queenHolderId === currentPlayer.id) {
-    return err(ErrorCode.QUEEN_HOLDER_CANNOT_USE_DRAGON);
-  }
-  const result = destroyWithDragon(
-    game.queendomino.buildersBoard,
-    buildingId,
-    currentPlayer
-  );
-  if (!result) {
-    return err(ErrorCode.BUILDING_NOT_FOUND);
-  }
-  const { updatedBoard, updatedPlayer } = result;
-  const updatedPlayers = game.players.map(
-    (p) => p.id === currentPlayer.id ? updatedPlayer : p
-  );
-  const maxTurns = game.rules.basic.maxTurns;
-  const isLastTurn = game.turn === maxTurns;
-  if (isLastTurn && allLordsHavePlayed(game.lords)) {
-    return ok({
-      ...game,
-      players: updatedPlayers,
-      queendomino: {
-        ...game.queendomino,
-        buildersBoard: updatedBoard,
-        dragonUsedThisRound: true
-      },
-      nextAction: { type: "step", step: gameSteps.result }
-    });
-  }
-  return ok({
-    ...game,
-    players: updatedPlayers,
-    queendomino: {
-      ...game.queendomino,
-      buildersBoard: updatedBoard,
-      dragonUsedThisRound: true
-    },
-    nextAction: nextLordWithAction(game.lords)
-  });
-};
-
 // src/config.ts
 var configureEngine = (config) => {
   const modeRepository = jsonModes_default();
@@ -9249,6 +9423,13 @@ var configureEngine = (config) => {
       translator,
       canPlaceDominoUseCase
     ),
+    getValidDominoPicksHandler: getValidActionTargetsHandler(
+      logger,
+      translator,
+      "getValidDominoPicks",
+      getValidDominoPicksUseCase,
+      (numbers) => `dominoes [${numbers.join(", ")}]`
+    ),
     serializeGameHandler: serializeGameHandler(logger, translator),
     deserializeGameHandler: deserializeGameHandler(logger, translator),
     getDynastyResultHandler: getDynastyResultHandler(
@@ -9312,6 +9493,13 @@ var configureEngine = (config) => {
       getAffordableBuildingsUseCase,
       (buildings) => `${buildings.length} buildings`
     ),
+    getValidDragonTargetsHandler: getValidActionTargetsHandler(
+      logger,
+      translator,
+      "getValidDragonTargets",
+      getValidDragonTargetsUseCase,
+      (buildings) => `${buildings.length} buildings`
+    ),
     getValidCavemanPlacementsHandler: getValidActionTargetsHandler(
       logger,
       translator,
@@ -9654,6 +9842,15 @@ var validateDominoes = (game) => {
           )
         );
       }
+      if (revealed.reservedFor !== void 0 && (!isNonEmptyString(revealed.reservedFor) || Array.isArray(game.players) && !game.players.some((p) => p.id === revealed.reservedFor))) {
+        issues.push(
+          issue(
+            `${path}.reservedFor`,
+            "RESERVED_PLAYER_NOT_FOUND",
+            `Domino is reserved for a non-existent player: ${String(revealed.reservedFor)}`
+          )
+        );
+      }
     }
   }
   if (Array.isArray(game.lords)) {
@@ -9872,15 +10069,10 @@ var buildingContext = (game, lordId) => ({
   validPositions: getValidBuildingPositionsUseCase(game, lordId),
   affordableBuildings: getAffordableBuildingsUseCase(game, lordId)
 });
-var dragonContext = (game, lordId) => {
-  const slots = game.queendomino?.buildersBoard.slots ?? [];
-  return {
-    ...baseContext(game, lordId),
-    targetBuildings: slots.filter(
-      (slot) => slot !== null && isOk(useDragonUseCase(game, lordId, slot.id))
-    )
-  };
-};
+var dragonContext = (game, lordId) => ({
+  ...baseContext(game, lordId),
+  targetBuildings: getValidDragonTargetsUseCase(game, lordId)
+});
 var fireTokenContext = (game, lordId) => ({
   ...baseContext(game, lordId),
   validPositions: getValidFireTokenPositionsUseCase(game, lordId)
@@ -10495,7 +10687,10 @@ var playBotTurn = (engine, game, strategy) => {
   const action = game.nextAction.nextAction;
   const defaults = greedyStrategy;
   if (action === "pickDomino") {
-    const availableDominoes = game.currentDominoes.filter((d) => !d.picked);
+    const { lord } = getLordAndPlayer(game, lordId);
+    const availableDominoes = game.currentDominoes.filter(
+      (d) => lord ? canLordPickRevealed(lord, d) : !d.picked
+    );
     const dominoPick = strategy.chooseDomino({
       game,
       lordId,
@@ -10669,6 +10864,7 @@ var wrapWithActionLog = (engine) => {
     calculateScore: (cmd) => engine.calculateScore(cmd),
     getValidPlacements: (cmd) => engine.getValidPlacements(cmd),
     canPlaceDomino: (cmd) => engine.canPlaceDomino(cmd),
+    getValidDominoPicks: (cmd) => engine.getValidDominoPicks(cmd),
     serialize: (cmd) => engine.serialize(cmd),
     deserialize: (cmd) => engine.deserialize(cmd),
     getResults: (cmd) => engine.getResults(cmd),
@@ -10833,6 +11029,7 @@ var wrapWithActionLog = (engine) => {
     getValidKnightPositions: (cmd) => engine.getValidKnightPositions(cmd),
     getValidBuildingPositions: (cmd) => engine.getValidBuildingPositions(cmd),
     getAffordableBuildings: (cmd) => engine.getAffordableBuildings(cmd),
+    getValidDragonTargets: (cmd) => engine.getValidDragonTargets(cmd),
     getValidCavemanPlacements: (cmd) => engine.getValidCavemanPlacements(cmd),
     getValidGiantPositions: (cmd) => engine.getValidGiantPositions(cmd),
     getValidGiantTargets: (cmd) => engine.getValidGiantTargets(cmd),
@@ -11068,6 +11265,7 @@ var createGameEngine = (config) => {
     calculateScoreHandler: calculateScoreHandler2,
     getValidPlacementsHandler: getValidPlacementsHandler2,
     canPlaceDominoHandler: canPlaceDominoHandler2,
+    getValidDominoPicksHandler,
     serializeGameHandler: serializeGameHandler2,
     deserializeGameHandler: deserializeGameHandler2,
     getDynastyResultHandler: getDynastyResultHandler2,
@@ -11083,6 +11281,7 @@ var createGameEngine = (config) => {
     getValidKnightPositionsHandler,
     getValidBuildingPositionsHandler,
     getAffordableBuildingsHandler,
+    getValidDragonTargetsHandler,
     getValidCavemanPlacementsHandler,
     getValidGiantPositionsHandler,
     getValidGiantTargetsHandler,
@@ -11103,6 +11302,7 @@ var createGameEngine = (config) => {
     calculateScore: (command) => calculateScoreHandler2(command),
     getValidPlacements: (command) => getValidPlacementsHandler2(command),
     canPlaceDomino: (command) => canPlaceDominoHandler2(command),
+    getValidDominoPicks: (command) => getValidDominoPicksHandler(command),
     serialize: (command) => serializeGameHandler2(command),
     deserialize: (command) => deserializeGameHandler2(command),
     getDynastyResults: (command) => getDynastyResultHandler2(command),
@@ -11118,6 +11318,7 @@ var createGameEngine = (config) => {
     getValidKnightPositions: (command) => getValidKnightPositionsHandler(command),
     getValidBuildingPositions: (command) => getValidBuildingPositionsHandler(command),
     getAffordableBuildings: (command) => getAffordableBuildingsHandler(command),
+    getValidDragonTargets: (command) => getValidDragonTargetsHandler(command),
     getValidCavemanPlacements: (command) => getValidCavemanPlacementsHandler(command),
     getValidGiantPositions: (command) => getValidGiantPositionsHandler(command),
     getValidGiantTargets: (command) => getValidGiantTargetsHandler(command),