client/src/variants/Suicide.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 SuicideRules 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   // Trim all non-capturing moves (not the most efficient, but easy)
  57   static KeepCaptures(moves) {
  58     return moves.filter(m => m.vanish.length == 2);
  59   }
  60
  61   // Stop at the first capture found (if any)
  62   atLeastOneCapture() {
  63     const color = this.turn;
  64     const oppCol = V.GetOppCol(color);
  65     for (let i = 0; i < V.size.x; i++) {
  66       for (let j = 0; j < V.size.y; j++) {
  67         if (
  68           this.board[i][j] != V.EMPTY &&
  69           this.getColor(i, j) != oppCol &&
  70           this.getPotentialMovesFrom([i, j]).some(m => m.vanish.length == 2)
  71         ) {
  72           return true;
  73         }
  74       }
  75     }
  76     return false;
  77   }
  78
  79   getPossibleMovesFrom(sq) {
  80     let moves = this.getPotentialMovesFrom(sq);
  81     const captureMoves = V.KeepCaptures(moves);
  82     if (captureMoves.length > 0) return captureMoves;
  83     if (this.atLeastOneCapture()) return [];
  84     return moves;
  85   }
  86
  87   filterValid(moves) {
  88     return moves;
  89   }
  90
  91   getAllValidMoves() {
  92     const moves = super.getAllValidMoves();
  93     if (moves.some(m => m.vanish.length == 2)) return V.KeepCaptures(moves);
  94     return moves;
  95   }
  96
  97   atLeastOneMove() {
  98     const color = this.turn;
  99     for (let i = 0; i < V.size.x; i++) {
 100       for (let j = 0; j < V.size.y; j++) {
 101         if (
 102           this.getColor(i, j) == color &&
 103           this.getPotentialMovesFrom([i, j]).length > 0
 104         ) {
 105           return true;
 106         }
 107       }
 108     }
 109     return false;
 110   }
 111
 112   getCheckSquares() {
 113     return [];
 114   }
 115
 116   // No variables update because no royal king + no castling
 117   updateVariables() {}
 118   unupdateVariables() {}
 119
 120   getCurrentScore() {
 121     if (this.atLeastOneMove()) return "*";
 122     // No valid move: the side who cannot move wins
 123     return this.turn == "w" ? "1-0" : "0-1";
 124   }
 125
 126   static get VALUES() {
 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     // Less material is better:
 143     return -super.evalPosition();
 144   }
 145
 146   static GenRandInitFen(randomness) {
 147     if (randomness == 0)
 148       return "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w 0 -";
 149
 150     let pieces = { w: new Array(8), b: new Array(8) };
 151     // Shuffle pieces on first and last rank
 152     for (let c of ["w", "b"]) {
 153       if (c == 'b' && randomness == 1) {
 154         pieces['b'] = pieces['w'];
 155         break;
 156       }
 157
 158       let positions = ArrayFun.range(8);
 159
 160       // Get random squares for bishops
 161       let randIndex = 2 * randInt(4);
 162       let bishop1Pos = positions[randIndex];
 163       // The second bishop must be on a square of different color
 164       let randIndex_tmp = 2 * randInt(4) + 1;
 165       let bishop2Pos = positions[randIndex_tmp];
 166       // Remove chosen squares
 167       positions.splice(Math.max(randIndex, randIndex_tmp), 1);
 168       positions.splice(Math.min(randIndex, randIndex_tmp), 1);
 169
 170       // Get random squares for knights
 171       randIndex = randInt(6);
 172       let knight1Pos = positions[randIndex];
 173       positions.splice(randIndex, 1);
 174       randIndex = randInt(5);
 175       let knight2Pos = positions[randIndex];
 176       positions.splice(randIndex, 1);
 177
 178       // Get random square for queen
 179       randIndex = randInt(4);
 180       let queenPos = positions[randIndex];
 181       positions.splice(randIndex, 1);
 182
 183       // Random square for king (no castle)
 184       randIndex = randInt(3);
 185       let kingPos = positions[randIndex];
 186       positions.splice(randIndex, 1);
 187
 188       // Rooks positions are now fixed
 189       let rook1Pos = positions[0];
 190       let rook2Pos = positions[1];
 191
 192       // Finally put the shuffled pieces in the board array
 193       pieces[c][rook1Pos] = "r";
 194       pieces[c][knight1Pos] = "n";
 195       pieces[c][bishop1Pos] = "b";
 196       pieces[c][queenPos] = "q";
 197       pieces[c][kingPos] = "k";
 198       pieces[c][bishop2Pos] = "b";
 199       pieces[c][knight2Pos] = "n";
 200       pieces[c][rook2Pos] = "r";
 201     }
 202     return (
 203       pieces["b"].join("") +
 204       "/pppppppp/8/8/8/8/PPPPPPPP/" +
 205       pieces["w"].join("").toUpperCase() +
 206       // En-passant allowed, but no flags
 207       " w 0 -"
 208     );
 209   }
 210 };