['r', 'n', 'b', 'q', 'k', 'b', 'n', 'r'],
{
randomness: this.options["randomness"],
- between: {p1: 'k', p2: 'r'},
+ between: [{p1: 'k', p2: 'r'}],
diffCol: ['b'],
flags: ['r']
}
// Flags part of the FEN string
getFlagsFen() {
- return ["w", "b"].map(c => {
+ return ['w', 'b'].map(c => {
return this.castleFlags[c].map(x => x.toString(36)).join("");
}).join("");
}
if (o.init)
return "000000000000";
return (
- ["w","b"].map(c => Object.values(this.reserve[c]).join("")).join("")
+ ['w', 'b'].map(c => Object.values(this.reserve[c]).join("")).join("")
);
}
// Get SVG board (background, no pieces)
getSvgChessboard() {
- const flipped = this.flippedBoard;
let board = `
<svg
viewBox="0 0 ${10*this.size.y} ${10*this.size.x}"
class="chessboard_SVG">`;
+ board += this.getBaseSvgChessboard();
+ board += "</svg>";
+ return board;
+ }
+
+ getBaseSvgChessboard() {
+ let board = "";
+ const flipped = this.flippedBoard;
for (let i=0; i < this.size.x; i++) {
for (let j=0; j < this.size.y; j++) {
if (!this.onBoard(i, j))
/>`;
}
}
- board += "</svg>";
return board;
}
else
this[arrName] = ArrayFun.init(this.size.x, this.size.y, null);
if (arrName == "d_pieces")
- this.marks.forEach(([i, j]) => addPiece(i, j, arrName, "mark"));
+ this.marks.forEach((m) => {
+ const formattedSquare =
+ (this.size.x - parseInt(m.substring(1), 10)).toString(36) +
+ (m.charCodeAt(0) - 97).toString(36);
+ const mCoords = V.SquareToCoords(formattedSquare);
+ addPiece(mCoords.x, mCoords.y, arrName, "mark");
+ });
};
if (this.marks)
conditionalReset("d_pieces");
let moves = this.getPotentialMovesOf(piece, [x, y]);
if (piece == "p" && this.hasEnpassant && this.epSquare)
Array.prototype.push.apply(moves, this.getEnpassantCaptures([x, y]));
- if (
- this.isKing(0, 0, piece) && this.hasCastle &&
- this.castleFlags[color || this.turn].some(v => v < this.size.y)
- ) {
+ if (this.isKing(0, 0, piece) && this.hasCastle)
Array.prototype.push.apply(moves, this.getCastleMoves([x, y]));
- }
return this.postProcessPotentialMoves(moves);
}
continue outerLoop;
const oldIJ = [i, j];
[i, j] = this.increment([i, j], step);
- if (Math.abs(j - oldIJ[1]) > 1 || Math.abs(i - oldIJ[0]) > 1) {
+ if (
+ Math.abs(i - oldIJ[0]) != Math.abs(step[0]) ||
+ Math.abs(j - oldIJ[1]) != Math.abs(step[1])
+ ) {
// Boundary between segments (cylinder or circular mode)
segments.push([[segStart[0], segStart[1]], oldIJ]);
segStart = [i, j];
return [];
}
- getCastleMoves([x, y], finalSquares, castleWith) {
+ getCastleMoves([x, y], finalSquares, castleWith, castleFlags) {
const c = this.getColor(x, y);
+ castleFlags = castleFlags || this.castleFlags[c];
// Castling ?
const oppCols = this.getOppCols(c);
castleSide < 2;
castleSide++ //large, then small
) {
- if (this.castleFlags[c][castleSide] >= this.size.y)
+ if (castleFlags[castleSide] >= this.size.y)
continue;
// If this code is reached, rook and king are on initial position
// NOTE: in some variants this is not a rook
- const rookPos = this.castleFlags[c][castleSide];
+ const rookPos = castleFlags[castleSide];
const castlingPiece = this.getPiece(x, rookPos);
if (
this.board[x][rookPos] == "" ||
this.board[psq.x][psq.y] = psq.c + psq.p;
}
- updateCastleFlags(move) {
+ // NOTE: arg "castleFlags" for Coregal or Twokings
+ updateCastleFlags(move, castleFlags, king) {
+ castleFlags = castleFlags || this.castleFlags;
+ // If flags already off, no need to re-check:
+ if (
+ Object.values(castleFlags).every(cvals =>
+ cvals.every(val => val >= this.size.y))
+ ) {
+ return;
+ }
// Update castling flags if start or arrive from/at rook/king locations
move.appear.concat(move.vanish).forEach(psq => {
- if (this.isKing(0, 0, psq.p))
- this.castleFlags[psq.c] = [this.size.y, this.size.y];
+ if ((king && psq.p == king) || (!king && this.isKing(0, 0, psq.p)))
+ castleFlags[psq.c] = [this.size.y, this.size.y];
// NOTE: not "else if" because king can capture enemy rook...
let c = "";
if (psq.x == 0)
else if (psq.x == this.size.x - 1)
c = "w";
if (c != "") {
- const fidx = this.castleFlags[c].findIndex(f => f == psq.y);
+ const fidx = castleFlags[c].findIndex(f => f == psq.y);
if (fidx >= 0)
- this.castleFlags[c][fidx] = this.size.y;
+ castleFlags[c][fidx] = this.size.y;
}
});
}
prePlay(move) {
- if (
- this.hasCastle &&
- // If flags already off, no need to re-check:
- Object.values(this.castleFlags).some(cvals =>
- cvals.some(val => val < this.size.y))
- ) {
+ if (this.hasCastle)
this.updateCastleFlags(move);
- }
if (this.options["crazyhouse"]) {
move.vanish.forEach(v => {
const square = C.CoordsToSquare({x: v.x, y: v.y});
if (this.options["teleport"]) {
if (
this.subTurnTeleport == 1 &&
- move.vanish.length > move.appear.length &&
+ move.vanish.length == 2 &&
+ move.appear.length == 1 &&
move.vanish[1].c == this.turn
) {
- const v = move.vanish[move.vanish.length - 1];
+ const v = move.vanish[1];
this.captured = {x: v.x, y: v.y, c: v.c, p: v.p};
this.subTurnTeleport = 2;
return;