client/src/variants/Losers.js

   1 import { ChessRules } from "@/base_rules";
   2 import { ArrayFun } from "@/utils/array";
   3 import { randInt } from "@/utils/alea";
   4
   5 export const VariantRules = class LosersRules extends ChessRules {
   6   static get HasFlags() {
   7     return false;
   8   }
   9
  10   getPotentialPawnMoves([x, y]) {
  11     let moves = super.getPotentialPawnMoves([x, y]);
  12
  13     // Complete with promotion(s) into king, if possible
  14     const color = this.turn;
  15     const shift = color == "w" ? -1 : 1;
  16     const lastRank = color == "w" ? 0 : V.size.x - 1;
  17     if (x + shift == lastRank) {
  18       // Normal move
  19       if (this.board[x + shift][y] == V.EMPTY)
  20         moves.push(
  21           this.getBasicMove([x, y], [x + shift, y], { c: color, p: V.KING })
  22         );
  23       // Captures
  24       if (
  25         y > 0 &&
  26         this.canTake([x, y], [x + shift, y - 1]) &&
  27         this.board[x + shift][y - 1] != V.EMPTY
  28       ) {
  29         moves.push(
  30           this.getBasicMove([x, y], [x + shift, y - 1], { c: color, p: V.KING })
  31         );
  32       }
  33       if (
  34         y < V.size.y - 1 &&
  35         this.canTake([x, y], [x + shift, y + 1]) &&
  36         this.board[x + shift][y + 1] != V.EMPTY
  37       ) {
  38         moves.push(
  39           this.getBasicMove([x, y], [x + shift, y + 1], { c: color, p: V.KING })
  40         );
  41       }
  42     }
  43
  44     return moves;
  45   }
  46
  47   getPotentialKingMoves(sq) {
  48     // No castle:
  49     return this.getSlideNJumpMoves(
  50       sq,
  51       V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
  52       "oneStep"
  53     );
  54   }
  55
  56   // Stop at the first capture found (if any)
  57   atLeastOneCapture() {
  58     const color = this.turn;
  59     const oppCol = V.GetOppCol(color);
  60     for (let i = 0; i < V.size.x; i++) {
  61       for (let j = 0; j < V.size.y; j++) {
  62         if (this.board[i][j] != V.EMPTY && this.getColor(i, j) != oppCol) {
  63           const moves = this.getPotentialMovesFrom([i, j]);
  64           if (moves.length > 0) {
  65             for (let k = 0; k < moves.length; k++) {
  66               if (
  67                 moves[k].vanish.length == 2 &&
  68                 this.filterValid([moves[k]]).length > 0
  69               )
  70                 return true;
  71             }
  72           }
  73         }
  74       }
  75     }
  76     return false;
  77   }
  78
  79   // Trim all non-capturing moves
  80   static KeepCaptures(moves) {
  81     return moves.filter(m => {
  82       return m.vanish.length == 2;
  83     });
  84   }
  85
  86   getPossibleMovesFrom(sq) {
  87     let moves = this.filterValid(this.getPotentialMovesFrom(sq));
  88     // This is called from interface: we need to know if a capture is possible
  89     if (this.atLeastOneCapture()) moves = V.KeepCaptures(moves);
  90     return moves;
  91   }
  92
  93   getAllValidMoves() {
  94     let moves = super.getAllValidMoves();
  95     if (
  96       moves.some(m => {
  97         return m.vanish.length == 2;
  98       })
  99     )
 100       moves = V.KeepCaptures(moves);
 101     return moves;
 102   }
 103
 104   underCheck() {
 105     return false; //No notion of check
 106   }
 107
 108   getCheckSquares() {
 109     return [];
 110   }
 111
 112   // No variables update because no royal king + no castling
 113   updateVariables() {}
 114   unupdateVariables() {}
 115
 116   getCurrentScore() {
 117     if (this.atLeastOneMove())
 118       // game not over
 119       return "*";
 120
 121     // No valid move: the side who cannot move wins
 122     return this.turn == "w" ? "1-0" : "0-1";
 123   }
 124
 125   static get VALUES() {
 126     // Experimental...
 127     return {
 128       p: 1,
 129       r: 7,
 130       n: 3,
 131       b: 3,
 132       q: 5,
 133       k: 5
 134     };
 135   }
 136
 137   static get SEARCH_DEPTH() {
 138     return 4;
 139   }
 140
 141   evalPosition() {
 142     return -super.evalPosition(); //better with less material
 143   }
 144
 145   static GenRandInitFen() {
 146     let pieces = { w: new Array(8), b: new Array(8) };
 147     // Shuffle pieces on first and last rank
 148     for (let c of ["w", "b"]) {
 149       let positions = ArrayFun.range(8);
 150
 151       // Get random squares for bishops
 152       let randIndex = 2 * randInt(4);
 153       let bishop1Pos = positions[randIndex];
 154       // The second bishop must be on a square of different color
 155       let randIndex_tmp = 2 * randInt(4) + 1;
 156       let bishop2Pos = positions[randIndex_tmp];
 157       // Remove chosen squares
 158       positions.splice(Math.max(randIndex, randIndex_tmp), 1);
 159       positions.splice(Math.min(randIndex, randIndex_tmp), 1);
 160
 161       // Get random squares for knights
 162       randIndex = randInt(6);
 163       let knight1Pos = positions[randIndex];
 164       positions.splice(randIndex, 1);
 165       randIndex = randInt(5);
 166       let knight2Pos = positions[randIndex];
 167       positions.splice(randIndex, 1);
 168
 169       // Get random square for queen
 170       randIndex = randInt(4);
 171       let queenPos = positions[randIndex];
 172       positions.splice(randIndex, 1);
 173
 174       // Random square for king (no castle)
 175       randIndex = randInt(3);
 176       let kingPos = positions[randIndex];
 177       positions.splice(randIndex, 1);
 178
 179       // Rooks positions are now fixed
 180       let rook1Pos = positions[0];
 181       let rook2Pos = positions[1];
 182
 183       // Finally put the shuffled pieces in the board array
 184       pieces[c][rook1Pos] = "r";
 185       pieces[c][knight1Pos] = "n";
 186       pieces[c][bishop1Pos] = "b";
 187       pieces[c][queenPos] = "q";
 188       pieces[c][kingPos] = "k";
 189       pieces[c][bishop2Pos] = "b";
 190       pieces[c][knight2Pos] = "n";
 191       pieces[c][rook2Pos] = "r";
 192     }
 193     return (
 194       pieces["b"].join("") +
 195       "/pppppppp/8/8/8/8/PPPPPPPP/" +
 196       pieces["w"].join("").toUpperCase() +
 197       " w 0 -"
 198     ); //en-passant allowed, but no flags
 199   }
 200 };