@pompidup/kingdomino-engine 1.1.1 → 2.0.0

package/dist/index.d.ts

@@ -1,11 +1,18 @@
-declare const ground: readonly ["castle", "wheat", "forest", "sea", "plain", "swamp", "mine"];
-type Ground = (typeof ground)[number];
+type GameMode = {
+    name: string;
+    description: string;
+};
+
+declare const GROUND: readonly ["castle", "wheat", "forest", "sea", "plain", "swamp", "mine"];
+type Ground = (typeof GROUND)[number];
+type EmptyGround = "empty";
+type Crown = number;
 type Tile = {
     type: Ground;
-    crowns: number;
+    crowns: Crown;
 };
 type EmptyTile = {
-    type: "empty";
+    type: EmptyGround;
     crowns: 0;
 };
 type Domino = {
@@ -23,7 +30,6 @@ type RevealsDomino = {
 type Lord = {
     id: string;
     playerId: string;
-    order: number;
     turnEnded: boolean;
     hasPick: boolean;
     hasPlace: boolean;
@@ -38,21 +44,40 @@ type Orientation = "vertical" | "horizontal";
 type Rotation = 0 | 180;
 type Kingdom = (Tile | EmptyTile)[][];
 
+type ObjectValues<T> = T[keyof T];
+
 type Player = {
     id: string;
     name: string;
     kingdom: Kingdom;
 };
+declare const playerActions: {
+    readonly placeDomino: "placeDomino";
+    readonly pickDomino: "pickDomino";
+    readonly pass: "pass";
+};
+type PlayerActions = ObjectValues<typeof playerActions>;
 
-declare const availableMode: readonly ["Classic"];
-type AvailableMode = (typeof availableMode)[number];
-
-type Rule = {
+type BasicRules = {
+    lords: number;
+    maxDominoes: number;
+    dominoesPerTurn: number;
+    maxTurns: number;
+};
+type ExtraRule = {
     name: string;
     description: string;
-    mode: AvailableMode[];
+    mode: GameMode[];
     playersLimit?: number;
 };
+type Rules = {
+    basic: Record<number, BasicRules>;
+    extraRules: ExtraRule[];
+};
+type SelectedRules = {
+    basic: BasicRules;
+    extra: ExtraRule[];
+};
 
 type Game = {
     id: string;
@@ -61,19 +86,37 @@ type Game = {
     players: Player[];
     lords: Lord[];
     turn: number;
-    maxTurns: number;
-    maxDominoes: number;
-    dominoesPerTurn: number;
-    order: Record<number, string>;
-    rules?: Rule[];
+    nextAction: NextAction | NextStep;
+    rules: SelectedRules;
+    mode: GameMode;
+};
+declare const gameSteps: {
+    readonly addPlayers: "addPlayers";
+    readonly options: "options";
+    readonly start: "start";
+    readonly result: "result";
+};
+type GameSteps = ObjectValues<typeof gameSteps>;
+type NextAction = {
+    type: "action";
+    nextLord: string;
+    nextAction: PlayerActions;
+};
+type NextStep = {
+    type: "step";
+    step: GameSteps;
+};
+type GameWithNextAction = Game & {
+    nextAction: NextAction;
+};
+type GameWithNextStep = Game & {
+    nextAction: NextStep;
 };
-
 type Score = {
-    score: number;
+    points: number;
     maxPropertiesSize: number;
     totalCrowns: number;
 };
-
 type ScoreResult = {
     playerId: string;
     playerName: string;
@@ -82,33 +125,102 @@ type ScoreResult = {
 type FinalResult = ScoreResult & {
     position: number;
 };
+type GameWithResults = Game & {
+    result: FinalResult[];
+};
 
-type Resp = {
-    nextLord: string;
-    nextAction: "pick" | "place" | "end";
-    game: Game;
+type GetModesCommand = Record<string, never>;
+
+type GetExtraRulesCommand = {
+    mode: GameMode["name"];
+    players: number;
 };
-type GameResult = {
-    result: FinalResult[];
-    game: Game;
-};
-/** Todo
- * Add rules step
- *
- **/
-declare const gameEngine: () => {
-    init: () => Game;
-    getMode: () => readonly ["Classic"];
-    setMode: (mode: string, game: Game) => Game;
-    getRules: (mode: string) => never[];
-    setRules: (rules: string[], game: Game) => Game;
-    start: (game: Game, players: {
-        name: string;
-    }[]) => Resp;
-    pass: (game: Game, lordId: string) => Resp;
-    placeDomino: (game: Game, lordId: string, position: Position, orientation: Orientation, rotation: Rotation) => Resp;
-    pickDomino: (game: Game, lordId: string, dominoPick: number) => Resp;
-    endGame: (game: Game) => GameResult;
-};
-
-export { gameEngine as default };
+
+type CreateGameCommand = {
+    mode: string;
+};
+
+type AddPlayersCommand = {
+    game: Game & {
+        nextAction: NextStep;
+    };
+    players: string[];
+};
+
+type AddExtraRulesCommand = {
+    game: Game & {
+        nextAction: NextStep;
+    };
+    extraRules: string[];
+};
+
+type StartGameCommand = {
+    game: Game & {
+        nextAction: NextStep;
+    };
+};
+
+type ChooseDominoCommand = {
+    game: GameWithNextAction;
+    dominoPick: number;
+    lordId: string;
+};
+
+type PlaceDominoCommand = {
+    game: GameWithNextAction;
+    lordId: string;
+    position: Position;
+    orientation: Orientation;
+    rotation: Rotation;
+};
+
+type DiscardDominoCommand = {
+    game: GameWithNextAction;
+    lordId: string;
+};
+
+type GetResultCommand = {
+    game: GameWithNextStep;
+};
+
+type GameEngine = {
+    getModes: (command: GetModesCommand) => GameMode[];
+    getExtraRules: (command: GetExtraRulesCommand) => ExtraRule[];
+    createGame: (command: CreateGameCommand) => GameWithNextStep;
+    addPlayers: (command: AddPlayersCommand) => GameWithNextStep;
+    addExtraRules: (command: AddExtraRulesCommand) => GameWithNextStep;
+    startGame: (command: StartGameCommand) => GameWithNextAction;
+    chooseDomino: (command: ChooseDominoCommand) => GameWithNextAction;
+    placeDomino: (command: PlaceDominoCommand) => GameWithNextAction | GameWithNextStep;
+    discardDomino: (command: DiscardDominoCommand) => GameWithNextAction | GameWithNextStep;
+    getResults: (command: GetResultCommand) => GameWithResults;
+};
+
+type DominoesRepository = {
+    getForMode: (mode: GameMode) => Domino[] | [];
+};
+
+type ModeRepository = {
+    getAvailables: () => GameMode[];
+};
+
+type RuleRepository = {
+    getAll: () => Rules;
+    getAllExtra: () => ExtraRule[];
+};
+
+type ShuffleMethod = <T>(array: T[]) => T[];
+
+type UuidMethod = () => string;
+
+type EngineConfig = {
+    modeRepository?: ModeRepository;
+    dominoesRepository?: DominoesRepository;
+    ruleRepository?: RuleRepository;
+    uuidMethod?: UuidMethod;
+    shuffleMethod?: ShuffleMethod;
+};
+
+declare const createGameEngine: (config: Partial<EngineConfig>) => GameEngine;
+
+export { createGameEngine };