client/src/variants/Wildebeest.js

   1 import { ChessRules } from "@/base_rules";
   2 import { ArrayFun } from "@/utils/array";
   3 import { sample, randInt } from "@/utils/alea";
   4
   5 export const VariantRules = class WildebeestRules extends ChessRules {
   6   static get size() {
   7     return { x: 10, y: 11 };
   8   }
   9
  10   static get CAMEL() {
  11     return "c";
  12   }
  13   static get WILDEBEEST() {
  14     return "w";
  15   }
  16
  17   static get PIECES() {
  18     return ChessRules.PIECES.concat([V.CAMEL, V.WILDEBEEST]);
  19   }
  20
  21   static get steps() {
  22     return Object.assign(
  23       ChessRules.steps, //add camel moves:
  24       {
  25         c: [
  26           [-3, -1],
  27           [-3, 1],
  28           [-1, -3],
  29           [-1, 3],
  30           [1, -3],
  31           [1, 3],
  32           [3, -1],
  33           [3, 1]
  34         ]
  35       }
  36     );
  37   }
  38
  39   static IsGoodEnpassant(enpassant) {
  40     if (enpassant != "-") {
  41       const squares = enpassant.split(",");
  42       if (squares.length > 2) return false;
  43       for (let sq of squares) {
  44         const ep = V.SquareToCoords(sq);
  45         if (isNaN(ep.x) || !V.OnBoard(ep)) return false;
  46       }
  47     }
  48     return true;
  49   }
  50
  51   getPpath(b) {
  52     return ([V.CAMEL, V.WILDEBEEST].includes(b[1]) ? "Wildebeest/" : "") + b;
  53   }
  54
  55   // There may be 2 enPassant squares (if pawn jump 3 squares)
  56   getEnpassantFen() {
  57     const L = this.epSquares.length;
  58     if (!this.epSquares[L - 1]) return "-"; //no en-passant
  59     let res = "";
  60     this.epSquares[L - 1].forEach(sq => {
  61       res += V.CoordsToSquare(sq) + ",";
  62     });
  63     return res.slice(0, -1); //remove last comma
  64   }
  65
  66   // En-passant after 2-sq or 3-sq jumps
  67   getEpSquare(moveOrSquare) {
  68     if (!moveOrSquare) return undefined;
  69     if (typeof moveOrSquare === "string") {
  70       const square = moveOrSquare;
  71       if (square == "-") return undefined;
  72       let res = [];
  73       square.split(",").forEach(sq => {
  74         res.push(V.SquareToCoords(sq));
  75       });
  76       return res;
  77     }
  78     // Argument is a move:
  79     const move = moveOrSquare;
  80     const [sx, sy, ex] = [move.start.x, move.start.y, move.end.x];
  81     if (this.getPiece(sx, sy) == V.PAWN && Math.abs(sx - ex) >= 2) {
  82       const step = (ex - sx) / Math.abs(ex - sx);
  83       let res = [
  84         {
  85           x: sx + step,
  86           y: sy
  87         }
  88       ];
  89       if (sx + 2 * step != ex) {
  90         //3-squares move
  91         res.push({
  92           x: sx + 2 * step,
  93           y: sy
  94         });
  95       }
  96       return res;
  97     }
  98     return undefined; //default
  99   }
 100
 101   getPotentialMovesFrom([x, y]) {
 102     switch (this.getPiece(x, y)) {
 103       case V.CAMEL:
 104         return this.getPotentialCamelMoves([x, y]);
 105       case V.WILDEBEEST:
 106         return this.getPotentialWildebeestMoves([x, y]);
 107       default:
 108         return super.getPotentialMovesFrom([x, y]);
 109     }
 110   }
 111
 112   // Pawns jump 2 or 3 squares, and promote to queen or wildebeest
 113   getPotentialPawnMoves([x, y]) {
 114     const color = this.turn;
 115     let moves = [];
 116     const [sizeX, sizeY] = [V.size.x, V.size.y];
 117     const shiftX = color == "w" ? -1 : 1;
 118     const startRanks = color == "w" ? [sizeX - 2, sizeX - 3] : [1, 2];
 119     const lastRank = color == "w" ? 0 : sizeX - 1;
 120     const finalPieces = x + shiftX == lastRank
 121       ? [V.WILDEBEEST, V.QUEEN]
 122       : [V.PAWN];
 123
 124     if (this.board[x + shiftX][y] == V.EMPTY) {
 125       // One square forward
 126       for (let piece of finalPieces)
 127         moves.push(
 128           this.getBasicMove([x, y], [x + shiftX, y], { c: color, p: piece })
 129         );
 130       if (startRanks.includes(x)) {
 131         if (this.board[x + 2 * shiftX][y] == V.EMPTY) {
 132           // Two squares jump
 133           moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
 134           if (x == startRanks[0] && this.board[x + 3 * shiftX][y] == V.EMPTY) {
 135             // Three squares jump
 136             moves.push(this.getBasicMove([x, y], [x + 3 * shiftX, y]));
 137           }
 138         }
 139       }
 140     }
 141     // Captures
 142     for (let shiftY of [-1, 1]) {
 143       if (
 144         y + shiftY >= 0 &&
 145         y + shiftY < sizeY &&
 146         this.board[x + shiftX][y + shiftY] != V.EMPTY &&
 147         this.canTake([x, y], [x + shiftX, y + shiftY])
 148       ) {
 149         for (let piece of finalPieces) {
 150           moves.push(
 151             this.getBasicMove([x, y], [x + shiftX, y + shiftY], {
 152               c: color,
 153               p: piece
 154             })
 155           );
 156         }
 157       }
 158     }
 159
 160     // En passant
 161     const Lep = this.epSquares.length;
 162     const epSquare = this.epSquares[Lep - 1];
 163     if (epSquare) {
 164       for (let epsq of epSquare) {
 165         // TODO: some redundant checks
 166         if (epsq.x == x + shiftX && Math.abs(epsq.y - y) == 1) {
 167           var enpassantMove = this.getBasicMove([x, y], [epsq.x, epsq.y]);
 168           // WARNING: the captured pawn may be diagonally behind us,
 169           // if it's a 3-squares jump and we take on 1st passing square
 170           const px = this.board[x][epsq.y] != V.EMPTY ? x : x - shiftX;
 171           enpassantMove.vanish.push({
 172             x: px,
 173             y: epsq.y,
 174             p: "p",
 175             c: this.getColor(px, epsq.y)
 176           });
 177           moves.push(enpassantMove);
 178         }
 179       }
 180     }
 181
 182     return moves;
 183   }
 184
 185   // TODO: wildebeest castle
 186
 187   getPotentialCamelMoves(sq) {
 188     return this.getSlideNJumpMoves(sq, V.steps[V.CAMEL], "oneStep");
 189   }
 190
 191   getPotentialWildebeestMoves(sq) {
 192     return this.getSlideNJumpMoves(
 193       sq,
 194       V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]),
 195       "oneStep"
 196     );
 197   }
 198
 199   isAttacked(sq, colors) {
 200     return (
 201       super.isAttacked(sq, colors) ||
 202       this.isAttackedByCamel(sq, colors) ||
 203       this.isAttackedByWildebeest(sq, colors)
 204     );
 205   }
 206
 207   isAttackedByCamel(sq, colors) {
 208     return this.isAttackedBySlideNJump(
 209       sq,
 210       colors,
 211       V.CAMEL,
 212       V.steps[V.CAMEL],
 213       "oneStep"
 214     );
 215   }
 216
 217   isAttackedByWildebeest(sq, colors) {
 218     return this.isAttackedBySlideNJump(
 219       sq,
 220       colors,
 221       V.WILDEBEEST,
 222       V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]),
 223       "oneStep"
 224     );
 225   }
 226
 227   getCurrentScore() {
 228     if (this.atLeastOneMove())
 229       // game not over
 230       return "*";
 231
 232     // No valid move: game is lost (stalemate is a win)
 233     return this.turn == "w" ? "0-1" : "1-0";
 234   }
 235
 236   static get VALUES() {
 237     return Object.assign(
 238       { c: 3, w: 7 }, //experimental
 239       ChessRules.VALUES
 240     );
 241   }
 242
 243   static get SEARCH_DEPTH() {
 244     return 2;
 245   }
 246
 247   static GenRandInitFen() {
 248     let pieces = { w: new Array(10), b: new Array(10) };
 249     for (let c of ["w", "b"]) {
 250       let positions = ArrayFun.range(11);
 251
 252       // Get random squares for bishops + camels (different colors)
 253       let randIndexes = sample(ArrayFun.range(6), 2).map(i => {
 254         return 2 * i;
 255       });
 256       let bishop1Pos = positions[randIndexes[0]];
 257       let camel1Pos = positions[randIndexes[1]];
 258       // The second bishop (camel) must be on a square of different color
 259       let randIndexes_tmp = sample(ArrayFun.range(5), 2).map(i => {
 260         return 2 * i + 1;
 261       });
 262       let bishop2Pos = positions[randIndexes_tmp[0]];
 263       let camel2Pos = positions[randIndexes_tmp[1]];
 264       for (let idx of randIndexes.concat(randIndexes_tmp).sort((a, b) => {
 265         return b - a;
 266       })) {
 267         //largest indices first
 268         positions.splice(idx, 1);
 269       }
 270
 271       let randIndex = randInt(7);
 272       let knight1Pos = positions[randIndex];
 273       positions.splice(randIndex, 1);
 274       randIndex = randInt(6);
 275       let knight2Pos = positions[randIndex];
 276       positions.splice(randIndex, 1);
 277
 278       randIndex = randInt(5);
 279       let queenPos = positions[randIndex];
 280       positions.splice(randIndex, 1);
 281
 282       // Random square for wildebeest
 283       randIndex = randInt(4);
 284       let wildebeestPos = positions[randIndex];
 285       positions.splice(randIndex, 1);
 286
 287       let rook1Pos = positions[0];
 288       let kingPos = positions[1];
 289       let rook2Pos = positions[2];
 290
 291       pieces[c][rook1Pos] = "r";
 292       pieces[c][knight1Pos] = "n";
 293       pieces[c][bishop1Pos] = "b";
 294       pieces[c][queenPos] = "q";
 295       pieces[c][camel1Pos] = "c";
 296       pieces[c][camel2Pos] = "c";
 297       pieces[c][wildebeestPos] = "w";
 298       pieces[c][kingPos] = "k";
 299       pieces[c][bishop2Pos] = "b";
 300       pieces[c][knight2Pos] = "n";
 301       pieces[c][rook2Pos] = "r";
 302     }
 303     return (
 304       pieces["b"].join("") +
 305       "/ppppppppppp/11/11/11/11/11/11/PPPPPPPPPPP/" +
 306       pieces["w"].join("").toUpperCase() +
 307       " w 0 1111 -"
 308     );
 309   }
 310 };