@pompidup/kingdomino-engine 2.0.1 → 2.0.5

package/dist/index.js

@@ -658,6 +658,61 @@ var jsonRules = () => {
 };
 var jsonRules_default = jsonRules;
 
+// src/adapterServerside/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]];
+  }
+  return array;
+};
+
+// src/adapterServerside/uuid.ts
+import { randomUUID } from "crypto";
+var uuidMethod = () => {
+  return randomUUID();
+};
+
+// src/core/domain/errors/domainErrors.ts
+var InvalidStepError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidStepError";
+  }
+};
+var StepExecutionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StepExecutionError";
+  }
+};
+var ActionExecutionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ActionExecutionError";
+  }
+};
+var NotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NotFoundError";
+  }
+};
+
+// src/core/domain/types/game.ts
+var gameSteps = {
+  addPlayers: "addPlayers",
+  options: "options",
+  start: "start",
+  result: "result"
+};
+var isGameWithNextAction = (game) => {
+  return game.nextAction.type === "action";
+};
+var isGameWithNextStep = (game) => {
+  return game.nextAction.type === "step";
+};
+
 // src/utils/result.ts
 var ok = (value) => ({ tag: "Ok", value });
 var err = (error) => ({ tag: "Err", error });
@@ -667,12 +722,15 @@ var isErr = (result) => result.tag === "Err";
 // src/application/handlers/addExtraRulesHandler.ts
 var addExtraRulesHandler = (useCase) => (command) => {
   const { game, extraRules } = command;
+  if (!isGameWithNextStep(game)) {
+    throw new InvalidStepError("Required game with nextAction type: 'step'");
+  }
   if (game.nextAction.step !== "options") {
-    throw new Error("Invalid next action");
+    throw new InvalidStepError("Required game with options step");
   }
   const result = useCase(game, extraRules);
   if (isErr(result)) {
-    throw new Error(result.error);
+    throw new StepExecutionError(result.error);
   }
   return result.value;
 };
@@ -680,12 +738,15 @@ var addExtraRulesHandler = (useCase) => (command) => {
 // src/application/handlers/addPlayersHandler.ts
 var addPlayersHandler = (useCase) => (command) => {
   const { game, players } = command;
+  if (!isGameWithNextStep(game)) {
+    throw new InvalidStepError("Required game with nextAction type: 'step'");
+  }
   if (game.nextAction.step !== "addPlayers") {
-    throw new Error("Invalid next action");
+    throw new InvalidStepError("Required game with addPlayers step");
   }
   const result = useCase(game, players);
   if (isErr(result)) {
-    throw new Error(result.error);
+    throw new StepExecutionError(result.error);
   }
   return result.value;
 };
@@ -693,12 +754,17 @@ var addPlayersHandler = (useCase) => (command) => {
 // src/application/handlers/chooseDominoHandler.ts
 var chooseDominoHandler = (useCase) => (command) => {
   const { game, lordId, dominoPick } = command;
+  if (!isGameWithNextAction(game)) {
+    throw new InvalidStepError(
+      "Required game with nextAction type: 'action'"
+    );
+  }
   if (game.nextAction.nextAction !== "pickDomino") {
-    throw new Error("Invalid next action");
+    throw new InvalidStepError("Required game with pickDomino action");
   }
   const result = useCase(game, lordId, dominoPick);
   if (isErr(result)) {
-    throw new Error(result.error);
+    throw new ActionExecutionError(result.error);
   }
   return result.value;
 };
@@ -707,31 +773,25 @@ var chooseDominoHandler = (useCase) => (command) => {
 var createGameHandler = (useCase) => (command) => {
   const result = useCase(command.mode);
   if (isErr(result)) {
-    throw new Error(result.error);
+    throw new StepExecutionError(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 (!isGameWithNextAction(game)) {
+    throw new InvalidStepError(
+      "Required game with nextAction type: 'action'"
+    );
+  }
   if (game.nextAction.nextAction !== "placeDomino") {
-    throw new Error("Invalid next action");
+    throw new InvalidStepError("Required game with placeDomino action");
   }
   const result = useCase(game, lordId);
   if (isErr(result)) {
-    throw new Error(result.error);
+    throw new ActionExecutionError(result.error);
   }
   if (isGameWithNextAction(result.value)) {
     return result.value;
@@ -744,7 +804,7 @@ var getExtraRulesHandler = (getExtraRulesUseCase2) => (command) => {
   const { mode, players } = command;
   const result = getExtraRulesUseCase2(mode, players);
   if (isErr(result)) {
-    throw new Error(result.error);
+    throw new NotFoundError(result.error);
   }
   return result.value;
 };
@@ -753,7 +813,7 @@ var getExtraRulesHandler = (getExtraRulesUseCase2) => (command) => {
 var getModesHandler = (getModeUseCase) => (_command) => {
   const result = getModeUseCase();
   if (isErr(result)) {
-    throw new Error(result.error);
+    throw new NotFoundError(result.error);
   }
   return result.value;
 };
@@ -761,12 +821,15 @@ var getModesHandler = (getModeUseCase) => (_command) => {
 // src/application/handlers/getResultHandler.ts
 var getResultHandler = (useCase) => (command) => {
   const { game } = command;
+  if (!isGameWithNextStep(game)) {
+    throw new InvalidStepError("Required game with nextAction type: 'step'");
+  }
   if (game.nextAction.step !== "result") {
-    throw new Error("Invalid next step");
+    throw new InvalidStepError("Required game with result step");
   }
   const result = useCase(game);
   if (isErr(result)) {
-    throw new Error(result.error);
+    throw new NotFoundError(result.error);
   }
   return result.value;
 };
@@ -774,12 +837,17 @@ var getResultHandler = (useCase) => (command) => {
 // src/application/handlers/placeDominoHandler.ts
 var placeDominoHandler = (useCase) => (command) => {
   const { game, lordId, position, orientation, rotation } = command;
+  if (!isGameWithNextAction(game)) {
+    throw new InvalidStepError(
+      "Required game with nextAction type: 'action'"
+    );
+  }
   if (game.nextAction.nextAction !== "placeDomino") {
-    throw new Error("Invalid next action");
+    throw new InvalidStepError("Required game with placeDomino step");
   }
   const result = useCase(game, lordId, position, orientation, rotation);
   if (isErr(result)) {
-    throw new Error(result.error);
+    throw new ActionExecutionError(result.error);
   }
   if (isGameWithNextAction(result.value)) {
     return result.value;
@@ -790,12 +858,17 @@ var placeDominoHandler = (useCase) => (command) => {
 // src/application/handlers/startGameHandler.ts
 var startGameHandler = (useCase) => (command) => {
   const { game } = command;
-  if (game.nextAction.step !== "start") {
-    throw new Error("Invalid next action");
+  if (!isGameWithNextStep(game)) {
+    throw new InvalidStepError("Required game with nextAction type: 'step'");
+  }
+  if (game.nextAction.step !== "start" && game.nextAction.step !== "options") {
+    throw new InvalidStepError(
+      "Required game with start step or options step"
+    );
   }
   const result = useCase(game);
   if (isErr(result)) {
-    throw new Error(result.error);
+    throw new StepExecutionError(result.error);
   }
   return result.value;
 };
@@ -867,26 +940,6 @@ var addExtraRulesUseCase = (deps) => (game, rules) => {
   return ok(updatedGame);
 };
 
-// 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);
@@ -1120,6 +1173,26 @@ var deepCopyKingdom = (kingdom) => {
   return kingdom.map((line) => line.map((tile) => ({ ...tile })));
 };
 
+// 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/useCases/addPlayers.ts
 var addPlayersUseCase = (deps) => (game, players) => {
   const { uuidMethod: uuidMethod2, shuffleMethod: shuffleMethod2, ruleRepository } = deps;
@@ -1186,8 +1259,8 @@ 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;
+  return lords.sort((a, b) => {
+    return a.dominoPicked.number - b.dominoPicked.number;
   });
 };
 var resetLordsActions = (lord) => {
@@ -1266,7 +1339,7 @@ var chooseDominoUseCase = (game, lordId, dominoPick) => {
       0,
       game.rules.basic.dominoesPerTurn
     );
-    dominoesDrawn.sort((a2, b2) => a2.number - b2.number);
+    dominoesDrawn.sort((a, b) => a.number - b.number);
     const updatedCurrentDominoes2 = dominoesDrawn.map((domino, index) => {
       return {
         domino,
@@ -1533,14 +1606,14 @@ var getResultUseCase = (game) => {
       }
     };
   });
-  scores.sort((a2, b2) => {
-    if (a2.details.points !== b2.details.points) {
-      return b2.details.points - a2.details.points;
+  scores.sort((a, b) => {
+    if (a.details.points !== b.details.points) {
+      return b.details.points - a.details.points;
     }
-    if (a2.details.maxPropertiesSize !== b2.details.maxPropertiesSize) {
-      return b2.details.maxPropertiesSize - a2.details.maxPropertiesSize;
+    if (a.details.maxPropertiesSize !== b.details.maxPropertiesSize) {
+      return b.details.maxPropertiesSize - a.details.maxPropertiesSize;
     }
-    return b2.details.totalCrowns - a2.details.totalCrowns;
+    return b.details.totalCrowns - a.details.totalCrowns;
   });
   const result = [];
   let isTie = false;
@@ -1550,21 +1623,21 @@ var getResultUseCase = (game) => {
     details: scores[0].details,
     position: 1
   });
-  for (let i2 = 1; i2 < scores.length; i2++) {
-    const currentScore = scores[i2];
-    const previousScore = scores[i2 - 1];
+  for (let i = 1; i < scores.length; i++) {
+    const currentScore = scores[i];
+    const previousScore = scores[i - 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) {
       result.push({
         ...currentScore,
-        position: result[i2 - 1].position
+        position: result[i - 1].position
       });
     } else {
       result.push({
         ...currentScore,
-        position: i2 + 1
+        position: i + 1
       });
     }
     isTie = false;
@@ -1641,13 +1714,15 @@ var placeDominoUseCase = (game, lordId, position, orientation, rotation) => {
     updatedGame = {
       ...game,
       lords: updatedLords,
-      nextAction: resultStep
+      nextAction: resultStep,
+      players: updatedPlayers
     };
   } else {
     updatedGame = {
       ...game,
       lords: updatedLords,
-      nextAction: nextLordWithAction(updatedLords)
+      nextAction: nextLordWithAction(updatedLords),
+      players: updatedPlayers
     };
   }
   return ok(updatedGame);
@@ -1665,16 +1740,16 @@ var startGameUseCase = (deps) => (game) => {
   } = game;
   const numberOfPlayers = players.length;
   const newLords = [];
-  for (let i2 = 0; i2 < numberOfPlayers; i2++) {
+  for (let i = 0; i < numberOfPlayers; i++) {
     for (let j = 0; j < maxLords; j++) {
-      const lord = createLord(uuidMethod2(), players[i2].id);
+      const lord = createLord(uuidMethod2(), players[i].id);
       newLords.push(lord);
     }
   }
   const shuffledLords = shuffleMethod2(newLords);
   const dominoesCopy = [...dominoes];
   const dominoesDrawn = dominoesCopy.splice(0, dominoesPerTurn);
-  dominoesDrawn.sort((a2, b2) => a2.number - b2.number);
+  dominoesDrawn.sort((a, b) => a.number - b.number);
   const nextAction = {
     type: "action",
     nextLord: shuffledLords[0].id,
@@ -1697,26 +1772,11 @@ var startGameUseCase = (deps) => (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 modeRepository = jsonModes_default();
+  const dominoesRepository = jsonDominoes_default();
+  const ruleRepository = jsonRules_default();
   const uuid = config.uuidMethod || uuidMethod;
   const shuffle = config.shuffleMethod || shuffleMethod;
   return {
@@ -1778,36 +1838,6 @@ var createGameEngine = (config) => {
     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 {
   createGameEngine
 };