client/src/variants/Omega.js

   1 import { ChessRules, Move, PiPo } from "@/base_rules";
   2 import { ArrayFun } from "@/utils/array";
   3 import { randInt } from "@/utils/alea";
   4
   5 export class OmegaRules extends ChessRules {
   6   static get PawnSpecs() {
   7     return Object.assign(
   8       {},
   9       ChessRules.PawnSpecs,
  10       {
  11         initShift: { w: 2, b: 2 },
  12         threeSquares: true,
  13         promotions:
  14           ChessRules.PawnSpecs.promotions.concat([V.CHAMPION, V.WIZARD])
  15       }
  16     );
  17   }
  18
  19   // For space between corners:
  20   static get NOTHING() {
  21     return "xx";
  22   }
  23
  24   static board2fen(b) {
  25     if (b[0] == 'x') return 'x';
  26     return ChessRules.board2fen(b);
  27   }
  28
  29   static fen2board(f) {
  30     if (f == 'x') return V.NOTHING;
  31     return ChessRules.fen2board(f);
  32   }
  33
  34   getPpath(b) {
  35     if (b[0] == 'x') return "Omega/nothing";
  36     return ([V.CHAMPION, V.WIZARD].includes(b[1]) ? "Omega/" : "") + b;
  37   }
  38
  39   // TODO: the wall position should be checked too
  40   static IsGoodPosition(position) {
  41     if (position.length == 0) return false;
  42     const rows = position.split("/");
  43     if (rows.length != V.size.x) return false;
  44     let kings = { "k": 0, "K": 0 };
  45     for (let row of rows) {
  46       let sumElts = 0;
  47       for (let i = 0; i < row.length; i++) {
  48         if (['K','k'].includes(row[i])) kings[row[i]]++;
  49         if (['x'].concat(V.PIECES).includes(row[i].toLowerCase())) sumElts++;
  50         else {
  51           const num = parseInt(row[i], 10);
  52           if (isNaN(num)) return false;
  53           sumElts += num;
  54         }
  55       }
  56       if (sumElts != V.size.y) return false;
  57     }
  58     if (Object.values(kings).some(v => v != 1)) return false;
  59     return true;
  60   }
  61
  62   // NOTE: keep this extensive check because the board has holes
  63   static IsGoodEnpassant(enpassant) {
  64     if (enpassant != "-") {
  65       const squares = enpassant.split(",");
  66       if (squares.length > 2) return false;
  67       for (let sq of squares) {
  68         const ep = V.SquareToCoords(sq);
  69         if (isNaN(ep.x) || !V.OnBoard(ep)) return false;
  70       }
  71     }
  72     return true;
  73   }
  74
  75   static get size() {
  76     return { x: 12, y: 12 };
  77   }
  78
  79   static OnBoard(x, y) {
  80     return (
  81       (x >= 1 && x <= 10 && y >= 1 && y <= 10) ||
  82       (x == 11 && [0, 11].includes(y)) ||
  83       (x == 0 && [0, 11].includes(y))
  84     );
  85   }
  86
  87   // Dabbabah + alfil + wazir
  88   static get CHAMPION() {
  89     return "c";
  90   }
  91
  92   // Camel + ferz
  93   static get WIZARD() {
  94     return "w";
  95   }
  96
  97   static get PIECES() {
  98     return ChessRules.PIECES.concat([V.CHAMPION, V.WIZARD]);
  99   }
 100
 101   static get steps() {
 102     return Object.assign(
 103       {},
 104       ChessRules.steps,
 105       {
 106         w: [
 107           [-3, -1],
 108           [-3, 1],
 109           [-1, -3],
 110           [-1, 3],
 111           [1, -3],
 112           [1, 3],
 113           [3, -1],
 114           [3, 1],
 115           [-1, -1],
 116           [-1, 1],
 117           [1, -1],
 118           [1, 1]
 119         ],
 120         c: [
 121           [1, 0],
 122           [-1, 0],
 123           [0, 1],
 124           [0, -1],
 125           [2, 2],
 126           [2, -2],
 127           [-2, 2],
 128           [-2, -2],
 129           [-2, 0],
 130           [0, -2],
 131           [2, 0],
 132           [0, 2]
 133         ]
 134       }
 135     );
 136   }
 137
 138   static GenRandInitFen(randomness) {
 139     if (randomness == 0) {
 140       return (
 141         "wxxxxxxxxxxw/xcrnbqkbnrcx/xppppppppppx/x91x/x91x/x91x/" +
 142         "x91x/x91x/x91x/xPPPPPPPPPPx/xCRNBQKBNRCx/WxxxxxxxxxxW " +
 143         "w 0 cjcj -"
 144       );
 145     }
 146
 147     let pieces = { w: new Array(10), b: new Array(10) };
 148     let flags = "";
 149     // Shuffle pieces on first (and last rank if randomness == 2)
 150     for (let c of ["w", "b"]) {
 151       if (c == 'b' && randomness == 1) {
 152         pieces['b'] = pieces['w'];
 153         flags += flags;
 154         break;
 155       }
 156
 157       let positions = ArrayFun.range(10);
 158
 159       // Get random squares for bishops
 160       let randIndex = 2 * randInt(5);
 161       const bishop1Pos = positions[randIndex];
 162       // The second bishop must be on a square of different color
 163       let randIndex_tmp = 2 * randInt(5) + 1;
 164       const bishop2Pos = positions[randIndex_tmp];
 165
 166       // Get random squares for champions
 167       let randIndexC = 2 * randInt(4);
 168       if (randIndexC >= bishop1Pos) randIndexC += 2;
 169       const champion1Pos = positions[randIndexC];
 170       // The second champion must be on a square of different color
 171       let randIndex_tmpC = 2 * randInt(4) + 1;
 172       if (randIndex_tmpC >= bishop2Pos) randIndex_tmpC += 2;
 173       const champion2Pos = positions[randIndex_tmpC];
 174
 175       let usedIndices = [randIndex, randIndex_tmp, randIndexC, randIndex_tmpC];
 176       usedIndices.sort();
 177       for (let i = 3; i >= 0; i--) positions.splice(usedIndices[i], 1);
 178
 179       // Get random squares for other pieces
 180       randIndex = randInt(6);
 181       const knight1Pos = positions[randIndex];
 182       positions.splice(randIndex, 1);
 183       randIndex = randInt(5);
 184       const knight2Pos = positions[randIndex];
 185       positions.splice(randIndex, 1);
 186
 187       randIndex = randInt(4);
 188       const queenPos = positions[randIndex];
 189       positions.splice(randIndex, 1);
 190
 191       // Rooks and king positions are now fixed
 192       const rook1Pos = positions[0];
 193       const kingPos = positions[1];
 194       const rook2Pos = positions[2];
 195
 196       pieces[c][champion1Pos] = "c";
 197       pieces[c][rook1Pos] = "r";
 198       pieces[c][knight1Pos] = "n";
 199       pieces[c][bishop1Pos] = "b";
 200       pieces[c][queenPos] = "q";
 201       pieces[c][kingPos] = "k";
 202       pieces[c][bishop2Pos] = "b";
 203       pieces[c][knight2Pos] = "n";
 204       pieces[c][rook2Pos] = "r";
 205       pieces[c][champion2Pos] = "c";
 206       flags += V.CoordToColumn(rook1Pos+1) + V.CoordToColumn(rook2Pos+1);
 207     }
 208     // Add turn + flags + enpassant
 209     return (
 210       "wxxxxxxxxxxw/" +
 211       "x" + pieces["b"].join("") +
 212       "x/xppppppppppx/x91x/x91x/x91x/x91x/x91x/x91x/xPPPPPPPPPPx/x" +
 213       pieces["w"].join("").toUpperCase() + "x" +
 214       "/WxxxxxxxxxxW " +
 215       "w 0 " + flags + " -"
 216     );
 217   }
 218
 219   // There may be 2 enPassant squares (if pawn jump 3 squares)
 220   getEnpassantFen() {
 221     const L = this.epSquares.length;
 222     if (!this.epSquares[L - 1]) return "-"; //no en-passant
 223     let res = "";
 224     this.epSquares[L - 1].forEach(sq => {
 225       res += V.CoordsToSquare(sq) + ",";
 226     });
 227     return res.slice(0, -1); //remove last comma
 228   }
 229
 230   canTake([x1, y1], [x2, y2]) {
 231     return (
 232       // Cannot take wall :)
 233       // NOTE: this check is useful only for pawns where OnBoard() isn't used
 234       this.board[x2][y2] != V.NOTHING &&
 235       this.getColor(x1, y1) !== this.getColor(x2, y2)
 236     );
 237   }
 238
 239   // En-passant after 2-sq or 3-sq jumps
 240   getEpSquare(moveOrSquare) {
 241     if (!moveOrSquare) return undefined;
 242     if (typeof moveOrSquare === "string") {
 243       const square = moveOrSquare;
 244       if (square == "-") return undefined;
 245       let res = [];
 246       square.split(",").forEach(sq => {
 247         res.push(V.SquareToCoords(sq));
 248       });
 249       return res;
 250     }
 251     // Argument is a move:
 252     const move = moveOrSquare;
 253     const [sx, sy, ex] = [move.start.x, move.start.y, move.end.x];
 254     if (this.getPiece(sx, sy) == V.PAWN && Math.abs(sx - ex) >= 2) {
 255       const step = (ex - sx) / Math.abs(ex - sx);
 256       let res = [
 257         {
 258           x: sx + step,
 259           y: sy
 260         }
 261       ];
 262       if (sx + 2 * step != ex) {
 263         // 3-squares jump
 264         res.push({
 265           x: sx + 2 * step,
 266           y: sy
 267         });
 268       }
 269       return res;
 270     }
 271     return undefined; //default
 272   }
 273
 274   getPotentialMovesFrom([x, y]) {
 275     switch (this.getPiece(x, y)) {
 276       case V.CHAMPION:
 277         return this.getPotentialChampionMoves([x, y]);
 278       case V.WIZARD:
 279         return this.getPotentialWizardMoves([x, y]);
 280       default:
 281         return super.getPotentialMovesFrom([x, y]);
 282     }
 283   }
 284
 285   getEnpassantCaptures([x, y], shiftX) {
 286     const Lep = this.epSquares.length;
 287     const epSquare = this.epSquares[Lep - 1];
 288     let moves = [];
 289     if (!!epSquare) {
 290       for (let epsq of epSquare) {
 291         // TODO: some redundant checks
 292         if (epsq.x == x + shiftX && Math.abs(epsq.y - y) == 1) {
 293           let enpassantMove = this.getBasicMove([x, y], [epsq.x, epsq.y]);
 294           // WARNING: the captured pawn may be diagonally behind us,
 295           // if it's a 3-squares jump and we take on 1st passing square
 296           const px = this.board[x][epsq.y] != V.EMPTY ? x : x - shiftX;
 297           enpassantMove.vanish.push({
 298             x: px,
 299             y: epsq.y,
 300             p: "p",
 301             c: this.getColor(px, epsq.y)
 302           });
 303           moves.push(enpassantMove);
 304         }
 305       }
 306     }
 307     return moves;
 308   }
 309
 310   addPawnMoves([x1, y1], [x2, y2], moves, promotions) {
 311     let finalPieces = [V.PAWN];
 312     const color = this.turn;
 313     const lastRank = (color == "w" ? 1 : V.size.x - 2);
 314     if (x2 == lastRank) {
 315       // promotions arg: special override for Hiddenqueen variant
 316       if (!!promotions) finalPieces = promotions;
 317       else if (!!V.PawnSpecs.promotions) finalPieces = V.PawnSpecs.promotions;
 318     }
 319     let tr = null;
 320     for (let piece of finalPieces) {
 321       tr = (piece != V.PAWN ? { c: color, p: piece } : null);
 322       moves.push(this.getBasicMove([x1, y1], [x2, y2], tr));
 323     }
 324   }
 325
 326   getPotentialChampionMoves(sq) {
 327     return this.getSlideNJumpMoves(sq, V.steps[V.CHAMPION], "oneStep");
 328   }
 329
 330   getPotentialWizardMoves(sq) {
 331     return this.getSlideNJumpMoves(sq, V.steps[V.WIZARD], "oneStep");
 332   }
 333
 334   getCastleMoves([x, y], castleInCheck) {
 335     const c = this.getColor(x, y);
 336     if (x != (c == "w" ? V.size.x - 2 : 1) || y != this.INIT_COL_KING[c])
 337       return []; //x isn't first rank, or king has moved (shortcut)
 338
 339     // Castling ?
 340     const oppCol = V.GetOppCol(c);
 341     let moves = [];
 342     let i = 0;
 343     // King, then rook:
 344     const finalSquares = [
 345       [4, 5],
 346       [8, 7]
 347     ];
 348     castlingCheck: for (
 349       let castleSide = 0;
 350       castleSide < 2;
 351       castleSide++ //large, then small
 352     ) {
 353       if (this.castleFlags[c][castleSide] >= V.size.y) continue;
 354       // If this code is reached, rook and king are on initial position
 355
 356       // NOTE: in some variants this is not a rook
 357       const rookPos = this.castleFlags[c][castleSide];
 358       if (this.board[x][rookPos] == V.EMPTY || this.getColor(x, rookPos) != c)
 359         // Rook is not here, or changed color (see Benedict)
 360         continue;
 361
 362       // Nothing on the path of the king ? (and no checks)
 363       const castlingPiece = this.getPiece(x, rookPos);
 364       const finDist = finalSquares[castleSide][0] - y;
 365       let step = finDist / Math.max(1, Math.abs(finDist));
 366       i = y;
 367       do {
 368         if (
 369           (!castleInCheck && this.isAttacked([x, i], oppCol)) ||
 370           (this.board[x][i] != V.EMPTY &&
 371             // NOTE: next check is enough, because of chessboard constraints
 372             (this.getColor(x, i) != c ||
 373               ![V.KING, castlingPiece].includes(this.getPiece(x, i))))
 374         ) {
 375           continue castlingCheck;
 376         }
 377         i += step;
 378       } while (i != finalSquares[castleSide][0]);
 379
 380       // Nothing on the path to the rook?
 381       step = castleSide == 0 ? -1 : 1;
 382       for (i = y + step; i != rookPos; i += step) {
 383         if (this.board[x][i] != V.EMPTY) continue castlingCheck;
 384       }
 385
 386       // Nothing on final squares, except maybe king and castling rook?
 387       for (i = 0; i < 2; i++) {
 388         if (
 389           finalSquares[castleSide][i] != rookPos &&
 390           this.board[x][finalSquares[castleSide][i]] != V.EMPTY &&
 391           (
 392             this.getPiece(x, finalSquares[castleSide][i]) != V.KING ||
 393             this.getColor(x, finalSquares[castleSide][i]) != c
 394           )
 395         ) {
 396           continue castlingCheck;
 397         }
 398       }
 399
 400       // If this code is reached, castle is valid
 401       moves.push(
 402         new Move({
 403           appear: [
 404             new PiPo({
 405               x: x,
 406               y: finalSquares[castleSide][0],
 407               p: V.KING,
 408               c: c
 409             }),
 410             new PiPo({
 411               x: x,
 412               y: finalSquares[castleSide][1],
 413               p: castlingPiece,
 414               c: c
 415             })
 416           ],
 417           vanish: [
 418             new PiPo({ x: x, y: y, p: V.KING, c: c }),
 419             new PiPo({ x: x, y: rookPos, p: castlingPiece, c: c })
 420           ],
 421           end:
 422             Math.abs(y - rookPos) <= 2
 423               ? { x: x, y: rookPos }
 424               : { x: x, y: y + 2 * (castleSide == 0 ? -1 : 1) }
 425         })
 426       );
 427     }
 428
 429     return moves;
 430   }
 431
 432   isAttacked(sq, color) {
 433     return (
 434       super.isAttacked(sq, color) ||
 435       this.isAttackedByChampion(sq, color) ||
 436       this.isAttackedByWizard(sq, color)
 437     );
 438   }
 439
 440   isAttackedByWizard(sq, color) {
 441     return (
 442       this.isAttackedBySlideNJump(
 443         sq, color, V.WIZARD, V.steps[V.WIZARD], "oneStep")
 444     );
 445   }
 446
 447   isAttackedByChampion(sq, color) {
 448     return (
 449       this.isAttackedBySlideNJump(
 450         sq, color, V.CHAMPION, V.steps[V.CHAMPION], "oneStep")
 451     );
 452   }
 453
 454   updateCastleFlags(move, piece) {
 455     const c = V.GetOppCol(this.turn);
 456     const firstRank = (c == "w" ? V.size.x - 2 : 1);
 457     // Update castling flags if rooks are moved
 458     const oppCol = this.turn;
 459     const oppFirstRank = V.size.x - 1 - firstRank;
 460     if (piece == V.KING)
 461       this.castleFlags[c] = [V.size.y, V.size.y];
 462     else if (
 463       move.start.x == firstRank && //our rook moves?
 464       this.castleFlags[c].includes(move.start.y)
 465     ) {
 466       const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1);
 467       this.castleFlags[c][flagIdx] = V.size.y;
 468     }
 469     // NOTE: not "else if" because a rook could take an opposing rook
 470     if (
 471       move.end.x == oppFirstRank && //we took opponent rook?
 472       this.castleFlags[oppCol].includes(move.end.y)
 473     ) {
 474       const flagIdx = (move.end.y == this.castleFlags[oppCol][0] ? 0 : 1);
 475       this.castleFlags[oppCol][flagIdx] = V.size.y;
 476     }
 477   }
 478
 479   static get SEARCH_DEPTH() {
 480     return 2;
 481   }
 482
 483   // Values taken from https://omegachess.com/strategy.htm
 484   static get VALUES() {
 485     return {
 486       p: 1,
 487       n: 2,
 488       b: 4,
 489       r: 6,
 490       q: 12,
 491       w: 4,
 492       c: 4,
 493       k: 1000
 494     };
 495   }
 496
 497   evalPosition() {
 498     let evaluation = 0;
 499     for (let i = 0; i < V.size.x; i++) {
 500       for (let j = 0; j < V.size.y; j++) {
 501         if (![V.EMPTY,V.NOTHING].includes(this.board[i][j])) {
 502           const sign = this.getColor(i, j) == "w" ? 1 : -1;
 503           evaluation += sign * V.VALUES[this.getPiece(i, j)];
 504         }
 505       }
 506     }
 507     return evaluation;
 508   }
 509 };