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;
return true;
}
+ getPpath(b) {
+ return (b[1] == V.KNIGHT ? "Enpassant/" : "") + b;
+ }
+
getEpSquare(moveOrSquare) {
if (!moveOrSquare) return undefined;
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.
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 (
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);
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 firstRank = color == "w" ? sizeX - 1 : 0;
- const startRank = color == "w" ? sizeX - 2 : 1;
- const lastRank = color == "w" ? 0 : sizeX - 1;
- const pawnColor = this.getColor(x, y); //can be different for checkered
-
- // NOTE: next condition is generally true (no pawn on last rank)
- if (x + shiftX >= 0 && x + shiftX < sizeX) {
- 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: pawnColor,
- p: piece
- })
- );
- }
- // Next condition because pawns on 1st rank can generally jump
- if (
- [startRank, firstRank].includes(x) &&
- 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: pawnColor,
- 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]) {
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,
projects / vchess.git / blobdiff