client/src/variants/Grand.js

   1 import { ChessRules } from "@/base_rules";
   2 import { ArrayFun } from "@/utils/array";
   3 import { randInt } from "@/utils/alea";
   4
   5 export class GrandRules extends ChessRules {
   6
   7   static get HasCastle() {
   8     return false;
   9   }
  10
  11   static IsGoodFen(fen) {
  12     if (!ChessRules.IsGoodFen(fen)) return false;
  13     const fenParsed = V.ParseFen(fen);
  14     // 5) Check captures
  15     if (!fenParsed.captured || !fenParsed.captured.match(/^[0-9]{12,12}$/))
  16       return false;
  17     return true;
  18   }
  19
  20   static IsGoodEnpassant(enpassant) {
  21     if (enpassant != "-") return !!enpassant.match(/^([a-j][0-9]{1,2},?)+$/);
  22     return true;
  23   }
  24
  25   static ParseFen(fen) {
  26     const fenParts = fen.split(" ");
  27     return Object.assign(
  28       ChessRules.ParseFen(fen),
  29       { captured: fenParts[4] }
  30     );
  31   }
  32
  33   getPpath(b) {
  34     return ([V.MARSHALL, V.CARDINAL].includes(b[1]) ? "Grand/" : "") + b;
  35   }
  36
  37   getFen() {
  38     return super.getFen() + " " + this.getCapturedFen();
  39   }
  40
  41   getFenForRepeat() {
  42     return super.getFenForRepeat() + "_" + this.getCapturedFen();
  43   }
  44
  45   getCapturedFen() {
  46     let counts = [...Array(12).fill(0)];
  47     let i = 0;
  48     for (let j = 0; j < V.PIECES.length; j++) {
  49       if ([V.KING, V.PAWN].includes(V.PIECES[j]))
  50         // No king captured, and pawns don't promote in pawns
  51         continue;
  52       counts[i] = this.captured["w"][V.PIECES[j]];
  53       counts[6 + i] = this.captured["b"][V.PIECES[j]];
  54       i++;
  55     }
  56     return counts.join("");
  57   }
  58
  59   setOtherVariables(fen) {
  60     super.setOtherVariables(fen);
  61     const captured =
  62       V.ParseFen(fen).captured.split("").map(x => parseInt(x, 10));
  63     // Initialize captured pieces' counts from FEN
  64     this.captured = {
  65       w: {
  66         [V.ROOK]: captured[0],
  67         [V.KNIGHT]: captured[1],
  68         [V.BISHOP]: captured[2],
  69         [V.QUEEN]: captured[3],
  70         [V.MARSHALL]: captured[4],
  71         [V.CARDINAL]: captured[5]
  72       },
  73       b: {
  74         [V.ROOK]: captured[6],
  75         [V.KNIGHT]: captured[7],
  76         [V.BISHOP]: captured[8],
  77         [V.QUEEN]: captured[9],
  78         [V.MARSHALL]: captured[10],
  79         [V.CARDINAL]: captured[11]
  80       }
  81     };
  82   }
  83
  84   static get size() {
  85     return { x: 10, y: 10 };
  86   }
  87
  88   // Rook + knight:
  89   static get MARSHALL() {
  90     return "m";
  91   }
  92
  93   // Bishop + knight
  94   static get CARDINAL() {
  95     return "c";
  96   }
  97
  98   static get PIECES() {
  99     return ChessRules.PIECES.concat([V.MARSHALL, V.CARDINAL]);
 100   }
 101
 102   getPotentialMovesFrom([x, y]) {
 103     switch (this.getPiece(x, y)) {
 104       case V.MARSHALL:
 105         return this.getPotentialMarshallMoves([x, y]);
 106       case V.CARDINAL:
 107         return this.getPotentialCardinalMoves([x, y]);
 108       default:
 109         return super.getPotentialMovesFrom([x, y]);
 110     }
 111   }
 112
 113   // Special pawn rules: promotions to captured friendly pieces,
 114   // optional on ranks 8-9 and mandatory on rank 10.
 115   getPotentialPawnMoves([x, y]) {
 116     const color = this.turn;
 117     let moves = [];
 118     const [sizeX, sizeY] = [V.size.x, V.size.y];
 119     const shiftX = color == "w" ? -1 : 1;
 120     const startRank = (color == "w" ? sizeX - 3 : 2);
 121     const lastRanks =
 122       color == "w" ? [0, 1, 2] : [sizeX - 1, sizeX - 2, sizeX - 3];
 123     const promotionPieces = [
 124       V.ROOK,
 125       V.KNIGHT,
 126       V.BISHOP,
 127       V.QUEEN,
 128       V.MARSHALL,
 129       V.CARDINAL
 130     ];
 131
 132     // Always x+shiftX >= 0 && x+shiftX < sizeX, because no pawns on last rank
 133     let finalPieces = undefined;
 134     if (lastRanks.includes(x + shiftX)) {
 135       finalPieces = promotionPieces.filter(p => this.captured[color][p] > 0);
 136       if (x + shiftX != lastRanks[0]) finalPieces.push(V.PAWN);
 137     }
 138     else finalPieces = [V.PAWN];
 139     if (this.board[x + shiftX][y] == V.EMPTY) {
 140       // One square forward
 141       for (let piece of finalPieces)
 142         moves.push(
 143           this.getBasicMove([x, y], [x + shiftX, y], { c: color, p: piece })
 144         );
 145       if (x == startRank && this.board[x + 2 * shiftX][y] == V.EMPTY)
 146         // Two squares jump
 147         moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
 148     }
 149     // Captures
 150     for (let shiftY of [-1, 1]) {
 151       if (
 152         y + shiftY >= 0 &&
 153         y + shiftY < sizeY &&
 154         this.board[x + shiftX][y + shiftY] != V.EMPTY &&
 155         this.canTake([x, y], [x + shiftX, y + shiftY])
 156       ) {
 157         for (let piece of finalPieces) {
 158           moves.push(
 159             this.getBasicMove([x, y], [x + shiftX, y + shiftY], {
 160               c: color,
 161               p: piece
 162             })
 163           );
 164         }
 165       }
 166     }
 167
 168     // En passant
 169     Array.prototype.push.apply(
 170       moves,
 171       this.getEnpassantCaptures([x, y], shiftX)
 172     );
 173
 174     return moves;
 175   }
 176
 177   getPotentialMarshallMoves(sq) {
 178     return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]).concat(
 179       this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep")
 180     );
 181   }
 182
 183   getPotentialCardinalMoves(sq) {
 184     return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]).concat(
 185       this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep")
 186     );
 187   }
 188
 189   isAttacked(sq, color) {
 190     return (
 191       super.isAttacked(sq, color) ||
 192       this.isAttackedByMarshall(sq, color) ||
 193       this.isAttackedByCardinal(sq, color)
 194     );
 195   }
 196
 197   isAttackedByMarshall(sq, color) {
 198     return (
 199       this.isAttackedBySlideNJump(sq, color, V.MARSHALL, V.steps[V.ROOK]) ||
 200       this.isAttackedBySlideNJump(
 201         sq,
 202         color,
 203         V.MARSHALL,
 204         V.steps[V.KNIGHT],
 205         "oneStep"
 206       )
 207     );
 208   }
 209
 210   isAttackedByCardinal(sq, color) {
 211     return (
 212       this.isAttackedBySlideNJump(sq, color, V.CARDINAL, V.steps[V.BISHOP]) ||
 213       this.isAttackedBySlideNJump(
 214         sq,
 215         color,
 216         V.CARDINAL,
 217         V.steps[V.KNIGHT],
 218         "oneStep"
 219       )
 220     );
 221   }
 222
 223   postPlay(move) {
 224     super.postPlay(move);
 225     if (move.vanish.length == 2 && move.appear.length == 1)
 226       // Capture: update this.captured
 227       this.captured[move.vanish[1].c][move.vanish[1].p]++;
 228   }
 229
 230   postUndo(move) {
 231     super.postUndo(move);
 232     if (move.vanish.length == 2 && move.appear.length == 1)
 233       this.captured[move.vanish[1].c][move.vanish[1].p]--;
 234   }
 235
 236   static get VALUES() {
 237     return Object.assign(
 238       { c: 5, m: 7 }, //experimental
 239       ChessRules.VALUES
 240     );
 241   }
 242
 243   static get SEARCH_DEPTH() {
 244     return 2;
 245   }
 246
 247   static GenRandInitFen(randomness) {
 248     if (randomness == 0) {
 249       return (
 250         "r8r/1nbqkmcbn1/pppppppppp/91/91/91/91/PPPPPPPPPP/1NBQKMCBN1/R8R " +
 251         "w 0 - 00000000000000"
 252       );
 253     }
 254
 255     let pieces = { w: new Array(8), b: new Array(8) };
 256     // Shuffle pieces on second and before-last rank
 257     for (let c of ["w", "b"]) {
 258       if (c == 'b' && randomness == 1) {
 259         pieces['b'] = pieces['w'];
 260         break;
 261       }
 262
 263       let positions = ArrayFun.range(8);
 264
 265       // Get random squares for bishops
 266       let randIndex = 2 * randInt(4);
 267       const bishop1Pos = positions[randIndex];
 268       // The second bishop must be on a square of different color
 269       let randIndex_tmp = 2 * randInt(4) + 1;
 270       const bishop2Pos = positions[randIndex_tmp];
 271       // Remove chosen squares
 272       positions.splice(Math.max(randIndex, randIndex_tmp), 1);
 273       positions.splice(Math.min(randIndex, randIndex_tmp), 1);
 274
 275       // Get random squares for knights
 276       randIndex = randInt(6);
 277       const knight1Pos = positions[randIndex];
 278       positions.splice(randIndex, 1);
 279       randIndex = randInt(5);
 280       const knight2Pos = positions[randIndex];
 281       positions.splice(randIndex, 1);
 282
 283       // Get random square for queen
 284       randIndex = randInt(4);
 285       const queenPos = positions[randIndex];
 286       positions.splice(randIndex, 1);
 287
 288       // ...random square for marshall
 289       randIndex = randInt(3);
 290       const marshallPos = positions[randIndex];
 291       positions.splice(randIndex, 1);
 292
 293       // ...random square for cardinal
 294       randIndex = randInt(2);
 295       const cardinalPos = positions[randIndex];
 296       positions.splice(randIndex, 1);
 297
 298       // King position is now fixed,
 299       const kingPos = positions[0];
 300
 301       // Finally put the shuffled pieces in the board array
 302       pieces[c][knight1Pos] = "n";
 303       pieces[c][bishop1Pos] = "b";
 304       pieces[c][queenPos] = "q";
 305       pieces[c][marshallPos] = "m";
 306       pieces[c][cardinalPos] = "c";
 307       pieces[c][kingPos] = "k";
 308       pieces[c][bishop2Pos] = "b";
 309       pieces[c][knight2Pos] = "n";
 310     }
 311     return (
 312       "r8r/1" + pieces["b"].join("") + "1/" +
 313       "pppppppppp/91/91/91/91/PPPPPPPPPP/" +
 314       "1" + pieces["w"].join("").toUpperCase() + "1/R8R" +
 315       " w 0 " + " - 00000000000000"
 316     );
 317   }
 318
 319 };