x: ['b', 'k'],
y: ['q', 'q'],
z: ['q', 'k'],
- '_': ['k', 'k']
+ '@': ['k', 'k']
};
}
static fen2board(f) {
- // Underscore is character 95, in file w_
- return f.charCodeAt() <= 95 ? "w" + f.toLowerCase() : "b" + f;
+ // Arobase is character 64
+ return f.charCodeAt() <= 90 ? "w" + f.toLowerCase() : "b" + f;
}
static IsGoodPosition(position) {
if (position.length == 0) return false;
const rows = position.split("/");
if (rows.length != V.size.x) return false;
- let kingSymb = ['k', 'g', 'm', 'u', 'x', '_'];
+ let kingSymb = ['k', 'g', 'm', 'u', 'x', 'z', '@'];
let kings = { 'k': 0, 'K': 0 };
for (let row of rows) {
let sumElts = 0;
for (let i = 0; i < row.length; i++) {
- if (!!(row[i].toLowerCase().match(/[a-z_]/))) {
+ if (!!(row[i].toLowerCase().match(/[a-z@]/))) {
sumElts++;
if (kingSymb.includes(row[i])) kings['k']++;
// Not "else if", if two kings dancing together
this.kingPos = { w: [-1, -1], b: [-1, -1] };
const fenRows = V.ParseFen(fen).position.split("/");
const startRow = { 'w': V.size.x - 1, 'b': 0 };
- const kingSymb = ['k', 'g', 'm', 'u', 'x', '_'];
+ const kingSymb = ['k', 'g', 'm', 'u', 'x', 'z', '@'];
for (let i = 0; i < fenRows.length; i++) {
let k = 0;
for (let j = 0; j < fenRows[i].length; j++) {
const c = fenRows[i].charAt(j);
- if (!!(c.toLowerCase().match(/[a-z_]/))) {
+ if (!!(c.toLowerCase().match(/[a-z@]/))) {
if (kingSymb.includes(c))
this.kingPos["b"] = [i, k];
// Not "else if", in case of two kings dancing together
end: ChessRules.SquareToCoords(umove.substr(2))
});
}
+ // Local stack of positions to avoid redundant moves:
+ this.repetitions = [];
}
static IsGoodFen(fen) {
// "positions" = array of FENs to detect infinite loops. Example:
// r1q1k2r/p1Pb1ppp/5n2/1f1p4/AV5P/P1eDP3/3B1PP1/R3K1NR,
// Bxd2 Bxc3 Bxb4 Bxc3 Bxb4 etc.
- const newPos = { fen: super.getBaseFen(), piece: released };
- if (positions.some(p => p.piece == newPos.piece && p.fen == newPos.fen))
+ const newPos = {
+ fen: super.getBaseFen(),
+ piece: released,
+ from: fromSquare
+ };
+ if (
+ positions.some(p => {
+ return (
+ p.piece == newPos.piece &&
+ p.fen == newPos.fen &&
+ p.from == newPos.from
+ );
+ })
+ ) {
// Start of an infinite loop: exit
return false;
+ }
positions.push(newPos);
const rank = (color == 'w' ? 0 : 7);
const moves = this.getPotentialMovesFrom(fromSquare);
return res;
}
+ isAttackedBySlideNJump([x, y], color, piece, steps, oneStep) {
+ for (let step of steps) {
+ let rx = x + step[0],
+ ry = y + step[1];
+ while (V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && !oneStep) {
+ rx += step[0];
+ ry += step[1];
+ }
+ if (
+ V.OnBoard(rx, ry) &&
+ this.board[rx][ry] != V.EMPTY &&
+ this.getPiece(rx, ry) == piece &&
+ this.getColor(rx, ry) == color &&
+ this.canTake([rx, ry], [x, y]) //TODO: necessary line?
+ //If not, generic method is OK
+ ) {
+ return true;
+ }
+ }
+ return false;
+ }
+
// Do not consider checks, except to forbid castling
getCheckSquares() {
return [];
}
+
filterValid(moves) {
if (moves.length == 0) return [];
const L = this.umoves.length; //at least 1: init from FEN
- return moves.filter(m => !this.oppositeMoves(this.umoves[L - 1], m));
+ return moves.filter(m => {
+ if (this.oppositeMoves(this.umoves[L - 1], m)) return false;
+ if (!m.end.released) return true;
+ // Check for repetitions:
+ V.PlayOnBoard(this.board, m);
+ const newState = {
+ piece: m.end.released,
+ square: { x: m.end.x, y: m.end.y },
+ position: this.getBaseFen()
+ };
+ const repet =
+ this.repetitions.some(r => {
+ return (
+ r.piece == newState.piece &&
+ (
+ r.square.x == newState.square.x &&
+ r.square.y == newState.square.y
+ ) &&
+ r.position == newState.position
+ );
+ });
+ V.UndoOnBoard(this.board, m);
+ return !repet;
+ });
}
updateCastleFlags(move, piece) {
const c = this.turn;
const L = this.lastMoveEnd.length;
const lm = this.lastMoveEnd[L-1];
- const piece = (!!lm ? lm.p : move.vanish[0].p);
+ // NOTE: lm.p != V.KING, always.
+ const piece =
+ !!lm
+ ? lm.p :
+ this.getPiece(move.vanish[0].x, move.vanish[0].y);
if (piece == V.KING)
this.kingPos[c] = [move.appear[0].x, move.appear[0].y];
this.updateCastleFlags(move, piece);
const pawnFirstRank = (c == 'w' ? 6 : 1);
- if (move.start.x == pawnFirstRank)
- // This move (potentially) turns off a 2-squares pawn flag
+ if (
+ move.start.x == pawnFirstRank &&
+ piece == V.PAWN &&
+ Math.abs(move.end.x - move.start.x) == 2
+ ) {
+ // This move turns off a 2-squares pawn flag
this.pawnFlags[c][move.start.y] = false;
+ }
}
play(move) {
}
V.PlayOnBoard(this.board, move);
this.umoves.push(this.getUmove(move));
+ if (!move.end.released) this.repetitions = [];
+ else {
+ this.repetitions.push(
+ {
+ piece: move.end.released,
+ square: { x: move.end.x, y: move.end.y },
+ position: this.getBaseFen()
+ }
+ );
+ }
}
undo(move) {
this.movesCount--;
}
this.umoves.pop();
+ if (!!move.end.released) this.repetitions.pop();
this.postUndo(move);
}
for (let i = mvArray.length - 1; i >= 0; i--) this.undo(mvArray[i]);
if (!mv.end.released) return (mvArray.length > 1 ? mvArray : mvArray[0]);
}
+ return null; //never reached
}
// NOTE: evalPosition() is wrong, but unused since bot plays at random
// Add potential promotion indications:
const firstLastRank = (c == 'w' ? [7, 0] : [0, 7]);
if (move.end.x == firstLastRank[1] && piece == V.PAWN) {
- const up = this.getUnionPieces(move.appear[0].c, move.appear[0].p);
- notation += "=" + up[c].toUpperCase();
+ notation += "=";
+ if (ChessRules.PIECES.includes(move.appear[0].p))
+ notation += move.appear[0].p.toUpperCase();
+ else {
+ const up = this.getUnionPieces(move.appear[0].c, move.appear[0].p);
+ notation += up[c].toUpperCase();
+ }
}
else if (
move.end.x == firstLastRank[0] &&