@oathompsonjones/mini-games 1.0.0

package/build/base/controller.d.ts

@@ -0,0 +1,124 @@
+import type Board from "./board.js";
+import { EventEmitter } from "eventemitter3";
+import type { Position } from "./board.js";
+export type PlayerType = "easyCPU" | "hardCPU" | "human" | "impossibleCPU" | "mediumCPU";
+export type Algorithm = "alphabeta" | "minimax";
+export interface GameConstructorOptions {
+    id?: string;
+    onEnd?: (winner: number | null) => Promise<void> | void;
+    onInvalidInput?: (position: Position) => Promise<void> | void;
+    renderer?: (controller: Controller) => Promise<void> | void;
+}
+export interface GameConstructor {
+    new (playerOneType: PlayerType, playerTwoType: PlayerType, options?: GameConstructorOptions): Controller;
+}
+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"];
+}> {
+    /**
+     * Contains the ID of the game.
+     */
+    readonly gameID: string;
+    /**
+     * Contains the board.
+     */
+    readonly board: Board;
+    /**
+     * Contains the view object.
+     */
+    readonly render: Required<GameConstructorOptions>["renderer"];
+    /**
+     * Contains the player objects.
+     */
+    protected readonly players: Array<{
+        id: number;
+        playerType: PlayerType;
+    }>;
+    /**
+     * Contains the ID of the current player.
+     */
+    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.
+     */
+    protected constructor(playerTypes: PlayerType[], board: Board, render: Controller["render"], gameID: string | undefined, onEnd?: GameConstructorOptions["onEnd"], onInvalidInput?: GameConstructorOptions["onInvalidInput"]);
+    /**
+     * Gets the current player object.
+     */
+    get currentPlayer(): {
+        id: number;
+        playerType: PlayerType;
+    };
+    /**
+     * Controls the main game flow.
+     *
+     * @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.
+     * @returns The optimal move.
+     */
+    protected minimax(depth?: number, maximisingPlayer?: boolean): {
+        move: Position;
+        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.
+     * @returns The optimal move.
+     */
+    protected alphabeta(depth?: number, alpha?: number, beta?: number, maximisingPlayer?: boolean): {
+        move: Position;
+        score: number;
+    };
+    /**
+     * Changes which player's turn it is.
+     */
+    private nextTurn;
+    /**
+     * Makes a move.
+     *
+     * @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.
+     * @returns The move.
+     */
+    abstract determineCPUMove(difficulty: Omit<PlayerType, "human">, algorithm?: Algorithm): Position;
+    /**
+     * Finds the optimal move.
+     *
+     * @param options The options.
+     * @returns The optimal move.
+     */
+    abstract findOptimalMove(options?: {
+        algorithm?: Algorithm;
+        maxDepth?: number;
+        randomMove?: Position;
+    }): Position;
+}

package/build/base/controller.js

@@ -0,0 +1,185 @@
+import { EventEmitter } from "eventemitter3";
+export function Game(constructor) {
+    void constructor;
+}
+/**
+ * Represents a game controller.
+ */
+export default class Controller extends EventEmitter {
+    /**
+     * Contains the ID of the game.
+     */
+    gameID;
+    /**
+     * Contains the board.
+     */
+    board;
+    /**
+     * Contains the view object.
+     */
+    render;
+    /**
+     * Contains the player objects.
+     */
+    players;
+    /**
+     * Contains the ID of the current player.
+     */
+    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.
+     */
+    // eslint-disable-next-line @typescript-eslint/max-params
+    constructor(playerTypes, board, render, gameID, onEnd, onInvalidInput) {
+        super();
+        this.gameID = gameID ?? Date.now().toString(16);
+        this.board = board;
+        this.board.setGameID(this.gameID);
+        this.players = playerTypes.map((playerType, id) => ({ id, playerType }));
+        this.render = render;
+        if (onEnd !== undefined)
+            this.on("end", onEnd);
+        if (onInvalidInput !== undefined)
+            this.on("invalidInput", onInvalidInput);
+    }
+    /**
+     * Gets the current player object.
+     */
+    get currentPlayer() {
+        return this.players[this.currentPlayerId];
+    }
+    /**
+     * Controls the main game flow.
+     *
+     * @returns The winner or null in the event of a tie.
+     */
+    async play(algorithm = "alphabeta") {
+        await this.render(this);
+        this.on("input", async (move) => {
+            await this.makeMove(move);
+            if (this.currentPlayer.playerType !== "human")
+                await this.makeMove(algorithm);
+        });
+        while (this.currentPlayer.playerType !== "human" && this.board.winner === false)
+            // eslint-disable-next-line no-await-in-loop
+            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.
+     * @returns The optimal move.
+     */
+    minimax(depth = Infinity, maximisingPlayer = true) {
+        const playerIds = [(this.currentPlayerId + 1) % 2, this.currentPlayerId];
+        if (depth === 0 || this.board.winner !== false) {
+            return {
+                move: { x: NaN, y: NaN },
+                score: this.board.heuristic * (this.currentPlayerId === 0 ? 1 : -1)
+            };
+        }
+        let bestMove = {
+            move: { x: NaN, y: NaN },
+            score: maximisingPlayer ? -Infinity : Infinity
+        };
+        const { emptyCells } = this.board;
+        for (const move of emptyCells) {
+            this.board.makeMove(move, playerIds[Number(maximisingPlayer)]);
+            const score = (9 - emptyCells.length) * this.minimax(depth - 1, !maximisingPlayer).score;
+            this.board.undoLastMove();
+            if (maximisingPlayer) {
+                const bestScore = Math.max(score, bestMove.score);
+                if (bestScore !== bestMove.score)
+                    bestMove = { move, score };
+            }
+            else {
+                const bestScore = Math.min(score, bestMove.score);
+                if (bestScore !== bestMove.score)
+                    bestMove = { move, score };
+            }
+        }
+        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.
+     * @returns The optimal move.
+     */
+    alphabeta(depth = Infinity, alpha = -Infinity, beta = Infinity, maximisingPlayer = true) {
+        const playerIds = [(this.currentPlayerId + 1) % 2, this.currentPlayerId];
+        if (depth === 0 || this.board.winner !== false) {
+            return {
+                move: { x: NaN, y: NaN },
+                score: this.board.heuristic * (this.currentPlayerId === 0 ? 1 : -1)
+            };
+        }
+        let bestMove = {
+            move: { x: NaN, y: NaN },
+            score: maximisingPlayer ? -Infinity : Infinity
+        };
+        const { emptyCells } = this.board;
+        for (const move of emptyCells) {
+            this.board.makeMove(move, playerIds[Number(maximisingPlayer)]);
+            const score = (9 - emptyCells.length) * this.alphabeta(depth - 1, alpha, beta, !maximisingPlayer).score;
+            this.board.undoLastMove();
+            if (maximisingPlayer) {
+                const bestScore = Math.max(score, bestMove.score);
+                if (bestScore !== bestMove.score)
+                    bestMove = { move, score };
+                if (bestMove.score > beta)
+                    break;
+                // eslint-disable-next-line no-param-reassign
+                alpha = Math.max(alpha, bestScore);
+            }
+            else {
+                const bestScore = Math.min(score, bestMove.score);
+                if (bestScore !== bestMove.score)
+                    bestMove = { move, score };
+                if (bestMove.score < alpha)
+                    break;
+                // eslint-disable-next-line no-param-reassign
+                beta = Math.min(beta, bestScore);
+            }
+        }
+        return bestMove;
+    }
+    /**
+     * Changes which player's turn it is.
+     */
+    nextTurn() {
+        this.currentPlayerId = (this.currentPlayerId + 1) % this.players.length;
+    }
+    /**
+     * Makes a move.
+     *
+     * @param input Either the algorithm to use to calculate the move or the move itself.
+     */
+    async makeMove(input) {
+        if (typeof input === "string") {
+            this.board.makeMove(this.determineCPUMove(this.currentPlayer.playerType, input), this.currentPlayer.id);
+        }
+        else {
+            if (this.currentPlayer.playerType !== "human" || !this.board.moveIsValid(input))
+                return void this.emit("invalidInput", input);
+            this.board.makeMove(input, this.currentPlayer.id);
+        }
+        await this.render(this);
+        const { winner } = this.board;
+        if (winner !== false)
+            return void this.emit("end", winner);
+        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 interface GameConstructorOptions {\n    id?: string;\n    onEnd?: (winner: number | null) => Promise<void> | void;\n    onInvalidInput?: (position: Position) => Promise<void> | void;\n    renderer?: (controller: Controller) => Promise<void> | void;\n}\nexport interface GameConstructor {\n    // eslint-disable-next-line @typescript-eslint/prefer-function-type\n    new (playerOneType: PlayerType, playerTwoType: PlayerType, options?: GameConstructorOptions): Controller;\n}\nexport function Game(constructor: GameConstructor): void {\n    void constructor;\n}\n\n\n/**\n * Represents a game controller.\n */\nexport default abstract class Controller extends EventEmitter<{\n    end: GameConstructorOptions[\"onEnd\"];\n    input: GameConstructorOptions[\"onInvalidInput\"];\n    invalidInput: GameConstructorOptions[\"onInvalidInput\"];\n}> {\n    /**\n     * Contains the ID of the game.\n     */\n    public readonly gameID: string;\n\n    /**\n     * Contains the board.\n     */\n    public readonly board: Board;\n\n    /**\n     * Contains the view object.\n     */\n    public readonly render: Required<GameConstructorOptions>[\"renderer\"];\n\n    /**\n     * Contains the player objects.\n     */\n    protected readonly players: Array<{ id: number; playerType: PlayerType; }>;\n\n    /**\n     * Contains the ID of the current player.\n     */\n    private currentPlayerId: number = 0;\n\n    /**\n     * Creates an instance of Controller.\n     *\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\n    protected constructor(\n        playerTypes: PlayerType[],\n        board: Board,\n        render: Controller[\"render\"],\n        gameID: string | undefined,\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        if (onEnd !== undefined)\n            this.on(\"end\", onEnd);\n        if (onInvalidInput !== undefined)\n            this.on(\"invalidInput\", onInvalidInput);\n    }\n\n    /**\n     * Gets 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     *\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            if (this.currentPlayer.playerType !== \"human\")\n                await this.makeMove(algorithm);\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     *\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        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        let bestMove: ReturnType<typeof this.minimax> = {\n            move: { x: NaN, y: NaN },\n            score: maximisingPlayer ? -Infinity : Infinity\n        };\n        const { emptyCells } = this.board;\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            this.board.undoLastMove();\n            if (maximisingPlayer) {\n                const bestScore = Math.max(score, bestMove.score);\n                if (bestScore !== bestMove.score)\n                    bestMove = { move, score };\n            } else {\n                const bestScore = Math.min(score, bestMove.score);\n                if (bestScore !== bestMove.score)\n                    bestMove = { move, score };\n            }\n        }\n        return bestMove;\n    }\n\n    /**\n     * The minimax algorithm with alpha-beta pruning.\n     *\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        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        let bestMove: ReturnType<typeof this.alphabeta> = {\n            move: { x: NaN, y: NaN },\n            score: maximisingPlayer ? -Infinity : Infinity\n        };\n        const { emptyCells } = this.board;\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            this.board.undoLastMove();\n            if (maximisingPlayer) {\n                const bestScore = Math.max(score, bestMove.score);\n                if (bestScore !== bestMove.score)\n                    bestMove = { move, score };\n                if (bestMove.score > beta)\n                    break;\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                if (bestScore !== bestMove.score)\n                    bestMove = { move, score };\n                if (bestMove.score < alpha)\n                    break;\n                // eslint-disable-next-line no-param-reassign\n                beta = Math.min(beta, bestScore);\n            }\n        }\n        return bestMove;\n    }\n\n    /**\n     * Changes which player's turn it is.\n     */\n    private nextTurn(): void {\n        this.currentPlayerId = (this.currentPlayerId + 1) % this.players.length;\n    }\n\n    /**\n     * Makes a move.\n     *\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                return void this.emit(\"invalidInput\", input);\n            this.board.makeMove(input, this.currentPlayer.id);\n        }\n        await this.render(this);\n        const { winner } = this.board;\n        if (winner !== false)\n            return void this.emit(\"end\", winner);\n        this.nextTurn();\n    }\n\n    /**\n     * Determines the CPU move.\n     *\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     *\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"]}

package/build/bitBoard/bitBoard.d.ts

@@ -0,0 +1,133 @@
+import type LongInt from "./longInt.js";
+import type { StringType } from "./longInt.js";
+/**
+ * Represents a BitBoard.
+ *
+ * @link https://en.wikipedia.org/wiki/Bitboard
+ */
+export default abstract class BitBoard<T extends LongInt | number = LongInt | number> {
+    /**
+     * The numeric data.
+     */
+    protected _data: T;
+    /**
+     * Creates an instance of BitBoard.
+     *
+     * @param data The data to assign to the BitBoard.
+     */
+    protected constructor(data: T);
+    /**
+     * Gets the numeric data.
+     */
+    get data(): T;
+    /**
+     * Returns a string representation of the BitBoard.
+     *
+     * @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.
+     */
+    assignBit(bit: number, value: 0 | 1): void;
+    /**
+     * Gets a given bit, based on it's x, y coordinates.
+     *
+     * @param bit The index of the bit to get, 0 = LSB.
+     * @returns The bit.
+     */
+    abstract getBit(bit: number): 0 | 1;
+    /**
+     * Sets a given bit (changes the value to 1), based on it's x, y coordinates.
+     *
+     * @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), based on it's x, y coordinates.
+     *
+     * @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), based on it's x, y coordinates.
+     *
+     * @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).
+     */
+    abstract clearAll(): void;
+    /**
+     * Set the whole BitBoard (sets all values to 1).
+     */
+    abstract setAll(): void;
+    /**
+     * Gets a range of bits.
+     *
+     * @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.
+     * @returns The result.
+     */
+    abstract and(right: BitBoard<T> | T | number): this;
+    /**
+     * Carries out a bitwise or (|) operation.
+     *
+     * @param right The right value.
+     * @returns The result.
+     */
+    abstract or(right: BitBoard<T> | T | number): this;
+    /**
+     * Carries out a bitwise xor (^) operation.
+     *
+     * @param right The right value.
+     * @returns The result.
+     */
+    abstract xor(right: BitBoard<T> | T | number): this;
+    /**
+     * Carries out a bitwise not (~) operation.
+     *
+     * @returns The result.
+     */
+    abstract not(): this;
+    /**
+     * Carries out a bitwise left shift (<<) operation.
+     *
+     * @param shiftAmount How much to shift it by.
+     * @returns The result.
+     */
+    abstract leftShift(shiftAmount: number): this;
+    /**
+     * Carries out a bitwise logical right shift (>>>) operation.
+     *
+     * @param shiftAmount How much to shift it by.
+     * @returns The result.
+     */
+    abstract rightShift(shiftAmount: number): this;
+    /**
+     * Carries out a bitwise arithmetic right shift (>>) operation.
+     *
+     * @param shiftAmount How much to shift it by.
+     * @returns The result.
+     */
+    abstract arithmeticRightShift(shiftAmount: number): this;
+    /**
+     * Checks if two BitBoards have equal data values.
+     *
+     * @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

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

package/build/bitBoard/intBitBoard.d.ts

@@ -0,0 +1,27 @@
+import BitBoard from "./bitBoard.js";
+/**
+ * Represents a BitBoard which uses just one 32-bit number.
+ */
+export default class IntBitBoard extends BitBoard<number> {
+    /**
+     * Creates an instance of NumberBitBoard.
+     *
+     * @param data The data to fill the BitBoard with.
+     */
+    constructor(data?: number);
+    getBit(bit: number): 0 | 1;
+    setBit(bit: number): void;
+    clearBit(bit: number): void;
+    toggleBit(bit: number): void;
+    clearAll(): void;
+    setAll(): void;
+    getBits(LSB: number, numberOfBits: number): number;
+    and(right: IntBitBoard | number): this;
+    or(right: IntBitBoard | number): this;
+    xor(right: IntBitBoard | number): this;
+    not(): this;
+    leftShift(shiftAmount: number): this;
+    rightShift(shiftAmount: number): this;
+    arithmeticRightShift(shiftAmount: number): this;
+    equals(value: IntBitBoard | number): boolean;
+}

package/build/bitBoard/intBitBoard.js

@@ -0,0 +1,65 @@
+import BitBoard from "./bitBoard.js";
+/**
+ * Represents a BitBoard which uses just one 32-bit number.
+ */
+export default class IntBitBoard extends BitBoard {
+    /**
+     * Creates an instance of NumberBitBoard.
+     *
+     * @param data The data to fill the BitBoard with.
+     */
+    constructor(data = 0) {
+        super(data);
+    }
+    getBit(bit) {
+        return (this._data >>> bit & 1);
+    }
+    setBit(bit) {
+        const mask = 1 << bit;
+        this._data |= mask;
+    }
+    clearBit(bit) {
+        const mask = ~(1 << bit);
+        this._data &= mask;
+    }
+    toggleBit(bit) {
+        const mask = 1 << bit;
+        this._data ^= mask;
+    }
+    clearAll() {
+        this._data = 0;
+    }
+    setAll() {
+        this._data = ~0 >>> 0;
+    }
+    getBits(LSB, numberOfBits) {
+        const mask = 2 ** numberOfBits - 1 << LSB;
+        const bits = (this._data & mask) >>> LSB;
+        return bits;
+    }
+    and(right) {
+        return new IntBitBoard(this._data & (right instanceof IntBitBoard ? right.data : right));
+    }
+    or(right) {
+        return new IntBitBoard(this._data | (right instanceof IntBitBoard ? right.data : right));
+    }
+    xor(right) {
+        return new IntBitBoard(this._data ^ (right instanceof IntBitBoard ? right.data : right));
+    }
+    not() {
+        return new IntBitBoard(~this._data);
+    }
+    leftShift(shiftAmount) {
+        return new IntBitBoard(this._data << shiftAmount);
+    }
+    rightShift(shiftAmount) {
+        return new IntBitBoard(this._data >>> shiftAmount);
+    }
+    arithmeticRightShift(shiftAmount) {
+        return new IntBitBoard(this._data >> shiftAmount);
+    }
+    equals(value) {
+        return this._data === (value instanceof IntBitBoard ? value._data : value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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