public/javascripts/variants/Wildebeest.js

   1 //https://www.chessvariants.com/large.dir/wildebeest.html
   2 class WildebeestRules extends ChessRules
   3 {
   4     static getPpath(b)
   5     {
   6         const V = VariantRules;
   7         return ([V.CAMEL,V.WILDEBEEST].includes(b[1]) ? "Wildebeest/" : "") + b;
   8     }
   9
  10     static get size() { return [10,11]; }
  11
  12     static get CAMEL() { return 'c'; }
  13     static get WILDEBEEST() { return 'w'; }
  14
  15     static get steps() {
  16         return Object.assign(
  17             ChessRules.steps, //add camel moves:
  18             {'c': [ [-3,-1],[-3,1],[-1,-3],[-1,3],[1,-3],[1,3],[3,-1],[3,1] ]}
  19         );
  20     }
  21
  22     // En-passant after 2-sq or 3-sq jumps
  23     getEpSquare(move)
  24     {
  25         const [sx,sy,ex] = [move.start.x,move.start.y,move.end.x];
  26         if (this.getPiece(sx,sy) == VariantRules.PAWN && Math.abs(sx - ex) >= 2)
  27         {
  28             const step = (ex-sx) / Math.abs(ex-sx);
  29             let res = [{
  30                 x: sx + step,
  31                 y: sy
  32             }];
  33             if (sx + 2*step != ex) //3-squares move
  34             {
  35                 res.push({
  36                     x: sx + 2*step,
  37                     y: sy
  38                 });
  39             }
  40             return res;
  41         }
  42         return undefined; //default
  43     }
  44
  45     getPotentialMovesFrom([x,y])
  46     {
  47         switch (this.getPiece(x,y))
  48         {
  49             case VariantRules.CAMEL:
  50                 return this.getPotentialCamelMoves([x,y]);
  51             case VariantRules.WILDEBEEST:
  52                 return this.getPotentialWildebeestMoves([x,y]);
  53             default:
  54                 return super.getPotentialMovesFrom([x,y])
  55         }
  56     }
  57
  58     // Pawns jump 2 or 3 squares, and promote to queen or wildebeest
  59     getPotentialPawnMoves([x,y])
  60     {
  61         const color = this.turn;
  62         let moves = [];
  63         const V = VariantRules;
  64         const [sizeX,sizeY] = VariantRules.size;
  65         const shift = (color == "w" ? -1 : 1);
  66         const startRanks = (color == "w" ? [sizeY-2,sizeY-3] : [1,2]);
  67         const lastRank = (color == "w" ? 0 : sizeY-1);
  68
  69         if (x+shift >= 0 && x+shift < sizeX && x+shift != lastRank)
  70         {
  71             // Normal moves
  72             if (this.board[x+shift][y] == V.EMPTY)
  73             {
  74                 moves.push(this.getBasicMove([x,y], [x+shift,y]));
  75                 if (startRanks.includes(x) && this.board[x+2*shift][y] == V.EMPTY)
  76                 {
  77                     // Two squares jump
  78                     moves.push(this.getBasicMove([x,y], [x+2*shift,y]));
  79                     if (x == startRanks[0] && this.board[x+3*shift][y] == V.EMPTY)
  80                     {
  81                         // 3-squares jump
  82                         moves.push(this.getBasicMove([x,y], [x+3*shift,y]));
  83                     }
  84                 }
  85             }
  86             // Captures
  87             if (y>0 && this.canTake([x,y], [x+shift,y-1]) && this.board[x+shift][y-1] != V.EMPTY)
  88                 moves.push(this.getBasicMove([x,y], [x+shift,y-1]));
  89             if (y<sizeY-1 && this.canTake([x,y], [x+shift,y+1]) && this.board[x+shift][y+1] != V.EMPTY)
  90                 moves.push(this.getBasicMove([x,y], [x+shift,y+1]));
  91         }
  92
  93         if (x+shift == lastRank)
  94         {
  95             // Promotion
  96             let promotionPieces = [V.QUEEN,V.WILDEBEEST];
  97             promotionPieces.forEach(p => {
  98                 // Normal move
  99                 if (this.board[x+shift][y] == V.EMPTY)
 100                     moves.push(this.getBasicMove([x,y], [x+shift,y], {c:color,p:p}));
 101                 // Captures
 102                 if (y>0 && this.canTake([x,y], [x+shift,y-1]) && this.board[x+shift][y-1] != V.EMPTY)
 103                     moves.push(this.getBasicMove([x,y], [x+shift,y-1], {c:color,p:p}));
 104                 if (y<sizeY-1 && this.canTake([x,y], [x+shift,y+1]) && this.board[x+shift][y+1] != V.EMPTY)
 105                     moves.push(this.getBasicMove([x,y], [x+shift,y+1], {c:color,p:p}));
 106             });
 107         }
 108
 109         // En passant
 110         const Lep = this.epSquares.length;
 111         const epSquare = Lep>0 ? this.epSquares[Lep-1] : undefined;
 112         if (!!epSquare)
 113         {
 114             for (let epsq of epSquare)
 115             {
 116                 // TODO: some redundant checks
 117                 if (epsq.x == x+shift && Math.abs(epsq.y - y) == 1)
 118                 {
 119                     let epStep = epsq.y - y;
 120                     var enpassantMove = this.getBasicMove([x,y], [x+shift,y+epStep]);
 121                     enpassantMove.vanish.push({
 122                         x: x,
 123                         y: y+epStep,
 124                         p: 'p',
 125                         c: this.getColor(x,y+epStep)
 126                     });
 127                     moves.push(enpassantMove);
 128                 }
 129             }
 130         }
 131
 132         return moves;
 133     }
 134
 135     // TODO: wildebeest castle
 136
 137     getPotentialCamelMoves(sq)
 138     {
 139         return this.getSlideNJumpMoves(sq, VariantRules.steps[VariantRules.CAMEL], "oneStep");
 140     }
 141
 142     getPotentialWildebeestMoves(sq)
 143     {
 144         const V = VariantRules;
 145         return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), "oneStep");
 146     }
 147
 148     isAttacked(sq, colors)
 149     {
 150         return super.isAttacked(sq, colors)
 151             || this.isAttackedByCamel(sq, colors)
 152             || this.isAttackedByWildebeest(sq, colors);
 153     }
 154
 155     isAttackedByCamel(sq, colors)
 156     {
 157         return this.isAttackedBySlideNJump(sq, colors,
 158             VariantRules.CAMEL, VariantRules.steps[VariantRules.CAMEL]);
 159     }
 160
 161     isAttackedByWildebeest(sq, colors)
 162     {
 163         const V = VariantRules;
 164         return this.isAttackedBySlideNJump(sq, colors, V.WILDEBEEST,
 165             V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]));
 166     }
 167
 168     // TODO: stalemate is a win (?!)
 169
 170     static get VALUES() {
 171         return Object.assign(
 172             ChessRules.VALUES,
 173             {'c': 3, 'w': 7} //experimental
 174         );
 175     }
 176
 177     static get SEARCH_DEPTH() { return 2; }
 178
 179     static GenRandInitFen()
 180     {
 181         let pieces = [new Array(10), new Array(10)];
 182         // Shuffle pieces on first and last rank
 183         for (let c = 0; c <= 1; c++)
 184         {
 185             let positions = _.range(11);
 186
 187             // Get random squares for bishops
 188             let randIndex = 2 * _.random(5);
 189             let bishop1Pos = positions[randIndex];
 190             // The second bishop must be on a square of different color
 191             let randIndex_tmp = 2 * _.random(4) + 1;
 192             let bishop2Pos = positions[randIndex_tmp];
 193             // Remove chosen squares
 194             positions.splice(Math.max(randIndex,randIndex_tmp), 1);
 195             positions.splice(Math.min(randIndex,randIndex_tmp), 1);
 196
 197             // Get random squares for knights
 198             randIndex = _.random(8);
 199             let knight1Pos = positions[randIndex];
 200             positions.splice(randIndex, 1);
 201             randIndex = _.random(7);
 202             let knight2Pos = positions[randIndex];
 203             positions.splice(randIndex, 1);
 204
 205             // Get random square for queen
 206             randIndex = _.random(6);
 207             let queenPos = positions[randIndex];
 208             positions.splice(randIndex, 1);
 209
 210             // ...random square for camels
 211             randIndex = _.random(5);
 212             let camel1Pos = positions[randIndex];
 213             positions.splice(randIndex, 1);
 214             randIndex = _.random(4);
 215             let camel2Pos = positions[randIndex];
 216             positions.splice(randIndex, 1);
 217
 218             // ...random square for wildebeest
 219             randIndex = _.random(3);
 220             let wildebeestPos = positions[randIndex];
 221             positions.splice(randIndex, 1);
 222
 223             // Rooks and king positions are now fixed, because of the ordering rook-king-rook
 224             let rook1Pos = positions[0];
 225             let kingPos = positions[1];
 226             let rook2Pos = positions[2];
 227
 228             // Finally put the shuffled pieces in the board array
 229             pieces[c][rook1Pos] = 'r';
 230             pieces[c][knight1Pos] = 'n';
 231             pieces[c][bishop1Pos] = 'b';
 232             pieces[c][queenPos] = 'q';
 233             pieces[c][camel1Pos] = 'c';
 234             pieces[c][camel2Pos] = 'c';
 235             pieces[c][wildebeestPos] = 'w';
 236             pieces[c][kingPos] = 'k';
 237             pieces[c][bishop2Pos] = 'b';
 238             pieces[c][knight2Pos] = 'n';
 239             pieces[c][rook2Pos] = 'r';
 240         }
 241         let fen = pieces[0].join("") +
 242             "/ppppppppppp/11/11/11/11/11/11/PPPPPPPPPPP/" +
 243             pieces[1].join("").toUpperCase() +
 244             " 1111";
 245         return fen;
 246     }
 247 }