Allow slides that are not orthogonal or diagonals

src/client/scripts/game/chess/checkdetection.js

@@ -44,20 +44,18 @@ const checkdetection = (function(){
         if (!coord) return false;
         if (colorOfFriendly !== 'white' && colorOfFriendly !== 'black') throw new Error(`Cannot detect if an opponent is attacking the square of the team of color ${colorOfFriendly}!`)
 
-        let atleast1Attacker = false;
-
         // How do we find out if this square is attacked?
 
         // 1. We check every square within a 3 block radius to see if there's any attacking pieces.
 
-        if (doesVicinityAttackSquare(gamefile, coord, colorOfFriendly, attackers)) atleast1Attacker = true;
+        if (doesVicinityAttackSquare(gamefile, coord, colorOfFriendly, attackers)) return true;
         // What about pawns? Could they capture us?
-        if (doesPawnAttackSquare(gamefile, coord, colorOfFriendly, attackers)) atleast1Attacker = true;
+        if (doesPawnAttackSquare(gamefile, coord, colorOfFriendly, attackers)) return true;
 
         // 2. We check every orthogonal and diagonal to see if there's any attacking pieces.
-        if (doesSlideAttackSquare(gamefile, coord, colorOfFriendly, attackers)) atleast1Attacker = true;
+        if (doesSlideAttackSquare(gamefile, coord, colorOfFriendly, attackers)) return true;
 
-        return atleast1Attacker; // Being attacked if true
+        return false; // Being attacked if true
     }
 
     // Checks to see if any piece within a 3-block radius can capture. Ignores sliding movesets.
@@ -115,34 +113,28 @@ const checkdetection = (function(){
     }
 
     // Returns true if there's any sliding piece that can capture on that square
+    /**
+     * 
+     * @param {gamefile} gamefile 
+     * @param {number[][]} coords 
+     * @param {string} color 
+     * @param {Array} attackers 
+     * @returns 
+     */
     function doesSlideAttackSquare (gamefile, coords, color, attackers) {
+        const lines = gamefile.slideMoves;
+        for (let i=0; i<0; i++) {
+            const line = lines[i]
+            const strline = math.getKeyFromCoords(line)
+            const key = math.getLineFromCoords(line, coords)
+            if (doesLineAttackSquare(gamefile, gamefile.piecesOrganizedByLines[strline][key], line, coords, color, attackers)) return true;
+        }
 
-        let atleast1Attacker = false;
-
-        // Horizontal
-        const row = gamefile.piecesOrganizedByRow[coords[1]];
-        if (doesLineAttackSquare(gamefile, row, 'horizontal', coords, color, attackers)) atleast1Attacker = true;
-
-        // Vertical
-        const column = gamefile.piecesOrganizedByColumn[coords[0]];
-        if (doesLineAttackSquare(gamefile, column, 'vertical', coords, color, attackers)) atleast1Attacker = true;
-
-        // Diagonal Up
-        let key = math.getUpDiagonalFromCoords(coords)
-        let diag = gamefile.piecesOrganizedByUpDiagonal[key];
-        if (doesLineAttackSquare(gamefile, diag, 'diagonalup', coords, color, attackers)) atleast1Attacker = true;
-
-        // Diagonal Down
-        key = math.getDownDiagonalFromCoords(coords)
-        diag = gamefile.piecesOrganizedByDownDiagonal[key];
-        if (doesLineAttackSquare(gamefile, diag, 'diagonaldown', coords, color, attackers)) atleast1Attacker = true;
-
-        return atleast1Attacker;
+        return false;
     }
 
     // Returns true if a piece on the specified line can capture on that square
     // THIS REQUIRES  coords  be already on the line.
-    // direction = 'horizontal' / 'vertical' / 'diagonalup' / 'diagonaldown'
     function doesLineAttackSquare(gamefile, line, direction, coords, colorOfFriendlys, attackers) {
 
         if (!line) return false; // No line, no pieces to attack
@@ -155,12 +147,12 @@ const checkdetection = (function(){
             if (thisPieceColor === 'neutral') continue;
 
             const thisPieceMoveset = legalmoves.getPieceMoveset(gamefile, thisPiece.type)
-            const lineIsVertical = direction === 'vertical' ? true : false;
-            const moveset = direction === 'horizontal' ? thisPieceMoveset.horizontal
+            const lineIsVertical = direction[0]==0
+            /**const moveset = direction === 'horizontal' ? thisPieceMoveset.horizontal
                           : direction === 'vertical' ? thisPieceMoveset.vertical
                           : direction === 'diagonalup' ? thisPieceMoveset.diagonalUp
-                          : thisPieceMoveset.diagonalDown;
-            const thisPieceLegalSlide = legalmoves.slide_CalcLegalLimit(line, lineIsVertical, moveset, thisPiece.coords, thisPieceColor)
+                          : thisPieceMoveset.diagonalDown;*/
+            const thisPieceLegalSlide = legalmoves.slide_CalcLegalLimit(line, lineIsVertical, thisPieceMoveset.slideMoves[line], thisPiece.coords, thisPieceColor)
             if (!thisPieceLegalSlide) continue; // This piece has no horizontal moveset, NEXT piece on this line!
 
             // const rectangle = {left: thisPieceLegalSlide[0], right: thisPieceLegalSlide[1], bottom: coords[1], top: coords[1]}
@@ -170,6 +162,7 @@ const checkdetection = (function(){
             if (isWithinMoveset) {
                 if (attackers) appendAttackerToList(attackers, { coords: thisPiece.coords, slidingCheck: true })
                 return true; // There'll never be more than 1 checker on the same line
+                // There are 2 sides? s<-k->s
             }
         }
 
@@ -230,10 +223,10 @@ const checkdetection = (function(){
         return movepiece.simulateMove(gamefile, move, color).isCheck;
     }
 
-    // Time complexity: O(1)
+    // Time complexity: O(slides) basically O(1) unless you add a ton of slides to a single piece
     function removeSlidingMovesThatPutYouInCheck (gamefile, moves, pieceSelected, color) {
 
-        if (!moves.horizontal && !moves.vertical && !moves.diagonalUp && !moves.diagonalDown) return; // No sliding movesets to remove
+        if (math.isEmpty) return;
 
         const royalCoords = gamefileutility.getJumpingRoyalCoords(gamefile, color); // List of coordinates of all our royal jumping pieces
 
@@ -297,76 +290,49 @@ const checkdetection = (function(){
         return true;
 
         function eraseAllSlidingMoves() {
-            legalMoves.vertical = undefined;
-            legalMoves.horizontal = undefined;
-            legalMoves.diagonalUp = undefined;
-            legalMoves.diagonalDown = undefined;
+            legalMoves.slides = {}
         }
     }
 
     function removeSlidingMovesThatOpenDiscovered (gamefile, moves, kingCoords, pieceSelected, color) {
 
         const selectedPieceCoords = pieceSelected.coords;
+        let sameLines = [];
+        for (const line of gamefile.slideMoves) { // Only check current possible slides
+            if (math.getLineFromCoords(line, kingCoords) !== math.getLineFromCoords(line, selectedPieceCoords)) continue;
+            sameLines.push(line);
+        };
 
-        const sameRow = kingCoords[1] === selectedPieceCoords[1];
-        const sameColumn = kingCoords[0] === selectedPieceCoords[0];
-
-        const kingDiagUp = math.getUpDiagonalFromCoords(kingCoords);
-        const selectedPieceDiagUp = math.getUpDiagonalFromCoords(selectedPieceCoords);
-        const sameUpDiagonal = kingDiagUp === selectedPieceDiagUp;
-
-        const kingDiagDown = math.getDownDiagonalFromCoords(kingCoords);
-        const selectedPieceDiagDown = math.getDownDiagonalFromCoords(selectedPieceCoords);
-        const sameDownDiagonal = kingDiagDown === selectedPieceDiagDown;
 
         // If not sharing any common line, there's no way we can open a discovered
-        if (!sameRow && !sameColumn && !sameUpDiagonal && !sameDownDiagonal) return;
+        if (sameLines.length===0) return;
 
         // Delete the piece, and add it back when we're done!
         const deletedPiece = math.deepCopyObject(pieceSelected);
-        movepiece.deletePiece(gamefile, pieceSelected, { updateData: false })
-
-        if (sameRow) {
-            // Does a movement off the row expose a discovered check?
-            const row = gamefile.piecesOrganizedByRow[kingCoords[1]]
-            const opensDiscovered = doesLineAttackSquare(gamefile, row, 'horizontal', kingCoords, color, [])
-            if (opensDiscovered) { // Remove the selected piece's vertical, and both diagonal movesets
-                moves.vertical = undefined;
-                moves.diagonalUp = undefined;
-                moves.diagonalDown = undefined;
-            }
-        }
-
-        else if (sameColumn) {
-            const column = gamefile.piecesOrganizedByColumn[kingCoords[0]]
-            const opensDiscovered = doesLineAttackSquare(gamefile, column, 'vertical', kingCoords, color, [])
-            if (opensDiscovered) { // Remove the selected piece's horizontal, and both diagonal movesets
-                moves.horizontal = undefined;
-                moves.diagonalUp = undefined;
-                moves.diagonalDown = undefined;
-            }
-        }
-
-        else if (sameUpDiagonal) {
-            const key = math.getUpDiagonalFromCoords(kingCoords)
-            const diagUp = gamefile.piecesOrganizedByUpDiagonal[key]
-            const opensDiscovered = doesLineAttackSquare(gamefile, diagUp, 'diagonalup', kingCoords, color, [])
-            if (opensDiscovered) { // Remove the selected piece's horizontal, vertical, and down diagonal movesets
-                moves.horizontal = undefined;
-                moves.vertical = undefined;
-                moves.diagonalDown = undefined;
-            }
+        movepiece.deletePiece(gamefile, pieceSelected, { updateData: false });
+
+        let checklines = [];
+        for (const line of sameLines) {
+            const strline = math.getKeyFromCoords(line);
+            const key = math.getLineFromCoords(line,kingCoords);
+            const opensDiscovered = doesLineAttackSquare(gamefile, gamefile.piecesOrganizedByLines[strline][key], 'horizontal', kingCoords, color, [])
+            if (!opensDiscovered) continue;
+            checklines.push(line);
         }
-
-        else { // sameDownDiagonal === true
-            const key = math.getDownDiagonalFromCoords(kingCoords)
-            const diagDown = gamefile.piecesOrganizedByDownDiagonal[key]
-            const opensDiscovered = doesLineAttackSquare(gamefile, diagDown, 'diagonaldown', kingCoords, color, [])
-            if (opensDiscovered) { // Remove the selected piece's horizontal, vertical, and up diagonal movesets
-                moves.horizontal = undefined;
-                moves.vertical = undefined;
-                moves.diagonalUp = undefined;
+        const tempslides = {}
+        if (checklines.length > 1) {
+            if (math.areLinesCollinear(checklines)) {
+                for (const line of checklines) {
+                    const strline = math.getKeyFromCoords(line)
+                    tempslides[strline] = moves.slideMoves[strline]
+                }
+            } else {
+                // Cannot slide to block all attack lines so blank the slides
+                // Could probably blank regular attacks too
             }
+        } else if (checklines.length === 1) {
+            const strline = math.getKeyFromCoords(checklines[0])
+            tempslides[strline] = moves.slideMoves[strline] 
         }
 
         // Add the piece back with the EXACT SAME index it had before!!

src/client/scripts/game/chess/formatconverter.js

@@ -31,6 +31,7 @@ const formatconverter = (function() {
         "centaursW": "CE", "centaursB": "ce",
         "royalQueensW": "RQ", "royalQueensB": "rq",
         "royalCentaursW": "RC", "royalCentaursB": "rc",
+        "knightRidersW": "NR", "knightRidersB": "nr",
         "obstaclesN": "ob",
         "voidsN": "vo"
     };

src/client/scripts/game/chess/gamefile.js

@@ -67,14 +67,10 @@ function gamefile(metadata, { moves = [], variantOptions, gameConclusion } = {})
     this.ourPieces = undefined;
     /** Pieces organized by key: `{ '1,2':'queensW', '2,3':'queensW' }` */
     this.piecesOrganizedByKey = undefined;
-    /** Pieces organized by row: `{ 2:[{type:'queensW',coords:[1,2]}] }` */
-    this.piecesOrganizedByRow = undefined;
-    /** Pieces organized by column: `{ 1:[{type:'queensW',coords:[1,2]}] }` */
-    this.piecesOrganizedByColumn = undefined;
-    /** Pieces organized by up-diagonal (slope 1). Each diagonal is given the integer value of it's y-intercept on the grid. i.e. The '0' diagonal intersects (0,0), the '1' diagonal intersects (0,1)... */
-    this.piecesOrganizedByUpDiagonal = undefined;
-    /** Pieces organized by down-diagonal (slope -1). Each diagonal is given the integar value of it's y-intercept on the grid. i.e. The '0' diagonal intersects (0,0), the '1' diagonal intersects (0,1)... */
-    this.piecesOrganizedByDownDiagonal = undefined;
+    /** Pieces organized by lines: `{ '1,0' { 2:[{type:'queensW',coords:[1,2]}] } }` */
+    this.piecesOrganizedByLines = undefined;
+    /** Legal slides*/
+    this.slideMoves = [[1,1],[1,-1],[1,0],[0,1],[1,2],[1,-2],[2,1],[2,-1]];
 
     /** The object that contains the buffer model to render the pieces */
     this.mesh = {
@@ -159,7 +155,6 @@ function gamefile(metadata, { moves = [], variantOptions, gameConclusion } = {})
     /** The number of half-moves played since the last capture or pawn push. */
     this.moveRuleState = this.gameRules.moveRule ? this.startSnapshot.moveRuleState : undefined;
     area.initStartingAreaBox(this);
-
     /** The move list. @type {Move[]} */
     this.moves = [];
     /** Index of the move we're currently viewing in the moves list. -1 means we're looking at the very beginning of the game. */