-import { Random } from "/utils/alea.js";
-import { ArrayFun } from "/utils/array.js";
+import {Random} from "/utils/alea.js";
+import {ArrayFun} from "/utils/array.js";
+import {FenUtil} from "/utils/setupPieces.js";
import PiPo from "/utils/PiPo.js";
import Move from "/utils/Move.js";
return true;
}
+ // Allow to take (moving: not disappearing) own pieces?
+ get hasSelfCaptures() {
+ return (
+ this.options["recycle"] ||
+ (this.options["teleport"] && this.subTurnTeleport == 1)
+ );
+ }
+
get hasReserve() {
return (
!!this.options["crazyhouse"] ||
return false;
}
+ // Some variants reveal moves only after both players played
+ get hideMoves() {
+ return false;
+ }
+
+ // Some variants do not flip board as black
+ get flippedBoard() {
+ return (this.playerColor == 'b');
+ }
+
// Some variants use click infos:
doClick(coords) {
if (typeof coords.x != "number")
return Object.values(cd).map(c => c.toString(36)).join("");
}
+ // c10 --> 02 (assuming 10 rows)
+ static SquareFromUsual(sq) {
+ return (
+ (this.size.x - parseInt(sq.substring(1), 10)).toString(36) +
+ (sq.charCodeAt(0) - 97).toString(36)
+ );
+ }
+
+ // 02 --> c10
+ static UsualFromSquare(sq) {
+ return (
+ String.fromCharCode(parseInt(sq.charAt(1), 36) + 97) +
+ (this.size.x - parseInt(sq.charAt(0), 36)).toString(10)
+ );
+ }
+
coordsToId(cd) {
if (typeof cd.x == "number") {
return (
return (f.charCodeAt(0) <= 90 ? "w" + f.toLowerCase() : "b" + f);
}
- // Setup the initial random-or-not (asymmetric-or-not) position
genRandInitFen(seed) {
- let fen, flags = "0707";
- if (!this.options.randomness)
- // Deterministic:
- fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w 0";
-
- 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)
- for (let c of ["w", "b"]) {
- if (c == 'b' && this.options.randomness == 1) {
- pieces['b'] = pieces['w'];
- flags += flags;
- break;
- }
+ 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 + " w 0" +
+ (Object.keys(parts).length > 0 ? (" " + JSON.stringify(parts)) : "")
+ );
+ }
- let positions = ArrayFun.range(8);
-
- // Get random squares for bishops
- let randIndex = 2 * Random.randInt(4);
- const bishop1Pos = positions[randIndex];
- // The second bishop must be on a square of different color
- let randIndex_tmp = 2 * Random.randInt(4) + 1;
- const bishop2Pos = positions[randIndex_tmp];
- // 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];
- positions.splice(randIndex, 1);
- 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";
- pieces[c][bishop1Pos] = "b";
- pieces[c][queenPos] = "q";
- pieces[c][kingPos] = "k";
- pieces[c][bishop2Pos] = "b";
- pieces[c][knight2Pos] = "n";
- pieces[c][rook2Pos] = "r";
- flags += rook1Pos.toString() + rook2Pos.toString();
+ // Setup the initial random-or-not (asymmetric-or-not) position
+ genRandInitBaseFen() {
+ const s = FenUtil.setupPieces(
+ ['r', 'n', 'b', 'q', 'k', 'b', 'n', 'r'],
+ {
+ randomness: this.options["randomness"],
+ between: [{p1: 'k', p2: 'r'}],
+ diffCol: ['b'],
+ flags: ['r']
}
- fen = (
- pieces["b"].join("") +
- "/pppppppp/8/8/8/8/PPPPPPPP/" +
- pieces["w"].join("").toUpperCase() +
- " 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: s.b.join("") + "/pppppppp/8/8/8/8/PPPPPPPP/" +
+ s.w.join("").toUpperCase(),
+ o: {flags: s.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) {
// Position part of the FEN string
getPosition() {
let position = "";
- for (let i = 0; i < this.size.y; i++) {
+ for (let i = 0; i < this.size.x; i++) {
let emptyCount = 0;
- for (let j = 0; j < this.size.x; j++) {
+ for (let j = 0; j < this.size.y; j++) {
if (this.board[i][j] == "")
emptyCount++;
else {
if (emptyCount > 0)
// "Flush remainder"
position += C.FenEmptySquares(emptyCount);
- if (i < this.size.y - 1)
+ if (i < this.size.x - 1)
position += "/"; //separate rows
}
return position;
}
- getTurnFen() {
- return this.turn;
- }
-
// 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("");
}
// 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 Array(2 * V.ReserveArray.length).fill('0').join("");
return (
- ["w","b"].map(c => Object.values(this.reserve[c]).join("")).join("")
+ ['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 (this.options[opt.variable] === undefined)
this.options[opt.variable] = opt.defaut;
});
- 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.isDiagram = o.diagram;
this.graphicalInit();
}
}
// ordering as in pieces() p,r,n,b,q,k
+ static get ReserveArray() {
+ return ['p', 'r', 'n', 'b', 'q', 'k'];
+ }
+
initReserves(reserveStr) {
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;
- for (let i of ArrayFun.range(2 * L)) {
- if (i < L)
- this.reserve['w'][pieceName[i]] = counts[i];
- else
- this.reserve['b'][pieceName[i-L]] = counts[i];
- }
+ const L = V.ReserveArray.length;
+ this.reserve = {
+ w: ArrayFun.toObject(V.ReserveArray, counts.slice(0, L)),
+ b: ArrayFun.toObject(V.ReserveArray, counts.slice(L, 2 * L))
+ };
}
initIspawn(ispawnStr) {
// VISUAL UTILS
getPieceWidth(rwidth) {
- return (rwidth / this.size.y);
+ return (rwidth / Math.max(this.size.x, this.size.y));
}
getReserveSquareSize(rwidth, nbR) {
}
getRankInReserve(c, p) {
- const pieces = Object.keys(this.pieces());
+ const pieces = Object.keys(this.pieces(c, c, p));
const lastIndex = pieces.findIndex(pp => pp == p)
let toTest = pieces.slice(0, lastIndex);
return toTest.reduce(
(oldV,newV) => oldV + (this.reserve[c][newV] > 0 ? 1 : 0), 0);
}
- static AddClass_es(piece, class_es) {
+ static AddClass_es(elt, class_es) {
if (!Array.isArray(class_es))
class_es = [class_es];
- class_es.forEach(cl => {
- piece.classList.add(cl);
- });
+ class_es.forEach(cl => elt.classList.add(cl));
}
- static RemoveClass_es(piece, class_es) {
+ static RemoveClass_es(elt, class_es) {
if (!Array.isArray(class_es))
class_es = [class_es];
- class_es.forEach(cl => {
- piece.classList.remove(cl);
- });
+ class_es.forEach(cl => elt.classList.remove(cl));
}
// Generally light square bottom-right
re_drawBoardElements() {
const board = this.getSvgChessboard();
- const oppCol = C.GetOppCol(this.playerColor);
const container = document.getElementById(this.containerId);
const rc = container.getBoundingClientRect();
let chessboard = container.querySelector(".chessboard");
chessboard.style.top = spaceTop + "px";
// Give sizes instead of recomputing them,
// because chessboard might not be drawn yet.
- this.setupPieces({
+ this.setupVisualPieces({
width: cbWidth,
height: cbHeight,
x: spaceLeft,
// Get SVG board (background, no pieces)
getSvgChessboard() {
- const flipped = (this.playerColor == 'b');
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))
+ continue;
const ii = (flipped ? this.size.x - 1 - i : i);
const jj = (flipped ? this.size.y - 1 - j : j);
let classes = this.getSquareColorClass(ii, jj);
/>`;
}
}
- board += "</svg>";
return board;
}
- setupPieces(r) {
- // TODO: d_pieces : only markers (for diagrams) / also in rescale()
- 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);
+ setupVisualPieces(r) {
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((m) => {
+ const formattedSquare = C.SquareFromUsual(m);
+ const mCoords = C.SquareToCoords(formattedSquare);
+ addPiece(mCoords.x, mCoords.y, 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"]);
- 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)`;
+ addPiece(i, j, "g_pieces", this.pieces(color, i, j)[piece]["class"]);
+ this.g_pieces[i][j].classList.add(V.GetColorClass(color));
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);
}
}
}
rcontainer.appendChild(r_cell);
let piece = document.createElement("piece");
C.AddClass_es(piece, this.pieces(c, c, p)[p]["class"]);
- piece.classList.add(C.GetColorClass(c));
+ piece.classList.add(V.GetColorClass(c));
piece.style.width = "100%";
piece.style.height = "100%";
this.r_pieces[c][p] = piece;
piece = "k"; //capturing cannibal king: back to king form
const oldCount = this.reserve[color][piece];
this.reserve[color][piece] = count;
- // Redrawing is much easier if count==0
- if ([oldCount, count].includes(0))
+ // Redrawing is much easier if count==0 (or undefined)
+ if ([oldCount, count].some(item => !item))
this.re_drawReserve([color]);
else {
const numId = this.getReserveNumId(color, piece);
}
}
}
- if (this.hasReserve && !this.isDiagram)
+ if (this.hasReserve)
this.rescaleReserve(newR);
}
y = (this.playerColor == i ? y = r.height + 5 : - 5 - rsqSize);
}
else {
- const sqSize = r.width / this.size.y;
- const flipped = (this.playerColor == 'b');
- x = (flipped ? this.size.y - 1 - j : j) * sqSize;
+ const sqSize = r.width / Math.max(this.size.x, this.size.y);
+ const flipped = this.flippedBoard;
+ x = (flipped ? this.size.y - 1 - j : j) * sqSize +
+ Math.abs(this.size.x - this.size.y) * sqSize / 2;
y = (flipped ? this.size.x - 1 - i : i) * sqSize;
}
return [r.x + x, r.y + y];
// TODO: onpointerdown/move/up ? See reveal.js /controllers/touch.js
}
+ // NOTE: not called if isDiagram
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);
const cdisp = moves[i].choice || moves[i].appear[0].p;
C.AddClass_es(piece,
this.pieces(color, moves[i].end.x, moves[i].end.y)[cdisp]["class"]);
- piece.classList.add(C.GetColorClass(color));
+ piece.classList.add(V.GetColorClass(color));
piece.style.width = "100%";
piece.style.height = "100%";
choice.appendChild(piece);
}
}
+ displayMessage(elt, msg, classe_s, timeout) {
+ if (elt)
+ // Fixed element, e.g. for Dice Chess
+ elt.innerHTML = msg;
+ else {
+ // Temporary div (Chakart, Apocalypse...)
+ let divMsg = document.createElement("div");
+ C.AddClass_es(divMsg, classe_s);
+ divMsg.innerHTML = msg;
+ let container = document.getElementById(this.containerId);
+ container.appendChild(divMsg);
+ setTimeout(() => container.removeChild(divMsg), timeout);
+ }
+ }
+
////////////////
// DARK METHODS
// 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;
+ // TODO: (0, 0) is wrong, would need to place an attacker here...
+ const steps = this.pieces(this.playerColor, 0, 0)["p"].attack[0].steps;
for (let step of steps) {
- const x = this.epSquare.x - step[0],
+ const x = this.epSquare.x - step[0], //NOTE: epSquare.x not on edge
y = this.getY(this.epSquare.y - step[1]);
if (
this.onBoard(x, y) &&
getPieceType(x, y, p) {
if (!p)
p = this.getPiece(x, y);
- return this.pieces()[p].moveas || p;
+ return this.pieces(this.getColor(x, y), x, y)[p].moveas || p;
}
isKing(x, y, p) {
return !!C.CannibalKings[p];
}
- // Get opponent color
- static GetOppCol(color) {
+ static GetOppTurn(color) {
+ return (color == 'w' ? 'b' : 'w');
+ }
+
+ // Get opponent color(s): may differ from turn (e.g. Checkered)
+ getOppCols(color) {
return (color == "w" ? "b" : "w");
}
////////////////////////
// PIECES SPECIFICATIONS
+ getPawnShift(color) {
+ return (color == "w" ? -1 : 1);
+ }
+ isPawnInitRank(x, color) {
+ return (color == 'w' && x >= 6) || (color == 'b' && x <= 1);
+ }
+
pieces(color, x, y) {
- const pawnShift = (color == "w" ? -1 : 1);
- // NOTE: jump 2 squares from first rank (pawns can be here sometimes)
- const initRank = ((color == 'w' && x >= 6) || (color == 'b' && x <= 1));
+ const pawnShift = this.getPawnShift(color || 'w');
return {
'p': {
"class": "pawn",
moves: [
{
steps: [[pawnShift, 0]],
- range: (initRank ? 2 : 1)
+ range: (this.isPawnInitRank(x, color) ? 2 : 1)
}
],
attack: [
},
'r': {
"class": "rook",
- moves: [
+ both: [
{steps: [[0, 1], [0, -1], [1, 0], [-1, 0]]}
]
},
'n': {
"class": "knight",
- moves: [
+ both: [
{
steps: [
[1, 2], [1, -2], [-1, 2], [-1, -2],
},
'b': {
"class": "bishop",
- moves: [
+ both: [
{steps: [[1, 1], [1, -1], [-1, 1], [-1, -1]]}
]
},
'q': {
"class": "queen",
- moves: [
+ both: [
{
steps: [
[0, 1], [0, -1], [1, 0], [-1, 0],
},
'k': {
"class": "king",
- moves: [
+ both: [
{
steps: [
[0, 1], [0, -1], [1, 0], [-1, 0],
res += this.size.y;
return res;
}
+ // Circular?
+ getX(x) {
+ return x; //generally, no
+ }
+
+ increment([x, y], step) {
+ return [
+ this.getX(x + step[0]),
+ this.getY(y + step[1])
+ ];
+ }
getSegments(curSeg, segStart, segEnd) {
if (curSeg.length == 0)
}
getStepSpec(color, x, y, piece) {
- return this.pieces(color, x, y)[piece || this.getPieceType(x, y)];
+ let pieceType = piece;
+ let allSpecs = this.pieces(color, x, y);
+ if (!piece)
+ pieceType = this.getPieceType(x, y);
+ else if (allSpecs[piece].moveas)
+ pieceType = allSpecs[piece].moveas;
+ let res = allSpecs[pieceType];
+ if (!res["both"])
+ res.both = [];
+ if (!res["moves"])
+ res.moves = [];
+ if (!res["attack"])
+ res.attack = [];
+ return res;
}
// Can thing on square1 capture thing on square2?
return this.getColor(x1, y1) !== this.getColor(x2, y2);
}
+ // Teleport & Recycle. Assumption: color(x1,y1) == color(x2,y2)
+ canSelfTake([x1, y1], [x2, y2]) {
+ return !this.isKing(x2, y2);
+ }
+
canStepOver(i, j, p) {
// In some variants, objects on boards don't stop movement (Chakart)
return this.board[i][j] == "";
if (!this.options["madrasi"])
return false;
const color = this.getColor(x, y);
- const oppCol = C.GetOppCol(color);
+ const oppCols = this.getOppCols(color);
const piece = this.getPieceType(x, y);
const stepSpec = this.getStepSpec(color, x, y, piece);
- const attacks = stepSpec.attack || stepSpec.moves;
+ const attacks = stepSpec.both.concat(stepSpec.attack);
for (let a of attacks) {
outerLoop: for (let step of a.steps) {
- let [i, j] = [x + step[0], y + step[1]];
- let stepCounter = 1;
+ let [i, j] = this.increment([x, y], step);
+ let stepCounter = 0;
while (this.onBoard(i, j) && this.board[i][j] == "") {
if (a.range <= stepCounter++)
continue outerLoop;
- i += step[0];
- j = this.getY(j + step[1]);
+ [i, j] = this.increment([i, j], step);
}
if (
this.onBoard(i, j) &&
- this.getColor(i, j) == oppCol &&
+ oppCols.includes(this.getColor(i, j)) &&
this.getPieceType(i, j) == piece
) {
return true;
// Stop at the first capture found
atLeastOneCapture(color) {
- const oppCol = C.GetOppCol(color);
const allowed = (sq1, sq2) => {
return (
// NOTE: canTake is reversed for Zen.
{
attackOnly: true,
one: true,
- segments: this.options["cylinder"]
},
allowed
)
this.options["zen"] &&
this.findCapturesOn(
[i, j],
- {
- one: true,
- segments: this.options["cylinder"]
- },
+ {one: true},
allowed
)
)
let moves = [];
for (let i=0; i<this.size.x; i++) {
for (let j=0; j<this.size.y; j++) {
- if (this.canDrop([c, p], [i, j])) {
+ if (this.onBoard(i, j) && this.canDrop([c, p], [i, j])) {
let mv = new Move({
start: {x: c, y: p},
end: {x: i, y: j},
}
// All possible moves from selected square
+ // TODO: generalize usage if arg "color" (e.g. Checkered)
getPotentialMovesFrom([x, y], color) {
if (this.subTurnTeleport == 2)
return [];
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 &&
- 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);
}
if (moves.length == 0)
return [];
const color = this.getColor(moves[0].start.x, moves[0].start.y);
- const oppCol = C.GetOppCol(color);
+ const oppCols = this.getOppCols(color);
if (this.options["capture"] && this.atLeastOneCapture(color))
- moves = this.capturePostProcess(moves, oppCol);
+ moves = this.capturePostProcess(moves, oppCols);
if (this.options["atomic"])
- this.atomicPostProcess(moves, color, oppCol);
+ moves = this.atomicPostProcess(moves, color, oppCols);
if (
moves.length > 0 &&
this.getPieceType(moves[0].start.x, moves[0].start.y) == "p"
) {
- this.pawnPostProcess(moves, color, oppCol);
+ moves = this.pawnPostProcess(moves, color, oppCols);
}
if (this.options["cannibal"] && this.options["rifle"])
// In this case a rifle-capture from last rank may promote a pawn
- this.riflePromotePostProcess(moves, color);
+ moves = this.riflePromotePostProcess(moves, color);
return moves;
}
- capturePostProcess(moves, oppCol) {
+ capturePostProcess(moves, oppCols) {
// Filter out non-capturing moves (not using m.vanish because of
// self captures of Recycle and Teleport).
return moves.filter(m => {
return (
this.board[m.end.x][m.end.y] != "" &&
- this.getColor(m.end.x, m.end.y) == oppCol
+ oppCols.includes(this.getColor(m.end.x, m.end.y))
);
});
}
- atomicPostProcess(moves, color, oppCol) {
+ atomicPostProcess(moves, color, oppCols) {
moves.forEach(m => {
if (
this.board[m.end.x][m.end.y] != "" &&
- this.getColor(m.end.x, m.end.y) == oppCol
+ oppCols.includes(this.getColor(m.end.x, m.end.y))
) {
// Explosion!
let steps = [
vanish: []
});
for (let step of steps) {
- let x = m.end.x + step[0];
- let y = this.getY(m.end.y + step[1]);
+ let [x, y] = this.increment([m.end.x, m.end.y], step);
if (
this.onBoard(x, y) &&
this.board[x][y] != "" &&
m.next = mNext;
}
});
+ return moves;
}
- pawnPostProcess(moves, color, oppCol) {
+ pawnPostProcess(moves, color, oppCols) {
let moreMoves = [];
const lastRank = (color == "w" ? 0 : this.size.x - 1);
const initPiece = this.getPiece(moves[0].start.x, moves[0].start.y);
m.appear.shift();
return;
}
- let finalPieces = ["p"];
+ let finalPieces;
if (
this.options["cannibal"] &&
this.board[x2][y2] != "" &&
- this.getColor(x2, y2) == oppCol
+ oppCols.includes(this.getColor(x2, y2))
) {
finalPieces = [this.getPieceType(x2, y2)];
}
if (initPiece == "!") //cannibal king-pawn
m.appear[0].p = C.CannibalKingCode[finalPieces[0]];
for (let i=1; i<finalPieces.length; i++) {
+ let newMove = JSON.parse(JSON.stringify(m));
const piece = finalPieces[i];
- const tr = {
- c: color,
- p: (initPiece != "!" ? piece : C.CannibalKingCode[piece])
- };
- let newMove = this.getBasicMove([x1, y1], [x2, y2], tr);
+ m.appear[0].p = (initPiece != "!" ? piece : C.CannibalKingCode[piece]);
moreMoves.push(newMove);
}
});
- Array.prototype.push.apply(moves, moreMoves);
+ return moves.concat(moreMoves);
}
riflePromotePostProcess(moves, color) {
m.appear[0].p = this.pawnPromotions[0];
for (let i=1; i<this.pawnPromotions.length; i++) {
let newMv = JSON.parse(JSON.stringify(m));
- newMv.appear[0].p = this.pawnSpecs.promotions[i];
+ newMv.appear[0].p = this.pawnPromotions[i];
newMoves.push(newMv);
}
}
});
- Array.prototype.push.apply(moves, newMoves);
+ return moves.concat(newMoves);
}
// Generic method to find possible moves of "sliding or jumping" pieces
[x, y],
{
attackOnly: true,
- segments: this.options["cylinder"],
stepSpec: stepSpec
},
([i1, j1], [i2, j2]) => {
[x, y],
{
moveOnly: !!stepSpec.attack || this.options["zen"],
- segments: this.options["cylinder"],
stepSpec: stepSpec
}
);
!this.isKing(i1, j1) && this.canTake([i2, j2], [i1, j1])
);
// Technical step: segments (if any) are reversed
- if (this.options["cylinder"]) {
- zenCaptures.forEach(z => {
+ zenCaptures.forEach(z => {
+ if (!!z.segments)
z.segments = z.segments.reverse().map(s => s.reverse())
- });
- }
+ });
Array.prototype.push.apply(squares, zenCaptures);
}
- if (
- this.options["recycle"] ||
- (this.options["teleport"] && this.subTurnTeleport == 1)
- ) {
+ if (this.hasSelfCaptures) {
const selfCaptures = this.findDestSquares(
[x, y],
{
attackOnly: true,
- segments: this.options["cylinder"],
stepSpec: stepSpec
},
- ([i1, j1], [i2, j2]) =>
- this.getColor(i2, j2) == color && !this.isKing(i2, j2)
+ ([i1, j1], [i2, j2]) => {
+ return (
+ this.getColor(i2, j2) == color &&
+ this.canSelfTake([i1, j1], [i2, j2])
+ );
+ }
);
Array.prototype.push.apply(squares, selfCaptures);
}
return squares.map(s => {
let mv = this.getBasicMove([x, y], s.sq);
- if (this.options["cylinder"] && s.segments.length >= 2)
+ if (!!s.segments)
mv.segments = s.segments;
return mv;
});
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)
+ // Next 3 for Cylinder mode or circular (useless otherwise)
let explored = {};
let segments = [];
let segStart = [];
const addSquare = ([i, j]) => {
let elt = {sq: [i, j]};
- if (o.segments)
- elt.segments = this.getSegments(segments, segStart, end);
+ if (segments.length >= 1)
+ elt.segments = this.getSegments(segments, segStart, [i, j]);
res.push(elt);
};
- const exploreSteps = (stepArray) => {
+ const exploreSteps = (stepArray, mode) => {
for (let s of stepArray) {
outerLoop: for (let step of s.steps) {
- if (o.segments) {
- segments = [];
- segStart = [x, y];
- }
+ segments = [];
+ segStart = [x, y];
let [i, j] = [x, y];
let stepCounter = 0;
while (
!o.captureTarget ||
(o.captureTarget[0] == i && o.captureTarget[1] == j)
) {
- if (o.one && !o.attackOnly)
+ if (o.one && mode != "attack")
return true;
- if (!o.attackOnly)
+ if (mode != "attack")
addSquare(!o.captureTarget ? [i, j] : [x, y]);
if (o.captureTarget)
return res[0];
if (s.range <= stepCounter++)
continue outerLoop;
const oldIJ = [i, j];
- i += step[0];
- j = this.getY(j + step[1]);
- if (o.segments && Math.abs(j - oldIJ[1]) > 1) {
- // Boundary between segments (cylinder mode)
+ [i, j] = this.increment([i, j], step);
+ 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];
}
if (!explored[i + "." + j]) {
explored[i + "." + j] = true;
if (allowed([x, y], [i, j])) {
- if (o.one && !o.moveOnly)
+ if (o.one && mode != "moves")
return true;
- if (!o.moveOnly)
+ if (mode != "moves")
addSquare(!o.captureTarget ? [i, j] : [x, y]);
if (
o.captureTarget &&
return undefined; //default, but let's explicit it
};
if (o.captureTarget)
- return exploreSteps(o.captureSteps)
+ return exploreSteps(o.captureSteps, "attack");
else {
const stepSpec =
o.stepSpec || this.getStepSpec(this.getColor(x, y), x, y);
let outOne = false;
- if (!o.attackOnly || !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);
- }
+ if (!o.attackOnly)
+ outOne = exploreSteps(stepSpec.both.concat(stepSpec.moves), "moves");
+ if (!outOne && !o.moveOnly)
+ outOne = exploreSteps(stepSpec.both.concat(stepSpec.attack), "attack");
return (o.one ? outOne : res);
}
}
// Search for enemy (or not) pieces attacking [x, y]
findCapturesOn([x, y], o, allowed) {
if (!o.byCol)
- o.byCol = [C.GetOppCol(this.getColor(x, y) || this.turn)];
+ o.byCol = this.getOppCols(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++) {
if (this.canStepOver(x, y, apparentPiece))
continue;
const stepSpec = this.getStepSpec(colIJ, i, j);
- const attacks = stepSpec.attack || stepSpec.moves;
+ const attacks = stepSpec.attack.concat(stepSpec.both);
for (let a of attacks) {
for (let s of a.steps) {
// Quick check: if step isn't compatible, don't even try
{
captureTarget: [x, y],
captureSteps: [{steps: [s], range: a.range}],
- segments: o.segments,
- attackOnly: true,
- one: false //one and captureTarget are mutually exclusive
},
allowed
);
getEnpassantCaptures([x, y]) {
const color = this.getColor(x, y);
const shiftX = (color == 'w' ? -1 : 1);
- const oppCol = C.GetOppCol(color);
+ const oppCols = this.getOppCols(color);
if (
this.epSquare &&
- this.epSquare.x == x + shiftX &&
+ this.epSquare.x == x + shiftX && //NOTE: epSquare.x not on edge
Math.abs(this.getY(this.epSquare.y - y)) == 1 &&
// Doublemove (and Progressive?) guards:
this.board[this.epSquare.x][this.epSquare.y] == "" &&
- this.getColor(x, this.epSquare.y) == oppCol
+ oppCols.includes(this.getColor(x, this.epSquare.y))
) {
const [epx, epy] = [this.epSquare.x, this.epSquare.y];
- this.board[epx][epy] = oppCol + 'p';
+ this.board[epx][epy] = this.board[x][this.epSquare.y];
let enpassantMove = this.getBasicMove([x, y], [epx, epy]);
this.board[epx][epy] = "";
const lastIdx = enpassantMove.vanish.length - 1; //think Rifle
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 oppCol = C.GetOppCol(c);
+ const oppCols = this.getOppCols(c);
let moves = [];
// King, then rook:
finalSquares =
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] == "" ||
// will be executed in filterValid() later.
(
i != finalSquares[castleSide][0] &&
- this.underCheck([x, i], oppCol)
+ this.underCheck([[x, i]], oppCols)
)
||
(
////////////////////
// MOVES VALIDATION
- // Is piece (or square) at given position attacked by "oppCol" ?
- underAttack([x, y], oppCol) {
+ // Is piece (or square) at given position attacked by "oppCol(s)" ?
+ underAttack([x, y], oppCols) {
// 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);
this.findCapturesOn(
[x, y],
{
- byCol: [oppCol],
- segments: this.options["cylinder"],
+ byCol: oppCols,
one: true
}
)
[x, y],
{
attackOnly: true,
- segments: this.options["cylinder"],
one: true
},
- ([i1, j1], [i2, j2]) => this.getColor(i2, j2) == oppCol
+ ([i1, j1], [i2, j2]) => oppCols.includes(this.getColor(i2, j2))
)
)
);
}
- underCheck([x, y], oppCol) {
+ // Argument is (very generally) an array of squares (= arrays)
+ underCheck(square_s, oppCols) {
if (this.options["taking"] || this.options["dark"])
return false;
- return this.underAttack([x, y], oppCol);
+ return square_s.some(sq => this.underAttack(sq, oppCols));
}
- // 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.isKing(i, j))
- return [i, j];
+ res.push([i, j]);
}
}
- return [-1, -1]; //king not found
+ return res;
+ }
+
+ // cb: callback returning a boolean (false if king missing)
+ trackKingWrap(move, kingPos, cb) {
+ if (move.appear.length == 0 && move.vanish.length == 0)
+ return true;
+ const color =
+ (move.vanish.length > 0 ? move.vanish[0].c : move.appear[0].c);
+ let newKingPP = null,
+ sqIdx = 0,
+ res = true; //a priori valid
+ const oldKingPP =
+ move.vanish.find(v => this.isKing(0, 0, v.p) && v.c == color);
+ if (oldKingPP) {
+ // Search king in appear array:
+ newKingPP =
+ move.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; //king vanished
+ }
+ res &&= cb(kingPos);
+ if (oldKingPP && newKingPP)
+ kingPos[sqIdx] = [oldKingPP.x, oldKingPP.y];
+ return res;
}
// 'color' arg because some variants (e.g. Refusal) check opponent moves
filterValid(moves, color) {
if (!color)
color = this.turn;
- const oppCol = C.GetOppCol(color);
- const kingPos = this.searchKingPos(color);
- let filtered = {}; //avoid re-checking similar moves (promotions...)
+ const oppCols = this.getOppCols(color);
+ let kingPos = this.searchKingPos(color);
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,
- res = true; //a priori valid
- 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 => this.isKing(0, 0, a.p) && a.c == color);
- if (newKingIdx >= 0)
- square = [m.appear[newKingIdx].x, m.appear[newKingIdx].y];
- else
- res = false;
- }
- res &&= !this.underCheck(square, oppCol);
- this.undoOnBoard(m);
- filtered[key] = res;
- return res;
- }
- return filtered[key];
+ this.playOnBoard(m);
+ const res = this.trackKingWrap(m, kingPos, (kp) => {
+ return !this.underCheck(kp, oppCols);
+ });
+ this.undoOnBoard(m);
+ return res;
});
}
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.ispawn[square])
- delete this.ispawn[square];
- });
if (move.appear.length > 0 && move.vanish.length > 0) {
// Assumption: something is moving
const initSquare = C.CoordsToSquare(move.start);
delete this.ispawn[destSquare];
}
}
+ move.vanish.forEach(v => {
+ const square = C.CoordsToSquare({x: v.x, y: v.y});
+ if (this.ispawn[square])
+ delete this.ispawn[square];
+ });
}
const minSize = Math.min(move.appear.length, move.vanish.length);
if (
}
postPlay(move) {
- const color = this.turn;
if (this.options["dark"])
this.updateEnlightened();
if (this.options["teleport"]) {
if (
this.subTurnTeleport == 1 &&
- move.vanish.length > move.appear.length &&
- move.vanish[1].c == color
+ 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;
this.subTurnTeleport = 1;
this.captured = null;
}
+ this.tryChangeTurn(move);
+ }
+
+ tryChangeTurn(move) {
if (this.isLastMove(move)) {
- this.turn = C.GetOppCol(color);
+ this.turn = C.GetOppTurn(this.turn);
this.movesCount++;
this.subTurn = 1;
}
if (move.next)
return false;
const color = this.turn;
- const oppKingPos = this.searchKingPos(C.GetOppCol(color));
- if (oppKingPos[0] < 0 || this.underCheck(oppKingPos, color))
+ const oppKingPos = this.searchKingPos(C.GetOppTurn(color));
+ if (oppKingPos.length == 0 || this.underCheck(oppKingPos, [color]))
return true;
return (
(
if (this.board[i][j] != "" && this.getColor(i, j) == color) {
// NOTE: in fact searching for all potential moves from i,j.
// I don't believe this is an issue, for now at least.
- const moves = this.getPotentialMovesFrom([i, j]);
+ const moves = this.getPotentialMovesFrom([i, j], color);
if (moves.some(m => this.filterValid([m]).length >= 1))
return true;
}
}
// What is the score ? (Interesting if game is over)
- 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)
+ getCurrentScore(move_s) {
+ const move = move_s[move_s.length - 1];
+ // Shortcut in case the score was computed before:
+ if (move.result)
+ return move.result;
+ const oppTurn = C.GetOppTurn(this.turn);
+ const kingPos = {
+ w: this.searchKingPos('w'),
+ b: this.searchKingPos('b')
+ };
+ if (kingPos[this.turn].length == 0 && kingPos[oppTurn].length == 0)
return "1/2";
- if (kingPos[0][0] < 0)
- return (color == "w" ? "0-1" : "1-0");
- if (kingPos[1][0] < 0)
- return (color == "w" ? "1-0" : "0-1");
- if (this.atLeastOneMove(color))
+ if (kingPos[this.turn].length == 0)
+ return (this.turn == "w" ? "0-1" : "1-0");
+ if (kingPos[oppTurn].length == 0)
+ return (this.turn == "w" ? "1-0" : "0-1");
+ if (this.atLeastOneMove(this.turn))
return "*";
// No valid move: stalemate or checkmate?
- if (!this.underCheck(kingPos[0], oppCol))
+ if (!this.underCheck(kingPos[this.turn], this.getOppCols(this.turn)))
return "1/2";
// OK, checkmate
- return (color == "w" ? "0-1" : "1-0");
+ return (this.turn == "w" ? "0-1" : "1-0");
}
playVisual(move, r) {
move.vanish.forEach(v => {
- this.g_pieces[v.x][v.y].remove();
+ if (this.g_pieces[v.x][v.y]) //can be null (e.g. Apocalypse)
+ this.g_pieces[v.x][v.y].remove();
this.g_pieces[v.x][v.y] = null;
});
let chessboard =
this.g_pieces[a.x][a.y] = document.createElement("piece");
C.AddClass_es(this.g_pieces[a.x][a.y],
this.pieces(a.c, a.x, a.y)[a.p]["class"]);
- this.g_pieces[a.x][a.y].classList.add(C.GetColorClass(a.c));
+ this.g_pieces[a.x][a.y].classList.add(V.GetColorClass(a.c));
this.g_pieces[a.x][a.y].style.width = pieceWidth + "px";
this.g_pieces[a.x][a.y].style.height = pieceWidth + "px";
const [ip, jp] = this.getPixelPosition(a.x, a.y, r);
buildMoveStack(move, r) {
this.moveStack.push(move);
this.computeNextMove(move);
- this.play(move);
- const newTurn = this.turn;
- if (this.moveStack.length == 1)
- this.playVisual(move, r);
- if (move.next) {
- this.gameState = {
- fen: this.getFen(),
- board: JSON.parse(JSON.stringify(this.board)) //easier
- };
- this.buildMoveStack(move.next, r);
- }
- else {
- if (this.moveStack.length == 1) {
- // Usual case (one normal move)
- this.afterPlay(this.moveStack, newTurn, {send: true, res: true});
- this.moveStack = []
+ const then = () => {
+ const newTurn = this.turn;
+ if (this.moveStack.length == 1 && !this.hideMoves)
+ this.playVisual(move, r);
+ if (move.next) {
+ this.gameState = {
+ fen: this.getFen(),
+ board: JSON.parse(JSON.stringify(this.board)) //easier
+ };
+ this.buildMoveStack(move.next, r);
}
else {
- this.afterPlay(this.moveStack, newTurn, {send: true, res: false});
- this.re_initFromFen(this.gameState.fen, this.gameState.board);
- this.playReceivedMove(this.moveStack.slice(1), () => {
- this.afterPlay(this.moveStack, newTurn, {send: false, res: true});
- this.moveStack = []
- });
+ if (this.moveStack.length == 1) {
+ // Usual case (one normal move)
+ this.afterPlay(this.moveStack, newTurn, {send: true, res: true});
+ this.moveStack = [];
+ }
+ else {
+ this.afterPlay(this.moveStack, newTurn, {send: true, res: false});
+ this.re_initFromFen(this.gameState.fen, this.gameState.board);
+ this.playReceivedMove(this.moveStack.slice(1), () => {
+ this.afterPlay(this.moveStack, newTurn, {send: false, res: true});
+ this.moveStack = [];
+ });
+ }
}
- }
+ };
+ // If hiding moves, then they are revealed in play() with callback
+ this.play(move, this.hideMoves ? then : null);
+ if (!this.hideMoves)
+ then();
}
// Implemented in variants using (automatic) moveStack
animateMoving(start, end, drag, segments, cb) {
let initPiece = this.getDomPiece(start.x, start.y);
+ if (!initPiece) { //TODO: shouldn't occur!
+ cb();
+ return;
+ }
// NOTE: cloning often not required, but light enough, and simpler
let movingPiece = initPiece.cloneNode();
initPiece.style.opacity = "0";
C.RemoveClass_es(movingPiece, pieces[startCode]["class"]);
C.AddClass_es(movingPiece, pieces[drag.p]["class"]);
if (apparentColor != drag.c) {
- movingPiece.classList.remove(C.GetColorClass(apparentColor));
- movingPiece.classList.add(C.GetColorClass(drag.c));
+ movingPiece.classList.remove(V.GetColorClass(apparentColor));
+ movingPiece.classList.add(V.GetColorClass(drag.c));
}
}
container.appendChild(movingPiece);
this.animateFading(arr, () => targetObj.increment());
}
}
+ targetObj.target +=
+ this.tryAnimateCastle(move, () => targetObj.increment());
targetObj.target +=
this.customAnimate(move, segments, () => targetObj.increment());
if (targetObj.target == 0)
callback();
}
+ tryAnimateCastle(move, cb) {
+ if (
+ this.hasCastle &&
+ move.vanish.length == 2 &&
+ move.appear.length == 2 &&
+ this.isKing(0, 0, move.vanish[0].p) &&
+ this.isKing(0, 0, move.appear[0].p)
+ ) {
+ const start = {x: move.vanish[1].x, y: move.vanish[1].y},
+ end = {x: move.appear[1].x, y: move.appear[1].y};
+ const segments = [ [[start.x, start.y], [end.x, end.y]] ];
+ this.animateMoving(start, end, null, segments, cb);
+ return 1;
+ }
+ return 0;
+ }
+
// Potential other animations (e.g. for Suction variant)
customAnimate(move, segments, cb) {
return 0; //nb of targets
}
- playReceivedMove(moves, callback) {
- const launchAnimation = () => {
- const r = container.querySelector(".chessboard").getBoundingClientRect();
- const animateRec = i => {
- this.animate(moves[i], () => {
- this.play(moves[i]);
- this.playVisual(moves[i], r);
- if (i < moves.length - 1)
- setTimeout(() => animateRec(i+1), 300);
- else
- callback();
- });
- };
- animateRec(0);
+ launchAnimation(moves, container, callback) {
+ if (this.hideMoves) {
+ for (let i=0; i<moves.length; i++)
+ // If hiding moves, they are revealed into play():
+ this.play(moves[i], i == moves.length - 1 ? callback : () => {});
+ return;
+ }
+ const r = container.querySelector(".chessboard").getBoundingClientRect();
+ const animateRec = i => {
+ this.animate(moves[i], () => {
+ this.play(moves[i]);
+ this.playVisual(moves[i], r);
+ if (i < moves.length - 1)
+ setTimeout(() => animateRec(i+1), 300);
+ else
+ callback();
+ });
};
+ animateRec(0);
+ }
+
+ playReceivedMove(moves, callback) {
// Delay if user wasn't focused:
const checkDisplayThenAnimate = (delay) => {
if (container.style.display == "none") {
alert("New move! Let's go back to game...");
document.getElementById("gameInfos").style.display = "none";
container.style.display = "block";
- setTimeout(launchAnimation, 700);
+ setTimeout(
+ () => this.launchAnimation(moves, container, callback),
+ 700
+ );
+ }
+ else {
+ setTimeout(
+ () => this.launchAnimation(moves, container, callback),
+ delay || 0
+ );
}
- else
- setTimeout(launchAnimation, delay || 0);
};
let container = document.getElementById(this.containerId);
if (document.hidden) {
document.onvisibilitychange = () => {
+ // TODO here: page reload ?! (some issues if tab changed...)
document.onvisibilitychange = undefined;
checkDisplayThenAnimate(700);
};
projects / xogo.git / blobdiff