X-Git-Url: https://git.auder.net/?p=vchess.git;a=blobdiff_plain;f=client%2Fsrc%2Fbase_rules.js;h=0876473dc9b743a24638798d781a5dc3ae4a246e;hp=167be91fd5d1e4f6f8fee7ae4834d6eb4858b1dd;hb=10cceb25109739fa39b9b968be2707dee1d25a07;hpb=156986e6b06dc5f0acd39860bd4fef6b030e263b diff --git a/client/src/base_rules.js b/client/src/base_rules.js index 167be91f..0876473d 100644 --- a/client/src/base_rules.js +++ b/client/src/base_rules.js @@ -22,17 +22,46 @@ export const Move = class Move { constructor(o) { this.appear = o.appear; this.vanish = o.vanish; - this.start = o.start ? o.start : { x: o.vanish[0].x, y: o.vanish[0].y }; - this.end = o.end ? o.end : { x: o.appear[0].x, y: o.appear[0].y }; + this.start = o.start || { x: o.vanish[0].x, y: o.vanish[0].y }; + this.end = o.end || { x: o.appear[0].x, y: o.appear[0].y }; } }; // NOTE: x coords = top to bottom; y = left to right // (from white player perspective) export const ChessRules = class ChessRules { + ////////////// // MISC UTILS + static get Options() { + return { + select: [ + { + label: "Randomness", + variable: "randomness", + defaut: 0, + options: [ + { label: "Deterministic", value: 0 }, + { label: "Symmetric random", value: 1 }, + { label: "Asymmetric random", value: 2 } + ] + } + ], + check: [] + }; + } + + static AbbreviateOptions(opts) { + return ""; + // Randomness is a special option: (TODO?) + //return "R" + opts.randomness; + } + + static IsValidOptions(opts) { + return true; + } + // Some variants don't have flags: static get HasFlags() { return true; @@ -80,6 +109,24 @@ export const ChessRules = class ChessRules { return V.ShowMoves; } + // Sometimes moves must remain hidden until game ends + static get SomeHiddenMoves() { + return false; + } + get someHiddenMoves() { + return V.SomeHiddenMoves; + } + + // Generally true, unless the variant includes random effects + static get CorrConfirm() { + return true; + } + + // Used for Monochrome variant (TODO: harmonize: !canFlip ==> showFirstTurn) + get showFirstTurn() { + return false; + } + // Some variants always show the same orientation static get CanFlip() { return true; @@ -88,11 +135,57 @@ export const ChessRules = class ChessRules { return V.CanFlip; } + // NOTE: these will disappear once each variant has its dedicated SVG board. + // For (generally old) variants without checkered board + static get Monochrome() { + return false; + } + // Some games are drawn unusually (bottom right corner is black) + static get DarkBottomRight() { + return false; + } + // Some variants require lines drawing + static get Lines() { + if (V.Monochrome) { + let lines = []; + // Draw all inter-squares lines + for (let i = 0; i <= V.size.x; i++) + lines.push([[i, 0], [i, V.size.y]]); + for (let j = 0; j <= V.size.y; j++) + lines.push([[0, j], [V.size.x, j]]); + return lines; + } + return null; + } + + // In some variants, the player who repeat a position loses + static get LoseOnRepetition() { + return false; + } + // And in some others (Iceage), repetitions should be ignored: + static get IgnoreRepetition() { + return false; + } + loseOnRepetition() { + // In some variants, result depends on the position: + return V.LoseOnRepetition; + } + + // At some stages, some games could wait clicks only: + onlyClick() { + return false; + } + // Some variants use click infos: doClick() { return null; } + // Some variants may need to highlight squares on hover (Hamilton, Weiqi...) + hoverHighlight() { + return false; + } + static get IMAGE_EXTENSION() { // All pieces should be in the SVG format return ".svg"; @@ -105,7 +198,7 @@ export const ChessRules = class ChessRules { // Turn "p" into "bp" (for board) static fen2board(f) { - return f.charCodeAt() <= 90 ? "w" + f.toLowerCase() : "b" + f; + return f.charCodeAt(0) <= 90 ? "w" + f.toLowerCase() : "b" + f; } // Check if FEN describes a board situation correctly @@ -116,7 +209,7 @@ export const ChessRules = class ChessRules { // 2) Check turn if (!fenParsed.turn || !V.IsGoodTurn(fenParsed.turn)) return false; // 3) Check moves count - if (!fenParsed.movesCount || !(parseInt(fenParsed.movesCount) >= 0)) + if (!fenParsed.movesCount || !(parseInt(fenParsed.movesCount, 10) >= 0)) return false; // 4) Check flags if (V.HasFlags && (!fenParsed.flags || !V.IsGoodFlags(fenParsed.flags))) @@ -143,8 +236,8 @@ export const ChessRules = class ChessRules { if (['K','k'].includes(row[i])) kings[row[i]]++; if (V.PIECES.includes(row[i].toLowerCase())) sumElts++; else { - const num = parseInt(row[i]); - if (isNaN(num)) return false; + const num = parseInt(row[i], 10); + if (isNaN(num) || num <= 0) return false; sumElts += num; } } @@ -190,7 +283,7 @@ export const ChessRules = class ChessRules { return { // NOTE: column is always one char => max 26 columns // row is counted from black side => subtraction - x: V.size.x - parseInt(sq.substr(1)), + x: V.size.x - parseInt(sq.substr(1), 10), y: sq[0].charCodeAt() - 97 }; } @@ -222,7 +315,7 @@ export const ChessRules = class ChessRules { // En-passant square, if any getEpSquare(moveOrSquare) { - if (!moveOrSquare) return undefined; + if (!moveOrSquare) return undefined; //TODO: necessary line?! if (typeof moveOrSquare === "string") { const square = moveOrSquare; if (square == "-") return undefined; @@ -263,7 +356,8 @@ export const ChessRules = class ChessRules { } // On which squares is color under check ? (for interface) - getCheckSquares(color) { + getCheckSquares() { + const color = this.turn; return ( this.underCheck(color) // kingPos must be duplicated, because it may change: @@ -276,8 +370,8 @@ export const ChessRules = class ChessRules { // FEN UTILS // Setup the initial random (asymmetric) position - static GenRandInitFen(randomness) { - if (randomness == 0) + static GenRandInitFen(options) { + if (!options.randomness || options.randomness == 0) // Deterministic: return "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w 0 ahah -"; @@ -285,7 +379,7 @@ export const ChessRules = class ChessRules { let flags = ""; // Shuffle pieces on first (and last rank if randomness == 2) for (let c of ["w", "b"]) { - if (c == 'b' && randomness == 1) { + if (c == 'b' && options.randomness == 1) { pieces['b'] = pieces['w']; flags += flags; break; @@ -383,8 +477,10 @@ export const ChessRules = class ChessRules { // if more than 9 consecutive free spaces, break the integer, // otherwise FEN parsing will fail. if (count <= 9) return count; - // Currently only boards of size up to 11 or 12: - return "9" + (count - 9); + // Most boards of size < 18: + if (count <= 18) return "9" + (count - 9); + // Except Gomoku: + return "99" + (count - 18); }; let position = ""; for (let i = 0; i < V.size.x; i++) { @@ -437,7 +533,7 @@ export const ChessRules = class ChessRules { let j = 0; for (let indexInRow = 0; indexInRow < rows[i].length; indexInRow++) { const character = rows[i][indexInRow]; - const num = parseInt(character); + const num = parseInt(character, 10); // If num is a number, just shift j: if (!isNaN(num)) j += num; // Else: something at position i,j @@ -468,32 +564,29 @@ export const ChessRules = class ChessRules { return; const fenParsed = V.ParseFen(fen); this.board = V.GetBoard(fenParsed.position); - this.turn = fenParsed.turn[0]; //[0] to work with MarseilleRules - this.movesCount = parseInt(fenParsed.movesCount); + this.turn = fenParsed.turn; + this.movesCount = parseInt(fenParsed.movesCount, 10); this.setOtherVariables(fen); } // Scan board for kings positions + // TODO: should be done from board, no need for the complete FEN scanKings(fen) { - this.INIT_COL_KING = { w: -1, b: -1 }; // Squares of white and black king: this.kingPos = { w: [-1, -1], b: [-1, -1] }; const fenRows = V.ParseFen(fen).position.split("/"); - const startRow = { 'w': V.size.x - 1, 'b': 0 }; for (let i = 0; i < fenRows.length; i++) { let k = 0; //column index on board for (let j = 0; j < fenRows[i].length; j++) { switch (fenRows[i].charAt(j)) { case "k": this.kingPos["b"] = [i, k]; - this.INIT_COL_KING["b"] = k; break; case "K": this.kingPos["w"] = [i, k]; - this.INIT_COL_KING["w"] = k; break; default: { - const num = parseInt(fenRows[i].charAt(j)); + const num = parseInt(fenRows[i].charAt(j), 10); if (!isNaN(num)) k += num - 1; } } @@ -602,36 +695,30 @@ export const ChessRules = class ChessRules { // MOVES GENERATION // All possible moves from selected square - getPotentialMovesFrom([x, y]) { - switch (this.getPiece(x, y)) { - case V.PAWN: - return this.getPotentialPawnMoves([x, y]); - case V.ROOK: - return this.getPotentialRookMoves([x, y]); - case V.KNIGHT: - return this.getPotentialKnightMoves([x, y]); - case V.BISHOP: - return this.getPotentialBishopMoves([x, y]); - case V.QUEEN: - return this.getPotentialQueenMoves([x, y]); - case V.KING: - return this.getPotentialKingMoves([x, y]); + getPotentialMovesFrom(sq) { + switch (this.getPiece(sq[0], sq[1])) { + case V.PAWN: return this.getPotentialPawnMoves(sq); + case V.ROOK: return this.getPotentialRookMoves(sq); + case V.KNIGHT: return this.getPotentialKnightMoves(sq); + case V.BISHOP: return this.getPotentialBishopMoves(sq); + case V.QUEEN: return this.getPotentialQueenMoves(sq); + case V.KING: return this.getPotentialKingMoves(sq); } - return []; //never reached + return []; //never reached (but some variants may use it: Bario...) } // Build a regular move from its initial and destination squares. // tr: transformation getBasicMove([sx, sy], [ex, ey], tr) { const initColor = this.getColor(sx, sy); - const initPiece = this.getPiece(sx, sy); + const initPiece = this.board[sx][sy].charAt(1); let mv = new Move({ appear: [ new PiPo({ x: ex, y: ey, - c: tr ? tr.c : initColor, - p: tr ? tr.p : initPiece + c: !!tr ? tr.c : initColor, + p: !!tr ? tr.p : initPiece }) ], vanish: [ @@ -651,7 +738,7 @@ export const ChessRules = class ChessRules { x: ex, y: ey, c: this.getColor(ex, ey), - p: this.getPiece(ex, ey) + p: this.board[ex][ey].charAt(1) }) ); } @@ -661,14 +748,15 @@ export const ChessRules = class ChessRules { // Generic method to find possible moves of non-pawn pieces: // "sliding or jumping" - getSlideNJumpMoves([x, y], steps, oneStep) { + getSlideNJumpMoves([x, y], steps, nbSteps) { let moves = []; outerLoop: for (let step of steps) { let i = x + step[0]; let j = y + step[1]; + let stepCounter = 0; while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) { moves.push(this.getBasicMove([x, y], [i, j])); - if (oneStep) continue outerLoop; + if (nbSteps && ++stepCounter >= nbSteps) continue outerLoop; i += step[0]; j += step[1]; } @@ -692,8 +780,7 @@ export const ChessRules = class ChessRules { enpassantMove.vanish.push({ x: x, y: epSquare.y, - // Captured piece is usually a pawn, but next line seems harmless - p: this.getPiece(x, epSquare.y), + p: this.board[x][epSquare.y].charAt(1), c: this.getColor(x, epSquare.y) }); } @@ -703,27 +790,26 @@ export const ChessRules = class ChessRules { // Consider all potential promotions: addPawnMoves([x1, y1], [x2, y2], moves, promotions) { let finalPieces = [V.PAWN]; - const color = this.turn; + const color = this.turn; //this.getColor(x1, y1); const lastRank = (color == "w" ? 0 : V.size.x - 1); if (x2 == lastRank) { // promotions arg: special override for Hiddenqueen variant if (!!promotions) finalPieces = promotions; - else if (!!V.PawnSpecs.promotions) - finalPieces = V.PawnSpecs.promotions; + else if (!!V.PawnSpecs.promotions) finalPieces = V.PawnSpecs.promotions; } - let tr = null; for (let piece of finalPieces) { - tr = (piece != V.PAWN ? { c: color, p: piece } : null); + const tr = (piece != V.PAWN ? { c: color, p: piece } : null); moves.push(this.getBasicMove([x1, y1], [x2, y2], tr)); } } // What are the pawn moves from square x,y ? getPotentialPawnMoves([x, y], promotions) { - const color = this.turn; + const color = this.turn; //this.getColor(x, y); const [sizeX, sizeY] = [V.size.x, V.size.y]; const pawnShiftX = V.PawnSpecs.directions[color]; const firstRank = (color == "w" ? sizeX - 1 : 0); + const forward = (color == 'w' ? -1 : 1); // Pawn movements in shiftX direction: const getPawnMoves = (shiftX) => { @@ -731,7 +817,7 @@ export const ChessRules = class ChessRules { // NOTE: next condition is generally true (no pawn on last rank) if (x + shiftX >= 0 && x + shiftX < sizeX) { if (this.board[x + shiftX][y] == V.EMPTY) { - // One square forward + // One square forward (or backward) this.addPawnMoves([x, y], [x + shiftX, y], moves, promotions); // Next condition because pawns on 1st rank can generally jump if ( @@ -742,7 +828,10 @@ export const ChessRules = class ChessRules { (color == 'b' && x <= V.PawnSpecs.initShift['b']) ) ) { - if (this.board[x + 2 * shiftX][y] == V.EMPTY) { + if ( + shiftX == forward && + this.board[x + 2 * shiftX][y] == V.EMPTY + ) { // Two squares jump moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y])); if ( @@ -758,10 +847,7 @@ export const ChessRules = class ChessRules { // Captures if (V.PawnSpecs.canCapture) { for (let shiftY of [-1, 1]) { - if ( - y + shiftY >= 0 && - y + shiftY < sizeY - ) { + if (y + shiftY >= 0 && y + shiftY < sizeY) { if ( this.board[x + shiftX][y + shiftY] != V.EMPTY && this.canTake([x, y], [x + shiftX, y + shiftY]) @@ -772,13 +858,13 @@ export const ChessRules = class ChessRules { ); } if ( - V.PawnSpecs.captureBackward && + V.PawnSpecs.captureBackward && shiftX == forward && x - shiftX >= 0 && x - shiftX < V.size.x && this.board[x - shiftX][y + shiftY] != V.EMPTY && this.canTake([x, y], [x - shiftX, y + shiftY]) ) { this.addPawnMoves( - [x, y], [x + shiftX, y + shiftY], + [x, y], [x - shiftX, y + shiftY], moves, promotions ); } @@ -812,7 +898,7 @@ export const ChessRules = class ChessRules { // What are the knight moves from square x,y ? getPotentialKnightMoves(sq) { - return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep"); + return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], 1); } // What are the bishop moves from square x,y ? @@ -823,38 +909,29 @@ export const ChessRules = class ChessRules { // What are the queen moves from square x,y ? getPotentialQueenMoves(sq) { return this.getSlideNJumpMoves( - sq, - V.steps[V.ROOK].concat(V.steps[V.BISHOP]) - ); + sq, V.steps[V.ROOK].concat(V.steps[V.BISHOP])); } // What are the king moves from square x,y ? getPotentialKingMoves(sq) { // Initialize with normal moves let moves = this.getSlideNJumpMoves( - sq, - V.steps[V.ROOK].concat(V.steps[V.BISHOP]), - "oneStep" - ); - if (V.HasCastle) moves = moves.concat(this.getCastleMoves(sq)); + sq, V.steps[V.ROOK].concat(V.steps[V.BISHOP]), 1); + if (V.HasCastle && this.castleFlags[this.turn].some(v => v < V.size.y)) + moves = moves.concat(this.getCastleMoves(sq)); return moves; } // "castleInCheck" arg to let some variants castle under check - getCastleMoves([x, y], castleInCheck) { + getCastleMoves([x, y], finalSquares, castleInCheck, castleWith) { const c = this.getColor(x, y); - if (x != (c == "w" ? V.size.x - 1 : 0) || y != this.INIT_COL_KING[c]) - return []; //x isn't first rank, or king has moved (shortcut) // Castling ? const oppCol = V.GetOppCol(c); let moves = []; - let i = 0; // King, then rook: - const finalSquares = [ - [2, 3], - [V.size.y - 2, V.size.y - 3] - ]; + finalSquares = finalSquares || [ [2, 3], [V.size.y - 2, V.size.y - 3] ]; + const castlingKing = this.board[x][y].charAt(1); castlingCheck: for ( let castleSide = 0; castleSide < 2; @@ -865,24 +942,28 @@ export const ChessRules = class ChessRules { // NOTE: in some variants this is not a rook const rookPos = this.castleFlags[c][castleSide]; - if (this.board[x][rookPos] == V.EMPTY || this.getColor(x, rookPos) != c) + const castlingPiece = this.board[x][rookPos].charAt(1); + if ( + this.board[x][rookPos] == V.EMPTY || + this.getColor(x, rookPos) != c || + (!!castleWith && !castleWith.includes(castlingPiece)) + ) { // Rook is not here, or changed color (see Benedict) continue; + } // Nothing on the path of the king ? (and no checks) - const castlingPiece = this.getPiece(x, rookPos); const finDist = finalSquares[castleSide][0] - y; let step = finDist / Math.max(1, Math.abs(finDist)); - i = y; + let i = y; do { if ( - // NOTE: "castling" arg is used by some variants (Monster), - // where "isAttacked" is overloaded in an infinite-recursive way. - (!castleInCheck && this.isAttacked([x, i], oppCol, "castling")) || - (this.board[x][i] != V.EMPTY && + (!castleInCheck && this.isAttacked([x, i], oppCol)) || + ( + this.board[x][i] != V.EMPTY && // NOTE: next check is enough, because of chessboard constraints - (this.getColor(x, i) != c || - ![V.KING, castlingPiece].includes(this.getPiece(x, i)))) + (this.getColor(x, i) != c || ![y, rookPos].includes(i)) + ) ) { continue castlingCheck; } @@ -901,7 +982,7 @@ export const ChessRules = class ChessRules { finalSquares[castleSide][i] != rookPos && this.board[x][finalSquares[castleSide][i]] != V.EMPTY && ( - this.getPiece(x, finalSquares[castleSide][i]) != V.KING || + finalSquares[castleSide][i] != y || this.getColor(x, finalSquares[castleSide][i]) != c ) ) { @@ -916,7 +997,7 @@ export const ChessRules = class ChessRules { new PiPo({ x: x, y: finalSquares[castleSide][0], - p: V.KING, + p: castlingKing, c: c }), new PiPo({ @@ -927,7 +1008,8 @@ export const ChessRules = class ChessRules { }) ], vanish: [ - new PiPo({ x: x, y: y, p: V.KING, c: c }), + // King might be initially disguised (Titan...) + new PiPo({ x: x, y: y, p: castlingKing, c: c }), new PiPo({ x: x, y: rookPos, p: castlingPiece, c: c }) ], end: @@ -985,16 +1067,18 @@ export const ChessRules = class ChessRules { // Stop at the first move found // TODO: not really, it explores all moves from a square (one is enough). + // Possible fix: add extra arg "oneMove" to getPotentialMovesFrom, + // and then return only boolean true at first move found + // (in all getPotentialXXXMoves() ... for all variants ...) atLeastOneMove() { const color = this.turn; for (let i = 0; i < V.size.x; i++) { for (let j = 0; j < V.size.y; j++) { - if (this.getColor(i, j) == color) { + if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) { const moves = this.getPotentialMovesFrom([i, j]); if (moves.length > 0) { - for (let k = 0; k < moves.length; k++) { + for (let k = 0; k < moves.length; k++) if (this.filterValid([moves[k]]).length > 0) return true; - } } } } @@ -1016,16 +1100,22 @@ export const ChessRules = class ChessRules { // Generic method for non-pawn pieces ("sliding or jumping"): // is x,y attacked by a piece of given color ? - isAttackedBySlideNJump([x, y], color, piece, steps, oneStep) { + isAttackedBySlideNJump([x, y], color, piece, steps, nbSteps) { for (let step of steps) { let rx = x + step[0], ry = y + step[1]; - while (V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && !oneStep) { + let stepCounter = 1; + while ( + V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && + (!nbSteps || stepCounter < nbSteps) + ) { rx += step[0]; ry += step[1]; + stepCounter++; } if ( V.OnBoard(rx, ry) && + this.board[rx][ry] != V.EMPTY && this.getPiece(rx, ry) == piece && this.getColor(rx, ry) == color ) { @@ -1036,21 +1126,15 @@ export const ChessRules = class ChessRules { } // Is square x,y attacked by 'color' pawns ? - isAttackedByPawn([x, y], color) { + isAttackedByPawn(sq, color) { const pawnShift = (color == "w" ? 1 : -1); - if (x + pawnShift >= 0 && x + pawnShift < V.size.x) { - for (let i of [-1, 1]) { - if ( - y + i >= 0 && - y + i < V.size.y && - this.getPiece(x + pawnShift, y + i) == V.PAWN && - this.getColor(x + pawnShift, y + i) == color - ) { - return true; - } - } - } - return false; + return this.isAttackedBySlideNJump( + sq, + color, + V.PAWN, + [[pawnShift, 1], [pawnShift, -1]], + "oneStep" + ); } // Is square x,y attacked by 'color' rooks ? @@ -1132,8 +1216,9 @@ export const ChessRules = class ChessRules { this.postPlay(move); } - updateCastleFlags(move, piece) { - const c = V.GetOppCol(this.turn); + updateCastleFlags(move, piece, color) { + // TODO: check flags. If already off, no need to always re-evaluate + const c = color || V.GetOppCol(this.turn); const firstRank = (c == "w" ? V.size.x - 1 : 0); // Update castling flags if rooks are moved const oppCol = this.turn; @@ -1169,10 +1254,8 @@ export const ChessRules = class ChessRules { piece = move.appear[0].p; // Update king position + flags - if (piece == V.KING && move.appear.length > 0) { - this.kingPos[c][0] = move.appear[0].x; - this.kingPos[c][1] = move.appear[0].y; - } + if (piece == V.KING && move.appear.length > 0) + this.kingPos[c] = [move.appear[0].x, move.appear[0].y]; if (V.HasCastle) this.updateCastleFlags(move, piece); } @@ -1246,10 +1329,11 @@ export const ChessRules = class ChessRules { return 3; } - getComputerMove() { + // 'movesList' arg for some variants to provide a custom list + getComputerMove(movesList) { const maxeval = V.INFINITY; const color = this.turn; - let moves1 = this.getAllValidMoves(); + let moves1 = movesList || this.getAllValidMoves(); if (moves1.length == 0) // TODO: this situation should not happen @@ -1438,4 +1522,5 @@ export const ChessRules = class ChessRules { ) ); } + };