client/src/variants/Alice.js

   1 import { ChessRules } from "@/base_rules";
   2 import { ArrayFun } from "@/utils/array";
   3
   4 // NOTE: alternative implementation, probably cleaner = use only 1 board
   5 // TODO? atLeastOneMove() would be more efficient if rewritten here
   6 // (less sideBoard computations)
   7 export class AliceRules extends ChessRules {
   8   static get ALICE_PIECES() {
   9     return {
  10       s: "p",
  11       t: "q",
  12       u: "r",
  13       c: "b",
  14       o: "n",
  15       l: "k"
  16     };
  17   }
  18   static get ALICE_CODES() {
  19     return {
  20       p: "s",
  21       q: "t",
  22       r: "u",
  23       b: "c",
  24       n: "o",
  25       k: "l"
  26     };
  27   }
  28
  29   static get PIECES() {
  30     return ChessRules.PIECES.concat(Object.keys(V.ALICE_PIECES));
  31   }
  32
  33   getPpath(b) {
  34     return (Object.keys(V.ALICE_PIECES).includes(b[1]) ? "Alice/" : "") + b;
  35   }
  36
  37   getEpSquare(moveOrSquare) {
  38     if (!moveOrSquare) return undefined;
  39     if (typeof moveOrSquare === "string") {
  40       const square = moveOrSquare;
  41       if (square == "-") return undefined;
  42       return V.SquareToCoords(square);
  43     }
  44     // Argument is a move:
  45     const move = moveOrSquare;
  46     const s = move.start,
  47           e = move.end;
  48     if (
  49       s.y == e.y &&
  50       Math.abs(s.x - e.x) == 2 &&
  51       // Special conditions: a pawn can be on the other side
  52       ['p','s'].includes(move.appear[0].p) &&
  53       ['p','s'].includes(move.vanish[0].p)
  54     ) {
  55       return {
  56         x: (s.x + e.x) / 2,
  57         y: s.y
  58       };
  59     }
  60     return undefined; //default
  61   }
  62
  63   setOtherVariables(fen) {
  64     super.setOtherVariables(fen);
  65     const rows = V.ParseFen(fen).position.split("/");
  66     if (this.kingPos["w"][0] < 0 || this.kingPos["b"][0] < 0) {
  67       // INIT_COL_XXX won't be required if Alice kings are found
  68       // (it means 'king moved')
  69       for (let i = 0; i < rows.length; i++) {
  70         let k = 0; //column index on board
  71         for (let j = 0; j < rows[i].length; j++) {
  72           switch (rows[i].charAt(j)) {
  73             case "l":
  74               this.kingPos["b"] = [i, k];
  75               break;
  76             case "L":
  77               this.kingPos["w"] = [i, k];
  78               break;
  79             default: {
  80               const num = parseInt(rows[i].charAt(j));
  81               if (!isNaN(num)) k += num - 1;
  82             }
  83           }
  84           k++;
  85         }
  86       }
  87     }
  88   }
  89
  90   // Return the (standard) color+piece notation at a square for a board
  91   getSquareOccupation(i, j, mirrorSide) {
  92     const piece = this.getPiece(i, j);
  93     if (mirrorSide == 1 && Object.keys(V.ALICE_CODES).includes(piece))
  94       return this.board[i][j];
  95     if (mirrorSide == 2 && Object.keys(V.ALICE_PIECES).includes(piece))
  96       return this.getColor(i, j) + V.ALICE_PIECES[piece];
  97     return "";
  98   }
  99
 100   // Build board of the given (mirror)side
 101   getSideBoard(mirrorSide) {
 102     // Build corresponding board from complete board
 103     let sideBoard = ArrayFun.init(V.size.x, V.size.y, "");
 104     for (let i = 0; i < V.size.x; i++) {
 105       for (let j = 0; j < V.size.y; j++)
 106         sideBoard[i][j] = this.getSquareOccupation(i, j, mirrorSide);
 107     }
 108     return sideBoard;
 109   }
 110
 111   // NOTE: castle & enPassant
 112   // https://www.chessvariants.com/other.dir/alice.html
 113   getPotentialMovesFrom([x, y], sideBoard) {
 114     const pieces = Object.keys(V.ALICE_CODES);
 115     const codes = Object.keys(V.ALICE_PIECES);
 116     const mirrorSide = pieces.includes(this.getPiece(x, y)) ? 1 : 2;
 117     if (!sideBoard) sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
 118     const color = this.getColor(x, y);
 119
 120     // Search valid moves on sideBoard
 121     const saveBoard = this.board;
 122     this.board = sideBoard[mirrorSide - 1];
 123     const moves = super.getPotentialMovesFrom([x, y]).filter(m => {
 124       // Filter out king moves which result in under-check position on
 125       // current board (before mirror traversing)
 126       let aprioriValid = true;
 127       if (m.appear[0].p == V.KING) {
 128         this.play(m);
 129         if (this.underCheck(color, sideBoard)) aprioriValid = false;
 130         this.undo(m);
 131       }
 132       return aprioriValid;
 133     });
 134     this.board = saveBoard;
 135
 136     // Finally filter impossible moves
 137     const res = moves.filter(m => {
 138       if (m.appear.length == 2) {
 139         // Castle: appear[i] must be an empty square on the other board
 140         for (let psq of m.appear) {
 141           if (
 142             this.getSquareOccupation(psq.x, psq.y, 3 - mirrorSide) != V.EMPTY
 143           ) {
 144             return false;
 145           }
 146         }
 147       } else if (this.board[m.end.x][m.end.y] != V.EMPTY) {
 148         // Attempt to capture
 149         const piece = this.getPiece(m.end.x, m.end.y);
 150         if (
 151           (mirrorSide == 1 && codes.includes(piece)) ||
 152           (mirrorSide == 2 && pieces.includes(piece))
 153         ) {
 154           return false;
 155         }
 156       }
 157       // If the move is computed on board1, m.appear change for Alice pieces.
 158       if (mirrorSide == 1) {
 159         m.appear.forEach(psq => {
 160           // forEach: castling taken into account
 161           psq.p = V.ALICE_CODES[psq.p]; //goto board2
 162         });
 163       }
 164       else {
 165         // Move on board2: mark vanishing pieces as Alice
 166         m.vanish.forEach(psq => {
 167           psq.p = V.ALICE_CODES[psq.p];
 168         });
 169       }
 170       // Fix en-passant captures
 171       if (
 172         m.vanish[0].p == V.PAWN &&
 173         m.vanish.length == 2 &&
 174         this.board[m.end.x][m.end.y] == V.EMPTY
 175       ) {
 176         m.vanish[1].c = V.GetOppCol(this.getColor(x, y));
 177         // In the special case of en-passant, if
 178         //  - board1 takes board2 : vanish[1] --> Alice
 179         //  - board2 takes board1 : vanish[1] --> normal
 180         let van = m.vanish[1];
 181         if (mirrorSide == 1 && codes.includes(this.getPiece(van.x, van.y)))
 182           van.p = V.ALICE_CODES[van.p];
 183         else if (
 184           mirrorSide == 2 &&
 185           pieces.includes(this.getPiece(van.x, van.y))
 186         )
 187           van.p = V.ALICE_PIECES[van.p];
 188       }
 189       return true;
 190     });
 191     return res;
 192   }
 193
 194   filterValid(moves, sideBoard) {
 195     if (moves.length == 0) return [];
 196     if (!sideBoard) sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
 197     const color = this.turn;
 198     return moves.filter(m => {
 199       this.playSide(m, sideBoard); //no need to track flags
 200       const res = !this.underCheck(color, sideBoard);
 201       this.undoSide(m, sideBoard);
 202       return res;
 203     });
 204   }
 205
 206   getAllValidMoves() {
 207     const color = this.turn;
 208     let potentialMoves = [];
 209     const sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
 210     for (var i = 0; i < V.size.x; i++) {
 211       for (var j = 0; j < V.size.y; j++) {
 212         if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) {
 213           Array.prototype.push.apply(
 214             potentialMoves,
 215             this.getPotentialMovesFrom([i, j], sideBoard)
 216           );
 217         }
 218       }
 219     }
 220     return this.filterValid(potentialMoves, sideBoard);
 221   }
 222
 223   // Play on sideboards [TODO: only one sideBoard required]
 224   playSide(move, sideBoard) {
 225     const pieces = Object.keys(V.ALICE_CODES);
 226     move.vanish.forEach(psq => {
 227       const mirrorSide = pieces.includes(psq.p) ? 1 : 2;
 228       sideBoard[mirrorSide - 1][psq.x][psq.y] = V.EMPTY;
 229     });
 230     move.appear.forEach(psq => {
 231       const mirrorSide = pieces.includes(psq.p) ? 1 : 2;
 232       const piece = mirrorSide == 1 ? psq.p : V.ALICE_PIECES[psq.p];
 233       sideBoard[mirrorSide - 1][psq.x][psq.y] = psq.c + piece;
 234       if (piece == V.KING) this.kingPos[psq.c] = [psq.x, psq.y];
 235     });
 236   }
 237
 238   // Undo on sideboards
 239   undoSide(move, sideBoard) {
 240     const pieces = Object.keys(V.ALICE_CODES);
 241     move.appear.forEach(psq => {
 242       const mirrorSide = pieces.includes(psq.p) ? 1 : 2;
 243       sideBoard[mirrorSide - 1][psq.x][psq.y] = V.EMPTY;
 244     });
 245     move.vanish.forEach(psq => {
 246       const mirrorSide = pieces.includes(psq.p) ? 1 : 2;
 247       const piece = mirrorSide == 1 ? psq.p : V.ALICE_PIECES[psq.p];
 248       sideBoard[mirrorSide - 1][psq.x][psq.y] = psq.c + piece;
 249       if (piece == V.KING) this.kingPos[psq.c] = [psq.x, psq.y];
 250     });
 251   }
 252
 253   // sideBoard: arg containing both boards (see getAllValidMoves())
 254   underCheck(color, sideBoard) {
 255     const kp = this.kingPos[color];
 256     const mirrorSide = sideBoard[0][kp[0]][kp[1]] != V.EMPTY ? 1 : 2;
 257     let saveBoard = this.board;
 258     this.board = sideBoard[mirrorSide - 1];
 259     let res = this.isAttacked(kp, [V.GetOppCol(color)]);
 260     this.board = saveBoard;
 261     return res;
 262   }
 263
 264   getCheckSquares() {
 265     const color = this.turn;
 266     const pieces = Object.keys(V.ALICE_CODES);
 267     const kp = this.kingPos[color];
 268     const mirrorSide = pieces.includes(this.getPiece(kp[0], kp[1])) ? 1 : 2;
 269     let sideBoard = this.getSideBoard(mirrorSide);
 270     let saveBoard = this.board;
 271     this.board = sideBoard;
 272     let res = this.isAttacked(this.kingPos[color], [V.GetOppCol(color)])
 273       ? [JSON.parse(JSON.stringify(this.kingPos[color]))]
 274       : [];
 275     this.board = saveBoard;
 276     return res;
 277   }
 278
 279   postPlay(move) {
 280     super.postPlay(move); //standard king
 281     const piece = move.vanish[0].p;
 282     const c = move.vanish[0].c;
 283     // "l" = Alice king
 284     if (piece == "l") {
 285       this.kingPos[c][0] = move.appear[0].x;
 286       this.kingPos[c][1] = move.appear[0].y;
 287       this.castleFlags[c] = [8, 8];
 288     }
 289   }
 290
 291   postUndo(move) {
 292     super.postUndo(move);
 293     const c = move.vanish[0].c;
 294     if (move.vanish[0].p == "l")
 295       this.kingPos[c] = [move.start.x, move.start.y];
 296   }
 297
 298   getCurrentScore() {
 299     if (this.atLeastOneMove()) return "*";
 300     const pieces = Object.keys(V.ALICE_CODES);
 301     const color = this.turn;
 302     const kp = this.kingPos[color];
 303     const mirrorSide = pieces.includes(this.getPiece(kp[0], kp[1])) ? 1 : 2;
 304     let sideBoard = this.getSideBoard(mirrorSide);
 305     let saveBoard = this.board;
 306     this.board = sideBoard;
 307     let res = "*";
 308     if (!this.isAttacked(this.kingPos[color], [V.GetOppCol(color)]))
 309       res = "1/2";
 310     else res = color == "w" ? "0-1" : "1-0";
 311     this.board = saveBoard;
 312     return res;
 313   }
 314
 315   static get VALUES() {
 316     return Object.assign(
 317       {
 318         s: 1,
 319         u: 5,
 320         o: 3,
 321         c: 3,
 322         t: 9,
 323         l: 1000
 324       },
 325       ChessRules.VALUES
 326     );
 327   }
 328
 329   static get SEARCH_DEPTH() {
 330     return 2;
 331   }
 332
 333   getNotation(move) {
 334     if (move.appear.length == 2 && move.appear[0].p == V.KING) {
 335       if (move.end.y < move.start.y) return "0-0-0";
 336       return "0-0";
 337     }
 338
 339     const finalSquare = V.CoordsToSquare(move.end);
 340     const piece = this.getPiece(move.start.x, move.start.y);
 341
 342     const captureMark = move.vanish.length > move.appear.length ? "x" : "";
 343     let pawnMark = "";
 344     if (["p", "s"].includes(piece) && captureMark.length == 1)
 345       pawnMark = V.CoordToColumn(move.start.y); //start column
 346
 347     // Piece or pawn movement
 348     let notation = piece.toUpperCase() + pawnMark + captureMark + finalSquare;
 349     if (["s", "p"].includes(piece) && !["s", "p"].includes(move.appear[0].p)) {
 350       // Promotion
 351       notation += "=" + move.appear[0].p.toUpperCase();
 352     }
 353     return notation;
 354   }
 355 };