return V.HasFlags;
}
- // Some variants don't have en-passant
+ // Pawns specifications
+ static get PawnSpecs() {
+ return {
+ directions: { 'w': -1, 'b': 1 },
+ twoSquares: true,
+ promotions: [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN],
+ canCapture: true,
+ captureBackward: false,
+ bidirectional: false
+ };
+ }
+
+ // En-passant captures need a stack of squares:
static get HasEnpassant() {
return true;
}
return f.charCodeAt() <= 90 ? "w" + f.toLowerCase() : "b" + f;
}
- // Check if FEN describe a board situation correctly
+ // Check if FEN describes a board situation correctly
static IsGoodFen(fen) {
const fenParsed = V.ParseFen(fen);
// 1) Check position
// Build a regular move from its initial and destination squares.
// tr: transformation
getBasicMove([sx, sy], [ex, ey], tr) {
+ const initColor = this.getColor(sx, sy);
+ const initPiece = this.getPiece(sx, sy);
let mv = new Move({
appear: [
new PiPo({
x: ex,
y: ey,
- c: tr ? tr.c : this.getColor(sx, sy),
- p: tr ? tr.p : this.getPiece(sx, sy)
+ c: tr ? tr.c : initColor,
+ p: tr ? tr.p : initPiece
})
],
vanish: [
new PiPo({
x: sx,
y: sy,
- c: this.getColor(sx, sy),
- p: this.getPiece(sx, sy)
+ c: initColor,
+ p: initPiece
})
]
});
return moves;
}
+ // Special case of en-passant captures: treated separately
+ getEnpassantCaptures([x, y], shiftX) {
+ const Lep = this.epSquares.length;
+ const epSquare = this.epSquares[Lep - 1]; //always at least one element
+ let enpassantMove = null;
+ if (
+ !!epSquare &&
+ epSquare.x == x + shiftX &&
+ Math.abs(epSquare.y - y) == 1
+ ) {
+ enpassantMove = this.getBasicMove([x, y], [epSquare.x, epSquare.y]);
+ enpassantMove.vanish.push({
+ x: x,
+ y: epSquare.y,
+ p: "p",
+ c: this.getColor(x, epSquare.y)
+ });
+ }
+ return !!enpassantMove ? [enpassantMove] : [];
+ }
+
+ // Consider all potential promotions:
+ addPawnMoves([x1, y1], [x2, y2], moves, promotions) {
+ let finalPieces = [V.PAWN];
+ const color = this.turn;
+ const lastRank = (color == "w" ? 0 : V.size.x - 1);
+ if (x2 == lastRank) {
+ // promotions arg: special override for Hiddenqueen variant
+ if (!!promotions) finalPieces = promotions;
+ else if (!!V.PawnSpecs.promotions)
+ finalPieces = V.PawnSpecs.promotions;
+ }
+ let tr = null;
+ for (let piece of finalPieces) {
+ tr = (piece != V.PAWN ? { c: color, p: piece } : null);
+ moves.push(this.getBasicMove([x1, y1], [x2, y2], tr));
+ }
+ }
+
// What are the pawn moves from square x,y ?
- getPotentialPawnMoves([x, y]) {
+ getPotentialPawnMoves([x, y], promotions) {
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;
-
- // 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];
- if (this.board[x + shiftX][y] == V.EMPTY) {
- // One square forward
- for (let piece of finalPieces) {
- moves.push(
- this.getBasicMove([x, y], [x + shiftX, y], {
- c: color,
- 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]));
+ const pawnShiftX = V.PawnSpecs.directions[color];
+ const firstRank = (color == "w" ? sizeX - 1 : 0);
+ const startRank = (color == "w" ? sizeX - 2 : 1);
+
+ // Pawn movements in shiftX direction:
+ const getPawnMoves = (shiftX) => {
+ let moves = [];
+ // NOTE: next condition is generally true (no pawn on last rank)
+ if (x + shiftX >= 0 && x + shiftX < sizeX) {
+ if (this.board[x + shiftX][y] == V.EMPTY) {
+ // One square forward
+ this.addPawnMoves([x, y], [x + shiftX, y], moves, promotions);
+ // Next condition because pawns on 1st rank can generally jump
+ if (
+ V.PawnSpecs.twoSquares &&
+ [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: color,
- p: piece
- })
- );
+ // Captures
+ if (V.PawnSpecs.canCapture) {
+ for (let shiftY of [-1, 1]) {
+ if (
+ y + shiftY >= 0 &&
+ y + shiftY < sizeY
+ ) {
+ if (
+ this.board[x + shiftX][y + shiftY] != V.EMPTY &&
+ this.canTake([x, y], [x + shiftX, y + shiftY])
+ ) {
+ this.addPawnMoves(
+ [x, y], [x + shiftX, y + shiftY],
+ moves, promotions
+ );
+ }
+ if (
+ V.PawnSpecs.captureBackward &&
+ x - shiftX >= 0 && x - shiftX < V.size.x &&
+ this.board[x - shiftX][y + shiftY] != V.EMPTY &&
+ this.canTake([x, y], [x - shiftX, y + shiftY])
+ ) {
+ this.addPawnMoves(
+ [x, y], [x + shiftX, y + shiftY],
+ moves, promotions
+ );
+ }
+ }
}
}
}
+ return moves;
}
+ let pMoves = getPawnMoves(pawnShiftX);
+ if (V.PawnSpecs.bidirectional)
+ pMoves = pMoves.concat(getPawnMoves(-pawnShiftX));
+
if (V.HasEnpassant) {
- // En passant
- const Lep = this.epSquares.length;
- const epSquare = this.epSquares[Lep - 1]; //always at least one element
- if (
- !!epSquare &&
- epSquare.x == x + shiftX &&
- Math.abs(epSquare.y - y) == 1
- ) {
- let enpassantMove = this.getBasicMove([x, y], [epSquare.x, epSquare.y]);
- enpassantMove.vanish.push({
- x: x,
- y: epSquare.y,
- p: "p",
- c: this.getColor(x, epSquare.y)
- });
- moves.push(enpassantMove);
- }
+ // NOTE: backward en-passant captures are not considered
+ // because no rules define them (for now).
+ Array.prototype.push.apply(
+ pMoves,
+ this.getEnpassantCaptures([x, y], pawnShiftX)
+ );
}
- return moves;
+ return pMoves;
}
// What are the rook moves from square x,y ?
// What are the king moves from square x,y ?
getPotentialKingMoves(sq) {
// Initialize with normal moves
- const moves = this.getSlideNJumpMoves(
+ let moves = this.getSlideNJumpMoves(
sq,
V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
"oneStep"
);
- return moves.concat(this.getCastleMoves(sq));
+ if (V.HasCastle) moves = moves.concat(this.getCastleMoves(sq));
+ return moves;
}
- getCastleMoves([x, y]) {
+ // "castleInCheck" arg to let some variants castle under check
+ getCastleMoves([x, y], castleInCheck) {
const c = this.getColor(x, y);
if (x != (c == "w" ? V.size.x - 1 : 0) || y != this.INIT_COL_KING[c])
return []; //x isn't first rank, or king has moved (shortcut)
if (this.castleFlags[c][castleSide] >= V.size.y) continue;
// If this code is reached, rooks and king are on initial position
+ // NOTE: in some variants this is not a rook, but let's keep variable name
+ const rookPos = this.castleFlags[c][castleSide];
+ const castlingPiece = this.getPiece(x, rookPos);
+ if (this.getColor(x, rookPos) != c)
+ // Rook is here but changed color (see Benedict)
+ continue;
+
// Nothing on the path of the king ? (and no checks)
const finDist = finalSquares[castleSide][0] - y;
let step = finDist / Math.max(1, Math.abs(finDist));
i = y;
do {
if (
- this.isAttacked([x, i], [oppCol]) ||
+ (!castleInCheck && this.isAttacked([x, i], oppCol)) ||
(this.board[x][i] != V.EMPTY &&
// NOTE: next check is enough, because of chessboard constraints
(this.getColor(x, i) != c ||
- ![V.KING, V.ROOK].includes(this.getPiece(x, i))))
+ ![V.KING, castlingPiece].includes(this.getPiece(x, i))))
) {
continue castlingCheck;
}
// Nothing on the path to the rook?
step = castleSide == 0 ? -1 : 1;
- const rookPos = this.castleFlags[c][castleSide];
for (i = y + step; i != rookPos; i += step) {
if (this.board[x][i] != V.EMPTY) continue castlingCheck;
}
new Move({
appear: [
new PiPo({ x: x, y: finalSquares[castleSide][0], p: V.KING, c: c }),
- new PiPo({ x: x, y: finalSquares[castleSide][1], p: V.ROOK, c: c })
+ new PiPo({ x: x, y: finalSquares[castleSide][1], p: castlingPiece, c: c })
],
vanish: [
new PiPo({ x: x, y: y, p: V.KING, c: c }),
- new PiPo({ x: x, y: rookPos, p: V.ROOK, c: c })
+ new PiPo({ x: x, y: rookPos, p: castlingPiece, c: c })
],
end:
Math.abs(y - rookPos) <= 2
return false;
}
- // Check if pieces of color in 'colors' are attacking (king) on square x,y
- isAttacked(sq, colors) {
+ // Check if pieces of given color are attacking (king) on square x,y
+ isAttacked(sq, color) {
return (
- this.isAttackedByPawn(sq, colors) ||
- this.isAttackedByRook(sq, colors) ||
- this.isAttackedByKnight(sq, colors) ||
- this.isAttackedByBishop(sq, colors) ||
- this.isAttackedByQueen(sq, colors) ||
- this.isAttackedByKing(sq, colors)
+ this.isAttackedByPawn(sq, color) ||
+ this.isAttackedByRook(sq, color) ||
+ this.isAttackedByKnight(sq, color) ||
+ this.isAttackedByBishop(sq, color) ||
+ this.isAttackedByQueen(sq, color) ||
+ this.isAttackedByKing(sq, color)
);
}
// Generic method for non-pawn pieces ("sliding or jumping"):
- // is x,y attacked by a piece of color in array 'colors' ?
- isAttackedBySlideNJump([x, y], colors, piece, steps, oneStep) {
+ // is x,y attacked by a piece of given color ?
+ isAttackedBySlideNJump([x, y], color, piece, steps, oneStep) {
for (let step of steps) {
let rx = x + step[0],
ry = y + step[1];
}
if (
V.OnBoard(rx, ry) &&
- this.getPiece(rx, ry) === piece &&
- colors.includes(this.getColor(rx, ry))
+ this.getPiece(rx, ry) == piece &&
+ this.getColor(rx, ry) == color
) {
return true;
}
return false;
}
- // Is square x,y attacked by 'colors' pawns ?
- isAttackedByPawn([x, y], colors) {
- for (let c of colors) {
- const pawnShift = c == "w" ? 1 : -1;
- if (x + pawnShift >= 0 && x + pawnShift < V.size.x) {
- for (let i of [-1, 1]) {
- if (
- y + i >= 0 &&
- y + i < V.size.y &&
- this.getPiece(x + pawnShift, y + i) == V.PAWN &&
- this.getColor(x + pawnShift, y + i) == c
- ) {
- return true;
- }
+ // Is square x,y attacked by 'color' pawns ?
+ isAttackedByPawn([x, y], color) {
+ const pawnShift = (color == "w" ? 1 : -1);
+ if (x + pawnShift >= 0 && x + pawnShift < V.size.x) {
+ for (let i of [-1, 1]) {
+ if (
+ y + i >= 0 &&
+ y + i < V.size.y &&
+ this.getPiece(x + pawnShift, y + i) == V.PAWN &&
+ this.getColor(x + pawnShift, y + i) == color
+ ) {
+ return true;
}
}
}
return false;
}
- // Is square x,y attacked by 'colors' rooks ?
- isAttackedByRook(sq, colors) {
- return this.isAttackedBySlideNJump(sq, colors, V.ROOK, V.steps[V.ROOK]);
+ // Is square x,y attacked by 'color' rooks ?
+ isAttackedByRook(sq, color) {
+ return this.isAttackedBySlideNJump(sq, color, V.ROOK, V.steps[V.ROOK]);
}
- // Is square x,y attacked by 'colors' knights ?
- isAttackedByKnight(sq, colors) {
+ // Is square x,y attacked by 'color' knights ?
+ isAttackedByKnight(sq, color) {
return this.isAttackedBySlideNJump(
sq,
- colors,
+ color,
V.KNIGHT,
V.steps[V.KNIGHT],
"oneStep"
);
}
- // Is square x,y attacked by 'colors' bishops ?
- isAttackedByBishop(sq, colors) {
- return this.isAttackedBySlideNJump(sq, colors, V.BISHOP, V.steps[V.BISHOP]);
+ // Is square x,y attacked by 'color' bishops ?
+ isAttackedByBishop(sq, color) {
+ return this.isAttackedBySlideNJump(sq, color, V.BISHOP, V.steps[V.BISHOP]);
}
- // Is square x,y attacked by 'colors' queens ?
- isAttackedByQueen(sq, colors) {
+ // Is square x,y attacked by 'color' queens ?
+ isAttackedByQueen(sq, color) {
return this.isAttackedBySlideNJump(
sq,
- colors,
+ color,
V.QUEEN,
V.steps[V.ROOK].concat(V.steps[V.BISHOP])
);
}
- // Is square x,y attacked by 'colors' king(s) ?
- isAttackedByKing(sq, colors) {
+ // Is square x,y attacked by 'color' king(s) ?
+ isAttackedByKing(sq, color) {
return this.isAttackedBySlideNJump(
sq,
- colors,
+ color,
V.KING,
V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
"oneStep"
// Is color under check after his move ?
underCheck(color) {
- return this.isAttacked(this.kingPos[color], [V.GetOppCol(color)]);
+ return this.isAttacked(this.kingPos[color], V.GetOppCol(color));
}
/////////////////
play(move) {
// DEBUG:
// if (!this.states) this.states = [];
-// const stateFen = this.getBaseFen() + this.getTurnFen();// + this.getFlagsFen();
+// const stateFen = this.getFen() + JSON.stringify(this.kingPos);
// this.states.push(stateFen);
this.prePlay(move);
this.postPlay(move);
}
+ updateCastleFlags(move) {
+ const c = V.GetOppCol(this.turn);
+ const firstRank = (c == "w" ? V.size.x - 1 : 0);
+ // Update castling flags if rooks are moved
+ const oppCol = V.GetOppCol(c);
+ const oppFirstRank = V.size.x - 1 - firstRank;
+ if (
+ move.start.x == firstRank && //our rook moves?
+ this.castleFlags[c].includes(move.start.y)
+ ) {
+ const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1);
+ this.castleFlags[c][flagIdx] = V.size.y;
+ } else if (
+ move.end.x == oppFirstRank && //we took opponent rook?
+ this.castleFlags[oppCol].includes(move.end.y)
+ ) {
+ const flagIdx = (move.end.y == this.castleFlags[oppCol][0] ? 0 : 1);
+ this.castleFlags[oppCol][flagIdx] = V.size.y;
+ }
+ }
+
// After move is played, update variables + flags
postPlay(move) {
const c = V.GetOppCol(this.turn);
else
// Crazyhouse-like variants
piece = move.appear[0].p;
- const firstRank = c == "w" ? V.size.x - 1 : 0;
// Update king position + flags
if (piece == V.KING && move.appear.length > 0) {
if (V.HasCastle) this.castleFlags[c] = [V.size.y, V.size.y];
return;
}
- if (V.HasCastle) {
- // Update castling flags if rooks are moved
- const oppCol = V.GetOppCol(c);
- const oppFirstRank = V.size.x - 1 - firstRank;
- if (
- move.start.x == firstRank && //our rook moves?
- this.castleFlags[c].includes(move.start.y)
- ) {
- const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1);
- this.castleFlags[c][flagIdx] = V.size.y;
- } else if (
- move.end.x == oppFirstRank && //we took opponent rook?
- this.castleFlags[oppCol].includes(move.end.y)
- ) {
- const flagIdx = (move.end.y == this.castleFlags[oppCol][0] ? 0 : 1);
- this.castleFlags[oppCol][flagIdx] = V.size.y;
- }
- }
+ if (V.HasCastle) this.updateCastleFlags(move);
}
preUndo() {}
this.postUndo(move);
// DEBUG:
-// const stateFen = this.getBaseFen() + this.getTurnFen();// + this.getFlagsFen();
+// const stateFen = this.getFen() + JSON.stringify(this.kingPos);
// if (stateFen != this.states[this.states.length-1]) debugger;
// this.states.pop();
}
// Game over
const color = this.turn;
// No valid move: stalemate or checkmate?
- if (!this.isAttacked(this.kingPos[color], [V.GetOppCol(color)]))
+ if (!this.isAttacked(this.kingPos[color], V.GetOppCol(color)))
return "1/2";
// OK, checkmate
- return color == "w" ? "0-1" : "1-0";
+ return (color == "w" ? "0-1" : "1-0");
}
///////////////
projects / vchess.git / blobdiff