client/src/variants/Cwda.js

   1 import { ChessRules } from "@/base_rules";
   2
   3 export class CwdaRules extends ChessRules {
   4
   5   static get Options() {
   6     return {
   7       select: ChessRules.Options.select.concat([
   8         {
   9           label: "Army 1",
  10           variable: "army1",
  11           defaut: 'C',
  12           options: [
  13             { label: "Colorbound Clobberers", value: 'C' },
  14             { label: "Nutty Knights", value: 'N' },
  15             { label: "Remarkable Rookies", value: 'R' },
  16             { label: "Fide", value: 'F' }
  17           ]
  18         },
  19         {
  20           label: "Army 2",
  21           variable: "army2",
  22           defaut: 'C',
  23           options: [
  24             { label: "Colorbound Clobberers", value: 'C' },
  25             { label: "Nutty Knights", value: 'N' },
  26             { label: "Remarkable Rookies", value: 'R' },
  27             { label: "Fide", value: 'F' }
  28           ]
  29         }
  30       ])
  31     };
  32   }
  33
  34   static AbbreviateOptions(opts) {
  35     return opts["army1"] + opts["army2"];
  36   }
  37
  38   static IsValidOptions(opts) {
  39     // Both armies filled, avoid Fide vs Fide
  40     return (
  41       opts.army1 && opts.army2 &&
  42       (opts.army1 != 'F' || opts.army2 != 'F')
  43     );
  44   }
  45
  46   getPpath(b) {
  47     return (ChessRules.PIECES.includes(b[1]) ? "" : "Cwda/") + b;
  48   }
  49
  50   static get PiecesMap() {
  51     return {
  52       // Colorbound Clobberers
  53       'C': {
  54         'r': 'd',
  55         'n': 'w',
  56         'b': 'f',
  57         'q': 'c',
  58         'k': 'k'
  59       },
  60       // Nutty Knights
  61       'N': {
  62         'r': 'g',
  63         'n': 'i',
  64         'b': 't',
  65         'q': 'l',
  66         'k': 'k'
  67       },
  68       // Remarkable Rookies
  69       'R': {
  70         'r': 's',
  71         'n': 'y',
  72         'b': 'h',
  73         'q': 'o',
  74         'k': 'k'
  75       }
  76     };
  77   }
  78
  79   static GenRandInitFen(options) {
  80     const baseFen = ChessRules.GenRandInitFen(options.randomness);
  81     let blackLine = baseFen.substr(0, 8);
  82     if (options.army2 != 'F') {
  83       blackLine = blackLine.split('')
  84         .map(p => V.PiecesMap[options.army2][p]).join('');
  85     }
  86     let whiteLine = baseFen.substr(35, 8);
  87     if (options.army1 != 'F') {
  88       whiteLine = whiteLine.split('')
  89         .map(p => V.PiecesMap[options.army1][p.toLowerCase()])
  90         .join('').toUpperCase();
  91     }
  92     return (
  93       blackLine + baseFen.substring(8, 35) + whiteLine +
  94       baseFen.substr(43) + " " + options.army1 + options.army2
  95     );
  96   }
  97
  98   setOtherVariables(fen) {
  99     super.setOtherVariables(fen);
 100     const armies = V.ParseFen(fen).armies;
 101     this.army1 = armies.charAt(0);
 102     this.army2 = armies.charAt(1);
 103   }
 104
 105   static ParseFen(fen) {
 106     return Object.assign(
 107       { armies: fen.split(" ")[5] },
 108       ChessRules.ParseFen(fen)
 109     );
 110   }
 111
 112   static IsGoodFen(fen) {
 113     if (!ChessRules.IsGoodFen(fen)) return false;
 114     const armies = V.ParseFen(fen).armies;
 115     if (!armies || !armies.match(/^[CNRF]{2,2}$/)) return false;
 116     return true;
 117   }
 118
 119   getFen() {
 120     return super.getFen() + " " + this.army1 + this.army2;
 121   }
 122
 123   static get C_ROOK() {
 124     return 'd';
 125   }
 126   static get C_KNIGHT() {
 127     return 'w';
 128   }
 129   static get C_BISHOP() {
 130     return 'f';
 131   }
 132   static get C_QUEEN() {
 133     return 'c';
 134   }
 135   static get N_ROOK() {
 136     return 'g';
 137   }
 138   static get N_KNIGHT() {
 139     return 'i';
 140   }
 141   static get N_BISHOP() {
 142     return 't';
 143   }
 144   static get N_QUEEN() {
 145     return 'l';
 146   }
 147   static get R_ROOK() {
 148     return 's';
 149   }
 150   static get R_KNIGHT() {
 151     return 'y';
 152   }
 153   static get R_BISHOP() {
 154     return 'h';
 155   }
 156   static get R_QUEEN() {
 157     return 'o';
 158   }
 159
 160   static get PIECES() {
 161     return ChessRules.PIECES.concat(
 162       [V.C_ROOK, V.C_KNIGHT, V.C_BISHOP, V.C_QUEEN]).concat(
 163       [V.N_ROOK, V.N_KNIGHT, V.N_BISHOP, V.N_QUEEN]).concat(
 164       [V.R_ROOK, V.R_KNIGHT, V.R_BISHOP, V.R_QUEEN]);
 165   }
 166
 167   getPotentialMovesFrom(sq) {
 168     switch (this.getPiece(sq[0], sq[1])) {
 169       case V.C_ROOK: return this.getPotentialC_rookMoves(sq);
 170       case V.C_KNIGHT: return this.getPotentialC_knightMoves(sq);
 171       case V.C_BISHOP: return this.getPotentialC_bishopMoves(sq);
 172       case V.C_QUEEN: return this.getPotentialC_queenMoves(sq);
 173       case V.N_ROOK: return this.getPotentialN_rookMoves(sq);
 174       case V.N_KNIGHT: return this.getPotentialN_knightMoves(sq);
 175       case V.N_BISHOP: return this.getPotentialN_bishopMoves(sq);
 176       case V.N_QUEEN: return this.getPotentialN_queenMoves(sq);
 177       case V.R_ROOK: return this.getPotentialR_rookMoves(sq);
 178       case V.R_KNIGHT: return this.getPotentialR_knightMoves(sq);
 179       case V.R_BISHOP: return this.getPotentialR_bishopMoves(sq);
 180       case V.R_QUEEN: return this.getPotentialR_queenMoves(sq);
 181       case V.PAWN: {
 182         // Can promote in anything from the two current armies
 183         let promotions = [];
 184         for (let army of ["army1", "army2"]) {
 185           if (army == "army2" && this.army2 == this.army1) break;
 186           switch (this[army]) {
 187             case 'C': {
 188               Array.prototype.push.apply(promotions,
 189                 [V.C_ROOK, V.C_KNIGHT, V.C_BISHOP, V.C_QUEEN]);
 190               break;
 191             }
 192             case 'N': {
 193               Array.prototype.push.apply(promotions,
 194                 [V.N_ROOK, V.N_KNIGHT, V.N_BISHOP, V.N_QUEEN]);
 195               break;
 196             }
 197             case 'R': {
 198               Array.prototype.push.apply(promotions,
 199                 [V.R_ROOK, V.R_KNIGHT, V.R_BISHOP, V.R_QUEEN]);
 200               break;
 201             }
 202             case 'F': {
 203               Array.prototype.push.apply(promotions,
 204                 [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]);
 205               break;
 206             }
 207           }
 208         }
 209         return super.getPotentialPawnMoves(sq, promotions);
 210       }
 211       default: return super.getPotentialMovesFrom(sq);
 212     }
 213     return [];
 214   }
 215
 216   static get steps() {
 217     return Object.assign(
 218       {
 219         // Dabbabah
 220         'd': [
 221           [-2, 0],
 222           [0, -2],
 223           [2, 0],
 224           [0, 2]
 225         ],
 226         // Alfil
 227         'a': [
 228           [2, 2],
 229           [2, -2],
 230           [-2, 2],
 231           [-2, -2]
 232         ],
 233         // Ferz
 234         'f': [
 235           [1, 1],
 236           [1, -1],
 237           [-1, 1],
 238           [-1, -1]
 239         ],
 240         // Wazir
 241         'w': [
 242           [-1, 0],
 243           [0, -1],
 244           [1, 0],
 245           [0, 1]
 246         ],
 247         // Threeleaper
 248         '$3': [
 249           [-3, 0],
 250           [0, -3],
 251           [3, 0],
 252           [0, 3]
 253         ],
 254         // Narrow knight
 255         '$n': [
 256           [-2, -1],
 257           [-2, 1],
 258           [2, -1],
 259           [2, 1]
 260         ]
 261       },
 262       ChessRules.steps,
 263     );
 264   }
 265
 266   getPotentialC_rookMoves(sq) {
 267     return (
 268       this.getSlideNJumpMoves(sq, V.steps.b).concat(
 269       this.getSlideNJumpMoves(sq, V.steps.d, 1))
 270     );
 271   }
 272
 273   getPotentialC_knightMoves(sq) {
 274     return (
 275       this.getSlideNJumpMoves(sq, V.steps.a, 1).concat(
 276       this.getSlideNJumpMoves(sq, V.steps.r, 1))
 277     );
 278   }
 279
 280   getPotentialC_bishopMoves(sq) {
 281     return (
 282       this.getSlideNJumpMoves(sq, V.steps.d, 1).concat(
 283       this.getSlideNJumpMoves(sq, V.steps.a, 1)).concat(
 284       this.getSlideNJumpMoves(sq, V.steps.b, 1))
 285     );
 286   }
 287
 288   getPotentialC_queenMoves(sq) {
 289     return (
 290       this.getSlideNJumpMoves(sq, V.steps.b).concat(
 291         this.getSlideNJumpMoves(sq, V.steps.n, 1))
 292     );
 293   }
 294
 295   getPotentialN_rookMoves(sq) {
 296     const c = this.turn;
 297     const rookSteps = [ [0, -1], [0, 1], [c == 'w' ? -1 : 1, 0] ];
 298     const backward = (c == 'w' ? 1 : -1);
 299     const kingSteps = [ [backward, -1], [backward, 0], [backward, 1] ];
 300     return (
 301       this.getSlideNJumpMoves(sq, rookSteps).concat(
 302       this.getSlideNJumpMoves(sq, kingSteps, 1))
 303     );
 304   }
 305
 306   getPotentialN_knightMoves(sq) {
 307     return (
 308       this.getSlideNJumpMoves(sq, V.steps.$n, 1).concat(
 309       this.getSlideNJumpMoves(sq, V.steps.f, 1))
 310     );
 311   }
 312
 313   getPotentialN_bishopMoves(sq) {
 314     const backward = (this.turn == 'w' ? 1 : -1);
 315     const kingSteps = [
 316       [0, -1], [0, 1], [backward, -1], [backward, 0], [backward, 1]
 317     ];
 318     const forward = -backward;
 319     const knightSteps = [
 320       [2*forward, -1], [2*forward, 1], [forward, -2], [forward, 2]
 321     ];
 322     return (
 323       this.getSlideNJumpMoves(sq, knightSteps, 1).concat(
 324       this.getSlideNJumpMoves(sq, kingSteps, 1))
 325     );
 326   }
 327
 328   getPotentialN_queenMoves(sq) {
 329     const backward = (this.turn == 'w' ? 1 : -1);
 330     const forward = -backward;
 331     const kingSteps = [
 332       [forward, -1], [forward, 1],
 333       [backward, -1], [backward, 0], [backward, 1]
 334     ];
 335     const knightSteps = [
 336       [2*forward, -1], [2*forward, 1], [forward, -2], [forward, 2]
 337     ];
 338     const rookSteps = [ [0, -1], [0, 1], [forward, 0] ];
 339     return (
 340       this.getSlideNJumpMoves(sq, rookSteps).concat(
 341       this.getSlideNJumpMoves(sq, kingSteps, 1)).concat(
 342       this.getSlideNJumpMoves(sq, knightSteps, 1))
 343     );
 344   }
 345
 346   getPotentialR_rookMoves(sq) {
 347     return this.getSlideNJumpMoves(sq, V.steps.r, 4);
 348   }
 349
 350   getPotentialR_knightMoves(sq) {
 351     return (
 352       this.getSlideNJumpMoves(sq, V.steps.d, 1).concat(
 353       this.getSlideNJumpMoves(sq, V.steps.w, 1))
 354     );
 355   }
 356
 357   getPotentialR_bishopMoves(sq) {
 358     return (
 359       this.getSlideNJumpMoves(sq, V.steps.d, 1).concat(
 360       this.getSlideNJumpMoves(sq, V.steps.f, 1)).concat(
 361       this.getSlideNJumpMoves(sq, V.steps.$3, 1))
 362     );
 363   }
 364
 365   getPotentialR_queenMoves(sq) {
 366     return (
 367       this.getSlideNJumpMoves(sq, V.steps.r).concat(
 368       this.getSlideNJumpMoves(sq, V.steps.n, 1))
 369     );
 370   }
 371
 372   getCastleMoves([x, y]) {
 373     const color = this.getColor(x, y);
 374     let finalSquares = [ [2, 3], [V.size.y - 2, V.size.y - 3] ];
 375     if (
 376       (color == 'w' && this.army1 == 'C') ||
 377       (color == 'b' && this.army2 == 'C')
 378     ) {
 379       // Colorbound castle long in an unusual way:
 380       finalSquares[0] = [1, 2];
 381     }
 382     return super.getCastleMoves([x, y], finalSquares);
 383   }
 384
 385   isAttacked(sq, color) {
 386     if (super.isAttackedByPawn(sq, color) || super.isAttackedByKing(sq, color))
 387       return true;
 388     for (let army of ['C', 'N', 'R', 'F']) {
 389       if (
 390         [this.army1, this.army2].includes(army) &&
 391         (
 392           this["isAttackedBy" + army + "_rook"](sq, color) ||
 393           this["isAttackedBy" + army + "_knight"](sq, color) ||
 394           this["isAttackedBy" + army + "_bishop"](sq, color) ||
 395           this["isAttackedBy" + army + "_queen"](sq, color)
 396         )
 397       ) {
 398         return true;
 399       }
 400     }
 401     return false;
 402   }
 403
 404   isAttackedByC_rook(sq, color) {
 405     return (
 406       this.isAttackedBySlideNJump(sq, color, V.C_ROOK, V.steps.b) ||
 407       this.isAttackedBySlideNJump(sq, color, V.C_ROOK, V.steps.d, 1)
 408     );
 409   }
 410
 411   isAttackedByC_knight(sq, color) {
 412     return (
 413       this.isAttackedBySlideNJump(sq, color, V.C_KNIGHT, V.steps.r, 1) ||
 414       this.isAttackedBySlideNJump(sq, color, V.C_KNIGHT, V.steps.a, 1)
 415     );
 416   }
 417
 418   isAttackedByC_bishop(sq, color) {
 419     return (
 420       this.isAttackedBySlideNJump(sq, color, V.C_BISHOP, V.steps.d, 1) ||
 421       this.isAttackedBySlideNJump(sq, color, V.C_BISHOP, V.steps.a, 1) ||
 422       this.isAttackedBySlideNJump(sq, color, V.C_BISHOP, V.steps.f, 1)
 423     );
 424   }
 425
 426   isAttackedByC_queen(sq, color) {
 427     return (
 428       this.isAttackedBySlideNJump(sq, color, V.C_QUEEN, V.steps.b) ||
 429       this.isAttackedBySlideNJump(sq, color, V.C_QUEEN, V.steps.n, 1)
 430     );
 431   }
 432
 433   isAttackedByN_rook(sq, color) {
 434     const rookSteps = [ [0, -1], [0, 1], [color == 'w' ? 1 : -1, 0] ];
 435     const backward = (color == 'w' ? -1 : 1);
 436     const kingSteps = [ [backward, -1], [backward, 0], [backward, 1] ];
 437     return (
 438       this.isAttackedBySlideNJump(sq, color, V.N_ROOK, rookSteps) ||
 439       this.isAttackedBySlideNJump(sq, color, V.N_ROOK, kingSteps, 1)
 440     );
 441   }
 442
 443   isAttackedByN_knight(sq, color) {
 444     return (
 445       this.isAttackedBySlideNJump(sq, color, V.N_KNIGHT, V.steps.$n, 1) ||
 446       this.isAttackedBySlideNJump(sq, color, V.N_KNIGHT, V.steps.f, 1)
 447     );
 448   }
 449
 450   isAttackedByN_bishop(sq, color) {
 451     const backward = (color == 'w' ? -1 : 1);
 452     const kingSteps = [
 453       [0, -1], [0, 1], [backward, -1], [backward, 0], [backward, 1]
 454     ];
 455     const forward = -backward;
 456     const knightSteps = [
 457       [2*forward, -1], [2*forward, 1], [forward, -2], [forward, 2]
 458     ];
 459     return (
 460       this.isAttackedBySlideNJump(sq, color, V.N_BISHOP, knightSteps, 1) ||
 461       this.isAttackedBySlideNJump(sq, color, V.N_BISHOP, kingSteps, 1)
 462     );
 463   }
 464
 465   isAttackedByN_queen(sq, color) {
 466     const backward = (color == 'w' ? -1 : 1);
 467     const forward = -backward;
 468     const kingSteps = [
 469       [forward, -1], [forward, 1],
 470       [backward, -1], [backward, 0], [backward, 1]
 471     ];
 472     const knightSteps = [
 473       [2*forward, -1], [2*forward, 1], [forward, -2], [forward, 2]
 474     ];
 475     const rookSteps = [ [0, -1], [0, 1], [forward, 0] ];
 476     return (
 477       this.isAttackedBySlideNJump(sq, color, V.N_QUEEN, knightSteps, 1) ||
 478       this.isAttackedBySlideNJump(sq, color, V.N_QUEEN, kingSteps, 1) ||
 479       this.isAttackedBySlideNJump(sq, color, V.N_QUEEN, rookSteps)
 480     );
 481   }
 482
 483   isAttackedByR_rook(sq, color) {
 484     return this.isAttackedBySlideNJump(sq, color, V.R_ROOK, V.steps.r, 4);
 485   }
 486
 487   isAttackedByR_knight(sq, color) {
 488     return (
 489       this.isAttackedBySlideNJump(sq, color, V.R_KNIGHT, V.steps.d, 1) ||
 490       this.isAttackedBySlideNJump(sq, color, V.R_KNIGHT, V.steps.w, 1)
 491     );
 492   }
 493
 494   isAttackedByR_bishop(sq, color) {
 495     return (
 496       this.isAttackedBySlideNJump(sq, color, V.R_BISHOP, V.steps.d, 1) ||
 497       this.isAttackedBySlideNJump(sq, color, V.R_BISHOP, V.steps.f, 1) ||
 498       this.isAttackedBySlideNJump(sq, color, V.R_BISHOP, V.steps.$3, 1)
 499     );
 500   }
 501
 502   isAttackedByR_queen(sq, color) {
 503     return (
 504       this.isAttackedBySlideNJump(sq, color, V.R_QUEEN, V.steps.r) ||
 505       this.isAttackedBySlideNJump(sq, color, V.R_QUEEN, V.steps.n, 1)
 506     );
 507   }
 508
 509   // [HACK] So that the function above works also on Fide army:
 510   isAttackedByF_rook(sq, color) {
 511     return super.isAttackedByRook(sq, color);
 512   }
 513   isAttackedByF_knight(sq, color) {
 514     return super.isAttackedByKnight(sq, color);
 515   }
 516   isAttackedByF_bishop(sq, color) {
 517     return super.isAttackedByBishop(sq, color);
 518   }
 519   isAttackedByF_queen(sq, color) {
 520     return super.isAttackedByQueen(sq, color);
 521   }
 522
 523   static get VALUES() {
 524     return Object.assign(
 525       {
 526         d: 4,
 527         w: 3,
 528         f: 5,
 529         c: 7,
 530         g: 4,
 531         i: 3,
 532         t: 4,
 533         l: 7,
 534         s: 4,
 535         y: 3,
 536         h: 4,
 537         o: 8
 538       },
 539       ChessRules.VALUES
 540     );
 541   }
 542
 543   static get SEARCH_DEPTH() {
 544     return 2;
 545   }
 546
 547 };