client/src/variants/Synchrone1.js

   1 import { ChessRules } from "@/base_rules";
   2 import { randInt } from "@/utils/alea";
   3
   4 export class Synchrone1Rules extends ChessRules {
   5
   6   static get CanAnalyze() {
   7     return false;
   8   }
   9
  10   static get ShowMoves() {
  11     return "byrow";
  12   }
  13
  14   static get SomeHiddenMoves() {
  15     return true;
  16   }
  17
  18   static IsGoodFen(fen) {
  19     if (!ChessRules.IsGoodFen(fen)) return false;
  20     const fenParsed = V.ParseFen(fen);
  21     // 5) Check whiteMove
  22     if (
  23       (
  24         fenParsed.turn == "b" &&
  25         // NOTE: do not check really JSON stringified move...
  26         (!fenParsed.whiteMove || fenParsed.whiteMove == "-")
  27       )
  28       ||
  29       (fenParsed.turn == "w" && fenParsed.whiteMove != "-")
  30     ) {
  31       return false;
  32     }
  33     return true;
  34   }
  35
  36   static IsGoodEnpassant(enpassant) {
  37     const epArray = enpassant.split(",");
  38     if (![2, 3].includes(epArray.length)) return false;
  39     epArray.forEach(epsq => {
  40       if (epsq != "-") {
  41         const ep = V.SquareToCoords(epsq);
  42         if (isNaN(ep.x) || !V.OnBoard(ep)) return false;
  43       }
  44     });
  45     return true;
  46   }
  47
  48   static ParseFen(fen) {
  49     const fenParts = fen.split(" ");
  50     return Object.assign(
  51       { whiteMove: fenParts[5] },
  52       ChessRules.ParseFen(fen)
  53     );
  54   }
  55
  56   static GenRandInitFen(randomness) {
  57     return ChessRules.GenRandInitFen(randomness).slice(0, -1) + "-,- -";
  58   }
  59
  60   getFen() {
  61     return super.getFen() + " " + this.getWhitemoveFen();
  62   }
  63
  64   getFenForRepeat() {
  65     return super.getFenForRepeat() + "_" + this.getWhitemoveFen();
  66   }
  67
  68   setOtherVariables(fen) {
  69     const parsedFen = V.ParseFen(fen);
  70     this.setFlags(parsedFen.flags);
  71     const epArray = parsedFen.enpassant.split(",");
  72     this.epSquares = [];
  73     epArray.forEach(epsq => this.epSquares.push(this.getEpSquare(epsq)));
  74     this.scanKings();
  75     // Also init whiteMove
  76     this.whiteMove =
  77       parsedFen.whiteMove != "-"
  78         ? JSON.parse(parsedFen.whiteMove)
  79         : null;
  80   }
  81
  82   scanKings() {
  83     this.kingPos = { w: [-1, -1], b: [-1, -1] };
  84     for (let i = 0; i < V.size.x; i++) {
  85       for (let j = 0; j < V.size.y; j++) {
  86         if (this.getPiece(i, j) == V.KING)
  87           this.kingPos[this.getColor(i, j)] = [i, j];
  88       }
  89     }
  90   }
  91
  92   getEnpassantFen() {
  93     const L = this.epSquares.length;
  94     let res = "";
  95     const start = L - 2 - (this.turn == 'b' ? 1 : 0);
  96     for (let i=start; i < L; i++) {
  97       if (!this.epSquares[i]) res += "-,";
  98       else res += V.CoordsToSquare(this.epSquares[i]) + ",";
  99     }
 100     return res.slice(0, -1);
 101   }
 102
 103   getWhitemoveFen() {
 104     if (!this.whiteMove) return "-";
 105     return JSON.stringify({
 106       start: this.whiteMove.start,
 107       end: this.whiteMove.end,
 108       appear: this.whiteMove.appear,
 109       vanish: this.whiteMove.vanish
 110     });
 111   }
 112
 113   getPossibleMovesFrom([x, y]) {
 114     let moves = this.filterValid(super.getPotentialMovesFrom([x, y]));
 115     if (!this.underCheck(this.getColor(x, y)))
 116       // Augment with potential recaptures, except if we are under check
 117       Array.prototype.push.apply(moves, this.getRecaptures([x, y]));
 118     return moves;
 119   }
 120
 121   // Aux function used to find opponent and self captures
 122   getCaptures(from, to, color) {
 123     const sliderAttack = (xx, yy, allowedSteps) => {
 124       const deltaX = xx - to[0],
 125             absDeltaX = Math.abs(deltaX);
 126       const deltaY = yy - to[1],
 127             absDeltaY = Math.abs(deltaY);
 128       const step = [ deltaX / absDeltaX || 0, deltaY / absDeltaY || 0 ];
 129       if (
 130         // Check that the step is a priori valid:
 131         (absDeltaX != absDeltaY && deltaX != 0 && deltaY != 0) ||
 132         allowedSteps.every(st => st[0] != step[0] || st[1] != step[1])
 133       ) {
 134         return null;
 135       }
 136       let sq = [ to[0] + step[0], to[1] + step[1] ];
 137       while (sq[0] != xx || sq[1] != yy) {
 138         // NOTE: no need to check OnBoard in this special case
 139         if (this.board[sq[0]][sq[1]] != V.EMPTY) return null;
 140         sq[0] += step[0];
 141         sq[1] += step[1];
 142       }
 143       return this.getBasicMove([xx, yy], [to[0], to[1]]);
 144     };
 145     // Can I take on the square 'to' ?
 146     // If yes, return the (list of) capturing move(s)
 147     const getTargetedCaptures = ([i, j]) => {
 148       let move = null;
 149       // From [i, j]:
 150       switch (this.getPiece(i, j)) {
 151         case V.PAWN: {
 152           // Pushed pawns move as enemy pawns
 153           const shift = (color == 'w' ? 1 : -1);
 154           if (to[0] + shift == i && Math.abs(to[1] - j) == 1)
 155             move = this.getBasicMove([i, j], to);
 156           break;
 157         }
 158         case V.KNIGHT: {
 159           const deltaX = Math.abs(i - to[0]);
 160           const deltaY = Math.abs(j - to[1]);
 161           if (
 162             deltaX + deltaY == 3 &&
 163             [1, 2].includes(deltaX) &&
 164             [1, 2].includes(deltaY)
 165           ) {
 166             move = this.getBasicMove([i, j], to);
 167           }
 168           break;
 169         }
 170         case V.KING:
 171           if (Math.abs(i - to[0]) <= 1 && Math.abs(j - to[1]) <= 1)
 172             move = this.getBasicMove([i, j], to);
 173           break;
 174         case V.ROOK: {
 175           move = sliderAttack(i, j, V.steps[V.ROOK]);
 176           break;
 177         }
 178         case V.BISHOP: {
 179           move = sliderAttack(i, j, V.steps[V.BISHOP]);
 180           break;
 181         }
 182         case V.QUEEN: {
 183           move = sliderAttack(i, j, V.steps[V.ROOK].concat(V.steps[V.BISHOP]));
 184           break;
 185         }
 186       }
 187       return move;
 188     };
 189     let moves = [];
 190     if (!!from) {
 191       const theMove = getTargetedCaptures(from);
 192       if (!!theMove) moves.push(theMove);
 193     }
 194     else {
 195       for (let i=0; i<8; i++) {
 196         for (let j=0; j<8; j++) {
 197           if (this.getColor(i, j) == color) {
 198             const newMove = getTargetedCaptures([i, j]);
 199             if (!!newMove) moves.push(newMove);
 200           }
 201         }
 202       }
 203     }
 204     return this.filterValid(moves);
 205   }
 206
 207   getRecaptures(from) {
 208     // 1) Generate all opponent's capturing moves
 209     let oppCaptureMoves = [];
 210     const color = this.turn;
 211     const oppCol = V.GetOppCol(color);
 212     for (let i=0; i<8; i++) {
 213       for (let j=0; j<8; j++) {
 214         if (
 215           this.getColor(i, j) == color &&
 216           // Do not consider king captures: self-captures of king are forbidden
 217           this.getPiece(i, j) != V.KING
 218         ) {
 219           Array.prototype.push.apply(
 220             oppCaptureMoves,
 221             this.getCaptures(null, [i, j], oppCol)
 222           );
 223         }
 224       }
 225     }
 226     // 2) Play each opponent's capture, and see if back-captures are possible:
 227     // Lookup table to quickly decide if a move is already in list:
 228     let moveSet = {};
 229     let moves = [];
 230     oppCaptureMoves.forEach(m => {
 231       // If another opponent capture with same endpoint already processed, skip
 232       const mHash = "m" + m.end.x + m.end.y;
 233       if (!moveSet[mHash]) {
 234         moveSet[mHash] = true;
 235         // Just make enemy piece disappear, to clear potential path:
 236         const justDisappear = {
 237           appear: [],
 238           vanish: [m.vanish[0]]
 239         };
 240         V.PlayOnBoard(this.board, justDisappear);
 241         // Can I take on [m.end.x, m.end.y] ? If yes, add to list:
 242         this.getCaptures(from, [m.end.x, m.end.y], color)
 243           .forEach(cm => moves.push(cm));
 244         V.UndoOnBoard(this.board, justDisappear);
 245       }
 246     });
 247     return moves;
 248   }
 249
 250   getAllValidMoves() {
 251     // Return possible moves + potential recaptures
 252     return super.getAllValidMoves().concat(this.getRecaptures());
 253   }
 254
 255   filterValid(moves) {
 256     if (moves.length == 0) return [];
 257     // filterValid can be called when it's "not our turn":
 258     const color = moves[0].vanish[0].c;
 259     return moves.filter(m => {
 260       const piece = m.vanish[0].p;
 261       if (piece == V.KING) {
 262         this.kingPos[color][0] = m.appear[0].x;
 263         this.kingPos[color][1] = m.appear[0].y;
 264       }
 265       V.PlayOnBoard(this.board, m);
 266       let res = !this.underCheck(color);
 267       V.UndoOnBoard(this.board, m);
 268       if (piece == V.KING) this.kingPos[color] = [m.start.x, m.start.y];
 269       return res;
 270     });
 271   }
 272
 273   atLeastOneMove(color) {
 274     const curTurn = this.turn;
 275     this.turn = color;
 276     const res = super.atLeastOneMove();
 277     this.turn = curTurn;
 278     return res;
 279   }
 280
 281   // White and black (partial) moves were played: merge
 282   resolveSynchroneMove(move) {
 283     const m1 = this.whiteMove;
 284     const m2 = move;
 285     // For PlayOnBoard (no need for start / end, irrelevant)
 286     let smove = {
 287       appear: [],
 288       vanish: [
 289         m1.vanish[0],
 290         m2.vanish[0]
 291       ]
 292     };
 293     if ((m1.end.x != m2.end.x) || (m1.end.y != m2.end.y)) {
 294       // Easy case: two independant moves (which may (self-)capture)
 295       smove.appear.push(m1.appear[0]);
 296       smove.appear.push(m2.appear[0]);
 297       // "Captured" pieces may have moved:
 298       if (m1.appear.length == 2) {
 299         // Castle
 300         smove.appear.push(m1.appear[1]);
 301         smove.vanish.push(m1.vanish[1]);
 302       }
 303       else if (
 304         m1.vanish.length == 2 &&
 305         (
 306           m1.vanish[1].x != m2.start.x ||
 307           m1.vanish[1].y != m2.start.y
 308         )
 309       ) {
 310         smove.vanish.push(m1.vanish[1]);
 311       }
 312       if (m2.appear.length == 2) {
 313         // Castle
 314         smove.appear.push(m2.appear[1]);
 315         smove.vanish.push(m2.vanish[1]);
 316       }
 317       else if (
 318         m2.vanish.length == 2 &&
 319         (
 320           m2.vanish[1].x != m1.start.x ||
 321           m2.vanish[1].y != m1.start.y
 322         )
 323       ) {
 324         smove.vanish.push(m2.vanish[1]);
 325       }
 326     }
 327     else {
 328       // Collision:
 329       if (m1.vanish.length == 1 && m2.vanish.length == 1) {
 330         // Easy case: both disappear except if one is a king
 331         const p1 = m1.vanish[0].p;
 332         const p2 = m2.vanish[0].p;
 333         if ([p1, p2].includes(V.KING)) {
 334           smove.appear.push({
 335             x: m1.end.x,
 336             y: m1.end.y,
 337             p: V.KING,
 338             c: (p1 == V.KING ? 'w' : 'b')
 339           });
 340         }
 341       }
 342       else {
 343         // One move is a self-capture and the other a normal capture:
 344         // only the self-capture appears
 345         const selfCaptureMove =
 346           m1.vanish[1].c == m1.vanish[0].c
 347             ? m1
 348             : m2;
 349         smove.appear.push({
 350           x: m1.end.x,
 351           y: m1.end.y,
 352           p: selfCaptureMove.appear[0].p,
 353           c: selfCaptureMove.vanish[0].c
 354         });
 355         smove.vanish.push({
 356           x: m1.end.x,
 357           y: m1.end.y,
 358           p: selfCaptureMove.vanish[1].p,
 359           c: selfCaptureMove.vanish[0].c
 360         });
 361       }
 362     }
 363     return smove;
 364   }
 365
 366   play(move) {
 367     move.flags = JSON.stringify(this.aggregateFlags()); //save flags (for undo)
 368     this.epSquares.push(this.getEpSquare(move));
 369     // Do not play on board (would reveal the move...)
 370     this.turn = V.GetOppCol(this.turn);
 371     this.movesCount++;
 372     this.postPlay(move);
 373   }
 374
 375   updateCastleFlags(move) {
 376     const firstRank = { 'w': V.size.x - 1, 'b': 0 };
 377     move.appear.concat(move.vanish).forEach(av => {
 378       for (let c of ['w', 'b']) {
 379         if (av.x == firstRank[c] && this.castleFlags[c].includes(av.y)) {
 380           const flagIdx = (av.y == this.castleFlags[c][0] ? 0 : 1);
 381           this.castleFlags[c][flagIdx] = 8;
 382         }
 383       }
 384     });
 385   }
 386
 387   postPlay(move) {
 388     if (this.turn == 'b') {
 389       // NOTE: whiteMove is used read-only, so no need to copy
 390       this.whiteMove = move;
 391       return;
 392     }
 393
 394     // A full turn just ended:
 395     const smove = this.resolveSynchroneMove(move);
 396     V.PlayOnBoard(this.board, smove);
 397     move.whiteMove = this.whiteMove; //for undo
 398     this.whiteMove = null;
 399
 400     // Update king position + flags
 401     let kingAppear = { 'w': false, 'b': false };
 402     for (let i = 0; i < smove.appear.length; i++) {
 403       if (smove.appear[i].p == V.KING) {
 404         const c = smove.appear[i].c;
 405         kingAppear[c] = true;
 406         this.kingPos[c][0] = smove.appear[i].x;
 407         this.kingPos[c][1] = smove.appear[i].y;
 408       }
 409     }
 410     for (let i = 0; i < smove.vanish.length; i++) {
 411       if (smove.vanish[i].p == V.KING) {
 412         const c = smove.vanish[i].c;
 413         if (!kingAppear[c]) {
 414           this.kingPos[c][0] = -1;
 415           this.kingPos[c][1] = -1;
 416         }
 417         break;
 418       }
 419     }
 420     this.updateCastleFlags(smove);
 421     move.smove = smove;
 422   }
 423
 424   undo(move) {
 425     this.epSquares.pop();
 426     this.disaggregateFlags(JSON.parse(move.flags));
 427     if (this.turn == 'w')
 428       // Back to the middle of the move
 429       V.UndoOnBoard(this.board, move.smove);
 430     this.turn = V.GetOppCol(this.turn);
 431     this.movesCount--;
 432     this.postUndo(move);
 433   }
 434
 435   postUndo(move) {
 436     if (this.turn == 'w') {
 437       // Reset king positions: scan board (TODO: could be more efficient)
 438       this.scanKings();
 439       // Also reset whiteMove
 440       this.whiteMove = null;
 441     }
 442     else this.whiteMove = move.whiteMove;
 443   }
 444
 445   getCheckSquares() {
 446     const color = this.turn;
 447     if (color == 'b') {
 448       // kingPos must be reset for appropriate highlighting:
 449       var lastMove = JSON.parse(JSON.stringify(this.whiteMove));
 450       this.undo(lastMove); //will erase whiteMove, thus saved above
 451     }
 452     let res = [];
 453     if (this.kingPos['w'][0] >= 0 && this.underCheck('w'))
 454       res.push(JSON.parse(JSON.stringify(this.kingPos['w'])));
 455     if (this.kingPos['b'][0] >= 0 && this.underCheck('b'))
 456       res.push(JSON.parse(JSON.stringify(this.kingPos['b'])));
 457     if (color == 'b') this.play(lastMove);
 458     return res;
 459   }
 460
 461   getCurrentScore() {
 462     if (this.turn == 'b')
 463       // Turn (white + black) not over yet
 464       return "*";
 465     // Was a king captured?
 466     if (this.kingPos['w'][0] < 0) return "0-1";
 467     if (this.kingPos['b'][0] < 0) return "1-0";
 468     const whiteCanMove = this.atLeastOneMove('w');
 469     const blackCanMove = this.atLeastOneMove('b');
 470     if (whiteCanMove && blackCanMove) return "*";
 471     // Game over
 472     const whiteInCheck = this.underCheck('w');
 473     const blackInCheck = this.underCheck('b');
 474     if (
 475       (whiteCanMove && !this.underCheck('b')) ||
 476       (blackCanMove && !this.underCheck('w'))
 477     ) {
 478       return "1/2";
 479     }
 480     // Checkmate: could be mutual
 481     if (!whiteCanMove && !blackCanMove) return "1/2";
 482     return (whiteCanMove ? "1-0" : "0-1");
 483   }
 484
 485   getComputerMove() {
 486     const maxeval = V.INFINITY;
 487     const color = this.turn;
 488     let moves = this.getAllValidMoves();
 489     if (moves.length == 0)
 490       // TODO: this situation should not happen
 491       return null;
 492
 493     if (Math.random() < 0.5)
 494       // Return a random move
 495       return moves[randInt(moves.length)];
 496
 497     // Rank moves at depth 1:
 498     // try to capture something (not re-capturing)
 499     moves.forEach(m => {
 500       V.PlayOnBoard(this.board, m);
 501       m.eval = this.evalPosition();
 502       V.UndoOnBoard(this.board, m);
 503     });
 504     moves.sort((a, b) => {
 505       return (color == "w" ? 1 : -1) * (b.eval - a.eval);
 506     });
 507     let candidates = [0];
 508     for (let i = 1; i < moves.length && moves[i].eval == moves[0].eval; i++)
 509       candidates.push(i);
 510     return moves[candidates[randInt(candidates.length)]];
 511   }
 512
 513   getNotation(move) {
 514     if (move.appear.length == 2 && move.appear[0].p == V.KING)
 515       // Castle
 516       return move.end.y < move.start.y ? "0-0-0" : "0-0";
 517     // Basic system: piece + init + dest square
 518     return (
 519       move.vanish[0].p.toUpperCase() +
 520       V.CoordsToSquare(move.start) +
 521       V.CoordsToSquare(move.end)
 522     );
 523   }
 524
 525 };