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")
return (f.charCodeAt(0) <= 90 ? "w" + f.toLowerCase() : "b" + f);
}
- // Setup the initial random-or-not (asymmetric-or-not) position
genRandInitFen(seed) {
+ Random.setSeed(seed); //may be unused
+ let baseFen = this.genRandInitBaseFen();
+ baseFen.o = Object.assign({init: true}, baseFen.o);
+ const parts = this.getPartFen(baseFen.o);
+ return (
+ baseFen.fen +
+ (Object.keys(parts).length > 0 ? (" " + JSON.stringify(parts)) : "")
+ );
+ }
+
+ // Setup the initial random-or-not (asymmetric-or-not) position
+ genRandInitBaseFen() {
let fen, flags = "0707";
if (!this.options.randomness)
// Deterministic:
else {
// Randomize
- Random.setSeed(seed);
let pieces = {w: new Array(8), b: new Array(8)};
flags = "";
// Shuffle pieces on first (and last rank if randomness == 2)
flags += flags;
break;
}
-
let positions = ArrayFun.range(8);
-
// Get random squares for bishops
let randIndex = 2 * Random.randInt(4);
const bishop1Pos = positions[randIndex];
// Remove chosen squares
positions.splice(Math.max(randIndex, randIndex_tmp), 1);
positions.splice(Math.min(randIndex, randIndex_tmp), 1);
-
// Get random squares for knights
randIndex = Random.randInt(6);
const knight1Pos = positions[randIndex];
randIndex = Random.randInt(5);
const knight2Pos = positions[randIndex];
positions.splice(randIndex, 1);
-
// Get random square for queen
randIndex = Random.randInt(4);
const queenPos = positions[randIndex];
positions.splice(randIndex, 1);
-
// Rooks and king positions are now fixed,
// because of the ordering rook-king-rook
const rook1Pos = positions[0];
const kingPos = positions[1];
const rook2Pos = positions[2];
-
// Finally put the shuffled pieces in the board array
pieces[c][rook1Pos] = "r";
pieces[c][knight1Pos] = "n";
" w 0"
);
}
- // Add turn + flags + enpassant (+ reserve)
- let parts = [];
- if (this.hasFlags)
- parts.push(`"flags":"${flags}"`);
- if (this.hasEnpassant)
- parts.push('"enpassant":"-"');
- if (this.hasReserveFen)
- parts.push('"reserve":"000000000000"');
- if (this.options["crazyhouse"])
- parts.push('"ispawn":"-"');
- if (parts.length >= 1)
- fen += " {" + parts.join(",") + "}";
- return fen;
+ return { fen: fen, o: {flags: flags} };
}
// "Parse" FEN: just return untransformed string data
// Return current fen (game state)
getFen() {
- let fen = (
- this.getPosition() + " " +
- this.getTurnFen() + " " +
- this.movesCount
+ const parts = this.getPartFen({});
+ return (
+ this.getBaseFen() +
+ (Object.keys(parts).length > 0 ? (" " + JSON.stringify(parts)) : "")
);
- let parts = [];
+ }
+
+ getBaseFen() {
+ return this.getPosition() + " " + this.turn + " " + this.movesCount;
+ }
+
+ getPartFen(o) {
+ let parts = {};
if (this.hasFlags)
- parts.push(`"flags":"${this.getFlagsFen()}"`);
+ parts["flags"] = o.init ? o.flags : this.getFlagsFen();
if (this.hasEnpassant)
- parts.push(`"enpassant":"${this.getEnpassantFen()}"`);
+ parts["enpassant"] = o.init ? "-" : this.getEnpassantFen();
if (this.hasReserveFen)
- parts.push(`"reserve":"${this.getReserveFen()}"`);
+ parts["reserve"] = this.getReserveFen(o);
if (this.options["crazyhouse"])
- parts.push(`"ispawn":"${this.getIspawnFen()}"`);
- if (parts.length >= 1)
- fen += " {" + parts.join(",") + "}";
- return fen;
+ parts["ispawn"] = this.getIspawnFen(o);
+ return parts;
}
static FenEmptySquares(count) {
return position;
}
- getTurnFen() {
- return this.turn;
- }
-
// Flags part of the FEN string
getFlagsFen() {
return ["w", "b"].map(c => {
// Enpassant part of the FEN string
getEnpassantFen() {
if (!this.epSquare)
- return "-"; //no en-passant
+ return "-";
return C.CoordsToSquare(this.epSquare);
}
- getReserveFen() {
+ getReserveFen(o) {
+ if (o.init)
+ return "000000000000";
return (
["w","b"].map(c => Object.values(this.reserve[c]).join("")).join("")
);
}
- getIspawnFen() {
+ getIspawnFen(o) {
+ if (o.init)
+ // NOTE: cannot merge because this.ispawn doesn't exist yet
+ return "-";
const squares = Object.keys(this.ispawn);
if (squares.length == 0)
return "-";
if (o.genFenOnly)
// This object will be used only for initial FEN generation
return;
+
+ // Some variables
this.playerColor = o.color;
this.afterPlay = o.afterPlay; //trigger some actions after playing a move
+ this.containerId = o.element;
+ this.isDiagram = o.diagram;
+ this.marks = o.marks;
- // Fen string fully describes the game state
+ // Initializations
if (!o.fen)
o.fen = this.genRandInitFen(o.seed);
this.re_initFromFen(o.fen);
-
- // Graphical (can use variables defined above)
- this.containerId = o.element;
this.graphicalInit();
}
this.setFlags(fenParsed.flags);
if (this.hasEnpassant)
this.epSquare = this.getEpSquare(fenParsed.enpassant);
- if (this.hasReserve)
+ if (this.hasReserve && !this.isDiagram)
this.initReserves(fenParsed.reserve);
if (this.options["crazyhouse"])
this.initIspawn(fenParsed.ispawn);
// VISUAL METHODS
graphicalInit() {
- // NOTE: not window.onresize = this.re_drawBoardElts because scope (this)
- window.onresize = () => this.re_drawBoardElements();
- this.re_drawBoardElements();
- this.initMouseEvents();
- const chessboard =
- document.getElementById(this.containerId).querySelector(".chessboard");
+ const g_init = () => {
+ this.re_drawBoardElements();
+ if (!this.isDiagram && !this.mouseListeners && !this.touchListeners)
+ this.initMouseEvents();
+ };
+ let container = document.getElementById(this.containerId);
+ this.windowResizeObs = new ResizeObserver(g_init);
+ this.windowResizeObs.observe(container);
}
re_drawBoardElements() {
const board = this.getSvgChessboard();
const oppCol = C.GetOppCol(this.playerColor);
- let chessboard =
- document.getElementById(this.containerId).querySelector(".chessboard");
+ const container = document.getElementById(this.containerId);
+ const rc = container.getBoundingClientRect();
+ let chessboard = container.querySelector(".chessboard");
chessboard.innerHTML = "";
chessboard.insertAdjacentHTML('beforeend', board);
// Compare window ratio width / height to aspectRatio:
- const windowRatio = window.innerWidth / window.innerHeight;
+ const windowRatio = rc.width / rc.height;
let cbWidth, cbHeight;
const vRatio = this.size.ratio || 1;
if (windowRatio <= vRatio) {
// Limiting dimension is width:
- cbWidth = Math.min(window.innerWidth, 767);
+ cbWidth = Math.min(rc.width, 767);
cbHeight = cbWidth / vRatio;
}
else {
// Limiting dimension is height:
- cbHeight = Math.min(window.innerHeight, 767);
+ cbHeight = Math.min(rc.height, 767);
cbWidth = cbHeight * vRatio;
}
- if (this.hasReserve) {
+ if (this.hasReserve && !this.isDiagram) {
const sqSize = cbWidth / this.size.y;
// NOTE: allocate space for reserves (up/down) even if they are empty
// Cannot use getReserveSquareSize() here, but sqSize is an upper bound.
- if ((window.innerHeight - cbHeight) / 2 < sqSize + 5) {
- cbHeight = window.innerHeight - 2 * (sqSize + 5);
+ if ((rc.height - cbHeight) / 2 < sqSize + 5) {
+ cbHeight = rc.height - 2 * (sqSize + 5);
cbWidth = cbHeight * vRatio;
}
}
chessboard.style.width = cbWidth + "px";
chessboard.style.height = cbHeight + "px";
// Center chessboard:
- const spaceLeft = (window.innerWidth - cbWidth) / 2,
- spaceTop = (window.innerHeight - cbHeight) / 2;
+ const spaceLeft = (rc.width - cbWidth) / 2,
+ spaceTop = (rc.height - cbHeight) / 2;
chessboard.style.left = spaceLeft + "px";
chessboard.style.top = spaceTop + "px";
// Give sizes instead of recomputing them,
}
setupPieces(r) {
- if (this.g_pieces) {
- // Refreshing: delete old pieces first
- for (let i=0; i<this.size.x; i++) {
- for (let j=0; j<this.size.y; j++) {
- if (this.g_pieces[i][j]) {
- this.g_pieces[i][j].remove();
- this.g_pieces[i][j] = null;
- }
- }
- }
- }
- else
- this.g_pieces = ArrayFun.init(this.size.x, this.size.y, null);
let chessboard =
document.getElementById(this.containerId).querySelector(".chessboard");
if (!r)
r = chessboard.getBoundingClientRect();
const pieceWidth = this.getPieceWidth(r.width);
+ const addPiece = (i, j, arrName, classes) => {
+ this[arrName][i][j] = document.createElement("piece");
+ C.AddClass_es(this[arrName][i][j], classes);
+ this[arrName][i][j].style.width = pieceWidth + "px";
+ this[arrName][i][j].style.height = pieceWidth + "px";
+ let [ip, jp] = this.getPixelPosition(i, j, r);
+ // Translate coordinates to use chessboard as reference:
+ this[arrName][i][j].style.transform =
+ `translate(${ip - r.x}px,${jp - r.y}px)`;
+ chessboard.appendChild(this[arrName][i][j]);
+ };
+ const conditionalReset = (arrName) => {
+ if (this[arrName]) {
+ // Refreshing: delete old pieces first. This isn't necessary,
+ // but simpler (this method isn't called many times)
+ for (let i=0; i<this.size.x; i++) {
+ for (let j=0; j<this.size.y; j++) {
+ if (this[arrName][i][j]) {
+ this[arrName][i][j].remove();
+ this[arrName][i][j] = null;
+ }
+ }
+ }
+ }
+ 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"));
+ };
+ if (this.marks)
+ conditionalReset("d_pieces");
+ conditionalReset("g_pieces");
for (let i=0; i < this.size.x; i++) {
for (let j=0; j < this.size.y; j++) {
if (this.board[i][j] != "") {
const color = this.getColor(i, j);
const piece = this.getPiece(i, j);
- this.g_pieces[i][j] = document.createElement("piece");
- C.AddClass_es(this.g_pieces[i][j],
- this.pieces(color, i, j)[piece]["class"]);
+ addPiece(i, j, "g_pieces", this.pieces(color, i, j)[piece]["class"]);
this.g_pieces[i][j].classList.add(C.GetColorClass(color));
- this.g_pieces[i][j].style.width = pieceWidth + "px";
- this.g_pieces[i][j].style.height = pieceWidth + "px";
- let [ip, jp] = this.getPixelPosition(i, j, r);
- // Translate coordinates to use chessboard as reference:
- this.g_pieces[i][j].style.transform =
- `translate(${ip - r.x}px,${jp - r.y}px)`;
if (this.enlightened && !this.enlightened[i][j])
this.g_pieces[i][j].classList.add("hidden");
- chessboard.appendChild(this.g_pieces[i][j]);
+ }
+ if (this.marks && this.d_pieces[i][j]) {
+ let classes = ["mark"];
+ if (this.board[i][j] != "")
+ classes.push("transparent");
+ addPiece(i, j, "d_pieces", classes);
}
}
}
- if (this.hasReserve)
+ if (this.hasReserve && !this.isDiagram)
this.re_drawReserve(['w', 'b'], r);
}
// Resize board: no need to destroy/recreate pieces
rescale(mode) {
- let chessboard =
- document.getElementById(this.containerId).querySelector(".chessboard");
- const r = chessboard.getBoundingClientRect();
+ const container = document.getElementById(this.containerId);
+ let chessboard = container.querySelector(".chessboard");
+ const rc = container.getBoundingClientRect(),
+ r = chessboard.getBoundingClientRect();
const multFact = (mode == "up" ? 1.05 : 0.95);
let [newWidth, newHeight] = [multFact * r.width, multFact * r.height];
// Stay in window:
const vRatio = this.size.ratio || 1;
- if (newWidth > window.innerWidth) {
- newWidth = window.innerWidth;
+ if (newWidth > rc.width) {
+ newWidth = rc.width;
newHeight = newWidth / vRatio;
}
- if (newHeight > window.innerHeight) {
- newHeight = window.innerHeight;
+ if (newHeight > rc.height) {
+ newHeight = rc.height;
newWidth = newHeight * vRatio;
}
chessboard.style.width = newWidth + "px";
chessboard.style.height = newHeight + "px";
- const newX = (window.innerWidth - newWidth) / 2;
+ const newX = (rc.width - newWidth) / 2;
chessboard.style.left = newX + "px";
- const newY = (window.innerHeight - newHeight) / 2;
+ const newY = (rc.height - newHeight) / 2;
chessboard.style.top = newY + "px";
const newR = {x: newX, y: newY, width: newWidth, height: newHeight};
const pieceWidth = this.getPieceWidth(newWidth);
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];
curPiece.remove();
};
+ const resize = (e) => this.rescale(e.deltaY < 0 ? "up" : "down");
+
if ('onmousedown' in window) {
- document.addEventListener("mousedown", mousedown);
- document.addEventListener("mousemove", mousemove);
- document.addEventListener("mouseup", mouseup);
- document.addEventListener("wheel",
- (e) => this.rescale(e.deltaY < 0 ? "up" : "down"));
+ this.mouseListeners = [
+ {type: "mousedown", listener: mousedown},
+ {type: "mousemove", listener: mousemove},
+ {type: "mouseup", listener: mouseup},
+ {type: "wheel", listener: resize}
+ ];
+ this.mouseListeners.forEach(ml => {
+ document.addEventListener(ml.type, ml.listener);
+ });
}
if ('ontouchstart' in window) {
- // https://stackoverflow.com/a/42509310/12660887
- document.addEventListener("touchstart", mousedown, {passive: false});
- document.addEventListener("touchmove", mousemove, {passive: false});
- document.addEventListener("touchend", mouseup, {passive: false});
+ this.touchListeners = [
+ {type: "touchstart", listener: mousedown},
+ {type: "touchmove", listener: mousemove},
+ {type: "touchend", listener: mouseup}
+ ];
+ this.touchListeners.forEach(tl => {
+ // https://stackoverflow.com/a/42509310/12660887
+ document.addEventListener(tl.type, tl.listener, {passive: false});
+ });
}
// TODO: onpointerdown/move/up ? See reveal.js /controllers/touch.js
}
+ removeListeners() {
+ let container = document.getElementById(this.containerId);
+ this.windowResizeObs.unobserve(container);
+ if (this.isDiagram)
+ return; //no listeners in this case
+ if ('onmousedown' in window) {
+ this.mouseListeners.forEach(ml => {
+ document.removeEventListener(ml.type, ml.listener);
+ });
+ }
+ if ('ontouchstart' in window) {
+ this.touchListeners.forEach(tl => {
+ // https://stackoverflow.com/a/42509310/12660887
+ document.removeEventListener(tl.type, tl.listener);
+ });
+ }
+ }
+
showChoices(moves, r) {
let container = document.getElementById(this.containerId);
let chessboard = container.querySelector(".chessboard");
}
// Piece type on square (i,j)
- getPieceType(i, j, p) {
+ getPieceType(x, y, p) {
+ if (!p)
+ p = this.getPiece(x, y);
+ return this.pieces()[p].moveas || p;
+ }
+
+ isKing(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);
+ if (!this.options["cannibal"])
+ return p == 'k';
+ return !!C.CannibalKings[p];
}
// Get opponent color
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;
+ getStepSpec(color, x, y, piece) {
+ return this.pieces(color, x, y)[piece || this.getPieceType(x, y)];
}
// Can thing on square1 capture thing on square2?
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;
}
}
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;
if (piece == "p" && this.hasEnpassant && this.epSquare)
Array.prototype.push.apply(moves, this.getEnpassantCaptures([x, y]));
if (
- piece == "k" && this.hasCastle &&
+ this.isKing(0, 0, piece) && this.hasCastle &&
this.castleFlags[color || this.turn].some(v => v < this.size.y)
) {
Array.prototype.push.apply(moves, this.getCastleMoves([x, y]));
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"]) {
[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;
if (!o.byCol)
o.byCol = [C.GetOppCol(this.getColor(x, y) || this.turn)];
let res = [];
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;
// 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],
- {byCol: [oppCol], segments: this.options["cylinder"], one: true},
- ([i, j]) => this.canTake([i, j], [x, y]))
+ 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]))
+ (!!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
+ )
)
);
}
- underCheck([x, y], oppCol) {
+ // Argument is (very generally) an array of squares (= arrays)
+ underCheck(square_s, oppCol) {
if (this.options["taking"] || this.options["dark"])
return false;
- return this.underAttack([x, y], oppCol);
+ if (!Array.isArray(square_s[0]))
+ square_s = [square_s];
+ return square_s.some(sq => this.underAttack(sq, oppCol));
}
- // Stop at first king found (TODO: multi-kings)
+ // Scan board for king(s)
searchKingPos(color) {
+ let res = [];
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')
- return [i, j];
+ if (this.getColor(i, j) == color && this.isKing(i, j))
+ res.push([i, j]);
}
}
- return [-1, -1]; //king not found
+ return res;
}
// 'color' arg because some variants (e.g. Refusal) check opponent moves
if (!color)
color = this.turn;
const oppCol = C.GetOppCol(color);
- const kingPos = this.searchKingPos(color);
+ let kingPos = this.searchKingPos(color);
let filtered = {}; //avoid re-checking similar moves (promotions...)
return moves.filter(m => {
const key = m.start.x + m.start.y + '.' + m.end.x + m.end.y;
if (!filtered[key]) {
this.playOnBoard(m);
- let square = kingPos,
+ let newKingPP = null,
+ sqIdx = 0,
res = true; //a priori valid
- if (m.vanish.some(v => {
- return this.getPieceType(0, 0, v.p) == 'k' && v.c == color;
- })) {
+ const oldKingPP =
+ m.vanish.find(v => this.isKing(0, 0, v.p) && v.c == color);
+ if (oldKingPP) {
// Search king in appear array:
- const newKingIdx =
- m.appear.findIndex(a => {
- return this.getPieceType(0, 0, a.p) == 'k' && a.c == color;
- });
- if (newKingIdx >= 0)
- square = [m.appear[newKingIdx].x, m.appear[newKingIdx].y];
+ newKingPP =
+ m.appear.find(a => this.isKing(0, 0, a.p) && a.c == color);
+ if (newKingPP) {
+ sqIdx = kingPos.findIndex(kp =>
+ kp[0] == oldKingPP.x && kp[1] == oldKingPP.y);
+ kingPos[sqIdx] = [newKingPP.x, newKingPP.y];
+ }
else
- res = false;
+ res = false; //king vanished
}
- res &&= !this.underCheck(square, oppCol);
+ res &&= !this.underCheck(kingPos, oppCol);
+ if (oldKingPP && newKingPP)
+ kingPos[sqIdx] = [oldKingPP.x, oldKingPP.y];
this.undoOnBoard(m);
filtered[key] = res;
return res;
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)
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);
- if (oppKingPos[0] < 0 || this.underCheck(oppKingPos, color))
+ const oppKingPos = this.searchKingPos(C.GetOppCol(color));
+ if (oppKingPos.length == 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) {
getCurrentScore(move) {
const color = this.turn;
const oppCol = C.GetOppCol(color);
- const kingPos = [this.searchKingPos(color), this.searchKingPos(oppCol)];
- if (kingPos[0][0] < 0 && kingPos[1][0] < 0)
+ const kingPos = {
+ [color]: this.searchKingPos(color),
+ [oppCol]: this.searchKingPos(oppCol)
+ };
+ if (kingPos[color].length == 0 && kingPos[oppCol].length == 0)
return "1/2";
- if (kingPos[0][0] < 0)
+ if (kingPos[color].length == 0)
return (color == "w" ? "0-1" : "1-0");
- if (kingPos[1][0] < 0)
+ if (kingPos[oppCol].length == 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[color], oppCol))
return "1/2";
// OK, checkmate
return (color == "w" ? "0-1" : "1-0");
projects / xogo.git / blobdiff