client/src/variants/Recycle.js

   1 import { ChessRules, PiPo, Move } from "@/base_rules";
   2 import { ArrayFun } from "@/utils/array";
   3
   4 export class RecycleRules extends ChessRules {
   5   static get PawnSpecs() {
   6     return Object.assign(
   7       {},
   8       ChessRules.PawnSpecs,
   9       { promotions: [V.PAWN] } //in fact, none
  10     );
  11   }
  12
  13   static IsGoodFen(fen) {
  14     if (!ChessRules.IsGoodFen(fen)) return false;
  15     const fenParsed = V.ParseFen(fen);
  16     // 5) Check reserves
  17     if (!fenParsed.reserve || !fenParsed.reserve.match(/^[0-9]{10,10}$/))
  18       return false;
  19     return true;
  20   }
  21
  22   static ParseFen(fen) {
  23     const fenParts = fen.split(" ");
  24     return Object.assign(
  25       ChessRules.ParseFen(fen),
  26       { reserve: fenParts[5] }
  27     );
  28   }
  29
  30   static GenRandInitFen(randomness) {
  31     return ChessRules.GenRandInitFen(randomness) + " 0000000000";
  32   }
  33
  34   getFen() {
  35     return super.getFen() + " " + this.getReserveFen();
  36   }
  37
  38   getFenForRepeat() {
  39     return super.getFenForRepeat() + "_" + this.getReserveFen();
  40   }
  41
  42   getReserveFen() {
  43     let counts = new Array(10);
  44     for (
  45       let i = 0;
  46       i < V.PIECES.length - 1;
  47       i++ //-1: no king reserve
  48     ) {
  49       counts[i] = this.reserve["w"][V.PIECES[i]];
  50       counts[5 + i] = this.reserve["b"][V.PIECES[i]];
  51     }
  52     return counts.join("");
  53   }
  54
  55   setOtherVariables(fen) {
  56     super.setOtherVariables(fen);
  57     const fenParsed = V.ParseFen(fen);
  58     // Also init reserves (used by the interface to show landable pieces)
  59     this.reserve = {
  60       w: {
  61         [V.PAWN]: parseInt(fenParsed.reserve[0]),
  62         [V.ROOK]: parseInt(fenParsed.reserve[1]),
  63         [V.KNIGHT]: parseInt(fenParsed.reserve[2]),
  64         [V.BISHOP]: parseInt(fenParsed.reserve[3]),
  65         [V.QUEEN]: parseInt(fenParsed.reserve[4])
  66       },
  67       b: {
  68         [V.PAWN]: parseInt(fenParsed.reserve[5]),
  69         [V.ROOK]: parseInt(fenParsed.reserve[6]),
  70         [V.KNIGHT]: parseInt(fenParsed.reserve[7]),
  71         [V.BISHOP]: parseInt(fenParsed.reserve[8]),
  72         [V.QUEEN]: parseInt(fenParsed.reserve[9])
  73       }
  74     };
  75   }
  76
  77   getColor(i, j) {
  78     if (i >= V.size.x) return i == V.size.x ? "w" : "b";
  79     return this.board[i][j].charAt(0);
  80   }
  81
  82   getPiece(i, j) {
  83     if (i >= V.size.x) return V.RESERVE_PIECES[j];
  84     return this.board[i][j].charAt(1);
  85   }
  86
  87   // Used by the interface:
  88   getReservePpath(index, color) {
  89     return color + V.RESERVE_PIECES[index];
  90   }
  91
  92   // Ordering on reserve pieces
  93   static get RESERVE_PIECES() {
  94     return [V.PAWN, V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN];
  95   }
  96
  97   getReserveMoves([x, y]) {
  98     const color = this.turn;
  99     const p = V.RESERVE_PIECES[y];
 100     if (this.reserve[color][p] == 0) return [];
 101     let moves = [];
 102     const pawnShift = p == V.PAWN ? 1 : 0;
 103     for (let i = pawnShift; i < V.size.x - pawnShift; i++) {
 104       for (let j = 0; j < V.size.y; j++) {
 105         if (this.board[i][j] == V.EMPTY) {
 106           let mv = new Move({
 107             appear: [
 108               new PiPo({
 109                 x: i,
 110                 y: j,
 111                 c: color,
 112                 p: p
 113               })
 114             ],
 115             vanish: [],
 116             start: { x: x, y: y }, //a bit artificial...
 117             end: { x: i, y: j }
 118           });
 119           moves.push(mv);
 120         }
 121       }
 122     }
 123     return moves;
 124   }
 125
 126   getPotentialMovesFrom([x, y]) {
 127     if (x >= V.size.x) {
 128       // Reserves, outside of board: x == sizeX(+1)
 129       return this.getReserveMoves([x, y]);
 130     }
 131     // Standard moves
 132     return super.getPotentialMovesFrom([x, y]);
 133   }
 134
 135   getPotentialPawnMoves([x, y]) {
 136     let moves = super.getPotentialPawnMoves([x, y]);
 137     // Remove pawns on 8th rank ("fallen"):
 138     const color = this.turn;
 139     const lastRank = (color == "w" ? 0 : V.size.x - 1);
 140     moves.forEach(m => {
 141       if (m.appear[0].x == lastRank) m.appear.pop();
 142     });
 143     return moves;
 144   }
 145
 146   getAllValidMoves() {
 147     let moves = super.getAllPotentialMoves();
 148     const color = this.turn;
 149     for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
 150       moves = moves.concat(
 151         this.getReserveMoves([V.size.x + (color == "w" ? 0 : 1), i])
 152       );
 153     }
 154     return this.filterValid(moves);
 155   }
 156
 157   atLeastOneMove() {
 158     if (!super.atLeastOneMove()) {
 159       // Search one reserve move
 160       for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
 161         let moves = this.filterValid(
 162           this.getReserveMoves([V.size.x + (this.turn == "w" ? 0 : 1), i])
 163         );
 164         if (moves.length > 0) return true;
 165       }
 166       return false;
 167     }
 168     return true;
 169   }
 170
 171   canTake([x1, y1], [x2, y2]) {
 172     // Self-captures allowed, except for the king:
 173     return this.getPiece(x2, y2) != V.KING;
 174   }
 175
 176   prePlay(move) {
 177     super.prePlay(move);
 178     // Skip castle:
 179     if (move.vanish.length == 2 && move.appear.length == 2) return;
 180     const color = this.turn;
 181     if (move.vanish.length == 0) this.reserve[color][move.appear[0].p]--;
 182     else if (move.vanish.length == 2 && move.vanish[1].c == color)
 183       // Self-capture
 184       this.reserve[color][move.vanish[1].p]++;
 185   }
 186
 187   postUndo(move) {
 188     super.postUndo(move);
 189     if (move.vanish.length == 2 && move.appear.length == 2) return;
 190     const color = this.turn;
 191     if (move.vanish.length == 0) this.reserve[color][move.appear[0].p]++;
 192     else if (move.vanish.length == 2 && move.vanish[1].c == color)
 193       this.reserve[color][move.vanish[1].p]--;
 194   }
 195
 196   static get SEARCH_DEPTH() {
 197     return 2;
 198   }
 199
 200   evalPosition() {
 201     let evaluation = super.evalPosition();
 202     // Add reserves:
 203     for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
 204       const p = V.RESERVE_PIECES[i];
 205       evaluation += this.reserve["w"][p] * V.VALUES[p];
 206       evaluation -= this.reserve["b"][p] * V.VALUES[p];
 207     }
 208     return evaluation;
 209   }
 210
 211   getNotation(move) {
 212     const finalSquare = V.CoordsToSquare(move.end);
 213     if (move.vanish.length > 0) {
 214       if (move.appear.length > 0) {
 215         // Standard move
 216         return super.getNotation(move);
 217       } else {
 218         // Pawn fallen: capturing or not
 219         let res = "";
 220         if (move.vanish.length == 2)
 221           res += V.CoordToColumn(move.start.y) + "x";
 222         return res + finalSquare;
 223       }
 224     }
 225     // Rebirth:
 226     const piece =
 227       move.appear[0].p != V.PAWN ? move.appear[0].p.toUpperCase() : "";
 228     return piece + "@" + V.CoordsToSquare(move.end);
 229   }
 230 };