@pompidup/kingdomino-engine 1.1.1 → 2.0.0

package/dist/index.js

@@ -1,609 +1,929 @@
-// src/adapters/driver/index.ts
-import { loadEnvFile } from "process";
-
 // src/datasources/dominoes.json
-var dominoes_default = [
-  {
-    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: "forest",
-      crowns: 0
-    },
-    right: {
-      type: "forest",
-      crowns: 0
-    },
-    number: 5
-  },
-  {
-    left: {
-      type: "forest",
-      crowns: 0
-    },
-    right: {
-      type: "forest",
-      crowns: 0
-    },
-    number: 6
-  },
-  {
-    left: {
-      type: "water",
-      crowns: 0
-    },
-    right: {
-      type: "water",
-      crowns: 0
-    },
-    number: 7
-  },
-  {
-    left: {
-      type: "water",
-      crowns: 0
-    },
-    right: {
-      type: "water",
-      crowns: 0
-    },
-    number: 8
-  },
-  {
-    left: {
-      type: "water",
-      crowns: 0
-    },
-    right: {
-      type: "water",
-      crowns: 0
-    },
-    number: 9
-  },
-  {
-    left: {
-      type: "grass",
-      crowns: 0
-    },
-    right: {
-      type: "grass",
-      crowns: 0
-    },
-    number: 10
-  },
-  {
-    left: {
-      type: "grass",
-      crowns: 0
-    },
-    right: {
-      type: "grass",
-      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: "water",
-      crowns: 0
-    },
-    number: 14
-  },
-  {
-    left: {
-      type: "wheat",
-      crowns: 0
-    },
-    right: {
-      type: "grass",
-      crowns: 0
-    },
-    number: 15
-  },
-  {
-    left: {
-      type: "wheat",
-      crowns: 0
-    },
-    right: {
-      type: "swamp",
-      crowns: 0
-    },
-    number: 16
-  },
-  {
-    left: {
-      type: "forest",
-      crowns: 0
-    },
-    right: {
-      type: "water",
-      crowns: 0
-    },
-    number: 17
-  },
-  {
-    left: {
-      type: "forest",
-      crowns: 0
-    },
-    right: {
-      type: "grass",
-      crowns: 0
-    },
-    number: 18
-  },
-  {
-    left: {
-      type: "wheat",
-      crowns: 1
-    },
-    right: {
-      type: "forest",
-      crowns: 0
-    },
-    number: 19
-  },
-  {
-    left: {
-      type: "wheat",
-      crowns: 1
-    },
-    right: {
-      type: "water",
-      crowns: 0
-    },
-    number: 20
-  },
-  {
-    left: {
-      type: "wheat",
-      crowns: 1
-    },
-    right: {
-      type: "grass",
-      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
+var dominoes_default = {
+  Classic: [
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 1
     },
-    number: 25
-  },
-  {
-    left: {
-      type: "forest",
-      crowns: 1
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 2
     },
-    right: {
-      type: "wheat",
-      crowns: 0
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 3
     },
-    number: 26
-  },
-  {
-    left: {
-      type: "forest",
-      crowns: 1
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 4
     },
-    right: {
-      type: "wheat",
-      crowns: 0
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 5
     },
-    number: 27
-  },
-  {
-    left: {
-      type: "forest",
-      crowns: 1
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 6
     },
-    right: {
-      type: "water",
-      crowns: 0
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 7
     },
-    number: 28
-  },
-  {
-    left: {
-      type: "forest",
-      crowns: 1
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 8
     },
-    right: {
-      type: "grass",
-      crowns: 0
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 9
     },
-    number: 29
-  },
-  {
-    left: {
-      type: "water",
-      crowns: 1
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 10
     },
-    right: {
-      type: "wheat",
-      crowns: 0
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 11
     },
-    number: 30
-  },
-  {
-    left: {
-      type: "water",
-      crowns: 1
+    {
+      left: {
+        type: "swamp",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 12
     },
-    right: {
-      type: "wheat",
-      crowns: 0
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 13
     },
-    number: 31
-  },
-  {
-    left: {
-      type: "water",
-      crowns: 1
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 14
     },
-    right: {
-      type: "forest",
-      crowns: 0
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 15
     },
-    number: 32
-  },
-  {
-    left: {
-      type: "water",
-      crowns: 1
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 16
     },
-    right: {
-      type: "forest",
-      crowns: 0
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 17
     },
-    number: 33
-  },
-  {
-    left: {
-      type: "water",
-      crowns: 1
+    {
+      left: {
+        type: "forest",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 18
     },
-    right: {
-      type: "forest",
-      crowns: 0
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 19
     },
-    number: 34
-  },
-  {
-    left: {
-      type: "water",
-      crowns: 1
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 20
     },
-    right: {
-      type: "forest",
-      crowns: 0
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 21
     },
-    number: 35
-  },
-  {
-    left: {
-      type: "wheat",
-      crowns: 0
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 22
     },
-    right: {
-      type: "grass",
-      crowns: 1
+    {
+      left: {
+        type: "wheat",
+        crowns: 1
+      },
+      right: {
+        type: "mine",
+        crowns: 0
+      },
+      number: 23
     },
-    number: 36
-  },
-  {
-    left: {
-      type: "water",
-      crowns: 0
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 24
     },
-    right: {
-      type: "grass",
-      crowns: 1
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 25
     },
-    number: 37
-  },
-  {
-    left: {
-      type: "wheat",
-      crowns: 0
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 26
     },
-    right: {
-      type: "swamp",
-      crowns: 1
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 27
     },
-    number: 38
-  },
-  {
-    left: {
-      type: "grass",
-      crowns: 0
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "sea",
+        crowns: 0
+      },
+      number: 28
     },
-    right: {
-      type: "swamp",
-      crowns: 0
+    {
+      left: {
+        type: "forest",
+        crowns: 1
+      },
+      right: {
+        type: "plain",
+        crowns: 0
+      },
+      number: 29
     },
-    number: 39
-  },
-  {
-    left: {
-      type: "mine",
-      crowns: 1
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 30
     },
-    right: {
-      type: "wheat",
-      crowns: 0
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 31
     },
-    number: 40
-  },
-  {
-    left: {
-      type: "wheat",
-      crowns: 0
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 32
     },
-    right: {
-      type: "grass",
-      crowns: 2
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 33
     },
-    number: 41
-  },
-  {
-    left: {
-      type: "water",
-      crowns: 0
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 34
     },
-    right: {
-      type: "grass",
-      crowns: 2
+    {
+      left: {
+        type: "sea",
+        crowns: 1
+      },
+      right: {
+        type: "forest",
+        crowns: 0
+      },
+      number: 35
     },
-    number: 42
-  },
-  {
-    left: {
-      type: "wheat",
-      crowns: 0
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 1
+      },
+      number: 36
     },
-    right: {
-      type: "swamp",
-      crowns: 2
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 1
+      },
+      number: 37
     },
-    number: 43
-  },
-  {
-    left: {
-      type: "grass",
-      crowns: 0
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 1
+      },
+      number: 38
     },
-    right: {
-      type: "swamp",
-      crowns: 2
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 0
+      },
+      number: 39
     },
-    number: 44
-  },
-  {
-    left: {
-      type: "mine",
-      crowns: 2
+    {
+      left: {
+        type: "mine",
+        crowns: 1
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 40
     },
-    right: {
-      type: "wheat",
-      crowns: 0
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 2
+      },
+      number: 41
     },
-    number: 45
-  },
-  {
-    left: {
-      type: "swamp",
-      crowns: 0
+    {
+      left: {
+        type: "sea",
+        crowns: 0
+      },
+      right: {
+        type: "plain",
+        crowns: 2
+      },
+      number: 42
     },
-    right: {
-      type: "mine",
-      crowns: 2
+    {
+      left: {
+        type: "wheat",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 2
+      },
+      number: 43
     },
-    number: 46
-  },
-  {
-    left: {
-      type: "swamp",
-      crowns: 0
+    {
+      left: {
+        type: "plain",
+        crowns: 0
+      },
+      right: {
+        type: "swamp",
+        crowns: 2
+      },
+      number: 44
     },
-    right: {
-      type: "mine",
-      crowns: 2
+    {
+      left: {
+        type: "mine",
+        crowns: 2
+      },
+      right: {
+        type: "wheat",
+        crowns: 0
+      },
+      number: 45
     },
-    number: 47
-  },
-  {
-    left: {
-      type: "wheat",
-      crowns: 0
+    {
+      left: {
+        type: "swamp",
+        crowns: 0
+      },
+      right: {
+        type: "mine",
+        crowns: 2
+      },
+      number: 46
     },
-    right: {
-      type: "mine",
-      crowns: 3
+    {
+      left: {
+        type: "swamp",
+        crowns: 0
+      },
+      right: {
+        type: "mine",
+        crowns: 2
+      },
+      number: 47
     },
-    number: 48
-  }
-];
-
-// src/adapters/driven/inMemoryDominoes.ts
-var inMemoryDominoes = () => {
-  const dominoes = [];
-  dominoes_default.forEach((domino) => {
-    dominoes.push({
+    {
       left: {
-        type: domino.left.type,
-        crowns: domino.left.crowns
+        type: "wheat",
+        crowns: 0
       },
       right: {
-        type: domino.right.type,
-        crowns: domino.right.crowns
+        type: "mine",
+        crowns: 3
       },
-      number: domino.number
+      number: 48
+    }
+  ]
+};
+
+// src/adapterServerside/jsonDominoes.ts
+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
+        },
+        number: domino.number
+      });
+    });
+    dominoes[key] = currentDominoes;
+  }
+  return {
+    getForMode: (mode) => {
+      return dominoes[mode.name] || [];
+    }
+  };
+};
+var jsonDominoes_default = jsonDominoes;
+
+// src/datasources/modes.json
+var modes_default = [
+  {
+    name: "Classic",
+    description: "Original KingDomino rules"
+  }
+];
+
+// src/adapterServerside/jsonModes.ts
+var jsonModes = () => {
+  const modes = [];
+  modes_default.forEach((mode) => {
+    modes.push({
+      name: mode.name,
+      description: mode.description
+    });
+  });
+  return {
+    getAvailables: () => {
+      return modes;
+    }
+  };
+};
+var jsonModes_default = jsonModes;
+
+// src/datasources/rules.json
+var rules_default = {
+  commun: [
+    {
+      playersLimit: 2,
+      lordsPerPlayer: 2,
+      maxDominoes: 24,
+      dominoesPerTurn: 4,
+      maxTurns: 6
+    },
+    {
+      playersLimit: 3,
+      lordsPerPlayer: 1,
+      maxDominoes: 36,
+      dominoesPerTurn: 3,
+      maxTurns: 12
+    },
+    {
+      playersLimit: 4,
+      lordsPerPlayer: 1,
+      maxDominoes: 48,
+      dominoesPerTurn: 4,
+      maxTurns: 12
+    }
+  ],
+  extra: [
+    {
+      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" }]
+    },
+    {
+      name: "Harmony",
+      description: "Gain 5 additional points if your kingdom is complete (no discarded dominoes).",
+      mode: [{ name: "Classic", description: "King Domino classic mode" }]
+    }
+  ]
+};
+
+// src/adapterServerside/jsonRules.ts
+var jsonRules = () => {
+  const rules = {
+    basic: {},
+    extraRules: []
+  };
+  const commonRules = rules_default.commun;
+  const extraRules = rules_default.extra;
+  commonRules.forEach((rule) => {
+    rules.basic[rule.playersLimit] = {
+      lords: rule.lordsPerPlayer,
+      maxDominoes: rule.maxDominoes,
+      dominoesPerTurn: rule.dominoesPerTurn,
+      maxTurns: rule.maxTurns
+    };
+  });
+  extraRules.forEach((rule) => {
+    rules.extraRules.push({
+      name: rule.name,
+      description: rule.description,
+      mode: rule.mode
     });
   });
   return {
     getAll: () => {
-      return dominoes;
+      return rules;
+    },
+    getAllExtra: () => {
+      return rules.extraRules;
     }
   };
 };
-var inMemoryDominoes_default = inMemoryDominoes;
+var jsonRules_default = jsonRules;
 
-// src/hexagon/internal/services/init.ts
-var init = (dependencies) => () => {
-  const dominoes = dependencies.dominoesRepository.getAll();
-  const id = dependencies.uuidMethod();
-  const state = {
-    id,
-    dominoes,
-    currentDominoes: [],
-    players: [],
-    lords: [],
-    turn: 0,
-    maxTurns: 0,
-    maxDominoes: 0,
-    dominoesPerTurn: 0,
-    order: {}
+// src/utils/result.ts
+var ok = (value) => ({ tag: "Ok", value });
+var err = (error) => ({ tag: "Err", error });
+var isOk = (result) => result.tag === "Ok";
+var isErr = (result) => result.tag === "Err";
+
+// src/application/handlers/addExtraRulesHandler.ts
+var addExtraRulesHandler = (useCase) => (command) => {
+  const { game, extraRules } = command;
+  if (game.nextAction.step !== "options") {
+    throw new Error("Invalid next action");
+  }
+  const result = useCase(game, extraRules);
+  if (isErr(result)) {
+    throw new Error(result.error);
+  }
+  return result.value;
+};
+
+// src/application/handlers/addPlayersHandler.ts
+var addPlayersHandler = (useCase) => (command) => {
+  const { game, players } = command;
+  if (game.nextAction.step !== "addPlayers") {
+    throw new Error("Invalid next action");
+  }
+  const result = useCase(game, players);
+  if (isErr(result)) {
+    throw new Error(result.error);
+  }
+  return result.value;
+};
+
+// src/application/handlers/chooseDominoHandler.ts
+var chooseDominoHandler = (useCase) => (command) => {
+  const { game, lordId, dominoPick } = command;
+  if (game.nextAction.nextAction !== "pickDomino") {
+    throw new Error("Invalid next action");
+  }
+  const result = useCase(game, lordId, dominoPick);
+  if (isErr(result)) {
+    throw new Error(result.error);
+  }
+  return result.value;
+};
+
+// src/application/handlers/createGameHandler.ts
+var createGameHandler = (useCase) => (command) => {
+  const result = useCase(command.mode);
+  if (isErr(result)) {
+    throw new Error(result.error);
+  }
+  return result.value;
+};
+
+// src/core/domain/types/game.ts
+var gameSteps = {
+  addPlayers: "addPlayers",
+  options: "options",
+  start: "start",
+  result: "result"
+};
+var isGameWithNextAction = (game) => {
+  return game.nextAction.type === "action";
+};
+
+// src/application/handlers/discardDominoHandler.ts
+var discardDominoHandler = (useCase) => (command) => {
+  const { game, lordId } = command;
+  if (game.nextAction.nextAction !== "placeDomino") {
+    throw new Error("Invalid next action");
+  }
+  const result = useCase(game, lordId);
+  if (isErr(result)) {
+    throw new Error(result.error);
+  }
+  if (isGameWithNextAction(result.value)) {
+    return result.value;
+  }
+  return result.value;
+};
+
+// src/application/handlers/getExtraRulesHandler.ts
+var getExtraRulesHandler = (getExtraRulesUseCase2) => (command) => {
+  const { mode, players } = command;
+  const result = getExtraRulesUseCase2(mode, players);
+  if (isErr(result)) {
+    throw new Error(result.error);
+  }
+  return result.value;
+};
+
+// src/application/handlers/getModesHandler.ts
+var getModesHandler = (getModeUseCase) => (_command) => {
+  const result = getModeUseCase();
+  if (isErr(result)) {
+    throw new Error(result.error);
+  }
+  return result.value;
+};
+
+// src/application/handlers/getResultHandler.ts
+var getResultHandler = (useCase) => (command) => {
+  const { game } = command;
+  if (game.nextAction.step !== "result") {
+    throw new Error("Invalid next step");
+  }
+  const result = useCase(game);
+  if (isErr(result)) {
+    throw new Error(result.error);
+  }
+  return result.value;
+};
+
+// src/application/handlers/placeDominoHandler.ts
+var placeDominoHandler = (useCase) => (command) => {
+  const { game, lordId, position, orientation, rotation } = command;
+  if (game.nextAction.nextAction !== "placeDomino") {
+    throw new Error("Invalid next action");
+  }
+  const result = useCase(game, lordId, position, orientation, rotation);
+  if (isErr(result)) {
+    throw new Error(result.error);
+  }
+  if (isGameWithNextAction(result.value)) {
+    return result.value;
+  }
+  return result.value;
+};
+
+// src/application/handlers/startGameHandler.ts
+var startGameHandler = (useCase) => (command) => {
+  const { game } = command;
+  if (game.nextAction.step !== "start") {
+    throw new Error("Invalid next action");
+  }
+  const result = useCase(game);
+  if (isErr(result)) {
+    throw new Error(result.error);
+  }
+  return result.value;
+};
+
+// src/core/domain/types/kingdom.ts
+var GRIDSIZE = 9;
+
+// src/core/domain/types/domino.ts
+var GROUND = [
+  "castle",
+  "wheat",
+  "forest",
+  "sea",
+  "plain",
+  "swamp",
+  "mine"
+];
+
+// src/core/domain/types/player.ts
+var playerActions = {
+  placeDomino: "placeDomino",
+  pickDomino: "pickDomino",
+  pass: "pass"
+};
+
+// src/core/domain/entities/rule.ts
+var getAvailablesExtraRules = (extraRules, mode, numberOfPlayers) => {
+  const availableExtraRules = extraRules.filter((rule) => {
+    return rule.mode.filter((m) => m.name === mode).length > 0 && (!rule.playersLimit || rule.playersLimit === numberOfPlayers);
+  });
+  if (availableExtraRules.length === 0) {
+    return err("No extra rules found");
+  }
+  return ok(availableExtraRules);
+};
+var toExtraRule = (rule, extraRules) => {
+  const foundRule = extraRules.find((r) => r.name === rule);
+  if (!foundRule) {
+    return err(`Rule not found: ${rule}`);
+  }
+  return ok(foundRule);
+};
+
+// src/core/useCases/addExtraRules.ts
+var addExtraRulesUseCase = (deps) => (game, rules) => {
+  const { ruleRepository } = deps;
+  const availableExtraRules = ruleRepository.getAllExtra();
+  const newExtraRules = [];
+  for (const rule of rules) {
+    const result = toExtraRule(rule, availableExtraRules);
+    if (isErr(result)) {
+      return result;
+    }
+    newExtraRules.push(result.value);
+  }
+  const updatedRules = {
+    basic: game.rules.basic,
+    extra: newExtraRules
+  };
+  const next = {
+    type: "step",
+    step: gameSteps.start
+  };
+  const updatedGame = {
+    ...game,
+    rules: updatedRules,
+    nextAction: next
   };
-  return state;
+  return ok(updatedGame);
 };
 
-// src/hexagon/internal/entities/kingdom.ts
+// src/core/domain/entities/player.ts
+var MINPLAYERSNAMELENGTH = 3;
+var validatePlayer = (name) => {
+  if (!name || name.trim().length < MINPLAYERSNAMELENGTH) {
+    return err(`Invalid player name: ${name}`);
+  }
+  return ok(name);
+};
+var createPlayer = (playerName, id, kingdom) => {
+  const name = validatePlayer(playerName);
+  if (isErr(name)) {
+    return name;
+  }
+  return ok({
+    name: name.value,
+    id,
+    kingdom
+  });
+};
+
+// src/core/domain/entities/domino.ts
+var isGround = (ground) => {
+  return GROUND.includes(ground);
+};
+var createTile = (ground, crowns = 0) => {
+  if (isGround(ground)) {
+    return { type: ground, crowns };
+  }
+  return { type: ground, crowns: 0 };
+};
+
+// src/core/domain/entities/kingdom.ts
 var createEmptyKingdom = () => {
-  const gridSize = 9;
-  const emptyTile = { type: "empty", crowns: 0 };
-  return Array.from(
-    { length: gridSize },
-    () => Array.from({ length: gridSize }, () => emptyTile)
+  const emptyTile = createTile("empty");
+  const grid = Array.from(
+    { length: GRIDSIZE },
+    () => Array.from({ length: GRIDSIZE }, () => emptyTile)
   );
+  return grid;
 };
-var createKingdomWithCastle = () => {
-  const kingdom2 = createEmptyKingdom();
-  return placeTile(kingdom2, { x: 4, y: 4 }, { type: "castle", crowns: 0 });
-};
-var placeTile = (kingdom2, position, tile) => {
-  const newRow = [...kingdom2[position.y]];
-  newRow[position.x] = tile;
-  return [
-    ...kingdom2.slice(0, position.y),
-    newRow,
-    ...kingdom2.slice(position.y + 1)
-  ];
+var placeCastle = (kingdom) => {
+  const castle = createTile("castle");
+  const newKingdom = deepCopyKingdom(kingdom);
+  newKingdom[4][4] = castle;
+  return newKingdom;
+};
+var placeTile = (kingdom, position, tile) => {
+  const newKingdom = deepCopyKingdom(kingdom);
+  newKingdom[position.y][position.x] = tile;
+  return newKingdom;
 };
-var getTile = (grid, position) => {
-  const tile = grid[position.y]?.[position.x];
-  if (tile === void 0) {
-    throw new Error("Invalid placement (not fit into the grid)");
+var getTile = (kingdom, position) => {
+  const tile = kingdom[position.y]?.[position.x];
+  if (!tile) {
+    return err("Invalid placement (not fit into the grid)");
   }
-  return tile;
+  return ok(tile);
 };
 var calculateDominoPosition = (position, orientation, rotation, domino) => {
   let firstTile;
@@ -675,51 +995,60 @@ var calculateDominoPosition = (position, orientation, rotation, domino) => {
   }
   return [firstTile, secondTile];
 };
-var placeDomino = (kingdom2, position, orientation, rotation, domino) => {
+var placeDomino = (kingdom, position, orientation, rotation, domino) => {
   const [firstTile, secondTile] = calculateDominoPosition(
     position,
     orientation,
     rotation,
     domino
   );
-  if (!isFreePlace(kingdom2, firstTile.position, secondTile.position)) {
-    throw new Error("Invalid placement (not free place)");
-  }
-  if (!isFitIntoTheGrid(kingdom2, [firstTile, secondTile])) {
-    throw new Error("Invalid placement (not fit into the grid)");
+  const isFreePlaceResult = isFreePlace(
+    kingdom,
+    firstTile.position,
+    secondTile.position
+  );
+  if (isErr(isFreePlaceResult)) {
+    return isFreePlaceResult;
   }
   const adjacentTiles = isAdjacent(
-    kingdom2,
+    kingdom,
     firstTile.position,
     secondTile.position
   );
   if (adjacentTiles.length === 0) {
-    throw new Error("Invalid placement (no adjacent)");
+    return err("Invalid placement (not adjacent)");
   }
   const hasValidAdjacentTiles = hasValidAdjacent(adjacentTiles, [
     firstTile.tile,
     secondTile.tile
   ]);
   if (!hasValidAdjacentTiles) {
-    throw new Error("Invalid placement (no valid adjacent)");
+    return err("Invalid placement (not valid adjacent)");
   }
-  return placeTiles(kingdom2, [firstTile, secondTile]);
+  return ok(placeTiles(kingdom, [firstTile, secondTile]));
 };
-var placeTiles = (kingdom2, tiles) => {
-  return tiles.reduce(
-    (newKingdom, { tile, position }) => placeTile(newKingdom, position, tile),
-    kingdom2
-  );
+var placeTiles = (kingdom, tiles) => {
+  let newKingdom = deepCopyKingdom(kingdom);
+  for (const { tile, position } of tiles) {
+    newKingdom = placeTile(newKingdom, position, tile);
+  }
+  return newKingdom;
 };
-var isFreePlace = (kingdom2, firstPosition, secondPosition) => {
-  const firstTile = getTile(kingdom2, firstPosition);
-  const secondTile = getTile(kingdom2, secondPosition);
-  if (firstTile.type !== "empty" || secondTile.type !== "empty") {
-    return false;
+var isFreePlace = (kingdom, firstPosition, secondPosition) => {
+  const firstTile = getTile(kingdom, firstPosition);
+  const secondTile = getTile(kingdom, secondPosition);
+  if (isErr(firstTile)) {
+    return firstTile;
+  }
+  if (isErr(secondTile)) {
+    return secondTile;
   }
-  return true;
+  if (firstTile.value.type !== "empty" || secondTile.value.type !== "empty") {
+    return err("Invalid placement (not empty)");
+  }
+  return ok(true);
 };
-var isAdjacent = (kingdom2, firstPosition, secondPosition) => {
+var isAdjacent = (kingdom, firstPosition, secondPosition) => {
   const xFirstPosition = firstPosition.x;
   const yFirstPosition = firstPosition.y;
   const xSecondPosition = secondPosition.x;
@@ -748,9 +1077,11 @@ var isAdjacent = (kingdom2, firstPosition, secondPosition) => {
     1
   );
   adjacentTilesKeys.forEach((key) => {
-    const tile = getTile(kingdom2, key);
-    if (tile) {
-      adjacentTiles.push(tile);
+    const tile = getTile(kingdom, key);
+    if (isOk(tile)) {
+      if (tile.value.type !== "empty") {
+        adjacentTiles.push(tile.value);
+      }
     }
   });
   return adjacentTiles;
@@ -762,675 +1093,722 @@ var hasValidAdjacent = (adjacentTiles, tiles) => {
     });
   });
 };
-var isFitIntoTheGrid = (grid, positions) => {
-  const maxSize = 5;
-  const simulateNewGrid = [...grid];
-  simulateNewGrid[positions[0].position.y][positions[0].position.x] = positions[0].tile;
-  simulateNewGrid[positions[1].position.y][positions[1].position.x] = positions[1].tile;
-  const lines = simulateNewGrid.map(
-    (line) => line.filter((tile) => tile.type !== "empty")
-  );
-  const columns = simulateNewGrid[0].map(
-    (_, index) => simulateNewGrid.map((line) => line[index]).filter((tile) => tile?.type !== "empty")
-  );
-  const linesLength = lines.map((line) => line.length);
-  const columnsLength = columns.map((line) => line.length);
-  const maxLineLength = Math.max(...linesLength);
-  const maxColumnLength = Math.max(...columnsLength);
-  if (maxLineLength > maxSize || maxColumnLength > maxSize) {
-    return false;
-  }
-  return true;
-};
-var kingdom = {
-  createEmptyKingdom,
-  createKingdomWithCastle,
-  getTile,
-  placeDomino
-};
-var kingdom_default = kingdom;
-
-// src/hexagon/internal/services/setup.ts
-var setup = (dependencies) => (payload) => {
-  const { state, players } = payload;
-  if (!players) {
-    throw new Error("There must be at least 2 players");
-  }
-  if (players.length > 4) {
-    throw new Error("There must be no more than 4 players");
-  }
-  if (players.length < 2) {
-    throw new Error("There must be at least 2 players");
-  }
-  const { dominoes } = state;
-  const { shuffleMethod: shuffleMethod2, uuidMethod: uuidMethod2 } = dependencies;
-  const { maxDominoes, dominoesPerTurn, maxTurns } = rules[players.length];
-  const shuffledDominoes = shuffleMethod2(dominoes);
-  shuffledDominoes.splice(maxDominoes);
-  const newPlayers = players.map((player) => {
-    return {
-      ...player,
-      kingdom: kingdom_default.createKingdomWithCastle(),
-      id: uuidMethod2()
-    };
-  });
-  let newLords;
-  if (newPlayers.length === 2) {
-    newLords = [
-      {
-        id: uuidMethod2(),
-        playerId: newPlayers[0].id,
-        order: 1,
-        turnEnded: false,
-        hasPick: false,
-        hasPlace: false
-      },
-      {
-        id: uuidMethod2(),
-        playerId: newPlayers[0].id,
-        order: 2,
-        turnEnded: false,
-        hasPick: false,
-        hasPlace: false
-      },
-      {
-        id: uuidMethod2(),
-        playerId: newPlayers[1].id,
-        order: 3,
-        turnEnded: false,
-        hasPick: false,
-        hasPlace: false
-      },
-      {
-        id: uuidMethod2(),
-        playerId: newPlayers[1].id,
-        order: 4,
-        turnEnded: false,
-        hasPick: false,
-        hasPlace: false
-      }
-    ];
-  } else {
-    newLords = newPlayers.map((player, index) => {
-      return {
-        id: uuidMethod2(),
-        playerId: player.id,
-        order: index + 1,
-        turnEnded: false,
-        hasPick: false,
-        hasPlace: false
-      };
-    });
-  }
-  const lordsWithOrder = shuffleMethod2(newLords);
-  lordsWithOrder.forEach((lord, index) => {
-    lord.order = index + 1;
-  });
-  lordsWithOrder.sort((a, b) => a.order - b.order);
-  const newState = {
-    ...state,
-    dominoes: shuffledDominoes,
-    players: newPlayers,
-    lords: lordsWithOrder,
-    maxTurns,
-    maxDominoes,
-    dominoesPerTurn,
-    turn: 0
-  };
-  return newState;
-};
-
-// src/hexagon/internal/services/startTurn.ts
-var startTurn = (payload) => {
-  const { state } = payload;
-  const turn = state.turn + 1;
-  const lords = state.lords;
-  lords.forEach((lord) => {
-    lord.turnEnded = false;
-    lord.hasPick = false;
-    lord.hasPlace = false;
-  });
-  const updatedState = {
-    ...state,
-    lords,
-    turn
-  };
-  return { game: updatedState };
+var checkCastleIsInMiddle = (kingdom) => {
+  const castlePosition = kingdom.map((row) => row.findIndex((tile) => tile.type === "castle")).find((index) => index !== -1);
+  const leftTiles = castlePosition !== void 0 ? kingdom[castlePosition].slice(0, castlePosition) : [];
+  const leftTilesCount = leftTiles.filter(
+    (tile) => tile.type !== "empty"
+  ).length;
+  const rightTiles = castlePosition !== void 0 ? kingdom[castlePosition].slice(castlePosition + 1) : [];
+  const rightTilesCount = rightTiles.filter(
+    (tile) => tile.type !== "empty"
+  ).length;
+  const topTiles = castlePosition !== void 0 ? kingdom[castlePosition].slice(0, castlePosition) : [];
+  const topTilesCount = topTiles.filter((tile) => tile.type !== "empty").length;
+  const bottomTiles = castlePosition != void 0 ? kingdom[castlePosition].slice(castlePosition + 1) : [];
+  const bottomTilesCount = bottomTiles.filter(
+    (tile) => tile.type !== "empty"
+  ).length;
+  return leftTilesCount === rightTilesCount && topTilesCount === bottomTilesCount && leftTilesCount === topTilesCount;
+};
+var countDominoes = (kingdom) => {
+  const notEmpties = kingdom.flat().filter((tile) => tile.type !== "empty");
+  const totalDominoes = (notEmpties.length - 1) / 2;
+  return totalDominoes;
+};
+var deepCopyKingdom = (kingdom) => {
+  return kingdom.map((line) => line.map((tile) => ({ ...tile })));
 };
 
-// src/hexagon/internal/services/pick.ts
-var pick = (payload) => {
-  const { lordId, data } = payload;
-  const { state, dominoPick } = data;
-  const { currentDominoes, lords } = state;
-  if (!isLordTurn(state, lordId)) {
-    throw new Error("It is not your turn");
-  }
-  const lord = lords.find((lord2) => lord2.id === lordId);
-  if (lord?.hasPick) {
-    throw new Error("You have already picked");
-  }
-  const domino = checkValidityDomino(state, dominoPick);
-  const isError = (domino2) => {
-    return domino2.error !== void 0;
-  };
-  if (isError(domino)) {
-    throw new Error(domino.error);
+// src/core/useCases/addPlayers.ts
+var addPlayersUseCase = (deps) => (game, players) => {
+  const { uuidMethod: uuidMethod2, shuffleMethod: shuffleMethod2, ruleRepository } = deps;
+  if (!players || players.length < 2 || players.length > 4) {
+    return err("Invalid number of players");
   }
-  const updatedCurrentDominoes = currentDominoes.map((domino2) => {
-    if (domino2.domino.number === dominoPick) {
-      domino2.picked = true;
-      domino2.lordId = lordId;
-    }
-    return domino2;
-  });
-  const updatedLords = lords.map((lord2) => {
-    if (lord2.id === lordId) {
-      lord2.hasPick = true;
-      lord2.turnEnded = true;
-      lord2.dominoPicked = domino.domino;
+  const newPlayers = [];
+  for (const player of players) {
+    let kingdom = createEmptyKingdom();
+    kingdom = placeCastle(kingdom);
+    let id = uuidMethod2();
+    const newPlayer = createPlayer(player, id, kingdom);
+    if (isErr(newPlayer)) {
+      return newPlayer;
     }
-    return lord2;
-  });
-  const updatedState = {
-    ...state,
-    currentDominoes: updatedCurrentDominoes,
-    lords: updatedLords
-  };
-  return updatedState;
-};
-
-// src/hexagon/internal/services/place.ts
-var place = (payload) => {
-  const { lordId, data } = payload;
-  const { state, position, orientation, rotation } = data;
-  const currentLord = state.lords.find((lord) => lord.id === lordId);
-  const currentPlayer = state.players.find(
-    (player) => player.id === currentLord?.playerId
-  );
-  const currentKingdom = currentPlayer?.kingdom;
-  if (!currentKingdom) {
-    throw new Error("Kingdom not found");
+    newPlayers.push(newPlayer.value);
   }
-  const domino = currentLord?.dominoPicked;
-  if (!domino) {
-    throw new Error("Domino not found");
+  const rules = ruleRepository.getAll();
+  const basicRules = rules.basic[newPlayers.length];
+  if (!basicRules) {
+    return err("No base rules found");
   }
-  kingdom_default.placeDomino(currentKingdom, position, orientation, rotation, domino);
-  currentPlayer.kingdom = currentKingdom;
-  currentLord.hasPlace = true;
-  const newState = {
-    ...state,
-    lords: state.lords.map((lord) => {
-      if (lord.id === lordId) {
-        return currentLord;
-      }
-      return lord;
-    })
+  const dominoes = game.dominoes;
+  const { maxDominoes } = basicRules;
+  const shuffledDominoes = shuffleMethod2(dominoes);
+  const splicedDominoes = shuffledDominoes.slice(0, maxDominoes);
+  const next = {
+    type: "step",
+    step: "options"
+  };
+  const updatedGame = {
+    ...game,
+    players: newPlayers,
+    dominoes: splicedDominoes,
+    rules: {
+      ...game.rules,
+      basic: basicRules
+    },
+    nextAction: next
   };
-  return newState;
+  return ok(updatedGame);
 };
 
-// src/hexagon/internal/services/order.ts
-var definePlayerOrder = (payload) => {
-  const { state } = payload;
-  const { lords, currentDominoes } = state;
-  const allLordsHavePlayed = lords.every((lord) => lord.turnEnded);
-  if (!allLordsHavePlayed) {
-    throw new Error("Not all lords have played");
-  }
-  const updatedLords = lords.map((lord) => {
-    return {
-      ...lord,
-      order: currentDominoes.find((domino) => domino.lordId === lord.id)?.position || 0
-    };
+// src/core/domain/entities/lord.ts
+var createLord = (id, playerId) => {
+  return {
+    id,
+    playerId,
+    turnEnded: false,
+    hasPick: false,
+    hasPlace: true
+  };
+};
+var hasPick = (lord) => lord.hasPick;
+var hasPlace = (lord) => lord.hasPlace;
+var hasTurnEnded = (lord) => lord.turnEnded;
+var canPass = (lord) => {
+  return !hasPick(lord) && !hasPlace(lord) && !hasTurnEnded(lord);
+};
+var canPick = (lord) => {
+  return !hasPick(lord) && hasPlace(lord) && !hasTurnEnded(lord);
+};
+var canPlaceAndDominoPickedIsDefined = (lord) => {
+  return !hasPick(lord) && !hasPlace(lord) && !hasTurnEnded(lord) && lord.dominoPicked !== void 0;
+};
+var updateLordOrder = (lords) => {
+  return lords.sort((a2, b2) => {
+    return a2.dominoPicked.number - b2.dominoPicked.number;
   });
-  const order = updatedLords.reduce((acc, lord) => {
-    return {
-      ...acc,
-      [lord.order]: lord.id
-    };
-  }, {});
-  const newState = {
-    ...state,
-    lords: updatedLords,
-    order
+};
+var resetLordsActions = (lord) => {
+  const lordsCopy = [...lord];
+  for (const lord2 of lordsCopy) {
+    lord2.turnEnded = false;
+    lord2.hasPick = false;
+    lord2.hasPlace = false;
+  }
+  return lordsCopy;
+};
+var nextLordWithAction = (lords) => {
+  const nextLord = findNextLord(lords);
+  return {
+    type: "action",
+    nextLord: nextLord.id,
+    nextAction: hasPlace(nextLord) ? playerActions.pickDomino : playerActions.placeDomino
   };
-  return newState;
+};
+var findNextLord = (lords) => {
+  const lord = lords.find((lord2) => !hasTurnEnded(lord2));
+  if (!lord) {
+    return lords[0];
+  }
+  return lord;
+};
+var allLordsHavePlayed = (lords) => {
+  return lords.every((lord) => lord.turnEnded);
 };
 
-// src/hexagon/internal/services/draw.ts
-var draw = (payload) => {
-  const { state } = payload;
-  const dominoesCopy = [...state.dominoes];
-  const dominoesDrawn = dominoesCopy.splice(0, state.dominoesPerTurn);
-  dominoesDrawn.sort((a, b) => a.number - b.number);
-  const newState = {
-    ...state,
-    dominoes: dominoesCopy,
-    currentDominoes: dominoesDrawn.map((domino, index) => {
+// src/core/useCases/chooseDomino.ts
+var chooseDominoUseCase = (game, lordId, dominoPick) => {
+  const currentLord = game.lords.find(
+    (lord) => lord.id === game.nextAction.nextLord
+  );
+  if (!currentLord) {
+    return err("Lord not found");
+  }
+  if (currentLord.id !== lordId) {
+    return err("Not your turn");
+  }
+  if (!canPick(currentLord)) {
+    return err("Lord can't pick");
+  }
+  const selectedDomino = game.currentDominoes.find(
+    (domino) => domino.domino.number === dominoPick
+  );
+  if (!selectedDomino) {
+    return err("Domino not found");
+  }
+  if (selectedDomino.picked) {
+    return err("Domino already picked");
+  }
+  const updatedCurrentDominoes = game.currentDominoes.map((domino) => {
+    if (domino.domino.number === dominoPick) {
+      domino.picked = true;
+      domino.lordId = currentLord.id;
+    }
+    return domino;
+  });
+  const updatedLords = game.lords.map((lord) => {
+    if (lord.id === currentLord.id) {
+      lord.hasPick = true;
+      lord.turnEnded = true;
+      lord.dominoPicked = selectedDomino.domino;
+    }
+    return lord;
+  });
+  const turnEnded = allLordsHavePlayed(updatedLords);
+  if (turnEnded) {
+    const lords = resetLordsActions(updateLordOrder(updatedLords));
+    const updatedTurn = game.turn + 1;
+    const next2 = nextLordWithAction(lords);
+    const dominoesCopy = [...game.dominoes];
+    const dominoesDrawn = dominoesCopy.splice(
+      0,
+      game.rules.basic.dominoesPerTurn
+    );
+    dominoesDrawn.sort((a2, b2) => a2.number - b2.number);
+    const updatedCurrentDominoes2 = dominoesDrawn.map((domino, index) => {
       return {
         domino,
         picked: false,
         lordId: null,
         position: index + 1
       };
-    })
+    });
+    return ok({
+      ...game,
+      currentDominoes: updatedCurrentDominoes2,
+      dominoes: dominoesCopy,
+      lords,
+      turn: updatedTurn,
+      nextAction: next2
+    });
+  }
+  const next = nextLordWithAction(updatedLords);
+  const updatedState = {
+    ...game,
+    currentDominoes: updatedCurrentDominoes,
+    lords: updatedLords,
+    nextAction: next
   };
-  return newState;
+  return ok(updatedState);
 };
 
-// src/hexagon/internal/services/scoring.ts
-var calculateScore = (kingdom2) => {
-  const visited = kingdom2.map((row) => row.map(() => false));
-  const properties = [];
-  const directions = [
-    [-1, 0],
-    [1, 0],
-    [0, -1],
-    [0, 1]
-  ];
-  const markZone = (x, y, type, crowns) => {
-    if (x < 0 || y < 0 || x >= kingdom2[0].length || y >= kingdom2.length || visited[y][x] || kingdom2[y][x].type !== type || kingdom2[y][x].type === "empty" || kingdom2[y][x].type === "castle") {
-      return;
-    }
-    visited[y][x] = true;
-    const currentZone = properties.find(
-      (property) => property.type === type && property.tiles.some(([tx, ty]) => {
-        for (let [dx, dy] of directions) {
-          if (tx + dx === x && ty + dy === y) {
-            return true;
-          }
-        }
-        return false;
-      })
-    );
-    if (currentZone) {
-      currentZone.crowns += crowns;
-      currentZone.size++;
-      currentZone.tiles.push([x, y]);
-    } else {
-      properties.push({ type, crowns, size: 1, tiles: [[x, y]] });
-    }
-    directions.forEach(([dx, dy]) => {
-      const nx = x + dx;
-      const ny = y + dy;
-      if (nx >= 0 && ny >= 0 && nx < kingdom2[0].length && ny < kingdom2.length && kingdom2[ny][nx].type === type) {
-        markZone(nx, ny, kingdom2[ny][nx].type, kingdom2[ny][nx].crowns);
-      }
-    });
+// src/core/domain/entities/game.ts
+var create = (payload) => {
+  const { id, mode, dominoes } = payload;
+  return {
+    id,
+    dominoes,
+    currentDominoes: [],
+    players: [],
+    lords: [],
+    turn: 0,
+    nextAction: {
+      type: "step",
+      step: gameSteps.addPlayers
+    },
+    rules: {
+      basic: {
+        lords: 0,
+        maxDominoes: 0,
+        dominoesPerTurn: 0,
+        maxTurns: 0
+      },
+      extra: []
+    },
+    mode
   };
-  kingdom2.forEach((row, y) => {
-    row.forEach((tile, x) => {
-      if (!visited[y][x]) {
-        markZone(x, y, tile.type, tile.crowns);
-      }
-    });
-  });
-  if (properties.length === 0) {
-    return {
-      score: 0,
-      maxPropertiesSize: 0,
-      totalCrowns: 0
-    };
+};
+
+// src/core/domain/entities/mode.ts
+var findMode = (mode, availableMode) => {
+  return availableMode.find((m) => m.name === mode);
+};
+var createMode = (mode, availableMode) => {
+  const foundMode = findMode(mode, availableMode);
+  if (foundMode) {
+    return ok(foundMode);
   }
-  const score = properties.reduce(
-    (score2, property) => score2 + property.crowns * property.size,
-    0
-  );
-  const maxPropertiesSize = Math.max(
-    ...properties.map((property) => property.size ?? 0)
-  );
-  const totalCrowns = properties.reduce(
-    (total, property) => total + property.crowns,
-    0
-  );
-  return {
-    score,
-    maxPropertiesSize,
-    totalCrowns
+  return err(`Invalid mode: ${mode}`);
+};
+
+// src/core/useCases/createGame.ts
+var createGameUseCase = (deps) => (mode) => {
+  const { modeRepository, dominoesRepository, uuidMethod: uuidMethod2 } = deps;
+  const id = uuidMethod2();
+  const availableMode = modeRepository.getAvailables();
+  const newMode = createMode(mode, availableMode);
+  if (isErr(newMode)) {
+    return newMode;
+  }
+  const dominoes = dominoesRepository.getForMode(newMode.value);
+  if (!dominoes || dominoes.length === 0) {
+    return err(`No dominoes found for mode ${newMode.value.name}`);
+  }
+  const payload = {
+    id,
+    mode: newMode.value,
+    dominoes
   };
+  const newGame = create(payload);
+  return ok(newGame);
 };
 
-// src/hexagon/internal/services/pass.ts
-var pass = (payload) => {
-  const { lordId, data } = payload;
-  const { state } = data;
-  const currentLord = state.lords.find((lord) => lord.id === lordId);
+// src/core/useCases/discardDomino.ts
+var discardDominoUseCase = (game, lordId) => {
+  const nextAction = game.nextAction;
+  const currentLord = game.lords.find(
+    (lord) => lord.id === nextAction.nextLord
+  );
   if (!currentLord) {
-    throw new Error("Lord not found");
+    return err("Lord not found");
   }
-  currentLord.hasPlace = true;
-  const newState = {
-    ...state,
-    lords: state.lords.map((lord) => {
-      if (lord.id === lordId) {
-        return currentLord;
+  if (currentLord.id !== lordId) {
+    return err("Not your turn");
+  }
+  if (!canPass(currentLord)) {
+    return err("Lord can't pass");
+  }
+  const maxTurns = game.rules.basic.maxTurns;
+  const currentTurn = game.turn;
+  const isLastTurn = currentTurn === maxTurns;
+  const updatedLord = game.lords.map((lord) => {
+    if (lord.id === currentLord.id) {
+      if (isLastTurn) {
+        return {
+          ...lord,
+          turnEnded: true,
+          hasPlace: true
+        };
       }
-      return lord;
-    })
+      return {
+        ...lord,
+        hasPlace: true
+      };
+    }
+    return lord;
+  });
+  let updatedGame;
+  const resultStep = {
+    type: "step",
+    step: gameSteps.result
   };
-  return newState;
+  if (isLastTurn && allLordsHavePlayed(updatedLord)) {
+    updatedGame = {
+      ...game,
+      lords: updatedLord,
+      nextAction: resultStep
+    };
+  } else {
+    updatedGame = {
+      ...game,
+      lords: updatedLord,
+      nextAction: nextLordWithAction(updatedLord)
+    };
+  }
+  return ok(updatedGame);
 };
 
-// src/hexagon/internal/services/game.ts
-var gameStep = (dependencies) => {
-  return {
-    init: init(dependencies),
-    setup: setup(dependencies),
-    startTurn,
-    pick,
-    place,
-    pass,
-    definePlayerOrder,
-    draw,
-    calculateScore
-  };
-};
-var isLordTurn = (state, lordId) => {
-  const { lords, currentDominoes } = state;
-  const currentLordOrder = lords.find((lord) => lord.id === lordId)?.order;
-  const pickedDominoes = currentDominoes.filter(
-    (currentDomino) => currentDomino.picked
-  );
-  if (currentLordOrder !== pickedDominoes.length + 1) {
-    return false;
+// src/core/useCases/getExtraRules.ts
+var getExtraRulesUseCase = (deps) => (mode, players) => {
+  const { ruleRepository } = deps;
+  const allExtraRules = ruleRepository.getAllExtra();
+  if (!allExtraRules) {
+    return err("No rules found");
   }
-  return true;
+  return getAvailablesExtraRules(allExtraRules, mode, players);
 };
-var checkValidityDomino = (state, dominoPick) => {
-  const { currentDominoes } = state;
-  const domino = currentDominoes.find(
-    (currentDomino) => currentDomino.domino.number === dominoPick
-  );
-  if (!domino) {
-    const error = {
-      error: "Domino not found"
+
+// src/core/useCases/getModes.ts
+var getModesUseCase = (deps) => () => {
+  const { modeRepository } = deps;
+  return ok(modeRepository.getAvailables());
+};
+
+// src/core/useCases/getResult.ts
+var getResultUseCase = (game) => {
+  const { players, rules } = game;
+  const { basic, extra } = rules;
+  const scores = players.map((player) => {
+    const { kingdom } = player;
+    const visited = kingdom.map((row) => row.map(() => false));
+    const properties = [];
+    const directions = [
+      [-1, 0],
+      [1, 0],
+      [0, -1],
+      [0, 1]
+    ];
+    const markZone = (x, y, type, crowns) => {
+      if (x < 0 || y < 0 || x >= kingdom[0].length || y >= kingdom.length || visited[y][x] || kingdom[y][x].type !== type || kingdom[y][x].type === "empty" || kingdom[y][x].type === "castle") {
+        return;
+      }
+      visited[y][x] = true;
+      const currentZone = properties.find(
+        (property) => property.type === type && property.tiles.some(([tx, ty]) => {
+          for (let [dx, dy] of directions) {
+            if (tx + dx === x && ty + dy === y) {
+              return true;
+            }
+          }
+          return false;
+        })
+      );
+      if (currentZone) {
+        currentZone.size += 1;
+        currentZone.tiles.push([x, y]);
+        currentZone.crowns += crowns;
+      } else {
+        properties.push({
+          type,
+          crowns,
+          size: 1,
+          tiles: [[x, y]]
+        });
+      }
+      directions.forEach(([dx, dy]) => {
+        const nx = x + dx;
+        const ny = y + dy;
+        if (nx >= 0 && ny >= 0 && nx < kingdom[0].length && ny < kingdom.length && kingdom[ny][nx].type === type) {
+          markZone(nx, ny, kingdom[ny][nx].type, kingdom[ny][nx].crowns);
+        }
+      });
     };
-    return error;
-  }
-  if (domino.picked) {
-    const error = {
-      error: "Domino already picked"
+    kingdom.forEach((row, y) => {
+      row.forEach((tile, x) => {
+        if (!visited[y][x]) {
+          markZone(x, y, tile.type, tile.crowns);
+        }
+      });
+    });
+    if (properties.length === 0) {
+      return {
+        playerId: player.id,
+        playerName: player.name,
+        details: {
+          points: 0,
+          maxPropertiesSize: 0,
+          totalCrowns: 0
+        }
+      };
+    }
+    let points = properties.reduce(
+      (score, property) => score + property.crowns * property.size,
+      0
+    );
+    const maxPropertiesSize = Math.max(
+      ...properties.map((property) => property.size ?? 0)
+    );
+    const totalCrowns = properties.reduce(
+      (total, property) => total + property.crowns,
+      0
+    );
+    if (extra.length > 0) {
+      extra.forEach((extraRule) => {
+        if (extraRule.name === "The middle Kingdom") {
+          const castleIsInMiddle = checkCastleIsInMiddle(kingdom);
+          if (castleIsInMiddle) {
+            points += 10;
+          }
+        }
+        if (extraRule.name === "Harmony") {
+          const totalDominoes = countDominoes(kingdom);
+          const dominoLimit = basic.maxDominoes;
+          const totalPlayers = players.length;
+          const dominoesPerPlayer = dominoLimit / totalPlayers;
+          if (totalDominoes === dominoesPerPlayer) {
+            points += 5;
+          }
+        }
+      });
+    }
+    return {
+      playerId: player.id,
+      playerName: player.name,
+      details: {
+        points,
+        maxPropertiesSize,
+        totalCrowns
+      }
     };
-    return error;
-  }
-  return domino;
-};
-var rules = {
-  2: {
-    lords: 2,
-    maxDominoes: 24,
-    dominoesPerTurn: 4,
-    maxTurns: 6
-  },
-  3: {
-    lords: 1,
-    maxDominoes: 36,
-    dominoesPerTurn: 3,
-    maxTurns: 12
-  },
-  4: {
-    lords: 1,
-    maxDominoes: 48,
-    dominoesPerTurn: 4,
-    maxTurns: 12
-  }
-};
-var game_default = gameStep;
-
-// src/hexagon/internal/services/result.ts
-var result = (scores) => {
-  scores.sort((a, b) => {
-    if (a.details.score !== b.details.score) {
-      return b.details.score - a.details.score;
+  });
+  scores.sort((a2, b2) => {
+    if (a2.details.points !== b2.details.points) {
+      return b2.details.points - a2.details.points;
     }
-    if (a.details.maxPropertiesSize !== b.details.maxPropertiesSize) {
-      return b.details.maxPropertiesSize - a.details.maxPropertiesSize;
+    if (a2.details.maxPropertiesSize !== b2.details.maxPropertiesSize) {
+      return b2.details.maxPropertiesSize - a2.details.maxPropertiesSize;
     }
-    return b.details.totalCrowns - a.details.totalCrowns;
+    return b2.details.totalCrowns - a2.details.totalCrowns;
   });
-  const result2 = [];
+  const result = [];
   let isTie = false;
-  result2.push({
-    ...scores[0],
+  result.push({
+    playerId: scores[0].playerId,
+    playerName: scores[0].playerName,
+    details: scores[0].details,
     position: 1
   });
-  for (let i = 1; i < scores.length; i++) {
-    const currentScore = scores[i];
-    const previousScore = scores[i - 1];
-    if (previousScore && currentScore && currentScore.details.score === previousScore.details.score && currentScore.details.maxPropertiesSize === previousScore.details.maxPropertiesSize && currentScore.details.totalCrowns === previousScore.details.totalCrowns) {
+  for (let i2 = 1; i2 < scores.length; i2++) {
+    const currentScore = scores[i2];
+    const previousScore = scores[i2 - 1];
+    if (previousScore && currentScore && currentScore.details.points === previousScore.details.points && currentScore.details.maxPropertiesSize === previousScore.details.maxPropertiesSize && currentScore.details.totalCrowns === previousScore.details.totalCrowns) {
       isTie = true;
     }
     if (isTie) {
-      result2.push({
+      result.push({
         ...currentScore,
-        position: result2[i - 1].position
+        position: result[i2 - 1].position
       });
     } else {
-      result2.push({
+      result.push({
         ...currentScore,
-        position: i + 1
+        position: i2 + 1
       });
     }
     isTie = false;
   }
-  return result2;
-};
-
-// src/hexagon/internal/entities/mode.ts
-var availableMode = ["Classic"];
-
-// src/adapters/driven/uuid.ts
-import { randomUUID } from "crypto";
-var uuidMethod = () => {
-  return randomUUID();
+  return ok({
+    ...game,
+    result
+  });
 };
 
-// src/adapters/driven/shuffle.ts
-var shuffleMethod = (array) => {
-  for (let i = array.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [array[i], array[j]] = [array[j], array[i]];
+// src/core/useCases/placeDomino.ts
+var placeDominoUseCase = (game, lordId, position, orientation, rotation) => {
+  const nextAction = game.nextAction;
+  const currentLord = game.lords.find(
+    (lord) => lord.id === nextAction.nextLord
+  );
+  if (!currentLord) {
+    return err("Lord not found");
   }
-  return array;
-};
-
-// src/adapters/driver/index.ts
-var gameEngine = () => {
-  let dependencies;
-  try {
-    loadEnvFile();
-  } catch (error) {
-    console.log("No .env file found. Using default configuration.");
-  }
-  if (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") {
-    console.log("Game engine is running in development mode");
-    dependencies = {
-      dominoesRepository: inMemoryDominoes_default(),
-      uuidMethod: () => `uuid-${Math.random()}`,
-      shuffleMethod: (array) => array
-    };
-  } else {
-    console.log("Game engine is running in production mode");
-    dependencies = {
-      dominoesRepository: inMemoryDominoes_default(),
-      uuidMethod,
-      shuffleMethod
-    };
+  if (currentLord.id !== lordId) {
+    return err("Not your turn");
   }
-  const {
-    init: init2,
-    setup: setup2,
-    startTurn: startTurn2,
-    pick: pick2,
-    place: place2,
-    pass: pass2,
-    definePlayerOrder: definePlayerOrder2,
-    draw: draw2,
-    calculateScore: calculateScore2
-  } = game_default(dependencies);
-  const getMode = () => {
-    return availableMode;
-  };
-  const setMode = (mode, game) => {
-    return game;
-  };
-  const getRules = (mode) => {
-    return [];
-  };
-  const setRules = (rules2, game) => {
-    return game;
-  };
-  const start = (game, players) => {
-    const setupState = setup2({
-      state: game,
-      players
-    });
-    const drawState = draw2({ state: setupState });
-    return {
-      nextLord: drawState.lords[0].id,
-      nextAction: "pick",
-      game: drawState
-    };
-  };
-  const passTurn = (game, lordId) => {
-    const updatedGame = pass2({
-      lordId,
-      action: "pass",
-      data: {
-        state: game
-      }
-    });
-    const resp = defineNextAction(updatedGame, "pass", lordId);
-    return resp;
-  };
-  const placeDomino2 = (game, lordId, position, orientation, rotation) => {
-    const updatedGame = place2({
-      lordId,
-      action: "place",
-      data: {
-        state: game,
-        position,
-        orientation,
-        rotation
-      }
-    });
-    const resp = defineNextAction(updatedGame, "place", lordId);
-    return resp;
-  };
-  const pickDomino = (game, lordId, dominoPick) => {
-    const updatedGame = pick2({
-      lordId,
-      action: "pick",
-      data: {
-        state: game,
-        dominoPick
-      }
-    });
-    const resp = defineNextAction(updatedGame, "pick", lordId);
-    return resp;
-  };
-  const prepareNextTurn = (game) => {
-    const updatedOrder = definePlayerOrder2({ state: game });
-    const updateDraw = draw2({ state: updatedOrder });
-    const updateTurn = startTurn2({ state: updateDraw });
-    if (updateTurn.game.turn > updateTurn.game.maxTurns) {
-      throw new Error("Game is over");
+  if (!canPlaceAndDominoPickedIsDefined(currentLord)) {
+    return err("Lord can't place");
+  }
+  const domino = currentLord.dominoPicked;
+  const currentPlayer = game.players.find(
+    (player) => player.id === currentLord.playerId
+  );
+  if (!currentPlayer) {
+    return err("Player not found");
+  }
+  const updatedKingdom = placeDomino(
+    currentPlayer.kingdom,
+    position,
+    orientation,
+    rotation,
+    domino
+  );
+  if (isErr(updatedKingdom)) {
+    return updatedKingdom;
+  }
+  const updatedPlayers = game.players.map((player) => {
+    if (player.id === currentPlayer.id) {
+      player.kingdom = updatedKingdom.value;
     }
-    return updateTurn.game;
-  };
-  const defineNextAction = (game, currentAction, currentLordId) => {
-    const { lords, turn } = game;
-    if (turn === 0) {
-      const nextLord2 = lords.find((lord) => !lord.hasPick);
-      if (!nextLord2) {
-        const newState = prepareNextTurn(game);
+    return player;
+  });
+  const maxTurns = game.rules.basic.maxTurns;
+  const currentTurn = game.turn;
+  const isLastTurn = currentTurn === maxTurns;
+  const updatedLords = game.lords.map((lord) => {
+    if (lord.id === currentLord.id) {
+      if (isLastTurn) {
         return {
-          nextLord: newState.lords[0].id,
-          nextAction: "place",
-          game: newState
+          ...lord,
+          turnEnded: true,
+          hasPlace: true
         };
       }
       return {
-        nextLord: nextLord2.id,
-        nextAction: "pick",
-        game
+        ...lord,
+        hasPlace: true
       };
     }
-    if (currentAction === "place" || currentAction === "pass") {
-      if (game.turn === game.maxTurns) {
-        const nextLord2 = lords.find((lord) => !lord.hasPlace);
-        if (!nextLord2) {
-          return {
-            nextLord: "none",
-            nextAction: "end",
-            game
-          };
-        }
-        return {
-          nextLord: nextLord2.id,
-          nextAction: "place",
-          game
-        };
-      }
-      return {
-        nextLord: currentLordId,
-        nextAction: "pick",
-        game
-      };
+    return lord;
+  });
+  let updatedGame;
+  const resultStep = {
+    type: "step",
+    step: gameSteps.result
+  };
+  if (isLastTurn && allLordsHavePlayed(updatedLords)) {
+    updatedGame = {
+      ...game,
+      lords: updatedLords,
+      nextAction: resultStep
+    };
+  } else {
+    updatedGame = {
+      ...game,
+      lords: updatedLords,
+      nextAction: nextLordWithAction(updatedLords)
+    };
+  }
+  return ok(updatedGame);
+};
+
+// src/core/useCases/startGame.ts
+var startGameUseCase = (deps) => (game) => {
+  const { uuidMethod: uuidMethod2, shuffleMethod: shuffleMethod2 } = deps;
+  const {
+    rules: {
+      basic: { lords: maxLords, dominoesPerTurn }
+    },
+    players,
+    dominoes
+  } = game;
+  const numberOfPlayers = players.length;
+  const newLords = [];
+  for (let i2 = 0; i2 < numberOfPlayers; i2++) {
+    for (let j = 0; j < maxLords; j++) {
+      const lord = createLord(uuidMethod2(), players[i2].id);
+      newLords.push(lord);
     }
-    const allLordsHavePicked = lords.every((lord) => lord.hasPick);
-    if (allLordsHavePicked) {
-      const newState = prepareNextTurn(game);
+  }
+  const shuffledLords = shuffleMethod2(newLords);
+  const dominoesCopy = [...dominoes];
+  const dominoesDrawn = dominoesCopy.splice(0, dominoesPerTurn);
+  dominoesDrawn.sort((a2, b2) => a2.number - b2.number);
+  const nextAction = {
+    type: "action",
+    nextLord: shuffledLords[0].id,
+    nextAction: playerActions.pickDomino
+  };
+  const newState = {
+    ...game,
+    lords: shuffledLords,
+    nextAction,
+    dominoes: dominoesCopy,
+    currentDominoes: dominoesDrawn.map((domino, index) => {
       return {
-        nextLord: newState.order["1"],
-        nextAction: "place",
-        game: newState
+        domino,
+        picked: false,
+        lordId: null,
+        position: index + 1
       };
-    }
-    const nextLord = lords.find((lord) => !lord.hasPlace);
-    return {
-      nextLord: nextLord.id,
-      nextAction: "place",
-      game
-    };
-  };
-  const endGame = (game) => {
-    const players = game.players;
-    const scores = [];
-    for (let player of players) {
-      const score = calculateScore2(player.kingdom);
-      scores.push({
-        playerId: player.id,
-        playerName: player.name,
-        details: score
-      });
-    }
-    const finalResult = result(scores);
-    return {
-      result: finalResult,
-      game
-    };
+    })
   };
+  return ok(newState);
+};
+
+// src/adapterServerside/shuffle.ts
+var shuffleMethod = (array) => {
+  for (let i2 = array.length - 1; i2 > 0; i2--) {
+    const j = Math.floor(Math.random() * (i2 + 1));
+    [array[i2], array[j]] = [array[j], array[i2]];
+  }
+  return array;
+};
+
+// src/adapterServerside/uuid.ts
+import { randomUUID } from "crypto";
+var uuidMethod = () => {
+  return randomUUID();
+};
+
+// src/config.ts
+var configureEngine = (config) => {
+  const modeRepository = config.modeRepository || jsonModes_default();
+  const dominoesRepository = config.dominoesRepository || jsonDominoes_default();
+  const ruleRepository = config.ruleRepository || jsonRules_default();
+  const uuid = config.uuidMethod || uuidMethod;
+  const shuffle = config.shuffleMethod || shuffleMethod;
   return {
-    init: init2,
-    getMode,
-    setMode,
-    getRules,
-    setRules,
-    start,
-    pass: passTurn,
-    placeDomino: placeDomino2,
-    pickDomino,
-    endGame
+    createGameHandler: createGameHandler(
+      createGameUseCase({
+        modeRepository,
+        dominoesRepository,
+        uuidMethod: uuid
+      })
+    ),
+    getModesHandler: getModesHandler(getModesUseCase({ modeRepository })),
+    getExtraRulesHandler: getExtraRulesHandler(
+      getExtraRulesUseCase({ ruleRepository })
+    ),
+    addPlayersHandler: addPlayersHandler(
+      addPlayersUseCase({
+        uuidMethod: uuid,
+        shuffleMethod: shuffle,
+        ruleRepository
+      })
+    ),
+    addExtraRulesHandler: addExtraRulesHandler(
+      addExtraRulesUseCase({ ruleRepository })
+    ),
+    startGameHandler: startGameHandler(
+      startGameUseCase({ uuidMethod: uuid, shuffleMethod: shuffle })
+    ),
+    chooseDominoHandler: chooseDominoHandler(chooseDominoUseCase),
+    placeDominoHandler: placeDominoHandler(placeDominoUseCase),
+    discardDominoHandler: discardDominoHandler(discardDominoUseCase),
+    getResultHandler: getResultHandler(getResultUseCase)
   };
 };
-var driver_default = gameEngine;
 
 // src/index.ts
-var src_default = driver_default;
+var createGameEngine = (config) => {
+  const {
+    createGameHandler: createGameHandler2,
+    getModesHandler: getModesHandler2,
+    getExtraRulesHandler: getExtraRulesHandler2,
+    addPlayersHandler: addPlayersHandler2,
+    addExtraRulesHandler: addExtraRulesHandler2,
+    startGameHandler: startGameHandler2,
+    chooseDominoHandler: chooseDominoHandler2,
+    placeDominoHandler: placeDominoHandler2,
+    discardDominoHandler: discardDominoHandler2,
+    getResultHandler: getResultHandler2
+  } = configureEngine(config);
+  return {
+    getModes: (command) => getModesHandler2(command),
+    getExtraRules: (command) => getExtraRulesHandler2(command),
+    createGame: (command) => createGameHandler2(command),
+    addPlayers: (command) => addPlayersHandler2(command),
+    addExtraRules: (command) => addExtraRulesHandler2(command),
+    startGame: (command) => startGameHandler2(command),
+    chooseDomino: (command) => chooseDominoHandler2(command),
+    placeDomino: (command) => placeDominoHandler2(command),
+    discardDomino: (command) => discardDominoHandler2(command),
+    getResults: (command) => getResultHandler2(command)
+  };
+};
+var engine = createGameEngine({});
+var a = engine.createGame({ mode: "standard" });
+var b = engine.getModes({});
+var c = engine.getExtraRules({ mode: "standard", players: 2 });
+var d = engine.addPlayers({ game: a, players: ["player1"] });
+var e = engine.addExtraRules({ game: d, extraRules: ["rule1"] });
+var f = engine.startGame({ game: e });
+var g = engine.chooseDomino({
+  game: f,
+  lordId: "player1",
+  dominoPick: 1
+});
+var h = engine.discardDomino({ game: g, lordId: "player1" });
+var i = engine.placeDomino({
+  game: g,
+  lordId: "player1",
+  position: { x: 1, y: 1 },
+  orientation: "horizontal",
+  rotation: 0
+});
+if (isGameWithNextAction(i)) {
+  const j = engine.chooseDomino({
+    game: i,
+    lordId: "player1",
+    dominoPick: 1
+  });
+}
+if (!isGameWithNextAction(i)) {
+  const j = engine.getResults({ game: i });
+}
 export {
-  src_default as default
+  createGameEngine
 };
 //# sourceMappingURL=index.js.map