X-Git-Url: https://git.auder.net/?p=vchess.git;a=blobdiff_plain;f=client%2Fsrc%2Fbase_rules.js;h=0876473dc9b743a24638798d781a5dc3ae4a246e;hp=656f7019c5c8f0beac84467b795535e2e2cb7a78;hb=10cceb25109739fa39b9b968be2707dee1d25a07;hpb=9bd6786b863c31c3ccd0057b87cf454c90886056 diff --git a/client/src/base_rules.js b/client/src/base_rules.js index 656f7019..0876473d 100644 --- a/client/src/base_rules.js +++ b/client/src/base_rules.js @@ -22,22 +22,71 @@ 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) +// 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; } - // Some variants don't have en-passant + // Or castle + static get HasCastle() { + return V.HasFlags; + } + + // Pawns specifications + 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, + bidirectional: false + }; + } + + // En-passant captures need a stack of squares: static get HasEnpassant() { return true; } @@ -46,16 +95,100 @@ export const ChessRules = class ChessRules { static get CanAnalyze() { return true; } + // Patch: issues with javascript OOP, objects can't access static fields. + get canAnalyze() { + return V.CanAnalyze; + } // Some variants show incomplete information, // and thus show only a partial moves list or no list at all. static get ShowMoves() { return "all"; } + get showMoves() { + return V.ShowMoves; + } + + // Sometimes moves must remain hidden until game ends + static get SomeHiddenMoves() { + return false; + } + get someHiddenMoves() { + return V.SomeHiddenMoves; + } - // Path to pieces - static getPpath(b) { - return b; //usual pieces in pieces/ folder + // 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; + } + get canFlip() { + 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"; } // Turn "wb" into "B" (for FEN) @@ -65,10 +198,10 @@ 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 describe a board situation correctly + // Check if FEN describes a board situation correctly static IsGoodFen(fen) { const fenParsed = V.ParseFen(fen); // 1) Check position @@ -76,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))) @@ -96,24 +229,22 @@ 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]); - if (isNaN(num)) return false; + const num = parseInt(row[i], 10); + if (isNaN(num) || num <= 0) return false; sumElts += num; } } 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; } @@ -124,9 +255,11 @@ export const ChessRules = class ChessRules { // For FEN checking static IsGoodFlags(flags) { - return !!flags.match(/^[01]{4,4}$/); + // NOTE: a little too permissive to work with more variants + 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); @@ -150,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 }; } @@ -160,6 +293,16 @@ export const ChessRules = class ChessRules { return V.CoordToColumn(coords.y) + (V.size.x - coords.x); } + // Path to pieces (standard ones in pieces/ folder) + getPpath(b) { + return b; + } + + // Path to promotion pieces (usually the same) + getPPpath(m) { + return this.getPpath(m.appear[0].c + m.appear[0].p); + } + // Aggregates flags into one object aggregateFlags() { return this.castleFlags; @@ -172,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; @@ -180,17 +323,18 @@ export const ChessRules = class ChessRules { } // Argument is a move: const move = moveOrSquare; - const [sx, sy, ex] = [move.start.x, move.start.y, move.end.x]; - // NOTE: next conditions are first for Atomic, and last for Checkered + const s = move.start, + e = move.end; if ( - move.appear.length > 0 && - Math.abs(sx - ex) == 2 && - move.appear[0].p == V.PAWN && - ["w", "b"].includes(move.appear[0].c) + 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 == V.PAWN) && + (move.vanish.length > 0 && move.vanish[0].p == V.PAWN) ) { return { - x: (sx + ex) / 2, - y: sy + x: (s.x + e.x) / 2, + y: s.y }; } return undefined; //default @@ -212,20 +356,35 @@ export const ChessRules = class ChessRules { } // On which squares is color under check ? (for interface) - getCheckSquares(color) { - return this.isAttacked(this.kingPos[color], [V.GetOppCol(color)]) - ? [JSON.parse(JSON.stringify(this.kingPos[color]))] //need to duplicate! - : []; + getCheckSquares() { + const color = this.turn; + return ( + this.underCheck(color) + // kingPos must be duplicated, because it may change: + ? [JSON.parse(JSON.stringify(this.kingPos[color]))] + : [] + ); } ///////////// // FEN UTILS - // Setup the initial random (assymetric) position - static GenRandInitFen() { + // Setup the initial random (asymmetric) position + static GenRandInitFen(options) { + if (!options.randomness || options.randomness == 0) + // Deterministic: + return "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w 0 ahah -"; + let pieces = { w: new Array(8), b: new Array(8) }; - // Shuffle pieces on first and last rank + let flags = ""; + // Shuffle pieces on first (and last rank if randomness == 2) for (let c of ["w", "b"]) { + if (c == 'b' && options.randomness == 1) { + pieces['b'] = pieces['w']; + flags += flags; + break; + } + let positions = ArrayFun.range(8); // Get random squares for bishops @@ -266,13 +425,15 @@ export const ChessRules = class ChessRules { pieces[c][bishop2Pos] = "b"; pieces[c][knight2Pos] = "n"; pieces[c][rook2Pos] = "r"; + flags += V.CoordToColumn(rook1Pos) + V.CoordToColumn(rook2Pos); } + // Add turn + flags + enpassant return ( pieces["b"].join("") + "/pppppppp/8/8/8/8/PPPPPPPP/" + pieces["w"].join("").toUpperCase() + - " w 0 1111 -" - ); //add turn + flags + enpassant + " w 0 " + flags + " -" + ); } // "Parse" FEN: just return untransformed string data @@ -292,18 +453,35 @@ export const ChessRules = class ChessRules { // Return current fen (game state) getFen() { return ( - this.getBaseFen() + - " " + - this.getTurnFen() + - " " + + this.getBaseFen() + " " + + this.getTurnFen() + " " + this.movesCount + (V.HasFlags ? " " + this.getFlagsFen() : "") + (V.HasEnpassant ? " " + this.getEnpassantFen() : "") ); } + getFenForRepeat() { + // Omit movesCount, only variable allowed to differ + return ( + this.getBaseFen() + "_" + + this.getTurnFen() + + (V.HasFlags ? "_" + this.getFlagsFen() : "") + + (V.HasEnpassant ? "_" + this.getEnpassantFen() : "") + ); + } + // 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; + // 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++) { let emptyCount = 0; @@ -312,7 +490,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]); @@ -320,7 +498,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 } @@ -334,10 +512,9 @@ export const ChessRules = class ChessRules { // Flags part of the FEN string getFlagsFen() { let flags = ""; - // Add castling flags - for (let i of ["w", "b"]) { - for (let j = 0; j < 2; j++) flags += this.castleFlags[i][j] ? "1" : "0"; - } + // Castling flags + for (let c of ["w", "b"]) + flags += this.castleFlags[c].map(V.CoordToColumn).join(""); return flags; } @@ -356,10 +533,10 @@ 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; - //just shift j - //something at position i,j + // Else: something at position i,j else board[i][j++] = V.fen2board(character); } } @@ -369,33 +546,34 @@ export const ChessRules = class ChessRules { // Extract (relevant) flags from fen setFlags(fenflags) { // white a-castle, h-castle, black a-castle, h-castle - this.castleFlags = { w: [true, true], b: [true, true] }; - if (!fenflags) return; - for (let i = 0; i < 4; i++) - this.castleFlags[i < 2 ? "w" : "b"][i % 2] = fenflags.charAt(i) == "1"; + this.castleFlags = { w: [-1, -1], b: [-1, -1] }; + for (let i = 0; i < 4; i++) { + this.castleFlags[i < 2 ? "w" : "b"][i % 2] = + V.ColumnToCoord(fenflags.charAt(i)); + } } ////////////////// // INITIALIZATION - constructor(fen) { - this.re_init(fen); - } - // Fen string fully describes the game state - re_init(fen) { + constructor(fen) { + if (!fen) + // In printDiagram() fen isn't supply because only getPpath() is used + // TODO: find a better solution! + 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 and rooks positions - scanKingsRooks(fen) { - this.INIT_COL_KING = { w: -1, b: -1 }; - this.INIT_COL_ROOK = { w: [-1, -1], b: [-1, -1] }; - this.kingPos = { w: [-1, -1], b: [-1, -1] }; //squares of white and black king + // Scan board for kings positions + // TODO: should be done from board, no need for the complete FEN + scanKings(fen) { + // Squares of white and black king: + this.kingPos = { w: [-1, -1], b: [-1, -1] }; const fenRows = V.ParseFen(fen).position.split("/"); for (let i = 0; i < fenRows.length; i++) { let k = 0; //column index on board @@ -403,22 +581,12 @@ export const ChessRules = class ChessRules { 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; - case "r": - if (this.INIT_COL_ROOK["b"][0] < 0) this.INIT_COL_ROOK["b"][0] = k; - else this.INIT_COL_ROOK["b"][1] = k; - break; - case "R": - if (this.INIT_COL_ROOK["w"][0] < 0) this.INIT_COL_ROOK["w"][0] = k; - else this.INIT_COL_ROOK["w"][1] = k; break; default: { - const num = parseInt(fenRows[i].charAt(j)); + const num = parseInt(fenRows[i].charAt(j), 10); if (!isNaN(num)) k += num - 1; } } @@ -439,8 +607,8 @@ export const ChessRules = class ChessRules { : undefined; this.epSquares = [epSq]; } - // Search for king and rooks positions: - this.scanKingsRooks(fen); + // Search for kings positions: + this.scanKings(fen); } ///////////////////// @@ -450,7 +618,7 @@ export const ChessRules = class ChessRules { return { x: 8, y: 8 }; } - // Color of thing on suqare (i,j). 'undefined' if square is empty + // Color of thing on square (i,j). 'undefined' if square is empty getColor(i, j) { return this.board[i][j].charAt(0); } @@ -526,43 +694,39 @@ export const ChessRules = class ChessRules { //////////////////// // MOVES GENERATION - // All possible moves from selected square (assumption: color is OK) - 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]); + // All possible moves from selected square + 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.board[sx][sy].charAt(1); let mv = new Move({ appear: [ new PiPo({ x: ex, y: ey, - c: tr ? tr.c : this.getColor(sx, sy), - p: tr ? tr.p : this.getPiece(sx, sy) + c: !!tr ? tr.c : initColor, + p: !!tr ? tr.p : initPiece }) ], vanish: [ new PiPo({ x: sx, y: sy, - c: this.getColor(sx, sy), - p: this.getPiece(sx, sy) + c: initColor, + p: initPiece }) ] }); @@ -574,23 +738,25 @@ 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) }) ); } + return mv; } // 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 !== undefined) continue outerLoop; + if (nbSteps && ++stepCounter >= nbSteps) continue outerLoop; i += step[0]; j += step[1]; } @@ -600,83 +766,129 @@ export const ChessRules = class ChessRules { return moves; } + // Special case of en-passant captures: treated separately + getEnpassantCaptures([x, y], shiftX) { + const Lep = this.epSquares.length; + const epSquare = this.epSquares[Lep - 1]; //always at least one element + let enpassantMove = null; + if ( + !!epSquare && + epSquare.x == x + shiftX && + Math.abs(epSquare.y - y) == 1 + ) { + enpassantMove = this.getBasicMove([x, y], [epSquare.x, epSquare.y]); + enpassantMove.vanish.push({ + x: x, + y: epSquare.y, + p: this.board[x][epSquare.y].charAt(1), + c: this.getColor(x, epSquare.y) + }); + } + return !!enpassantMove ? [enpassantMove] : []; + } + + // Consider all potential promotions: + addPawnMoves([x1, y1], [x2, y2], moves, promotions) { + let finalPieces = [V.PAWN]; + 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; + } + for (let piece of finalPieces) { + 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]) { - const color = this.turn; - let moves = []; + getPotentialPawnMoves([x, y], promotions) { + const color = this.turn; //this.getColor(x, y); const [sizeX, sizeY] = [V.size.x, V.size.y]; - const shiftX = color == "w" ? -1 : 1; - const firstRank = color == "w" ? sizeX - 1 : 0; - const startRank = color == "w" ? sizeX - 2 : 1; - const lastRank = color == "w" ? 0 : sizeX - 1; - const pawnColor = this.getColor(x, y); //can be different for checkered - - // NOTE: next condition is generally true (no pawn on last rank) - if (x + shiftX >= 0 && x + shiftX < sizeX) { - const finalPieces = - x + shiftX == lastRank - ? [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN] - : [V.PAWN]; - // One square forward - if (this.board[x + shiftX][y] == V.EMPTY) { - for (let piece of finalPieces) { - moves.push( - this.getBasicMove([x, y], [x + shiftX, y], { - c: pawnColor, - p: piece - }) - ); - } - // Next condition because pawns on 1st rank can generally jump - if ( - [startRank, firstRank].includes(x) && - this.board[x + 2 * shiftX][y] == V.EMPTY - ) { - // Two squares jump - moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, 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) => { + let moves = []; + // 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 (or backward) + this.addPawnMoves([x, y], [x + shiftX, y], moves, promotions); + // Next condition because pawns on 1st rank can generally jump + if ( + V.PawnSpecs.twoSquares && + ( + (color == 'w' && x >= V.size.x - 1 - V.PawnSpecs.initShift['w']) + || + (color == 'b' && x <= V.PawnSpecs.initShift['b']) + ) + ) { + 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 ( + 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 - for (let shiftY of [-1, 1]) { - if ( - y + shiftY >= 0 && - y + shiftY < sizeY && - this.board[x + shiftX][y + shiftY] != V.EMPTY && - this.canTake([x, y], [x + shiftX, y + shiftY]) - ) { - for (let piece of finalPieces) { - moves.push( - this.getBasicMove([x, y], [x + shiftX, y + shiftY], { - c: pawnColor, - p: piece - }) - ); + // Captures + if (V.PawnSpecs.canCapture) { + for (let shiftY of [-1, 1]) { + if (y + shiftY >= 0 && y + shiftY < sizeY) { + if ( + this.board[x + shiftX][y + shiftY] != V.EMPTY && + this.canTake([x, y], [x + shiftX, y + shiftY]) + ) { + this.addPawnMoves( + [x, y], [x + shiftX, y + shiftY], + moves, promotions + ); + } + if ( + 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], + moves, promotions + ); + } + } } } } + return moves; } + let pMoves = getPawnMoves(pawnShiftX); + if (V.PawnSpecs.bidirectional) + pMoves = pMoves.concat(getPawnMoves(-pawnShiftX)); + if (V.HasEnpassant) { - // En passant - const Lep = this.epSquares.length; - const epSquare = this.epSquares[Lep - 1]; //always at least one element - if ( - !!epSquare && - epSquare.x == x + shiftX && - Math.abs(epSquare.y - y) == 1 - ) { - let enpassantMove = this.getBasicMove([x, y], [epSquare.x, epSquare.y]); - enpassantMove.vanish.push({ - x: x, - y: epSquare.y, - p: "p", - c: this.getColor(x, epSquare.y) - }); - moves.push(enpassantMove); - } + // NOTE: backward en-passant captures are not considered + // because no rules define them (for now). + Array.prototype.push.apply( + pMoves, + this.getEnpassantCaptures([x, y], pawnShiftX) + ); } - return moves; + return pMoves; } // What are the rook moves from square x,y ? @@ -686,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 ? @@ -697,55 +909,61 @@ 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" - ); - return 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; } - getCastleMoves([x, y]) { + // "castleInCheck" arg to let some variants castle under check + 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; castleSide++ //large, then small ) { - if (!this.castleFlags[c][castleSide]) continue; - // If this code is reached, rooks and king are on initial position + if (this.castleFlags[c][castleSide] >= V.size.y) continue; + // If this code is reached, rook and king are on initial position + + // NOTE: in some variants this is not a rook + const rookPos = this.castleFlags[c][castleSide]; + const 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 finDist = finalSquares[castleSide][0] - y; let step = finDist / Math.max(1, Math.abs(finDist)); - i = y; + let i = y; do { if ( - this.isAttacked([x, i], [oppCol]) || - (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, V.ROOK].includes(this.getPiece(x, i)))) + (this.getColor(x, i) != c || ![y, rookPos].includes(i)) + ) ) { continue castlingCheck; } @@ -754,17 +972,19 @@ export const ChessRules = class ChessRules { // Nothing on the path to the rook? step = castleSide == 0 ? -1 : 1; - for (i = y + step; i != this.INIT_COL_ROOK[c][castleSide]; i += step) { + for (i = y + step; i != rookPos; i += step) { if (this.board[x][i] != V.EMPTY) continue castlingCheck; } - const rookPos = this.INIT_COL_ROOK[c][castleSide]; // 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 + ( + finalSquares[castleSide][i] != y || + this.getColor(x, finalSquares[castleSide][i]) != c + ) ) { continue castlingCheck; } @@ -774,12 +994,23 @@ 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: V.ROOK, c: c }) + new PiPo({ + x: x, + y: finalSquares[castleSide][0], + p: castlingKing, + 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 }), - new PiPo({ x: x, y: rookPos, p: V.ROOK, 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: Math.abs(y - rookPos) <= 2 @@ -812,16 +1043,12 @@ export const ChessRules = class ChessRules { }); } - // Search for all valid moves considering current turn - // (for engine and game end) - getAllValidMoves() { + getAllPotentialMoves() { const color = this.turn; - const oppCol = V.GetOppCol(color); let potentialMoves = []; for (let i = 0; i < V.size.x; i++) { for (let j = 0; j < V.size.y; j++) { - // Next condition "!= oppCol" to work with checkered variant - if (this.board[i][j] != V.EMPTY && this.getColor(i, j) != oppCol) { + if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) { Array.prototype.push.apply( potentialMoves, this.getPotentialMovesFrom([i, j]) @@ -829,21 +1056,29 @@ 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). + // 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; - const oppCol = V.GetOppCol(color); for (let i = 0; i < V.size.x; i++) { for (let j = 0; j < V.size.y; j++) { - if (this.board[i][j] != V.EMPTY && this.getColor(i, j) != oppCol) { + 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; - } } } } @@ -851,104 +1086,102 @@ export const ChessRules = class ChessRules { return false; } - // Check if pieces of color in 'colors' are attacking (king) on square x,y - isAttacked(sq, colors) { + // Check if pieces of given color are attacking (king) on square x,y + isAttacked(sq, color) { return ( - this.isAttackedByPawn(sq, colors) || - this.isAttackedByRook(sq, colors) || - this.isAttackedByKnight(sq, colors) || - this.isAttackedByBishop(sq, colors) || - this.isAttackedByQueen(sq, colors) || - this.isAttackedByKing(sq, colors) + this.isAttackedByPawn(sq, color) || + this.isAttackedByRook(sq, color) || + this.isAttackedByKnight(sq, color) || + this.isAttackedByBishop(sq, color) || + this.isAttackedByQueen(sq, color) || + this.isAttackedByKing(sq, color) ); } - // Is square x,y attacked by 'colors' pawns ? - isAttackedByPawn([x, y], colors) { - for (let c of colors) { - let pawnShift = c == "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) == c - ) { - return true; - } - } + // 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, nbSteps) { + for (let step of steps) { + let rx = x + step[0], + ry = y + step[1]; + 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 + ) { + return true; } } return false; } - // Is square x,y attacked by 'colors' rooks ? - isAttackedByRook(sq, colors) { - return this.isAttackedBySlideNJump(sq, colors, V.ROOK, V.steps[V.ROOK]); + // Is square x,y attacked by 'color' pawns ? + isAttackedByPawn(sq, color) { + const pawnShift = (color == "w" ? 1 : -1); + return this.isAttackedBySlideNJump( + sq, + color, + V.PAWN, + [[pawnShift, 1], [pawnShift, -1]], + "oneStep" + ); + } + + // Is square x,y attacked by 'color' rooks ? + isAttackedByRook(sq, color) { + return this.isAttackedBySlideNJump(sq, color, V.ROOK, V.steps[V.ROOK]); } - // Is square x,y attacked by 'colors' knights ? - isAttackedByKnight(sq, colors) { + // Is square x,y attacked by 'color' knights ? + isAttackedByKnight(sq, color) { return this.isAttackedBySlideNJump( sq, - colors, + color, V.KNIGHT, V.steps[V.KNIGHT], "oneStep" ); } - // Is square x,y attacked by 'colors' bishops ? - isAttackedByBishop(sq, colors) { - return this.isAttackedBySlideNJump(sq, colors, V.BISHOP, V.steps[V.BISHOP]); + // Is square x,y attacked by 'color' bishops ? + isAttackedByBishop(sq, color) { + return this.isAttackedBySlideNJump(sq, color, V.BISHOP, V.steps[V.BISHOP]); } - // Is square x,y attacked by 'colors' queens ? - isAttackedByQueen(sq, colors) { + // Is square x,y attacked by 'color' queens ? + isAttackedByQueen(sq, color) { return this.isAttackedBySlideNJump( sq, - colors, + color, V.QUEEN, V.steps[V.ROOK].concat(V.steps[V.BISHOP]) ); } - // Is square x,y attacked by 'colors' king(s) ? - isAttackedByKing(sq, colors) { + // Is square x,y attacked by 'color' king(s) ? + isAttackedByKing(sq, color) { return this.isAttackedBySlideNJump( sq, - colors, + color, V.KING, V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep" ); } - // Generic method for non-pawn pieces ("sliding or jumping"): - // is x,y attacked by a piece of color in array 'colors' ? - isAttackedBySlideNJump([x, y], colors, piece, steps, oneStep) { - 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) { - rx += step[0]; - ry += step[1]; - } - if ( - V.OnBoard(rx, ry) && - this.getPiece(rx, ry) === piece && - colors.includes(this.getColor(rx, ry)) - ) { - return true; - } - } - return false; - } - // Is color under check after his move ? underCheck(color) { - return this.isAttacked(this.kingPos[color], [V.GetOppCol(color)]); + return this.isAttacked(this.kingPos[color], V.GetOppCol(color)); } ///////////////// @@ -965,106 +1198,105 @@ export const ChessRules = class ChessRules { for (let psq of move.vanish) board[psq.x][psq.y] = psq.c + psq.p; } - // After move is played, update variables + flags - updateVariables(move) { - let piece = undefined; - let c = undefined; - if (move.vanish.length >= 1) { - // Usual case, something is moved - piece = move.vanish[0].p; - c = move.vanish[0].c; - } else { - // Crazyhouse-like variants - piece = move.appear[0].p; - c = move.appear[0].c; - } - if (c == "c") { - //if (!["w","b"].includes(c)) - // 'c = move.vanish[0].c' doesn't work for Checkered - c = V.GetOppCol(this.turn); - } - const firstRank = c == "w" ? V.size.x - 1 : 0; - - // 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 (V.HasFlags) this.castleFlags[c] = [false, false]; - return; - } - if (V.HasFlags) { - // Update castling flags if rooks are moved - const oppCol = V.GetOppCol(c); - const oppFirstRank = V.size.x - 1 - firstRank; - if ( - move.start.x == firstRank && //our rook moves? - this.INIT_COL_ROOK[c].includes(move.start.y) - ) { - const flagIdx = move.start.y == this.INIT_COL_ROOK[c][0] ? 0 : 1; - this.castleFlags[c][flagIdx] = false; - } else if ( - move.end.x == oppFirstRank && //we took opponent rook? - this.INIT_COL_ROOK[oppCol].includes(move.end.y) - ) { - const flagIdx = move.end.y == this.INIT_COL_ROOK[oppCol][0] ? 0 : 1; - this.castleFlags[oppCol][flagIdx] = false; - } - } - } - - // After move is undo-ed *and flags resetted*, un-update other variables - // TODO: more symmetry, by storing flags increment in move (?!) - unupdateVariables(move) { - // (Potentially) Reset king position - const c = this.getColor(move.start.x, move.start.y); - if (this.getPiece(move.start.x, move.start.y) == V.KING) - this.kingPos[c] = [move.start.x, move.start.y]; - } + prePlay() {} play(move) { // DEBUG: // if (!this.states) this.states = []; -// const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen(); +// const stateFen = this.getFen() + JSON.stringify(this.kingPos); // this.states.push(stateFen); - if (V.HasFlags) move.flags = JSON.stringify(this.aggregateFlags()); //save flags (for undo) + this.prePlay(move); + // 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); this.movesCount++; - this.updateVariables(move); + this.postPlay(move); + } + + 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; + const oppFirstRank = V.size.x - 1 - firstRank; + if (piece == V.KING && move.appear.length > 0) + this.castleFlags[c] = [V.size.y, V.size.y]; + else if ( + move.start.x == firstRank && //our rook moves? + this.castleFlags[c].includes(move.start.y) + ) { + const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1); + this.castleFlags[c][flagIdx] = V.size.y; + } + // 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) + ) { + const flagIdx = (move.end.y == this.castleFlags[oppCol][0] ? 0 : 1); + this.castleFlags[oppCol][flagIdx] = V.size.y; + } + } + + // After move is played, update variables + flags + postPlay(move) { + const c = V.GetOppCol(this.turn); + let piece = undefined; + if (move.vanish.length >= 1) + // Usual case, something is moved + piece = move.vanish[0].p; + else + // Crazyhouse-like variants + piece = move.appear[0].p; + + // Update king position + flags + 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); } + preUndo() {} + undo(move) { + this.preUndo(move); if (V.HasEnpassant) this.epSquares.pop(); if (V.HasFlags) this.disaggregateFlags(JSON.parse(move.flags)); V.UndoOnBoard(this.board, move); this.turn = V.GetOppCol(this.turn); this.movesCount--; - this.unupdateVariables(move); + this.postUndo(move); // DEBUG: -// const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen(); +// const stateFen = this.getFen() + JSON.stringify(this.kingPos); // if (stateFen != this.states[this.states.length-1]) debugger; // this.states.pop(); } + // After move is undo-ed *and flags resetted*, un-update other variables + // TODO: more symmetry, by storing flags increment in move (?!) + postUndo(move) { + // (Potentially) Reset king position + const c = this.getColor(move.start.x, move.start.y); + if (this.getPiece(move.start.x, move.start.y) == V.KING) + this.kingPos[c] = [move.start.x, move.start.y]; + } + /////////////// // END OF GAME // What is the score ? (Interesting if game is over) getCurrentScore() { - if (this.atLeastOneMove()) - // game not over - return "*"; - + if (this.atLeastOneMove()) return "*"; // Game over const color = this.turn; // No valid move: stalemate or checkmate? - if (!this.isAttacked(this.kingPos[color], [V.GetOppCol(color)])) - return "1/2"; + if (!this.underCheck(color)) return "1/2"; // OK, checkmate - return color == "w" ? "0-1" : "1-0"; + return (color == "w" ? "0-1" : "1-0"); } /////////////// @@ -1092,70 +1324,65 @@ 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; } - // NOTE: works also for extinction chess because depth is 3... - getComputerMove() { + // 'movesList' arg for some variants to provide a custom list + getComputerMove(movesList) { const maxeval = V.INFINITY; const color = this.turn; - // Some variants may show a bigger moves list to the human (Switching), - // thus the argument "computer" below (which is generally ignored) - let moves1 = this.getAllValidMoves("computer"); + let moves1 = movesList || this.getAllValidMoves(); + if (moves1.length == 0) - //TODO: this situation should not happen + // TODO: this situation should not happen return null; - // Can I mate in 1 ? (for Magnetic & Extinction) - for (let i of shuffle(ArrayFun.range(moves1.length))) { + // Rank moves using a min-max at depth 2 (if search_depth >= 2!) + for (let i = 0; i < moves1.length; i++) { this.play(moves1[i]); - let finish = Math.abs(this.evalPosition()) >= V.THRESHOLD_MATE; - if (!finish) { - const score = this.getCurrentScore(); - if (["1-0", "0-1"].includes(score)) finish = true; + const score1 = this.getCurrentScore(); + if (score1 != "*") { + moves1[i].eval = + score1 == "1/2" + ? 0 + : (score1 == "1-0" ? 1 : -1) * maxeval; + } + if (V.SEARCH_DEPTH == 1 || score1 != "*") { + if (!moves1[i].eval) moves1[i].eval = this.evalPosition(); + this.undo(moves1[i]); + continue; } - this.undo(moves1[i]); - if (finish) return moves1[i]; - } - - // Rank moves using a min-max at depth 2 - for (let i = 0; i < moves1.length; i++) { // Initial self evaluation is very low: "I'm checkmated" moves1[i].eval = (color == "w" ? -1 : 1) * maxeval; - this.play(moves1[i]); - const score1 = this.getCurrentScore(); - let eval2 = undefined; - if (score1 == "*") { - // Initial enemy evaluation is very low too, for him - eval2 = (color == "w" ? 1 : -1) * maxeval; - // Second half-move: - let moves2 = this.getAllValidMoves("computer"); - for (let j = 0; j < moves2.length; j++) { - this.play(moves2[j]); - const score2 = this.getCurrentScore(); - let evalPos = 0; //1/2 value - switch (score2) { - case "*": - evalPos = this.evalPosition(); - break; - case "1-0": - evalPos = maxeval; - break; - case "0-1": - evalPos = -maxeval; - break; - } - if ( - (color == "w" && evalPos < eval2) || - (color == "b" && evalPos > eval2) - ) { - eval2 = evalPos; - } - this.undo(moves2[j]); + // Initial enemy evaluation is very low too, for him + let eval2 = (color == "w" ? 1 : -1) * maxeval; + // Second half-move: + let moves2 = this.getAllValidMoves(); + for (let j = 0; j < moves2.length; j++) { + this.play(moves2[j]); + const score2 = this.getCurrentScore(); + let evalPos = 0; //1/2 value + switch (score2) { + case "*": + evalPos = this.evalPosition(); + break; + case "1-0": + evalPos = maxeval; + break; + case "0-1": + evalPos = -maxeval; + break; + } + if ( + (color == "w" && evalPos < eval2) || + (color == "b" && evalPos > eval2) + ) { + eval2 = evalPos; } - } else eval2 = score1 == "1/2" ? 0 : (score1 == "1-0" ? 1 : -1) * maxeval; + this.undo(moves2[j]); + } if ( (color == "w" && eval2 > moves1[i].eval) || (color == "b" && eval2 < moves1[i].eval) @@ -1167,20 +1394,11 @@ export const ChessRules = class ChessRules { moves1.sort((a, b) => { return (color == "w" ? 1 : -1) * (b.eval - a.eval); }); - - let candidates = [0]; //indices of candidates moves - for (let j = 1; j < moves1.length && moves1[j].eval == moves1[0].eval; j++) - candidates.push(j); - let currentBest = moves1[candidates[randInt(candidates.length)]]; +// console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; })); // Skip depth 3+ if we found a checkmate (or if we are checkmated in 1...) if (V.SEARCH_DEPTH >= 3 && Math.abs(moves1[0].eval) < V.THRESHOLD_MATE) { - // From here, depth >= 3: may take a while, so we control time - const timeStart = Date.now(); for (let i = 0; i < moves1.length; i++) { - if (Date.now() - timeStart >= 5000) - //more than 5 seconds - return currentBest; //depth 2 at least this.play(moves1[i]); // 0.1 * oldEval : heuristic to avoid some bad moves (not all...) moves1[i].eval = @@ -1191,12 +1409,11 @@ export const ChessRules = class ChessRules { moves1.sort((a, b) => { return (color == "w" ? 1 : -1) * (b.eval - a.eval); }); - } else return currentBest; - // console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; })); + } - candidates = [0]; - for (let j = 1; j < moves1.length && moves1[j].eval == moves1[0].eval; j++) - candidates.push(j); + let candidates = [0]; + for (let i = 1; i < moves1.length && moves1[i].eval == moves1[0].eval; i++) + candidates.push(i); return moves1[candidates[randInt(candidates.length)]]; } @@ -1207,7 +1424,7 @@ export const ChessRules = class ChessRules { if (score != "*") return score == "1/2" ? 0 : (score == "1-0" ? 1 : -1) * maxeval; if (depth == 0) return this.evalPosition(); - const moves = this.getAllValidMoves("computer"); + const moves = this.getAllValidMoves(); let v = color == "w" ? -maxeval : maxeval; if (color == "w") { for (let i = 0; i < moves.length; i++) { @@ -1217,8 +1434,9 @@ export const ChessRules = class ChessRules { alpha = Math.max(alpha, v); if (alpha >= beta) break; //beta cutoff } - } //color=="b" + } else { + // color=="b" for (let i = 0; i < moves.length; i++) { this.play(moves[i]); v = Math.min(v, this.alphabeta(depth - 1, alpha, beta)); @@ -1252,7 +1470,7 @@ export const ChessRules = class ChessRules { // TODO: un-ambiguous notation (switch on piece type, check directions...) getNotation(move) { if (move.appear.length == 2 && move.appear[0].p == V.KING) - //castle + // Castle return move.end.y < move.start.y ? "0-0-0" : "0-0"; // Translate final square @@ -1266,10 +1484,10 @@ export const ChessRules = class ChessRules { // Capture const startColumn = V.CoordToColumn(move.start.y); notation = startColumn + "x" + finalSquare; - } //no capture + } else notation = finalSquare; if (move.appear.length > 0 && move.appear[0].p != V.PAWN) - //promotion + // Promotion notation += "=" + move.appear[0].p.toUpperCase(); return notation; } @@ -1280,4 +1498,29 @@ 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(".") + : "-" + ) + ); + } + };