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 kings = { 'k': 0, 'K': 0 };
for (let row of rows) {
let sumElts = 0;
for (let i = 0; i < row.length; i++) {
- const lowR = row[i].toLowerCase
+ const lowR = row[i].toLowerCase();
const readNext = !(ChessRules.PIECES.includes(lowR));
if (!!(lowR.match(/[a-z_]/))) {
sumElts++;
- if (kingSymb.includes(row[i])) kings['k']++;
- // Not "else if", if two kings dancing together
- if (kingSymb.some(s => row[i] == s.toUpperCase())) kings['K']++;
- if (readNext) i++;
+ if (lowR == 'k') kings[row[i]]++;
+ else if (readNext) {
+ const up = this.getUnionPieces(row[++i], lowR);
+ if (up.w == V.KING) kings['K']++;
+ // NOTE: not "else if" because two kings might be in union
+ if (up.b == V.KING) kings['k']++;
+ }
}
else {
const num = parseInt(row[i], 10);
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', '_'];
for (let i = 0; i < fenRows.length; i++) {
let k = 0;
for (let j = 0; j < fenRows[i].length; j++) {
const lowR = c.toLowerCase();
const readNext = !(ChessRules.PIECES.includes(lowR));
if (!!(lowR.match(/[a-z_]/))) {
- if (kingSymb.includes(c))
- this.kingPos["b"] = [i, k];
- // Not "else if", in case of two kings dancing together
- if (kingSymb.some(s => c == s.toUpperCase()))
- this.kingPos["w"] = [i, k];
- if (readNext) j++;
+ if (lowR == 'k') this.kingPos[c == 'k' ? 'b' : 'w'] = [i, k];
+ else if (readNext) {
+ const up = this.getUnionPieces(fenRows[i][++j], lowR);
+ if (up.w == V.KING) this.kingPos['w'] = [i, k];
+ if (up.b == V.KING) this.kingPos['b'] = [i, k];
+ }
}
else {
const num = parseInt(fenRows[i].charAt(j), 10);
super.setOtherVariables(fen);
// Stack of "last move" only for intermediate chaining
this.lastMoveEnd = [null];
+ this.repetitions = [];
}
static IsGoodFlags(flags) {
break;
case V.KING:
baseMoves = this.getSlideNJumpMoves(
- sq,
+ [x, y],
V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
"oneStep"
);
if (!noCastle && this.castleFlags[this.turn].some(v => v < V.size.y))
- baseMoves = baseMoves.concat(this.getCastleMoves(sq));
+ baseMoves = baseMoves.concat(this.getCastleMoves([x, y]));
break;
}
// When a pawn in an union reaches final rank with a non-standard
getCheckSquares() {
return [];
}
+
filterValid(moves) {
- return moves;
+ if (moves.length == 0) return [];
+ return moves.filter(m => {
+ 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);
+ 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) {
else
this.lastMoveEnd.push(Object.assign({ p: move.end.released }, move.end));
V.PlayOnBoard(this.board, 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.turn = V.GetOppCol(this.turn);
this.movesCount--;
}
+ 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] &&
projects / vchess.git / blobdiff