return !!this.options["dark"];
}
+ // Some variants use only click information
+ get clickOnly() {
+ return false;
+ }
+
// Some variants use click infos:
doClick(coords) {
if (typeof coords.x != "number")
new PiPo({
x: coords.x,
y: coords.y,
- c: this.captured.c, //this.turn,
+ c: this.captured.c,
p: this.captured.p
})
],
this.moveStack = [];
}
- updateEnlightened() {
- this.oldEnlightened = this.enlightened;
- this.enlightened = ArrayFun.init(this.size.x, this.size.y, false);
- // Add pieces positions + all squares reachable by moves (includes Zen):
- for (let x=0; x<this.size.x; x++) {
- for (let y=0; y<this.size.y; y++) {
- if (this.board[x][y] != "" && this.getColor(x, y) == this.playerColor)
- {
- this.enlightened[x][y] = true;
- this.getPotentialMovesFrom([x, y]).forEach(m => {
- this.enlightened[m.end.x][m.end.y] = true;
- });
- }
- }
- }
- if (this.epSquare)
- this.enlightEnpassant();
- }
-
- // Include square of the en-passant capturing square:
- enlightEnpassant() {
- // NOTE: shortcut, pawn has only one attack type, doesn't depend on square
- const steps = this.pieces(this.playerColor)["p"].attack[0].steps;
- for (let step of steps) {
- const x = this.epSquare.x - step[0],
- y = this.getY(this.epSquare.y - step[1]);
- if (
- this.onBoard(x, y) &&
- this.getColor(x, y) == this.playerColor &&
- this.getPieceType(x, y) == "p"
- ) {
- this.enlightened[x][this.epSquare.y] = true;
- break;
- }
- }
- }
-
- // ordering as in pieces() p,r,n,b,q,k (+ count in base 30 if needed)
+ // ordering as in pieces() p,r,n,b,q,k
initReserves(reserveStr) {
- const counts = reserveStr.split("").map(c => parseInt(c, 30));
+ const counts = reserveStr.split("").map(c => parseInt(c, 36));
this.reserve = { w: {}, b: {} };
const pieceName = ['p', 'r', 'n', 'b', 'q', 'k'];
const L = pieceName.length;
this.ispawn = {};
}
+ ////////////////
+ // VISUAL UTILS
+
+ getPieceWidth(rwidth) {
+ return (rwidth / this.size.y);
+ }
+
+ getReserveSquareSize(rwidth, nbR) {
+ const sqSize = this.getPieceWidth(rwidth);
+ return Math.min(sqSize, rwidth / nbR);
+ }
+
+ getReserveNumId(color, piece) {
+ return `${this.containerId}|rnum-${color}${piece}`;
+ }
+
getNbReservePieces(color) {
return (
Object.values(this.reserve[color]).reduce(
(oldV,newV) => oldV + (this.reserve[c][newV] > 0 ? 1 : 0), 0);
}
- //////////////
- // VISUAL PART
-
- getPieceWidth(rwidth) {
- return (rwidth / this.size.y);
- }
-
- getReserveSquareSize(rwidth, nbR) {
- const sqSize = this.getPieceWidth(rwidth);
- return Math.min(sqSize, rwidth / nbR);
- }
-
- getReserveNumId(color, piece) {
- return `${this.containerId}|rnum-${color}${piece}`;
- }
-
static AddClass_es(piece, class_es) {
if (!Array.isArray(class_es))
class_es = [class_es];
});
}
+ // Generally light square bottom-right
+ getSquareColorClass(x, y) {
+ return ((x+y) % 2 == 0 ? "light-square": "dark-square");
+ }
+
+ getMaxDistance(r) {
+ // Works for all rectangular boards:
+ return Math.sqrt(r.width ** 2 + r.height ** 2);
+ }
+
+ getDomPiece(x, y) {
+ return (typeof x == "string" ? this.r_pieces : this.g_pieces)[x][y];
+ }
+
+ //////////////////
+ // VISUAL METHODS
+
graphicalInit() {
// NOTE: not window.onresize = this.re_drawBoardElts because scope (this)
window.onresize = () => this.re_drawBoardElements();
return board;
}
- // Generally light square bottom-right
- getSquareColorClass(x, y) {
- return ((x+y) % 2 == 0 ? "light-square": "dark-square");
- }
-
setupPieces(r) {
if (this.g_pieces) {
// Refreshing: delete old pieces first
}
}
- // Apply diff this.enlightened --> oldEnlightened on board
- graphUpdateEnlightened() {
- let chessboard =
- document.getElementById(this.containerId).querySelector(".chessboard");
- const r = chessboard.getBoundingClientRect();
- const pieceWidth = this.getPieceWidth(r.width);
- for (let x=0; x<this.size.x; x++) {
- for (let y=0; y<this.size.y; y++) {
- if (!this.enlightened[x][y] && this.oldEnlightened[x][y]) {
- let elt = document.getElementById(this.coordsToId({x: x, y: y}));
- elt.classList.add("in-shadow");
- if (this.g_pieces[x][y])
- this.g_pieces[x][y].classList.add("hidden");
- }
- else if (this.enlightened[x][y] && !this.oldEnlightened[x][y]) {
- let elt = document.getElementById(this.coordsToId({x: x, y: y}));
- elt.classList.remove("in-shadow");
- if (this.g_pieces[x][y])
- this.g_pieces[x][y].classList.remove("hidden");
- }
- }
- }
- }
-
// Resize board: no need to destroy/recreate pieces
rescale(mode) {
let chessboard =
const move = this.doClick(cd);
if (move)
this.buildMoveStack(move, r);
- else {
+ else if (!this.clickOnly) {
const [x, y] = Object.values(cd);
if (typeof x != "number")
startPiece = this.r_pieces[x][y];
}
}
+ ////////////////
+ // DARK METHODS
+
+ updateEnlightened() {
+ this.oldEnlightened = this.enlightened;
+ this.enlightened = ArrayFun.init(this.size.x, this.size.y, false);
+ // Add pieces positions + all squares reachable by moves (includes Zen):
+ for (let x=0; x<this.size.x; x++) {
+ for (let y=0; y<this.size.y; y++) {
+ if (this.board[x][y] != "" && this.getColor(x, y) == this.playerColor)
+ {
+ this.enlightened[x][y] = true;
+ this.getPotentialMovesFrom([x, y]).forEach(m => {
+ this.enlightened[m.end.x][m.end.y] = true;
+ });
+ }
+ }
+ }
+ if (this.epSquare)
+ this.enlightEnpassant();
+ }
+
+ // Include square of the en-passant capturing square:
+ enlightEnpassant() {
+ // NOTE: shortcut, pawn has only one attack type, doesn't depend on square
+ const steps = this.pieces(this.playerColor)["p"].attack[0].steps;
+ for (let step of steps) {
+ const x = this.epSquare.x - step[0],
+ y = this.getY(this.epSquare.y - step[1]);
+ if (
+ this.onBoard(x, y) &&
+ this.getColor(x, y) == this.playerColor &&
+ this.getPieceType(x, y) == "p"
+ ) {
+ this.enlightened[x][this.epSquare.y] = true;
+ break;
+ }
+ }
+ }
+
+ // Apply diff this.enlightened --> oldEnlightened on board
+ graphUpdateEnlightened() {
+ let chessboard =
+ document.getElementById(this.containerId).querySelector(".chessboard");
+ const r = chessboard.getBoundingClientRect();
+ const pieceWidth = this.getPieceWidth(r.width);
+ for (let x=0; x<this.size.x; x++) {
+ for (let y=0; y<this.size.y; y++) {
+ if (!this.enlightened[x][y] && this.oldEnlightened[x][y]) {
+ let elt = document.getElementById(this.coordsToId({x: x, y: y}));
+ elt.classList.add("in-shadow");
+ if (this.g_pieces[x][y])
+ this.g_pieces[x][y].classList.add("hidden");
+ }
+ else if (this.enlightened[x][y] && !this.oldEnlightened[x][y]) {
+ let elt = document.getElementById(this.coordsToId({x: x, y: y}));
+ elt.classList.remove("in-shadow");
+ if (this.g_pieces[x][y])
+ this.g_pieces[x][y].classList.remove("hidden");
+ }
+ }
+ }
+ }
+
//////////////
// BASIC UTILS
};
}
- // Color of thing on square (i,j). 'undefined' if square is empty
+ // Color of thing on square (i,j). '' if square is empty
getColor(i, j) {
if (typeof i == "string")
return i; //reserves
return "other-color"; //unidentified color
}
- // Assume square i,j isn't empty
+ // Piece on i,j. '' if square is empty
getPiece(i, j) {
if (typeof j == "string")
return j; //reserves
}
// Piece type on square (i,j)
- getPieceType(i, j, p) {
+ getPieceType(x, y, p) {
if (!p)
- p = this.getPiece(i, j);
- return C.CannibalKings[p] || p; //a cannibal king move as...
+ p = this.getPiece(x, y);
+ return this.pieces()[p].moveas || p;
+ }
+
+ isKing(x, y, p) {
+ if (!p)
+ p = this.getPiece(x, y);
+ if (!this.options["cannibal"])
+ return p == 'k';
+ return !!C.CannibalKings[p];
}
// Get opponent color
}
]
},
- // rook
'r': {
"class": "rook",
moves: [
{steps: [[0, 1], [0, -1], [1, 0], [-1, 0]]}
]
},
- // knight
'n': {
"class": "knight",
moves: [
}
]
},
- // bishop
'b': {
"class": "bishop",
moves: [
{steps: [[1, 1], [1, -1], [-1, 1], [-1, -1]]}
]
},
- // queen
'q': {
"class": "queen",
moves: [
}
]
},
- // king
'k': {
"class": "king",
moves: [
return res;
}
+ getSegments(curSeg, segStart, segEnd) {
+ if (curSeg.length == 0)
+ return undefined;
+ let segments = JSON.parse(JSON.stringify(curSeg)); //not altering
+ segments.push([[segStart[0], segStart[1]], [segEnd[0], segEnd[1]]]);
+ return segments;
+ }
+
+ getStepSpec(color, x, y, piece) {
+ return this.pieces(color, x, y)[piece || this.getPieceType(x, y)];
+ }
+
// Can thing on square1 capture thing on square2?
canTake([x1, y1], [x2, y2]) {
return this.getColor(x1, y1) !== this.getColor(x2, y2);
return this.board[i][j] == "";
}
+ canDrop([c, p], [i, j]) {
+ return (
+ this.board[i][j] == "" &&
+ (!this.enlightened || this.enlightened[i][j]) &&
+ (
+ p != "p" ||
+ (c == 'w' && i < this.size.x - 1) ||
+ (c == 'b' && i > 0)
+ )
+ );
+ }
+
// For Madrasi:
// (redefined in Baroque etc, where Madrasi condition doesn't make sense)
isImmobilized([x, y]) {
return false;
const color = this.getColor(x, y);
const oppCol = C.GetOppCol(color);
- const piece = this.getPieceType(x, y); //ok not cannibal king
- const stepSpec = this.getStepSpec(color, x, y);
+ const piece = this.getPieceType(x, y);
+ const stepSpec = this.getStepSpec(color, x, y, piece);
const attacks = stepSpec.attack || stepSpec.moves;
for (let a of attacks) {
outerLoop: for (let step of a.steps) {
// Stop at the first capture found
atLeastOneCapture(color) {
const oppCol = C.GetOppCol(color);
- const allowed = ([x, y]) => {
- this.getColor(x, y) == oppCol &&
- this.filterValid([this.getBasicMove([i, j], [x, y])]).length >= 1
+ const allowed = (sq1, sq2) => {
+ return (
+ // NOTE: canTake is reversed for Zen.
+ // Generally ok because of the symmetry. TODO?
+ this.canTake(sq1, sq2) &&
+ this.filterValid(
+ [this.getBasicMove(sq1, sq2)]).length >= 1
+ );
};
for (let i=0; i<this.size.x; i++) {
for (let j=0; j<this.size.y; j++) {
if (this.getColor(i, j) == color) {
if (
- (!this.options["zen"] && this.findDestSquares(
- [i, j], {attackOnly: true, one: true}, allowed).length == 1) ||
- (this.options["zen"] && this.findCapturesOn(
- [i, j], {one: true}, allowed).length == 1)
+ (
+ !this.options["zen"] &&
+ this.findDestSquares(
+ [i, j],
+ {
+ attackOnly: true,
+ one: true,
+ segments: this.options["cylinder"]
+ },
+ allowed
+ )
+ )
+ ||
+ (
+ (
+ this.options["zen"] &&
+ this.findCapturesOn(
+ [i, j],
+ {
+ one: true,
+ segments: this.options["cylinder"]
+ },
+ allowed
+ )
+ )
+ )
) {
return true;
}
return false;
}
- getSegments(curSeg, segStart, segEnd) {
- if (curSeg.length == 0)
- return undefined;
- let segments = JSON.parse(JSON.stringify(curSeg)); //not altering
- segments.push([[segStart[0], segStart[1]], [segEnd[0], segEnd[1]]]);
- return segments;
- }
-
- getStepSpec(color, x, y) {
- const allSpecs = this.pieces(color, x, y);
- let stepSpec = allSpecs[piece];
- if (stepSpec.moveas)
- stepSpec = allSpecs[stepSpec.moveas];
- return stepSpec;
- }
-
compatibleStep([x1, y1], [x2, y2], step, range) {
+ const epsilon = 1e-7; //arbitrary small value
let shifts = [0];
if (this.options["cylinder"])
Array.prototype.push.apply(shifts, [-this.size.y, this.size.y]);
const rx = (x2 - x1) / step[0],
ry = (y2 + sh - y1) / step[1];
if (
+ // Zero step but non-zero interval => impossible
(!Number.isFinite(rx) && !Number.isNaN(rx)) ||
- (!Number.isFinite(ry) && !Number.isNaN(ry))
+ (!Number.isFinite(ry) && !Number.isNaN(ry)) ||
+ // Negative number of step (impossible)
+ (rx < 0 || ry < 0) ||
+ // Not the same number of steps in both directions:
+ (!Number.isNaN(rx) && !Number.isNaN(ry) && Math.abs(rx - ry) > epsilon)
) {
continue;
}
let distance = (Number.isNaN(rx) ? ry : rx);
- // TODO: 1e-7 here is totally arbitrary
- if (Math.abs(distance - Math.round(distance)) > 1e-7)
+ if (Math.abs(distance - Math.round(distance)) > epsilon)
continue;
distance = Math.round(distance); //in case of (numerical...)
- if (range >= distance)
+ if (!range || range >= distance)
return true;
}
return false;
let moves = [];
for (let i=0; i<this.size.x; i++) {
for (let j=0; j<this.size.y; j++) {
- if (
- this.board[i][j] == "" &&
- (!this.enlightened || this.enlightened[i][j]) &&
- (
- p != "p" ||
- (c == 'w' && i < this.size.x - 1) ||
- (c == 'b' && i > 0)
- )
- ) {
- moves.push(
- new Move({
- start: {x: c, y: p},
- end: {x: i, y: j},
- appear: [new PiPo({x: i, y: j, c: c, p: p})],
- vanish: []
- })
- );
+ if (this.canDrop([c, p], [i, j])) {
+ let mv = new Move({
+ start: {x: c, y: p},
+ end: {x: i, y: j},
+ appear: [new PiPo({x: i, y: j, c: c, p: p})],
+ vanish: []
+ });
+ if (this.board[i][j] != "") {
+ mv.vanish.push(new PiPo({
+ x: i,
+ y: j,
+ c: this.getColor(i, j),
+ p: this.getPiece(i, j)
+ }));
+ }
+ moves.push(mv);
}
}
}
}
// All possible moves from selected square
- getPotentialMovesFrom(sq, color) {
+ getPotentialMovesFrom([x, y], color) {
if (this.subTurnTeleport == 2)
return [];
- if (typeof sq[0] == "string")
- return this.getDropMovesFrom(sq);
- if (this.isImmobilized(sq))
+ if (typeof x == "string")
+ return this.getDropMovesFrom([x, y]);
+ if (this.isImmobilized([x, y]))
return [];
- const piece = this.getPieceType(sq[0], sq[1]);
- let moves = this.getPotentialMovesOf(piece, sq);
- if (
- piece == "p" &&
- this.hasEnpassant &&
- this.epSquare
- ) {
- Array.prototype.push.apply(moves, this.getEnpassantCaptures(sq));
- }
+ const piece = this.getPieceType(x, y);
+ let moves = this.getPotentialMovesOf(piece, [x, y]);
+ if (piece == "p" && this.hasEnpassant && this.epSquare)
+ Array.prototype.push.apply(moves, this.getEnpassantCaptures([x, y]));
if (
- piece == "k" &&
- this.hasCastle &&
+ piece == "k" && this.hasCastle &&
this.castleFlags[color || this.turn].some(v => v < this.size.y)
) {
- Array.prototype.push.apply(moves, this.getCastleMoves(sq));
+ Array.prototype.push.apply(moves, this.getCastleMoves([x, y]));
}
return this.postProcessPotentialMoves(moves);
}
const color = this.getColor(moves[0].start.x, moves[0].start.y);
const oppCol = C.GetOppCol(color);
- if (this.options["capture"] && this.atLeastOneCapture())
+ if (this.options["capture"] && this.atLeastOneCapture(color))
moves = this.capturePostProcess(moves, oppCol);
if (this.options["atomic"])
this.pawnPostProcess(moves, color, oppCol);
}
- if (
- this.options["cannibal"] &&
- this.options["rifle"]
- ) {
+ if (this.options["cannibal"] && this.options["rifle"])
// In this case a rifle-capture from last rank may promote a pawn
this.riflePromotePostProcess(moves, color);
- }
return moves;
}
}
// Generic method to find possible moves of "sliding or jumping" pieces
- getPotentialMovesOf(piece, [x, y], color) {
+ getPotentialMovesOf(piece, [x, y]) {
const color = this.getColor(x, y);
- const specialAttack = !!this.getStepSpec(color, x, y).attack;
+ const stepSpec = this.getStepSpec(color, x, y, piece);
let squares = [];
- if (specialAttack) {
+ if (stepSpec.attack) {
squares = this.findDestSquares(
[x, y],
{
attackOnly: true,
- segments: this.options["cylinder"]
+ segments: this.options["cylinder"],
+ stepSpec: stepSpec
},
- ([i, j]) => {
+ ([i1, j1], [i2, j2]) => {
return (
- (!this.options["zen"] || this.getPieceType(i, j) == 'k') &&
- this.canTake([x, y], [i, j])
+ (!this.options["zen"] || this.isKing(i2, j2)) &&
+ this.canTake([i1, j1], [i2, j2])
);
}
);
const noSpecials = this.findDestSquares(
[x, y],
{
- moveOnly: specialAttack || this.options["zen"],
- segments: this.options["cylinder"]
- },
- ([i, j]) => this.board[i][j] == "" || this.canTake([x, y], [i, j])
+ moveOnly: !!stepSpec.attack || this.options["zen"],
+ segments: this.options["cylinder"],
+ stepSpec: stepSpec
+ }
);
Array.prototype.push.apply(squares, noSpecials);
if (this.options["zen"]) {
let zenCaptures = this.findCapturesOn(
[x, y],
- {},
- ([i, j]) => this.getPieceType(i, j) != 'k'
+ {}, //byCol: default is ok
+ ([i1, j1], [i2, j2]) =>
+ !this.isKing(i1, j1) && this.canTake([i2, j2], [i1, j1])
);
// Technical step: segments (if any) are reversed
if (this.options["cylinder"]) {
zenCaptures.forEach(z => {
- if (z.segments)
- z.segments = z.segments.reverse().map(s => s.reverse())
+ z.segments = z.segments.reverse().map(s => s.reverse())
});
}
Array.prototype.push.apply(squares, zenCaptures);
[x, y],
{
attackOnly: true,
- segments: this.options["cylinder"]
+ segments: this.options["cylinder"],
+ stepSpec: stepSpec
},
- ([i, j]) =>
- this.getColor(i, j) == color && this.getPieceType(i, j) != 'k'
+ ([i1, j1], [i2, j2]) =>
+ this.getColor(i2, j2) == color && !this.isKing(i2, j2)
);
Array.prototype.push.apply(squares, selfCaptures);
}
findDestSquares([x, y], o, allowed) {
if (!allowed)
- allowed = () => true;
+ allowed = (sq1, sq2) => this.canTake(sq1, sq2);
const apparentPiece = this.getPiece(x, y); //how it looks
let res = [];
// Next 3 for Cylinder mode: (unused if !o.segments)
this.onBoard(i, j) &&
((i == x && j == y) || this.canStepOver(i, j, apparentPiece))
) {
- if (!explored[i + "." + j] && (i != x || j != y))
- {
+ if (!explored[i + "." + j] && (i != x || j != y)) {
explored[i + "." + j] = true;
if (
- allowed([i, j]) &&
- (
- !o.captureTarget ||
- (o.captureTarget[0] == i && o.captureTarget[1] == j)
- )
+ !o.captureTarget ||
+ (o.captureTarget[0] == i && o.captureTarget[1] == j)
) {
if (o.one && !o.attackOnly)
return true;
const pieceIJ = this.getPieceType(i, j);
if (!explored[i + "." + j]) {
explored[i + "." + j] = true;
- if (allowed([i, j])) {
+ if (allowed([x, y], [i, j])) {
if (o.one && !o.moveOnly)
return true;
if (!o.moveOnly)
}
}
}
+ return undefined; //default, but let's explicit it
};
if (o.captureTarget)
- exploreSteps(o.captureSteps)
+ return exploreSteps(o.captureSteps)
else {
- const stepSpec = this.getStepSpec(this.getColor(x, y), x, y);
+ const stepSpec =
+ o.stepSpec || this.getStepSpec(this.getColor(x, y), x, y);
+ let outOne = false;
if (!o.attackOnly || !stepSpec.attack)
- exploreSteps(stepSpec.moves);
- if (!o.moveOnly && !!stepSpec.attack)
- exploreSteps(stepSpec.attack);
+ outOne = exploreSteps(stepSpec.moves);
+ if (!outOne && !o.moveOnly && !!stepSpec.attack) {
+ o.attackOnly = true; //ok because o is always a temporary object
+ outOne = exploreSteps(stepSpec.attack);
+ }
+ return (o.one ? outOne : res);
}
- return o.captureTarget ? null : (o.one ? false : res);
}
// Search for enemy (or not) pieces attacking [x, y]
findCapturesOn([x, y], o, allowed) {
- if (!allowed)
- allowed = () => true;
- let res = [];
if (!o.byCol)
o.byCol = [C.GetOppCol(this.getColor(x, y) || this.turn)];
+ let res = [];
for (let i=0; i<this.size.x; i++) {
for (let j=0; j<this.size.y; j++) {
const colIJ = this.getColor(i, j);
if (!this.compatibleStep([i, j], [x, y], s, a.range))
continue;
// Finally verify that nothing stand in-between
- const newSquare = this.findDestSquares(
+ const out = this.findDestSquares(
[i, j],
{
captureTarget: [x, y],
captureSteps: [{steps: [s], range: a.range}],
- segments: this.options["cylinder"],
- attackOnly: true
+ segments: o.segments,
+ attackOnly: true,
+ one: false //one and captureTarget are mutually exclusive
},
- ([ii, jj]) => this.canTake([ii, jj], [x, y])
+ allowed
);
- if (newSquare)
+ if (out) {
if (o.one)
return true;
- res.push(newSquare);
+ res.push(out);
}
}
}
}
}
}
- return (one ? false : res);
+ return (o.one ? false : res);
}
// Build a regular move from its initial and destination squares.
})
);
if (this.options["cannibal"] && destColor != initColor) {
- const lastIdx = mv.vanish.length - 1;
+ const lastIdx = mv.vanish.length - 1; //think "Rifle+Cannibal"
let trPiece = mv.vanish[lastIdx].p;
- if (this.getPieceType(sx, sy) == 'k')
+ if (this.isKing(sx, sy))
trPiece = C.CannibalKingCode[trPiece];
if (mv.appear.length >= 1)
mv.appear[0].p = trPiece;
// Next conditions for variants like Atomic or Rifle, Recycle...
(
move.appear.length > 0 &&
- this.getPieceType(0, 0, move.appear[0].p) == "p"
+ this.getPieceType(0, 0, move.appear[0].p) == 'p'
)
&&
(
move.vanish.length > 0 &&
- this.getPieceType(0, 0, move.vanish[0].p) == "p"
+ this.getPieceType(0, 0, move.vanish[0].p) == 'p'
)
) {
return {
const color = this.getColor(x, y);
const shiftX = (color == 'w' ? -1 : 1);
const oppCol = C.GetOppCol(color);
- let enpassantMove = null;
if (
- !!this.epSquare &&
+ this.epSquare &&
this.epSquare.x == x + shiftX &&
Math.abs(this.getY(this.epSquare.y - y)) == 1 &&
- this.getColor(x, this.epSquare.y) == oppCol //Doublemove guard...
+ // Doublemove (and Progressive?) guards:
+ this.board[this.epSquare.x][this.epSquare.y] == "" &&
+ this.getColor(x, this.epSquare.y) == oppCol
) {
const [epx, epy] = [this.epSquare.x, this.epSquare.y];
- this.board[epx][epy] = oppCol + "p";
- enpassantMove = this.getBasicMove([x, y], [epx, epy]);
+ this.board[epx][epy] = oppCol + 'p';
+ let enpassantMove = this.getBasicMove([x, y], [epx, epy]);
this.board[epx][epy] = "";
const lastIdx = enpassantMove.vanish.length - 1; //think Rifle
enpassantMove.vanish[lastIdx].x = x;
+ return [enpassantMove];
}
- return !!enpassantMove ? [enpassantMove] : [];
+ return [];
}
- // "castleInCheck" arg to let some variants castle under check
- getCastleMoves([x, y], finalSquares, castleInCheck, castleWith) {
+ getCastleMoves([x, y], finalSquares, castleWith) {
const c = this.getColor(x, y);
// Castling ?
if (
this.board[x][rookPos] == "" ||
this.getColor(x, rookPos) != c ||
- (!!castleWith && !castleWith.includes(castlingPiece))
+ (castleWith && !castleWith.includes(castlingPiece))
) {
// Rook is not here, or changed color (see Benedict)
continue;
let i = y;
do {
if (
- (!castleInCheck && this.underCheck([x, i], oppCol)) ||
+ // NOTE: next weird test because underCheck() verification
+ // will be executed in filterValid() later.
+ (
+ i != finalSquares[castleSide][0] &&
+ this.underCheck([x, i], oppCol)
+ )
+ ||
(
this.board[x][i] != "" &&
// NOTE: next check is enough, because of chessboard constraints
}
}
- // If this code is reached, castle is valid
+ // If this code is reached, castle is potentially valid
moves.push(
new Move({
appear: [
// Is piece (or square) at given position attacked by "oppCol" ?
underAttack([x, y], oppCol) {
- const king = this.getPieceType(x, y) == 'k';
+ // An empty square is considered as king,
+ // since it's used only in getCastleMoves (TODO?)
+ const king = this.board[x][y] == "" || this.isKing(x, y);
return (
(
(!this.options["zen"] || king) &&
- this.findCapturesOn([x, y],
- {oppCol: oppCol, segments: this.options["cylinder"], one: true},
- ([i, j]) => this.canTake([i, j], [x, y])).length == 1
+ this.findCapturesOn(
+ [x, y],
+ {
+ byCol: [oppCol],
+ segments: this.options["cylinder"],
+ one: true
+ }
+ )
)
||
(
- (this.options["zen"] && !king) &&
- this.findDestSquares([x, y],
- {attackOnly: true, segments: this.options["cylinder"], one: true},
- ([i, j]) => this.canTake([i, j], [x, y])).length == 1
+ (!!this.options["zen"] && !king) &&
+ this.findDestSquares(
+ [x, y],
+ {
+ attackOnly: true,
+ segments: this.options["cylinder"],
+ one: true
+ },
+ ([i1, j1], [i2, j2]) => this.getColor(i2, j2) == oppCol
+ )
)
);
}
searchKingPos(color) {
for (let i=0; i < this.size.x; i++) {
for (let j=0; j < this.size.y; j++) {
- if (this.getColor(i, j) == color && this.getPieceType(i, j) == 'k')
+ if (this.getColor(i, j) == color && this.isKing(i, j))
return [i, j];
}
}
this.playOnBoard(m);
let square = kingPos,
res = true; //a priori valid
- if (m.vanish.some(v => {
- return this.getPieceType(0, 0, v.p) == 'k' && v.c == color;
- })) {
+ if (m.vanish.some(v => this.isKing(0, 0, v.p) && v.c == color)) {
// Search king in appear array:
const newKingIdx =
- m.appear.findIndex(a => {
- return this.getPieceType(0, 0, a.p) == 'k' && a.c == color;
- });
+ m.appear.findIndex(a => this.isKing(0, 0, a.p) && a.c == color);
if (newKingIdx >= 0)
square = [m.appear[newKingIdx].x, m.appear[newKingIdx].y];
else
/////////////////
// MOVES PLAYING
- // Aggregate flags into one object
- aggregateFlags() {
- return this.castleFlags;
- }
-
- // Reverse operation
- disaggregateFlags(flags) {
- this.castleFlags = flags;
- }
-
// Apply a move on board
playOnBoard(move) {
for (let psq of move.vanish)
updateCastleFlags(move) {
// Update castling flags if start or arrive from/at rook/king locations
move.appear.concat(move.vanish).forEach(psq => {
- if (
- this.board[psq.x][psq.y] != "" &&
- this.getPieceType(psq.x, psq.y) == "k"
- ) {
+ if (this.isKing(0, 0, psq.p))
this.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)
if (
this.hasCastle &&
// If flags already off, no need to re-check:
- Object.keys(this.castleFlags).some(c => {
- return this.castleFlags[c].some(val => val < this.size.y)})
+ Object.values(this.castleFlags).some(cvals =>
+ cvals.some(val => val < this.size.y))
) {
this.updateCastleFlags(move);
}
const destSquare = C.CoordsToSquare(move.end);
if (
this.ispawn[initSquare] ||
- (move.vanish[0].p == "p" && move.appear[0].p != "p")
+ (move.vanish[0].p == 'p' && move.appear[0].p != 'p')
) {
this.ispawn[destSquare] = true;
}
this.ispawn[destSquare] &&
this.getColor(move.end.x, move.end.y) != move.vanish[0].c
) {
- move.vanish[1].p = "p";
+ move.vanish[1].p = 'p';
delete this.ispawn[destSquare];
}
}
this.captured = null;
}
if (this.isLastMove(move)) {
- this.turn = oppCol;
+ this.turn = C.GetOppCol(color);
this.movesCount++;
this.subTurn = 1;
}
if (move.next)
return false;
const color = this.turn;
- const oppCol = C.GetOppCol(color);
- const oppKingPos = this.searchKingPos(oppCol);
+ const oppKingPos = this.searchKingPos(C.GetOppCol(color));
if (oppKingPos[0] < 0 || this.underCheck(oppKingPos, color))
return true;
return (
(
!this.options["balance"] ||
- ![1, 3].includes(this.movesCount)
+ ![1, 2].includes(this.movesCount) ||
+ this.subTurn == 2
)
&&
(
// "Stop at the first move found"
atLeastOneMove(color) {
- color = color || this.turn;
for (let i = 0; i < this.size.x; i++) {
for (let j = 0; j < this.size.y; j++) {
if (this.board[i][j] != "" && this.getColor(i, j) == color) {
return (color == "w" ? "0-1" : "1-0");
if (kingPos[1][0] < 0)
return (color == "w" ? "1-0" : "0-1");
- if (this.atLeastOneMove())
+ if (this.atLeastOneMove(color))
return "*";
// No valid move: stalemate or checkmate?
- if (!this.underCheck(kingPos[0], color))
+ if (!this.underCheck(kingPos[0], oppCol))
return "1/2";
// OK, checkmate
return (color == "w" ? "0-1" : "1-0");
// Implemented in variants using (automatic) moveStack
computeNextMove(move) {}
- getMaxDistance(r) {
- // Works for all rectangular boards:
- return Math.sqrt(r.width ** 2 + r.height ** 2);
- }
-
- getDomPiece(x, y) {
- return (typeof x == "string" ? this.r_pieces : this.g_pieces)[x][y];
- }
-
animateMoving(start, end, drag, segments, cb) {
let initPiece = this.getDomPiece(start.x, start.y);
// NOTE: cloning often not required, but light enough, and simpler