@pompidup/kingdomino-engine 3.3.0 → 3.4.0

package/dist/index.js

@@ -168,6 +168,25 @@ var wrapWithDebug = (engine, options) => {
       engine.getDynastyResults,
       logger,
       level
+    ),
+    placeKnight: wrapMethod(
+      "placeKnight",
+      engine.placeKnight,
+      logger,
+      level
+    ),
+    constructBuilding: wrapMethod(
+      "constructBuilding",
+      engine.constructBuilding,
+      logger,
+      level
+    ),
+    useDragon: wrapMethod("useDragon", engine.useDragon, logger, level),
+    skipOptionalAction: wrapMethod(
+      "skipOptionalAction",
+      engine.skipOptionalAction,
+      logger,
+      level
     )
   };
 };
@@ -232,7 +251,12 @@ var wrapWithEvents = (engine, callbacks) => ({
       callbacks.onGameEnd?.({ game });
     }
     return game;
-  }
+  },
+  // Queendomino methods — pass through (no specific events yet)
+  placeKnight: (cmd) => engine.placeKnight(cmd),
+  constructBuilding: (cmd) => engine.constructBuilding(cmd),
+  useDragon: (cmd) => engine.useDragon(cmd),
+  skipOptionalAction: (cmd) => engine.skipOptionalAction(cmd)
 });
 
 // src/adapterServerside/consoleLogger.ts
@@ -261,6 +285,61 @@ var silentLogger = {
   }
 };
 
+// src/datasources/buildings.json
+var buildings_default = [
+  { id: 1, name: "The Bakery", cost: 1, immediateBonus: { type: "coins", amount: 2 }, crowns: 0, towers: 0 },
+  { id: 2, name: "The Bakery", cost: 1, immediateBonus: { type: "coins", amount: 2 }, crowns: 0, towers: 0 },
+  { id: 3, name: "The Sawmill", cost: 2, crowns: 0, towers: 0, endGameScoring: { type: "perTerrain", terrain: "forest", points: 1 } },
+  { id: 4, name: "The Fishmonger's", cost: 2, immediateBonus: { type: "coins", amount: 1 }, crowns: 0, towers: 0, endGameScoring: { type: "perTerrain", terrain: "sea", points: 1 } },
+  { id: 5, name: "The Fishmonger's", cost: 2, immediateBonus: { type: "coins", amount: 1 }, crowns: 0, towers: 0, endGameScoring: { type: "perTerrain", terrain: "sea", points: 1 } },
+  { id: 6, name: "The Weaving Shop", cost: 3, crowns: 1, towers: 0, endGameScoring: { type: "perTerrain", terrain: "wheat", points: 1 } },
+  { id: 7, name: "The Magic School", cost: 4, crowns: 1, towers: 0, endGameScoring: { type: "perCrown", points: 1 } },
+  { id: 8, name: "The Fountain", cost: 3, crowns: 0, towers: 1, endGameScoring: { type: "perTower", points: 2 } },
+  { id: 9, name: "The Church", cost: 4, crowns: 1, towers: 0, endGameScoring: { type: "perBuilding", points: 2 } },
+  { id: 10, name: "The Bath", cost: 2, immediateBonus: { type: "coins", amount: 1 }, crowns: 0, towers: 0, endGameScoring: { type: "flat", points: 4 } },
+  { id: 11, name: "The Guard Tower", cost: 1, crowns: 0, towers: 1, endGameScoring: { type: "flat", points: 2 } },
+  { id: 12, name: "The Guard Tower", cost: 1, crowns: 0, towers: 1, endGameScoring: { type: "flat", points: 2 } },
+  { id: 13, name: "The Big Tower", cost: 3, crowns: 0, towers: 2, endGameScoring: { type: "flat", points: 4 } },
+  { id: 14, name: "The Guardhouse", cost: 2, crowns: 0, towers: 1, endGameScoring: { type: "perBuilding", points: 1 } },
+  { id: 15, name: "The Fortified Castle", cost: 5, crowns: 2, towers: 1, endGameScoring: { type: "flat", points: 6 } },
+  { id: 16, name: "The Travelling Castle", cost: 3, crowns: 1, towers: 1, endGameScoring: { type: "perTower", points: 1 } },
+  { id: 17, name: "The Travelling Group", cost: 2, immediateBonus: { type: "coins", amount: 1 }, crowns: 0, towers: 0, endGameScoring: { type: "perBuilding", points: 1 } },
+  { id: 18, name: "The Harbour", cost: 3, crowns: 0, towers: 0, endGameScoring: { type: "perTerrain", terrain: "sea", points: 2 } }
+];
+
+// src/adapterServerside/jsonBuildings.ts
+var jsonBuildings = () => {
+  const buildings = buildings_default.map((b) => {
+    const tile = {
+      id: b.id,
+      name: b.name,
+      cost: b.cost,
+      crowns: b.crowns,
+      towers: b.towers
+    };
+    if (b.immediateBonus) {
+      tile.immediateBonus = {
+        type: b.immediateBonus.type,
+        amount: b.immediateBonus.amount
+      };
+    }
+    if ("endGameScoring" in b && b.endGameScoring) {
+      tile.endGameScoring = {
+        type: b.endGameScoring.type,
+        points: b.endGameScoring.points,
+        ..."terrain" in b.endGameScoring && {
+          terrain: b.endGameScoring.terrain
+        }
+      };
+    }
+    return tile;
+  });
+  return {
+    getAll: () => buildings
+  };
+};
+var jsonBuildings_default = jsonBuildings;
+
 // src/datasources/dominoes.json
 var dominoes_default = {
   Classic: [
@@ -314,84 +393,614 @@ var dominoes_default = {
         crowns: 0
       },
       right: {
-        type: "forest",
+        type: "forest",
+        crowns: 0
+      },
+      number: 5
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 6
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 7
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 8
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 9
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 10
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 11
+    },
+    {
+      left: {
+        type: "swamp",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 12
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 13
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 14
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 15
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 16
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 17
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 18
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 19
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 20
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 21
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 22
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "mine",
+        crowns: 0
+      },
+      number: 23
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 24
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 25
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 26
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 27
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 28
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 29
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 30
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 31
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 32
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 33
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 34
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 35
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 1
+      },
+      number: 36
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 1
+      },
+      number: 37
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 1
+      },
+      number: 38
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 39
+    },
+    {
+      left: {
+        type: "mine",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 40
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 2
+      },
+      number: 41
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 2
+      },
+      number: 42
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 2
+      },
+      number: 43
+    },
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 2
+      },
+      number: 44
+    },
+    {
+      left: {
+        type: "mine",
+        crowns: 2
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 45
+    },
+    {
+      left: {
+        type: "swamp",
+        crowns: 0
+      },
+      right: {
+        type: "mine",
+        crowns: 2
+      },
+      number: 46
+    },
+    {
+      left: {
+        type: "swamp",
+        crowns: 0
+      },
+      right: {
+        type: "mine",
+        crowns: 2
+      },
+      number: 47
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "mine",
+        crowns: 3
+      },
+      number: 48
+    }
+  ],
+  QueenDomino: [
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 1
+    },
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 2
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 3
+    },
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 4
+    },
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
         crowns: 0
       },
       number: 5
     },
     {
       left: {
-        type: "forest",
+        type: "sea",
         crowns: 0
       },
       right: {
-        type: "forest",
+        type: "sea",
         crowns: 0
       },
       number: 6
     },
     {
       left: {
-        type: "sea",
+        type: "plain",
         crowns: 0
       },
       right: {
-        type: "sea",
+        type: "plain",
         crowns: 0
       },
       number: 7
     },
     {
       left: {
-        type: "sea",
+        type: "plain",
         crowns: 0
       },
       right: {
-        type: "sea",
+        type: "plain",
         crowns: 0
       },
       number: 8
     },
     {
       left: {
-        type: "sea",
+        type: "swamp",
         crowns: 0
       },
       right: {
-        type: "sea",
+        type: "swamp",
         crowns: 0
       },
       number: 9
     },
     {
       left: {
-        type: "plain",
+        type: "swamp",
         crowns: 0
       },
       right: {
-        type: "plain",
+        type: "swamp",
         crowns: 0
       },
       number: 10
     },
     {
       left: {
-        type: "plain",
+        type: "mine",
         crowns: 0
       },
       right: {
-        type: "plain",
+        type: "mine",
         crowns: 0
       },
       number: 11
     },
     {
       left: {
-        type: "swamp",
+        type: "wheat",
         crowns: 0
       },
       right: {
-        type: "swamp",
+        type: "forest",
         crowns: 0
       },
       number: 12
@@ -399,10 +1008,11 @@ var dominoes_default = {
     {
       left: {
         type: "wheat",
-        crowns: 0
+        crowns: 0,
+        hasConstructionSquare: true
       },
       right: {
-        type: "forest",
+        type: "sea",
         crowns: 0
       },
       number: 13
@@ -413,51 +1023,54 @@ var dominoes_default = {
         crowns: 0
       },
       right: {
-        type: "sea",
-        crowns: 0
+        type: "plain",
+        crowns: 0,
+        hasConstructionSquare: true
       },
       number: 14
     },
     {
       left: {
-        type: "wheat",
-        crowns: 0
+        type: "forest",
+        crowns: 0,
+        hasConstructionSquare: true
       },
       right: {
-        type: "plain",
+        type: "sea",
         crowns: 0
       },
       number: 15
     },
     {
       left: {
-        type: "wheat",
+        type: "forest",
         crowns: 0
       },
       right: {
-        type: "swamp",
+        type: "plain",
         crowns: 0
       },
       number: 16
     },
     {
       left: {
-        type: "forest",
+        type: "sea",
         crowns: 0
       },
       right: {
-        type: "sea",
-        crowns: 0
+        type: "plain",
+        crowns: 0,
+        hasConstructionSquare: true
       },
       number: 17
     },
     {
       left: {
-        type: "forest",
+        type: "wheat",
         crowns: 0
       },
       right: {
-        type: "plain",
+        type: "swamp",
         crowns: 0
       },
       number: 18
@@ -465,7 +1078,8 @@ var dominoes_default = {
     {
       left: {
         type: "wheat",
-        crowns: 1
+        crowns: 1,
+        hasConstructionSquare: true
       },
       right: {
         type: "forest",
@@ -491,28 +1105,30 @@ var dominoes_default = {
       },
       right: {
         type: "plain",
-        crowns: 0
+        crowns: 0,
+        hasConstructionSquare: true
       },
       number: 21
     },
     {
       left: {
-        type: "wheat",
+        type: "forest",
         crowns: 1
       },
       right: {
-        type: "swamp",
-        crowns: 0
+        type: "wheat",
+        crowns: 0,
+        hasConstructionSquare: true
       },
       number: 22
     },
     {
       left: {
-        type: "wheat",
+        type: "forest",
         crowns: 1
       },
       right: {
-        type: "mine",
+        type: "sea",
         crowns: 0
       },
       number: 23
@@ -520,17 +1136,18 @@ var dominoes_default = {
     {
       left: {
         type: "forest",
-        crowns: 1
+        crowns: 1,
+        hasConstructionSquare: true
       },
       right: {
-        type: "wheat",
+        type: "plain",
         crowns: 0
       },
       number: 24
     },
     {
       left: {
-        type: "forest",
+        type: "sea",
         crowns: 1
       },
       right: {
@@ -541,18 +1158,19 @@ var dominoes_default = {
     },
     {
       left: {
-        type: "forest",
+        type: "sea",
         crowns: 1
       },
       right: {
-        type: "wheat",
-        crowns: 0
+        type: "forest",
+        crowns: 0,
+        hasConstructionSquare: true
       },
       number: 26
     },
     {
       left: {
-        type: "forest",
+        type: "plain",
         crowns: 1
       },
       right: {
@@ -563,22 +1181,23 @@ var dominoes_default = {
     },
     {
       left: {
-        type: "forest",
-        crowns: 1
+        type: "plain",
+        crowns: 1,
+        hasConstructionSquare: true
       },
       right: {
-        type: "sea",
+        type: "forest",
         crowns: 0
       },
       number: 28
     },
     {
       left: {
-        type: "forest",
+        type: "wheat",
         crowns: 1
       },
       right: {
-        type: "plain",
+        type: "mine",
         crowns: 0
       },
       number: 29
@@ -589,30 +1208,33 @@ var dominoes_default = {
         crowns: 1
       },
       right: {
-        type: "wheat",
-        crowns: 0
+        type: "plain",
+        crowns: 0,
+        hasConstructionSquare: true
       },
       number: 30
     },
     {
       left: {
-        type: "sea",
-        crowns: 1
+        type: "wheat",
+        crowns: 1,
+        hasConstructionSquare: true
       },
       right: {
-        type: "wheat",
-        crowns: 0
+        type: "swamp",
+        crowns: 1
       },
       number: 31
     },
     {
       left: {
-        type: "sea",
+        type: "forest",
         crowns: 1
       },
       right: {
-        type: "forest",
-        crowns: 0
+        type: "sea",
+        crowns: 1,
+        hasConstructionSquare: true
       },
       number: 32
     },
@@ -622,73 +1244,77 @@ var dominoes_default = {
         crowns: 1
       },
       right: {
-        type: "forest",
-        crowns: 0
+        type: "plain",
+        crowns: 1
       },
       number: 33
     },
     {
       left: {
-        type: "sea",
-        crowns: 1
+        type: "plain",
+        crowns: 1,
+        hasConstructionSquare: true
       },
       right: {
-        type: "forest",
-        crowns: 0
+        type: "swamp",
+        crowns: 1
       },
       number: 34
     },
     {
       left: {
-        type: "sea",
-        crowns: 1
+        type: "forest",
+        crowns: 1,
+        hasConstructionSquare: true
       },
       right: {
-        type: "forest",
-        crowns: 0
+        type: "mine",
+        crowns: 1
       },
       number: 35
     },
     {
       left: {
         type: "wheat",
-        crowns: 0
+        crowns: 2,
+        hasConstructionSquare: true
       },
       right: {
-        type: "plain",
-        crowns: 1
+        type: "forest",
+        crowns: 0
       },
       number: 36
     },
     {
       left: {
         type: "sea",
-        crowns: 0
+        crowns: 2
       },
       right: {
-        type: "plain",
-        crowns: 1
+        type: "wheat",
+        crowns: 0,
+        hasConstructionSquare: true
       },
       number: 37
     },
     {
       left: {
-        type: "wheat",
-        crowns: 0
+        type: "plain",
+        crowns: 2
       },
       right: {
-        type: "swamp",
-        crowns: 1
+        type: "forest",
+        crowns: 0
       },
       number: 38
     },
     {
       left: {
-        type: "plain",
-        crowns: 0
+        type: "swamp",
+        crowns: 2
       },
       right: {
-        type: "swamp",
+        type: "wheat",
         crowns: 0
       },
       number: 39
@@ -696,7 +1322,8 @@ var dominoes_default = {
     {
       left: {
         type: "mine",
-        crowns: 1
+        crowns: 2,
+        hasConstructionSquare: true
       },
       right: {
         type: "wheat",
@@ -707,7 +1334,7 @@ var dominoes_default = {
     {
       left: {
         type: "wheat",
-        crowns: 0
+        crowns: 2
       },
       right: {
         type: "plain",
@@ -718,73 +1345,75 @@ var dominoes_default = {
     {
       left: {
         type: "sea",
-        crowns: 0
+        crowns: 2
       },
       right: {
-        type: "plain",
-        crowns: 2
+        type: "forest",
+        crowns: 1,
+        hasConstructionSquare: true
       },
       number: 42
     },
     {
       left: {
-        type: "wheat",
-        crowns: 0
-      },
-      right: {
         type: "swamp",
         crowns: 2
       },
+      right: {
+        type: "plain",
+        crowns: 1
+      },
       number: 43
     },
     {
       left: {
-        type: "plain",
-        crowns: 0
+        type: "mine",
+        crowns: 2
       },
       right: {
         type: "swamp",
-        crowns: 2
+        crowns: 1
       },
       number: 44
     },
     {
       left: {
-        type: "mine",
+        type: "wheat",
         crowns: 2
       },
       right: {
-        type: "wheat",
-        crowns: 0
+        type: "mine",
+        crowns: 2
       },
       number: 45
     },
     {
       left: {
-        type: "swamp",
-        crowns: 0
+        type: "forest",
+        crowns: 2
       },
       right: {
         type: "mine",
-        crowns: 2
+        crowns: 2,
+        hasConstructionSquare: true
       },
       number: 46
     },
     {
       left: {
         type: "swamp",
-        crowns: 0
+        crowns: 2
       },
       right: {
         type: "mine",
-        crowns: 2
+        crowns: 3
       },
       number: 47
     },
     {
       left: {
-        type: "wheat",
-        crowns: 0
+        type: "plain",
+        crowns: 2
       },
       right: {
         type: "mine",
@@ -796,20 +1425,24 @@ var dominoes_default = {
 };
 
 // src/adapterServerside/jsonDominoes.ts
+var mapTile = (raw) => {
+  const tile = {
+    type: raw.type,
+    crowns: raw.crowns
+  };
+  if (raw.hasConstructionSquare) {
+    tile.hasConstructionSquare = true;
+  }
+  return tile;
+};
 var jsonDominoes = () => {
   const dominoes = {};
   for (const [key, value] of Object.entries(dominoes_default)) {
     const currentDominoes = [];
     value.forEach((domino) => {
       currentDominoes.push({
-        left: {
-          type: domino.left.type,
-          crowns: domino.left.crowns
-        },
-        right: {
-          type: domino.right.type,
-          crowns: domino.right.crowns
-        },
+        left: mapTile(domino.left),
+        right: mapTile(domino.right),
         number: domino.number
       });
     });
@@ -828,6 +1461,10 @@ var modes_default = [
   {
     name: "Classic",
     description: "Original KingDomino rules"
+  },
+  {
+    name: "QueenDomino",
+    description: "Queendomino expansion with buildings, knights, coins, the Queen and the Dragon"
   }
 ];
 
@@ -888,23 +1525,35 @@ var rules_default = {
     {
       name: "The middle Kingdom",
       description: "Gain 10 additional points if your castle is in the middle of the kingdom.",
-      mode: [{ name: "Classic", description: "King Domino classic mode" }]
+      mode: [
+        { name: "Classic", description: "King Domino classic mode" },
+        { name: "QueenDomino", description: "Queendomino expansion with buildings, knights, coins, the Queen and the Dragon" }
+      ]
     },
     {
       name: "Harmony",
       description: "Gain 5 additional points if your kingdom is complete (no discarded dominoes).",
-      mode: [{ name: "Classic", description: "King Domino classic mode" }]
+      mode: [
+        { name: "Classic", description: "King Domino classic mode" },
+        { name: "QueenDomino", description: "Queendomino expansion with buildings, knights, coins, the Queen and the Dragon" }
+      ]
     },
     {
       name: "The Mighty Duel",
       description: "Use all 48 dominoes and build a 7x7 kingdom. For 2 players only.",
-      mode: [{ name: "Classic", description: "King Domino classic mode" }],
+      mode: [
+        { name: "Classic", description: "King Domino classic mode" },
+        { name: "QueenDomino", description: "Queendomino expansion with buildings, knights, coins, the Queen and the Dragon" }
+      ],
       playersLimit: 2
     },
     {
       name: "Dynasty",
       description: "Play 3 games in a row. The player with the highest total points wins.",
-      mode: [{ name: "Classic", description: "King Domino classic mode" }]
+      mode: [
+        { name: "Classic", description: "King Domino classic mode" },
+        { name: "QueenDomino", description: "Queendomino expansion with buildings, knights, coins, the Queen and the Dragon" }
+      ]
     }
   ]
 };
@@ -986,7 +1635,17 @@ var ErrorCode = {
   DOMINO_ALREADY_PICKED: "DOMINO_ALREADY_PICKED",
   // History errors
   UNDO_UNAVAILABLE: "UNDO_UNAVAILABLE",
-  REDO_UNAVAILABLE: "REDO_UNAVAILABLE"
+  REDO_UNAVAILABLE: "REDO_UNAVAILABLE",
+  // Queendomino errors
+  CANNOT_PLACE_KNIGHT: "CANNOT_PLACE_KNIGHT",
+  MAX_KNIGHTS_REACHED: "MAX_KNIGHTS_REACHED",
+  KNIGHT_TERRITORY_OCCUPIED: "KNIGHT_TERRITORY_OCCUPIED",
+  CANNOT_AFFORD_BUILDING: "CANNOT_AFFORD_BUILDING",
+  NO_CONSTRUCTION_SQUARE: "NO_CONSTRUCTION_SQUARE",
+  DRAGON_UNAVAILABLE: "DRAGON_UNAVAILABLE",
+  QUEEN_HOLDER_CANNOT_USE_DRAGON: "QUEEN_HOLDER_CANNOT_USE_DRAGON",
+  BUILDING_NOT_FOUND: "BUILDING_NOT_FOUND",
+  INVALID_OPTIONAL_ACTION: "INVALID_OPTIONAL_ACTION"
 };
 var createDomainError = (code, message, context) => ({
   code,
@@ -1119,7 +1778,17 @@ var TranslationKey = {
   // Actions
   ACTION_PICK_DOMINO: "action.pickDomino",
   ACTION_PLACE_DOMINO: "action.placeDomino",
-  ACTION_PASS: "action.pass"
+  ACTION_PASS: "action.pass",
+  // Queendomino errors
+  ERROR_CANNOT_PLACE_KNIGHT: "error.cannotPlaceKnight",
+  ERROR_MAX_KNIGHTS_REACHED: "error.maxKnightsReached",
+  ERROR_KNIGHT_TERRITORY_OCCUPIED: "error.knightTerritoryOccupied",
+  ERROR_CANNOT_AFFORD_BUILDING: "error.cannotAffordBuilding",
+  ERROR_NO_CONSTRUCTION_SQUARE: "error.noConstructionSquare",
+  ERROR_DRAGON_UNAVAILABLE: "error.dragonUnavailable",
+  ERROR_QUEEN_HOLDER_CANNOT_USE_DRAGON: "error.queenHolderCannotUseDragon",
+  ERROR_BUILDING_NOT_FOUND: "error.buildingNotFound",
+  ERROR_INVALID_OPTIONAL_ACTION: "error.invalidOptionalAction"
 };
 var defaultTranslations = {
   // Error messages
@@ -1165,7 +1834,17 @@ var defaultTranslations = {
   // Actions
   [TranslationKey.ACTION_PICK_DOMINO]: "Pick Domino",
   [TranslationKey.ACTION_PLACE_DOMINO]: "Place Domino",
-  [TranslationKey.ACTION_PASS]: "Pass"
+  [TranslationKey.ACTION_PASS]: "Pass",
+  // Queendomino errors
+  [TranslationKey.ERROR_CANNOT_PLACE_KNIGHT]: "Cannot place knight here",
+  [TranslationKey.ERROR_MAX_KNIGHTS_REACHED]: "Maximum number of knights reached (3)",
+  [TranslationKey.ERROR_KNIGHT_TERRITORY_OCCUPIED]: "This territory already has a knight",
+  [TranslationKey.ERROR_CANNOT_AFFORD_BUILDING]: "Not enough coins to purchase this building",
+  [TranslationKey.ERROR_NO_CONSTRUCTION_SQUARE]: "No open construction square available",
+  [TranslationKey.ERROR_DRAGON_UNAVAILABLE]: "The Dragon is not available this round",
+  [TranslationKey.ERROR_QUEEN_HOLDER_CANNOT_USE_DRAGON]: "The Queen holder cannot use the Dragon",
+  [TranslationKey.ERROR_BUILDING_NOT_FOUND]: "Building not found on the Builders Board",
+  [TranslationKey.ERROR_INVALID_OPTIONAL_ACTION]: "Invalid optional action for this game state"
 };
 var errorCodeToTranslationKey = {
   [ErrorCode.INVALID_STEP]: TranslationKey.ERROR_INVALID_STEP,
@@ -1188,7 +1867,16 @@ var errorCodeToTranslationKey = {
   [ErrorCode.CANNOT_PLACE]: TranslationKey.ERROR_CANNOT_PLACE,
   [ErrorCode.DOMINO_ALREADY_PICKED]: TranslationKey.ERROR_DOMINO_ALREADY_PICKED,
   [ErrorCode.UNDO_UNAVAILABLE]: TranslationKey.ERROR_UNDO_UNAVAILABLE,
-  [ErrorCode.REDO_UNAVAILABLE]: TranslationKey.ERROR_REDO_UNAVAILABLE
+  [ErrorCode.REDO_UNAVAILABLE]: TranslationKey.ERROR_REDO_UNAVAILABLE,
+  [ErrorCode.CANNOT_PLACE_KNIGHT]: TranslationKey.ERROR_CANNOT_PLACE_KNIGHT,
+  [ErrorCode.MAX_KNIGHTS_REACHED]: TranslationKey.ERROR_MAX_KNIGHTS_REACHED,
+  [ErrorCode.KNIGHT_TERRITORY_OCCUPIED]: TranslationKey.ERROR_KNIGHT_TERRITORY_OCCUPIED,
+  [ErrorCode.CANNOT_AFFORD_BUILDING]: TranslationKey.ERROR_CANNOT_AFFORD_BUILDING,
+  [ErrorCode.NO_CONSTRUCTION_SQUARE]: TranslationKey.ERROR_NO_CONSTRUCTION_SQUARE,
+  [ErrorCode.DRAGON_UNAVAILABLE]: TranslationKey.ERROR_DRAGON_UNAVAILABLE,
+  [ErrorCode.QUEEN_HOLDER_CANNOT_USE_DRAGON]: TranslationKey.ERROR_QUEEN_HOLDER_CANNOT_USE_DRAGON,
+  [ErrorCode.BUILDING_NOT_FOUND]: TranslationKey.ERROR_BUILDING_NOT_FOUND,
+  [ErrorCode.INVALID_OPTIONAL_ACTION]: TranslationKey.ERROR_INVALID_OPTIONAL_ACTION
 };
 var translateErrorCode = (translator, code, params) => {
   const key = errorCodeToTranslationKey[code];
@@ -1678,47 +2366,191 @@ var deserializeGameHandler = (logger, translator) => {
   };
 };
 
-// src/application/handlers/startGameHandler.ts
-var startGameHandler = (logger, translator, useCase) => (command) => {
-  const { game } = command;
-  logger.info(`Starting game: ${game.id}`);
-  if (!isGameWithNextStep(game)) {
+// src/application/handlers/startGameHandler.ts
+var startGameHandler = (logger, translator, useCase) => (command) => {
+  const { game } = command;
+  logger.info(`Starting game: ${game.id}`);
+  if (!isGameWithNextStep(game)) {
+    logger.error(
+      `Invalid game, required nextAction type: 'step' but got: ${game.nextAction.type}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      { expected: "step", actual: game.nextAction.type, gameId: game.id }
+    );
+  }
+  if (game.nextAction.step !== "start" && game.nextAction.step !== "options") {
+    logger.error(
+      `Required game with start step or options step but got: ${game.nextAction.step}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      {
+        expected: "start|options",
+        actual: game.nextAction.step,
+        gameId: game.id
+      }
+    );
+  }
+  const result = useCase(game);
+  if (isErr(result)) {
+    logger.error(`Error starting game: ${result.error}`);
+    const code = result.error;
+    throw new StepExecutionError(translateErrorCode(translator, code), code, {
+      gameId: game.id
+    });
+  }
+  logger.info(`Game started: ${game.id}`);
+  return result.value;
+};
+
+// src/application/handlers/placeKnightHandler.ts
+var placeKnightHandler = (logger, translator, useCase) => (command) => {
+  const { game, lordId, position } = command;
+  logger.info(
+    `Placing knight for lord: ${lordId} at position: ${JSON.stringify(
+      position
+    )} in game: ${game.id}`
+  );
+  if (game.nextAction.nextAction !== "placeKnight") {
+    logger.error(
+      `Required game with placeKnight action but got: ${game.nextAction.nextAction}`
+    );
+    throw new InvalidStepError(
+      translateErrorCode(translator, ErrorCode.INVALID_STEP),
+      {
+        expected: "placeKnight",
+        actual: game.nextAction.nextAction,
+        gameId: game.id
+      }
+    );
+  }
+  const result = useCase(game, lordId, position);
+  if (isErr(result)) {
+    logger.error(`Error placing knight: ${result.error}`);
+    const code = result.error;
+    throw new ActionExecutionError(
+      translateErrorCode(translator, code),
+      code,
+      {
+        gameId: game.id,
+        lordId: command.lordId,
+        position: command.position
+      }
+    );
+  }
+  logger.info(
+    `Knight placed for lord: ${lordId} at position: ${JSON.stringify(
+      position
+    )} in game: ${game.id}`
+  );
+  return result.value;
+};
+
+// src/application/handlers/constructBuildingHandler.ts
+var constructBuildingHandler = (logger, translator, useCase) => (command) => {
+  const { game, lordId, buildingId, position } = command;
+  logger.info(
+    `Constructing building: ${buildingId} for lord: ${lordId} at position: ${JSON.stringify(
+      position
+    )} in game: ${game.id}`
+  );
+  if (game.nextAction.nextAction !== "constructBuilding") {
     logger.error(
-      `Invalid game, required nextAction type: 'step' but got: ${game.nextAction.type}`
+      `Required game with constructBuilding action but got: ${game.nextAction.nextAction}`
     );
     throw new InvalidStepError(
       translateErrorCode(translator, ErrorCode.INVALID_STEP),
-      { expected: "step", actual: game.nextAction.type, gameId: game.id }
+      {
+        expected: "constructBuilding",
+        actual: game.nextAction.nextAction,
+        gameId: game.id
+      }
     );
   }
-  if (game.nextAction.step !== "start" && game.nextAction.step !== "options") {
+  const result = useCase(game, lordId, buildingId, position);
+  if (isErr(result)) {
+    logger.error(`Error constructing building: ${result.error}`);
+    const code = result.error;
+    throw new ActionExecutionError(
+      translateErrorCode(translator, code),
+      code,
+      {
+        gameId: game.id,
+        lordId: command.lordId,
+        buildingId: command.buildingId,
+        position: command.position
+      }
+    );
+  }
+  logger.info(
+    `Building constructed: ${buildingId} for lord: ${lordId} at position: ${JSON.stringify(
+      position
+    )} in game: ${game.id}`
+  );
+  return result.value;
+};
+
+// src/application/handlers/useDragonHandler.ts
+var useDragonHandler = (logger, translator, useCase) => (command) => {
+  const { game, lordId, buildingId } = command;
+  logger.info(
+    `Using dragon on building: ${buildingId} for lord: ${lordId} in game: ${game.id}`
+  );
+  if (game.nextAction.nextAction !== "useDragon") {
     logger.error(
-      `Required game with start step or options step but got: ${game.nextAction.step}`
+      `Required game with useDragon action but got: ${game.nextAction.nextAction}`
     );
     throw new InvalidStepError(
       translateErrorCode(translator, ErrorCode.INVALID_STEP),
       {
-        expected: "start|options",
-        actual: game.nextAction.step,
+        expected: "useDragon",
+        actual: game.nextAction.nextAction,
         gameId: game.id
       }
     );
   }
-  const result = useCase(game);
+  const result = useCase(game, lordId, buildingId);
   if (isErr(result)) {
-    logger.error(`Error starting game: ${result.error}`);
+    logger.error(`Error using dragon: ${result.error}`);
     const code = result.error;
-    throw new StepExecutionError(translateErrorCode(translator, code), code, {
-      gameId: game.id
-    });
+    throw new ActionExecutionError(
+      translateErrorCode(translator, code),
+      code,
+      {
+        gameId: game.id,
+        lordId: command.lordId,
+        buildingId: command.buildingId
+      }
+    );
   }
-  logger.info(`Game started: ${game.id}`);
+  logger.info(
+    `Dragon used on building: ${buildingId} for lord: ${lordId} in game: ${game.id}`
+  );
   return result.value;
 };
 
-// src/core/domain/types/kingdom.ts
-var GRIDSIZE = 9;
-var MAX_KINGDOM_SIZE = 5;
+// src/application/handlers/skipOptionalActionHandler.ts
+var skipOptionalActionHandler = (logger, translator, useCase) => (command) => {
+  const { game, lordId } = command;
+  logger.info(
+    `Skipping optional action for lord: ${lordId} in game: ${game.id}`
+  );
+  const result = useCase(game, lordId);
+  if (isErr(result)) {
+    logger.error(`Error skipping optional action: ${result.error}`);
+    const code = result.error;
+    throw new ActionExecutionError(
+      translateErrorCode(translator, code),
+      code,
+      { gameId: game.id, lordId: command.lordId }
+    );
+  }
+  logger.info(
+    `Optional action skipped for lord: ${lordId} in game: ${game.id}`
+  );
+  return result.value;
+};
 
 // src/core/domain/types/domino.ts
 var GROUND = [
@@ -1731,6 +2563,10 @@ var GROUND = [
   "mine"
 ];
 
+// src/core/domain/types/kingdom.ts
+var GRIDSIZE = 9;
+var MAX_KINGDOM_SIZE = 5;
+
 // src/core/domain/types/player.ts
 var playerActions = {
   /** Place a previously picked domino on the kingdom */
@@ -1738,7 +2574,15 @@ var playerActions = {
   /** Pick a domino from the revealed set */
   pickDomino: "pickDomino",
   /** Pass/discard when no valid placement exists */
-  pass: "pass"
+  pass: "pass",
+  /** Place a knight on the just-placed domino (Queendomino, optional) */
+  placeKnight: "placeKnight",
+  /** Construct a building on a construction square (Queendomino, optional) */
+  constructBuilding: "constructBuilding",
+  /** Use the Dragon to burn a building tile (Queendomino, optional) */
+  useDragon: "useDragon",
+  /** Skip the current optional action (Queendomino) */
+  skipOptionalAction: "skipOptionalAction"
 };
 
 // src/core/domain/entities/rule.ts
@@ -1836,6 +2680,24 @@ var addExtraRulesUseCase = (deps) => (game, rules) => {
   return ok(updatedGame);
 };
 
+// src/core/domain/entities/economy.ts
+var STARTING_COINS = 7;
+var MAX_KNIGHTS = 3;
+var addCoins = (player, amount) => ({
+  ...player,
+  coins: (player.coins ?? 0) + amount
+});
+var removeCoins = (player, amount) => ({
+  ...player,
+  coins: (player.coins ?? 0) - amount
+});
+var canAfford = (player, cost) => (player.coins ?? 0) >= cost;
+var addTowers = (player, amount) => ({
+  ...player,
+  towers: (player.towers ?? 0) + amount
+});
+var getTowerCount = (player) => player.towers ?? 0;
+
 // src/core/domain/entities/domino.ts
 var isGround = (ground) => {
   return GROUND.includes(ground);
@@ -2131,6 +2993,12 @@ var addPlayersUseCase = (deps) => (game, players) => {
     if (isErr(newPlayer)) {
       return newPlayer;
     }
+    if (game.mode.name === "QueenDomino") {
+      newPlayer.value.coins = STARTING_COINS;
+      newPlayer.value.towers = 0;
+      newPlayer.value.knights = [];
+      newPlayer.value.buildings = [];
+    }
     newPlayers.push(newPlayer.value);
   }
   const rules = ruleRepository.getAll();
@@ -2277,6 +3145,19 @@ var findNextLord = (lords) => {
 var allLordsHavePlayed = (lords) => {
   return lords.every((lord) => lord.turnEnded);
 };
+var QUEENDOMINO_ACTION_SEQUENCE = [
+  playerActions.placeKnight,
+  playerActions.constructBuilding,
+  playerActions.useDragon,
+  playerActions.pickDomino
+];
+var nextQueenDominoAction = (currentAction) => {
+  const index = QUEENDOMINO_ACTION_SEQUENCE.indexOf(currentAction);
+  if (index === -1 || index >= QUEENDOMINO_ACTION_SEQUENCE.length - 1) {
+    return playerActions.pickDomino;
+  }
+  return QUEENDOMINO_ACTION_SEQUENCE[index + 1];
+};
 
 // src/core/useCases/chooseDomino.ts
 var chooseDominoUseCase = (game, lordId, dominoPick) => {
@@ -2347,7 +3228,19 @@ var chooseDominoUseCase = (game, lordId, dominoPick) => {
 
 // src/core/domain/entities/game.ts
 var create = (payload) => {
-  const { id, mode, dominoes, seed } = payload;
+  const { id, mode, dominoes, seed, buildings } = payload;
+  let queendomino;
+  if (mode.name === "QueenDomino" && buildings) {
+    queendomino = {
+      buildersBoard: {
+        slots: [],
+        drawPile: buildings
+      },
+      queenHolderId: null,
+      dragonAvailable: true,
+      dragonUsedThisRound: false
+    };
+  }
   return {
     id,
     dominoes,
@@ -2370,7 +3263,8 @@ var create = (payload) => {
       extra: []
     },
     mode,
-    ...seed !== void 0 && { seed }
+    ...seed !== void 0 && { seed },
+    ...queendomino !== void 0 && { queendomino }
   };
 };
 
@@ -2388,7 +3282,7 @@ var createMode = (mode, availableMode) => {
 
 // src/core/useCases/createGame.ts
 var createGameUseCase = (deps) => (mode, seed) => {
-  const { modeRepository, dominoesRepository, uuidMethod: uuidMethod2 } = deps;
+  const { modeRepository, dominoesRepository, uuidMethod: uuidMethod2, buildingsRepository } = deps;
   const id = uuidMethod2();
   const gameSeed = seed ?? uuidMethod2();
   const availableMode = modeRepository.getAvailables();
@@ -2400,11 +3294,17 @@ var createGameUseCase = (deps) => (mode, seed) => {
   if (!dominoes || dominoes.length === 0) {
     return err(ErrorCode.DOMINO_NOT_FOUND);
   }
+  const isQueenDomino = newMode.value.name === "QueenDomino";
+  let buildings;
+  if (isQueenDomino && buildingsRepository) {
+    buildings = buildingsRepository.getAll();
+  }
   const payload = {
     id,
     mode: newMode.value,
     dominoes,
-    seed: gameSeed
+    seed: gameSeed,
+    buildings
   };
   const newGame = create(payload);
   return ok(newGame);
@@ -2697,6 +3597,7 @@ var placeDominoUseCase = (game, lordId, position, rotation) => {
     type: "step",
     step: gameSteps.result
   };
+  const isQueenDomino = game.mode.name === "QueenDomino";
   if (isLastTurn && allLordsHavePlayed(updatedLords)) {
     updatedGame = {
       ...game,
@@ -2704,6 +3605,29 @@ var placeDominoUseCase = (game, lordId, position, rotation) => {
       nextAction: resultStep,
       players: updatedPlayers
     };
+  } else if (isQueenDomino && !isLastTurn) {
+    updatedGame = {
+      ...game,
+      lords: updatedLords,
+      nextAction: {
+        type: "action",
+        nextLord: currentLord.id,
+        nextAction: playerActions.placeKnight
+      },
+      players: updatedPlayers
+    };
+  } else if (isQueenDomino && isLastTurn) {
+    const queenDominoAction = {
+      type: "action",
+      nextLord: currentLord.id,
+      nextAction: playerActions.placeKnight
+    };
+    updatedGame = {
+      ...game,
+      lords: updatedLords,
+      nextAction: queenDominoAction,
+      players: updatedPlayers
+    };
   } else {
     updatedGame = {
       ...game,
@@ -2715,6 +3639,401 @@ var placeDominoUseCase = (game, lordId, position, rotation) => {
   return ok(updatedGame);
 };
 
+// src/core/domain/entities/knight.ts
+var countConstructionSquaresInTerritory = (kingdom, position) => {
+  const rows = kingdom.length;
+  const cols = kingdom[0]?.length ?? 0;
+  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 visited = kingdom.map((row) => row.map(() => false));
+  const queue = [[position.x, position.y]];
+  visited[position.y][position.x] = true;
+  const territoryPositions = /* @__PURE__ */ new Set();
+  const directions = [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1]
+  ];
+  while (queue.length > 0) {
+    const [cx, cy] = queue.pop();
+    territoryPositions.add(`${cx},${cy}`);
+    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 === terrain) {
+        visited[ny][nx] = true;
+        queue.push([nx, ny]);
+      }
+    }
+  }
+  return knights.some(
+    (k) => territoryPositions.has(`${k.position.x},${k.position.y}`)
+  );
+};
+var canPlaceKnight = (player, kingdom, position) => {
+  const knights = player.knights ?? [];
+  if (knights.length >= MAX_KNIGHTS) return false;
+  const tile = kingdom[position.y]?.[position.x];
+  if (!tile || tile.type === "empty" || tile.type === "castle") return false;
+  if (territoryHasKnight(kingdom, position, knights)) 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 updatedPlayer = addCoins({ ...player, knights }, taxAmount);
+  return updatedPlayer;
+};
+
+// src/core/useCases/placeKnight.ts
+var placeKnightUseCase = (game, lordId, position) => {
+  const currentAction = game.nextAction;
+  if (currentAction.nextLord !== lordId) {
+    return err(ErrorCode.NOT_YOUR_TURN);
+  }
+  if (currentAction.nextAction !== playerActions.placeKnight) {
+    return err(ErrorCode.INVALID_OPTIONAL_ACTION);
+  }
+  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 (!canPlaceKnight(currentPlayer, currentPlayer.kingdom, position)) {
+    return err(ErrorCode.CANNOT_PLACE_KNIGHT);
+  }
+  const updatedPlayer = placeKnight(
+    currentPlayer,
+    currentPlayer.kingdom,
+    position
+  );
+  const updatedPlayers = game.players.map(
+    (p) => p.id === currentPlayer.id ? updatedPlayer : p
+  );
+  const nextAction = nextQueenDominoAction(playerActions.placeKnight);
+  return ok({
+    ...game,
+    players: updatedPlayers,
+    nextAction: {
+      type: "action",
+      nextLord: lordId,
+      nextAction
+    }
+  });
+};
+
+// src/core/domain/entities/building.ts
+var BOARD_SLOTS = 4;
+var createBuildersBoard = (tiles, shuffle) => {
+  const shuffled = shuffle([...tiles]);
+  const slots = shuffled.slice(0, BOARD_SLOTS);
+  const drawPile = shuffled.slice(BOARD_SLOTS);
+  return {
+    slots,
+    drawPile
+  };
+};
+var findBuildingOnBoard = (board, buildingId) => {
+  for (let i = 0; i < board.slots.length; i++) {
+    const slot = board.slots[i];
+    if (slot && slot.id === buildingId) {
+      return { building: slot, slotIndex: i };
+    }
+  }
+  return null;
+};
+var removeBuildingFromBoard = (board, slotIndex) => {
+  const newSlots = [...board.slots];
+  newSlots[slotIndex] = null;
+  return { ...board, slots: newSlots };
+};
+var purchaseBuilding = (board, player, buildingId) => {
+  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);
+  if (building.immediateBonus) {
+    switch (building.immediateBonus.type) {
+      case "coins":
+        updatedPlayer = addCoins(updatedPlayer, building.immediateBonus.amount);
+        break;
+      case "tower":
+        updatedPlayer = addTowers(
+          updatedPlayer,
+          building.immediateBonus.amount
+        );
+        break;
+    }
+  }
+  if (building.towers > 0) {
+    updatedPlayer = addTowers(updatedPlayer, building.towers);
+  }
+  const updatedBoard = removeBuildingFromBoard(board, slotIndex);
+  return { updatedBoard, updatedPlayer, building };
+};
+var isValidConstructionPosition = (kingdom, placedBuildings, position) => {
+  const tile = kingdom[position.y]?.[position.x];
+  if (!tile || tile.type === "empty" || tile.type === "castle") return false;
+  if (!("hasConstructionSquare" in tile) || !tile.hasConstructionSquare)
+    return false;
+  const occupied = placedBuildings.some(
+    (b) => b.position.x === position.x && b.position.y === position.y
+  );
+  return !occupied;
+};
+var placeBuildingOnKingdom = (kingdom, building, position) => {
+  const newKingdom = kingdom.map((row) => [...row]);
+  const tile = newKingdom[position.y][position.x];
+  if (tile.type !== "empty" && tile.type !== "castle") {
+    newKingdom[position.y][position.x] = {
+      ...tile,
+      crowns: tile.crowns + building.crowns
+    };
+  }
+  return newKingdom;
+};
+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 updatedBoard = removeBuildingFromBoard(board, slotIndex);
+  return { updatedBoard, updatedPlayer };
+};
+
+// src/core/domain/entities/queen.ts
+var determineQueenHolder = (players, currentHolderId) => {
+  let maxTowers = 0;
+  let leaderId = null;
+  let isTied = false;
+  for (const player of players) {
+    const towers = getTowerCount(player);
+    if (towers > maxTowers) {
+      maxTowers = towers;
+      leaderId = player.id;
+      isTied = false;
+    } else if (towers === maxTowers && towers > 0 && leaderId !== null) {
+      isTied = true;
+    }
+  }
+  if (isTied || maxTowers === 0) {
+    return currentHolderId;
+  }
+  return leaderId;
+};
+
+// src/core/useCases/constructBuilding.ts
+var constructBuildingUseCase = (game, lordId, buildingId, position) => {
+  const currentAction = game.nextAction;
+  if (currentAction.nextLord !== lordId) {
+    return err(ErrorCode.NOT_YOUR_TURN);
+  }
+  if (currentAction.nextAction !== playerActions.constructBuilding) {
+    return err(ErrorCode.INVALID_OPTIONAL_ACTION);
+  }
+  if (!game.queendomino) {
+    return err(ErrorCode.INVALID_OPTIONAL_ACTION);
+  }
+  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 (!isValidConstructionPosition(
+    currentPlayer.kingdom,
+    currentPlayer.buildings ?? [],
+    position
+  )) {
+    return err(ErrorCode.NO_CONSTRUCTION_SQUARE);
+  }
+  const purchaseResult = purchaseBuilding(
+    game.queendomino.buildersBoard,
+    currentPlayer,
+    buildingId
+  );
+  if (!purchaseResult) {
+    return err(ErrorCode.CANNOT_AFFORD_BUILDING);
+  }
+  const { updatedBoard, updatedPlayer, building } = purchaseResult;
+  const updatedKingdom = placeBuildingOnKingdom(
+    updatedPlayer.kingdom,
+    building,
+    position
+  );
+  const placedBuilding = { building, position };
+  const finalPlayer = {
+    ...updatedPlayer,
+    kingdom: updatedKingdom,
+    buildings: [...updatedPlayer.buildings ?? [], placedBuilding]
+  };
+  const updatedPlayers = game.players.map(
+    (p) => p.id === currentPlayer.id ? finalPlayer : p
+  );
+  const newQueenHolder = determineQueenHolder(
+    updatedPlayers,
+    game.queendomino.queenHolderId
+  );
+  const nextAction = nextQueenDominoAction(playerActions.constructBuilding);
+  return ok({
+    ...game,
+    players: updatedPlayers,
+    queendomino: {
+      ...game.queendomino,
+      buildersBoard: updatedBoard,
+      queenHolderId: newQueenHolder
+    },
+    nextAction: {
+      type: "action",
+      nextLord: lordId,
+      nextAction
+    }
+  });
+};
+
+// 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/core/useCases/skipOptionalAction.ts
+var skipOptionalActionUseCase = (game, lordId) => {
+  const currentAction = game.nextAction;
+  if (currentAction.nextLord !== lordId) {
+    return err(ErrorCode.NOT_YOUR_TURN);
+  }
+  const action = currentAction.nextAction;
+  const isOptional = action === playerActions.placeKnight || action === playerActions.constructBuilding || action === playerActions.useDragon;
+  if (!isOptional) {
+    return err(ErrorCode.INVALID_OPTIONAL_ACTION);
+  }
+  const nextAction = nextQueenDominoAction(action);
+  if (nextAction === playerActions.pickDomino) {
+    const maxTurns = game.rules.basic.maxTurns;
+    const isLastTurn = game.turn === maxTurns;
+    if (isLastTurn && allLordsHavePlayed(game.lords)) {
+      return ok({
+        ...game,
+        nextAction: { type: "step", step: gameSteps.result }
+      });
+    }
+    return ok({
+      ...game,
+      nextAction: nextLordWithAction(game.lords)
+    });
+  }
+  return ok({
+    ...game,
+    nextAction: {
+      type: "action",
+      nextLord: lordId,
+      nextAction
+    }
+  });
+};
+
 // src/core/useCases/startGame.ts
 var startGameUseCase = (deps) => (game) => {
   const { uuidMethod: uuidMethod2, shuffleMethod: shuffleMethod2 } = deps;
@@ -2743,6 +4062,15 @@ var startGameUseCase = (deps) => (game) => {
     nextLord: shuffledLords[0].id,
     nextAction: playerActions.pickDomino
   };
+  let queendomino = game.queendomino;
+  if (queendomino && game.mode.name === "QueenDomino") {
+    const buildingShuffle = game.seed ? createSeededShuffle(game.seed, "buildings") : shuffleMethod2;
+    const board = createBuildersBoard(
+      queendomino.buildersBoard.drawPile,
+      buildingShuffle
+    );
+    queendomino = { ...queendomino, buildersBoard: board };
+  }
   const newState = {
     ...game,
     lords: shuffledLords,
@@ -2755,7 +4083,8 @@ var startGameUseCase = (deps) => (game) => {
         lordId: null,
         position: index + 1
       };
-    })
+    }),
+    ...queendomino !== void 0 && { queendomino }
   };
   return ok(newState);
 };
@@ -2764,6 +4093,7 @@ var startGameUseCase = (deps) => (game) => {
 var configureEngine = (config) => {
   const modeRepository = jsonModes_default();
   const dominoesRepository = jsonDominoes_default();
+  const buildingsRepository = jsonBuildings_default();
   const ruleRepository = jsonRules_default();
   const uuid = config.uuidMethod || uuidMethod;
   const shuffle = config.shuffleMethod || shuffleMethod;
@@ -2776,7 +4106,8 @@ var configureEngine = (config) => {
       createGameUseCase({
         modeRepository,
         dominoesRepository,
-        uuidMethod: uuid
+        uuidMethod: uuid,
+        buildingsRepository
       })
     ),
     getModesHandler: getModesHandler(
@@ -2852,6 +4183,26 @@ var configureEngine = (config) => {
       logger,
       translator,
       getDynastyResultUseCase
+    ),
+    placeKnightHandler: placeKnightHandler(
+      logger,
+      translator,
+      placeKnightUseCase
+    ),
+    constructBuildingHandler: constructBuildingHandler(
+      logger,
+      translator,
+      constructBuildingUseCase
+    ),
+    useDragonHandler: useDragonHandler(
+      logger,
+      translator,
+      useDragonUseCase
+    ),
+    skipOptionalActionHandler: skipOptionalActionHandler(
+      logger,
+      translator,
+      skipOptionalActionUseCase
     )
   };
 };
@@ -3575,7 +4926,12 @@ var wrapWithActionLog = (engine) => {
       const game = engine.discardDomino(cmd);
       record("discardDomino", { lordId: cmd.lordId }, game.turn);
       return game;
-    }
+    },
+    // Queendomino methods — pass through (no action log recording yet)
+    placeKnight: (cmd) => engine.placeKnight(cmd),
+    constructBuilding: (cmd) => engine.constructBuilding(cmd),
+    useDragon: (cmd) => engine.useDragon(cmd),
+    skipOptionalAction: (cmd) => engine.skipOptionalAction(cmd)
   };
   return {
     engine: wrappedEngine,
@@ -3716,7 +5072,11 @@ var createGameEngine = (config) => {
     canPlaceDominoHandler: canPlaceDominoHandler2,
     serializeGameHandler: serializeGameHandler2,
     deserializeGameHandler: deserializeGameHandler2,
-    getDynastyResultHandler: getDynastyResultHandler2
+    getDynastyResultHandler: getDynastyResultHandler2,
+    placeKnightHandler: placeKnightHandler2,
+    constructBuildingHandler: constructBuildingHandler2,
+    useDragonHandler: useDragonHandler2,
+    skipOptionalActionHandler: skipOptionalActionHandler2
   } = configureEngine(config);
   let engine = {
     getModes: (command) => getModesHandler2(command),
@@ -3734,7 +5094,11 @@ var createGameEngine = (config) => {
     canPlaceDomino: (command) => canPlaceDominoHandler2(command),
     serialize: (command) => serializeGameHandler2(command),
     deserialize: (command) => deserializeGameHandler2(command),
-    getDynastyResults: (command) => getDynastyResultHandler2(command)
+    getDynastyResults: (command) => getDynastyResultHandler2(command),
+    placeKnight: (command) => placeKnightHandler2(command),
+    constructBuilding: (command) => constructBuildingHandler2(command),
+    useDragon: (command) => useDragonHandler2(command),
+    skipOptionalAction: (command) => skipOptionalActionHandler2(command)
   };
   if (config.events) {
     engine = wrapWithEvents(engine, config.events);