client/src/variants/Doublemove1.js

   1 import { ChessRules } from "@/base_rules";
   2
   3 export class Doublemove1Rules extends ChessRules {
   4
   5   static IsGoodEnpassant(enpassant) {
   6     const squares = enpassant.split(",");
   7     if (squares.length > 2) return false;
   8     for (let sq of squares) {
   9       if (sq != "-") {
  10         const ep = V.SquareToCoords(sq);
  11         if (isNaN(ep.x) || !V.OnBoard(ep)) return false;
  12       }
  13     }
  14     return true;
  15   }
  16
  17   // There may be 2 enPassant squares (if 2 pawns jump 2 squares in same turn)
  18   getEnpassantFen() {
  19     return this.epSquares[this.epSquares.length - 1].map(
  20       epsq => epsq === undefined
  21         ? "-" //no en-passant
  22         : V.CoordsToSquare(epsq)
  23     ).join(",");
  24   }
  25
  26   setOtherVariables(fen) {
  27     const parsedFen = V.ParseFen(fen);
  28     this.setFlags(parsedFen.flags);
  29     this.epSquares = [parsedFen.enpassant.split(",").map(sq => {
  30       if (sq != "-") return V.SquareToCoords(sq);
  31       return undefined;
  32     })];
  33     this.scanKings(fen);
  34     this.turn = parsedFen.turn;
  35     this.subTurn = 1;
  36   }
  37
  38   getEnpassantCaptures([x, y], shiftX) {
  39     let moves = [];
  40     // En passant: always OK if subturn 1,
  41     // OK on subturn 2 only if enPassant was played at subturn 1
  42     // (and if there are two e.p. squares available).
  43     const Lep = this.epSquares.length;
  44     const epSquares = this.epSquares[Lep - 1]; //always at least one element
  45     let epSqs = [];
  46     epSquares.forEach(sq => {
  47       if (sq) epSqs.push(sq);
  48     });
  49     if (epSqs.length == 0) return moves;
  50     const oppCol = V.GetOppCol(this.getColor(x, y));
  51     for (let sq of epSqs) {
  52       if (
  53         this.subTurn == 1 ||
  54         (epSqs.length == 2 &&
  55           // Was this en-passant capture already played at subturn 1 ?
  56           // (Or maybe the opponent filled the en-passant square with a piece)
  57           this.board[epSqs[0].x][epSqs[0].y] != V.EMPTY)
  58       ) {
  59         if (
  60           sq.x == x + shiftX &&
  61           Math.abs(sq.y - y) == 1 &&
  62           // Add condition "enemy pawn must be present"
  63           this.getPiece(x, sq.y) == V.PAWN &&
  64           this.getColor(x, sq.y) == oppCol
  65         ) {
  66           let epMove = this.getBasicMove([x, y], [sq.x, sq.y]);
  67           epMove.vanish.push({
  68             x: x,
  69             y: sq.y,
  70             p: "p",
  71             c: oppCol
  72           });
  73           moves.push(epMove);
  74         }
  75       }
  76     }
  77     return moves;
  78   }
  79
  80   atLeastOneMove() {
  81     const color = this.turn;
  82     for (let i = 0; i < V.size.x; i++) {
  83       for (let j = 0; j < V.size.y; j++) {
  84         if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) {
  85           const moves = this.getPotentialMovesFrom([i, j]);
  86           if (moves.length > 0) {
  87             for (let k = 0; k < moves.length; k++) {
  88               const m = moves[k];
  89               // NOTE: not using play() here (=> infinite loop)
  90               V.PlayOnBoard(this.board, m);
  91               if (m.vanish[0].p == V.KING)
  92                 this.kingPos[color] = [m.appear[0].x, m.appear[0].y];
  93               const res = !this.underCheck(color);
  94               V.UndoOnBoard(this.board, m);
  95               if (m.vanish[0].p == V.KING)
  96                 this.kingPos[color] = [m.start.x, m.start.y];
  97               if (res) return true;
  98             }
  99           }
 100         }
 101       }
 102     }
 103     return false;
 104   }
 105
 106   play(move) {
 107     move.flags = JSON.stringify(this.aggregateFlags());
 108     move.turn = [this.turn, this.subTurn];
 109     V.PlayOnBoard(this.board, move);
 110     const epSq = this.getEpSquare(move);
 111     const oppCol = V.GetOppCol(this.turn);
 112     if (this.movesCount == 0) {
 113       // First move in game
 114       this.turn = "b";
 115       this.epSquares.push([epSq]);
 116       this.movesCount = 1;
 117     }
 118     // Does this move give check on subturn 1 or reach stalemate?
 119     // If yes, skip subturn 2
 120     else if (
 121       this.subTurn == 1 &&
 122       (
 123         this.underCheck(V.GetOppCol(this.turn)) ||
 124         !this.atLeastOneMove()
 125       )
 126     ) {
 127       this.turn = oppCol;
 128       this.epSquares.push([epSq]);
 129       move.checkOnSubturn1 = true;
 130       this.movesCount++;
 131     }
 132     else {
 133       if (this.subTurn == 2) {
 134         this.turn = oppCol;
 135         let lastEpsq = this.epSquares[this.epSquares.length - 1];
 136         lastEpsq.push(epSq);
 137       }
 138       else {
 139         this.epSquares.push([epSq]);
 140         this.movesCount++;
 141       }
 142       this.subTurn = 3 - this.subTurn;
 143     }
 144     this.postPlay(move);
 145   }
 146
 147   postPlay(move) {
 148     const c = move.turn[0];
 149     const piece = move.vanish[0].p;
 150     const firstRank = c == "w" ? V.size.x - 1 : 0;
 151
 152     if (piece == V.KING) {
 153       this.kingPos[c] = [move.appear[0].x, move.appear[0].y];
 154       this.castleFlags[c] = [V.size.y, V.size.y];
 155       return;
 156     }
 157     const oppCol = V.GetOppCol(c);
 158     const oppFirstRank = V.size.x - 1 - firstRank;
 159     if (
 160       move.start.x == firstRank && //our rook moves?
 161       this.castleFlags[c].includes(move.start.y)
 162     ) {
 163       const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1);
 164       this.castleFlags[c][flagIdx] = V.size.y;
 165     }
 166     if (
 167       move.end.x == oppFirstRank && //we took opponent rook?
 168       this.castleFlags[oppCol].includes(move.end.y)
 169     ) {
 170       const flagIdx = (move.end.y == this.castleFlags[oppCol][0] ? 0 : 1);
 171       this.castleFlags[oppCol][flagIdx] = V.size.y;
 172     }
 173   }
 174
 175   undo(move) {
 176     this.disaggregateFlags(JSON.parse(move.flags));
 177     V.UndoOnBoard(this.board, move);
 178     if (this.movesCount == 1 || !!move.checkOnSubturn1 || this.subTurn == 2) {
 179       // The move may not be full, but is fully undone:
 180       this.epSquares.pop();
 181       // Moves counter was just incremented:
 182       this.movesCount--;
 183     }
 184     else {
 185       // Undo the second half of a move
 186       let lastEpsq = this.epSquares[this.epSquares.length - 1];
 187       lastEpsq.pop();
 188     }
 189     this.turn = move.turn[0];
 190     this.subTurn = move.turn[1];
 191     super.postUndo(move);
 192   }
 193
 194   static get VALUES() {
 195     return {
 196       p: 1,
 197       r: 5,
 198       n: 3,
 199       b: 3,
 200       q: 7, //slightly less than in orthodox game
 201       k: 1000
 202     };
 203   }
 204
 205   // No alpha-beta here, just adapted min-max at depth 2(+1)
 206   getComputerMove() {
 207     const maxeval = V.INFINITY;
 208     const color = this.turn;
 209     const oppCol = V.GetOppCol(this.turn);
 210
 211     // Search best (half) move for opponent turn
 212     const getBestMoveEval = () => {
 213       let score = this.getCurrentScore();
 214       if (score != "*") {
 215         if (score == "1/2") return 0;
 216         return maxeval * (score == "1-0" ? 1 : -1);
 217       }
 218       let moves = this.getAllValidMoves();
 219       let res = oppCol == "w" ? -maxeval : maxeval;
 220       for (let m of moves) {
 221         this.play(m);
 222         score = this.getCurrentScore();
 223         // Now turn is oppCol,2 if m doesn't give check
 224         // Otherwise it's color,1. In both cases the next test makes sense
 225         if (score != "*") {
 226           if (score == "1/2")
 227             res = oppCol == "w" ? Math.max(res, 0) : Math.min(res, 0);
 228           else {
 229             // Found a mate
 230             this.undo(m);
 231             return maxeval * (score == "1-0" ? 1 : -1);
 232           }
 233         }
 234         const evalPos = this.evalPosition();
 235         res = oppCol == "w" ? Math.max(res, evalPos) : Math.min(res, evalPos);
 236         this.undo(m);
 237       }
 238       return res;
 239     };
 240
 241     const moves11 = this.getAllValidMoves();
 242     let doubleMove = null;
 243     let bestEval = Number.POSITIVE_INFINITY * (color == 'w' ? -1 : 1);
 244     // Rank moves using a min-max at depth 2
 245     for (let i = 0; i < moves11.length; i++) {
 246       this.play(moves11[i]);
 247       if (this.turn != color) {
 248         // We gave check with last move: search the best opponent move
 249         const evalM = getBestMoveEval() + 0.05 - Math.random() / 10;
 250         if (
 251           (color == 'w' && evalM > bestEval) ||
 252           (color == 'b' && evalM < bestEval)
 253         ) {
 254           doubleMove = moves11[i];
 255           bestEval = evalM;
 256         }
 257       }
 258       else {
 259         let moves12 = this.getAllValidMoves();
 260         for (let j = 0; j < moves12.length; j++) {
 261           this.play(moves12[j]);
 262           const evalM  = getBestMoveEval() + 0.05 - Math.random() / 10
 263           if (
 264             (color == 'w' && evalM > bestEval) ||
 265             (color == 'b' && evalM < bestEval)
 266           ) {
 267             doubleMove = [moves11[i], moves12[j]];
 268             bestEval = evalM;
 269           }
 270           this.undo(moves12[j]);
 271         }
 272       }
 273       this.undo(moves11[i]);
 274     }
 275     return doubleMove;
 276   }
 277
 278 };