Allow slides that are not orthogonal or diagonals

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

@@ -49,6 +49,10 @@ function gamefile(metadata, { moves = [], variantOptions, gameConclusion } = {})
         /** The bounding box surrounding the starting position, without padding.
          * @type {BoundingBox} */
         box: undefined,
+        /** A set of all types of pieces that are in this game, without their color extension: `['pawns','queens']` */
+        existingTypes: undefined,
+        /** Possible sliding moves in this game, dependant on what pieces there are. */
+        slidingPossible: undefined
     }
 
     this.gameRules = {
@@ -67,14 +71,8 @@ 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;
 
     /** The object that contains the buffer model to render the pieces */
     this.mesh = {
@@ -159,7 +157,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. */

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

@@ -10,10 +10,7 @@
 /** An object containing all the legal moves of a piece.
  * @typedef {Object} LegalMoves
  * @property {Object} individual - A list of the legal jumping move coordinates: `[[1,2], [2,1]]`
- * @property {number[]} horizontal - A length-2 array containing the legal left and right slide limits: `[-5, Infinity]`
- * @property {number[]} vertical - A length-2 array containing the legal bottom and top slide limits: `[-Infinity, 1]`
- * @property {number[]} diagonalUp - A length-2 array containing the legal down-left, and up-right slides, where the number represents the `x` limit: `[-Infinity, 7]`
- * @property {number[]} diagonalDown - A length-2 array containing the legal up-left, and down-right slides, where the number represents the `x` limit: `[3, 15]`
+ * @property {Object} sliding - A dict containing length-2 arrays with the legal left and right slide limits: `{[1,0]:[-5, Infinity]}`
  */
 
 const legalmoves = (function(){
@@ -34,7 +31,9 @@ const legalmoves = (function(){
         // For every piece moveset...
         for (let i = 0; i < pieces.white.length; i++) {
             const thisPieceType = pieces.white[i]
-            const thisPieceIndividualMoveset = getPieceMoveset(gamefile, thisPieceType).individual;
+            var thisPieceIndividualMoveset
+            if (getPieceMoveset(gamefile, thisPieceType).individual) thisPieceIndividualMoveset = getPieceMoveset(gamefile, thisPieceType).individual;
+            else thisPieceIndividualMoveset = []
 
             // For each individual move...
             for (let a = 0; a < thisPieceIndividualMoveset.length; a++) {
@@ -87,39 +86,34 @@ const legalmoves = (function(){
         const thisPieceMoveset = getPieceMoveset(gamefile, type) // Default piece moveset
 
         let legalIndividualMoves = [];
-        let legalHorizontalMoves;
-        let legalVerticalMoves;
-        let legalUpDiagonalMoves;
-        let legalDownDiagonalMoves;
+        let legalSliding = {};
 
         if (!onlyCalcSpecials) {
 
             // Legal jumping/individual moves
 
             shiftIndividualMovesetByCoords(thisPieceMoveset.individual, coords)
             legalIndividualMoves = moves_RemoveOccupiedByFriendlyPieceOrVoid(gamefile, thisPieceMoveset.individual, color)
-
+            
             // Legal sliding moves
-
-            let key = coords[1]; // Key is y level for horizontal slide
-            legalHorizontalMoves = slide_CalcLegalLimit(gamefile.piecesOrganizedByRow[key], false, thisPieceMoveset.horizontal, coords, color)
-            key = coords[0] // Key is x for vertical slide
-            legalVerticalMoves = slide_CalcLegalLimit(gamefile.piecesOrganizedByColumn[key], true, thisPieceMoveset.vertical, coords, color)
-            key = math.getUpDiagonalFromCoords(coords) // Key is -x + y for up-diagonal slide
-            legalUpDiagonalMoves = slide_CalcLegalLimit(gamefile.piecesOrganizedByUpDiagonal[key], false, thisPieceMoveset.diagonalUp, coords, color)
-            key = math.getDownDiagonalFromCoords(coords) // Key is x + y for down-diagonal slide
-            legalDownDiagonalMoves = slide_CalcLegalLimit(gamefile.piecesOrganizedByDownDiagonal[key], false, thisPieceMoveset.diagonalDown, coords, color)
+            if (thisPieceMoveset.sliding) {
+                let lines = gamefile.startSnapshot.slidingPossible;
+                for (let i=0; i<lines.length; i++) {
+                    const line = lines[i];
+                    if (!thisPieceMoveset.sliding[line]) continue;
+                    const key = math.getKeyFromLine(line,coords);
+                    legalSliding[line] = slide_CalcLegalLimit(gamefile.piecesOrganizedByLines[line][key],line, thisPieceMoveset.sliding[line], coords, color);
+                };
+            };
+
         }
 
         // Add any special moves!
         if (gamefile.specialDetects[trimmedType]) gamefile.specialDetects[trimmedType](gamefile, coords, color, legalIndividualMoves)
 
         let moves = {
             individual: legalIndividualMoves,
-            horizontal: legalHorizontalMoves,
-            vertical: legalVerticalMoves,
-            diagonalUp: legalUpDiagonalMoves,
-            diagonalDown: legalDownDiagonalMoves,
+            sliding: legalSliding
         }
 
         // Skip if we've selected the opposite side's piece (edit mode)
@@ -164,47 +158,50 @@ const legalmoves = (function(){
         return individualMoves;
     }
 
-    // Takes in specified organized list, direction of the slide, the current moveset...
-    // Shortens the moveset by pieces that block it's path.
-    function slide_CalcLegalLimit (organizedLine, lineIsVertical, slideMoveset, coords, color) {
+    /**
+     * Takes in specified organized list, direction of the slide, the current moveset...
+     * Shortens the moveset by pieces that block it's path.
+     * @param {*} organizedLine 
+     * @param {*} line 
+     * @param {*} slidinget 
+     * @param {*} coords 
+     * @param {*} color 
+     * @returns 
+     */
+    function slide_CalcLegalLimit (organizedLine, line, slidinget, coords, color) {
 
-        if (!slideMoveset) return // Return undefined if there is no slide moveset
+        if (!slidinget) return; // Return undefined if there is no slide moveset
 
         // The default slide is [-Infinity, Infinity], change that if there are any pieces blocking our path!
 
         // For most we'll be comparing the x values, only exception is the columns.
-        const zeroOrOne = lineIsVertical ? 1 : 0 
-        const limit = [slideMoveset[0] + coords[zeroOrOne], slideMoveset[1] + coords[zeroOrOne]]
-
+        const zeroOrOne = line[0] == 0 ? 1 : 0 
+        const limit = [slidinget[0], slidinget[1]]
         // Iterate through all pieces on same line
         for (let i = 0; i < organizedLine.length; i++) {
             // What are the coords of this piece?
             const thisPiece = organizedLine[i] // { type, coords }
-            const thisPieceXorY = thisPiece.coords[zeroOrOne]
+            const thisPieceSteps = Math.floor((thisPiece.coords[zeroOrOne]-coords[zeroOrOne])/line[zeroOrOne])
             const thisPieceColor = math.getPieceColorFromType(thisPiece.type)
             const isFriendlyPiece = color === thisPieceColor
             const isVoid = thisPiece.type === 'voidsN';
-
             // Is the piece to the left of us or right of us?
-            if (thisPieceXorY < coords[zeroOrOne]) { // To our left
+            if (thisPieceSteps < 0) { // To our left
 
                 // What would our new left slide limit be? If it's an opponent, it's legal to capture it.
-                const newLeftSlideLimit = isFriendlyPiece || isVoid ? thisPieceXorY + 1 : thisPieceXorY
-
+                const newLeftSlideLimit = isFriendlyPiece || isVoid ? thisPieceSteps + 1 : thisPieceSteps
                 // If the piece x is closer to us than our current left slide limit, update it
                 if (newLeftSlideLimit > limit[0]) limit[0] = newLeftSlideLimit
 
-            } else if (thisPieceXorY > coords[zeroOrOne]) { // To our right
+            } else if (thisPieceSteps > 0) { // To our right
 
                 // What would our new right slide limit be? If it's an opponent, it's legal to capture it.
-                const newRightSlideLimit = isFriendlyPiece || isVoid ? thisPieceXorY - 1 : thisPieceXorY
-
+                const newRightSlideLimit = isFriendlyPiece || isVoid ? thisPieceSteps - 1 : thisPieceSteps
                 // If the piece x is closer to us than our current left slide limit, update it
                 if (newRightSlideLimit < limit[1]) limit[1] = newRightSlideLimit
 
             } // else this is us, don't do anything.
         }
-
         return limit;
     }
 
@@ -237,38 +234,17 @@ const legalmoves = (function(){
             }
         }
 
-        // Do one of the horizontal moves match?
-        const horizontal = legalMoves.horizontal;
-        if (horizontal && endCoords[1] == startCoords[1]) {
-            // Compare the clicked x tile with this horizontal moveset
-            if (endCoords[0] >= horizontal[0] && endCoords[0] <= horizontal[1]) return true;
-        }
-
-        // Do one of the vertical moves match?
-        const vertical = legalMoves.vertical;
-        if (vertical && endCoords[0] == startCoords[0]) {
-            // Compare the clicked y tile with this vertical moveset
-            if (endCoords[1] >= vertical[0] && endCoords[1] <= vertical[1]) return true;
-        }
+        for (var strline in legalMoves.sliding) {
+            let line = math.getCoordsFromKey(strline);
+            let limits = legalMoves.sliding[strline];
 
-        // Do one of the up-diagonal moves match?
-        const diagonalUp = legalMoves.diagonalUp;
-        let selectedPieceDiagonal = math.getUpDiagonalFromCoords(startCoords);
-        let clickedCoordsDiagonal = math.getUpDiagonalFromCoords(endCoords);
-        if (diagonalUp && selectedPieceDiagonal == clickedCoordsDiagonal) {
-            // Compare the clicked x tile with this diagonal moveset
-            if (endCoords[0] >= diagonalUp[0] && endCoords[0] <= diagonalUp[1]) return true;
-        }
+            let selectedPieceLine = math.getKeyFromLine(line,startCoords);
+            let clickedCoordsLine = math.getKeyFromLine(line,endCoords);
+            if (!limits || selectedPieceLine !== clickedCoordsLine) continue;
 
-        // Do one of the down-diagonal moves match?
-        const diagonalDown = legalMoves.diagonalDown;
-        selectedPieceDiagonal = math.getDownDiagonalFromCoords(startCoords);
-        clickedCoordsDiagonal = math.getDownDiagonalFromCoords(endCoords);
-        if (diagonalDown && selectedPieceDiagonal == clickedCoordsDiagonal) {
-            // Compare the clicked x tile with this diagonal moveset
-            if (endCoords[0] >= diagonalDown[0] && endCoords[0] <= diagonalDown[1]) return true;
+            if (!doesSlidingNetContainSquare(limits, line, startCoords, endCoords)) continue;
+            return true;
         }
-
         return false;
     }
 
@@ -334,7 +310,7 @@ const legalmoves = (function(){
         // Test if that piece's legal moves contain the destinationCoords.
         const legalMoves = legalmoves.calculate(gamefile, piecemoved);
         // This should pass on any special moves tags at the same time.
-        if (!legalmoves.checkIfMoveLegal(legalMoves, moveCopy.startCoords, moveCopy.endCoords)) { // Illegal move
+        if (!legalmoves.checkIfMoveLegal(gamefile, legalMoves, moveCopy.startCoords, moveCopy.endCoords)) { // Illegal move
             console.log(`Opponent's move is illegal because the destination coords are illegal. Move: ${JSON.stringify(moveCopy)}`)
             return rewindGameAndReturnReason(`Destination coordinates are illegal. inCheck: ${JSON.stringify(gamefile.inCheck)}. attackers: ${JSON.stringify(gamefile.attackers)}. originalMoveIndex: ${originalMoveIndex}. inCheckB4Forwarding: ${inCheckB4Forwarding}. attackersB4Forwarding: ${JSON.stringify(attackersB4Forwarding)}`);
         }
@@ -370,25 +346,31 @@ const legalmoves = (function(){
         }
     }
 
+    // TODO: moveset changes
     // This requires coords be on the same line as the sliding moveset.
-    function doesSlideMovesetContainSquare (slideMoveset, lineIsVertical, coords) {
+    function doesSlidingNetContainSquare(slidinget, line, pieceCoords, coords) {
 
-        const xOrY = lineIsVertical ? coords[1] : coords[0];
+        const axis = line[0] === 0 ? 1 : 0
+        const coordMag = coords[axis];
+        const min = slidinget[0] * line[axis] + pieceCoords[axis]
+        const max = slidinget[1] * line[axis] + pieceCoords[axis]
 
-        if (xOrY < slideMoveset[0]) return false;
-        if (xOrY > slideMoveset[1]) return false;
+        if (coordMag < min) return false;
+        if (coordMag > max) return false;
 
         return true;
     }
 
-    // Accepts the calculated legal moves, tests to see if there are any
+    /**
+     * Accepts the calculated legal moves, tests to see if there are any
+     * @param {LegalMoves} moves 
+     * @returns {boolean} 
+     */
     function hasAtleast1Move (moves) { // { individual, horizontal, vertical, ... }
 
         if (moves.individual.length > 0) return true;
-        if (doesSlideHaveWidth(moves.horizontal)) return true;
-        if (doesSlideHaveWidth(moves.vertical)) return true;
-        if (doesSlideHaveWidth(moves.diagonalUp)) return true;
-        if (doesSlideHaveWidth(moves.diagonalDown)) return true;
+        for (var line in moves.sliding)
+            if (doesSlideHaveWidth(moves.sliding[line])) return true;
 
         function doesSlideHaveWidth(slide) { // [-Infinity, Infinity]
             if (!slide) return false;
@@ -403,7 +385,7 @@ const legalmoves = (function(){
         getPieceMoveset,
         calculate,
         checkIfMoveLegal,
-        doesSlideMovesetContainSquare,
+        doesSlidingNetContainSquare,
         hasAtleast1Move,
         slide_CalcLegalLimit,
         isOpponentsMoveLegal