client/src/variants/Avalanche.js

   1 import { ChessRules, Move, PiPo } from "@/base_rules";
   2 import { randInt } from "@/utils/alea";
   3
   4 export class AvalancheRules extends ChessRules {
   5
   6   static get PawnSpecs() {
   7     return (
   8       Object.assign(
   9         { promotions: [V.PAWN] },
  10         ChessRules.PawnSpecs
  11       )
  12     );
  13   }
  14
  15   static get HasEnpassant() {
  16     return false;
  17   }
  18
  19   static IsGoodFen(fen) {
  20     if (!ChessRules.IsGoodFen(fen)) return false;
  21     const fenParts = fen.split(" ");
  22     if (fenParts.length != 5) return false;
  23     if (!fenParts[4].match(/^[0-8]$/)) return false;
  24     return true;
  25   }
  26
  27   canIplay(side, [x, y]) {
  28     if (this.subTurn == 0) return (x >= V.size.x);
  29     const c = this.getColor(x, y);
  30     return (
  31       (this.subTurn == 1 && c == side) ||
  32       (this.subTurn == 2 && c != side && this.getPiece(x, y) == V.PAWN)
  33     );
  34   }
  35
  36   static ParseFen(fen) {
  37     const fenParts = fen.split(" ");
  38     return Object.assign(
  39       ChessRules.ParseFen(fen),
  40       { promoteFile: fenParts[4] }
  41     );
  42   }
  43
  44   getPromoteFen() {
  45     const L = this.promoteFile.length;
  46     return (this.promoteFile[L-1] + 1);
  47   }
  48
  49   getFen() {
  50     return super.getFen() + " " + this.getPromoteFen();
  51   }
  52
  53   getFenForRepeat() {
  54     return super.getFenForRepeat() + "_" + this.getPromoteFen();
  55   }
  56
  57   static GenRandInitFen(randomness) {
  58     return ChessRules.GenRandInitFen(randomness).slice(0, -1) + "0";
  59   }
  60
  61   getPiece(i, j) {
  62     if (i >= V.size.x) return V.RESERVE_PIECES[j];
  63     return this.board[i][j].charAt(1);
  64   }
  65
  66   static get RESERVE_PIECES() {
  67     // Promotion pieces
  68     return [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN];
  69   }
  70
  71   setOtherVariables(fen) {
  72     super.setOtherVariables(fen);
  73     const fenPromoteFile = V.ParseFen(fen).promoteFile;
  74     this.promoteFile = [parseInt(fenPromoteFile, 10) - 1];
  75     this.reserve = { 'w': null, 'b': null };
  76     if (this.promoteFile[0] >= 0) {
  77       this.reserve = {
  78         [this.turn]: {
  79           [V.ROOK]: 1,
  80           [V.KNIGHT]: 1,
  81           [V.BISHOP]: 1,
  82           [V.QUEEN]: 1
  83         }
  84       };
  85       this.subTurn = 0;
  86     }
  87     else this.subTurn = 1;
  88   }
  89
  90   getReservePpath(index, color) {
  91     return color + V.RESERVE_PIECES[index];
  92   }
  93
  94   getReserveMove(y) {
  95     // Send a new piece piece to our first rank
  96     const color = this.turn;
  97     const L = this.promoteFile.length;
  98     const [rank, file] = [color == 'w' ? 0 : 7, this.promoteFile[L-1]];
  99     return new Move({
 100       appear: [
 101         new PiPo({ x: rank, y: file, c: color, p: V.RESERVE_PIECES[y] })
 102       ],
 103       vanish: [
 104         new PiPo({ x: rank, y: file, c: color, p: V.PAWN })
 105       ],
 106       start: { x: 8, y: y },
 107       end: { x: rank, y: file }
 108     });
 109   }
 110
 111   getPotentialMovesFrom([x, y]) {
 112     if (this.subTurn == 0)
 113       // Reserves, outside of board: x == sizeX(+1)
 114       return (x >= 8 ? [this.getReserveMove(y)] : []);
 115     if (this.subTurn == 1)
 116       // Usual case:
 117       return super.getPotentialMovesFrom([x, y]);
 118     // subTurn == 2: only allowed to push an opponent's pawn (if possible)
 119     const oppPawnShift = (this.turn == 'w' ? 1 : -1);
 120     if (
 121       V.OnBoard(x + oppPawnShift, y) &&
 122       this.board[x + oppPawnShift][y] == V.EMPTY
 123     ) {
 124       return [this.getBasicMove([x, y], [x + oppPawnShift, y])];
 125     }
 126     return [];
 127   }
 128
 129   getAllValidMoves() {
 130     if (this.subTurn == 0) {
 131       let moves = [];
 132       for (let y = 0; y < V.RESERVE_PIECES.length; y++)
 133         moves.push(this.getReserveMove(y));
 134       return moves;
 135     }
 136     if (this.subTurn == 1)
 137       return this.filterValid(super.getAllPotentialMoves());
 138     // subTurn == 2: move opponent's pawn only
 139     let moves = [];
 140     const oppCol = V.GetOppCol(this.turn);
 141     for (let i = 0; i < 8; i++) {
 142       for (let j = 0; j < 8; j++) {
 143         if (
 144           this.board[i][j] != V.EMPTY &&
 145           this.getColor(i, j) == oppCol &&
 146           this.getPiece(i, j) == V.PAWN
 147         ) {
 148           Array.prototype.push.apply(
 149             moves, this.getPotentialMovesFrom([i, j]));
 150         }
 151       }
 152     }
 153     return moves;
 154   }
 155
 156   filterValid(moves) {
 157     if (this.subTurn != 1) return moves; //self-checks by pawns are allowed
 158     return super.filterValid(moves);
 159   }
 160
 161   atLeastOneMove() {
 162     if (this.subTurn == 0) return true; //TODO: never called in this situation
 163     if (this.subTurn == 1) {
 164       // Cannot use super method: infinite recursive calls
 165       const color = this.turn;
 166       for (let i = 0; i < 8; i++) {
 167         for (let j = 0; j < 8; j++) {
 168           if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) {
 169             const moves = this.getPotentialMovesFrom([i, j]);
 170             if (moves.length > 0) {
 171               for (let k = 0; k < moves.length; k++) {
 172                 const piece = moves[k].vanish[0].p;
 173                 if (piece == V.KING) {
 174                   this.kingPos[color] =
 175                     [moves[k].appear[0].x, moves[k].appear[0].y];
 176                 }
 177                 V.PlayOnBoard(this.board, moves[k]);
 178                 const res = !this.underCheck(color);
 179                 V.UndoOnBoard(this.board, moves[k]);
 180                 if (piece == V.KING) {
 181                   this.kingPos[color] =
 182                     [moves[k].vanish[0].x, moves[k].vanish[0].y];
 183                 }
 184                 if (res) return true;
 185               }
 186             }
 187           }
 188         }
 189       }
 190       return false;
 191     }
 192     // subTurn == 2: need to find an enemy pawn which can advance
 193     const oppCol = V.GetOppCol(this.turn);
 194     const oppPawnShift = (oppCol == 'w' ? -1 : 1);
 195     for (let i = 0; i < 8; i++) {
 196       for (let j = 0; j < 8; j++) {
 197         if (
 198           this.board[i][j] != V.EMPTY &&
 199           this.getColor(i, j) == oppCol &&
 200           this.getPiece(i, j) == V.PAWN &&
 201           V.OnBoard(i + oppPawnShift, j) &&
 202           this.board[i + oppPawnShift][j] == V.EMPTY
 203         ) {
 204           return true;
 205         }
 206       }
 207     }
 208     return false;
 209   }
 210
 211   getCheckSquares() {
 212     if (this.kingPos[this.turn][0] < 0) return [];
 213     return super.getCheckSquares();
 214   }
 215
 216   getCurrentScore() {
 217     // If my king disappeared: I lost!
 218     const c = this.turn;
 219     if (this.kingPos[c][0] < 0) return (c == 'w' ? "0-1" : "1-0");
 220     return super.getCurrentScore();
 221   }
 222
 223   prePlay(move) {
 224     if (this.subTurn != 1) return;
 225     const c = move.vanish[0].c;
 226     const piece = move.vanish[0].p;
 227     const firstRank = c == "w" ? V.size.x - 1 : 0;
 228     if (piece == V.KING) {
 229       this.kingPos[c] = [move.appear[0].x, move.appear[0].y];
 230       this.castleFlags[c] = [V.size.y, V.size.y];
 231       return;
 232     }
 233     const oppCol = V.GetOppCol(c);
 234     if (move.vanish.length == 2 && move.vanish[1].p == V.KING) {
 235       // Opponent's king is captured, game over
 236       this.kingPos[oppCol] = [-1, -1];
 237       move.captureKing = true;
 238     }
 239     const oppFirstRank = V.size.x - 1 - firstRank;
 240     if (
 241       move.start.x == firstRank && //our rook moves?
 242       this.castleFlags[c].includes(move.start.y)
 243     ) {
 244       const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1);
 245       this.castleFlags[c][flagIdx] = V.size.y;
 246     }
 247     if (
 248       move.end.x == oppFirstRank && //we took opponent rook?
 249       this.castleFlags[oppCol].includes(move.end.y)
 250     ) {
 251       const flagIdx = (move.end.y == this.castleFlags[oppCol][0] ? 0 : 1);
 252       this.castleFlags[oppCol][flagIdx] = V.size.y;
 253     }
 254   }
 255
 256   play(move) {
 257     move.flags = JSON.stringify(this.aggregateFlags());
 258     this.prePlay(move);
 259     V.PlayOnBoard(this.board, move);
 260     const c = this.turn;
 261     move.turn = [c, this.subTurn];
 262     const oppCol = V.GetOppCol(c);
 263     const oppLastRank = (c == 'w' ? 7 : 0);
 264     if (this.subTurn <= 1) this.reserve[oppCol] = null;
 265     if (this.subTurn == 0) {
 266       this.subTurn++;
 267       this.reserve[c] = null;
 268     }
 269     else if (this.subTurn == 1) {
 270       this.subTurn++;
 271       if (
 272         this.movesCount == 0 ||
 273         !!move.captureKing ||
 274         !this.atLeastOneMove()
 275       ) {
 276         this.turn = oppCol;
 277         this.movesCount++;
 278         this.subTurn = 1;
 279         this.promoteFile.push(-1);
 280         move.pushPromote = true;
 281       }
 282     }
 283     else {
 284       // subTurn == 2
 285       this.turn = oppCol;
 286       if (move.end.x == oppLastRank) {
 287         this.promoteFile.push(move.end.y);
 288         this.reserve[oppCol] = {
 289           [V.ROOK]: 1,
 290           [V.KNIGHT]: 1,
 291           [V.BISHOP]: 1,
 292           [V.QUEEN]: 1
 293         };
 294         this.subTurn = 0;
 295       }
 296       else {
 297         this.subTurn = 1;
 298         this.promoteFile.push(-1);
 299       }
 300       move.pushPromote = true;
 301       this.movesCount++;
 302     }
 303   }
 304
 305   undo(move) {
 306     this.disaggregateFlags(JSON.parse(move.flags));
 307     V.UndoOnBoard(this.board, move);
 308     const changeTurn = (this.turn != move.turn[0]);
 309     this.turn = move.turn[0];
 310     this.subTurn = move.turn[1];
 311     if (!!move.pushPromote) {
 312       const promoteFile = this.promoteFile.pop();
 313       if (promoteFile >= 0) this.reserve[V.GetOppCol(this.turn)] = null;
 314     }
 315     else if (this.subTurn == 0) {
 316       this.reserve[this.turn] = {
 317         [V.ROOK]: 1,
 318         [V.KNIGHT]: 1,
 319         [V.BISHOP]: 1,
 320         [V.QUEEN]: 1
 321       };
 322     }
 323     if (changeTurn) this.movesCount--;
 324     this.postUndo(move);
 325   }
 326
 327   postUndo(move) {
 328     if (this.subTurn != 1) return;
 329     if (move.vanish.length == 2 && move.vanish[1].p == V.KING)
 330       // Opponent's king was captured
 331       this.kingPos[move.vanish[1].c] = [move.vanish[1].x, move.vanish[1].y];
 332     super.postUndo(move);
 333   }
 334
 335   getComputerMove() {
 336     // Just try to capture as much material as possible (1-half move)
 337     const moves = this.getAllValidMoves();
 338     if (this.subTurn == 0) {
 339       this.play(moves[3]); //HACK... 3 = queen index
 340       const res = this.getComputerMove();
 341       this.undo(moves[3]);
 342       return [moves[3], res];
 343     }
 344     // subTurn == 1 (necessarily)
 345     let candidates = [];
 346     let maxValue = -V.INFINITY;
 347     for (let m of moves) {
 348       let value = 0;
 349       if (m.vanish.length == 2) {
 350         // Compute delta value, to not give all material on pawns... (TODO)
 351         // 0.5 to favor captures (if same type of piece).
 352         value = 0.5 +
 353           ChessRules.VALUES[m.vanish[1].p] - ChessRules.VALUES[m.vanish[0].p];
 354       }
 355       if (value > maxValue) {
 356         candidates = [m];
 357         maxValue = value;
 358       }
 359       else if (value == maxValue) candidates.push(m);
 360     }
 361     const m1 = candidates[randInt(candidates.length)];
 362     this.play(m1);
 363     let m2 = null;
 364     if (this.subTurn == 2) {
 365       // Just pick a pawn at random
 366       const moves2 = this.getAllValidMoves();
 367       m2 = moves2[randInt(moves2.length)];
 368     }
 369     this.undo(m1);
 370     if (!m2) return m1;
 371     return [m1, m2];
 372   }
 373
 374   getNotation(move) {
 375     if (this.subTurn == 0)
 376       return move.appear[0].p.toUpperCase() + "@" + V.CoordsToSquare(move.end);
 377     if (this.subTurn == 1) return super.getNotation(move);
 378     // subTurn == 2: just indicate final square
 379     return V.CoordsToSquare(move.end);
 380   }
 381
 382 };