knightstour 1.0.2 → 1.0.4

package/README.md

@@ -0,0 +1,115 @@
+```
+# KnightsTour
+
+A flexible **Knight's Tour** game engine in JavaScript/TypeScript.  
+Supports single-player (Open/Closed tours) and multiplayer (Co-op/Versus) modes, with built-in move validation, undo, hints, and automated tour generation.
+
+---
+
+## Installation
+
+```bash
+npm install knightstour
+```
+
+or with Yarn:
+
+```bash
+yarn add knightstour
+```
+
+---
+
+## Usage
+
+```ts
+import KnightsTour from "knightstour";
+
+// Create a new game
+const game = new KnightsTour({
+  rows: 8,
+  cols: 8,
+  players: [
+    { name: "Alice", color: "red", moveIndexes: [] },
+    { name: "Bob", color: "blue", moveIndexes: [] }
+  ],
+  gameMode: "Co-op", // Open, Closed, Versus, Co-op
+  disabledIndexes: [0, 7] // optional blocked cells
+});
+
+// Make a move
+game.move(10);
+
+// Undo last move
+game.undo();
+
+// Get the next available moves for current player
+const nextMoves = game.getAvailableMovesFor(game.turnIndex);
+console.log(nextMoves);
+
+// Reset the game
+game.reset();
+```
+
+---
+
+## API
+
+### `new KnightsTour(config?: KnightsTourConfig)`
+
+- `rows` – number of rows (default: 6)
+- `cols` – number of columns (default: 5)
+- `players` – array of player objects:
+  ```ts
+  {
+    name: string;
+    color: string;
+    moveIndexes: number[];
+    CPU?: boolean; // optional
+  }
+  ```
+- `gameMode` – `"Open" | "Closed" | "Co-op" | "Versus"` (default depends on player count)
+- `disabledIndexes` – array of blocked cell indices
+
+---
+
+### Methods
+
+- `move(index: number): boolean` – Move the current player to the given index
+- `undo(): void` – Undo the last move
+- `getAvailableMovesFor(playerIndex: number): number[]` – Get valid moves for a player
+- `reset(): void` – Reset the game to initial configuration
+- `updateBoard(autoMove?: boolean): void` – Refresh the board and calculate next moves
+- `hint(): void` – Suggest and execute the best move for the current player
+- `solve(increment?: number): void` – Attempt to solve the tour (single-player)
+- `generate(increment?: number): void` – Attempt to generate a valid tour
+
+---
+
+### Properties
+
+- `rows`, `cols` – board dimensions
+- `players` – current players with their moves
+- `turnIndex` – index of current player
+- `cells` – array of cell objects for rendering
+- `state` – current game state (e.g., `"Game Over"`, `"Alice's Turn"`)
+- `solved` – boolean indicating if a tour is completed
+- `generated` – boolean indicating if a tour was generated
+- `allMoveIndexes` – flattened move history of all players
+
+---
+
+## TypeScript Support
+
+Type definitions are included. Importing in TypeScript will give full IntelliSense support.
+
+```ts
+import KnightsTour from "knightstour";
+```
+
+---
+
+## License
+
+MIT © Puzzookie
+```

package/index.js

@@ -45,14 +45,11 @@ class KnightsTour {
 
         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++)
@@ -72,7 +69,6 @@ class KnightsTour {
         
         this.cells = [];
 
-        // Set Game Mode logic
         if (this.players.length === 1) {
             this.gameMode = (gameMode === "Open" || gameMode === "Closed") ? gameMode : "Open";
         } else {
@@ -100,28 +96,23 @@ class KnightsTour {
                     isDisabled: this.disabledIndexes.includes(index),
                     isHighlighted: false,
                     isClosed: false,
-                    value: null // Stores the move number or exit count
+                    value: null
                 };
             })
         );
     }
 
-    // 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);
@@ -134,15 +125,12 @@ class KnightsTour {
 
         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;
@@ -162,11 +150,10 @@ class KnightsTour {
 
         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);
 
@@ -182,7 +169,6 @@ class KnightsTour {
 
         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);
@@ -206,10 +192,8 @@ class KnightsTour {
         }
         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") {
@@ -353,7 +337,6 @@ class KnightsTour {
     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);
     }
 
@@ -421,6 +404,10 @@ class KnightsTour {
         {
             nextCell = this.cells[Math.floor(Math.random() * this.cells.length)];
         }
+        if(this.players[this.turnIndex].moveIndexes.length === 0)
+        {
+            nextCell = this.cells[Math.floor(Math.random() * this.cells.length)];
+        }
         this.move(nextCell.index);
     }
 
@@ -428,13 +415,11 @@ class KnightsTour {
     {
         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
@@ -446,7 +431,6 @@ class KnightsTour {
             }
             else
             {
-                //console.log("Solved in " + (increment + 1) + " attempt(s)");
                 this.solving = false;
             }
         }
@@ -457,9 +441,7 @@ class KnightsTour {
         this.generating = true;
         if(increment === 1000)
         {
-            //console.log("No generation");
             this.generating = false;
-
         }
         else
         {
@@ -471,7 +453,6 @@ class KnightsTour {
             }
             else
             {
-                //console.log("Generated in " + (increment + 1) + " attempt(s)");
                 this.generating = false;
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knightstour",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",