X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=base_rules.js;h=6a68f84dbef6f98b575f756f5b614c686ab79a2f;hb=a5da62690c1314425a576302466b1d4ad406d80d;hp=ce0de11244674b7cbfcac38bbf3f40b1ee677752;hpb=af9c9be34f416500f9e025e28f39fe89a8c7c345;p=xogo.git diff --git a/base_rules.js b/base_rules.js index ce0de11..6a68f84 100644 --- a/base_rules.js +++ b/base_rules.js @@ -111,6 +111,11 @@ export default class ChessRules { 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") @@ -125,7 +130,7 @@ export default class ChessRules { new PiPo({ x: coords.x, y: coords.y, - c: this.captured.c, //this.turn, + c: this.captured.c, p: this.captured.p }) ], @@ -466,46 +471,9 @@ export default class ChessRules { this.moveStack = []; } - updateEnlightened() { - this.oldEnlightened = this.enlightened; - this.enlightened = ArrayFun.init(this.size.x, this.size.y, false); - // Add pieces positions + all squares reachable by moves (includes Zen): - for (let x=0; x { - this.enlightened[m.end.x][m.end.y] = true; - }); - } - } - } - if (this.epSquare) - this.enlightEnpassant(); - } - - // Include square of the en-passant capturing square: - enlightEnpassant() { - // NOTE: shortcut, pawn has only one attack type, doesn't depend on square - const steps = this.pieces(this.playerColor)["p"].attack[0].steps; - for (let step of steps) { - const x = this.epSquare.x - step[0], - y = this.getY(this.epSquare.y - step[1]); - if ( - this.onBoard(x, y) && - this.getColor(x, y) == this.playerColor && - this.getPieceType(x, y) == "p" - ) { - this.enlightened[x][this.epSquare.y] = true; - break; - } - } - } - - // ordering as in pieces() p,r,n,b,q,k (+ count in base 30 if needed) + // ordering as in pieces() p,r,n,b,q,k initReserves(reserveStr) { - const counts = reserveStr.split("").map(c => parseInt(c, 30)); + const counts = reserveStr.split("").map(c => parseInt(c, 36)); this.reserve = { w: {}, b: {} }; const pieceName = ['p', 'r', 'n', 'b', 'q', 'k']; const L = pieceName.length; @@ -524,6 +492,22 @@ export default class ChessRules { this.ispawn = {}; } + //////////////// + // VISUAL UTILS + + getPieceWidth(rwidth) { + return (rwidth / this.size.y); + } + + getReserveSquareSize(rwidth, nbR) { + const sqSize = this.getPieceWidth(rwidth); + return Math.min(sqSize, rwidth / nbR); + } + + getReserveNumId(color, piece) { + return `${this.containerId}|rnum-${color}${piece}`; + } + getNbReservePieces(color) { return ( Object.values(this.reserve[color]).reduce( @@ -539,22 +523,6 @@ export default class ChessRules { (oldV,newV) => oldV + (this.reserve[c][newV] > 0 ? 1 : 0), 0); } - ////////////// - // VISUAL PART - - getPieceWidth(rwidth) { - return (rwidth / this.size.y); - } - - getReserveSquareSize(rwidth, nbR) { - const sqSize = this.getPieceWidth(rwidth); - return Math.min(sqSize, rwidth / nbR); - } - - getReserveNumId(color, piece) { - return `${this.containerId}|rnum-${color}${piece}`; - } - static AddClass_es(piece, class_es) { if (!Array.isArray(class_es)) class_es = [class_es]; @@ -571,6 +539,23 @@ export default class ChessRules { }); } + // Generally light square bottom-right + getSquareColorClass(x, y) { + return ((x+y) % 2 == 0 ? "light-square": "dark-square"); + } + + getMaxDistance(r) { + // Works for all rectangular boards: + return Math.sqrt(r.width ** 2 + r.height ** 2); + } + + getDomPiece(x, y) { + return (typeof x == "string" ? this.r_pieces : this.g_pieces)[x][y]; + } + + ////////////////// + // VISUAL METHODS + graphicalInit() { // NOTE: not window.onresize = this.re_drawBoardElts because scope (this) window.onresize = () => this.re_drawBoardElements(); @@ -657,11 +642,6 @@ export default class ChessRules { return board; } - // Generally light square bottom-right - getSquareColorClass(x, y) { - return ((x+y) % 2 == 0 ? "light-square": "dark-square"); - } - setupPieces(r) { if (this.g_pieces) { // Refreshing: delete old pieces first @@ -789,30 +769,6 @@ export default class ChessRules { } } - // Apply diff this.enlightened --> oldEnlightened on board - graphUpdateEnlightened() { - let chessboard = - document.getElementById(this.containerId).querySelector(".chessboard"); - const r = chessboard.getBoundingClientRect(); - const pieceWidth = this.getPieceWidth(r.width); - for (let x=0; x this.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() { + 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"); @@ -1069,6 +1050,70 @@ export default class ChessRules { } } + //////////////// + // DARK METHODS + + updateEnlightened() { + this.oldEnlightened = this.enlightened; + this.enlightened = ArrayFun.init(this.size.x, this.size.y, false); + // Add pieces positions + all squares reachable by moves (includes Zen): + for (let x=0; x { + this.enlightened[m.end.x][m.end.y] = true; + }); + } + } + } + if (this.epSquare) + this.enlightEnpassant(); + } + + // Include square of the en-passant capturing square: + enlightEnpassant() { + // NOTE: shortcut, pawn has only one attack type, doesn't depend on square + const steps = this.pieces(this.playerColor)["p"].attack[0].steps; + for (let step of steps) { + const x = this.epSquare.x - step[0], + y = this.getY(this.epSquare.y - step[1]); + if ( + this.onBoard(x, y) && + this.getColor(x, y) == this.playerColor && + this.getPieceType(x, y) == "p" + ) { + this.enlightened[x][this.epSquare.y] = true; + break; + } + } + } + + // Apply diff this.enlightened --> oldEnlightened on board + graphUpdateEnlightened() { + let chessboard = + document.getElementById(this.containerId).querySelector(".chessboard"); + const r = chessboard.getBoundingClientRect(); + const pieceWidth = this.getPieceWidth(r.width); + for (let x=0; x 0) + ) + ); + } + // For Madrasi: // (redefined in Baroque etc, where Madrasi condition doesn't make sense) isImmobilized([x, y]) { @@ -1262,8 +1334,8 @@ export default class ChessRules { 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) { @@ -1290,18 +1362,45 @@ export default class ChessRules { // 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 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; @@ -1362,23 +1450,22 @@ export default class ChessRules { let moves = []; for (let i=0; i 0) - ) - ) { - moves.push( - new Move({ - start: {x: c, y: p}, - end: {x: i, y: j}, - appear: [new PiPo({x: i, y: j, c: c, p: p})], - vanish: [] - }) - ); + if (this.canDrop([c, p], [i, j])) { + let mv = new Move({ + start: {x: c, y: p}, + end: {x: i, y: j}, + appear: [new PiPo({x: i, y: j, c: c, p: p})], + vanish: [] + }); + if (this.board[i][j] != "") { + mv.vanish.push(new PiPo({ + x: i, + y: j, + c: this.getColor(i, j), + p: this.getPiece(i, j) + })); + } + moves.push(mv); } } } @@ -1386,28 +1473,22 @@ export default class ChessRules { } // All possible moves from selected square - getPotentialMovesFrom(sq, color) { + getPotentialMovesFrom([x, y], color) { if (this.subTurnTeleport == 2) return []; - if (typeof sq[0] == "string") - return this.getDropMovesFrom(sq); - if (this.isImmobilized(sq)) + if (typeof x == "string") + return this.getDropMovesFrom([x, y]); + if (this.isImmobilized([x, y])) return []; - const piece = this.getPieceType(sq[0], sq[1]); - let moves = this.getPotentialMovesOf(piece, sq); + const piece = this.getPieceType(x, y); + let moves = this.getPotentialMovesOf(piece, [x, y]); + if (piece == "p" && this.hasEnpassant && this.epSquare) + Array.prototype.push.apply(moves, this.getEnpassantCaptures([x, y])); if ( - piece == "p" && - this.hasEnpassant && - this.epSquare - ) { - Array.prototype.push.apply(moves, this.getEnpassantCaptures(sq)); - } - if ( - piece == "k" && - this.hasCastle && + piece == "k" && this.hasCastle && this.castleFlags[color || this.turn].some(v => v < this.size.y) ) { - Array.prototype.push.apply(moves, this.getCastleMoves(sq)); + Array.prototype.push.apply(moves, this.getCastleMoves([x, y])); } return this.postProcessPotentialMoves(moves); } @@ -1418,7 +1499,7 @@ export default class ChessRules { 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"]) @@ -1431,13 +1512,9 @@ export default class ChessRules { 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; } @@ -1577,21 +1654,22 @@ export default class ChessRules { } // 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]) ); } ); @@ -1599,23 +1677,23 @@ export default class ChessRules { const noSpecials = this.findDestSquares( [x, y], { - moveOnly: specialAttack || this.options["zen"], - segments: this.options["cylinder"] - }, - ([i, j]) => this.board[i][j] == "" || this.canTake([x, y], [i, j]) + moveOnly: !!stepSpec.attack || this.options["zen"], + segments: this.options["cylinder"], + stepSpec: stepSpec + } ); Array.prototype.push.apply(squares, noSpecials); if (this.options["zen"]) { let zenCaptures = this.findCapturesOn( [x, y], - {}, - ([i, j]) => this.getPieceType(i, j) != 'k' + {}, //byCol: default is ok + ([i1, j1], [i2, j2]) => + !this.isKing(i1, j1) && this.canTake([i2, j2], [i1, j1]) ); // Technical step: segments (if any) are reversed if (this.options["cylinder"]) { zenCaptures.forEach(z => { - if (z.segments) - z.segments = z.segments.reverse().map(s => s.reverse()) + z.segments = z.segments.reverse().map(s => s.reverse()) }); } Array.prototype.push.apply(squares, zenCaptures); @@ -1628,10 +1706,11 @@ export default class ChessRules { [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); } @@ -1645,7 +1724,7 @@ export default class ChessRules { 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) @@ -1671,15 +1750,11 @@ export default class ChessRules { 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; @@ -1705,7 +1780,7 @@ export default class ChessRules { 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) @@ -1720,26 +1795,29 @@ export default class ChessRules { } } } + return undefined; //default, but let's explicit it }; if (o.captureTarget) - exploreSteps(o.captureSteps) + return exploreSteps(o.captureSteps) else { - const stepSpec = this.getStepSpec(this.getColor(x, y), x, y); + const stepSpec = + o.stepSpec || this.getStepSpec(this.getColor(x, y), x, y); + let outOne = false; if (!o.attackOnly || !stepSpec.attack) - exploreSteps(stepSpec.moves); - if (!o.moveOnly && !!stepSpec.attack) - exploreSteps(stepSpec.attack); + outOne = exploreSteps(stepSpec.moves); + if (!outOne && !o.moveOnly && !!stepSpec.attack) { + o.attackOnly = true; //ok because o is always a temporary object + outOne = exploreSteps(stepSpec.attack); + } + return (o.one ? outOne : res); } - return o.captureTarget ? null : (o.one ? false : res); } // Search for enemy (or not) pieces attacking [x, y] findCapturesOn([x, y], o, allowed) { - if (!allowed) - allowed = () => true; - let res = []; if (!o.byCol) o.byCol = [C.GetOppCol(this.getColor(x, y) || this.turn)]; + let res = []; for (let i=0; i this.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. @@ -1827,9 +1906,9 @@ export default class ChessRules { }) ); 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; @@ -1874,12 +1953,12 @@ export default class ChessRules { // Next conditions for variants like Atomic or Rifle, Recycle... ( move.appear.length > 0 && - this.getPieceType(0, 0, move.appear[0].p) == "p" + this.getPieceType(0, 0, move.appear[0].p) == 'p' ) && ( move.vanish.length > 0 && - this.getPieceType(0, 0, move.vanish[0].p) == "p" + this.getPieceType(0, 0, move.vanish[0].p) == 'p' ) ) { return { @@ -1895,25 +1974,26 @@ export default class ChessRules { const color = this.getColor(x, y); const shiftX = (color == 'w' ? -1 : 1); const oppCol = C.GetOppCol(color); - let enpassantMove = null; if ( - !!this.epSquare && + this.epSquare && this.epSquare.x == x + shiftX && Math.abs(this.getY(this.epSquare.y - y)) == 1 && - this.getColor(x, this.epSquare.y) == oppCol //Doublemove guard... + // Doublemove (and Progressive?) guards: + this.board[this.epSquare.x][this.epSquare.y] == "" && + this.getColor(x, this.epSquare.y) == oppCol ) { const [epx, epy] = [this.epSquare.x, this.epSquare.y]; - this.board[epx][epy] = oppCol + "p"; - enpassantMove = this.getBasicMove([x, y], [epx, epy]); + this.board[epx][epy] = oppCol + 'p'; + let enpassantMove = this.getBasicMove([x, y], [epx, epy]); this.board[epx][epy] = ""; const lastIdx = enpassantMove.vanish.length - 1; //think Rifle enpassantMove.vanish[lastIdx].x = x; + return [enpassantMove]; } - return !!enpassantMove ? [enpassantMove] : []; + return []; } - // "castleInCheck" arg to let some variants castle under check - getCastleMoves([x, y], finalSquares, castleInCheck, castleWith) { + getCastleMoves([x, y], finalSquares, castleWith) { const c = this.getColor(x, y); // Castling ? @@ -1938,7 +2018,7 @@ export default class ChessRules { if ( this.board[x][rookPos] == "" || this.getColor(x, rookPos) != c || - (!!castleWith && !castleWith.includes(castlingPiece)) + (castleWith && !castleWith.includes(castlingPiece)) ) { // Rook is not here, or changed color (see Benedict) continue; @@ -1949,7 +2029,13 @@ export default class ChessRules { let i = y; do { if ( - (!castleInCheck && this.underCheck([x, i], oppCol)) || + // NOTE: next weird test because underCheck() verification + // will be executed in filterValid() later. + ( + i != finalSquares[castleSide][0] && + this.underCheck([x, i], oppCol) + ) + || ( this.board[x][i] != "" && // NOTE: next check is enough, because of chessboard constraints @@ -1981,7 +2067,7 @@ export default class ChessRules { } } - // If this code is reached, castle is valid + // If this code is reached, castle is potentially valid moves.push( new Move({ appear: [ @@ -2019,20 +2105,33 @@ export default class ChessRules { // Is piece (or square) at given position attacked by "oppCol" ? underAttack([x, y], oppCol) { - const king = this.getPieceType(x, y) == 'k'; + // An empty square is considered as king, + // since it's used only in getCastleMoves (TODO?) + const king = this.board[x][y] == "" || this.isKing(x, y); return ( ( (!this.options["zen"] || king) && - this.findCapturesOn([x, y], - {oppCol: oppCol, segments: this.options["cylinder"], one: true}, - ([i, j]) => this.canTake([i, j], [x, y])).length == 1 + this.findCapturesOn( + [x, y], + { + byCol: [oppCol], + segments: this.options["cylinder"], + one: true + } + ) ) || ( - (this.options["zen"] && !king) && - this.findDestSquares([x, y], - {attackOnly: true, segments: this.options["cylinder"], one: true}, - ([i, j]) => this.canTake([i, j], [x, y])).length == 1 + (!!this.options["zen"] && !king) && + this.findDestSquares( + [x, y], + { + attackOnly: true, + segments: this.options["cylinder"], + one: true + }, + ([i1, j1], [i2, j2]) => this.getColor(i2, j2) == oppCol + ) ) ); } @@ -2047,7 +2146,7 @@ export default class ChessRules { searchKingPos(color) { for (let i=0; i < this.size.x; i++) { for (let j=0; j < this.size.y; j++) { - if (this.getColor(i, j) == color && this.getPieceType(i, j) == 'k') + if (this.getColor(i, j) == color && this.isKing(i, j)) return [i, j]; } } @@ -2067,14 +2166,10 @@ export default class ChessRules { this.playOnBoard(m); let square = kingPos, res = true; //a priori valid - if (m.vanish.some(v => { - return this.getPieceType(0, 0, v.p) == 'k' && v.c == color; - })) { + if (m.vanish.some(v => this.isKing(0, 0, v.p) && v.c == color)) { // Search king in appear array: const newKingIdx = - m.appear.findIndex(a => { - return this.getPieceType(0, 0, a.p) == 'k' && a.c == color; - }); + m.appear.findIndex(a => this.isKing(0, 0, a.p) && a.c == color); if (newKingIdx >= 0) square = [m.appear[newKingIdx].x, m.appear[newKingIdx].y]; else @@ -2092,16 +2187,6 @@ export default class ChessRules { ///////////////// // MOVES PLAYING - // Aggregate flags into one object - aggregateFlags() { - return this.castleFlags; - } - - // Reverse operation - disaggregateFlags(flags) { - this.castleFlags = flags; - } - // Apply a move on board playOnBoard(move) { for (let psq of move.vanish) @@ -2120,12 +2205,8 @@ export default class ChessRules { 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) @@ -2144,8 +2225,8 @@ export default class ChessRules { if ( this.hasCastle && // If flags already off, no need to re-check: - Object.keys(this.castleFlags).some(c => { - return this.castleFlags[c].some(val => val < this.size.y)}) + Object.values(this.castleFlags).some(cvals => + cvals.some(val => val < this.size.y)) ) { this.updateCastleFlags(move); } @@ -2161,7 +2242,7 @@ export default class ChessRules { const destSquare = C.CoordsToSquare(move.end); if ( this.ispawn[initSquare] || - (move.vanish[0].p == "p" && move.appear[0].p != "p") + (move.vanish[0].p == 'p' && move.appear[0].p != 'p') ) { this.ispawn[destSquare] = true; } @@ -2169,7 +2250,7 @@ export default class ChessRules { this.ispawn[destSquare] && this.getColor(move.end.x, move.end.y) != move.vanish[0].c ) { - move.vanish[1].p = "p"; + move.vanish[1].p = 'p'; delete this.ispawn[destSquare]; } } @@ -2228,7 +2309,7 @@ export default class ChessRules { this.captured = null; } if (this.isLastMove(move)) { - this.turn = oppCol; + this.turn = C.GetOppCol(color); this.movesCount++; this.subTurn = 1; } @@ -2240,14 +2321,14 @@ export default class ChessRules { if (move.next) return false; const color = this.turn; - const oppCol = C.GetOppCol(color); - const oppKingPos = this.searchKingPos(oppCol); + const oppKingPos = this.searchKingPos(C.GetOppCol(color)); if (oppKingPos[0] < 0 || this.underCheck(oppKingPos, color)) return true; return ( ( !this.options["balance"] || - ![1, 3].includes(this.movesCount) + ![1, 2].includes(this.movesCount) || + this.subTurn == 2 ) && ( @@ -2265,7 +2346,6 @@ export default class ChessRules { // "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) { @@ -2298,10 +2378,10 @@ export default class ChessRules { return (color == "w" ? "0-1" : "1-0"); if (kingPos[1][0] < 0) return (color == "w" ? "1-0" : "0-1"); - if (this.atLeastOneMove()) + if (this.atLeastOneMove(color)) return "*"; // No valid move: stalemate or checkmate? - if (!this.underCheck(kingPos[0], color)) + if (!this.underCheck(kingPos[0], oppCol)) return "1/2"; // OK, checkmate return (color == "w" ? "0-1" : "1-0"); @@ -2371,15 +2451,6 @@ export default class ChessRules { // Implemented in variants using (automatic) moveStack computeNextMove(move) {} - getMaxDistance(r) { - // Works for all rectangular boards: - return Math.sqrt(r.width ** 2 + r.height ** 2); - } - - getDomPiece(x, y) { - return (typeof x == "string" ? this.r_pieces : this.g_pieces)[x][y]; - } - animateMoving(start, end, drag, segments, cb) { let initPiece = this.getDomPiece(start.x, start.y); // NOTE: cloning often not required, but light enough, and simpler