knightstour 1.0.0

package/index.js

@@ -0,0 +1,481 @@
+class KnightsTour {
+    static KNIGHT_OFFSETS = [
+        [-2, -1],
+        [-2, 1],
+        [-1, -2],
+        [-1, 2],
+        [1, -2],
+        [1, 2],
+        [2, -1],
+        [2, 1]
+    ];
+
+    constructor({
+        rows = 6,
+        cols = 5,
+        players = [{
+            name: "Player 1",
+            color: "blue",
+            moveIndexes: []
+        }],
+        gameMode = "",
+        disabledIndexes = [],
+    } = {}) {
+
+        this.initialConfig = {
+            rows,
+            cols,
+            players: JSON.parse(JSON.stringify(players)),
+            gameMode,
+            disabledIndexes,
+        };
+        this.init(this.initialConfig);
+    }
+
+    init({
+        rows,
+        cols,
+        players,
+        gameMode,
+        disabledIndexes,
+    }) {
+        this.rows = rows;
+        this.cols = cols;
+        this.disabledIndexes = [...disabledIndexes];
+
+        this.players = players.map(p => ({
+            ...p,
+            // Ensures each player gets a fresh copy of their original moves
+            moveIndexes: [...p.moveIndexes] 
+        }));
+
+        //need to fix allMoveIndexes
+        this.allMoveIndexes = [];
+
+
+        const maxMoves = Math.max(...this.players.map(p => p.moveIndexes.length));
+        for (let i = 0; i < maxMoves; i++) {
+            for(let j = 0; j < this.players.length; j++)
+            {
+                if (this.players[j].moveIndexes[i] !== undefined) {
+                    this.allMoveIndexes.push(this.players[j].moveIndexes[i]);
+                }
+            }
+        }
+
+        this.turnIndex = this.allMoveIndexes.length % this.players.length;
+
+        this.state = "";
+
+        this.solved = false;
+        this.generated = false;
+        
+        this.cells = [];
+
+        // Set Game Mode logic
+        if (this.players.length === 1) {
+            this.gameMode = (gameMode === "Open" || gameMode === "Closed") ? gameMode : "Open";
+        } else {
+            this.gameMode = (gameMode === "Versus" || gameMode === "Co-op") ? gameMode : "Co-op";
+        }
+
+        this.createBoard();
+        this.updateBoard();
+    }
+
+    reset() {
+        this.init(this.initialConfig);
+    }
+
+    createBoard() {
+        this.matrix = Array.from({
+                length: this.rows
+            }, (_, r) =>
+            Array.from({
+                length: this.cols
+            }, (_, c) => {
+                const index = r * this.cols + c;
+                return {
+                    index,
+                    isDisabled: this.disabledIndexes.includes(index),
+                    isHighlighted: false,
+                    isClosed: false,
+                    value: null // Stores the move number or exit count
+                };
+            })
+        );
+    }
+
+    // Helper to get cell by index without repetitive math
+    getCell(index) {
+        const r = Math.floor(index / this.cols);
+        const c = index % this.cols;
+        return this.matrix[r] ? this.matrix[r][c] : null;
+    }
+
+    /**
+     * Core logic: Identifies where the current player can move.
+     */
+    getAvailableMovesFor(playerIndex) {
+        const player = this.players[playerIndex];
+        const lastMove = player.moveIndexes[player.moveIndexes.length - 1];
+
+        if (lastMove === undefined) {
+            // First move: any non-disabled, non-visited cell
+            return this.matrix.flat()
+                .filter(cell => this.isAvailable(cell.index))
+                .map(cell => cell.index);
+        }
+        return this.getKnightMovesAt(lastMove);
+    }
+
+    move(index) {
+        if (!this.isValid(index)) return false;
+
+        const currentPlayer = this.players[this.turnIndex];
+
+        // Record move
+        currentPlayer.moveIndexes.push(index);
+        this.allMoveIndexes.push(this.turnIndex);
+
+        // Visually mark the cell with the move number
+        const cell = this.getCell(index);
+        cell.value = currentPlayer.moveIndexes.length;
+
+        // Switch turn and refresh board
+        this.turnIndex = (this.turnIndex + 1) % this.players.length;
+        this.updateBoard();
+        return true;
+    }
+
+
+    undo() {
+        
+        if (this.allMoveIndexes.length === 0) {
+            this.updateBoard();
+            return;
+        }
+
+        const lastPlayerIndex = this.allMoveIndexes.pop();
+        const lastMoveIndex = this.players[lastPlayerIndex].moveIndexes.pop();
+
+
+        this.generated = false;
+        this.solved = false;
+        // Reset the cell value completely
+        const cell = this.getCell(lastMoveIndex);
+        if (cell) cell.value = null;
+
+        // Return turn to the player who was undone
+        this.turnIndex = lastPlayerIndex;
+        this.updateBoard(false);
+
+        if (this.players[this.turnIndex].CPU) {
+            this.undo();
+        }
+    }
+
+    getNextMoves(startIndex, increment = 0) {
+        if (increment === this.players.length) {
+            return [];
+        }
+
+        let nextMoves = this.getAvailableMovesFor(startIndex);
+
+        // 3. If current player is stuck, try skipping to next player (Co-op/Versus)
+        if (nextMoves.length === 0 && this.players.length > 1) {
+            const nextIdx = (startIndex + 1) % this.players.length;
+            const nextMoves = this.getAvailableMovesFor(nextIdx);
+
+            if (nextMoves.length > 0) {
+                this.turnIndex = nextIdx;
+                return nextMoves;
+            } else {
+                return this.getNextMoves(nextIdx, increment + 1);
+            }
+        } else {
+            return nextMoves;
+        }
+
+    }
+    updateBoard(autoMove = true) {
+
+        if(this.solved || this.generated)
+        {
+            return;
+        }
+        this.clear();
+
+        // 2. Calculate next moves for the current player
+        let nextMoves = this.getNextMoves(this.turnIndex);
+
+        // 4. Update Board State
+        if (nextMoves.length === 0) {
+            this.state = "Game Over";
+            if (this.gameMode === "Open") {
+                if (this.isComplete()) {
+                    this.state = "Open tour complete!";
+                    this.solved = true;
+                } else {
+                    this.state = "Incomplete open tour. Please try again";
+                    if(this.solving)
+                    {
+                        this.state = "No open tour solution found";
+                        this.solved = false;
+                    }
+                    else if(this.generating)
+                    {
+                        this.state = "Unable to generate open tour";
+                        this.generated = false;
+                    }
+                    
+                }
+            } else if (this.gameMode === "Closed") {
+                if (this.isComplete() && this.isClosed()) {
+                    this.state = "Closed tour complete!";
+                    this.solved = true;
+                } else {
+                    this.state = "Incomplete closed tour. Please try again";
+                    if(this.solving)
+                    {
+                        this.state = "No closed tour solution found";
+                        this.solved = false;
+                    }
+                    else if(this.generating)
+                    {
+                        this.state = "Unable to generate closed tour";
+                        this.generated = false;
+                    }
+                }
+            } else if (this.gameMode === "Versus") {
+                this.state = this.determineWinner();
+            } else if (this.gameMode === "Co-op") {
+                if (this.isComplete()) {
+                    this.solved = true;
+                    this.state = "Co-op tour complete!"
+                } else {
+                    this.state = "Incomplete co-op tour. Please try again"
+                     if(this.solving)
+                    {
+                        this.state = "No co-op solution found";
+                        this.solved = false;
+                    }
+                    else if(this.generating)
+                    {
+                        this.state = "Unable to generate co-op tour";
+                        this.generated = false;
+                    }
+                }
+            }
+        } else {
+
+            this.cells = [];
+            nextMoves.forEach(idx => {
+                const cell = this.getCell(idx);
+                cell.isHighlighted = true;
+                cell.isClosed = this.isClosed(idx);
+                cell.value = this.getKnightMovesAt(idx).length;
+                this.cells.push(cell);
+            });
+            this.state = `${this.players[this.turnIndex].name}'s Turn`;
+
+            if ((this.players[this.turnIndex].CPU && autoMove) || this.generating || this.solving) {
+                if (this.players[this.turnIndex].moveIndexes.length === 0) {
+                    const nextCell = this.cells[Math.floor(Math.random() * this.cells.length) ];
+                    this.move(nextCell.index);
+                } else {
+                    const total = (this.rows * this.cols) - this.disabledIndexes.length;
+
+                    if (this.gameMode === "Closed") {
+                        const closedCells = this.cells.filter(cell => cell.isClosed);
+                        if (this.generating && this.players[this.turnIndex].moveIndexes.length >= Math.floor(total * 0.75) && closedCells.length > 0) {
+                            this.generated = true;
+                            this.state = "Closed tour generated!";
+                        }
+                    } else {
+                        if (this.generating && this.allMoveIndexes.length >= Math.floor(total * 0.75)) {
+                            this.generated = true;
+                            if(this.gameMode === "Open")
+                            {
+                                this.state = "Open tour generated!";
+                            }
+                            else if(this.gameMode === "Co-op")
+                            {
+                                this.state = "Co-op tour generated!";
+                            }
+                            else if(this.gameMode === "Versus")
+                            {
+                                this.state = "Versus tour generated!";
+                            }
+                        }
+                    }
+
+                    this.hint();
+                }
+            }
+        }
+
+    }
+
+    clear()
+    {
+        this.matrix.flat().forEach(cell => {
+            cell.isHighlighted = false;
+            cell.isClosed = false;
+            if (!this.isVisited(cell.index)) cell.value = null;
+        });
+    }
+
+    determineWinner() {
+        const sortedPlayers = [...this.players].sort(
+            (a, b) => (b.moveIndexes.length - a.moveIndexes.length) || a.name.localeCompare(b.name)
+        );
+
+        const winningScore = sortedPlayers[0].moveIndexes.length;
+        const winners = sortedPlayers.filter(p => p.moveIndexes.length === winningScore);
+
+        if (winners.length === 1) {
+            return `${winners[0].name} wins!`;
+        } else {
+            const names = winners.map(p => p.name);
+            const formatter = new Intl.ListFormat('en', {
+                style: 'long',
+                type: 'conjunction'
+            });
+            return `Tie between ${formatter.format(names)}`;
+        }
+    }
+
+    isComplete() {
+        return this.allMoveIndexes.length + this.disabledIndexes.length === this.rows * this.cols;
+    }
+
+    isClosed(lastMove = this.players[0].moveIndexes[this.players[0].moveIndexes.length - 1]) {
+        const firstMove = this.players[0].moveIndexes[0];
+        const knightMoves = this.getKnightMovesAt(firstMove, false);
+        //const lastMove = this.players[0].moveIndexes[this.players[0].moveIndexes.length - 1];
+        return knightMoves.includes(lastMove);
+    }
+
+    getKnightMovesAt(index, context = true) {
+        const r = Math.floor(index / this.cols);
+        const c = index % this.cols;
+        const moves = [];
+
+        for (const [dr, dc] of Game.KNIGHT_OFFSETS) {
+            const nR = r + dr,
+                nC = c + dc;
+            const nIdx = nR * this.cols + nC;
+            if (context) {
+                if (nR >= 0 && nR < this.rows && nC >= 0 && nC < this.cols && this.isAvailable(nIdx)) {
+                    moves.push(nIdx);
+                }
+            } else {
+                if (nR >= 0 && nR < this.rows && nC >= 0 && nC < this.cols && !this.disabledIndexes.includes(nIdx)) {
+                    moves.push(nIdx);
+                }
+            }
+        }
+        return moves;
+    }
+
+    isAvailable(index) {
+        return !this.disabledIndexes.includes(index) && !this.isVisited(index);
+    }
+
+    isVisited(index) {
+        return this.players.some(p => p.moveIndexes.includes(index));
+    }
+
+    isValid(index) {
+        const moves = this.getAvailableMovesFor(this.turnIndex);
+        return moves.includes(index);
+    }
+
+    hint()
+    {
+
+        if(this.cells.length === 0)
+        {
+            return;
+        }
+
+        if(this.generated)
+        {
+            const closedCells = this.cells.filter(c => c.isClosed);
+            const nextCell = closedCells[Math.floor(Math.random() * closedCells.length)];
+            if(nextCell)
+            {
+                this.move(nextCell.index);
+            }
+            this.clear();
+            return;
+        }
+        const openCells = this.cells.filter(c => !c.isClosed);
+
+        const candidates = openCells.length > 0 ? openCells : this.cells;
+        const minValue = Math.min(...candidates.map(c => c.value));
+        const bestCells = candidates.filter(c => c.value === minValue);
+        let nextCell = bestCells[Math.floor(Math.random() * bestCells.length)];
+        if((this.gameMode === "Open" || this.gameMode === "Versus") && (this.generating))
+        {
+            nextCell = this.cells[Math.floor(Math.random() * this.cells.length)];
+        }
+        this.move(nextCell.index);
+    }
+
+    solve(increment = 0)
+    {
+        if(this.gameMode === "Versus")
+        {
+            //console.log("Cannot solve in Versus mode");
+            return;
+        }
+        this.solving = true;
+        if(increment === 1000)
+        {
+            //console.log("No solution");
+            this.solving = false;
+        }
+        else
+        {
+            if(!this.solved)
+            {
+                this.reset();
+                this.solve(increment + 1);
+            }
+            else
+            {
+                //console.log("Solved in " + (increment + 1) + " attempt(s)");
+                this.solving = false;
+            }
+        }
+    }
+
+    generate(increment = 0)
+    {
+        this.generating = true;
+        if(increment === 1000)
+        {
+            //console.log("No generation");
+            this.generating = false;
+
+        }
+        else
+        {
+            if(!this.generated)
+            {
+                this.reset();
+                this.generate(increment + 1);
+                
+            }
+            else
+            {
+                //console.log("Generated in " + (increment + 1) + " attempt(s)");
+                this.generating = false;
+            }
+        }
+    }
+}
+
+export default KnightsTour;

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "knightstour",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC"
+}