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