X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=client%2Fsrc%2Fbase_rules.js;h=1c5eabca5feb7de88393a73c20f4ec0e85b44c48;hb=90e814b6717b1ba932bba0e52958f54f814a2503;hp=db9b981a9f0b8f053e666f0ccf8fed1aea69aba0;hpb=1c5bfdf23707e893735f185786e9774b2270ace1;p=vchess.git diff --git a/client/src/base_rules.js b/client/src/base_rules.js index db9b981a..1c5eabca 100644 --- a/client/src/base_rules.js +++ b/client/src/base_rules.js @@ -197,13 +197,10 @@ export const ChessRules = class ChessRules { const move = moveOrSquare; const s = move.start, e = move.end; - // NOTE: next conditions are first for Atomic, and last for Checkered if ( - move.appear.length > 0 && Math.abs(s.x - e.x) == 2 && s.y == e.y && - move.appear[0].p == V.PAWN && - ["w", "b"].includes(move.appear[0].c) + move.appear[0].p == V.PAWN ) { return { x: (s.x + e.x) / 2, @@ -238,11 +235,20 @@ export const ChessRules = class ChessRules { ///////////// // FEN UTILS - // Setup the initial random (assymetric) position - static GenRandInitFen() { + // Setup the initial random (asymmetric) position + static GenRandInitFen(randomness) { + if (randomness == 0) + // Deterministic: + return "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w 0 1111 -"; + let pieces = { w: new Array(8), b: new Array(8) }; - // Shuffle pieces on first and last rank + // Shuffle pieces on first (and last rank if randomness == 2) for (let c of ["w", "b"]) { + if (c == 'b' && randomness == 1) { + pieces['b'] = pieces['w']; + break; + } + let positions = ArrayFun.range(8); // Get random squares for bishops @@ -310,16 +316,24 @@ 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() { let position = ""; @@ -395,14 +409,12 @@ export const ChessRules = class ChessRules { ////////////////// // INITIALIZATION - constructor(fen) { - // In printDiagram() fen isn't supply because only getPpath() is used - if (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 @@ -416,6 +428,7 @@ export const ChessRules = class ChessRules { this.INIT_COL_ROOK = { w: [-1, -1], b: [-1, -1] }; this.kingPos = { w: [-1, -1], b: [-1, -1] }; //squares of white and black king 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++) { @@ -429,12 +442,16 @@ export const ChessRules = class ChessRules { 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; + if (i == startRow['b']) { + 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; + if (i == startRow['w']) { + 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)); @@ -610,7 +627,7 @@ export const ChessRules = class ChessRules { let j = y + step[1]; 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 (oneStep) continue outerLoop; i += step[0]; j += step[1]; } @@ -629,7 +646,6 @@ export const ChessRules = class ChessRules { 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) { @@ -642,7 +658,7 @@ export const ChessRules = class ChessRules { for (let piece of finalPieces) { moves.push( this.getBasicMove([x, y], [x + shiftX, y], { - c: pawnColor, + c: color, p: piece }) ); @@ -667,7 +683,7 @@ export const ChessRules = class ChessRules { for (let piece of finalPieces) { moves.push( this.getBasicMove([x, y], [x + shiftX, y + shiftY], { - c: pawnColor, + c: color, p: piece }) ); @@ -836,12 +852,10 @@ export const ChessRules = class ChessRules { // (for engine and game end) getAllValidMoves() { 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.getColor(i, j) == color) { Array.prototype.push.apply( potentialMoves, this.getPotentialMovesFrom([i, j]) @@ -855,10 +869,9 @@ export const ChessRules = class ChessRules { // Stop at the first move found 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.getColor(i, j) == color) { const moves = this.getPotentialMovesFrom([i, j]); if (moves.length > 0) { for (let k = 0; k < moves.length; k++) { @@ -883,10 +896,31 @@ export const ChessRules = class ChessRules { ); } + // 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 square x,y attacked by 'colors' pawns ? isAttackedByPawn([x, y], colors) { for (let c of colors) { - let pawnShift = c == "w" ? 1 : -1; + const pawnShift = c == "w" ? 1 : -1; if (x + pawnShift >= 0 && x + pawnShift < V.size.x) { for (let i of [-1, 1]) { if ( @@ -945,27 +979,6 @@ export const ChessRules = class ChessRules { ); } - // 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)]); @@ -988,7 +1001,7 @@ export const ChessRules = class ChessRules { // After move is played, update variables + flags updateVariables(move) { let piece = undefined; - // TODO: update variables before move is played, and just use this.turn ? + // TODO: update variables before move is played, and just use this.turn? // (doesn't work in general, think MarseilleChess) let c = undefined; if (move.vanish.length >= 1) { @@ -1117,32 +1130,21 @@ export const ChessRules = class ChessRules { return 3; } - // NOTE: works also for extinction chess because depth is 3... getComputerMove() { 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 = 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))) { - 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; - } - this.undo(moves1[i]); - if (finish) return moves1[i]; - } - - // Rank moves using a min-max at depth 2 + // Rank moves using a min-max at depth 2 (if search_depth >= 2!) for (let i = 0; i < moves1.length; i++) { + if (V.SEARCH_DEPTH == 1) { + moves1[i].eval = this.evalPosition(); + continue; + } // Initial self evaluation is very low: "I'm checkmated" moves1[i].eval = (color == "w" ? -1 : 1) * maxeval; this.play(moves1[i]); @@ -1152,7 +1154,7 @@ export const ChessRules = class ChessRules { // Initial enemy evaluation is very low too, for him eval2 = (color == "w" ? 1 : -1) * maxeval; // Second half-move: - let moves2 = this.getAllValidMoves("computer"); + let moves2 = this.getAllValidMoves(); for (let j = 0; j < moves2.length; j++) { this.play(moves2[j]); const score2 = this.getCurrentScore(); @@ -1188,20 +1190,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 = @@ -1212,10 +1205,9 @@ 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]; + let candidates = [0]; for (let j = 1; j < moves1.length && moves1[j].eval == moves1[0].eval; j++) candidates.push(j); return moves1[candidates[randInt(candidates.length)]]; @@ -1228,7 +1220,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++) {