X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=base_rules.js;h=ce0de11244674b7cbfcac38bbf3f40b1ee677752;hb=af9c9be34f416500f9e025e28f39fe89a8c7c345;hp=0d7b703f2de907ad08f7aff0af360f5c4d5d279f;hpb=f77da909dea9da0992a23a92b48d8f08703b4f72;p=xogo.git diff --git a/base_rules.js b/base_rules.js index 0d7b703..ce0de11 100644 --- a/base_rules.js +++ b/base_rules.js @@ -3,6 +3,21 @@ import { ArrayFun } from "/utils/array.js"; import PiPo from "/utils/PiPo.js"; import Move from "/utils/Move.js"; +// Helper class for move animation +class TargetObj { + + constructor(callOnComplete) { + this.value = 0; + this.target = 0; + this.callOnComplete = callOnComplete; + } + increment() { + if (++this.value == this.target) + this.callOnComplete(); + } + +}; + // NOTE: x coords: top to bottom (white perspective); y: left to right // NOTE: ChessRules is aliased as window.C, and variants as window.V export default class ChessRules { @@ -29,16 +44,18 @@ export default class ChessRules { {label: "Asymmetric random", value: 2} ] }], - check: [ + input: [ { label: "Capture king", - defaut: false, - variable: "taking" + variable: "taking", + type: "checkbox", + defaut: false }, { label: "Falling pawn", - defaut: false, - variable: "pawnfall" + variable: "pawnfall", + type: "checkbox", + defaut: false } ], // Game modifiers (using "elementary variants"). Default: false @@ -85,6 +102,10 @@ export default class ChessRules { (!!this.options["recycle"] && !this.options["teleport"]) ); } + // Some variants do not store reserve state (Align4, Chakart...) + get hasReserveFen() { + return this.hasReserve; + } get noAnimate() { return !!this.options["dark"]; @@ -173,8 +194,6 @@ export default class ChessRules { // Setup the initial random-or-not (asymmetric-or-not) position genRandInitFen(seed) { - Random.setSeed(seed); - let fen, flags = "0707"; if (!this.options.randomness) // Deterministic: @@ -182,7 +201,8 @@ export default class ChessRules { else { // Randomize - let pieces = { w: new Array(8), b: new Array(8) }; + 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"]) { @@ -247,7 +267,7 @@ export default class ChessRules { parts.push(`"flags":"${flags}"`); if (this.hasEnpassant) parts.push('"enpassant":"-"'); - if (this.hasReserve) + if (this.hasReserveFen) parts.push('"reserve":"000000000000"'); if (this.options["crazyhouse"]) parts.push('"ispawn":"-"'); @@ -281,7 +301,7 @@ export default class ChessRules { parts.push(`"flags":"${this.getFlagsFen()}"`); if (this.hasEnpassant) parts.push(`"enpassant":"${this.getEnpassantFen()}"`); - if (this.hasReserve) + if (this.hasReserveFen) parts.push(`"reserve":"${this.getReserveFen()}"`); if (this.options["crazyhouse"]) parts.push(`"ispawn":"${this.getIspawnFen()}"`); @@ -377,23 +397,30 @@ export default class ChessRules { 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; this.playerColor = o.color; this.afterPlay = o.afterPlay; //trigger some actions after playing a move // Fen string fully describes the game state if (!o.fen) o.fen = this.genRandInitFen(o.seed); - const fenParsed = this.parseFen(o.fen); - this.board = this.getBoard(fenParsed.position); - this.turn = fenParsed.turn; - this.movesCount = parseInt(fenParsed.movesCount, 10); - this.setOtherVariables(fenParsed); + this.re_initFromFen(o.fen); // Graphical (can use variables defined above) this.containerId = o.element; this.graphicalInit(); } + re_initFromFen(fen, oldBoard) { + const fenParsed = this.parseFen(fen); + this.board = oldBoard || this.getBoard(fenParsed.position); + this.turn = fenParsed.turn; + this.movesCount = parseInt(fenParsed.movesCount, 10); + this.setOtherVariables(fenParsed); + } + // Turn position fen into double array ["wb","wp","bk",...] getBoard(position) { const rows = position.split("/"); @@ -425,7 +452,6 @@ export default class ChessRules { this.initReserves(fenParsed.reserve); if (this.options["crazyhouse"]) this.initIspawn(fenParsed.ispawn); - this.subTurn = 1; //may be unused if (this.options["teleport"]) { this.subTurnTeleport = 1; this.captured = null; @@ -435,6 +461,9 @@ export default class ChessRules { this.enlightened = ArrayFun.init(this.size.x, this.size.y, false); this.updateEnlightened(); } + this.subTurn = 1; //may be unused + if (!this.moveStack) //avoid resetting (unwanted) + this.moveStack = []; } updateEnlightened() { @@ -526,6 +555,22 @@ export default class ChessRules { return `${this.containerId}|rnum-${color}${piece}`; } + static AddClass_es(piece, class_es) { + if (!Array.isArray(class_es)) + class_es = [class_es]; + class_es.forEach(cl => { + piece.classList.add(cl); + }); + } + + static RemoveClass_es(piece, class_es) { + if (!Array.isArray(class_es)) + class_es = [class_es]; + class_es.forEach(cl => { + piece.classList.remove(cl); + }); + } + graphicalInit() { // NOTE: not window.onresize = this.re_drawBoardElts because scope (this) window.onresize = () => this.re_drawBoardElements(); @@ -545,15 +590,16 @@ export default class ChessRules { // Compare window ratio width / height to aspectRatio: const windowRatio = window.innerWidth / window.innerHeight; let cbWidth, cbHeight; - if (windowRatio <= this.size.ratio) { + const vRatio = this.size.ratio || 1; + if (windowRatio <= vRatio) { // Limiting dimension is width: cbWidth = Math.min(window.innerWidth, 767); - cbHeight = cbWidth / this.size.ratio; + cbHeight = cbWidth / vRatio; } else { // Limiting dimension is height: cbHeight = Math.min(window.innerHeight, 767); - cbWidth = cbHeight * this.size.ratio; + cbWidth = cbHeight * vRatio; } if (this.hasReserve) { const sqSize = cbWidth / this.size.y; @@ -561,7 +607,7 @@ export default class ChessRules { // Cannot use getReserveSquareSize() here, but sqSize is an upper bound. if ((window.innerHeight - cbHeight) / 2 < sqSize + 5) { cbHeight = window.innerHeight - 2 * (sqSize + 5); - cbWidth = cbHeight * this.size.ratio; + cbWidth = cbHeight * vRatio; } } chessboard.style.width = cbWidth + "px"; @@ -586,7 +632,7 @@ export default class ChessRules { const flipped = (this.playerColor == 'b'); let board = ` `; for (let i=0; i < this.size.x; i++) { for (let j=0; j < this.size.y; j++) { @@ -641,7 +687,8 @@ export default class ChessRules { const color = this.getColor(i, j); const piece = this.getPiece(i, j); this.g_pieces[i][j] = document.createElement("piece"); - this.g_pieces[i][j].classList.add(this.pieces()[piece]["class"]); + 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"; @@ -659,24 +706,17 @@ export default class ChessRules { this.re_drawReserve(['w', 'b'], r); } - // NOTE: assume !!this.reserve + // NOTE: assume this.reserve != null re_drawReserve(colors, r) { if (this.r_pieces) { // Remove (old) reserve pieces for (let c of colors) { - if (!this.reserve[c]) - continue; - Object.keys(this.reserve[c]).forEach(p => { - if (this.r_pieces[c][p]) { - this.r_pieces[c][p].remove(); - delete this.r_pieces[c][p]; - const numId = this.getReserveNumId(c, p); - document.getElementById(numId).remove(); - } + Object.keys(this.r_pieces[c]).forEach(p => { + this.r_pieces[c][p].remove(); + delete this.r_pieces[c][p]; + const numId = this.getReserveNumId(c, p); + document.getElementById(numId).remove(); }); - let reservesDiv = document.getElementById("reserves_" + c); - if (reservesDiv) - reservesDiv.remove(); } } else @@ -685,6 +725,9 @@ export default class ChessRules { if (!r) r = container.querySelector(".chessboard").getBoundingClientRect(); for (let c of colors) { + let reservesDiv = document.getElementById("reserves_" + c); + if (reservesDiv) + reservesDiv.remove(); if (!this.reserve[c]) continue; const nbR = this.getNbReservePieces(c); @@ -713,8 +756,7 @@ export default class ChessRules { r_cell.style.height = sqResSize + "px"; rcontainer.appendChild(r_cell); let piece = document.createElement("piece"); - const pieceSpec = this.pieces()[p]; - piece.classList.add(pieceSpec["class"]); + C.AddClass_es(piece, this.pieces(c, c, p)[p]["class"]); piece.classList.add(C.GetColorClass(c)); piece.style.width = "100%"; piece.style.height = "100%"; @@ -779,13 +821,14 @@ export default class ChessRules { 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; - newHeight = newWidth / this.size.ratio; + newHeight = newWidth / vRatio; } if (newHeight > window.innerHeight) { newHeight = window.innerHeight; - newWidth = newHeight * this.size.ratio; + newWidth = newHeight * vRatio; } chessboard.style.width = newWidth + "px"; chessboard.style.height = newHeight + "px"; @@ -908,7 +951,7 @@ export default class ChessRules { if (cd) { const move = this.doClick(cd); if (move) - this.playPlusVisual(move); + this.buildMoveStack(move, r); else { const [x, y] = Object.values(cd); if (typeof x != "number") @@ -943,11 +986,6 @@ export default class ChessRules { }; const mouseup = (e) => { - const newR = chessboard.getBoundingClientRect(); - if (newR.width != r.width || newR.height != r.height) { - this.rescale(); - return; - } if (!start) return; const [x, y] = [start.x, start.y]; @@ -967,20 +1005,17 @@ export default class ChessRules { if (moves.length >= 2) this.showChoices(moves, r); else if (moves.length == 1) - this.playPlusVisual(moves[0], r); + this.buildMoveStack(moves[0], r); } curPiece.remove(); }; - const wheelResize = (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", wheelResize); + document.addEventListener("wheel", + (e) => this.rescale(e.deltaY < 0 ? "up" : "down")); } if ('ontouchstart' in window) { // https://stackoverflow.com/a/42509310/12660887 @@ -996,6 +1031,8 @@ export default class ChessRules { let chessboard = container.querySelector(".chessboard"); let choices = document.createElement("div"); choices.id = "choices"; + if (!r) + r = chessboard.getBoundingClientRect(); choices.style.width = r.width + "px"; choices.style.height = r.height + "px"; choices.style.left = r.x + "px"; @@ -1009,7 +1046,7 @@ export default class ChessRules { const callback = (m) => { chessboard.style.opacity = "1"; container.removeChild(choices); - this.playPlusVisual(m, r); + this.buildMoveStack(m, r); } for (let i=0; i < moves.length; i++) { let choice = document.createElement("div"); @@ -1021,8 +1058,9 @@ export default class ChessRules { choice.style.backgroundColor = "lightyellow"; choice.onclick = () => callback(moves[i]); const piece = document.createElement("piece"); - const pieceSpec = this.pieces()[moves[i].appear[0].p]; - piece.classList.add(pieceSpec["class"]); + 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.style.width = "100%"; piece.style.height = "100%"; @@ -1038,7 +1076,7 @@ export default class ChessRules { return { x: 8, y: 8, - ratio: 1 //for rectangular board = y / x + ratio: 1 //for rectangular board = y / x (optional, 1 = default) }; } @@ -1050,7 +1088,11 @@ export default class ChessRules { } static GetColorClass(c) { - return (c == 'w' ? "white" : "black"); + if (c == 'w') + return "white"; + if (c == 'b') + return "black"; + return "other-color"; //unidentified color } // Assume square i,j isn't empty @@ -1061,8 +1103,9 @@ export default class ChessRules { } // Piece type on square (i,j) - getPieceType(i, j) { - const p = this.getPiece(i, j); + getPieceType(i, j, p) { + if (!p) + p = this.getPiece(i, j); return C.CannibalKings[p] || p; //a cannibal king move as... } @@ -1071,11 +1114,6 @@ export default class ChessRules { return (color == "w" ? "b" : "w"); } - // Can thing on square1 capture (no return) thing on square2? - canTake([x1, y1], [x2, y2]) { - return (this.getColor(x1, y1) !== this.getColor(x2, y2)); - } - // Is (x,y) on the chessboard? onBoard(x, y) { return (x >= 0 && x < this.size.x && @@ -1171,8 +1209,31 @@ export default class ChessRules { }; } - //////////////////// - // MOVES GENERATION + // NOTE: using special symbols to not interfere with variants' pieces codes + static get CannibalKings() { + return { + "!": "p", + "#": "r", + "$": "n", + "%": "b", + "*": "q", + "k": "k" + }; + } + + static get CannibalKingCode() { + return { + "p": "!", + "r": "#", + "n": "$", + "b": "%", + "q": "*", + "k": "k" + }; + } + + ////////////////////////// + // MOVES GENERATION UTILS // For Cylinder: get Y coordinate getY(y) { @@ -1184,36 +1245,65 @@ export default class ChessRules { return res; } + // Can thing on square1 capture thing on square2? + canTake([x1, y1], [x2, y2]) { + return this.getColor(x1, y1) !== this.getColor(x2, y2); + } + + canStepOver(i, j, p) { + // In some variants, objects on boards don't stop movement (Chakart) + return this.board[i][j] == ""; + } + + // For Madrasi: + // (redefined in Baroque etc, where Madrasi condition doesn't make sense) + isImmobilized([x, y]) { + if (!this.options["madrasi"]) + 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 attacks = stepSpec.attack || stepSpec.moves; + for (let a of attacks) { + outerLoop: for (let step of a.steps) { + let [i, j] = [x + step[0], y + step[1]]; + let stepCounter = 1; + while (this.onBoard(i, j) && this.board[i][j] == "") { + if (a.range <= stepCounter++) + continue outerLoop; + i += step[0]; + j = this.getY(j + step[1]); + } + if ( + this.onBoard(i, j) && + this.getColor(i, j) == oppCol && + this.getPieceType(i, j) == piece + ) { + return true; + } + } + } + return false; + } + // Stop at the first capture found atLeastOneCapture(color) { - color = color || this.turn; const oppCol = C.GetOppCol(color); - 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) { - const allSpecs = this.pieces(color, i, j) - let specs = allSpecs[this.getPieceType(i, j)]; - const attacks = specs.attack || specs.moves; - for (let a of attacks) { - outerLoop: for (let step of a.steps) { - let [ii, jj] = [i + step[0], this.getY(j + step[1])]; - let stepCounter = 1; - while (this.onBoard(ii, jj) && this.board[ii][jj] == "") { - if (a.range <= stepCounter++) - continue outerLoop; - ii += step[0]; - jj = this.getY(jj + step[1]); - } - if ( - this.onBoard(ii, jj) && - this.getColor(ii, jj) == oppCol && - this.filterValid( - [this.getBasicMove([i, j], [ii, jj])] - ).length >= 1 - ) { - return true; - } - } + const allowed = ([x, y]) => { + this.getColor(x, y) == oppCol && + this.filterValid([this.getBasicMove([i, j], [x, y])]).length >= 1 + }; + for (let i=0; i 1e-7) + continue; + distance = Math.round(distance); //in case of (numerical...) + if (range >= distance) + return true; + } + return false; + } + + //////////////////// + // MOVES GENERATION + getDropMovesFrom([c, p]) { // NOTE: by design, this.reserve[c][p] >= 1 on user click // (but not necessarily otherwise: atLeastOneMove() etc) @@ -1289,7 +1422,7 @@ export default class ChessRules { moves = this.capturePostProcess(moves, oppCol); if (this.options["atomic"]) - this.atomicPostProcess(moves, oppCol); + this.atomicPostProcess(moves, color, oppCol); if ( moves.length > 0 && @@ -1320,7 +1453,7 @@ export default class ChessRules { }); } - atomicPostProcess(moves, oppCol) { + atomicPostProcess(moves, color, oppCol) { moves.forEach(m => { if ( this.board[m.end.x][m.end.y] != "" && @@ -1337,15 +1470,22 @@ export default class ChessRules { [1, 0], [1, 1] ]; + let mNext = new Move({ + start: m.end, + end: m.end, + appear: [], + vanish: [] + }); for (let step of steps) { let x = m.end.x + step[0]; let y = this.getY(m.end.y + step[1]); if ( this.onBoard(x, y) && this.board[x][y] != "" && + (x != m.start.x || y != m.start.y) && this.getPieceType(x, y) != "p" ) { - m.vanish.push( + mNext.vanish.push( new PiPo({ p: this.getPiece(x, y), c: this.getColor(x, y), @@ -1355,8 +1495,18 @@ export default class ChessRules { ); } } - if (!this.options["rifle"]) - m.appear.pop(); //nothing appears + if (!this.options["rifle"]) { + // The moving piece also vanish + mNext.vanish.unshift( + new PiPo({ + x: m.end.x, + y: m.end.y, + c: color, + p: this.getPiece(m.start.x, m.start.y) + }) + ); + } + m.next = mNext; } }); } @@ -1426,109 +1576,125 @@ export default class ChessRules { Array.prototype.push.apply(moves, newMoves); } - // NOTE: using special symbols to not interfere with variants' pieces codes - static get CannibalKings() { - return { - "!": "p", - "#": "r", - "$": "n", - "%": "b", - "*": "q", - "k": "k" - }; - } - - static get CannibalKingCode() { - return { - "p": "!", - "r": "#", - "n": "$", - "b": "%", - "q": "*", - "k": "k" - }; - } - - isKing(symbol) { - return !!C.CannibalKings[symbol]; - } - - // For Madrasi: - // (redefined in Baroque etc, where Madrasi condition doesn't make sense) - isImmobilized([x, y]) { - if (!this.options["madrasi"]) - return false; + // Generic method to find possible moves of "sliding or jumping" pieces + getPotentialMovesOf(piece, [x, y], color) { const color = this.getColor(x, y); - const oppCol = C.GetOppCol(color); - const piece = this.getPieceType(x, y); //ok not cannibal king - const stepSpec = this.pieces(color, x, y)[piece]; - const attacks = stepSpec.attack || stepSpec.moves; - for (let a of attacks) { - outerLoop: for (let step of a.steps) { - let [i, j] = [x + step[0], y + step[1]]; - let stepCounter = 1; - while (this.onBoard(i, j) && this.board[i][j] == "") { - if (a.range <= stepCounter++) - continue outerLoop; - i += step[0]; - j = this.getY(j + step[1]); - } - if ( - this.onBoard(i, j) && - this.getColor(i, j) == oppCol && - this.getPieceType(i, j) == piece - ) { - return true; + const specialAttack = !!this.getStepSpec(color, x, y).attack; + let squares = []; + if (specialAttack) { + squares = this.findDestSquares( + [x, y], + { + attackOnly: true, + segments: this.options["cylinder"] + }, + ([i, j]) => { + return ( + (!this.options["zen"] || this.getPieceType(i, j) == 'k') && + this.canTake([x, y], [i, j]) + ); } + ); + } + 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]) + ); + Array.prototype.push.apply(squares, noSpecials); + if (this.options["zen"]) { + let zenCaptures = this.findCapturesOn( + [x, y], + {}, + ([i, j]) => this.getPieceType(i, j) != 'k' + ); + // 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()) + }); } + Array.prototype.push.apply(squares, zenCaptures); } - return false; + if ( + this.options["recycle"] || + (this.options["teleport"] && this.subTurnTeleport == 1) + ) { + const selfCaptures = this.findDestSquares( + [x, y], + { + attackOnly: true, + segments: this.options["cylinder"] + }, + ([i, j]) => + this.getColor(i, j) == color && this.getPieceType(i, j) != 'k' + ); + 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) + mv.segments = s.segments; + return mv; + }); } - // Generic method to find possible moves of "sliding or jumping" pieces - getPotentialMovesOf(piece, [x, y]) { - const color = this.getColor(x, y); - const stepSpec = this.pieces(color, x, y)[piece]; - let moves = []; - // Next 3 for Cylinder mode: + findDestSquares([x, y], o, allowed) { + if (!allowed) + allowed = () => true; + const apparentPiece = this.getPiece(x, y); //how it looks + let res = []; + // Next 3 for Cylinder mode: (unused if !o.segments) let explored = {}; let segments = []; let segStart = []; - - const addMove = (start, end) => { - let newMove = this.getBasicMove(start, end); - if (segments.length > 0) { - newMove.segments = JSON.parse(JSON.stringify(segments)); - newMove.segments.push([[segStart[0], segStart[1]], [end[0], end[1]]]); - } - moves.push(newMove); + const addSquare = ([i, j]) => { + let elt = {sq: [i, j]}; + if (o.segments) + elt.segments = this.getSegments(segments, segStart, end); + res.push(elt); }; - - const findAddMoves = (type, stepArray) => { + const exploreSteps = (stepArray) => { for (let s of stepArray) { outerLoop: for (let step of s.steps) { - segments = []; - segStart = [x, y]; + if (o.segments) { + segments = []; + segStart = [x, y]; + } let [i, j] = [x, y]; let stepCounter = 0; while ( this.onBoard(i, j) && - (this.board[i][j] == "" || (i == x && j == y)) + ((i == x && j == y) || this.canStepOver(i, j, apparentPiece)) ) { - if ( - type != "attack" && - !explored[i + "." + j] && - (i != x || j != y) - ) { + if (!explored[i + "." + j] && (i != x || j != y)) + { explored[i + "." + j] = true; - addMove([x, y], [i, j]); + if ( + allowed([i, j]) && + ( + !o.captureTarget || + (o.captureTarget[0] == i && o.captureTarget[1] == j) + ) + ) { + if (o.one && !o.attackOnly) + return true; + if (!o.attackOnly) + 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 (Math.abs(j - oldIJ[1]) > 1) { + if (o.segments && Math.abs(j - oldIJ[1]) > 1) { // Boundary between segments (cylinder mode) segments.push([[segStart[0], segStart[1]], oldIJ]); segStart = [i, j]; @@ -1537,106 +1703,84 @@ export default class ChessRules { if (!this.onBoard(i, j)) continue; const pieceIJ = this.getPieceType(i, j); - if ( - type != "moveonly" && - !explored[i + "." + j] && - ( - !this.options["zen"] || - pieceIJ == "k" - ) && - ( - this.canTake([x, y], [i, j]) || - ( - (this.options["recycle"] || this.options["teleport"]) && - pieceIJ != "k" - ) - ) - ) { + if (!explored[i + "." + j]) { explored[i + "." + j] = true; - addMove([x, y], [i, j]); + if (allowed([i, j])) { + if (o.one && !o.moveOnly) + return true; + if (!o.moveOnly) + addSquare(!o.captureTarget ? [i, j] : [x, y]); + if ( + o.captureTarget && + o.captureTarget[0] == i && o.captureTarget[1] == j + ) { + return res[0]; + } + } } } } }; - - const specialAttack = !!stepSpec.attack; - if (specialAttack) - findAddMoves("attack", stepSpec.attack); - findAddMoves(specialAttack ? "moveonly" : "all", stepSpec.moves); - if (this.options["zen"]) { - Array.prototype.push.apply(moves, - this.findCapturesOn([x, y], {zen: true})); + if (o.captureTarget) + exploreSteps(o.captureSteps) + else { + const stepSpec = this.getStepSpec(this.getColor(x, y), x, y); + if (!o.attackOnly || !stepSpec.attack) + exploreSteps(stepSpec.moves); + if (!o.moveOnly && !!stepSpec.attack) + exploreSteps(stepSpec.attack); } - return moves; + return o.captureTarget ? null : (o.one ? false : res); } // Search for enemy (or not) pieces attacking [x, y] - findCapturesOn([x, y], args) { - let moves = []; - if (!args.oppCol) - args.oppCol = C.GetOppCol(this.getColor(x, y) || this.turn); + findCapturesOn([x, y], o, allowed) { + if (!allowed) + allowed = () => true; + let res = []; + if (!o.byCol) + o.byCol = [C.GetOppCol(this.getColor(x, y) || this.turn)]; for (let i=0; i this.canTake([ii, jj], [x, y]) + ); + if (newSquare) + if (o.one) + return true; + res.push(newSquare); } } } } } } - return moves; - } - - static CompatibleStep([x1, y1], [x2, y2], step, range) { - const rx = (x2 - x1) / step[0], - ry = (y2 - y1) / step[1]; - if ( - (!Number.isFinite(rx) && !Number.isNaN(rx)) || - (!Number.isFinite(ry) && !Number.isNaN(ry)) - ) { - return false; - } - let distance = (Number.isNaN(rx) ? ry : rx); - // TODO: 1e-7 here is totally arbitrary - if (Math.abs(distance - Math.round(distance)) > 1e-7) - return false; - distance = Math.round(distance); //in case of (numerical...) - if (range < distance) - return false; - return true; + return (one ? false : res); } // Build a regular move from its initial and destination squares. @@ -1685,7 +1829,7 @@ export default class ChessRules { if (this.options["cannibal"] && destColor != initColor) { const lastIdx = mv.vanish.length - 1; let trPiece = mv.vanish[lastIdx].p; - if (this.isKing(this.getPiece(sx, sy))) + if (this.getPieceType(sx, sy) == 'k') trPiece = C.CannibalKingCode[trPiece]; if (mv.appear.length >= 1) mv.appear[0].p = trPiece; @@ -1728,8 +1872,15 @@ export default class ChessRules { s.y == e.y && Math.abs(s.x - e.x) == 2 && // Next conditions for variants like Atomic or Rifle, Recycle... - (move.appear.length > 0 && move.appear[0].p == "p") && - (move.vanish.length > 0 && move.vanish[0].p == "p") + ( + move.appear.length > 0 && + this.getPieceType(0, 0, move.appear[0].p) == "p" + ) + && + ( + move.vanish.length > 0 && + this.getPieceType(0, 0, move.vanish[0].p) == "p" + ) ) { return { x: (s.x + e.x) / 2, @@ -1866,48 +2017,48 @@ export default class ChessRules { //////////////////// // MOVES VALIDATION - // Is (king at) given position under check by "oppCol" ? + // Is piece (or square) at given position attacked by "oppCol" ? + underAttack([x, y], oppCol) { + const king = this.getPieceType(x, y) == 'k'; + 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.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 + ) + ); + } + underCheck([x, y], oppCol) { if (this.options["taking"] || this.options["dark"]) return false; - return ( - this.findCapturesOn([x, y], {oppCol: oppCol, one: true}).length >= 1 - ); + return this.underAttack([x, y], oppCol); } // Stop at first king found (TODO: multi-kings) 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.isKing(this.getPiece(i, j))) + if (this.getColor(i, j) == color && this.getPieceType(i, j) == 'k') return [i, j]; } } return [-1, -1]; //king not found } - filterValid(moves) { - if (moves.length == 0) - return []; - const color = this.turn; + // 'color' arg because some variants (e.g. Refusal) check opponent moves + filterValid(moves, color) { + if (!color) + color = this.turn; const oppCol = C.GetOppCol(color); - if (this.options["balance"] && [1, 3].includes(this.movesCount)) { - // Forbid moves either giving check or exploding opponent's king: - const oppKingPos = this.searchKingPos(oppCol); - moves = moves.filter(m => { - if ( - m.vanish.some(v => v.c == oppCol && v.p == "k") && - m.appear.every(a => a.c != oppCol || a.p != "k") - ) - return false; - this.playOnBoard(m); - const res = !this.underCheck(oppKingPos, color); - this.undoOnBoard(m); - return res; - }); - } - if (this.options["taking"] || this.options["dark"]) - return moves; const kingPos = this.searchKingPos(color); let filtered = {}; //avoid re-checking similar moves (promotions...) return moves.filter(m => { @@ -1917,12 +2068,12 @@ export default class ChessRules { let square = kingPos, res = true; //a priori valid if (m.vanish.some(v => { - return C.CannibalKings[v.p] && v.c == color; + return this.getPieceType(0, 0, v.p) == 'k' && v.c == color; })) { // Search king in appear array: const newKingIdx = m.appear.findIndex(a => { - return C.CannibalKings[a.p] && a.c == color; + return this.getPieceType(0, 0, a.p) == 'k' && a.c == color; }); if (newKingIdx >= 0) square = [m.appear[newKingIdx].x, m.appear[newKingIdx].y]; @@ -2060,14 +2211,13 @@ export default class ChessRules { postPlay(move) { const color = this.turn; - const oppCol = C.GetOppCol(color); if (this.options["dark"]) this.updateEnlightened(); if (this.options["teleport"]) { if ( this.subTurnTeleport == 1 && move.vanish.length > move.appear.length && - move.vanish[move.vanish.length - 1].c == color + move.vanish[1].c == color ) { const v = move.vanish[move.vanish.length - 1]; this.captured = {x: v.x, y: v.y, c: v.c, p: v.p}; @@ -2077,35 +2227,40 @@ export default class ChessRules { this.subTurnTeleport = 1; this.captured = null; } - if (this.options["balance"]) { - if (![1, 3].includes(this.movesCount)) - this.turn = oppCol; - } - else { - if ( - ( - this.options["doublemove"] && - this.movesCount >= 1 && - this.subTurn == 1 - ) || - (this.options["progressive"] && this.subTurn <= this.movesCount) - ) { - const oppKingPos = this.searchKingPos(oppCol); - if ( - oppKingPos[0] >= 0 && - ( - this.options["taking"] || - !this.underCheck(oppKingPos, color) - ) - ) { - this.subTurn++; - return; - } - } + if (this.isLastMove(move)) { this.turn = oppCol; + this.movesCount++; + this.subTurn = 1; } - this.movesCount++; - this.subTurn = 1; + else if (!move.next) + this.subTurn++; + } + + isLastMove(move) { + 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)) + return true; + return ( + ( + !this.options["balance"] || + ![1, 3].includes(this.movesCount) + ) + && + ( + !this.options["doublemove"] || + this.movesCount == 0 || + this.subTurn == 2 + ) + && + ( + !this.options["progressive"] || + this.subTurn == this.movesCount + 1 + ) + ); } // "Stop at the first move found" @@ -2164,8 +2319,9 @@ export default class ChessRules { const pieceWidth = this.getPieceWidth(r.width); move.appear.forEach(a => { this.g_pieces[a.x][a.y] = document.createElement("piece"); - this.g_pieces[a.x][a.y].classList.add(this.pieces()[a.p]["class"]); - this.g_pieces[a.x][a.y].classList.add(a.c == "w" ? "white" : "black"); + 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].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); @@ -2180,56 +2336,81 @@ export default class ChessRules { this.graphUpdateEnlightened(); } - playPlusVisual(move, r) { + // TODO: send stack receive stack, or allow incremental? (good/bad points) + buildMoveStack(move, r) { + this.moveStack.push(move); + this.computeNextMove(move); this.play(move); - this.playVisual(move, r); - this.afterPlay(move); //user method + 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 = [] + } + 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 = [] + }); + } + } } - getMaxDistance(rwidth) { + // Implemented in variants using (automatic) moveStack + computeNextMove(move) {} + + getMaxDistance(r) { // Works for all rectangular boards: - return Math.sqrt(rwidth ** 2 + (rwidth / this.size.ratio) ** 2); + return Math.sqrt(r.width ** 2 + r.height ** 2); } getDomPiece(x, y) { return (typeof x == "string" ? this.r_pieces : this.g_pieces)[x][y]; } - animate(move, callback) { - if (this.noAnimate || move.noAnimate) { - callback(); - return; - } - let initPiece = this.getDomPiece(move.start.x, move.start.y); - // NOTE: cloning generally not required, but light enough, and simpler + animateMoving(start, end, drag, segments, cb) { + let initPiece = this.getDomPiece(start.x, start.y); + // NOTE: cloning often not required, but light enough, and simpler let movingPiece = initPiece.cloneNode(); initPiece.style.opacity = "0"; let container = document.getElementById(this.containerId) const r = container.querySelector(".chessboard").getBoundingClientRect(); - if (typeof move.start.x == "string") { + if (typeof start.x == "string") { // Need to bound width/height (was 100% for reserve pieces) const pieceWidth = this.getPieceWidth(r.width); movingPiece.style.width = pieceWidth + "px"; movingPiece.style.height = pieceWidth + "px"; } - const maxDist = this.getMaxDistance(r.width); - const pieces = this.pieces(); - if (move.drag) { - const startCode = this.getPiece(move.start.x, move.start.y); - movingPiece.classList.remove(pieces[startCode]["class"]); - movingPiece.classList.add(pieces[move.drag.p]["class"]); - const apparentColor = this.getColor(move.start.x, move.start.y); - if (apparentColor != move.drag.c) { + const maxDist = this.getMaxDistance(r); + const apparentColor = this.getColor(start.x, start.y); + const pieces = this.pieces(apparentColor, start.x, start.y); + if (drag) { + const startCode = this.getPiece(start.x, start.y); + 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(move.drag.c)); + movingPiece.classList.add(C.GetColorClass(drag.c)); } } container.appendChild(movingPiece); const animateSegment = (index, cb) => { // NOTE: move.drag could be generalized per-segment (usage?) - const [i1, j1] = move.segments[index][0]; - const [i2, j2] = move.segments[index][1]; + const [i1, j1] = segments[index][0]; + const [i2, j2] = segments[index][1]; const dep = this.getPixelPosition(i1, j1, r); const arr = this.getPixelPosition(i2, j2, r); movingPiece.style.transitionDuration = "0s"; @@ -2245,24 +2426,64 @@ export default class ChessRules { setTimeout(cb, duration * 1000); }, 50); }; - if (!move.segments) { - move.segments = [ - [[move.start.x, move.start.y], [move.end.x, move.end.y]] - ]; - } let index = 0; const animateSegmentCallback = () => { - if (index < move.segments.length) + if (index < segments.length) animateSegment(index++, animateSegmentCallback); else { movingPiece.remove(); initPiece.style.opacity = "1"; - callback(); + cb(); } }; animateSegmentCallback(); } + // Input array of objects with at least fields x,y (e.g. PiPo) + animateFading(arr, cb) { + const animLength = 350; //TODO: 350ms? More? Less? + arr.forEach(v => { + let fadingPiece = this.getDomPiece(v.x, v.y); + fadingPiece.style.transitionDuration = (animLength / 1000) + "s"; + fadingPiece.style.opacity = "0"; + }); + setTimeout(cb, animLength); + } + + animate(move, callback) { + if (this.noAnimate || move.noAnimate) { + callback(); + return; + } + let segments = move.segments; + if (!segments) + segments = [ [[move.start.x, move.start.y], [move.end.x, move.end.y]] ]; + let targetObj = new TargetObj(callback); + if (move.start.x != move.end.x || move.start.y != move.end.y) { + targetObj.target++; + this.animateMoving(move.start, move.end, move.drag, segments, + () => targetObj.increment()); + } + if (move.vanish.length > move.appear.length) { + const arr = move.vanish.slice(move.appear.length) + // Ignore disappearing pieces hidden by some appearing ones: + .filter(v => move.appear.every(a => a.x != v.x || a.y != v.y)); + if (arr.length > 0) { + targetObj.target++; + this.animateFading(arr, () => targetObj.increment()); + } + } + targetObj.target += + this.customAnimate(move, segments, () => targetObj.increment()); + if (targetObj.target == 0) + callback(); + } + + // 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();