client/src/variants/Suction.js

   1 import { ChessRules, PiPo, Move } from "@/base_rules";
   2 import { SuicideRules } from "@/variants/Suicide";
   3
   4 export class SuctionRules extends ChessRules {
   5   static get PawnSpecs() {
   6     return Object.assign(
   7       {},
   8       ChessRules.PawnSpecs,
   9       // No promotions:
  10       { promotions: [V.PAWN] }
  11     );
  12   }
  13
  14   static get HasFlags() {
  15     return false;
  16   }
  17
  18   setOtherVariables(fen) {
  19     super.setOtherVariables(fen);
  20     // Local stack of "captures"
  21     this.cmoves = [];
  22     const cmove = V.ParseFen(fen).cmove;
  23     if (cmove == "-") this.cmoves.push(null);
  24     else {
  25       this.cmoves.push({
  26         start: ChessRules.SquareToCoords(cmove.substr(0, 2)),
  27         end: ChessRules.SquareToCoords(cmove.substr(2))
  28       });
  29     }
  30   }
  31
  32   static ParseFen(fen) {
  33     return Object.assign(
  34       ChessRules.ParseFen(fen),
  35       { cmove: fen.split(" ")[4] }
  36     );
  37   }
  38
  39   static IsGoodFen(fen) {
  40     if (!ChessRules.IsGoodFen(fen)) return false;
  41     const fenParts = fen.split(" ");
  42     if (fenParts.length != 5) return false;
  43     if (fenParts[4] != "-" && !fenParts[4].match(/^([a-h][1-8]){2}$/))
  44       return false;
  45     return true;
  46   }
  47
  48   getCmove(move) {
  49     if (move.vanish.length == 2)
  50       return { start: move.start, end: move.end };
  51     return null;
  52   }
  53
  54   getBasicMove([sx, sy], [ex, ey]) {
  55     const startColor = this.getColor(sx, sy);
  56     const startPiece = this.getPiece(sx, sy);
  57     let mv = new Move({
  58       appear: [
  59         new PiPo({
  60           x: ex,
  61           y: ey,
  62           c: startColor,
  63           p: startPiece
  64         })
  65       ],
  66       vanish: [
  67         new PiPo({
  68           x: sx,
  69           y: sy,
  70           c: startColor,
  71           p: startPiece
  72         })
  73       ]
  74     });
  75
  76     if (this.board[ex][ey] != V.EMPTY) {
  77       const endColor = this.getColor(ex, ey);
  78       const endPiece = this.getPiece(ex, ey);
  79       mv.vanish.push(
  80         new PiPo({
  81           x: ex,
  82           y: ey,
  83           c: endColor,
  84           p: endPiece
  85         })
  86       );
  87       mv.appear.push(
  88         new PiPo({
  89           x: sx,
  90           y: sy,
  91           c: endColor,
  92           p: endPiece
  93         })
  94       );
  95     }
  96     return mv;
  97   }
  98
  99   getEnpassantCaptures([x, y], shiftX) {
 100     let moves = [];
 101     const Lep = this.epSquares.length;
 102     const epSquare = this.epSquares[Lep - 1]; //always at least one element
 103     if (
 104       !!epSquare &&
 105       epSquare.x == x + shiftX &&
 106       Math.abs(epSquare.y - y) == 1
 107     ) {
 108       let enpassantMove = this.getBasicMove([x, y], [epSquare.x, epSquare.y]);
 109       const oppCol = V.GetOppCol(this.turn);
 110       enpassantMove.vanish.push({
 111         x: x,
 112         y: epSquare.y,
 113         p: "p",
 114         c: oppCol
 115       });
 116       enpassantMove.appear.push({
 117         x: x,
 118         y: y,
 119         p: "p",
 120         c: oppCol
 121       });
 122       moves.push(enpassantMove);
 123     }
 124     return moves;
 125   }
 126
 127   getPotentialKingMoves() {
 128     return [];
 129   }
 130
 131   // Does m2 un-do m1 ? (to disallow undoing captures)
 132   oppositeMoves(m1, m2) {
 133     return (
 134       !!m1 &&
 135       m2.vanish.length == 2 &&
 136       m1.start.x == m2.start.x &&
 137       m1.end.x == m2.end.x &&
 138       m1.start.y == m2.start.y &&
 139       m1.end.y == m2.end.y
 140     );
 141   }
 142
 143   filterValid(moves) {
 144     if (moves.length == 0) return [];
 145     return moves.filter(m => {
 146       const L = this.cmoves.length; //at least 1: init from FEN
 147       return !this.oppositeMoves(this.cmoves[L - 1], m);
 148     });
 149   }
 150
 151   static GenRandInitFen(randomness) {
 152     // Add empty cmove:
 153     return SuicideRules.GenRandInitFen(randomness) + " -";
 154   }
 155
 156   getCmoveFen() {
 157     const L = this.cmoves.length;
 158     return (
 159       !this.cmoves[L - 1]
 160         ? "-"
 161         : ChessRules.CoordsToSquare(this.cmoves[L - 1].start) +
 162           ChessRules.CoordsToSquare(this.cmoves[L - 1].end)
 163     );
 164   }
 165
 166   getFen() {
 167     return super.getFen() + " " + this.getCmoveFen();
 168   }
 169
 170   getFenForRepeat() {
 171     return super.getFenForRepeat() + "_" + this.getCmoveFen();
 172   }
 173
 174   postPlay(move) {
 175     super.postPlay(move);
 176     if (move.vanish.length == 2) {
 177       // Was opponent king swapped?
 178       if (move.vanish[1].p == V.KING)
 179         this.kingPos[this.turn] = [move.appear[1].x, move.appear[1].y];
 180     }
 181     this.cmoves.push(this.getCmove(move));
 182   }
 183
 184   postUndo(move) {
 185     super.postUndo(move);
 186     if (move.appear.length == 2) {
 187       if (move.appear[1].p == V.KING)
 188         this.kingPos[move.vanish[1].c] = [move.vanish[1].x, move.vanish[1].y];
 189     }
 190     this.cmoves.pop();
 191   }
 192
 193   atLeastOneMove() {
 194     return true;
 195   }
 196
 197   getCheckSquares() {
 198     return [];
 199   }
 200
 201   getCurrentScore() {
 202     const color = this.turn;
 203     const kp = this.kingPos[color];
 204     if (color == "w" && kp[0] == 0) return "0-1";
 205     if (color == "b" && kp[0] == V.size.x - 1) return "1-0";
 206     // King is not on the opposite edge: game not over
 207     return "*";
 208   }
 209
 210   evalPosition() {
 211     // Very simple criterion for now: kings position
 212     return this.kingPos["w"][0] + this.kingPos["b"][0];
 213   }
 214
 215   getNotation(move) {
 216     // Translate final square
 217     const finalSquare = V.CoordsToSquare(move.end);
 218
 219     const piece = this.getPiece(move.start.x, move.start.y);
 220     if (piece == V.PAWN) {
 221       // Pawn move
 222       let notation = "";
 223       if (move.vanish.length == 2) {
 224         // Capture
 225         const startColumn = V.CoordToColumn(move.start.y);
 226         notation = startColumn + "x" + finalSquare;
 227       }
 228       else notation = finalSquare;
 229       return notation;
 230     }
 231     // Piece movement
 232     return (
 233       piece.toUpperCase() +
 234       (move.vanish.length == 2 ? "x" : "") +
 235       finalSquare
 236     );
 237   }
 238 };