for (let row of rows) {
let sumElts = 0;
for (let i = 0; i < row.length; i++) {
- if (['K','k'].includes(row[i]))
- kings[row[i]] = true;
+ if (['K','k'].includes(row[i])) kings[row[i]] = true;
if (V.PIECES.includes(row[i].toLowerCase())) sumElts++;
else {
const num = parseInt(row[i]);
if (sumElts != V.size.y) return false;
}
// Both kings should be on board:
- if (Object.keys(kings).length != 2)
- return false;
+ if (Object.keys(kings).length != 2) return false;
return true;
}
// Extract (relevant) flags from fen
setFlags(fenflags) {
// white a-castle, h-castle, black a-castle, h-castle
- this.castleFlags = { w: [true, true], b: [true, true] };
+ this.castleFlags = { w: [-1, -1], b: [-1, -1] };
for (let i = 0; i < 4; i++) {
this.castleFlags[i < 2 ? "w" : "b"][i % 2] =
V.ColumnToCoord(fenflags.charAt(i));
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)
castleSide++ //large, then small
) {
if (this.castleFlags[c][castleSide] >= V.size.y) continue;
- // If this code is reached, rooks and king are on initial position
+ // If this code is reached, rook 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;
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;
}
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
this.postPlay(move);
}
- updateCastleFlags(move) {
+ updateCastleFlags(move, piece) {
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 (
+ if (piece == V.KING && move.appear.length > 0)
+ this.castleFlags[c] = [V.size.y, V.size.y];
+ else if (
move.start.x == firstRank && //our rook moves?
this.castleFlags[c].includes(move.start.y)
) {
if (piece == V.KING && move.appear.length > 0) {
this.kingPos[c][0] = move.appear[0].x;
this.kingPos[c][1] = move.appear[0].y;
- if (V.HasCastle) this.castleFlags[c] = [V.size.y, V.size.y];
return;
}
- if (V.HasCastle) this.updateCastleFlags(move);
+ if (V.HasCastle) this.updateCastleFlags(move, piece);
}
preUndo() {}
// What is the score ? (Interesting if game is over)
getCurrentScore() {
- if (this.atLeastOneMove())
- return "*";
-
+ if (this.atLeastOneMove()) return "*";
// Game over
const color = this.turn;
// No valid move: stalemate or checkmate?
- if (!this.isAttacked(this.kingPos[color], V.GetOppCol(color)))
- return "1/2";
+ if (!this.underCheck(color)) return "1/2";
// OK, checkmate
return (color == "w" ? "0-1" : "1-0");
}