client/src/variants/Convert.js

   1 import { ChessRules, PiPo, Move } from "@/base_rules";
   2 import { randInt } from "@/utils/alea";
   3
   4 export class ConvertRules extends ChessRules {
   5
   6   static get HasEnpassant() {
   7     return false;
   8   }
   9
  10   setOtherVariables(fen) {
  11     super.setOtherVariables(fen);
  12     // Stack of "last move" only for intermediate chaining
  13     this.lastMoveEnd = [null];
  14   }
  15
  16   static GenRandInitFen(randomness) {
  17     if (randomness == 0)
  18       return "rnbqkbnr/8/pppppppp/8/8/PPPPPPPP/8/RNBQKBNR w 0 ahah";
  19     const baseFen = ChessRules.GenRandInitFen(randomness);
  20     return (
  21       baseFen.substr(0, 8) +
  22       "/8/pppppppp/8/8/PPPPPPPP/8/" +
  23       baseFen.substr(35, 17)
  24     );
  25   }
  26
  27   getBasicMove([sx, sy], [ex, ey], tr) {
  28     const L = this.lastMoveEnd.length;
  29     const lm = this.lastMoveEnd[L-1];
  30     const piece = (!!lm ? lm.p : null);
  31     const c = this.turn;
  32     if (this.board[ex][ey] == V.EMPTY) {
  33       if (!!piece && !tr) tr = { c: c, p: piece }
  34       let mv = super.getBasicMove([sx, sy], [ex, ey], tr);
  35       if (!!piece) mv.vanish.pop();
  36       return mv;
  37     }
  38     // Capture: initial, or inside a chain
  39     const initPiece = (piece || this.getPiece(sx, sy));
  40     const oppCol = V.GetOppCol(c);
  41     const oppPiece = this.getPiece(ex, ey);
  42     let mv = new Move({
  43       start: { x: sx, y: sy },
  44       end: { x: ex, y: ey },
  45       appear: [
  46         new PiPo({
  47           x: ex,
  48           y: ey,
  49           c: c,
  50           p: (!!tr ? tr.p : initPiece)
  51         })
  52       ],
  53       vanish: [
  54         new PiPo({
  55           x: ex,
  56           y: ey,
  57           c: oppCol,
  58           p: oppPiece
  59         })
  60       ]
  61     });
  62     if (!piece) {
  63       // Initial capture
  64       mv.vanish.unshift(
  65         new PiPo({
  66           x: sx,
  67           y: sy,
  68           c: c,
  69           p: initPiece
  70         })
  71       );
  72     }
  73     // TODO: This "converted" indication isn't needed in fact,
  74     // because it can be deduced from the move itself.
  75     mv.end.converted = oppPiece;
  76     return mv;
  77   }
  78
  79   getPotentialMovesFrom([x, y], asA) {
  80     const L = this.lastMoveEnd.length;
  81     if (!!this.lastMoveEnd[L-1]) {
  82       if (x != this.lastMoveEnd[L-1].x || y != this.lastMoveEnd[L-1].y)
  83         // A capture was played: wrong square
  84         return [];
  85       asA = this.lastMoveEnd[L-1].p;
  86     }
  87     switch (asA || this.getPiece(x, y)) {
  88       case V.PAWN: return super.getPotentialPawnMoves([x, y]);
  89       case V.ROOK: return super.getPotentialRookMoves([x, y]);
  90       case V.KNIGHT: return super.getPotentialKnightMoves([x, y]);
  91       case V.BISHOP: return super.getPotentialBishopMoves([x, y]);
  92       case V.QUEEN: return super.getPotentialQueenMoves([x, y]);
  93       case V.KING: return super.getPotentialKingMoves([x, y]);
  94     }
  95     return [];
  96   }
  97
  98   getPossibleMovesFrom(sq) {
  99     const L = this.lastMoveEnd.length;
 100     let asA = undefined;
 101     if (!!this.lastMoveEnd[L-1]) {
 102       if (
 103         sq[0] != this.lastMoveEnd[L-1].x ||
 104         sq[1] != this.lastMoveEnd[L-1].y
 105       ) {
 106         return [];
 107       }
 108       asA = this.lastMoveEnd[L-1].p;
 109     }
 110     return this.filterValid(this.getPotentialMovesFrom(sq, asA));
 111   }
 112
 113   isAttacked_aux([x, y], color, explored) {
 114     if (explored.some(sq => sq[0] == x && sq[1] == y))
 115       // Start of an infinite loop: exit
 116       return false;
 117     explored.push([x, y]);
 118     if (super.isAttacked([x, y], color)) return true;
 119     // Maybe indirect "chaining" attack:
 120     const myColor = this.turn
 121     let res = false;
 122     let toCheck = []; //check all but king (no need)
 123     // Pawns:
 124     const shiftToPawn = (myColor == 'w' ? -1 : 1);
 125     for (let yShift of [-1, 1]) {
 126       const [i, j] = [x + shiftToPawn, y + yShift];
 127       if (
 128         V.OnBoard(i, j) &&
 129         this.board[i][j] != V.EMPTY &&
 130         // NOTE: no need to check color (no enemy pawn can take directly)
 131         this.getPiece(i, j) == V.PAWN
 132       ) {
 133         toCheck.push([i, j]);
 134       }
 135     }
 136     // Knights:
 137     V.steps[V.KNIGHT].forEach(s => {
 138       const [i, j] = [x + s[0], y + s[1]];
 139       if (
 140         V.OnBoard(i, j) &&
 141         this.board[i][j] != V.EMPTY &&
 142         this.getPiece(i, j) == V.KNIGHT
 143       ) {
 144         toCheck.push([i, j]);
 145       }
 146     });
 147     // Sliders:
 148     V.steps[V.ROOK].concat(V.steps[V.BISHOP]).forEach(s => {
 149       let [i, j] = [x + s[0], y + s[1]];
 150       while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
 151         i += s[0];
 152         j += s[1];
 153       }
 154       if (!V.OnBoard(i, j)) return;
 155       const piece = this.getPiece(i, j);
 156       if (
 157         piece == V.QUEEN ||
 158         (piece == V.ROOK && (s[0] == 0 || s[1] == 0)) ||
 159         (piece == V.BISHOP && (s[0] != 0 && s[1] != 0))
 160       ) {
 161         toCheck.push([i, j]);
 162       }
 163     });
 164     for (let ij of toCheck) {
 165       if (this.isAttacked_aux(ij, color, explored)) return true;
 166     }
 167     return false;
 168   }
 169
 170   isAttacked([x, y], color) {
 171     let explored = [];
 172     return this.isAttacked_aux([x, y], color, explored);
 173   }
 174
 175   filterValid(moves) {
 176     // No "checks" (except to forbid castle)
 177     return moves;
 178   }
 179
 180   getCheckSquares() {
 181     return [];
 182   }
 183
 184   prePlay(move) {
 185     const c = this.turn;
 186     // Extra conditions to avoid tracking converted kings:
 187     if (
 188       move.appear[0].p == V.KING &&
 189       move.vanish.length >= 1 &&
 190       move.vanish[0].p == V.KING
 191     ) {
 192       this.kingPos[c][0] = move.appear[0].x;
 193       this.kingPos[c][1] = move.appear[0].y;
 194     }
 195   }
 196
 197   play(move) {
 198     this.prePlay(move);
 199     const c = this.turn;
 200     move.flags = JSON.stringify(this.aggregateFlags());
 201     V.PlayOnBoard(this.board, move);
 202     if (!move.end.converted) {
 203       // Not a capture: change turn
 204       this.turn = V.GetOppCol(this.turn);
 205       this.movesCount++;
 206       this.lastMoveEnd.push(null);
 207     }
 208     else {
 209       this.lastMoveEnd.push(
 210         Object.assign({}, move.end, { p: move.end.converted })
 211       );
 212     }
 213     super.updateCastleFlags(move, move.appear[0].p, c);
 214   }
 215
 216   undo(move) {
 217     this.disaggregateFlags(JSON.parse(move.flags));
 218     this.lastMoveEnd.pop();
 219     V.UndoOnBoard(this.board, move);
 220     if (!move.end.converted) {
 221       this.turn = V.GetOppCol(this.turn);
 222       this.movesCount--;
 223     }
 224     this.postUndo(move);
 225   }
 226
 227   postUndo(move) {
 228     const c = this.getColor(move.start.x, move.start.y);
 229     if (
 230       move.appear[0].p == V.KING &&
 231       move.vanish.length >= 1 &&
 232       move.vanish[0].p == V.KING
 233     ) {
 234       this.kingPos[c] = [move.start.x, move.start.y];
 235     }
 236   }
 237
 238   getCurrentScore() {
 239     const color = this.turn;
 240     const kp = this.kingPos[color];
 241     if (this.getColor(kp[0], kp[1]) != color)
 242       return (color == "w" ? "0-1" : "1-0");
 243     if (!super.atLeastOneMove()) return "1/2";
 244     return "*";
 245   }
 246
 247   getComputerMove() {
 248     let initMoves = this.getAllValidMoves();
 249     if (initMoves.length == 0) return null;
 250     // Loop until valid move is found (no blocked pawn conversion...)
 251     while (true) {
 252       let moves = JSON.parse(JSON.stringify(initMoves));
 253       let mvArray = [];
 254       let mv = null;
 255       // Just play random moves (for now at least. TODO?)
 256       while (moves.length > 0) {
 257         mv = moves[randInt(moves.length)];
 258         mvArray.push(mv);
 259         this.play(mv);
 260         if (!!mv.end.converted)
 261           // A piece was just converted
 262           moves = this.getPotentialMovesFrom([mv.end.x, mv.end.y]);
 263         else break;
 264       }
 265       for (let i = mvArray.length - 1; i >= 0; i--) this.undo(mvArray[i]);
 266       if (!mv.end.converted) return (mvArray.length > 1 ? mvArray : mvArray[0]);
 267     }
 268     return null; //never reached
 269   }
 270
 271   getNotation(move) {
 272     if (move.appear.length == 2 && move.appear[0].p == V.KING)
 273       return (move.end.y < move.start.y ? "0-0-0" : "0-0");
 274     const c = this.turn;
 275     const L = this.lastMoveEnd.length;
 276     const lm = this.lastMoveEnd[L-1];
 277     const piece = (!lm ? move.appear[0].p : lm.p);
 278     // Basic move notation:
 279     let notation = piece.toUpperCase();
 280     if (
 281       this.board[move.end.x][move.end.y] != V.EMPTY ||
 282       (piece == V.PAWN && move.start.y != move.end.y)
 283     ) {
 284       notation += "x";
 285     }
 286     const finalSquare = V.CoordsToSquare(move.end);
 287     notation += finalSquare;
 288
 289     // Add potential promotion indications:
 290     const firstLastRank = (c == 'w' ? [7, 0] : [0, 7]);
 291     if (move.end.x == firstLastRank[1] && piece == V.PAWN)
 292       notation += "=" + move.appear[0].p.toUpperCase();
 293     return notation;
 294   }
 295
 296 };