};
}
+ static fen2board(f) {
+ // Underscore is character 95, in file w_
+ return f.charCodeAt() <= 95 ? "w" + f.toLowerCase() : "b" + f;
+ }
+
static IsGoodPosition(position) {
if (position.length == 0) return false;
const rows = position.split("/");
for (let row of rows) {
let sumElts = 0;
for (let i = 0; i < row.length; i++) {
- const lowR = row[i].toLowerCase
if (!!(row[i].toLowerCase().match(/[a-z_]/))) {
sumElts++;
if (kingSymb.includes(row[i])) kings['k']++;
getUmove(move) {
if (
move.vanish.length == 1 &&
- !(ChessRules.PIECES.includes(move.appear[0].p))
+ !(ChessRules.PIECES.includes(move.appear[0].p)) &&
+ move.appear[0].p == move.vanish[0].p //not a promotion
) {
// An union moving
return { start: move.start, end: move.end };
p: cp.p
})
];
- mv.released = up[c];
+ // In move.end, to be sent to the server
+ mv.end.released = up[c];
return mv;
}
return;
// Fix en-passant capture: union type, maybe released piece too
const cs = [m.end.x + (c == 'w' ? 1 : -1), m.end.y];
- const color = this.board[cs[0]][cs[1]].charAt(0);
const code = this.board[cs[0]][cs[1]].charAt(1);
if (code == V.PAWN) {
// Simple en-passant capture (usual: just form union)
m.appear[0].p = 'a';
}
else {
- // An union pawn + something juste moved two squares
+ // An union pawn + something just moved two squares
+ const color = this.board[cs[0]][cs[1]].charAt(0);
const up = this.getUnionPieces(color, code);
- m.released = up[c];
+ m.end.released = up[c];
let args = [V.PAWN, up[oppCol]];
if (c == 'b') args = args.reverse();
const cp = this.getUnionCode(args[0], args[1]);
const move = moveOrSquare;
const s = move.start,
e = move.end;
- const oppCol = V.GetOppCol(this.turn);
if (
s.y == e.y &&
Math.abs(s.x - e.x) == 2 &&
- this.getPiece(s.x, s.y, oppCol) == V.PAWN
+ this.getPiece(s.x, s.y, this.turn) == V.PAWN
) {
return {
x: (s.x + e.x) / 2,
!!m1 &&
!(ChessRules.PIECES.includes(m2.appear[0].p)) &&
m2.vanish.length == 1 &&
- !m2.released &&
+ !m2.end.released &&
m1.start.x == m2.end.x &&
m1.end.x == m2.start.x &&
m1.start.y == m2.end.y &&
// Found an attack!
return true;
for (let m of moves) {
- if (!!m.released) {
+ if (!!m.end.released) {
// Turn won't change since !!m.released
this.play(m);
const res = this.isAttacked_aux(
- files, color, positions, [m.end.x, m.end.y], m.released);
+ files, color, positions, [m.end.x, m.end.y], m.end.released);
this.undo(m);
if (res) return true;
}
break outerLoop;
}
for (let m of moves) {
- if (!!m.released) {
+ if (!!m.end.released) {
// Turn won't change since !!m.released
this.play(m);
let positions = [];
res = this.isAttacked_aux(
- files, color, positions, [m.end.x, m.end.y], m.released);
+ files, color, positions, [m.end.x, m.end.y], m.end.released);
this.undo(m);
if (res) break outerLoop;
}
return moves.filter(m => !this.oppositeMoves(this.umoves[L - 1], m));
}
- play(move) {
- move.flags = JSON.stringify(this.aggregateFlags());
- this.epSquares.push(this.getEpSquare(move));
- // Check if the move is the last of the turn: all cases except releases
- if (!move.released) {
- // No more union releases available
- this.turn = V.GetOppCol(this.turn);
- this.movesCount++;
- this.lastMoveEnd.push(null);
- }
- else this.lastMoveEnd.push(Object.assign({ p: move.released }, move.end));
- V.PlayOnBoard(this.board, move);
- this.umoves.push(this.getUmove(move));
- this.postPlay(move);
- }
-
updateCastleFlags(move, piece) {
- const c = V.GetOppCol(this.turn);
+ const c = this.turn;
const firstRank = (c == "w" ? 7 : 0);
- const oppCol = this.turn;
- const oppFirstRank = 7 - firstRank;
if (piece == V.KING && move.appear.length > 0)
this.castleFlags[c] = [V.size.y, V.size.y];
else if (
const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1);
this.castleFlags[c][flagIdx] = V.size.y;
}
- // No more checking: a rook in union can take part in castling.
+ else if (
+ move.end.x == firstRank &&
+ this.castleFlags[c].includes(move.end.y)
+ ) {
+ // Move to our rook: necessary normal piece, to union, releasing
+ // (or the rook was moved before!)
+ const flagIdx = (move.end.y == this.castleFlags[c][0] ? 0 : 1);
+ this.castleFlags[c][flagIdx] = V.size.y;
+ }
}
- postPlay(move) {
- if (move.vanish.length == 0)
- // A released piece just moved. Cannot be the king.
- return;
- const c = move.vanish[0].c;
- const piece = move.vanish[0].p;
+ prePlay(move) {
+ // Easier before move is played in this case (flags are saved)
+ const c = this.turn;
+ const L = this.lastMoveEnd.length;
+ const lm = this.lastMoveEnd[L-1];
+ const piece = (!!lm ? lm.p : move.vanish[0].p);
if (piece == V.KING)
this.kingPos[c] = [move.appear[0].x, move.appear[0].y];
this.updateCastleFlags(move, piece);
- if (
- [1, 6].includes(move.start.x) &&
- move.vanish.length >= 1 &&
- move.appear.length == 1
- ) {
- // Does this move turn off a 2-squares pawn flag?
- if (
- move.vanish[0].p == V.PAWN ||
- (
- !(ChessRules.PIECES.includes(move.vanish[0].p)) &&
- this.getUnionPieces(move.vanish[0].c, move.vanish[0].p)[c] == V.PAWN
- )
- ) {
- this.pawnFlags[move.start.x == 6 ? "w" : "b"][move.start.y] = false;
- }
+ const pawnFirstRank = (c == 'w' ? 6 : 1);
+ if (move.start.x == pawnFirstRank)
+ // This move (potentially) turns off a 2-squares pawn flag
+ this.pawnFlags[c][move.start.y] = false;
+ }
+
+ play(move) {
+ move.flags = JSON.stringify(this.aggregateFlags());
+ this.prePlay(move);
+ this.epSquares.push(this.getEpSquare(move));
+ // Check if the move is the last of the turn: all cases except releases
+ if (!move.end.released) {
+ // No more union releases available
+ this.turn = V.GetOppCol(this.turn);
+ this.movesCount++;
+ this.lastMoveEnd.push(null);
}
+ else {
+ this.lastMoveEnd.push({
+ p: move.end.released,
+ x: move.end.x,
+ y: move.end.y
+ });
+ }
+ V.PlayOnBoard(this.board, move);
+ this.umoves.push(this.getUmove(move));
}
undo(move) {
this.disaggregateFlags(JSON.parse(move.flags));
V.UndoOnBoard(this.board, move);
this.lastMoveEnd.pop();
- if (!move.released) {
+ if (!move.end.released) {
this.turn = V.GetOppCol(this.turn);
this.movesCount--;
}
mv = moves[randInt(moves.length)];
mvArray.push(mv);
this.play(mv);
- if (!!mv.released)
+ if (!!mv.end.released)
// A piece was just released from an union
moves = this.getPotentialMovesFrom([mv.end.x, mv.end.y]);
else break;
}
for (let i = mvArray.length - 1; i >= 0; i--) this.undo(mvArray[i]);
- if (!mv.released) return (mvArray.length > 1 ? mvArray : mvArray[0]);
+ if (!mv.end.released) return (mvArray.length > 1 ? mvArray : mvArray[0]);
}
}
projects / vchess.git / blobdiff