client/src/variants/Dynamo.js

   1 import { ChessRules, Move, PiPo } from "@/base_rules";
   2 import { randInt } from "@/utils/alea";
   3
   4 export class DynamoRules extends ChessRules {
   5
   6   // TODO? later, allow to push out pawns on a and h files
   7   static get HasEnpassant() {
   8     return false;
   9   }
  10
  11   canIplay(side, [x, y]) {
  12     // Sometimes opponent's pieces can be moved directly
  13     return this.turn == side;
  14   }
  15
  16   setOtherVariables(fen) {
  17     super.setOtherVariables(fen);
  18     this.subTurn = 1;
  19     // Local stack of "action moves"
  20     this.amoves = [];
  21     const amove = V.ParseFen(fen).amove;
  22     if (amove != "-") {
  23       const amoveParts = amove.split("/");
  24       let move = {
  25         // No need for start & end
  26         appear: [],
  27         vanish: []
  28       };
  29       [0, 1].map(i => {
  30         if (amoveParts[i] != "-") {
  31           amoveParts[i].split(".").forEach(av => {
  32             // Format is "bpe3"
  33             const xy = V.SquareToCoords(av.substr(2));
  34             move[i == 0 ? "appear" : "vanish"].push(
  35               new PiPo({
  36                 x: xy.x,
  37                 y: xy.y,
  38                 c: av[0],
  39                 p: av[1]
  40               })
  41             );
  42           });
  43         }
  44       });
  45       this.amoves.push(move);
  46     }
  47     // Stack "first moves" (on subTurn 1) to merge and check opposite moves
  48     this.firstMove = [];
  49   }
  50
  51   static ParseFen(fen) {
  52     return Object.assign(
  53       ChessRules.ParseFen(fen),
  54       { amove: fen.split(" ")[4] }
  55     );
  56   }
  57
  58   static IsGoodFen(fen) {
  59     if (!ChessRules.IsGoodFen(fen)) return false;
  60     const fenParts = fen.split(" ");
  61     if (fenParts.length != 5) return false;
  62     if (fenParts[4] != "-") {
  63       // TODO: a single regexp instead.
  64       // Format is [bpa2[.wpd3]] || '-'/[bbc3[.wrd5]] || '-'
  65       const amoveParts = fenParts[4].split("/");
  66       if (amoveParts.length != 2) return false;
  67       for (let part of amoveParts) {
  68         if (part != "-") {
  69           for (let psq of part.split("."))
  70             if (!psq.match(/^[a-z]{3}[1-8]$/)) return false;
  71         }
  72       }
  73     }
  74     return true;
  75   }
  76
  77   getFen() {
  78     return super.getFen() + " " + this.getAmoveFen();
  79   }
  80
  81   getFenForRepeat() {
  82     return super.getFenForRepeat() + "_" + this.getAmoveFen();
  83   }
  84
  85   getAmoveFen() {
  86     const L = this.amoves.length;
  87     if (L == 0) return "-";
  88     return (
  89       ["appear","vanish"].map(
  90         mpart => {
  91           if (this.amoves[L-1][mpart].length == 0) return "-";
  92           return (
  93             this.amoves[L-1][mpart].map(
  94               av => {
  95                 const square = V.CoordsToSquare({ x: av.x, y: av.y });
  96                 return av.c + av.p + square;
  97               }
  98             ).join(".")
  99           );
 100         }
 101       ).join("/")
 102     );
 103   }
 104
 105   canTake() {
 106     // Captures don't occur (only pulls & pushes)
 107     return false;
 108   }
 109
 110   // Step is right, just add (push/pull) moves in this direction
 111   // Direction is assumed normalized.
 112   getMovesInDirection([x, y], [dx, dy], nbSteps) {
 113     nbSteps = nbSteps || 8; //max 8 steps anyway
 114     let [i, j] = [x + dx, y + dy];
 115     let moves = [];
 116     const color = this.getColor(x, y);
 117     const piece = this.getPiece(x, y);
 118     const lastRank = (color == 'w' ? 0 : 7);
 119     let counter = 1;
 120     while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
 121       if (i == lastRank && piece == V.PAWN) {
 122         // Promotion by push or pull
 123         V.PawnSpecs.promotions.forEach(p => {
 124           let move = super.getBasicMove([x, y], [i, j], { c: color, p: p });
 125           moves.push(move);
 126         });
 127       }
 128       else moves.push(super.getBasicMove([x, y], [i, j]));
 129       if (++counter > nbSteps) break;
 130       i += dx;
 131       j += dy;
 132     }
 133     if (!V.OnBoard(i, j) && piece != V.KING) {
 134       // Add special "exit" move, by "taking king"
 135       moves.push(
 136         new Move({
 137           start: { x: x, y: y },
 138           end: { x: this.kingPos[color][0], y: this.kingPos[color][1] },
 139           appear: [],
 140           vanish: [{ x: x, y: y, c: color, p: piece }]
 141         })
 142       );
 143     }
 144     return moves;
 145   }
 146
 147   // Normalize direction to know the step
 148   getNormalizedDirection([dx, dy]) {
 149     const absDir = [Math.abs(dx), Math.abs(dy)];
 150     let divisor = 0;
 151     if (absDir[0] != 0 && absDir[1] != 0 && absDir[0] != absDir[1])
 152       // Knight
 153       divisor = Math.min(absDir[0], absDir[1]);
 154     else
 155       // Standard slider (or maybe a pawn or king: same)
 156       divisor = Math.max(absDir[0], absDir[1]);
 157     return [dx / divisor, dy / divisor];
 158   }
 159
 160   // There was something on x2,y2, maybe our color, pushed or (self)pulled
 161   isAprioriValidExit([x1, y1], [x2, y2], color2, piece2) {
 162     const color1 = this.getColor(x1, y1);
 163     const pawnShift = (color1 == 'w' ? -1 : 1);
 164     const lastRank = (color1 == 'w' ? 0 : 7);
 165     const deltaX = Math.abs(x1 - x2);
 166     const deltaY = Math.abs(y1 - y2);
 167     const checkSlider = () => {
 168       const dir = this.getNormalizedDirection([x2 - x1, y2 - y1]);
 169       let [i, j] = [x1 + dir[0], y1 + dir[1]];
 170       while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
 171         i += dir[0];
 172         j += dir[1];
 173       }
 174       return !V.OnBoard(i, j);
 175     };
 176     switch (piece2 || this.getPiece(x1, y1)) {
 177       case V.PAWN:
 178         return (
 179           x1 + pawnShift == x2 &&
 180           (
 181             (color1 == color2 && x2 == lastRank && y1 == y2) ||
 182             (
 183               color1 != color2 &&
 184               deltaY == 1 &&
 185               !V.OnBoard(2 * x2 - x1, 2 * y2 - y1)
 186             )
 187           )
 188         );
 189       case V.ROOK:
 190         if (x1 != x2 && y1 != y2) return false;
 191         return checkSlider();
 192       case V.KNIGHT:
 193         return (
 194           deltaX + deltaY == 3 &&
 195           (deltaX == 1 || deltaY == 1) &&
 196           !V.OnBoard(2 * x2 - x1, 2 * y2 - y1)
 197         );
 198       case V.BISHOP:
 199         if (deltaX != deltaY) return false;
 200         return checkSlider();
 201       case V.QUEEN:
 202         if (deltaX != 0 && deltaY != 0 && deltaX != deltaY) return false;
 203         return checkSlider();
 204       case V.KING:
 205         return (
 206           deltaX <= 1 &&
 207           deltaY <= 1 &&
 208           !V.OnBoard(2 * x2 - x1, 2 * y2 - y1)
 209         );
 210     }
 211     return false;
 212   }
 213
 214   isAprioriValidVertical([x1, y1], x2) {
 215     const piece = this.getPiece(x1, y1);
 216     const deltaX = Math.abs(x1 - x2);
 217     const startRank = (this.getColor(x1, y1) == 'w' ? 6 : 1);
 218     return (
 219       [V.QUEEN, V.ROOK].includes(piece) ||
 220       (
 221         [V.KING, V.PAWN].includes(piece) &&
 222         (
 223           deltaX == 1 ||
 224           (deltaX == 2 && piece == V.PAWN && x1 == startRank)
 225         )
 226       )
 227     );
 228   }
 229
 230   // NOTE: for pushes, play the pushed piece first.
 231   //       for pulls: play the piece doing the action first
 232   // NOTE: to push a piece out of the board, make it slide until its king
 233   getPotentialMovesFrom([x, y]) {
 234     const color = this.turn;
 235     const sqCol = this.getColor(x, y);
 236     const pawnShift = (color == 'w' ? -1 : 1);
 237     const pawnStartRank = (color == 'w' ? 6 : 1);
 238     const getMoveHash = (m) => {
 239       return V.CoordsToSquare(m.start) + V.CoordsToSquare(m.end);
 240     };
 241     if (this.subTurn == 1) {
 242       const addMoves = (dir, nbSteps) => {
 243         const newMoves =
 244           this.getMovesInDirection([x, y], [-dir[0], -dir[1]], nbSteps)
 245           .filter(m => !movesHash[getMoveHash(m)]);
 246         newMoves.forEach(m => { movesHash[getMoveHash(m)] = true; });
 247         Array.prototype.push.apply(moves, newMoves);
 248       };
 249       // Free to play any move (if piece of my color):
 250       let moves =
 251         sqCol == color
 252           ? super.getPotentialMovesFrom([x, y])
 253           : [];
 254       // There may be several suicide moves: keep only one
 255       let hasExit = false;
 256       moves = moves.filter(m => {
 257         const suicide = (m.appear.length == 0);
 258         if (suicide) {
 259           if (hasExit) return false;
 260           hasExit = true;
 261         }
 262         return true;
 263       });
 264       // Structure to avoid adding moves twice (can be action & move)
 265       let movesHash = {};
 266       moves.forEach(m => { movesHash[getMoveHash(m)] = true; });
 267       // [x, y] is pushed by 'color'
 268       for (let step of V.steps[V.KNIGHT]) {
 269         const [i, j] = [x + step[0], y + step[1]];
 270         if (
 271           V.OnBoard(i, j) &&
 272           this.board[i][j] != V.EMPTY &&
 273           this.getColor(i, j) == color &&
 274           this.getPiece(i, j) == V.KNIGHT
 275         ) {
 276           addMoves(step, 1);
 277         }
 278       }
 279       for (let step of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) {
 280         let [i, j] = [x + step[0], y + step[1]];
 281         while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
 282           i += step[0];
 283           j += step[1];
 284         }
 285         if (
 286           V.OnBoard(i, j) &&
 287           this.board[i][j] != V.EMPTY &&
 288           this.getColor(i, j) == color
 289         ) {
 290           const deltaX = Math.abs(i - x);
 291           const deltaY = Math.abs(j - y);
 292           switch (this.getPiece(i, j)) {
 293             case V.PAWN:
 294               if (
 295                 (x - i) / deltaX == pawnShift &&
 296                 deltaX <= 2 &&
 297                 deltaY <= 1
 298               ) {
 299                 if (sqCol == color && deltaY == 0) {
 300                   // Pushed forward
 301                   const maxSteps = (i == pawnStartRank && deltaX == 1 ? 2 : 1);
 302                   addMoves(step, maxSteps);
 303                 }
 304                 else if (sqCol != color && deltaY == 1 && deltaX == 1)
 305                   // Pushed diagonally
 306                   addMoves(step, 1);
 307               }
 308               break;
 309             case V.ROOK:
 310               if (deltaX == 0 || deltaY == 0) addMoves(step);
 311               break;
 312             case V.BISHOP:
 313               if (deltaX == deltaY) addMoves(step);
 314               break;
 315             case V.QUEEN:
 316               // All steps are valid for a queen:
 317               addMoves(step);
 318               break;
 319             case V.KING:
 320               if (deltaX <= 1 && deltaY <= 1) addMoves(step, 1);
 321               break;
 322           }
 323         }
 324       }
 325       return moves;
 326     }
 327     // If subTurn == 2 then we should have a first move,
 328     // which restrict what we can play now: only in the first move direction
 329     const L = this.firstMove.length;
 330     const fm = this.firstMove[L-1];
 331     if (
 332       (fm.appear.length == 2 && fm.vanish.length == 2) ||
 333       (fm.vanish[0].c == sqCol && sqCol != color)
 334     ) {
 335       // Castle or again opponent color: no move playable then.
 336       return [];
 337     }
 338     const piece = this.getPiece(x, y);
 339     const getPushExit = () => {
 340       // Piece at subTurn 1 exited: can I have caused the exit?
 341       if (
 342         this.isAprioriValidExit(
 343           [x, y],
 344           [fm.start.x, fm.start.y],
 345           fm.vanish[0].c
 346         )
 347       ) {
 348         // Seems so:
 349         const dir = this.getNormalizedDirection(
 350           [fm.start.x - x, fm.start.y - y]);
 351         const nbSteps =
 352           [V.PAWN, V.KING, V.KNIGHT].includes(piece)
 353             ? 1
 354             : null;
 355         return this.getMovesInDirection([x, y], dir, nbSteps);
 356       }
 357       return [];
 358     }
 359     const getPushMoves = () => {
 360       // Piece from subTurn 1 is still on board:
 361       const dirM = this.getNormalizedDirection(
 362         [fm.end.x - fm.start.x, fm.end.y - fm.start.y]);
 363       const dir = this.getNormalizedDirection(
 364         [fm.start.x - x, fm.start.y - y]);
 365       // Normalized directions should match
 366       if (dir[0] == dirM[0] && dir[1] == dirM[1]) {
 367         // We don't know if first move is a pushed piece or normal move,
 368         // so still must check if the push is valid.
 369         const deltaX = Math.abs(fm.start.x - x);
 370         const deltaY = Math.abs(fm.start.y - y);
 371         switch (piece) {
 372           case V.PAWN:
 373             if (x == pawnStartRank) {
 374               if (
 375                 (fm.start.x - x) * pawnShift < 0 ||
 376                 deltaX >= 3 ||
 377                 deltaY >= 2 ||
 378                 (fm.vanish[0].c == color && deltaY > 0) ||
 379                 (fm.vanish[0].c != color && deltaY == 0) ||
 380                 Math.abs(fm.end.x - fm.start.x) > deltaX ||
 381                 fm.end.y - fm.start.y != fm.start.y - y
 382               ) {
 383                 return [];
 384               }
 385             }
 386             else {
 387               if (
 388                 fm.start.x - x != pawnShift ||
 389                 deltaY >= 2 ||
 390                 (fm.vanish[0].c == color && deltaY == 1) ||
 391                 (fm.vanish[0].c != color && deltaY == 0) ||
 392                 fm.end.x - fm.start.x != pawnShift ||
 393                 fm.end.y - fm.start.y != fm.start.y - y
 394               ) {
 395                 return [];
 396               }
 397             }
 398             break;
 399           case V.KNIGHT:
 400             if (
 401               (deltaX + deltaY != 3 || (deltaX == 0 && deltaY == 0)) ||
 402               (fm.end.x - fm.start.x != fm.start.x - x) ||
 403               (fm.end.y - fm.start.y != fm.start.y - y)
 404             ) {
 405               return [];
 406             }
 407             break;
 408           case V.KING:
 409             if (
 410               (deltaX >= 2 || deltaY >= 2) ||
 411               (fm.end.x - fm.start.x != fm.start.x - x) ||
 412               (fm.end.y - fm.start.y != fm.start.y - y)
 413             ) {
 414               return [];
 415             }
 416             break;
 417           case V.BISHOP:
 418             if (deltaX != deltaY) return [];
 419             break;
 420           case V.ROOK:
 421             if (deltaX != 0 && deltaY != 0) return [];
 422             break;
 423           case V.QUEEN:
 424             if (deltaX != deltaY && deltaX != 0 && deltaY != 0) return [];
 425             break;
 426         }
 427         // Nothing should stand between [x, y] and the square fm.start
 428         let [i, j] = [x + dir[0], y + dir[1]];
 429         while (
 430           (i != fm.start.x || j != fm.start.y) &&
 431           this.board[i][j] == V.EMPTY
 432         ) {
 433           i += dir[0];
 434           j += dir[1];
 435         }
 436         if (i == fm.start.x && j == fm.start.y)
 437           return this.getMovesInDirection([x, y], dir);
 438       }
 439       return [];
 440     }
 441     const getPullExit = () => {
 442       // Piece at subTurn 1 exited: can I be pulled?
 443       // Note: kings cannot suicide, so fm.vanish[0].p is not KING.
 444       // Could be PAWN though, if a pawn was pushed out of board.
 445       if (
 446         fm.vanish[0].p != V.PAWN && //pawns cannot pull
 447         this.isAprioriValidExit(
 448           [x, y],
 449           [fm.start.x, fm.start.y],
 450           fm.vanish[0].c,
 451           fm.vanish[0].p
 452         )
 453       ) {
 454         // Seems so:
 455         const dir = this.getNormalizedDirection(
 456           [fm.start.x - x, fm.start.y - y]);
 457         const nbSteps = (fm.vanish[0].p == V.KNIGHT ? 1 : null);
 458         return this.getMovesInDirection([x, y], dir, nbSteps);
 459       }
 460       return [];
 461     };
 462     const getPullMoves = () => {
 463       if (fm.vanish[0].p == V.PAWN)
 464         // pawns cannot pull
 465         return [];
 466       const dirM = this.getNormalizedDirection(
 467         [fm.end.x - fm.start.x, fm.end.y - fm.start.y]);
 468       const dir = this.getNormalizedDirection(
 469         [fm.start.x - x, fm.start.y - y]);
 470       // Normalized directions should match
 471       if (dir[0] == dirM[0] && dir[1] == dirM[1]) {
 472         // Am I at the right distance?
 473         const deltaX = Math.abs(x - fm.start.x);
 474         const deltaY = Math.abs(y - fm.start.y);
 475         if (
 476           (fm.vanish[0].p == V.KING && (deltaX > 1 || deltaY > 1)) ||
 477           (fm.vanish[0].p == V.KNIGHT &&
 478             (deltaX + deltaY != 3 || deltaX == 0 || deltaY == 0))
 479         ) {
 480           return [];
 481         }
 482         // Nothing should stand between [x, y] and the square fm.start
 483         let [i, j] = [x + dir[0], y + dir[1]];
 484         while (
 485           (i != fm.start.x || j != fm.start.y) &&
 486           this.board[i][j] == V.EMPTY
 487         ) {
 488           i += dir[0];
 489           j += dir[1];
 490         }
 491         if (i == fm.start.x && j == fm.start.y)
 492           return this.getMovesInDirection([x, y], dir);
 493       }
 494       return [];
 495     };
 496     if (fm.vanish[0].c != color) {
 497       // Only possible action is a push:
 498       if (fm.appear.length == 0) return getPushExit();
 499       return getPushMoves();
 500     }
 501     else if (sqCol != color) {
 502       // Only possible action is a pull, considering moving piece abilities
 503       if (fm.appear.length == 0) return getPullExit();
 504       return getPullMoves();
 505     }
 506     else {
 507       // My color + my color: both actions possible
 508       // Structure to avoid adding moves twice (can be action & move)
 509       let movesHash = {};
 510       if (fm.appear.length == 0) {
 511         const pushes = getPushExit();
 512         pushes.forEach(m => { movesHash[getMoveHash(m)] = true; });
 513         return (
 514           pushes.concat(getPullExit().filter(m => !movesHash[getMoveHash(m)]))
 515         );
 516       }
 517       const pushes = getPushMoves();
 518       pushes.forEach(m => { movesHash[getMoveHash(m)] = true; });
 519       return (
 520         pushes.concat(getPullMoves().filter(m => !movesHash[getMoveHash(m)]))
 521       );
 522     }
 523     return [];
 524   }
 525
 526   getSlideNJumpMoves([x, y], steps, oneStep) {
 527     let moves = [];
 528     const c = this.getColor(x, y);
 529     const piece = this.getPiece(x, y);
 530     outerLoop: for (let step of steps) {
 531       let i = x + step[0];
 532       let j = y + step[1];
 533       while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
 534         moves.push(this.getBasicMove([x, y], [i, j]));
 535         if (oneStep) continue outerLoop;
 536         i += step[0];
 537         j += step[1];
 538       }
 539       if (V.OnBoard(i, j)) {
 540         if (this.canTake([x, y], [i, j]))
 541           moves.push(this.getBasicMove([x, y], [i, j]));
 542       }
 543       else {
 544         // Add potential board exit (suicide), except for the king
 545         if (piece != V.KING) {
 546           moves.push({
 547             start: { x: x, y: y},
 548             end: { x: this.kingPos[c][0], y: this.kingPos[c][1] },
 549             appear: [],
 550             vanish: [
 551               new PiPo({
 552                 x: x,
 553                 y: y,
 554                 c: c,
 555                 p: piece
 556               })
 557             ]
 558           });
 559         }
 560       }
 561     }
 562     return moves;
 563   }
 564
 565   // Does m2 un-do m1 ? (to disallow undoing actions)
 566   oppositeMoves(m1, m2) {
 567     const isEqual = (av1, av2) => {
 568       for (let av of av1) {
 569         const avInAv2 = av2.find(elt => {
 570           return (
 571             elt.x == av.x &&
 572             elt.y == av.y &&
 573             elt.c == av.c &&
 574             elt.p == av.p
 575           );
 576         });
 577         if (!avInAv2) return false;
 578       }
 579       return true;
 580     };
 581     // All appear and vanish arrays must have the same length
 582     const mL = m1.appear.length;
 583     return (
 584       m2.appear.length == mL &&
 585       m1.vanish.length == mL &&
 586       m2.vanish.length == mL &&
 587       isEqual(m1.appear, m2.vanish) &&
 588       isEqual(m1.vanish, m2.appear)
 589     );
 590   }
 591
 592   getAmove(move1, move2) {
 593     // Just merge (one is action one is move, one may be empty)
 594     return {
 595       appear: move1.appear.concat(move2.appear),
 596       vanish: move1.vanish.concat(move2.vanish)
 597     }
 598   }
 599
 600   filterValid(moves) {
 601     const color = this.turn;
 602     const La = this.amoves.length;
 603     if (this.subTurn == 1) {
 604       return moves.filter(m => {
 605         // A move is valid either if it doesn't result in a check,
 606         // or if a second move is possible to counter the check
 607         // (not undoing a potential move + action of the opponent)
 608         this.play(m);
 609         let res = this.underCheck(color);
 610         if (this.subTurn == 2) {
 611           let isOpposite = La > 0 && this.oppositeMoves(this.amoves[La-1], m);
 612           if (res || isOpposite) {
 613             const moves2 = this.getAllPotentialMoves();
 614             for (let m2 of moves2) {
 615               this.play(m2);
 616               const res2 = this.underCheck(color);
 617               const amove = this.getAmove(m, m2);
 618               isOpposite =
 619                 La > 0 && this.oppositeMoves(this.amoves[La-1], amove);
 620               this.undo(m2);
 621               if (!res2 && !isOpposite) {
 622                 res = false;
 623                 break;
 624               }
 625             }
 626           }
 627         }
 628         this.undo(m);
 629         return !res;
 630       });
 631     }
 632     if (La == 0) return super.filterValid(moves);
 633     const Lf = this.firstMove.length;
 634     return (
 635       super.filterValid(
 636         moves.filter(m => {
 637           // Move shouldn't undo another:
 638           const amove = this.getAmove(this.firstMove[Lf-1], m);
 639           return !this.oppositeMoves(this.amoves[La-1], amove);
 640         })
 641       )
 642     );
 643   }
 644
 645   isAttackedBySlideNJump([x, y], color, piece, steps, oneStep) {
 646     for (let step of steps) {
 647       let rx = x + step[0],
 648           ry = y + step[1];
 649       while (V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && !oneStep) {
 650         rx += step[0];
 651         ry += step[1];
 652       }
 653       if (
 654         V.OnBoard(rx, ry) &&
 655         this.getPiece(rx, ry) == piece &&
 656         this.getColor(rx, ry) == color
 657       ) {
 658         // Continue some steps in the same direction (pull)
 659         rx += step[0];
 660         ry += step[1];
 661         while (
 662           V.OnBoard(rx, ry) &&
 663           this.board[rx][ry] == V.EMPTY &&
 664           !oneStep
 665         ) {
 666           rx += step[0];
 667           ry += step[1];
 668         }
 669         if (!V.OnBoard(rx, ry)) return true;
 670         // Step in the other direction (push)
 671         rx = x - step[0];
 672         ry = y - step[1];
 673         while (
 674           V.OnBoard(rx, ry) &&
 675           this.board[rx][ry] == V.EMPTY &&
 676           !oneStep
 677         ) {
 678           rx -= step[0];
 679           ry -= step[1];
 680         }
 681         if (!V.OnBoard(rx, ry)) return true;
 682       }
 683     }
 684     return false;
 685   }
 686
 687   isAttackedByPawn([x, y], color) {
 688     // The king can be pushed out by a pawn on last rank or near the edge
 689     const pawnShift = (color == "w" ? 1 : -1);
 690     for (let i of [-1, 1]) {
 691       if (
 692         V.OnBoard(x + pawnShift, y + i) &&
 693         this.board[x + pawnShift][y + i] != V.EMPTY &&
 694         this.getPiece(x + pawnShift, y + i) == V.PAWN &&
 695         this.getColor(x + pawnShift, y + i) == color
 696       ) {
 697         if (!V.OnBoard(x - pawnShift, y - i)) return true;
 698       }
 699     }
 700     return false;
 701   }
 702
 703   static OnTheEdge(x, y) {
 704     return (x == 0 || x == 7 || y == 0 || y == 7);
 705   }
 706
 707   isAttackedByKing([x, y], color) {
 708     // Attacked if I'm on the edge and the opponent king just next,
 709     // but not on the edge.
 710     if (V.OnTheEdge(x, y)) {
 711       for (let step of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) {
 712         const [i, j] = [x + step[0], y + step[1]];
 713         if (
 714           V.OnBoard(i, j) &&
 715           !V.OnTheEdge(i, j) &&
 716           this.board[i][j] != V.EMPTY &&
 717           this.getPiece(i, j) == V.KING
 718           // NOTE: since only one king of each color, and (x, y) is occupied
 719           // by our king, no need to check other king's color.
 720         ) {
 721           return true;
 722         }
 723       }
 724     }
 725     return false;
 726   }
 727
 728   // No consideration of color: all pieces could be played
 729   getAllPotentialMoves() {
 730     let potentialMoves = [];
 731     for (let i = 0; i < V.size.x; i++) {
 732       for (let j = 0; j < V.size.y; j++) {
 733         if (this.board[i][j] != V.EMPTY) {
 734           Array.prototype.push.apply(
 735             potentialMoves,
 736             this.getPotentialMovesFrom([i, j])
 737           );
 738         }
 739       }
 740     }
 741     return potentialMoves;
 742   }
 743
 744   getEmptyMove() {
 745     return new Move({
 746       start: { x: -1, y: -1 },
 747       end: { x: -1, y: -1 },
 748       appear: [],
 749       vanish: []
 750     });
 751   }
 752
 753   doClick(square) {
 754     // A click to promote a piece on subTurn 2 would trigger this.
 755     // For now it would then return [NaN, NaN] because surrounding squares
 756     // have no IDs in the promotion modal. TODO: improve this?
 757     if (isNaN(square[0])) return null;
 758     // If subTurn == 2 && square is empty && !underCheck && !isOpposite,
 759     // then return an empty move, allowing to "pass" subTurn2
 760     const La = this.amoves.length;
 761     const Lf = this.firstMove.length;
 762     if (
 763       this.subTurn == 2 &&
 764       this.board[square[0]][square[1]] == V.EMPTY &&
 765       !this.underCheck(this.turn) &&
 766       (La == 0 || !this.oppositeMoves(this.amoves[La-1], this.firstMove[Lf-1]))
 767     ) {
 768       return this.getEmptyMove();
 769     }
 770     return null;
 771   }
 772
 773   play(move) {
 774     if (this.subTurn == 1 && move.vanish.length == 0) {
 775       // Patch to work with old format: (TODO: remove later)
 776       move.ignore = true;
 777       return;
 778     }
 779     const color = this.turn;
 780     move.subTurn = this.subTurn; //for undo
 781     const gotoNext = (mv) => {
 782       const L = this.firstMove.length;
 783       this.amoves.push(this.getAmove(this.firstMove[L-1], mv));
 784       this.turn = V.GetOppCol(color);
 785       this.subTurn = 1;
 786       this.movesCount++;
 787     };
 788     move.flags = JSON.stringify(this.aggregateFlags());
 789     V.PlayOnBoard(this.board, move);
 790     if (this.subTurn == 2) gotoNext(move);
 791     else {
 792       this.subTurn = 2;
 793       this.firstMove.push(move);
 794       this.toNewKingPos(move);
 795       if (
 796         // Condition is true on empty arrays:
 797         this.getAllPotentialMoves().every(m => {
 798           V.PlayOnBoard(this.board, m);
 799           this.toNewKingPos(m);
 800           const res = this.underCheck(color);
 801           V.UndoOnBoard(this.board, m);
 802           this.toOldKingPos(m);
 803           return res;
 804         })
 805       ) {
 806         // No valid move at subTurn 2
 807         gotoNext(this.getEmptyMove());
 808       }
 809       this.toOldKingPos(move);
 810     }
 811     this.postPlay(move);
 812   }
 813
 814   toNewKingPos(move) {
 815     for (let a of move.appear)
 816       if (a.p == V.KING) this.kingPos[a.c] = [a.x, a.y];
 817   }
 818
 819   postPlay(move) {
 820     if (move.start.x < 0) return;
 821     this.toNewKingPos(move);
 822     this.updateCastleFlags(move);
 823   }
 824
 825   updateCastleFlags(move) {
 826     const firstRank = { 'w': V.size.x - 1, 'b': 0 };
 827     for (let v of move.vanish) {
 828       if (v.p == V.KING) this.castleFlags[v.c] = [V.size.y, V.size.y];
 829       else if (v.x == firstRank[v.c] && this.castleFlags[v.c].includes(v.y)) {
 830         const flagIdx = (v.y == this.castleFlags[v.c][0] ? 0 : 1);
 831         this.castleFlags[v.c][flagIdx] = V.size.y;
 832       }
 833     }
 834   }
 835
 836   undo(move) {
 837     if (!!move.ignore) return; //TODO: remove that later
 838     this.disaggregateFlags(JSON.parse(move.flags));
 839     V.UndoOnBoard(this.board, move);
 840     if (this.subTurn == 1) {
 841       this.amoves.pop();
 842       this.turn = V.GetOppCol(this.turn);
 843       this.movesCount--;
 844     }
 845     if (move.subTurn == 1) this.firstMove.pop();
 846     this.subTurn = move.subTurn;
 847     this.toOldKingPos(move);
 848   }
 849
 850   toOldKingPos(move) {
 851     // (Potentially) Reset king position
 852     for (let v of move.vanish)
 853       if (v.p == V.KING) this.kingPos[v.c] = [v.x, v.y];
 854   }
 855
 856   getComputerMove() {
 857     let moves = this.getAllValidMoves();
 858     if (moves.length == 0) return null;
 859     // "Search" at depth 1 for now
 860     const maxeval = V.INFINITY;
 861     const color = this.turn;
 862     const emptyMove = {
 863       start: { x: -1, y: -1 },
 864       end: { x: -1, y: -1 },
 865       appear: [],
 866       vanish: []
 867     };
 868     moves.forEach(m => {
 869       this.play(m);
 870       if (this.turn != color) m.eval = this.evalPosition();
 871       else {
 872         m.eval = (color == "w" ? -1 : 1) * maxeval;
 873         const moves2 = this.getAllValidMoves().concat([emptyMove]);
 874         m.next = moves2[0];
 875         moves2.forEach(m2 => {
 876           this.play(m2);
 877           const score = this.getCurrentScore();
 878           let mvEval = 0;
 879           if (score != "1/2") {
 880             if (score != "*") mvEval = (score == "1-0" ? 1 : -1) * maxeval;
 881             else mvEval = this.evalPosition();
 882           }
 883           if (
 884             (color == 'w' && mvEval > m.eval) ||
 885             (color == 'b' && mvEval < m.eval)
 886           ) {
 887             m.eval = mvEval;
 888             m.next = m2;
 889           }
 890           this.undo(m2);
 891         });
 892       }
 893       this.undo(m);
 894     });
 895     moves.sort((a, b) => {
 896       return (color == "w" ? 1 : -1) * (b.eval - a.eval);
 897     });
 898     let candidates = [0];
 899     for (let i = 1; i < moves.length && moves[i].eval == moves[0].eval; i++)
 900       candidates.push(i);
 901     const mIdx = candidates[randInt(candidates.length)];
 902     if (!moves[mIdx].next) return moves[mIdx];
 903     const move2 = moves[mIdx].next;
 904     delete moves[mIdx]["next"];
 905     return [moves[mIdx], move2];
 906   }
 907
 908   getNotation(move) {
 909     if (move.start.x < 0)
 910       // A second move is always required, but may be empty
 911       return "-";
 912     const initialSquare = V.CoordsToSquare(move.start);
 913     const finalSquare = V.CoordsToSquare(move.end);
 914     if (move.appear.length == 0)
 915       // Pushed or pulled out of the board
 916       return initialSquare + "R";
 917     return move.appear[0].p.toUpperCase() + initialSquare + finalSquare;
 918   }
 919
 920 };