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