X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=client%2Fsrc%2Fbase_rules.js;h=1a4a32d96aaf61649580328802f2e906e143d505;hb=472c0c4f5aa29d96e080873ebfce2a04f664d852;hp=71fa13cfaa4e756d96b7e04445ec009d14964620;hpb=bb688df52df0713aba7b2c1c068614544f5ae96d;p=vchess.git diff --git a/client/src/base_rules.js b/client/src/base_rules.js index 71fa13cf..1a4a32d9 100644 --- a/client/src/base_rules.js +++ b/client/src/base_rules.js @@ -27,7 +27,8 @@ export const Move = class Move { } }; -// NOTE: x coords = top to bottom; y = left to right (from white player perspective) +// NOTE: x coords = top to bottom; y = left to right +// (from white player perspective) export const ChessRules = class ChessRules { ////////////// // MISC UTILS @@ -46,7 +47,9 @@ export const ChessRules = class ChessRules { static get PawnSpecs() { return { directions: { 'w': -1, 'b': 1 }, + initShift: { w: 1, b: 1 }, twoSquares: true, + threeSquares: false, promotions: [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN], canCapture: true, captureBackward: false, @@ -85,6 +88,11 @@ export const ChessRules = class ChessRules { return V.CanFlip; } + // Some variants use click infos: + doClick() { + return null; + } + static get IMAGE_EXTENSION() { // All pieces should be in the SVG format return ".svg"; @@ -128,11 +136,11 @@ export const ChessRules = class ChessRules { if (position.length == 0) return false; const rows = position.split("/"); if (rows.length != V.size.x) return false; - let kings = {}; + let kings = { "k": 0, "K": 0 }; for (let row of rows) { let sumElts = 0; for (let i = 0; i < row.length; i++) { - if (['K','k'].includes(row[i])) kings[row[i]] = true; + if (['K','k'].includes(row[i])) kings[row[i]]++; if (V.PIECES.includes(row[i].toLowerCase())) sumElts++; else { const num = parseInt(row[i]); @@ -142,8 +150,8 @@ export const ChessRules = class ChessRules { } if (sumElts != V.size.y) return false; } - // Both kings should be on board: - if (Object.keys(kings).length != 2) return false; + // Both kings should be on board. Exactly one per color. + if (Object.values(kings).some(v => v != 1)) return false; return true; } @@ -158,6 +166,7 @@ export const ChessRules = class ChessRules { return !!flags.match(/^[a-z]{4,4}$/); } + // NOTE: not with regexp to adapt to different board sizes. (TODO?) static IsGoodEnpassant(enpassant) { if (enpassant != "-") { const ep = V.SquareToCoords(enpassant); @@ -191,14 +200,14 @@ export const ChessRules = class ChessRules { return V.CoordToColumn(coords.y) + (V.size.x - coords.x); } - // Path to pieces + // Path to pieces (standard ones in pieces/ folder) getPpath(b) { - return b; //usual pieces in pieces/ folder + return b; } // Path to promotion pieces (usually the same) - getPPpath(b) { - return this.getPpath(b); + getPPpath(m) { + return this.getPpath(m.appear[0].c + m.appear[0].p); } // Aggregates flags into one object @@ -224,9 +233,11 @@ export const ChessRules = class ChessRules { const s = move.start, e = move.end; if ( - Math.abs(s.x - e.x) == 2 && s.y == e.y && - move.appear[0].p == V.PAWN + Math.abs(s.x - e.x) == 2 && + // Next conditions for variants like Atomic or Rifle, Recycle... + (move.appear.length > 0 && move.appear[0].p == V.PAWN) && + (move.vanish.length > 0 && move.vanish[0].p == V.PAWN) ) { return { x: (s.x + e.x) / 2, @@ -255,7 +266,8 @@ export const ChessRules = class ChessRules { getCheckSquares(color) { return ( this.underCheck(color) - ? [JSON.parse(JSON.stringify(this.kingPos[color]))] //need to duplicate! + // kingPos must be duplicated, because it may change: + ? [JSON.parse(JSON.stringify(this.kingPos[color]))] : [] ); } @@ -367,6 +379,13 @@ export const ChessRules = class ChessRules { // Position part of the FEN string getBaseFen() { + const format = (count) => { + // 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); + }; let position = ""; for (let i = 0; i < V.size.x; i++) { let emptyCount = 0; @@ -375,7 +394,7 @@ export const ChessRules = class ChessRules { else { if (emptyCount > 0) { // Add empty squares in-between - position += emptyCount; + position += format(emptyCount); emptyCount = 0; } position += V.board2fen(this.board[i][j]); @@ -383,7 +402,7 @@ export const ChessRules = class ChessRules { } if (emptyCount > 0) { // "Flush remainder" - position += emptyCount; + position += format(emptyCount); } if (i < V.size.x - 1) position += "/"; //separate rows } @@ -457,7 +476,8 @@ export const ChessRules = class ChessRules { // Scan board for kings positions scanKings(fen) { this.INIT_COL_KING = { w: -1, b: -1 }; - this.kingPos = { w: [-1, -1], b: [-1, -1] }; //squares of white and black king + // 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++) { @@ -672,7 +692,8 @@ export const ChessRules = class ChessRules { enpassantMove.vanish.push({ x: x, y: epSquare.y, - p: "p", + // Captured piece is usually a pawn, but next line seems harmless + p: this.getPiece(x, epSquare.y), c: this.getColor(x, epSquare.y) }); } @@ -703,7 +724,6 @@ export const ChessRules = class ChessRules { const [sizeX, sizeY] = [V.size.x, V.size.y]; const pawnShiftX = V.PawnSpecs.directions[color]; const firstRank = (color == "w" ? sizeX - 1 : 0); - const startRank = (color == "w" ? sizeX - 2 : 1); // Pawn movements in shiftX direction: const getPawnMoves = (shiftX) => { @@ -716,11 +736,23 @@ export const ChessRules = class ChessRules { // Next condition because pawns on 1st rank can generally jump if ( V.PawnSpecs.twoSquares && - [startRank, firstRank].includes(x) && - this.board[x + 2 * shiftX][y] == V.EMPTY + ( + (color == 'w' && x >= V.size.x - 1 - V.PawnSpecs.initShift['w']) + || + (color == 'b' && x <= V.PawnSpecs.initShift['b']) + ) ) { - // Two squares jump - moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y])); + if (this.board[x + 2 * shiftX][y] == V.EMPTY) { + // Two squares jump + moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y])); + if ( + V.PawnSpecs.threeSquares && + this.board[x + 3 * shiftX][y] == V.EMPTY + ) { + // Three squares jump + moves.push(this.getBasicMove([x, y], [x + 3 * shiftX, y])); + } + } } } // Captures @@ -829,22 +861,24 @@ export const ChessRules = class ChessRules { castleSide++ //large, then small ) { if (this.castleFlags[c][castleSide] >= V.size.y) continue; - // If this code is reached, rooks and king are on initial position + // If this code is reached, rook and king are on initial position - // NOTE: in some variants this is not a rook, but let's keep variable name + // NOTE: in some variants this is not a rook const rookPos = this.castleFlags[c][castleSide]; - const castlingPiece = this.getPiece(x, rookPos); - if (this.getColor(x, rookPos) != c) - // Rook is here but changed color (see Benedict) + if (this.board[x][rookPos] == V.EMPTY || this.getColor(x, rookPos) != c) + // 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; do { if ( - (!castleInCheck && this.isAttacked([x, i], oppCol)) || + // 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 && // NOTE: next check is enough, because of chessboard constraints (this.getColor(x, i) != c || @@ -864,9 +898,12 @@ export const ChessRules = class ChessRules { // Nothing on final squares, except maybe king and castling rook? for (i = 0; i < 2; i++) { if ( + finalSquares[castleSide][i] != rookPos && this.board[x][finalSquares[castleSide][i]] != V.EMPTY && - this.getPiece(x, finalSquares[castleSide][i]) != V.KING && - finalSquares[castleSide][i] != rookPos + ( + this.getPiece(x, finalSquares[castleSide][i]) != V.KING || + this.getColor(x, finalSquares[castleSide][i]) != c + ) ) { continue castlingCheck; } @@ -876,8 +913,18 @@ export const ChessRules = class ChessRules { moves.push( new Move({ appear: [ - new PiPo({ x: x, y: finalSquares[castleSide][0], p: V.KING, c: c }), - new PiPo({ x: x, y: finalSquares[castleSide][1], p: castlingPiece, c: c }) + new PiPo({ + x: x, + y: finalSquares[castleSide][0], + p: V.KING, + c: c + }), + new PiPo({ + x: x, + y: finalSquares[castleSide][1], + p: castlingPiece, + c: c + }) ], vanish: [ new PiPo({ x: x, y: y, p: V.KING, c: c }), @@ -914,9 +961,7 @@ export const ChessRules = class ChessRules { }); } - // Search for all valid moves considering current turn - // (for engine and game end) - getAllValidMoves() { + getAllPotentialMoves() { const color = this.turn; let potentialMoves = []; for (let i = 0; i < V.size.x; i++) { @@ -929,10 +974,17 @@ export const ChessRules = class ChessRules { } } } - return this.filterValid(potentialMoves); + return potentialMoves; + } + + // Search for all valid moves considering current turn + // (for engine and game end) + getAllValidMoves() { + return this.filterValid(this.getAllPotentialMoves()); } // Stop at the first move found + // TODO: not really, it explores all moves from a square (one is enough). atLeastOneMove() { const color = this.turn; for (let i = 0; i < V.size.x; i++) { @@ -1071,7 +1123,8 @@ export const ChessRules = class ChessRules { // this.states.push(stateFen); this.prePlay(move); - if (V.HasFlags) move.flags = JSON.stringify(this.aggregateFlags()); //save flags (for undo) + // Save flags (for undo) + if (V.HasFlags) move.flags = JSON.stringify(this.aggregateFlags()); if (V.HasEnpassant) this.epSquares.push(this.getEpSquare(move)); V.PlayOnBoard(this.board, move); this.turn = V.GetOppCol(this.turn); @@ -1083,7 +1136,7 @@ export const ChessRules = class ChessRules { const c = V.GetOppCol(this.turn); const firstRank = (c == "w" ? V.size.x - 1 : 0); // Update castling flags if rooks are moved - const oppCol = V.GetOppCol(c); + const oppCol = this.turn; const oppFirstRank = V.size.x - 1 - firstRank; if (piece == V.KING && move.appear.length > 0) this.castleFlags[c] = [V.size.y, V.size.y]; @@ -1093,7 +1146,9 @@ export const ChessRules = class ChessRules { ) { const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1); this.castleFlags[c][flagIdx] = V.size.y; - } else if ( + } + // NOTE: not "else if" because a rook could take an opposing rook + if ( move.end.x == oppFirstRank && //we took opponent rook? this.castleFlags[oppCol].includes(move.end.y) ) { @@ -1117,7 +1172,6 @@ export const ChessRules = class ChessRules { if (piece == V.KING && move.appear.length > 0) { this.kingPos[c][0] = move.appear[0].x; this.kingPos[c][1] = move.appear[0].y; - return; } if (V.HasCastle) this.updateCastleFlags(move, piece); } @@ -1187,7 +1241,7 @@ export const ChessRules = class ChessRules { return V.INFINITY; } - // Search depth: 2 for high branching factor, 4 for small (Loser chess, eg.) + // Search depth: 1,2 for e.g. higher branching factor, 4 for smaller static get SEARCH_DEPTH() { return 3; } @@ -1274,8 +1328,8 @@ export const ChessRules = class ChessRules { } let candidates = [0]; - for (let j = 1; j < moves1.length && moves1[j].eval == moves1[0].eval; j++) - candidates.push(j); + for (let i = 1; i < moves1.length && moves1[i].eval == moves1[0].eval; i++) + candidates.push(i); return moves1[candidates[randInt(candidates.length)]]; } @@ -1360,4 +1414,28 @@ export const ChessRules = class ChessRules { finalSquare ); } + + static GetUnambiguousNotation(move) { + // Machine-readable format with all the informations about the move + return ( + (!!move.start && V.OnBoard(move.start.x, move.start.y) + ? V.CoordsToSquare(move.start) + : "-" + ) + "." + + (!!move.end && V.OnBoard(move.end.x, move.end.y) + ? V.CoordsToSquare(move.end) + : "-" + ) + " " + + (!!move.appear && move.appear.length > 0 + ? move.appear.map(a => + a.c + a.p + V.CoordsToSquare({ x: a.x, y: a.y })).join(".") + : "-" + ) + "/" + + (!!move.vanish && move.vanish.length > 0 + ? move.vanish.map(a => + a.c + a.p + V.CoordsToSquare({ x: a.x, y: a.y })).join(".") + : "-" + ) + ); + } };