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 // NOTE: initial setup differs from the original; see
   6 // https://www.chessvariants.com/large.dir/freeling.html
   7 export class GrandRules extends ChessRules {
   8   static IsGoodFen(fen) {
   9     if (!ChessRules.IsGoodFen(fen)) return false;
  10     const fenParsed = V.ParseFen(fen);
  11     // 5) Check captures
  12     if (!fenParsed.captured || !fenParsed.captured.match(/^[0-9]{12,12}$/))
  13       return false;
  14     return true;
  15   }
  16
  17   static IsGoodEnpassant(enpassant) {
  18     if (enpassant != "-") return !!enpassant.match(/^([a-j][0-9]{1,2},?)+$/);
  19     return true;
  20   }
  21
  22   static ParseFen(fen) {
  23     const fenParts = fen.split(" ");
  24     return Object.assign(
  25       ChessRules.ParseFen(fen),
  26       { captured: fenParts[5] }
  27     );
  28   }
  29
  30   getPpath(b) {
  31     return ([V.MARSHALL, V.CARDINAL].includes(b[1]) ? "Grand/" : "") + b;
  32   }
  33
  34   getFen() {
  35     return super.getFen() + " " + this.getCapturedFen();
  36   }
  37
  38   getFenForRepeat() {
  39     return super.getFenForRepeat() + "_" + this.getCapturedFen();
  40   }
  41
  42   getCapturedFen() {
  43     let counts = [...Array(12).fill(0)];
  44     let i = 0;
  45     for (let j = 0; j < V.PIECES.length; j++) {
  46       if ([V.KING, V.PAWN].includes(V.PIECES[j]))
  47         // No king captured, and pawns don't promote in pawns
  48         continue;
  49       counts[i] = this.captured["w"][V.PIECES[j]];
  50       counts[6 + i] = this.captured["b"][V.PIECES[j]];
  51       i++;
  52     }
  53     return counts.join("");
  54   }
  55
  56   setOtherVariables(fen) {
  57     super.setOtherVariables(fen);
  58     const fenParsed = V.ParseFen(fen);
  59     // Initialize captured pieces' counts from FEN
  60     this.captured = {
  61       w: {
  62         [V.ROOK]: parseInt(fenParsed.captured[0]),
  63         [V.KNIGHT]: parseInt(fenParsed.captured[1]),
  64         [V.BISHOP]: parseInt(fenParsed.captured[2]),
  65         [V.QUEEN]: parseInt(fenParsed.captured[3]),
  66         [V.MARSHALL]: parseInt(fenParsed.captured[4]),
  67         [V.CARDINAL]: parseInt(fenParsed.captured[5])
  68       },
  69       b: {
  70         [V.ROOK]: parseInt(fenParsed.captured[6]),
  71         [V.KNIGHT]: parseInt(fenParsed.captured[7]),
  72         [V.BISHOP]: parseInt(fenParsed.captured[8]),
  73         [V.QUEEN]: parseInt(fenParsed.captured[9]),
  74         [V.MARSHALL]: parseInt(fenParsed.captured[10]),
  75         [V.CARDINAL]: parseInt(fenParsed.captured[11])
  76       }
  77     };
  78   }
  79
  80   static get size() {
  81     return { x: 10, y: 10 };
  82   }
  83
  84   // Rook + knight:
  85   static get MARSHALL() {
  86     return "m";
  87   }
  88
  89   // Bishop + knight
  90   static get CARDINAL() {
  91     return "c";
  92   }
  93
  94   static get PIECES() {
  95     return ChessRules.PIECES.concat([V.MARSHALL, V.CARDINAL]);
  96   }
  97
  98   // There may be 2 enPassant squares (if pawn jump 3 squares)
  99   getEnpassantFen() {
 100     const L = this.epSquares.length;
 101     if (!this.epSquares[L - 1]) return "-"; //no en-passant
 102     let res = "";
 103     this.epSquares[L - 1].forEach(sq => {
 104       res += V.CoordsToSquare(sq) + ",";
 105     });
 106     return res.slice(0, -1); //remove last comma
 107   }
 108
 109   // En-passant after 2-sq or 3-sq jumps
 110   getEpSquare(moveOrSquare) {
 111     if (!moveOrSquare) return undefined;
 112     if (typeof moveOrSquare === "string") {
 113       const square = moveOrSquare;
 114       if (square == "-") return undefined;
 115       let res = [];
 116       square.split(",").forEach(sq => {
 117         res.push(V.SquareToCoords(sq));
 118       });
 119       return res;
 120     }
 121     // Argument is a move:
 122     const move = moveOrSquare;
 123     const [sx, sy, ex] = [move.start.x, move.start.y, move.end.x];
 124     if (this.getPiece(sx, sy) == V.PAWN && Math.abs(sx - ex) >= 2) {
 125       const step = (ex - sx) / Math.abs(ex - sx);
 126       let res = [
 127         {
 128           x: sx + step,
 129           y: sy
 130         }
 131       ];
 132       if (sx + 2 * step != ex) {
 133         // 3-squares jump
 134         res.push({
 135           x: sx + 2 * step,
 136           y: sy
 137         });
 138       }
 139       return res;
 140     }
 141     return undefined; //default
 142   }
 143
 144   getPotentialMovesFrom([x, y]) {
 145     switch (this.getPiece(x, y)) {
 146       case V.MARSHALL:
 147         return this.getPotentialMarshallMoves([x, y]);
 148       case V.CARDINAL:
 149         return this.getPotentialCardinalMoves([x, y]);
 150       default:
 151         return super.getPotentialMovesFrom([x, y]);
 152     }
 153   }
 154
 155   // Special pawn rules: promotions to captured friendly pieces,
 156   // optional on ranks 8-9 and mandatory on rank 10.
 157   getPotentialPawnMoves([x, y]) {
 158     const color = this.turn;
 159     let moves = [];
 160     const [sizeX, sizeY] = [V.size.x, V.size.y];
 161     const shiftX = color == "w" ? -1 : 1;
 162     const startRanks = color == "w" ? [sizeX - 2, sizeX - 3] : [1, 2];
 163     const lastRanks =
 164       color == "w" ? [0, 1, 2] : [sizeX - 1, sizeX - 2, sizeX - 3];
 165     const promotionPieces = [
 166       V.ROOK,
 167       V.KNIGHT,
 168       V.BISHOP,
 169       V.QUEEN,
 170       V.MARSHALL,
 171       V.CARDINAL
 172     ];
 173
 174     // Always x+shiftX >= 0 && x+shiftX < sizeX, because no pawns on last rank
 175     let finalPieces = undefined;
 176     if (lastRanks.includes(x + shiftX)) {
 177       finalPieces = promotionPieces.filter(p => this.captured[color][p] > 0);
 178       if (x + shiftX != lastRanks[0]) finalPieces.push(V.PAWN);
 179     } else finalPieces = [V.PAWN];
 180     if (this.board[x + shiftX][y] == V.EMPTY) {
 181       // One square forward
 182       for (let piece of finalPieces)
 183         moves.push(
 184           this.getBasicMove([x, y], [x + shiftX, y], { c: color, p: piece })
 185         );
 186       if (startRanks.includes(x)) {
 187         if (this.board[x + 2 * shiftX][y] == V.EMPTY) {
 188           // Two squares jump
 189           moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
 190           if (x == startRanks[0] && this.board[x + 3 * shiftX][y] == V.EMPTY) {
 191             // Three squares jump
 192             moves.push(this.getBasicMove([x, y], [x + 3 * shiftX, y]));
 193           }
 194         }
 195       }
 196     }
 197     // Captures
 198     for (let shiftY of [-1, 1]) {
 199       if (
 200         y + shiftY >= 0 &&
 201         y + shiftY < sizeY &&
 202         this.board[x + shiftX][y + shiftY] != V.EMPTY &&
 203         this.canTake([x, y], [x + shiftX, y + shiftY])
 204       ) {
 205         for (let piece of finalPieces) {
 206           moves.push(
 207             this.getBasicMove([x, y], [x + shiftX, y + shiftY], {
 208               c: color,
 209               p: piece
 210             })
 211           );
 212         }
 213       }
 214     }
 215
 216     // En passant
 217     const Lep = this.epSquares.length;
 218     const epSquare = this.epSquares[Lep - 1];
 219     if (!!epSquare) {
 220       for (let epsq of epSquare) {
 221         // TODO: some redundant checks
 222         if (epsq.x == x + shiftX && Math.abs(epsq.y - y) == 1) {
 223           let enpassantMove = this.getBasicMove([x, y], [epsq.x, epsq.y]);
 224           // WARNING: the captured pawn may be diagonally behind us,
 225           // if it's a 3-squares jump and we take on 1st passing square
 226           const px = this.board[x][epsq.y] != V.EMPTY ? x : x - shiftX;
 227           enpassantMove.vanish.push({
 228             x: px,
 229             y: epsq.y,
 230             p: "p",
 231             c: this.getColor(px, epsq.y)
 232           });
 233           moves.push(enpassantMove);
 234         }
 235       }
 236     }
 237
 238     return moves;
 239   }
 240
 241   // TODO: different castle?
 242
 243   getPotentialMarshallMoves(sq) {
 244     return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]).concat(
 245       this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep")
 246     );
 247   }
 248
 249   getPotentialCardinalMoves(sq) {
 250     return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]).concat(
 251       this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep")
 252     );
 253   }
 254
 255   isAttacked(sq, color) {
 256     return (
 257       super.isAttacked(sq, color) ||
 258       this.isAttackedByMarshall(sq, color) ||
 259       this.isAttackedByCardinal(sq, color)
 260     );
 261   }
 262
 263   isAttackedByMarshall(sq, color) {
 264     return (
 265       this.isAttackedBySlideNJump(sq, color, V.MARSHALL, V.steps[V.ROOK]) ||
 266       this.isAttackedBySlideNJump(
 267         sq,
 268         color,
 269         V.MARSHALL,
 270         V.steps[V.KNIGHT],
 271         "oneStep"
 272       )
 273     );
 274   }
 275
 276   isAttackedByCardinal(sq, color) {
 277     return (
 278       this.isAttackedBySlideNJump(sq, color, V.CARDINAL, V.steps[V.BISHOP]) ||
 279       this.isAttackedBySlideNJump(
 280         sq,
 281         color,
 282         V.CARDINAL,
 283         V.steps[V.KNIGHT],
 284         "oneStep"
 285       )
 286     );
 287   }
 288
 289   postPlay(move) {
 290     super.postPlay(move);
 291     if (move.vanish.length == 2 && move.appear.length == 1)
 292       // Capture: update this.captured
 293       this.captured[move.vanish[1].c][move.vanish[1].p]++;
 294   }
 295
 296   postUndo(move) {
 297     super.postUndo(move);
 298     if (move.vanish.length == 2 && move.appear.length == 1)
 299       this.captured[move.vanish[1].c][move.vanish[1].p]--;
 300   }
 301
 302   static get VALUES() {
 303     return Object.assign(
 304       { c: 5, m: 7 }, //experimental
 305       ChessRules.VALUES
 306     );
 307   }
 308
 309   static get SEARCH_DEPTH() {
 310     return 2;
 311   }
 312
 313   static GenRandInitFen(randomness) {
 314     if (randomness == 0) {
 315       return (
 316         "r8r/1nbqkmcbn1/pppppppppp/91/91/91/91/PPPPPPPPPP/1NBQKMCBN1/R8R " +
 317         // No castling in the official initial setup
 318         "w 0 zzzz - 00000000000000"
 319       );
 320     }
 321
 322     let pieces = { w: new Array(10), b: new Array(10) };
 323     let flags = "";
 324     // Shuffle pieces on first and last rank
 325     for (let c of ["w", "b"]) {
 326       if (c == 'b' && randomness == 1) {
 327         pieces['b'] = pieces['w'];
 328         flags += flags;
 329         break;
 330       }
 331
 332       let positions = ArrayFun.range(10);
 333
 334       // Get random squares for bishops
 335       let randIndex = 2 * randInt(5);
 336       let bishop1Pos = positions[randIndex];
 337       // The second bishop must be on a square of different color
 338       let randIndex_tmp = 2 * randInt(5) + 1;
 339       let bishop2Pos = positions[randIndex_tmp];
 340       // Remove chosen squares
 341       positions.splice(Math.max(randIndex, randIndex_tmp), 1);
 342       positions.splice(Math.min(randIndex, randIndex_tmp), 1);
 343
 344       // Get random squares for knights
 345       randIndex = randInt(8);
 346       let knight1Pos = positions[randIndex];
 347       positions.splice(randIndex, 1);
 348       randIndex = randInt(7);
 349       let knight2Pos = positions[randIndex];
 350       positions.splice(randIndex, 1);
 351
 352       // Get random square for queen
 353       randIndex = randInt(6);
 354       let queenPos = positions[randIndex];
 355       positions.splice(randIndex, 1);
 356
 357       // ...random square for marshall
 358       randIndex = randInt(5);
 359       let marshallPos = positions[randIndex];
 360       positions.splice(randIndex, 1);
 361
 362       // ...random square for cardinal
 363       randIndex = randInt(4);
 364       let cardinalPos = positions[randIndex];
 365       positions.splice(randIndex, 1);
 366
 367       // Rooks and king positions are now fixed,
 368       // because of the ordering rook-king-rook
 369       let rook1Pos = positions[0];
 370       let kingPos = positions[1];
 371       let rook2Pos = positions[2];
 372
 373       // Finally put the shuffled pieces in the board array
 374       pieces[c][rook1Pos] = "r";
 375       pieces[c][knight1Pos] = "n";
 376       pieces[c][bishop1Pos] = "b";
 377       pieces[c][queenPos] = "q";
 378       pieces[c][marshallPos] = "m";
 379       pieces[c][cardinalPos] = "c";
 380       pieces[c][kingPos] = "k";
 381       pieces[c][bishop2Pos] = "b";
 382       pieces[c][knight2Pos] = "n";
 383       pieces[c][rook2Pos] = "r";
 384       flags += V.CoordToColumn(rook1Pos) + V.CoordToColumn(rook2Pos);
 385     }
 386     return (
 387       pieces["b"].join("") +
 388       "/pppppppppp/91/91/91/91/91/91/PPPPPPPPPP/" +
 389       pieces["w"].join("").toUpperCase() +
 390       " w 0 " + flags + " - 00000000000000"
 391     );
 392   }
 393 };