@pompidup/kingdomino-engine 2.3.0 → 3.1.0

package/dist/index.js

@@ -673,73 +673,132 @@ var uuidMethod = () => {
   return randomUUID();
 };
 
-// src/adapterServerside/winstonLogger.ts
-import winston from "winston";
-var winstonLogger = (isLoggingEnabled) => {
-  const myFormat = winston.format.printf(
-    ({ level, message, label, timestamp }) => {
-      return `${timestamp} [${label}] ${level}: ${message}`;
-    }
-  );
-  const logger = winston.createLogger({
-    level: "info",
-    format: winston.format.combine(
-      winston.format.label({ label: "KDomino_Engine" }),
-      winston.format.timestamp(),
-      winston.format.simple(),
-      winston.format.json(),
-      winston.format.colorize(),
-      myFormat
-    ),
-    transports: [new winston.transports.Console()]
-  });
+// src/adapterServerside/consoleLogger.ts
+var consoleLogger = (isLoggingEnabled) => {
+  const formatMessage = (level, message) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    return `${timestamp} [KDomino_Engine] ${level}: ${message}`;
+  };
   return {
     info: (message) => {
       if (isLoggingEnabled) {
-        logger.info(message);
+        console.log(formatMessage("info", message));
       }
-      return void 0;
     },
     error: (message) => {
       if (isLoggingEnabled) {
-        logger.error(message);
+        console.error(formatMessage("error", message));
       }
-      return void 0;
     }
   };
 };
+var silentLogger = {
+  info: () => {
+  },
+  error: () => {
+  }
+};
 
 // src/core/domain/errors/domainErrors.ts
-var InvalidStepError = class extends Error {
-  constructor(message) {
-    super(message);
+var ErrorCode = {
+  // Game flow errors
+  INVALID_STEP: "INVALID_STEP",
+  STEP_EXECUTION_FAILED: "STEP_EXECUTION_FAILED",
+  ACTION_EXECUTION_FAILED: "ACTION_EXECUTION_FAILED",
+  // Entity not found errors
+  LORD_NOT_FOUND: "LORD_NOT_FOUND",
+  PLAYER_NOT_FOUND: "PLAYER_NOT_FOUND",
+  DOMINO_NOT_FOUND: "DOMINO_NOT_FOUND",
+  MODE_NOT_FOUND: "MODE_NOT_FOUND",
+  // Validation errors
+  INVALID_PLAYER_COUNT: "INVALID_PLAYER_COUNT",
+  INVALID_PLAYER_NAME: "INVALID_PLAYER_NAME",
+  INVALID_PLACEMENT: "INVALID_PLACEMENT",
+  PLACEMENT_NOT_EMPTY: "PLACEMENT_NOT_EMPTY",
+  PLACEMENT_NOT_ADJACENT: "PLACEMENT_NOT_ADJACENT",
+  PLACEMENT_INVALID_TERRAIN: "PLACEMENT_INVALID_TERRAIN",
+  PLACEMENT_OUT_OF_BOUNDS: "PLACEMENT_OUT_OF_BOUNDS",
+  // Action errors
+  NOT_YOUR_TURN: "NOT_YOUR_TURN",
+  CANNOT_PICK: "CANNOT_PICK",
+  CANNOT_PLACE: "CANNOT_PLACE",
+  DOMINO_ALREADY_PICKED: "DOMINO_ALREADY_PICKED"
+};
+var createDomainError = (code, message, context) => ({
+  code,
+  message,
+  context
+});
+var DomainException = class extends Error {
+  code;
+  context;
+  constructor(error) {
+    super(error.message);
+    this.name = "DomainException";
+    this.code = error.code;
+    this.context = error.context;
+  }
+};
+var InvalidStepError = class extends DomainException {
+  constructor(message, context) {
+    super({
+      code: ErrorCode.INVALID_STEP,
+      message,
+      context
+    });
     this.name = "InvalidStepError";
   }
 };
-var StepExecutionError = class extends Error {
-  constructor(message) {
-    super(message);
+var StepExecutionError = class extends DomainException {
+  constructor(message, context) {
+    super({
+      code: ErrorCode.STEP_EXECUTION_FAILED,
+      message,
+      context
+    });
     this.name = "StepExecutionError";
   }
 };
-var ActionExecutionError = class extends Error {
-  constructor(message) {
-    super(message);
+var ActionExecutionError = class extends DomainException {
+  constructor(message, code = ErrorCode.ACTION_EXECUTION_FAILED, context) {
+    super({
+      code,
+      message,
+      context
+    });
     this.name = "ActionExecutionError";
   }
 };
-var NotFoundError = class extends Error {
-  constructor(message) {
-    super(message);
+var NotFoundError = class extends DomainException {
+  constructor(message, code = ErrorCode.LORD_NOT_FOUND, context) {
+    super({
+      code,
+      message,
+      context
+    });
     this.name = "NotFoundError";
   }
 };
+var ValidationError = class extends DomainException {
+  constructor(message, code, context) {
+    super({
+      code,
+      message,
+      context
+    });
+    this.name = "ValidationError";
+  }
+};
 
 // src/core/domain/types/game.ts
 var gameSteps = {
+  /** Waiting for players to be added */
   addPlayers: "addPlayers",
+  /** Optional rules selection phase */
   options: "options",
+  /** Ready to start the game */
   start: "start",
+  /** Game has ended, results available */
   result: "result"
 };
 var isGameWithNextAction = (game) => {
@@ -754,6 +813,12 @@ var ok = (value) => ({ tag: "Ok", value });
 var err = (error) => ({ tag: "Err", error });
 var isOk = (result) => result.tag === "Ok";
 var isErr = (result) => result.tag === "Err";
+var unwrap = (result) => {
+  if (result.tag === "Err") {
+    throw result.error;
+  }
+  return result.value;
+};
 
 // src/application/handlers/addExtraRulesHandler.ts
 var addExtraRulesHandler = (logger, useCase) => (command) => {
@@ -952,11 +1017,11 @@ var getResultHandler = (logger, useCases) => (command) => {
 
 // src/application/handlers/placeDominoHandler.ts
 var placeDominoHandler = (logger, useCase) => (command) => {
-  const { game, lordId, position, orientation, rotation } = command;
+  const { game, lordId, position, rotation } = command;
   logger.info(
     `Placing domino: ${lordId} in position: ${JSON.stringify(
       position
-    )} with orientation: ${orientation} and rotation: ${rotation} in game: ${game.id}`
+    )} with rotation: ${rotation} in game: ${game.id}`
   );
   if (!isGameWithNextAction(game)) {
     logger.error(
@@ -972,7 +1037,7 @@ var placeDominoHandler = (logger, useCase) => (command) => {
     );
     throw new InvalidStepError("Required game with placeDomino step");
   }
-  const result = useCase(game, lordId, position, orientation, rotation);
+  const result = useCase(game, lordId, position, rotation);
   if (isErr(result)) {
     logger.error(`Error placing domino: ${result.error}`);
     throw new ActionExecutionError(result.error);
@@ -981,14 +1046,14 @@ var placeDominoHandler = (logger, useCase) => (command) => {
     logger.info(
       `Domino placed: ${lordId} in position: ${JSON.stringify(
         position
-      )} with orientation: ${orientation} and rotation: ${rotation} in game: ${game.id}`
+      )} with rotation: ${rotation} in game: ${game.id}`
     );
     return result.value;
   }
   logger.info(
     `Domino placed: ${lordId} in position: ${JSON.stringify(
       position
-    )} with orientation: ${orientation} and rotation: ${rotation} in game: ${game.id}`
+    )} with rotation: ${rotation} in game: ${game.id}`
   );
   return result.value;
 };
@@ -1049,57 +1114,14 @@ var GROUND = [
 
 // src/core/domain/types/player.ts
 var playerActions = {
+  /** Place a previously picked domino on the kingdom */
   placeDomino: "placeDomino",
+  /** Pick a domino from the revealed set */
   pickDomino: "pickDomino",
+  /** Pass/discard when no valid placement exists */
   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 ok(updatedGame);
-};
-
 // src/core/domain/entities/domino.ts
 var isGround = (ground) => {
   return GROUND.includes(ground);
@@ -1114,11 +1136,10 @@ var createTile = (ground, crowns = 0) => {
 // src/core/domain/entities/kingdom.ts
 var createEmptyKingdom = () => {
   const emptyTile = createTile("empty");
-  const grid = Array.from(
+  return Array.from(
     { length: GRIDSIZE },
     () => Array.from({ length: GRIDSIZE }, () => emptyTile)
   );
-  return grid;
 };
 var placeCastle = (kingdom) => {
   const castle = createTile("castle");
@@ -1138,11 +1159,11 @@ var getTile = (kingdom, position) => {
   }
   return ok(tile);
 };
-var calculateDominoPosition = (position, orientation, rotation, domino) => {
+var calculateDominoPosition = (position, rotation, domino) => {
   let firstTile;
   let secondTile;
-  if (orientation === "horizontal") {
-    if (rotation === 0) {
+  switch (rotation) {
+    case 0:
       firstTile = {
         tile: domino.left,
         position: {
@@ -1157,39 +1178,40 @@ var calculateDominoPosition = (position, orientation, rotation, domino) => {
           y: position.y
         }
       };
-    } else {
+      break;
+    case 90:
       firstTile = {
-        tile: domino.right,
+        tile: domino.left,
         position: {
           x: position.x,
           y: position.y
         }
       };
       secondTile = {
-        tile: domino.left,
+        tile: domino.right,
         position: {
-          x: position.x + 1,
-          y: position.y
+          x: position.x,
+          y: position.y + 1
         }
       };
-    }
-  } else {
-    if (rotation === 0) {
+      break;
+    case 180:
       firstTile = {
-        tile: domino.left,
+        tile: domino.right,
         position: {
           x: position.x,
           y: position.y
         }
       };
       secondTile = {
-        tile: domino.right,
+        tile: domino.left,
         position: {
-          x: position.x,
-          y: position.y + 1
+          x: position.x + 1,
+          y: position.y
         }
       };
-    } else {
+      break;
+    case 270:
       firstTile = {
         tile: domino.right,
         position: {
@@ -1204,14 +1226,13 @@ var calculateDominoPosition = (position, orientation, rotation, domino) => {
           y: position.y + 1
         }
       };
-    }
+      break;
   }
   return [firstTile, secondTile];
 };
-var placeDomino = (kingdom, position, orientation, rotation, domino) => {
+var placeDomino = (kingdom, position, rotation, domino) => {
   const [firstTile, secondTile] = calculateDominoPosition(
     position,
-    orientation,
     rotation,
     domino
   );
@@ -1307,32 +1328,207 @@ var hasValidAdjacent = (adjacentTiles, tiles) => {
   });
 };
 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;
+  let castleX;
+  let castleY;
+  for (let y = 0; y < kingdom.length; y++) {
+    const x = kingdom[y].findIndex((tile) => tile.type === "castle");
+    if (x !== -1) {
+      castleX = x;
+      castleY = y;
+      break;
+    }
+  }
+  if (castleX === void 0 || castleY === void 0) {
+    return false;
+  }
+  const leftTilesCount = kingdom[castleY].slice(0, castleX).filter((tile) => tile.type !== "empty").length;
+  const rightTilesCount = kingdom[castleY].slice(castleX + 1).filter((tile) => tile.type !== "empty").length;
+  let topTilesCount = 0;
+  for (let y = 0; y < castleY; y++) {
+    if (kingdom[y][castleX].type !== "empty") {
+      topTilesCount++;
+    }
+  }
+  let bottomTilesCount = 0;
+  for (let y = castleY + 1; y < kingdom.length; y++) {
+    if (kingdom[y][castleX].type !== "empty") {
+      bottomTilesCount++;
+    }
+  }
   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;
+  return (notEmpties.length - 1) / 2;
 };
 var deepCopyKingdom = (kingdom) => {
   return kingdom.map((line) => line.map((tile) => ({ ...tile })));
 };
 
+// src/core/useCases/getValidPlacements.ts
+var getValidPlacementsUseCase = (kingdom, domino) => {
+  const validPlacements = [];
+  const rotations = [0, 90, 180, 270];
+  for (let y = 0; y < GRIDSIZE; y++) {
+    for (let x = 0; x < GRIDSIZE; x++) {
+      const position = { x, y };
+      for (const rotation of rotations) {
+        const result = placeDomino(kingdom, position, rotation, domino);
+        if (isOk(result)) {
+          validPlacements.push({ position, rotation });
+        }
+      }
+    }
+  }
+  return validPlacements;
+};
+var canPlaceDominoUseCase = (kingdom, domino) => {
+  const rotations = [0, 90, 180, 270];
+  for (let y = 0; y < GRIDSIZE; y++) {
+    for (let x = 0; x < GRIDSIZE; x++) {
+      const position = { x, y };
+      for (const rotation of rotations) {
+        const result = placeDomino(kingdom, position, rotation, domino);
+        if (isOk(result)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+};
+
+// src/application/handlers/getValidPlacementsHandler.ts
+var getValidPlacementsHandler = (logger) => {
+  return (command) => {
+    logger.info(`Getting valid placements for domino: ${command.domino.number}`);
+    const placements = getValidPlacementsUseCase(command.kingdom, command.domino);
+    logger.info(`Found ${placements.length} valid placements`);
+    return placements;
+  };
+};
+
+// src/application/handlers/canPlaceDominoHandler.ts
+var canPlaceDominoHandler = (logger) => {
+  return (command) => {
+    logger.info(`Checking if domino ${command.domino.number} can be placed`);
+    const canPlace = canPlaceDominoUseCase(command.kingdom, command.domino);
+    logger.info(`Can place domino: ${canPlace}`);
+    return canPlace;
+  };
+};
+
+// src/core/useCases/serialization.ts
+var SERIALIZATION_VERSION = 1;
+var serializeGame = (game) => {
+  const serialized = {
+    version: SERIALIZATION_VERSION,
+    data: game,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return JSON.stringify(serialized);
+};
+var deserializeGame = (json) => {
+  try {
+    const parsed = JSON.parse(json);
+    if (!parsed.version || !parsed.data) {
+      return err("Invalid serialized game format");
+    }
+    if (parsed.version > SERIALIZATION_VERSION) {
+      return err(
+        `Unsupported serialization version: ${parsed.version}. Current version: ${SERIALIZATION_VERSION}`
+      );
+    }
+    const game = parsed.data;
+    if (!game.id || !game.players || !game.lords || !game.nextAction) {
+      return err("Invalid game state structure");
+    }
+    return ok(game);
+  } catch (error) {
+    return err(`Failed to parse game JSON: ${error.message}`);
+  }
+};
+var createSavePoint = (game) => {
+  return {
+    serialized: serializeGame(game),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    gameId: game.id,
+    turn: game.turn
+  };
+};
+var restoreFromSavePoint = (savePoint) => {
+  return deserializeGame(savePoint.serialized);
+};
+
+// src/application/handlers/serializeGameHandler.ts
+var serializeGameHandler = (logger) => {
+  return (command) => {
+    logger.info(`Serializing game: ${command.game.id}`);
+    const serialized = serializeGame(command.game);
+    logger.info(`Game serialized successfully`);
+    return serialized;
+  };
+};
+var deserializeGameHandler = (logger) => {
+  return (command) => {
+    logger.info(`Deserializing game from JSON`);
+    const result = deserializeGame(command.json);
+    if (isErr(result)) {
+      logger.error(`Failed to deserialize game: ${result.error}`);
+      throw new StepExecutionError(result.error);
+    }
+    const game = unwrap(result);
+    logger.info(`Game deserialized successfully: ${game.id}`);
+    return game;
+  };
+};
+
+// 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 ok(updatedGame);
+};
+
 // src/core/domain/entities/player.ts
 var MINPLAYERSNAMELENGTH = 3;
 var validatePlayer = (name) => {
@@ -1740,7 +1936,7 @@ var getResultUseCase = (game, scoreResult) => {
 };
 
 // src/core/useCases/placeDomino.ts
-var placeDominoUseCase = (game, lordId, position, orientation, rotation) => {
+var placeDominoUseCase = (game, lordId, position, rotation) => {
   const nextAction = game.nextAction;
   const currentLord = game.lords.find(
     (lord) => lord.id === nextAction.nextLord
@@ -1764,7 +1960,6 @@ var placeDominoUseCase = (game, lordId, position, orientation, rotation) => {
   const updatedKingdom = placeDomino(
     currentPlayer.kingdom,
     position,
-    orientation,
     rotation,
     domino
   );
@@ -1946,7 +2141,7 @@ var configureEngine = (config) => {
   const ruleRepository = jsonRules_default();
   const uuid = config.uuidMethod || uuidMethod;
   const shuffle = config.shuffleMethod || shuffleMethod;
-  const logger = config.logging ? winstonLogger(true) : winstonLogger(false);
+  const logger = config.logger ? config.logger : config.logging ? consoleLogger(true) : silentLogger;
   return {
     createGameHandler: createGameHandler(
       logger,
@@ -1987,9 +2182,175 @@ var configureEngine = (config) => {
       getResultUseCase,
       calculateScoreUseCase
     }),
-    calculateScoreHandler: calculateScoreHandler(logger, calculateScoreUseCase)
+    calculateScoreHandler: calculateScoreHandler(logger, calculateScoreUseCase),
+    getValidPlacementsHandler: getValidPlacementsHandler(logger),
+    canPlaceDominoHandler: canPlaceDominoHandler(logger),
+    serializeGameHandler: serializeGameHandler(logger),
+    deserializeGameHandler: deserializeGameHandler(logger)
+  };
+};
+
+// src/core/events/gameEvents.ts
+var GameEventType = {
+  GAME_CREATED: "game:created",
+  PLAYERS_ADDED: "game:playersAdded",
+  GAME_STARTED: "game:started",
+  DOMINO_PICKED: "domino:picked",
+  DOMINO_PLACED: "domino:placed",
+  DOMINO_DISCARDED: "domino:discarded",
+  TURN_CHANGED: "turn:changed",
+  GAME_ENDED: "game:ended"
+};
+var GameEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  /**
+   * Subscribe to a specific event type.
+   *
+   * @param eventType - The event type to listen for, or "*" for all events
+   * @param listener - The callback function to invoke
+   * @returns Unsubscribe function
+   */
+  on(eventType, listener) {
+    const listeners = this.listeners.get(eventType) || [];
+    listeners.push(listener);
+    this.listeners.set(eventType, listeners);
+    return () => {
+      const currentListeners = this.listeners.get(eventType) || [];
+      const index = currentListeners.indexOf(listener);
+      if (index > -1) {
+        currentListeners.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * Emit an event to all registered listeners.
+   *
+   * @param event - The event to emit
+   */
+  emit(event) {
+    const typeListeners = this.listeners.get(event.type) || [];
+    typeListeners.forEach((listener) => listener(event));
+    const wildcardListeners = this.listeners.get("*") || [];
+    wildcardListeners.forEach((listener) => listener(event));
+  }
+  /**
+   * Remove all listeners for a specific event type or all listeners.
+   *
+   * @param eventType - Optional event type to clear, clears all if not provided
+   */
+  clear(eventType) {
+    if (eventType) {
+      this.listeners.delete(eventType);
+    } else {
+      this.listeners.clear();
+    }
+  }
+};
+var createEvent = (gameId, type, data) => {
+  return {
+    type,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    gameId,
+    ...data
+  };
+};
+
+// src/core/i18n/translations.ts
+var TranslationKey = {
+  // Error messages
+  ERROR_INVALID_STEP: "error.invalidStep",
+  ERROR_LORD_NOT_FOUND: "error.lordNotFound",
+  ERROR_PLAYER_NOT_FOUND: "error.playerNotFound",
+  ERROR_DOMINO_NOT_FOUND: "error.dominoNotFound",
+  ERROR_INVALID_PLACEMENT: "error.invalidPlacement",
+  ERROR_PLACEMENT_NOT_EMPTY: "error.placementNotEmpty",
+  ERROR_PLACEMENT_NOT_ADJACENT: "error.placementNotAdjacent",
+  ERROR_PLACEMENT_INVALID_TERRAIN: "error.placementInvalidTerrain",
+  ERROR_PLACEMENT_OUT_OF_BOUNDS: "error.placementOutOfBounds",
+  ERROR_NOT_YOUR_TURN: "error.notYourTurn",
+  ERROR_CANNOT_PICK: "error.cannotPick",
+  ERROR_CANNOT_PLACE: "error.cannotPlace",
+  ERROR_DOMINO_ALREADY_PICKED: "error.dominoAlreadyPicked",
+  ERROR_INVALID_PLAYER_COUNT: "error.invalidPlayerCount",
+  ERROR_INVALID_PLAYER_NAME: "error.invalidPlayerName",
+  // Game mode names
+  MODE_CLASSIC: "mode.classic",
+  // Extra rule names
+  RULE_MIDDLE_KINGDOM: "rule.middleKingdom",
+  RULE_HARMONY: "rule.harmony",
+  // Ground types
+  GROUND_CASTLE: "ground.castle",
+  GROUND_WHEAT: "ground.wheat",
+  GROUND_FOREST: "ground.forest",
+  GROUND_SEA: "ground.sea",
+  GROUND_PLAIN: "ground.plain",
+  GROUND_SWAMP: "ground.swamp",
+  GROUND_MINE: "ground.mine",
+  // Game phases
+  PHASE_ADD_PLAYERS: "phase.addPlayers",
+  PHASE_OPTIONS: "phase.options",
+  PHASE_START: "phase.start",
+  PHASE_RESULT: "phase.result",
+  // Actions
+  ACTION_PICK_DOMINO: "action.pickDomino",
+  ACTION_PLACE_DOMINO: "action.placeDomino",
+  ACTION_PASS: "action.pass"
+};
+var defaultTranslations = {
+  // Error messages
+  [TranslationKey.ERROR_INVALID_STEP]: "Invalid game step",
+  [TranslationKey.ERROR_LORD_NOT_FOUND]: "Lord not found",
+  [TranslationKey.ERROR_PLAYER_NOT_FOUND]: "Player not found",
+  [TranslationKey.ERROR_DOMINO_NOT_FOUND]: "Domino not found",
+  [TranslationKey.ERROR_INVALID_PLACEMENT]: "Invalid placement",
+  [TranslationKey.ERROR_PLACEMENT_NOT_EMPTY]: "Position is not empty",
+  [TranslationKey.ERROR_PLACEMENT_NOT_ADJACENT]: "Not adjacent to existing tiles",
+  [TranslationKey.ERROR_PLACEMENT_INVALID_TERRAIN]: "Terrain type does not match",
+  [TranslationKey.ERROR_PLACEMENT_OUT_OF_BOUNDS]: "Placement is out of bounds",
+  [TranslationKey.ERROR_NOT_YOUR_TURN]: "It is not your turn",
+  [TranslationKey.ERROR_CANNOT_PICK]: "Cannot pick a domino now",
+  [TranslationKey.ERROR_CANNOT_PLACE]: "Cannot place a domino now",
+  [TranslationKey.ERROR_DOMINO_ALREADY_PICKED]: "Domino has already been picked",
+  [TranslationKey.ERROR_INVALID_PLAYER_COUNT]: "Invalid number of players (2-4 required)",
+  [TranslationKey.ERROR_INVALID_PLAYER_NAME]: "Player name must be at least 3 characters",
+  // Game mode names
+  [TranslationKey.MODE_CLASSIC]: "Classic",
+  // Extra rule names
+  [TranslationKey.RULE_MIDDLE_KINGDOM]: "The Middle Kingdom",
+  [TranslationKey.RULE_HARMONY]: "Harmony",
+  // Ground types
+  [TranslationKey.GROUND_CASTLE]: "Castle",
+  [TranslationKey.GROUND_WHEAT]: "Wheat Field",
+  [TranslationKey.GROUND_FOREST]: "Forest",
+  [TranslationKey.GROUND_SEA]: "Sea",
+  [TranslationKey.GROUND_PLAIN]: "Plain",
+  [TranslationKey.GROUND_SWAMP]: "Swamp",
+  [TranslationKey.GROUND_MINE]: "Mine",
+  // Game phases
+  [TranslationKey.PHASE_ADD_PLAYERS]: "Add Players",
+  [TranslationKey.PHASE_OPTIONS]: "Game Options",
+  [TranslationKey.PHASE_START]: "Start Game",
+  [TranslationKey.PHASE_RESULT]: "Game Results",
+  // Actions
+  [TranslationKey.ACTION_PICK_DOMINO]: "Pick Domino",
+  [TranslationKey.ACTION_PLACE_DOMINO]: "Place Domino",
+  [TranslationKey.ACTION_PASS]: "Pass"
+};
+var createTranslator = (translations = {}) => {
+  const mergedTranslations = { ...defaultTranslations, ...translations };
+  return {
+    t(key, params) {
+      let text = mergedTranslations[key] || key;
+      if (params) {
+        Object.entries(params).forEach(([paramKey, value]) => {
+          text = text.replace(new RegExp(`{{${paramKey}}}`, "g"), String(value));
+        });
+      }
+      return text;
+    }
   };
 };
+var defaultTranslator = createTranslator();
 
 // src/index.ts
 var createGameEngine = (config) => {
@@ -2004,7 +2365,11 @@ var createGameEngine = (config) => {
     placeDominoHandler: placeDominoHandler2,
     discardDominoHandler: discardDominoHandler2,
     getResultHandler: getResultHandler2,
-    calculateScoreHandler: calculateScoreHandler2
+    calculateScoreHandler: calculateScoreHandler2,
+    getValidPlacementsHandler: getValidPlacementsHandler2,
+    canPlaceDominoHandler: canPlaceDominoHandler2,
+    serializeGameHandler: serializeGameHandler2,
+    deserializeGameHandler: deserializeGameHandler2
   } = configureEngine(config);
   return {
     getModes: (command) => getModesHandler2(command),
@@ -2017,16 +2382,39 @@ var createGameEngine = (config) => {
     placeDomino: (command) => placeDominoHandler2(command),
     discardDomino: (command) => discardDominoHandler2(command),
     getResults: (command) => getResultHandler2(command),
-    calculateScore: (command) => calculateScoreHandler2(command)
+    calculateScore: (command) => calculateScoreHandler2(command),
+    getValidPlacements: (command) => getValidPlacementsHandler2(command),
+    canPlaceDomino: (command) => canPlaceDominoHandler2(command),
+    serialize: (command) => serializeGameHandler2(command),
+    deserialize: (command) => deserializeGameHandler2(command)
   };
 };
 export {
+  ActionExecutionError,
+  DomainException,
+  ErrorCode,
   GRIDSIZE,
   GROUND,
+  GameEventEmitter,
+  GameEventType,
+  InvalidStepError,
+  NotFoundError,
+  StepExecutionError,
+  TranslationKey,
+  ValidationError,
+  createDomainError,
+  createEvent,
   createGameEngine,
+  createSavePoint,
+  createTranslator,
+  defaultTranslations,
+  defaultTranslator,
+  deserializeGame,
   gameSteps,
   isGameWithNextAction,
   isGameWithNextStep,
-  playerActions
+  playerActions,
+  restoreFromSavePoint,
+  serializeGame
 };
 //# sourceMappingURL=index.js.map