@oathompsonjones/mini-games 1.0.7 → 1.0.9

package/TODO.md

@@ -0,0 +1,6 @@
+[ ] Write this program in Rust (faster + I should learn it).
+The rust program should have a few modes:
+- [ ] CPU vs CPU
+- [ ] Human vs CPU
+- [ ] Human vs human
+- [ ] Find optimal move (this will take in a game state, then calculate the most optimal move for the next player)

package/build/base/board.d.ts

@@ -1,4 +1,5 @@
 import type BitBoard from "../bitBoard/bitBoard.js";
+import LongInt from "../bitBoard/longInt.js";
 export type Position = {
     y: number;
     x: number;
@@ -17,14 +18,17 @@ export declare const enum GridLines {
     TBottom = "\u2534",
     Cross = "\u253C"
 }
-/** Represents a game board. */
-export default abstract class Board<T extends BitBoard = BitBoard> {
+/**
+ * Represents a game board.
+ * @template T - The type of the numeric data.
+ */
+export default abstract class Board<T extends LongInt | number> {
     /** Contains the data stored in a BitBoard. */
-    protected readonly bitBoard: T;
-    /** The width of the board. */
-    protected readonly boardWidth: number;
-    /** The height of the board. */
-    protected readonly boardHeight: number;
+    protected readonly bitBoard: BitBoard<T>;
+    /** The width of the game board. */
+    protected readonly width: number;
+    /** The height of the game board. */
+    protected readonly height: number;
     /** A stack of moves. */
     protected readonly moves: number[];
     /** How many boards there are representing player positions (most likely 2). */
@@ -32,91 +36,102 @@ export default abstract class Board<T extends BitBoard = BitBoard> {
     /** Number of boards in total (most likely also 2). */
     private readonly numberOfBoards;
     /** The board states which represent a winning state. */
-    protected abstract readonly winningStates: T[];
+    protected abstract readonly winningStates: Array<BitBoard<T>>;
     /**
      * Creates an instance of Board.
-     * @param width The width of the board.
-     * @param height The height of the board.
-     * @param playerBoardCount How many boards there are representing player positions (most likely 2).
-     * @param extraBoardCount Number of extra boards (most likely 0).
+     * @param width - The width of the game board.
+     * @param height - The height of the game board.
+     * @param playerBoardCount - How many boards there are representing player positions (most likely 2).
+     * @param extraBoardCount - Number of extra boards (most likely 0).
      */
     protected constructor(width: number, height: number, playerBoardCount?: number, extraBoardCount?: number);
-    /** Calculates whether or not the board is full. */
+    /**
+     * Calculates whether or not the board is full.
+     * @returns Whether or not the board is full.
+     */
     get isFull(): boolean;
-    /** Calculates whether or not the board is empty. */
+    /**
+     * Calculates whether or not the board is empty.
+     * @returns Whether or not the board is empty.
+     */
     get isEmpty(): boolean;
     /**
      * Calculates who the winner is.
-     * If the game is not over, the output is false.
-     * If there is a winner, the output is their ID.
-     * If there is a draw, the output is null.
+     * @returns `false` if the game is not over, the player ID if there is a winner, and `null` if there is a draw.
      */
     get winner(): 0 | 1 | false | null;
-    /** Calculates which cells are empty. */
+    /**
+     * Calculates which cells are empty.
+     * @returns The empty cells on the board.
+     */
     get emptyCells(): Position[];
     /** Calculates the heuristic score for a given board state. */
     abstract get heuristic(): number;
     /**
      * Makes a move on the board.
-     * @param move The position of the move.
-     * @param playerId The player who's making the move.
+     * @param move - The position of the move.
+     * @param playerId - The player who's making the move.
      */
     makeMove(move: Position, playerId: number): void;
-    /** Reverses the last move. */
+    /**
+     * Reverses the last move.
+     * @throws {Error} - If there is no move to undo.
+     */
     undoLastMove(): void;
     /**
      * Checks if a move is valid.
-     * @param move The move.
+     * @param move - The position of the move.
      * @returns Whether or not it's valid.
      */
     moveIsValid(move: Position): boolean;
     /**
      * Checks which player is occupying a given cell.
-     * @param cell The cell to check.
+     * @param cell - The cell to check.
      * @returns If the cell is empty, the output is null, otherwise the output is the player's ID.
      */
     cellOccupier(cell: Position): number | null;
     /**
      * Creates a string representation of the board.
-     * @param wrap Whether or not to provide a border for the board.
-     * @param labelX Whether or not to label x.
-     * @param labelY Whether or not to label y.
-     * @param symbols The symbols to use as board pieces.
-     * @param colour Whether or not to colour the pieces.
+     * @param wrap - Whether or not to provide a border for the board.
+     * @param labelX - Whether or not to label x.
+     * @param labelY - Whether or not to label y.
+     * @param symbols - The symbols to use as board pieces.
+     * @param colour - Whether or not to colour the pieces.
      * @returns The string representation.
+     * @throws {Error} - If the symbols are not the same length.
      */
     toString(wrap?: boolean, labelX?: boolean, labelY?: boolean, symbols?: string[], colour?: boolean): string;
     /**
      * Determines if a given player has a line of pieces on the board.
-     * @param playerId The ID of the player.
-     * @param length The number of pieces needed.
-     * @param maxGaps The number of gaps allowed for a line to be valid. Defaults to 0.
+     * @param playerId - The ID of the player to check.
+     * @param length - The number of pieces needed.
+     * @param maxGaps - The number of gaps allowed for a line to be valid. Defaults to 0.
      * @returns How many lines exist.
      */
     hasLine(playerId: number, length: number, maxGaps?: number): number;
     /**
      * Gets a bit index from its coordinates and player ID.
-     * @param move The coordinates.
-     * @param playerId The player ID.
-     * @returns The bit index.
+     * @param move - The coordinates.
+     * @param playerId - The player ID to use.
+     * @returns The bit index of the move.
      */
     protected getBitIndex(move: Position, playerId: number): number;
     /**
      * A BitBoard containing only the player's bits.
-     * @param playerId The player's ID.
+     * @param playerId - The player's ID to get the board for.
      * @returns The player's bits.
      */
-    protected getPlayerBoard(playerId: number): T;
+    protected getPlayerBoard(playerId: number): BitBoard<T>;
     /**
      * Gets a bit index from its coordinates.
-     * @param move The coordinates.
+     * @param move - The coordinates.
      * @returns The bit index.
      */
     private getIndex;
     /**
      * Checks if a move is valid for the given board.
      * Does not check if that cell is already occupied.
-     * @param position The position to check.
+     * @param position - The position to check.
      * @returns Whether or not that cell exists on the board.
      */
     private isValidPosition;

package/build/base/board.js

@@ -1,14 +1,17 @@
 import IntBitBoard from "../bitBoard/intBitBoard.js";
 import LongInt from "../bitBoard/longInt.js";
 import LongIntBitBoard from "../bitBoard/longIntBitBoard.js";
-/** Represents a game board. */
+/**
+ * Represents a game board.
+ * @template T - The type of the numeric data.
+ */
 export default class Board {
     /** Contains the data stored in a BitBoard. */
     bitBoard;
-    /** The width of the board. */
-    boardWidth;
-    /** The height of the board. */
-    boardHeight;
+    /** The width of the game board. */
+    width;
+    /** The height of the game board. */
+    height;
     /** A stack of moves. */
     moves = [];
     /** How many boards there are representing player positions (most likely 2). */
@@ -17,38 +20,46 @@ export default class Board {
     numberOfBoards;
     /**
      * Creates an instance of Board.
-     * @param width The width of the board.
-     * @param height The height of the board.
-     * @param playerBoardCount How many boards there are representing player positions (most likely 2).
-     * @param extraBoardCount Number of extra boards (most likely 0).
+     * @param width - The width of the game board.
+     * @param height - The height of the game board.
+     * @param playerBoardCount - How many boards there are representing player positions (most likely 2).
+     * @param extraBoardCount - Number of extra boards (most likely 0).
      */
     constructor(width, height, playerBoardCount = 2, extraBoardCount = 0) {
-        this.boardWidth = width;
-        this.boardHeight = height;
+        this.width = width;
+        this.height = height;
         this.numberOfPlayerBoards = playerBoardCount;
         this.numberOfBoards = this.numberOfPlayerBoards + extraBoardCount;
-        const totalBits = this.boardWidth * this.boardHeight * this.numberOfBoards;
-        this.bitBoard = (totalBits > 32 ? new LongIntBitBoard(Math.ceil(totalBits / 32)) : new IntBitBoard());
+        const totalBits = this.width * this.height * this.numberOfBoards;
+        this.bitBoard = (totalBits > 32
+            ? new LongIntBitBoard(Math.ceil(totalBits / 32))
+            : new IntBitBoard());
     }
-    /** Calculates whether or not the board is full. */
+    /**
+     * Calculates whether or not the board is full.
+     * @returns Whether or not the board is full.
+     */
     get isFull() {
         let isFull = (this.bitBoard instanceof LongIntBitBoard
-            ? new LongIntBitBoard(Math.ceil(this.boardWidth * this.boardHeight / 32))
+            ? new LongIntBitBoard(Math.ceil(this.width * this.height / 32))
             : new IntBitBoard());
         for (let i = 0; i < this.numberOfPlayerBoards; i++)
             isFull = isFull.or(this.getPlayerBoard(i));
-        const fullValue = this.bitBoard instanceof LongIntBitBoard
+        const fullValue = (this.bitBoard instanceof LongIntBitBoard
             ? new LongInt([
-                ...Array(Math.ceil(this.boardWidth * this.boardHeight / 32) - 1).fill(~0 >>> 0),
-                2 ** (this.boardWidth * this.boardHeight - (Math.ceil(this.boardWidth * this.boardHeight / 32) - 1) * 32) - 1,
+                ...Array(Math.ceil(this.width * this.height / 32) - 1).fill(~0 >>> 0),
+                2 ** (this.width * this.height - (Math.ceil(this.width * this.height / 32) - 1) * 32) - 1,
             ])
-            : 2 ** (this.boardWidth * this.boardHeight) - 1;
+            : 2 ** (this.width * this.height) - 1);
         return isFull.equals(fullValue);
     }
-    /** Calculates whether or not the board is empty. */
+    /**
+     * Calculates whether or not the board is empty.
+     * @returns Whether or not the board is empty.
+     */
     get isEmpty() {
         let isEmpty = (this.bitBoard instanceof LongIntBitBoard
-            ? new LongIntBitBoard(Math.ceil(this.boardWidth * this.boardHeight / 32))
+            ? new LongIntBitBoard(Math.ceil(this.width * this.height / 32))
             : new IntBitBoard());
         for (let i = 0; i < this.numberOfPlayerBoards; i++)
             isEmpty = isEmpty.or(this.getPlayerBoard(i));
@@ -56,9 +67,7 @@ export default class Board {
     }
     /**
      * Calculates who the winner is.
-     * If the game is not over, the output is false.
-     * If there is a winner, the output is their ID.
-     * If there is a draw, the output is null.
+     * @returns `false` if the game is not over, the player ID if there is a winner, and `null` if there is a draw.
      */
     get winner() {
         const playerOneBoard = this.getPlayerBoard(0);
@@ -73,11 +82,14 @@ export default class Board {
             return null;
         return false;
     }
-    /** Calculates which cells are empty. */
+    /**
+     * Calculates which cells are empty.
+     * @returns The empty cells on the board.
+     */
     get emptyCells() {
         const emptyCells = [];
-        for (let y = 0; y < this.boardHeight; y++) {
-            for (let x = 0; x < this.boardWidth; x++) {
+        for (let y = 0; y < this.height; y++) {
+            for (let x = 0; x < this.width; x++) {
                 if (this.cellOccupier({ x, y }) === null)
                     emptyCells.push({ x, y });
             }
@@ -86,15 +98,18 @@ export default class Board {
     }
     /**
      * Makes a move on the board.
-     * @param move The position of the move.
-     * @param playerId The player who's making the move.
+     * @param move - The position of the move.
+     * @param playerId - The player who's making the move.
      */
     makeMove(move, playerId) {
         const bit = this.getBitIndex(move, playerId);
         this.moves.push(bit);
         this.bitBoard.setBit(bit);
     }
-    /** Reverses the last move. */
+    /**
+     * Reverses the last move.
+     * @throws {Error} - If there is no move to undo.
+     */
     undoLastMove() {
         const lastMove = this.moves.pop();
         if (lastMove === undefined)
@@ -103,7 +118,7 @@ export default class Board {
     }
     /**
      * Checks if a move is valid.
-     * @param move The move.
+     * @param move - The position of the move.
      * @returns Whether or not it's valid.
      */
     moveIsValid(move) {
@@ -111,7 +126,7 @@ export default class Board {
     }
     /**
      * Checks which player is occupying a given cell.
-     * @param cell The cell to check.
+     * @param cell - The cell to check.
      * @returns If the cell is empty, the output is null, otherwise the output is the player's ID.
      */
     cellOccupier(cell) {
@@ -123,12 +138,13 @@ export default class Board {
     }
     /**
      * Creates a string representation of the board.
-     * @param wrap Whether or not to provide a border for the board.
-     * @param labelX Whether or not to label x.
-     * @param labelY Whether or not to label y.
-     * @param symbols The symbols to use as board pieces.
-     * @param colour Whether or not to colour the pieces.
+     * @param wrap - Whether or not to provide a border for the board.
+     * @param labelX - Whether or not to label x.
+     * @param labelY - Whether or not to label y.
+     * @param symbols - The symbols to use as board pieces.
+     * @param colour - Whether or not to colour the pieces.
      * @returns The string representation.
+     * @throws {Error} - If the symbols are not the same length.
      */
     toString(wrap = true, labelX = true, labelY = true, symbols = ["X", "O"], colour = true) {
         if (symbols.length !== this.numberOfPlayerBoards)
@@ -139,39 +155,39 @@ export default class Board {
         const matchCellSpace = new RegExp(`.{${symbolLength + 2}}`, "gu");
         const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
         const xLabels = labelX
-            ? `${alphabet.slice(0, this.boardWidth)
+            ? `${alphabet.slice(0, this.width)
                 .split("")
                 .map((letter) => ` ${letter.padStart(symbolLength)} `)
                 .join("")
                 .match(matchCellSpace)
                 .join(" ")
-                .padStart(4 * this.boardWidth - 1 + Number(wrap) + Number(labelY))}\n`
+                .padStart(4 * this.width - 1 + Number(wrap) + Number(labelY))}\n`
             : "";
         const topBorder = wrap
             ? `${labelY ? " " : ""}${"\u250C" /* GridLines.TopLeft */}${"\u2500" /* GridLines.Horizontal */
-                .repeat(this.boardWidth * (symbolLength + 2))
+                .repeat(this.width * (symbolLength + 2))
                 .match(matchCellSpace)
                 .join("\u252C" /* GridLines.TTop */)}${"\u2510" /* GridLines.TopRight */}\n`
             : "";
         const bottomBorder = wrap
             ? `${labelY ? " " : ""}${"\u2514" /* GridLines.BottomLeft */}${"\u2500" /* GridLines.Horizontal */
-                .repeat(this.boardWidth * (symbolLength + 2))
+                .repeat(this.width * (symbolLength + 2))
                 .match(matchCellSpace)
                 .join("\u2534" /* GridLines.TBottom */)}${"\u2518" /* GridLines.BottomRight */}`
             : "";
         const rowSeparator = `${labelY ? " " : ""}${wrap ? "\u251C" /* GridLines.TLeft */ : ""}${"\u2500" /* GridLines.Horizontal */
-            .repeat(this.boardWidth * (symbolLength + 2))
+            .repeat(this.width * (symbolLength + 2))
             .match(matchCellSpace)
             .join("\u253C" /* GridLines.Cross */)}${wrap ? "\u2524" /* GridLines.TRight */ : ""}\n`;
         const rows = [];
-        for (let y = 0; y < this.boardHeight; y++) {
+        for (let y = 0; y < this.height; y++) {
             const yLabel = labelY ? `${y + 1}` : "";
             const leftBorder = wrap ? "\u2502" /* GridLines.Vertical */ : "";
             const rightBorder = wrap ? "\u2502" /* GridLines.Vertical */ : "";
             let row = `${yLabel}${leftBorder}`;
-            for (let x = 0; x < this.boardWidth; x++) {
+            for (let x = 0; x < this.width; x++) {
                 const cell = { x, y };
-                const bar = x === this.boardWidth - 1 ? "" : "\u2502" /* GridLines.Vertical */;
+                const bar = x === this.width - 1 ? "" : "\u2502" /* GridLines.Vertical */;
                 const cellOccupier = this.cellOccupier(cell);
                 if (cellOccupier === null) {
                     row += ` ${" ".repeat(symbolLength)} ${bar}`;
@@ -188,15 +204,20 @@ export default class Board {
     }
     /**
      * Determines if a given player has a line of pieces on the board.
-     * @param playerId The ID of the player.
-     * @param length The number of pieces needed.
-     * @param maxGaps The number of gaps allowed for a line to be valid. Defaults to 0.
+     * @param playerId - The ID of the player to check.
+     * @param length - The number of pieces needed.
+     * @param maxGaps - The number of gaps allowed for a line to be valid. Defaults to 0.
      * @returns How many lines exist.
      */
     hasLine(playerId, length, maxGaps = 0) {
-        if (length > Math.max(this.boardWidth, this.boardHeight))
+        if (length > Math.max(this.width, this.height))
             return 0;
-        const DIRECTIONS = [{ x: 1, y: 0 }, { x: 0, y: 1 }, { x: 1, y: 1 }, { x: 1, y: -1 }];
+        const DIRECTIONS = [
+            { x: 1, y: 0 },
+            { x: 0, y: 1 },
+            { x: 1, y: 1 },
+            { x: 1, y: -1 },
+        ];
         let lineCount = 0;
         let gaps = [0, 0, 0, 0];
         let lengths = [0, 0, 0, 0];
@@ -210,8 +231,8 @@ export default class Board {
                     lengths[direction]++;
             }
         };
-        for (let x = 0; x < this.boardWidth; x++) {
-            for (let y = 0; y < this.boardHeight; y++) {
+        for (let x = 0; x < this.width; x++) {
+            for (let y = 0; y < this.height; y++) {
                 gaps = [0, 0, 0, 0];
                 lengths = [0, 0, 0, 0];
                 for (let i = 0; i < length; i++) {
@@ -229,41 +250,41 @@ export default class Board {
     }
     /**
      * Gets a bit index from its coordinates and player ID.
-     * @param move The coordinates.
-     * @param playerId The player ID.
-     * @returns The bit index.
+     * @param move - The coordinates.
+     * @param playerId - The player ID to use.
+     * @returns The bit index of the move.
      */
     getBitIndex(move, playerId) {
         const moveIndex = this.getIndex(move);
-        const bitBoardMoveIndex = moveIndex + this.boardWidth * this.boardHeight * playerId;
+        const bitBoardMoveIndex = moveIndex + this.width * this.height * playerId;
         return bitBoardMoveIndex;
     }
     /**
      * A BitBoard containing only the player's bits.
-     * @param playerId The player's ID.
+     * @param playerId - The player's ID to get the board for.
      * @returns The player's bits.
      */
     getPlayerBoard(playerId) {
         const totalBits = (this.bitBoard instanceof LongIntBitBoard ? this.bitBoard.data.wordCount : 1) * 32;
-        const boardSize = this.boardWidth * this.boardHeight;
+        const boardSize = this.width * this.height;
         return this.bitBoard.leftShift(totalBits - boardSize * (playerId + 1)).rightShift(totalBits - boardSize);
     }
     /**
      * Gets a bit index from its coordinates.
-     * @param move The coordinates.
+     * @param move - The coordinates.
      * @returns The bit index.
      */
     getIndex(move) {
-        return this.boardWidth * move.y + move.x;
+        return this.width * move.y + move.x;
     }
     /**
      * Checks if a move is valid for the given board.
      * Does not check if that cell is already occupied.
-     * @param position The position to check.
+     * @param position - The position to check.
      * @returns Whether or not that cell exists on the board.
      */
     isValidPosition(position) {
-        return position.x >= 0 && position.x < this.boardWidth && position.y >= 0 && position.y < this.boardHeight;
+        return position.x >= 0 && position.x < this.width && position.y >= 0 && position.y < this.height;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"board.js","sourceRoot":"","sources":["../../src/base/board.ts"],"names":[],"mappings":"AACA,OAAO,WAAW,MAAM,4BAA4B,CAAC;AACrD,OAAO,OAAO,MAAM,wBAAwB,CAAC;AAC7C,OAAO,eAAe,MAAM,gCAAgC,CAAC;AAsB7D,+BAA+B;AAC/B,MAAM,CAAC,OAAO,OAAgB,KAAK;IAC/B,8CAA8C;IAC3B,QAAQ,CAAI;IAE/B,8BAA8B;IACX,UAAU,CAAS;IAEtC,+BAA+B;IACZ,WAAW,CAAS;IAEvC,wBAAwB;IACL,KAAK,GAAa,EAAE,CAAC;IAExC,+EAA+E;IAC9D,oBAAoB,CAAS;IAE9C,sDAAsD;IACrC,cAAc,CAAS;IAKxC;;;;;;OAMG;IACH,YAAsB,KAAa,EAAE,MAAc,EAAE,mBAA2B,CAAC,EAAE,kBAA0B,CAAC;QAC1G,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;QAC1B,IAAI,CAAC,oBAAoB,GAAG,gBAAgB,CAAC;QAC7C,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,oBAAoB,GAAG,eAAe,CAAC;QAClE,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC;QAE3E,IAAI,CAAC,QAAQ,GAAG,CAAC,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAM,CAAC;IAC/G,CAAC;IAED,mDAAmD;IACnD,IAAW,MAAM;QACb,IAAI,MAAM,GAAG,CAAC,IAAI,CAAC,QAAQ,YAAY,eAAe;YAClD,CAAC,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC,CAAC;YACzE,CAAC,CAAC,IAAI,WAAW,EAAE,CAAM,CAAC;QAE9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC,EAAE;YAC9C,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;QAC/C,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,YAAY,eAAe;YACtD,CAAC,CAAC,IAAI,OAAO,CAAC;gBACV,GAAG,KAAK,CAAS,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;gBACvF,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC;aAChH,CAAC;YACF,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QAEpD,OAAO,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAED,oDAAoD;IACpD,IAAW,OAAO;QACd,IAAI,OAAO,GAAG,CAAC,IAAI,CAAC,QAAQ,YAAY,eAAe;YACnD,CAAC,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC,CAAC;YACzE,CAAC,CAAC,IAAI,WAAW,EAAE,CAAM,CAAC;QAE9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC,EAAE;YAC9C,OAAO,GAAG,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;QAEjD,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAC7B,CAAC;IAED;;;;;OAKG;IACH,IAAW,MAAM;QACb,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;QAC9C,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;QAE9C,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACrC,IAAI,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;gBACvC,OAAO,CAAC,CAAC;YAEb,IAAI,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;gBACvC,OAAO,CAAC,CAAC;QACjB,CAAC;QAED,IAAI,IAAI,CAAC,MAAM;YACX,OAAO,IAAI,CAAC;QAEhB,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,wCAAwC;IACxC,IAAW,UAAU;QACjB,MAAM,UAAU,GAAe,EAAE,CAAC;QAElC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;gBACvC,IAAI,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,IAAI;oBACpC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;YAClC,CAAC;QACL,CAAC;QAED,OAAO,UAAU,CAAC;IACtB,CAAC;IAKD;;;;OAIG;IACI,QAAQ,CAAC,IAAc,EAAE,QAAgB;QAC5C,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QAE7C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACrB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IAED,8BAA8B;IACvB,YAAY;QACf,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;QAElC,IAAI,QAAQ,KAAK,SAAS;YACtB,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;QAExC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACrC,CAAC;IAED;;;;OAIG;IACI,WAAW,CAAC,IAAc;QAC7B,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC;IAC1E,CAAC;IAED;;;;OAIG;IACI,YAAY,CAAC,IAAc;QAC9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC,EAAE,EAAE,CAAC;YACjD,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;gBACrD,OAAO,CAAC,CAAC;QACjB,CAAC;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;;OAQG;IACI,QAAQ,CACX,OAAgB,IAAI,EACpB,SAAkB,IAAI,EACtB,SAAkB,IAAI,EACtB,UAAoB,CAAC,GAAG,EAAE,GAAG,CAAC,EAC9B,SAAkB,IAAI;QAEtB,IAAI,OAAO,CAAC,MAAM,KAAK,IAAI,CAAC,oBAAoB;YAC5C,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;QAEzC,MAAM,YAAY,GAAG,OAAO,CAAC,CAAC,CAAE,CAAC,MAAM,CAAC;QAExC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,YAAY,CAAC;YAC9C,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;QAExD,MAAM,cAAc,GAAG,IAAI,MAAM,CAAC,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAClE,MAAM,QAAQ,GAAG,sDAAsD,CAAC;QACxE,MAAM,OAAO,GAAG,MAAM;YAClB,CAAC,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC;iBAClC,KAAK,CAAC,EAAE,CAAC;iBACT,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC,GAAG,CAAC;iBACrD,IAAI,CAAC,EAAE,CAAC;iBACR,KAAK,CAAC,cAAc,CAAE;iBACtB,IAAI,CAAC,GAAG,CAAC;iBACT,QAAQ,CAAC,CAAC,GAAG,IAAI,CAAC,UAAU,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CACrE,IAAI;YACJ,CAAC,CAAC,EAAE,CAAC;QACT,MAAM,SAAS,GAAG,IAAI;YAClB,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,gCAAiB,GAAG;iBACxC,MAAM,CAAC,IAAI,CAAC,UAAU,GAAG,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC;iBAC5C,KAAK,CAAC,cAAc,CAAE;iBACtB,IAAI,+BAAgB,GAAG,iCAAkB,IAAI;YAClD,CAAC,CAAC,EAAE,CAAC;QACT,MAAM,YAAY,GAAG,IAAI;YACrB,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,mCAAoB,GAAG;iBAC3C,MAAM,CAAC,IAAI,CAAC,UAAU,GAAG,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC;iBAC5C,KAAK,CAAC,cAAc,CAAE;iBACtB,IAAI,kCAAmB,GAAG,oCAAqB,EAAE;YACtD,CAAC,CAAC,EAAE,CAAC;QACT,MAAM,YAAY,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,gCAAiB,CAAC,CAAC,EAAE,GAAG;aACrE,MAAM,CAAC,IAAI,CAAC,UAAU,GAAG,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC;aAC5C,KAAK,CAAC,cAAc,CAAE;aACtB,IAAI,gCAAiB,GAAG,IAAI,CAAC,CAAC,iCAAkB,CAAC,CAAC,EAAE,IAAI,CAAC;QAC9D,MAAM,IAAI,GAAa,EAAE,CAAC;QAE1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,MAAM,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACxC,MAAM,UAAU,GAAG,IAAI,CAAC,CAAC,mCAAoB,CAAC,CAAC,EAAE,CAAC;YAClD,MAAM,WAAW,GAAG,IAAI,CAAC,CAAC,mCAAoB,CAAC,CAAC,EAAE,CAAC;YACnD,IAAI,GAAG,GAAG,GAAG,MAAM,GAAG,UAAU,EAAE,CAAC;YAEnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;gBACvC,MAAM,IAAI,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;gBACtB,MAAM,GAAG,GAAG,CAAC,KAAK,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,kCAAmB,CAAC;gBAChE,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;gBAE7C,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;oBACxB,GAAG,IAAI,IAAI,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,GAAG,EAAE,CAAC;gBACjD,CAAC;qBAAM,CAAC;oBACJ,GAAG,IAAI,IAAI,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,YAAY,CAAE,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;wBACzD,GAAG,OAAO,CAAC,YAAY,CAAC,EAAE;wBAC1B,GAAG,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,GAAG,EAAE,CAAC;gBAC5C,CAAC;YACL,CAAC;YACD,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,WAAW,IAAI,CAAC,CAAC;QACxC,CAAC;QAED,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,YAAY,EAAE,CAAC;IAC7E,CAAC;IAED;;;;;;OAMG;IACI,OAAO,CAAC,QAAgB,EAAE,MAAc,EAAE,UAAkB,CAAC;QAChE,IAAI,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,WAAW,CAAC;YACpD,OAAO,CAAC,CAAC;QAEb,MAAM,UAAU,GAA6C,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;QAC/H,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,IAAI,IAAI,GAAqC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAC1D,IAAI,OAAO,GAAqC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAC7D,MAAM,SAAS,GAAG,CAAC,CAAS,EAAE,CAAS,EAAE,SAAwB,EAAQ,EAAE;YACvE,MAAM,IAAI,GAAG,EAAE,CAAC,EAAE,CAAC,EAAc,CAAC;YAElC,IAAI,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC7B,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;gBAE7C,IAAI,YAAY,KAAK,IAAI;oBACrB,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;qBACjB,IAAI,YAAY,KAAK,QAAQ;oBAC9B,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YAC7B,CAAC;QACL,CAAC,CAAC;QAEF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;YACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC;gBACxC,IAAI,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;gBACpB,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;gBACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC9B,KAAK,IAAI,CAAC,GAAG,CAAkB,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;wBAC1C,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,OAAO;4BACjB,SAAS;wBAEb,SAAS,CAAC,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;wBAE/D,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,MAAM;4BACrB,SAAS,EAAE,CAAC;oBACpB,CAAC;gBACL,CAAC;YACL,CAAC;QACL,CAAC;QAED,OAAO,SAAS,CAAC;IACrB,CAAC;IAED;;;;;OAKG;IACO,WAAW,CAAC,IAAc,EAAE,QAAgB;QAClD,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACtC,MAAM,iBAAiB,GAAG,SAAS,GAAG,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC;QAEpF,OAAO,iBAAiB,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACO,cAAc,CAAC,QAAgB;QACrC,MAAM,SAAS,GAAG,CAAC,IAAI,CAAC,QAAQ,YAAY,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;QACrG,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC;QAErD,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,SAAS,GAAG,SAAS,GAAG,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;IAC7G,CAAC;IAED;;;;OAIG;IACK,QAAQ,CAAC,IAAc;QAC3B,OAAO,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;OAKG;IACK,eAAe,CAAC,QAAkB;QACtC,OAAO,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,QAAQ,CAAC,CAAC,GAAG,IAAI,CAAC,UAAU,IAAI,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,QAAQ,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC;IAC/G,CAAC;CACJ","sourcesContent":["import type BitBoard from \"../bitBoard/bitBoard.js\";\nimport IntBitBoard from \"../bitBoard/intBitBoard.js\";\nimport LongInt from \"../bitBoard/longInt.js\";\nimport LongIntBitBoard from \"../bitBoard/longIntBitBoard.js\";\n\nexport type Position = {\n    y: number;\n    x: number;\n};\n\n/** Defines the characters used to draw a grid. */\nexport const enum GridLines {\n    Horizontal = \"\\u2500\",\n    Vertical = \"\\u2502\",\n    TopLeft = \"\\u250C\",\n    TopRight = \"\\u2510\",\n    BottomLeft = \"\\u2514\",\n    BottomRight = \"\\u2518\",\n    TLeft = \"\\u251C\",\n    TRight = \"\\u2524\",\n    TTop = \"\\u252C\",\n    TBottom = \"\\u2534\",\n    Cross = \"\\u253C\",\n}\n\n/** Represents a game board. */\nexport default abstract class Board<T extends BitBoard = BitBoard> {\n    /** Contains the data stored in a BitBoard. */\n    protected readonly bitBoard: T;\n\n    /** The width of the board. */\n    protected readonly boardWidth: number;\n\n    /** The height of the board. */\n    protected readonly boardHeight: number;\n\n    /** A stack of moves. */\n    protected readonly moves: number[] = [];\n\n    /** How many boards there are representing player positions (most likely 2). */\n    private readonly numberOfPlayerBoards: number;\n\n    /** Number of boards in total (most likely also 2). */\n    private readonly numberOfBoards: number;\n\n    /** The board states which represent a winning state. */\n    protected abstract readonly winningStates: T[];\n\n    /**\n     * Creates an instance of Board.\n     * @param width The width of the board.\n     * @param height The height of the board.\n     * @param playerBoardCount How many boards there are representing player positions (most likely 2).\n     * @param extraBoardCount Number of extra boards (most likely 0).\n     */\n    protected constructor(width: number, height: number, playerBoardCount: number = 2, extraBoardCount: number = 0) {\n        this.boardWidth = width;\n        this.boardHeight = height;\n        this.numberOfPlayerBoards = playerBoardCount;\n        this.numberOfBoards = this.numberOfPlayerBoards + extraBoardCount;\n        const totalBits = this.boardWidth * this.boardHeight * this.numberOfBoards;\n\n        this.bitBoard = (totalBits > 32 ? new LongIntBitBoard(Math.ceil(totalBits / 32)) : new IntBitBoard()) as T;\n    }\n\n    /** Calculates whether or not the board is full. */\n    public get isFull(): boolean {\n        let isFull = (this.bitBoard instanceof LongIntBitBoard\n            ? new LongIntBitBoard(Math.ceil(this.boardWidth * this.boardHeight / 32))\n            : new IntBitBoard()) as T;\n\n        for (let i = 0; i < this.numberOfPlayerBoards; i++)\n            isFull = isFull.or(this.getPlayerBoard(i));\n        const fullValue = this.bitBoard instanceof LongIntBitBoard\n            ? new LongInt([\n                ...Array<number>(Math.ceil(this.boardWidth * this.boardHeight / 32) - 1).fill(~0 >>> 0),\n                2 ** (this.boardWidth * this.boardHeight - (Math.ceil(this.boardWidth * this.boardHeight / 32) - 1) * 32) - 1,\n            ])\n            : 2 ** (this.boardWidth * this.boardHeight) - 1;\n\n        return isFull.equals(fullValue);\n    }\n\n    /** Calculates whether or not the board is empty. */\n    public get isEmpty(): boolean {\n        let isEmpty = (this.bitBoard instanceof LongIntBitBoard\n            ? new LongIntBitBoard(Math.ceil(this.boardWidth * this.boardHeight / 32))\n            : new IntBitBoard()) as T;\n\n        for (let i = 0; i < this.numberOfPlayerBoards; i++)\n            isEmpty = isEmpty.or(this.getPlayerBoard(i));\n\n        return isEmpty.equals(0);\n    }\n\n    /**\n     * Calculates who the winner is.\n     * If the game is not over, the output is false.\n     * If there is a winner, the output is their ID.\n     * If there is a draw, the output is null.\n     */\n    public get winner(): 0 | 1 | false | null {\n        const playerOneBoard = this.getPlayerBoard(0);\n        const playerTwoBoard = this.getPlayerBoard(1);\n\n        for (const state of this.winningStates) {\n            if (playerOneBoard.and(state).equals(state))\n                return 0;\n\n            if (playerTwoBoard.and(state).equals(state))\n                return 1;\n        }\n\n        if (this.isFull)\n            return null;\n\n        return false;\n    }\n\n    /** Calculates which cells are empty. */\n    public get emptyCells(): Position[] {\n        const emptyCells: Position[] = [];\n\n        for (let y = 0; y < this.boardHeight; y++) {\n            for (let x = 0; x < this.boardWidth; x++) {\n                if (this.cellOccupier({ x, y }) === null)\n                    emptyCells.push({ x, y });\n            }\n        }\n\n        return emptyCells;\n    }\n\n    /** Calculates the heuristic score for a given board state. */\n    public abstract get heuristic(): number;\n\n    /**\n     * Makes a move on the board.\n     * @param move The position of the move.\n     * @param playerId The player who's making the move.\n     */\n    public makeMove(move: Position, playerId: number): void {\n        const bit = this.getBitIndex(move, playerId);\n\n        this.moves.push(bit);\n        this.bitBoard.setBit(bit);\n    }\n\n    /** Reverses the last move. */\n    public undoLastMove(): void {\n        const lastMove = this.moves.pop();\n\n        if (lastMove === undefined)\n            throw new Error(\"No move to undo.\");\n\n        this.bitBoard.clearBit(lastMove);\n    }\n\n    /**\n     * Checks if a move is valid.\n     * @param move The move.\n     * @returns Whether or not it's valid.\n     */\n    public moveIsValid(move: Position): boolean {\n        return this.isValidPosition(move) && this.cellOccupier(move) === null;\n    }\n\n    /**\n     * Checks which player is occupying a given cell.\n     * @param cell The cell to check.\n     * @returns If the cell is empty, the output is null, otherwise the output is the player's ID.\n     */\n    public cellOccupier(cell: Position): number | null {\n        for (let i = 0; i < this.numberOfPlayerBoards; i++) {\n            if (this.bitBoard.getBit(this.getBitIndex(cell, i)) === 1)\n                return i;\n        }\n\n        return null;\n    }\n\n    /**\n     * Creates a string representation of the board.\n     * @param wrap Whether or not to provide a border for the board.\n     * @param labelX Whether or not to label x.\n     * @param labelY Whether or not to label y.\n     * @param symbols The symbols to use as board pieces.\n     * @param colour Whether or not to colour the pieces.\n     * @returns The string representation.\n     */\n    public toString(\n        wrap: boolean = true,\n        labelX: boolean = true,\n        labelY: boolean = true,\n        symbols: string[] = [\"X\", \"O\"],\n        colour: boolean = true,\n    ): string {\n        if (symbols.length !== this.numberOfPlayerBoards)\n            throw new Error(\"Too many symbols.\");\n\n        const symbolLength = symbols[0]!.length;\n\n        if (symbols.some((s) => s.length !== symbolLength))\n            throw new Error(\"Symbols must be the same length.\");\n\n        const matchCellSpace = new RegExp(`.{${symbolLength + 2}}`, \"gu\");\n        const alphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\";\n        const xLabels = labelX\n            ? `${alphabet.slice(0, this.boardWidth)\n                .split(\"\")\n                .map((letter) => ` ${letter.padStart(symbolLength)} `)\n                .join(\"\")\n                .match(matchCellSpace)!\n                .join(\" \")\n                .padStart(4 * this.boardWidth - 1 + Number(wrap) + Number(labelY))\n            }\\n`\n            : \"\";\n        const topBorder = wrap\n            ? `${labelY ? \" \" : \"\"}${GridLines.TopLeft}${GridLines.Horizontal\n                .repeat(this.boardWidth * (symbolLength + 2))\n                .match(matchCellSpace)!\n                .join(GridLines.TTop)}${GridLines.TopRight}\\n`\n            : \"\";\n        const bottomBorder = wrap\n            ? `${labelY ? \" \" : \"\"}${GridLines.BottomLeft}${GridLines.Horizontal\n                .repeat(this.boardWidth * (symbolLength + 2))\n                .match(matchCellSpace)!\n                .join(GridLines.TBottom)}${GridLines.BottomRight}`\n            : \"\";\n        const rowSeparator = `${labelY ? \" \" : \"\"}${wrap ? GridLines.TLeft : \"\"}${GridLines.Horizontal\n            .repeat(this.boardWidth * (symbolLength + 2))\n            .match(matchCellSpace)!\n            .join(GridLines.Cross)}${wrap ? GridLines.TRight : \"\"}\\n`;\n        const rows: string[] = [];\n\n        for (let y = 0; y < this.boardHeight; y++) {\n            const yLabel = labelY ? `${y + 1}` : \"\";\n            const leftBorder = wrap ? GridLines.Vertical : \"\";\n            const rightBorder = wrap ? GridLines.Vertical : \"\";\n            let row = `${yLabel}${leftBorder}`;\n\n            for (let x = 0; x < this.boardWidth; x++) {\n                const cell = { x, y };\n                const bar = x === this.boardWidth - 1 ? \"\" : GridLines.Vertical;\n                const cellOccupier = this.cellOccupier(cell);\n\n                if (cellOccupier === null) {\n                    row += ` ${\" \".repeat(symbolLength)} ${bar}`;\n                } else {\n                    row += ` ${colour ? `\\x1b[${[91, 93][cellOccupier]!}m` : \"\"}` +\n                        `${symbols[cellOccupier]}` +\n                        `${colour ? \"\\x1b[0m\" : \"\"} ${bar}`;\n                }\n            }\n            rows.push(`${row}${rightBorder}\\n`);\n        }\n\n        return `${xLabels}${topBorder}${rows.join(rowSeparator)}${bottomBorder}`;\n    }\n\n    /**\n     * Determines if a given player has a line of pieces on the board.\n     * @param playerId The ID of the player.\n     * @param length The number of pieces needed.\n     * @param maxGaps The number of gaps allowed for a line to be valid. Defaults to 0.\n     * @returns How many lines exist.\n     */\n    public hasLine(playerId: number, length: number, maxGaps: number = 0): number {\n        if (length > Math.max(this.boardWidth, this.boardHeight))\n            return 0;\n\n        const DIRECTIONS: [Position, Position, Position, Position] = [{ x: 1, y: 0 }, { x: 0, y: 1 }, { x: 1, y: 1 }, { x: 1, y: -1 }];\n        let lineCount = 0;\n        let gaps: [number, number, number, number] = [0, 0, 0, 0];\n        let lengths: [number, number, number, number] = [0, 0, 0, 0];\n        const checkCell = (x: number, y: number, direction: 0 | 1 | 2 | 3): void => {\n            const cell = { x, y } as Position;\n\n            if (this.isValidPosition(cell)) {\n                const cellOccupier = this.cellOccupier(cell);\n\n                if (cellOccupier === null)\n                    gaps[direction]++;\n                else if (cellOccupier === playerId)\n                    lengths[direction]++;\n            }\n        };\n\n        for (let x = 0; x < this.boardWidth; x++) {\n            for (let y = 0; y < this.boardHeight; y++) {\n                gaps = [0, 0, 0, 0];\n                lengths = [0, 0, 0, 0];\n                for (let i = 0; i < length; i++) {\n                    for (let j = 0 as 0 | 1 | 2 | 3; j < 4; j++) {\n                        if (gaps[j] > maxGaps)\n                            continue;\n\n                        checkCell(x + i * DIRECTIONS[j].x, y + i * DIRECTIONS[j].y, j);\n\n                        if (lengths[j] === length)\n                            lineCount++;\n                    }\n                }\n            }\n        }\n\n        return lineCount;\n    }\n\n    /**\n     * Gets a bit index from its coordinates and player ID.\n     * @param move The coordinates.\n     * @param playerId The player ID.\n     * @returns The bit index.\n     */\n    protected getBitIndex(move: Position, playerId: number): number {\n        const moveIndex = this.getIndex(move);\n        const bitBoardMoveIndex = moveIndex + this.boardWidth * this.boardHeight * playerId;\n\n        return bitBoardMoveIndex;\n    }\n\n    /**\n     * A BitBoard containing only the player's bits.\n     * @param playerId The player's ID.\n     * @returns The player's bits.\n     */\n    protected getPlayerBoard(playerId: number): T {\n        const totalBits = (this.bitBoard instanceof LongIntBitBoard ? this.bitBoard.data.wordCount : 1) * 32;\n        const boardSize = this.boardWidth * this.boardHeight;\n\n        return this.bitBoard.leftShift(totalBits - boardSize * (playerId + 1)).rightShift(totalBits - boardSize);\n    }\n\n    /**\n     * Gets a bit index from its coordinates.\n     * @param move The coordinates.\n     * @returns The bit index.\n     */\n    private getIndex(move: Position): number {\n        return this.boardWidth * move.y + move.x;\n    }\n\n    /**\n     * Checks if a move is valid for the given board.\n     * Does not check if that cell is already occupied.\n     * @param position The position to check.\n     * @returns Whether or not that cell exists on the board.\n     */\n    private isValidPosition(position: Position): boolean {\n        return position.x >= 0 && position.x < this.boardWidth && position.y >= 0 && position.y < this.boardHeight;\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"board.js","sourceRoot":"","sources":["../../src/base/board.ts"],"names":[],"mappings":"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","sourcesContent":["import type BitBoard from \"../bitBoard/bitBoard.js\";\nimport IntBitBoard from \"../bitBoard/intBitBoard.js\";\nimport LongInt from \"../bitBoard/longInt.js\";\nimport LongIntBitBoard from \"../bitBoard/longIntBitBoard.js\";\n\nexport type Position = {\n    y: number;\n    x: number;\n};\n\n/** Defines the characters used to draw a grid. */\nexport const enum GridLines {\n    Horizontal = \"\\u2500\",\n    Vertical = \"\\u2502\",\n    TopLeft = \"\\u250C\",\n    TopRight = \"\\u2510\",\n    BottomLeft = \"\\u2514\",\n    BottomRight = \"\\u2518\",\n    TLeft = \"\\u251C\",\n    TRight = \"\\u2524\",\n    TTop = \"\\u252C\",\n    TBottom = \"\\u2534\",\n    Cross = \"\\u253C\",\n}\n\n/**\n * Represents a game board.\n * @template T - The type of the numeric data.\n */\nexport default abstract class Board<T extends LongInt | number> {\n    /** Contains the data stored in a BitBoard. */\n    protected readonly bitBoard: BitBoard<T>;\n\n    /** The width of the game board. */\n    protected readonly width: number;\n\n    /** The height of the game board. */\n    protected readonly height: number;\n\n    /** A stack of moves. */\n    protected readonly moves: number[] = [];\n\n    /** How many boards there are representing player positions (most likely 2). */\n    private readonly numberOfPlayerBoards: number;\n\n    /** Number of boards in total (most likely also 2). */\n    private readonly numberOfBoards: number;\n\n    /** The board states which represent a winning state. */\n    protected abstract readonly winningStates: Array<BitBoard<T>>;\n\n    /**\n     * Creates an instance of Board.\n     * @param width - The width of the game board.\n     * @param height - The height of the game board.\n     * @param playerBoardCount - How many boards there are representing player positions (most likely 2).\n     * @param extraBoardCount - Number of extra boards (most likely 0).\n     */\n    protected constructor(width: number, height: number, playerBoardCount: number = 2, extraBoardCount: number = 0) {\n        this.width = width;\n        this.height = height;\n        this.numberOfPlayerBoards = playerBoardCount;\n        this.numberOfBoards = this.numberOfPlayerBoards + extraBoardCount;\n        const totalBits = this.width * this.height * this.numberOfBoards;\n\n        this.bitBoard = (totalBits > 32\n            ? new LongIntBitBoard(Math.ceil(totalBits / 32))\n            : new IntBitBoard()) as BitBoard<T>;\n    }\n\n    /**\n     * Calculates whether or not the board is full.\n     * @returns Whether or not the board is full.\n     */\n    public get isFull(): boolean {\n        let isFull = (this.bitBoard instanceof LongIntBitBoard\n            ? new LongIntBitBoard(Math.ceil(this.width * this.height / 32))\n            : new IntBitBoard()) as BitBoard<T>;\n\n        for (let i = 0; i < this.numberOfPlayerBoards; i++)\n            isFull = isFull.or(this.getPlayerBoard(i));\n        const fullValue = (this.bitBoard instanceof LongIntBitBoard\n            ? new LongInt([\n                ...Array<number>(Math.ceil(this.width * this.height / 32) - 1).fill(~0 >>> 0),\n                2 ** (this.width * this.height - (Math.ceil(this.width * this.height / 32) - 1) * 32) - 1,\n            ])\n            : 2 ** (this.width * this.height) - 1) as T;\n\n        return isFull.equals(fullValue);\n    }\n\n    /**\n     * Calculates whether or not the board is empty.\n     * @returns Whether or not the board is empty.\n     */\n    public get isEmpty(): boolean {\n        let isEmpty = (this.bitBoard instanceof LongIntBitBoard\n            ? new LongIntBitBoard(Math.ceil(this.width * this.height / 32))\n            : new IntBitBoard()) as BitBoard<T>;\n\n        for (let i = 0; i < this.numberOfPlayerBoards; i++)\n            isEmpty = isEmpty.or(this.getPlayerBoard(i));\n\n        return isEmpty.equals(0);\n    }\n\n    /**\n     * Calculates who the winner is.\n     * @returns `false` if the game is not over, the player ID if there is a winner, and `null` if there is a draw.\n     */\n    public get winner(): 0 | 1 | false | null {\n        const playerOneBoard = this.getPlayerBoard(0);\n        const playerTwoBoard = this.getPlayerBoard(1);\n\n        for (const state of this.winningStates) {\n            if (playerOneBoard.and(state).equals(state))\n                return 0;\n\n            if (playerTwoBoard.and(state).equals(state))\n                return 1;\n        }\n\n        if (this.isFull)\n            return null;\n\n        return false;\n    }\n\n    /**\n     * Calculates which cells are empty.\n     * @returns The empty cells on the board.\n     */\n    public get emptyCells(): Position[] {\n        const emptyCells: Position[] = [];\n\n        for (let y = 0; y < this.height; y++) {\n            for (let x = 0; x < this.width; x++) {\n                if (this.cellOccupier({ x, y }) === null)\n                    emptyCells.push({ x, y });\n            }\n        }\n\n        return emptyCells;\n    }\n\n    /** Calculates the heuristic score for a given board state. */\n    public abstract get heuristic(): number;\n\n    /**\n     * Makes a move on the board.\n     * @param move - The position of the move.\n     * @param playerId - The player who's making the move.\n     */\n    public makeMove(move: Position, playerId: number): void {\n        const bit = this.getBitIndex(move, playerId);\n\n        this.moves.push(bit);\n        this.bitBoard.setBit(bit);\n    }\n\n    /**\n     * Reverses the last move.\n     * @throws {Error} - If there is no move to undo.\n     */\n    public undoLastMove(): void {\n        const lastMove = this.moves.pop();\n\n        if (lastMove === undefined)\n            throw new Error(\"No move to undo.\");\n\n        this.bitBoard.clearBit(lastMove);\n    }\n\n    /**\n     * Checks if a move is valid.\n     * @param move - The position of the move.\n     * @returns Whether or not it's valid.\n     */\n    public moveIsValid(move: Position): boolean {\n        return this.isValidPosition(move) && this.cellOccupier(move) === null;\n    }\n\n    /**\n     * Checks which player is occupying a given cell.\n     * @param cell - The cell to check.\n     * @returns If the cell is empty, the output is null, otherwise the output is the player's ID.\n     */\n    public cellOccupier(cell: Position): number | null {\n        for (let i = 0; i < this.numberOfPlayerBoards; i++) {\n            if (this.bitBoard.getBit(this.getBitIndex(cell, i)) === 1)\n                return i;\n        }\n\n        return null;\n    }\n\n    /**\n     * Creates a string representation of the board.\n     * @param wrap - Whether or not to provide a border for the board.\n     * @param labelX - Whether or not to label x.\n     * @param labelY - Whether or not to label y.\n     * @param symbols - The symbols to use as board pieces.\n     * @param colour - Whether or not to colour the pieces.\n     * @returns The string representation.\n     * @throws {Error} - If the symbols are not the same length.\n     */\n    public toString(\n        wrap: boolean = true,\n        labelX: boolean = true,\n        labelY: boolean = true,\n        symbols: string[] = [\"X\", \"O\"],\n        colour: boolean = true,\n    ): string {\n        if (symbols.length !== this.numberOfPlayerBoards)\n            throw new Error(\"Too many symbols.\");\n\n        const symbolLength = symbols[0]!.length;\n\n        if (symbols.some((s) => s.length !== symbolLength))\n            throw new Error(\"Symbols must be the same length.\");\n\n        const matchCellSpace = new RegExp(`.{${symbolLength + 2}}`, \"gu\");\n        const alphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\";\n        const xLabels = labelX\n            ? `${alphabet.slice(0, this.width)\n                .split(\"\")\n                .map((letter) => ` ${letter.padStart(symbolLength)} `)\n                .join(\"\")\n                .match(matchCellSpace)!\n                .join(\" \")\n                .padStart(4 * this.width - 1 + Number(wrap) + Number(labelY))\n            }\\n`\n            : \"\";\n        const topBorder = wrap\n            ? `${labelY ? \" \" : \"\"}${GridLines.TopLeft}${GridLines.Horizontal\n                .repeat(this.width * (symbolLength + 2))\n                .match(matchCellSpace)!\n                .join(GridLines.TTop)}${GridLines.TopRight}\\n`\n            : \"\";\n        const bottomBorder = wrap\n            ? `${labelY ? \" \" : \"\"}${GridLines.BottomLeft}${GridLines.Horizontal\n                .repeat(this.width * (symbolLength + 2))\n                .match(matchCellSpace)!\n                .join(GridLines.TBottom)}${GridLines.BottomRight}`\n            : \"\";\n        const rowSeparator = `${labelY ? \" \" : \"\"}${wrap ? GridLines.TLeft : \"\"}${GridLines.Horizontal\n            .repeat(this.width * (symbolLength + 2))\n            .match(matchCellSpace)!\n            .join(GridLines.Cross)}${wrap ? GridLines.TRight : \"\"}\\n`;\n        const rows: string[] = [];\n\n        for (let y = 0; y < this.height; y++) {\n            const yLabel = labelY ? `${y + 1}` : \"\";\n            const leftBorder = wrap ? GridLines.Vertical : \"\";\n            const rightBorder = wrap ? GridLines.Vertical : \"\";\n            let row = `${yLabel}${leftBorder}`;\n\n            for (let x = 0; x < this.width; x++) {\n                const cell = { x, y };\n                const bar = x === this.width - 1 ? \"\" : GridLines.Vertical;\n                const cellOccupier = this.cellOccupier(cell);\n\n                if (cellOccupier === null) {\n                    row += ` ${\" \".repeat(symbolLength)} ${bar}`;\n                } else {\n                    row += ` ${colour ? `\\x1b[${[91, 93][cellOccupier]!}m` : \"\"}` +\n                        `${symbols[cellOccupier]}` +\n                        `${colour ? \"\\x1b[0m\" : \"\"} ${bar}`;\n                }\n            }\n            rows.push(`${row}${rightBorder}\\n`);\n        }\n\n        return `${xLabels}${topBorder}${rows.join(rowSeparator)}${bottomBorder}`;\n    }\n\n    /**\n     * Determines if a given player has a line of pieces on the board.\n     * @param playerId - The ID of the player to check.\n     * @param length - The number of pieces needed.\n     * @param maxGaps - The number of gaps allowed for a line to be valid. Defaults to 0.\n     * @returns How many lines exist.\n     */\n    public hasLine(playerId: number, length: number, maxGaps: number = 0): number {\n        if (length > Math.max(this.width, this.height))\n            return 0;\n\n        const DIRECTIONS: [Position, Position, Position, Position] = [\n            { x: 1, y: 0 },\n            { x: 0, y: 1 },\n            { x: 1, y: 1 },\n            { x: 1, y: -1 },\n        ];\n        let lineCount = 0;\n        let gaps: [number, number, number, number] = [0, 0, 0, 0];\n        let lengths: [number, number, number, number] = [0, 0, 0, 0];\n        const checkCell = (x: number, y: number, direction: 0 | 1 | 2 | 3): void => {\n            const cell = { x, y } as Position;\n\n            if (this.isValidPosition(cell)) {\n                const cellOccupier = this.cellOccupier(cell);\n\n                if (cellOccupier === null)\n                    gaps[direction]++;\n                else if (cellOccupier === playerId)\n                    lengths[direction]++;\n            }\n        };\n\n        for (let x = 0; x < this.width; x++) {\n            for (let y = 0; y < this.height; y++) {\n                gaps = [0, 0, 0, 0];\n                lengths = [0, 0, 0, 0];\n                for (let i = 0; i < length; i++) {\n                    for (let j = 0 as 0 | 1 | 2 | 3; j < 4; j++) {\n                        if (gaps[j] > maxGaps)\n                            continue;\n\n                        checkCell(x + i * DIRECTIONS[j].x, y + i * DIRECTIONS[j].y, j);\n\n                        if (lengths[j] === length)\n                            lineCount++;\n                    }\n                }\n            }\n        }\n\n        return lineCount;\n    }\n\n    /**\n     * Gets a bit index from its coordinates and player ID.\n     * @param move - The coordinates.\n     * @param playerId - The player ID to use.\n     * @returns The bit index of the move.\n     */\n    protected getBitIndex(move: Position, playerId: number): number {\n        const moveIndex = this.getIndex(move);\n        const bitBoardMoveIndex = moveIndex + this.width * this.height * playerId;\n\n        return bitBoardMoveIndex;\n    }\n\n    /**\n     * A BitBoard containing only the player's bits.\n     * @param playerId - The player's ID to get the board for.\n     * @returns The player's bits.\n     */\n    protected getPlayerBoard(playerId: number): BitBoard<T> {\n        const totalBits = (this.bitBoard instanceof LongIntBitBoard ? this.bitBoard.data.wordCount : 1) * 32;\n        const boardSize = this.width * this.height;\n\n        return this.bitBoard.leftShift(totalBits - boardSize * (playerId + 1)).rightShift(totalBits - boardSize);\n    }\n\n    /**\n     * Gets a bit index from its coordinates.\n     * @param move - The coordinates.\n     * @returns The bit index.\n     */\n    private getIndex(move: Position): number {\n        return this.width * move.y + move.x;\n    }\n\n    /**\n     * Checks if a move is valid for the given board.\n     * Does not check if that cell is already occupied.\n     * @param position - The position to check.\n     * @returns Whether or not that cell exists on the board.\n     */\n    private isValidPosition(position: Position): boolean {\n        return position.x >= 0 && position.x < this.width && position.y >= 0 && position.y < this.height;\n    }\n}\n"]}