@oathompsonjones/mini-games 1.0.6 → 1.0.9

package/build/base/controller.d.ts

@@ -1,34 +1,39 @@
 import type Board from "./board.js";
 import { EventEmitter } from "eventemitter3";
+import type LongInt from "../bitBoard/longInt.js";
 import type { Position } from "./board.js";
 export type PlayerType = "easyCPU" | "hardCPU" | "human" | "impossibleCPU" | "mediumCPU";
 export type Algorithm = "alphabeta" | "minimax";
-export type GameConstructorOptions = {
-    id?: unknown;
+export type GameConstructorOptions<T> = {
+    id: T;
     onEnd?: (winner: number | null) => Promise<void> | void;
     onInvalidInput?: (position: Position) => Promise<void> | void;
-    renderer?: (controller: Controller) => Promise<void> | void;
+    renderer?: (controller: Controller<T>) => Promise<void> | void;
 };
-export type GameConstructor = {
-    new (playerOneType: PlayerType, playerTwoType: PlayerType, options?: GameConstructorOptions): Controller;
+export type GameConstructor<T> = {
+    new (playerOneType: PlayerType, playerTwoType: PlayerType, options: GameConstructorOptions<T>): Controller<T>;
 };
 /**
  * Decorator to check that the constructor type for the given class is correct.
- * @param constructor The class to check.
+ * @template T - The type of the game ID.
+ * @param constructor - The class to check.
  */
-export declare function Game(constructor: GameConstructor): void;
-/** Represents a game controller. */
-export default abstract class Controller extends EventEmitter<{
-    end: GameConstructorOptions["onEnd"];
-    input: GameConstructorOptions["onInvalidInput"];
-    invalidInput: GameConstructorOptions["onInvalidInput"];
+export declare function Game<T>(constructor: GameConstructor<T>): void;
+/**
+ * Represents a game controller.
+ * @template T - The type of the game ID.
+ */
+export default abstract class Controller<T> extends EventEmitter<{
+    end: GameConstructorOptions<T>["onEnd"];
+    input: GameConstructorOptions<T>["onInvalidInput"];
+    invalidInput: GameConstructorOptions<T>["onInvalidInput"];
 }> {
     /** Contains the ID of the game. */
-    readonly gameID: unknown;
+    readonly gameID: T;
     /** Contains the board. */
-    readonly board: Board;
+    readonly board: Board<LongInt | number>;
     /** Contains the view object. */
-    readonly render: Required<GameConstructorOptions>["renderer"];
+    readonly render: () => Promise<void> | void;
     /** Contains the player objects. */
     protected readonly players: Array<{
         id: number;
@@ -38,28 +43,32 @@ export default abstract class Controller extends EventEmitter<{
     private currentPlayerId;
     /**
      * Creates an instance of Controller.
-     * @param playerTypes The types of player.
-     * @param view The view object.
-     * @param gameID The ID of the game.
-     * @param board The board.
+     * @param playerTypes - The types of player for the game.
+     * @param board - The board object.
+     * @param render - The render function.
+     * @param gameID - The ID of the game instance.
+     * @param onEnd - The function to call when the game ends.
+     * @param onInvalidInput - The function to call when the input is invalid.
+     */
+    protected constructor(playerTypes: PlayerType[], board: Board<LongInt | number>, render: Required<GameConstructorOptions<T>>["renderer"], gameID: T, onEnd?: GameConstructorOptions<T>["onEnd"], onInvalidInput?: GameConstructorOptions<T>["onInvalidInput"]);
+    /**
+     * Gets the current player object.
+     * @returns The current player object.
      */
-    protected constructor(playerTypes: PlayerType[], board: Board, render: Controller["render"], gameID: unknown, onEnd?: GameConstructorOptions["onEnd"], onInvalidInput?: GameConstructorOptions["onInvalidInput"]);
-    /** Gets the current player object. */
     get currentPlayer(): {
         id: number;
         playerType: PlayerType;
     };
     /**
      * Controls the main game flow.
-     * @param algorithm The algorithm to use.
+     * @param algorithm - The algorithm to use.
      * @returns The winner or null in the event of a tie.
      */
     play(algorithm?: Algorithm): Promise<void>;
     /**
-     * The bog standard minimax algorithm. Left in for reference.
-     * @link https://en.wikipedia.org/wiki/Minimax
-     * @param depth The depth of the algorithm.
-     * @param maximisingPlayer Whether or not the current player is the maximising player.
+     * The bog standard minimax algorithm. Left in for reference (https://en.wikipedia.org/wiki/Minimax).
+     * @param depth - The depth of the algorithm.
+     * @param maximisingPlayer - Whether or not the current player is the maximising player.
      * @returns The optimal move.
      */
     protected minimax(depth?: number, maximisingPlayer?: boolean): {
@@ -67,12 +76,11 @@ export default abstract class Controller extends EventEmitter<{
         score: number;
     };
     /**
-     * The minimax algorithm with alpha-beta pruning.
-     * @link https://en.wikipedia.org/wiki/Minimax
-     * @param depth The depth of the algorithm.
-     * @param alpha The bounds for the alpha-beta variation of the algorithm.
-     * @param beta The bounds for the alpha-beta variation of the algorithm.
-     * @param maximisingPlayer Whether or not the current player is the maximising player.
+     * The minimax algorithm with alpha-beta pruning (https://en.wikipedia.org/wiki/Minimax).
+     * @param depth - The depth of the algorithm.
+     * @param alpha - The bounds for the alpha-beta variation of the algorithm.
+     * @param beta - The bounds for the alpha-beta variation of the algorithm.
+     * @param maximisingPlayer - Whether or not the current player is the maximising player.
      * @returns The optimal move.
      */
     protected alphabeta(depth?: number, alpha?: number, beta?: number, maximisingPlayer?: boolean): {
@@ -83,20 +91,23 @@ export default abstract class Controller extends EventEmitter<{
     private nextTurn;
     /**
      * Makes a move.
-     * @param input Either the algorithm to use to calculate the move or the move itself.
+     * @param input - Either the algorithm to use to calculate the move or the move itself.
      */
     private makeMove;
     /**
      * Determines the CPU move.
-     * @param difficulty The difficulty of the AI.
-     * @param algorithm The algorithm to use.
+     * @param difficulty - The difficulty of the AI.
+     * @param algorithm - The algorithm to use.
      * @returns The move.
      */
     abstract determineCPUMove(difficulty: Omit<PlayerType, "human">, algorithm?: Algorithm): Position;
     /**
      * Finds the optimal move.
-     * @param options The options.
-     * @returns The optimal move.
+     * @param options - The options to use.
+     * @param options.algorithm - The algorithm to use.
+     * @param options.maxDepth - The maximum depth to search.
+     * @param options.randomMove - A random move to make.
+     * @returns The optimal move to make.
      */
     abstract findOptimalMove(options?: {
         algorithm?: Algorithm;

package/build/base/controller.js

@@ -1,12 +1,16 @@
 import { EventEmitter } from "eventemitter3";
 /**
  * Decorator to check that the constructor type for the given class is correct.
- * @param constructor The class to check.
+ * @template T - The type of the game ID.
+ * @param constructor - The class to check.
  */
 export function Game(constructor) {
     void constructor;
 }
-/** Represents a game controller. */
+/**
+ * Represents a game controller.
+ * @template T - The type of the game ID.
+ */
 export default class Controller extends EventEmitter {
     /** Contains the ID of the game. */
     gameID;
@@ -20,35 +24,39 @@ export default class Controller extends EventEmitter {
     currentPlayerId = 0;
     /**
      * Creates an instance of Controller.
-     * @param playerTypes The types of player.
-     * @param view The view object.
-     * @param gameID The ID of the game.
-     * @param board The board.
+     * @param playerTypes - The types of player for the game.
+     * @param board - The board object.
+     * @param render - The render function.
+     * @param gameID - The ID of the game instance.
+     * @param onEnd - The function to call when the game ends.
+     * @param onInvalidInput - The function to call when the input is invalid.
      */
-    // eslint-disable-next-line @typescript-eslint/max-params, require-jsdoc
+    // eslint-disable-next-line @typescript-eslint/max-params
     constructor(playerTypes, board, render, gameID, onEnd, onInvalidInput) {
         super();
-        this.gameID = gameID ?? Date.now().toString(16);
+        this.gameID = gameID;
         this.board = board;
-        this.board.setGameID(this.gameID);
         this.players = playerTypes.map((playerType, id) => ({ id, playerType }));
-        this.render = render;
+        this.render = render.bind(null, this);
         if (onEnd !== undefined)
             this.on("end", onEnd);
         if (onInvalidInput !== undefined)
             this.on("invalidInput", onInvalidInput);
     }
-    /** Gets the current player object. */
+    /**
+     * Gets the current player object.
+     * @returns The current player object.
+     */
     get currentPlayer() {
         return this.players[this.currentPlayerId];
     }
     /**
      * Controls the main game flow.
-     * @param algorithm The algorithm to use.
+     * @param algorithm - The algorithm to use.
      * @returns The winner or null in the event of a tie.
      */
     async play(algorithm = "alphabeta") {
-        await this.render(this);
+        await this.render();
         this.on("input", async (move) => {
             await this.makeMove(move);
             if (this.currentPlayer.playerType !== "human")
@@ -59,10 +67,9 @@ export default class Controller extends EventEmitter {
             await this.makeMove(algorithm);
     }
     /**
-     * The bog standard minimax algorithm. Left in for reference.
-     * @link https://en.wikipedia.org/wiki/Minimax
-     * @param depth The depth of the algorithm.
-     * @param maximisingPlayer Whether or not the current player is the maximising player.
+     * The bog standard minimax algorithm. Left in for reference (https://en.wikipedia.org/wiki/Minimax).
+     * @param depth - The depth of the algorithm.
+     * @param maximisingPlayer - Whether or not the current player is the maximising player.
      * @returns The optimal move.
      */
     minimax(depth = Infinity, maximisingPlayer = true) {
@@ -96,12 +103,11 @@ export default class Controller extends EventEmitter {
         return bestMove;
     }
     /**
-     * The minimax algorithm with alpha-beta pruning.
-     * @link https://en.wikipedia.org/wiki/Minimax
-     * @param depth The depth of the algorithm.
-     * @param alpha The bounds for the alpha-beta variation of the algorithm.
-     * @param beta The bounds for the alpha-beta variation of the algorithm.
-     * @param maximisingPlayer Whether or not the current player is the maximising player.
+     * The minimax algorithm with alpha-beta pruning (https://en.wikipedia.org/wiki/Minimax).
+     * @param depth - The depth of the algorithm.
+     * @param alpha - The bounds for the alpha-beta variation of the algorithm.
+     * @param beta - The bounds for the alpha-beta variation of the algorithm.
+     * @param maximisingPlayer - Whether or not the current player is the maximising player.
      * @returns The optimal move.
      */
     alphabeta(depth = Infinity, alpha = -Infinity, beta = Infinity, maximisingPlayer = true) {
@@ -148,7 +154,7 @@ export default class Controller extends EventEmitter {
     }
     /**
      * Makes a move.
-     * @param input Either the algorithm to use to calculate the move or the move itself.
+     * @param input - Either the algorithm to use to calculate the move or the move itself.
      */
     async makeMove(input) {
         if (typeof input === "string") {
@@ -161,7 +167,7 @@ export default class Controller extends EventEmitter {
             }
             this.board.makeMove(input, this.currentPlayer.id);
         }
-        await this.render(this);
+        await this.render();
         const { winner } = this.board;
         if (winner !== false) {
             this.emit("end", winner);
@@ -170,4 +176,4 @@ export default class Controller extends EventEmitter {
         this.nextTurn();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controller.js","sourceRoot":"","sources":["../../src/base/controller.ts"],"names":[],"mappings":"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","sourcesContent":["import type Board from \"./board.js\";\nimport { EventEmitter } from \"eventemitter3\";\nimport type { Position } from \"./board.js\";\n\nexport type PlayerType = \"easyCPU\" | \"hardCPU\" | \"human\" | \"impossibleCPU\" | \"mediumCPU\";\nexport type Algorithm = \"alphabeta\" | \"minimax\";\nexport type GameConstructorOptions = {\n    id?: unknown;\n    onEnd?: (winner: number | null) => Promise<void> | void;\n    onInvalidInput?: (position: Position) => Promise<void> | void;\n    renderer?: (controller: Controller) => Promise<void> | void;\n};\nexport type GameConstructor = {\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type\n    new (playerOneType: PlayerType, playerTwoType: PlayerType, options?: GameConstructorOptions): Controller;\n};\n/**\n * Decorator to check that the constructor type for the given class is correct.\n * @param constructor The class to check.\n */\nexport function Game(constructor: GameConstructor): void {\n    void constructor;\n}\n\n/** Represents a game controller. */\nexport default abstract class Controller extends EventEmitter<{\n    end: GameConstructorOptions[\"onEnd\"];\n    input: GameConstructorOptions[\"onInvalidInput\"];\n    invalidInput: GameConstructorOptions[\"onInvalidInput\"];\n}> {\n    /** Contains the ID of the game. */\n    public readonly gameID: unknown;\n\n    /** Contains the board. */\n    public readonly board: Board;\n\n    /** Contains the view object. */\n    public readonly render: Required<GameConstructorOptions>[\"renderer\"];\n\n    /** Contains the player objects. */\n    protected readonly players: Array<{ id: number; playerType: PlayerType; }>;\n\n    /** Contains the ID of the current player. */\n    private currentPlayerId: number = 0;\n\n    /**\n     * Creates an instance of Controller.\n     * @param playerTypes The types of player.\n     * @param view The view object.\n     * @param gameID The ID of the game.\n     * @param board The board.\n     */\n    // eslint-disable-next-line @typescript-eslint/max-params, require-jsdoc\n    protected constructor(\n        playerTypes: PlayerType[],\n        board: Board,\n        render: Controller[\"render\"],\n        gameID: unknown,\n        onEnd?: GameConstructorOptions[\"onEnd\"],\n        onInvalidInput?: GameConstructorOptions[\"onInvalidInput\"],\n    ) {\n        super();\n        this.gameID = gameID ?? Date.now().toString(16);\n        this.board = board;\n        this.board.setGameID(this.gameID);\n        this.players = playerTypes.map((playerType, id) => ({ id, playerType }));\n        this.render = render;\n\n        if (onEnd !== undefined)\n            this.on(\"end\", onEnd);\n\n        if (onInvalidInput !== undefined)\n            this.on(\"invalidInput\", onInvalidInput);\n    }\n\n    /** Gets the current player object. */\n    public get currentPlayer(): { id: number; playerType: PlayerType; } {\n        return this.players[this.currentPlayerId]!;\n    }\n\n    /**\n     * Controls the main game flow.\n     * @param algorithm The algorithm to use.\n     * @returns The winner or null in the event of a tie.\n     */\n    public async play(algorithm: Algorithm = \"alphabeta\"): Promise<void> {\n        await this.render(this);\n        this.on(\"input\", async (move: Position): Promise<void> => {\n            await this.makeMove(move);\n\n            if (this.currentPlayer.playerType !== \"human\")\n                await this.makeMove(algorithm);\n        });\n\n        while (this.currentPlayer.playerType !== \"human\" && this.board.winner === false)\n            // eslint-disable-next-line no-await-in-loop\n            await this.makeMove(algorithm);\n    }\n\n    /**\n     * The bog standard minimax algorithm. Left in for reference.\n     * @link https://en.wikipedia.org/wiki/Minimax\n     * @param depth The depth of the algorithm.\n     * @param maximisingPlayer Whether or not the current player is the maximising player.\n     * @returns The optimal move.\n     */\n    protected minimax(depth: number = Infinity, maximisingPlayer: boolean = true): { move: Position; score: number; } {\n        const playerIds = [(this.currentPlayerId + 1) % 2, this.currentPlayerId] as const;\n\n        if (depth === 0 || this.board.winner !== false) {\n            return {\n                move: { x: NaN, y: NaN },\n                score: this.board.heuristic * (this.currentPlayerId === 0 ? 1 : -1),\n            };\n        }\n\n        let bestMove: ReturnType<typeof this.minimax> = {\n            move: { x: NaN, y: NaN },\n            score: maximisingPlayer ? -Infinity : Infinity,\n        };\n        const { emptyCells } = this.board;\n\n        for (const move of emptyCells) {\n            this.board.makeMove(move, playerIds[Number(maximisingPlayer)]!);\n            const score = (9 - emptyCells.length) * this.minimax(depth - 1, !maximisingPlayer).score;\n\n            this.board.undoLastMove();\n\n            if (maximisingPlayer) {\n                const bestScore = Math.max(score, bestMove.score);\n\n                if (bestScore !== bestMove.score)\n                    bestMove = { move, score };\n            } else {\n                const bestScore = Math.min(score, bestMove.score);\n\n                if (bestScore !== bestMove.score)\n                    bestMove = { move, score };\n            }\n        }\n\n        return bestMove;\n    }\n\n    /**\n     * The minimax algorithm with alpha-beta pruning.\n     * @link https://en.wikipedia.org/wiki/Minimax\n     * @param depth The depth of the algorithm.\n     * @param alpha The bounds for the alpha-beta variation of the algorithm.\n     * @param beta The bounds for the alpha-beta variation of the algorithm.\n     * @param maximisingPlayer Whether or not the current player is the maximising player.\n     * @returns The optimal move.\n     */\n    protected alphabeta(\n        depth: number = Infinity,\n        alpha: number = -Infinity,\n        beta: number = Infinity,\n        maximisingPlayer: boolean = true,\n    ): { move: Position; score: number; } {\n        const playerIds = [(this.currentPlayerId + 1) % 2, this.currentPlayerId] as const;\n\n        if (depth === 0 || this.board.winner !== false) {\n            return {\n                move: { x: NaN, y: NaN },\n                score: this.board.heuristic * (this.currentPlayerId === 0 ? 1 : -1),\n            };\n        }\n\n        let bestMove: ReturnType<typeof this.alphabeta> = {\n            move: { x: NaN, y: NaN },\n            score: maximisingPlayer ? -Infinity : Infinity,\n        };\n        const { emptyCells } = this.board;\n\n        for (const move of emptyCells) {\n            this.board.makeMove(move, playerIds[Number(maximisingPlayer)]!);\n            const score = (9 - emptyCells.length) * this.alphabeta(depth - 1, alpha, beta, !maximisingPlayer).score;\n\n            this.board.undoLastMove();\n\n            if (maximisingPlayer) {\n                const bestScore = Math.max(score, bestMove.score);\n\n                if (bestScore !== bestMove.score)\n                    bestMove = { move, score };\n\n                if (bestMove.score > beta)\n                    break;\n\n                // eslint-disable-next-line no-param-reassign\n                alpha = Math.max(alpha, bestScore);\n            } else {\n                const bestScore = Math.min(score, bestMove.score);\n\n                if (bestScore !== bestMove.score)\n                    bestMove = { move, score };\n\n                if (bestMove.score < alpha)\n                    break;\n\n                // eslint-disable-next-line no-param-reassign\n                beta = Math.min(beta, bestScore);\n            }\n        }\n\n        return bestMove;\n    }\n\n    /** Changes which player's turn it is. */\n    private nextTurn(): void {\n        this.currentPlayerId = (this.currentPlayerId + 1) % this.players.length;\n    }\n\n    /**\n     * Makes a move.\n     * @param input Either the algorithm to use to calculate the move or the move itself.\n     */\n    private async makeMove(input: Algorithm | Position): Promise<void> {\n        if (typeof input === \"string\") {\n            this.board.makeMove(this.determineCPUMove(this.currentPlayer.playerType, input), this.currentPlayer.id);\n        } else {\n            if (this.currentPlayer.playerType !== \"human\" || !this.board.moveIsValid(input)) {\n                this.emit(\"invalidInput\", input);\n\n                return;\n            }\n\n            this.board.makeMove(input, this.currentPlayer.id);\n        }\n\n        await this.render(this);\n        const { winner } = this.board;\n\n        if (winner !== false) {\n            this.emit(\"end\", winner);\n\n            return;\n        }\n\n        this.nextTurn();\n    }\n\n    /**\n     * Determines the CPU move.\n     * @param difficulty The difficulty of the AI.\n     * @param algorithm The algorithm to use.\n     * @returns The move.\n     */\n    public abstract determineCPUMove(difficulty: Omit<PlayerType, \"human\">, algorithm?: Algorithm): Position;\n\n    /**\n     * Finds the optimal move.\n     * @param options The options.\n     * @returns The optimal move.\n     */\n    public abstract findOptimalMove(options?: { algorithm?: Algorithm; maxDepth?: number; randomMove?: Position; }): Position;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controller.js","sourceRoot":"","sources":["../../src/base/controller.ts"],"names":[],"mappings":"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","sourcesContent":["import type Board from \"./board.js\";\nimport { EventEmitter } from \"eventemitter3\";\nimport type LongInt from \"../bitBoard/longInt.js\";\nimport type { Position } from \"./board.js\";\n\nexport type PlayerType = \"easyCPU\" | \"hardCPU\" | \"human\" | \"impossibleCPU\" | \"mediumCPU\";\nexport type Algorithm = \"alphabeta\" | \"minimax\";\nexport type GameConstructorOptions<T> = {\n    id: T;\n    onEnd?: (winner: number | null) => Promise<void> | void;\n    onInvalidInput?: (position: Position) => Promise<void> | void;\n    renderer?: (controller: Controller<T>) => Promise<void> | void;\n};\nexport type GameConstructor<T> = {\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type\n    new(playerOneType: PlayerType, playerTwoType: PlayerType, options: GameConstructorOptions<T>): Controller<T>;\n};\n/**\n * Decorator to check that the constructor type for the given class is correct.\n * @template T - The type of the game ID.\n * @param constructor - The class to check.\n */\nexport function Game<T>(constructor: GameConstructor<T>): void {\n    void constructor;\n}\n\n/**\n * Represents a game controller.\n * @template T - The type of the game ID.\n */\nexport default abstract class Controller<T> extends EventEmitter<{\n    end: GameConstructorOptions<T>[\"onEnd\"];\n    input: GameConstructorOptions<T>[\"onInvalidInput\"];\n    invalidInput: GameConstructorOptions<T>[\"onInvalidInput\"];\n}> {\n    /** Contains the ID of the game. */\n    public readonly gameID: T;\n\n    /** Contains the board. */\n    public readonly board: Board<LongInt | number>;\n\n    /** Contains the view object. */\n    public readonly render: () => Promise<void> | void;\n\n    /** Contains the player objects. */\n    protected readonly players: Array<{ id: number; playerType: PlayerType; }>;\n\n    /** Contains the ID of the current player. */\n    private currentPlayerId: number = 0;\n\n    /**\n     * Creates an instance of Controller.\n     * @param playerTypes - The types of player for the game.\n     * @param board - The board object.\n     * @param render - The render function.\n     * @param gameID - The ID of the game instance.\n     * @param onEnd - The function to call when the game ends.\n     * @param onInvalidInput - The function to call when the input is invalid.\n     */\n    // eslint-disable-next-line @typescript-eslint/max-params\n    protected constructor(\n        playerTypes: PlayerType[],\n        board: Board<LongInt | number>,\n        render: Required<GameConstructorOptions<T>>[\"renderer\"],\n        gameID: T,\n        onEnd?: GameConstructorOptions<T>[\"onEnd\"],\n        onInvalidInput?: GameConstructorOptions<T>[\"onInvalidInput\"],\n    ) {\n        super();\n        this.gameID = gameID;\n        this.board = board;\n        this.players = playerTypes.map((playerType, id) => ({ id, playerType }));\n        this.render = render.bind(null, this);\n\n        if (onEnd !== undefined)\n            this.on(\"end\", onEnd);\n\n        if (onInvalidInput !== undefined)\n            this.on(\"invalidInput\", onInvalidInput);\n    }\n\n    /**\n     * Gets the current player object.\n     * @returns The current player object.\n     */\n    public get currentPlayer(): { id: number; playerType: PlayerType; } {\n        return this.players[this.currentPlayerId]!;\n    }\n\n    /**\n     * Controls the main game flow.\n     * @param algorithm - The algorithm to use.\n     * @returns The winner or null in the event of a tie.\n     */\n    public async play(algorithm: Algorithm = \"alphabeta\"): Promise<void> {\n        await this.render();\n        this.on(\"input\", async (move: Position): Promise<void> => {\n            await this.makeMove(move);\n\n            if (this.currentPlayer.playerType !== \"human\")\n                await this.makeMove(algorithm);\n        });\n\n        while (this.currentPlayer.playerType !== \"human\" && this.board.winner === false)\n            // eslint-disable-next-line no-await-in-loop\n            await this.makeMove(algorithm);\n    }\n\n    /**\n     * The bog standard minimax algorithm. Left in for reference (https://en.wikipedia.org/wiki/Minimax).\n     * @param depth - The depth of the algorithm.\n     * @param maximisingPlayer - Whether or not the current player is the maximising player.\n     * @returns The optimal move.\n     */\n    protected minimax(depth: number = Infinity, maximisingPlayer: boolean = true): { move: Position; score: number; } {\n        const playerIds = [(this.currentPlayerId + 1) % 2, this.currentPlayerId] as const;\n\n        if (depth === 0 || this.board.winner !== false) {\n            return {\n                move: { x: NaN, y: NaN },\n                score: this.board.heuristic * (this.currentPlayerId === 0 ? 1 : -1),\n            };\n        }\n\n        let bestMove: ReturnType<typeof this.minimax> = {\n            move: { x: NaN, y: NaN },\n            score: maximisingPlayer ? -Infinity : Infinity,\n        };\n        const { emptyCells } = this.board;\n\n        for (const move of emptyCells) {\n            this.board.makeMove(move, playerIds[Number(maximisingPlayer)]!);\n            const score = (9 - emptyCells.length) * this.minimax(depth - 1, !maximisingPlayer).score;\n\n            this.board.undoLastMove();\n\n            if (maximisingPlayer) {\n                const bestScore = Math.max(score, bestMove.score);\n\n                if (bestScore !== bestMove.score)\n                    bestMove = { move, score };\n            } else {\n                const bestScore = Math.min(score, bestMove.score);\n\n                if (bestScore !== bestMove.score)\n                    bestMove = { move, score };\n            }\n        }\n\n        return bestMove;\n    }\n\n    /**\n     * The minimax algorithm with alpha-beta pruning (https://en.wikipedia.org/wiki/Minimax).\n     * @param depth - The depth of the algorithm.\n     * @param alpha - The bounds for the alpha-beta variation of the algorithm.\n     * @param beta - The bounds for the alpha-beta variation of the algorithm.\n     * @param maximisingPlayer - Whether or not the current player is the maximising player.\n     * @returns The optimal move.\n     */\n    protected alphabeta(\n        depth: number = Infinity,\n        alpha: number = -Infinity,\n        beta: number = Infinity,\n        maximisingPlayer: boolean = true,\n    ): { move: Position; score: number; } {\n        const playerIds = [(this.currentPlayerId + 1) % 2, this.currentPlayerId] as const;\n\n        if (depth === 0 || this.board.winner !== false) {\n            return {\n                move: { x: NaN, y: NaN },\n                score: this.board.heuristic * (this.currentPlayerId === 0 ? 1 : -1),\n            };\n        }\n\n        let bestMove: ReturnType<typeof this.alphabeta> = {\n            move: { x: NaN, y: NaN },\n            score: maximisingPlayer ? -Infinity : Infinity,\n        };\n        const { emptyCells } = this.board;\n\n        for (const move of emptyCells) {\n            this.board.makeMove(move, playerIds[Number(maximisingPlayer)]!);\n            const score = (9 - emptyCells.length) * this.alphabeta(depth - 1, alpha, beta, !maximisingPlayer).score;\n\n            this.board.undoLastMove();\n\n            if (maximisingPlayer) {\n                const bestScore = Math.max(score, bestMove.score);\n\n                if (bestScore !== bestMove.score)\n                    bestMove = { move, score };\n\n                if (bestMove.score > beta)\n                    break;\n\n                // eslint-disable-next-line no-param-reassign\n                alpha = Math.max(alpha, bestScore);\n            } else {\n                const bestScore = Math.min(score, bestMove.score);\n\n                if (bestScore !== bestMove.score)\n                    bestMove = { move, score };\n\n                if (bestMove.score < alpha)\n                    break;\n\n                // eslint-disable-next-line no-param-reassign\n                beta = Math.min(beta, bestScore);\n            }\n        }\n\n        return bestMove;\n    }\n\n    /** Changes which player's turn it is. */\n    private nextTurn(): void {\n        this.currentPlayerId = (this.currentPlayerId + 1) % this.players.length;\n    }\n\n    /**\n     * Makes a move.\n     * @param input - Either the algorithm to use to calculate the move or the move itself.\n     */\n    private async makeMove(input: Algorithm | Position): Promise<void> {\n        if (typeof input === \"string\") {\n            this.board.makeMove(this.determineCPUMove(this.currentPlayer.playerType, input), this.currentPlayer.id);\n        } else {\n            if (this.currentPlayer.playerType !== \"human\" || !this.board.moveIsValid(input)) {\n                this.emit(\"invalidInput\", input);\n\n                return;\n            }\n\n            this.board.makeMove(input, this.currentPlayer.id);\n        }\n\n        await this.render();\n        const { winner } = this.board;\n\n        if (winner !== false) {\n            this.emit(\"end\", winner);\n\n            return;\n        }\n\n        this.nextTurn();\n    }\n\n    /**\n     * Determines the CPU move.\n     * @param difficulty - The difficulty of the AI.\n     * @param algorithm - The algorithm to use.\n     * @returns The move.\n     */\n    public abstract determineCPUMove(difficulty: Omit<PlayerType, \"human\">, algorithm?: Algorithm): Position;\n\n    /**\n     * Finds the optimal move.\n     * @param options - The options to use.\n     * @param options.algorithm - The algorithm to use.\n     * @param options.maxDepth - The maximum depth to search.\n     * @param options.randomMove - A random move to make.\n     * @returns The optimal move to make.\n     */\n    public abstract findOptimalMove(options?: {\n        algorithm?: Algorithm;\n        maxDepth?: number;\n        randomMove?: Position;\n    }): Position;\n}\n"]}

package/build/bitBoard/bitBoard.d.ts

@@ -1,50 +1,53 @@
 import type LongInt from "./longInt.js";
-import type { StringType } from "./longInt.js";
+import { StringType } from "./longInt.js";
 /**
- * Represents a BitBoard.
- * @link https://en.wikipedia.org/wiki/Bitboard
+ * Represents a BitBoard (https://en.wikipedia.org/wiki/Bitboard).
+ * @template T - The type of the numeric data.
  */
-export default abstract class BitBoard<T extends LongInt | number = LongInt | number> {
+export default abstract class BitBoard<T extends LongInt | number> {
     /** The numeric data. */
     protected _data: T;
     /**
      * Creates an instance of BitBoard.
-     * @param data The data to assign to the BitBoard.
+     * @param data - The data to assign to the BitBoard.
      */
     protected constructor(data: T);
-    /** Gets the numeric data. */
+    /**
+     * Gets the numeric data.
+     * @returns The numeric data.
+     */
     get data(): T;
     /**
      * Returns a string representation of the BitBoard.
-     * @param type The base of the string to print.
+     * @param type - The base of the string to print.
      * @returns The string representation.
      */
     toString(type?: StringType): string;
     /**
      * Assigns a given bit a given value.
-     * @param bit The x coordinate.
-     * @param value The value to assign to the bit.
+     * @param bit - The x coordinate.
+     * @param value - The value to assign to the bit.
      */
     assignBit(bit: number, value: 0 | 1): void;
     /**
-     * Gets a given bit
-     * @param bit The index of the bit to get, 0 = LSB.
-     * @returns The bit.
+     * Gets a given bit.
+     * @param bit - The index of the bit to get, 0 = LSB.
+     * @returns The bit value.
      */
     abstract getBit(bit: number): 0 | 1;
     /**
-     * Sets a given bit (changes the value to 1)
-     * @param bit The index of the bit to get, 0 = LSB.
+     * Sets a given bit (changes the value to 1).
+     * @param bit - The index of the bit to get, 0 = LSB.
      */
     abstract setBit(bit: number): void;
     /**
-     * Clears a given bit (changes the value to 0)
-     * @param bit The index of the bit to get, 0 = LSB.
+     * Clears a given bit (changes the value to 0).
+     * @param bit - The index of the bit to get, 0 = LSB.
      */
     abstract clearBit(bit: number): void;
     /**
-     * Toggles a given bit (changes the value from 0 to 1 or 1 to 0)
-     * @param bit The index of the bit to get, 0 = LSB.
+     * Toggles a given bit (changes the value from 0 to 1 or 1 to 0).
+     * @param bit - The index of the bit to get, 0 = LSB.
      */
     abstract toggleBit(bit: number): void;
     /** Clears the whole BitBoard (sets all values to 0). */
@@ -53,55 +56,55 @@ export default abstract class BitBoard<T extends LongInt | number = LongInt | nu
     abstract setAll(): void;
     /**
      * Gets a range of bits.
-     * @param LSB The least significant bit.
-     * @param numberOfBits The number of bits to get.
+     * @param LSB - The least significant bit.
+     * @param numberOfBits - The number of bits to get.
      * @returns The range of bits.
      */
     abstract getBits(LSB: number, numberOfBits: number): T;
     /**
      * Carries out a bitwise and (&) operation.
-     * @param right The right value.
+     * @param right - The right value.
      * @returns The result.
      */
-    abstract and(right: BitBoard<T> | T | number): this;
+    abstract and(right: BitBoard<T> | T | number): BitBoard<T>;
     /**
      * Carries out a bitwise or (|) operation.
-     * @param right The right value.
+     * @param right - The right value.
      * @returns The result.
      */
-    abstract or(right: BitBoard<T> | T | number): this;
+    abstract or(right: BitBoard<T> | T | number): BitBoard<T>;
     /**
      * Carries out a bitwise xor (^) operation.
-     * @param right The right value.
+     * @param right - The right value.
      * @returns The result.
      */
-    abstract xor(right: BitBoard<T> | T | number): this;
+    abstract xor(right: BitBoard<T> | T | number): BitBoard<T>;
     /**
      * Carries out a bitwise not (~) operation.
      * @returns The result.
      */
-    abstract not(): this;
+    abstract not(): BitBoard<T>;
     /**
      * Carries out a bitwise left shift (<<) operation.
-     * @param shiftAmount How much to shift it by.
+     * @param shiftAmount - How much to shift it by.
      * @returns The result.
      */
-    abstract leftShift(shiftAmount: number): this;
+    abstract leftShift(shiftAmount: number): BitBoard<T>;
     /**
      * Carries out a bitwise logical right shift (>>>) operation.
-     * @param shiftAmount How much to shift it by.
+     * @param shiftAmount - How much to shift it by.
      * @returns The result.
      */
-    abstract rightShift(shiftAmount: number): this;
+    abstract rightShift(shiftAmount: number): BitBoard<T>;
     /**
      * Carries out a bitwise arithmetic right shift (>>) operation.
-     * @param shiftAmount How much to shift it by.
+     * @param shiftAmount - How much to shift it by.
      * @returns The result.
      */
-    abstract arithmeticRightShift(shiftAmount: number): this;
+    abstract arithmeticRightShift(shiftAmount: number): BitBoard<T>;
     /**
      * Checks if two BitBoards have equal data values.
-     * @param value The value to compare against.
+     * @param value - The value to compare against.
      * @returns Whether or not the two BitBoard have the same data value.
      */
     abstract equals(value: BitBoard<T> | T | number): boolean;

package/build/bitBoard/bitBoard.js

@@ -1,36 +1,39 @@
 /**
- * Represents a BitBoard.
- * @link https://en.wikipedia.org/wiki/Bitboard
+ * Represents a BitBoard (https://en.wikipedia.org/wiki/Bitboard).
+ * @template T - The type of the numeric data.
  */
 export default class BitBoard {
     /** The numeric data. */
     _data;
     /**
      * Creates an instance of BitBoard.
-     * @param data The data to assign to the BitBoard.
+     * @param data - The data to assign to the BitBoard.
      */
     constructor(data) {
         this._data = data;
     }
-    /** Gets the numeric data. */
+    /**
+     * Gets the numeric data.
+     * @returns The numeric data.
+     */
     get data() {
         return this._data;
     }
     /**
      * Returns a string representation of the BitBoard.
-     * @param type The base of the string to print.
+     * @param type - The base of the string to print.
      * @returns The string representation.
      */
-    toString(type = 16) {
+    toString(type = 16 /* StringType.HEXADECIMAL */) {
         let padLength = 0;
         switch (type) {
-            case 2:
+            case 2 /* StringType.BINARY */:
                 padLength = 32;
                 break;
-            case 10:
+            case 10 /* StringType.DECIMAL */:
                 padLength = 10;
                 break;
-            case 16:
+            case 16 /* StringType.HEXADECIMAL */:
                 padLength = 8;
                 break;
         }
@@ -38,8 +41,8 @@ export default class BitBoard {
     }
     /**
      * Assigns a given bit a given value.
-     * @param bit The x coordinate.
-     * @param value The value to assign to the bit.
+     * @param bit - The x coordinate.
+     * @param value - The value to assign to the bit.
      */
     assignBit(bit, value) {
         if (value === 0)
@@ -48,4 +51,4 @@ export default class BitBoard {
             this.setBit(bit);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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