X-Git-Url: https://git.auder.net/?p=vchess.git;a=blobdiff_plain;f=client%2Fsrc%2Fvariants%2FEnpassant.js;h=53f5c4fb5993aadbc6a09cd823bd7873f56c0ec5;hp=374a620c932069fe6661e18f9d0fbe73f5b459a8;hb=472c0c4f5aa29d96e080873ebfce2a04f664d852;hpb=78d64531113d4b5045ff588dd43f301a332ebae8 diff --git a/client/src/variants/Enpassant.js b/client/src/variants/Enpassant.js index 374a620c..53f5c4fb 100644 --- a/client/src/variants/Enpassant.js +++ b/client/src/variants/Enpassant.js @@ -1,10 +1,10 @@ import { ChessRules, PiPo, Move } from "@/base_rules"; -export const VariantRules = class EnpassantRules extends ChessRules { - +export class EnpassantRules extends ChessRules { static IsGoodEnpassant(enpassant) { if (enpassant != "-") { const squares = enpassant.split(","); + if (squares.length > 2) return false; for (let sq of squares) { const ep = V.SquareToCoords(sq); if (isNaN(ep.x) || !V.OnBoard(ep)) return false; @@ -18,11 +18,34 @@ export const VariantRules = class EnpassantRules extends ChessRules { if (typeof moveOrSquare === "string") { const square = moveOrSquare; if (square == "-") return undefined; - let res = []; - square.split(",").forEach(sq => { - res.push(V.SquareToCoords(sq)); - }); - return res; + // Expand init + dest squares into a full path: + const init = V.SquareToCoords(square.substr(0, 2)); + let newPath = [init]; + if (square.length == 2) return newPath; + const dest = V.SquareToCoords(square.substr(2)); + const delta = ['x', 'y'].map(i => Math.abs(dest[i] - init[i])); + // Check if it's a knight(rider) movement: + let step = [0, 0]; + if (delta[0] > 0 && delta[1] > 0 && delta[0] != delta[1]) { + // Knightrider + const minShift = Math.min(delta[0], delta[1]); + step[0] = (dest.x - init.x) / minShift; + step[1] = (dest.y - init.y) / minShift; + } else { + // "Sliders" + step = ['x', 'y'].map((i, idx) => { + return (dest[i] - init[i]) / delta[idx] || 0 + }); + } + let x = init.x + step[0], + y = init.y + step[1]; + while (x != dest.x || y != dest.y) { + newPath.push({ x: x, y: y }); + x += step[0]; + y += step[1]; + } + newPath.push(dest); + return newPath; } // Argument is a move: all intermediate squares are en-passant candidates, // except if the moving piece is a king. @@ -42,7 +65,10 @@ export const VariantRules = class EnpassantRules extends ChessRules { const divisor = Math.min(Math.abs(delta[0]), Math.abs(delta[1])); step = [delta[0]/divisor || 0, delta[1]/divisor || 0]; } else { - step = [delta[0]/Math.abs(delta[0]) || 0, delta[1]/Math.abs(delta[1]) || 0]; + step = [ + delta[0]/Math.abs(delta[0]) || 0, + delta[1]/Math.abs(delta[1]) || 0 + ]; } let res = []; for ( @@ -50,7 +76,7 @@ export const VariantRules = class EnpassantRules extends ChessRules { x != move.end.x || y != move.end.y; x += step[0], y += step[1] ) { - res.push({x:x, y:y}); + res.push({ x: x, y: y }); } // Add final square to know which piece is taken en passant: res.push(move.end); @@ -60,102 +86,10 @@ export const VariantRules = class EnpassantRules extends ChessRules { getEnpassantFen() { const L = this.epSquares.length; if (!this.epSquares[L - 1]) return "-"; //no en-passant - let res = ""; - this.epSquares[L - 1].forEach(sq => { - res += V.CoordsToSquare(sq) + ","; - }); - return res.slice(0, -1); //remove last comma - } - - // TODO: this getPotentialPawnMovesFrom() is mostly duplicated: - // it could be split in "capture", "promotion", "enpassant"... - getPotentialPawnMoves([x, y]) { - const color = this.turn; - let moves = []; - const [sizeX, sizeY] = [V.size.x, V.size.y]; - const shiftX = color == "w" ? -1 : 1; - const startRank = color == "w" ? sizeX - 2 : 1; - const lastRank = color == "w" ? 0 : sizeX - 1; - - const finalPieces = - x + shiftX == lastRank - ? [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN] - : [V.PAWN]; - // One square forward - if (this.board[x + shiftX][y] == V.EMPTY) { - for (let piece of finalPieces) { - moves.push( - this.getBasicMove([x, y], [x + shiftX, y], { - c: color, - p: piece - }) - ); - } - if ( - x == startRank && - this.board[x + 2 * shiftX][y] == V.EMPTY - ) { - // Two squares jump - moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y])); - } - } - // Captures - for (let shiftY of [-1, 1]) { - if ( - y + shiftY >= 0 && - y + shiftY < sizeY && - this.board[x + shiftX][y + shiftY] != V.EMPTY && - this.canTake([x, y], [x + shiftX, y + shiftY]) - ) { - for (let piece of finalPieces) { - moves.push( - this.getBasicMove([x, y], [x + shiftX, y + shiftY], { - c: color, - p: piece - }) - ); - } - } - } - - // En passant - const Lep = this.epSquares.length; - const squares = this.epSquares[Lep - 1]; - if (!!squares) { - const S = squares.length; - const taken = squares[S-1]; - const pipoV = new PiPo({ - x: taken.x, - y: taken.y, - p: this.getPiece(taken.x, taken.y), - c: this.getColor(taken.x, taken.y) - }); - [...Array(S-1).keys()].forEach(i => { - const sq = squares[i]; - if (sq.x == x + shiftX && Math.abs(sq.y - y) == 1) { - let enpassantMove = this.getBasicMove([x, y], [sq.x, sq.y]); - enpassantMove.vanish.push(pipoV); - moves.push(enpassantMove); - } - }); - } - - return moves; - } - - // Remove the "onestep" condition: knight promote to knightrider: - - getPotentialKnightMoves(sq) { - return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT]); - } - - isAttackedByKnight(sq, colors) { - return this.isAttackedBySlideNJump( - sq, - colors, - V.KNIGHT, - V.steps[V.KNIGHT] - ); + const epsq = this.epSquares[L - 1]; + if (epsq.length <= 2) return epsq.map(V.CoordsToSquare).join(""); + // Condensate path: just need initial and final squares: + return V.CoordsToSquare(epsq[0]) + V.CoordsToSquare(epsq[epsq.length - 1]); } getPotentialMovesFrom([x, y]) { @@ -204,6 +138,58 @@ export const VariantRules = class EnpassantRules extends ChessRules { return moves; } + getEnpassantCaptures([x, y], shiftX) { + const Lep = this.epSquares.length; + const squares = this.epSquares[Lep - 1]; + let moves = []; + if (!!squares) { + const S = squares.length; + const taken = squares[S-1]; + const pipoV = new PiPo({ + x: taken.x, + y: taken.y, + p: this.getPiece(taken.x, taken.y), + c: this.getColor(taken.x, taken.y) + }); + [...Array(S-1).keys()].forEach(i => { + const sq = squares[i]; + if (sq.x == x + shiftX && Math.abs(sq.y - y) == 1) { + let enpassantMove = this.getBasicMove([x, y], [sq.x, sq.y]); + enpassantMove.vanish.push(pipoV); + moves.push(enpassantMove); + } + }); + } + return moves; + } + + // Remove the "onestep" condition: knight promote to knightrider: + getPotentialKnightMoves(sq) { + return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT]); + } + + filterValid(moves) { + const filteredMoves = super.filterValid(moves); + // If at least one full move made, everything is allowed: + if (this.movesCount >= 2) + return filteredMoves; + // Else, forbid captures: + return filteredMoves.filter(m => m.vanish.length == 1); + } + + isAttackedByKnight(sq, color) { + return this.isAttackedBySlideNJump( + sq, + color, + V.KNIGHT, + V.steps[V.KNIGHT] + ); + } + + static get SEARCH_DEPTH() { + return 2; + } + static get VALUES() { return { p: 1,