client/src/variants/Berolina.js

   1 import { ChessRules } from "@/base_rules";
   2
   3 export class BerolinaRules extends ChessRules {
   4   // En-passant after 2-sq jump
   5   getEpSquare(moveOrSquare) {
   6     if (!moveOrSquare) return undefined;
   7     if (typeof moveOrSquare === "string") {
   8       const square = moveOrSquare;
   9       if (square == "-") return undefined;
  10       // Enemy pawn initial column must be given too:
  11       let res = [];
  12       const epParts = square.split(",");
  13       res.push(V.SquareToCoords(epParts[0]));
  14       res.push(V.ColumnToCoord(epParts[1]));
  15       return res;
  16     }
  17     // Argument is a move:
  18     const move = moveOrSquare;
  19     const [sx, ex, sy] = [move.start.x, move.end.x, move.start.y];
  20     if (this.getPiece(sx, sy) == V.PAWN && Math.abs(sx - ex) == 2) {
  21       return [
  22         {
  23           x: (ex + sx) / 2,
  24           y: (move.end.y + sy) / 2
  25         },
  26         // The arrival column must be remembered, because
  27         // potentially two pawns could be candidates to be captured:
  28         // one on our left, and one on our right.
  29         move.end.y
  30       ];
  31     }
  32     return undefined; //default
  33   }
  34
  35   static IsGoodEnpassant(enpassant) {
  36     if (enpassant != "-") {
  37       const epParts = enpassant.split(",");
  38       const epSq = V.SquareToCoords(epParts[0]);
  39       if (isNaN(epSq.x) || isNaN(epSq.y) || !V.OnBoard(epSq)) return false;
  40       const arrCol = V.ColumnToCoord(epParts[1]);
  41       if (isNaN(arrCol) || arrCol < 0 || arrCol >= V.size.y) return false;
  42     }
  43     return true;
  44   }
  45
  46   getEnpassantFen() {
  47     const L = this.epSquares.length;
  48     if (!this.epSquares[L - 1]) return "-"; //no en-passant
  49     return (
  50       V.CoordsToSquare(this.epSquares[L - 1][0]) +
  51       "," +
  52       V.CoordToColumn(this.epSquares[L - 1][1])
  53     );
  54   }
  55
  56   // Special pawns movements
  57   getPotentialPawnMoves([x, y]) {
  58     const color = this.turn;
  59     let moves = [];
  60     const [sizeX, sizeY] = [V.size.x, V.size.y];
  61     const shiftX = color == "w" ? -1 : 1;
  62     const startRank = color == "w" ? sizeX - 2 : 1;
  63     const lastRank = color == "w" ? 0 : sizeX - 1;
  64     const finalPieces =
  65       x + shiftX == lastRank
  66         ? [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]
  67         : [V.PAWN];
  68
  69     // One square diagonally
  70     for (let shiftY of [-1, 1]) {
  71       if (this.board[x + shiftX][y + shiftY] == V.EMPTY) {
  72         for (let piece of finalPieces) {
  73           moves.push(
  74             this.getBasicMove([x, y], [x + shiftX, y + shiftY], {
  75               c: color,
  76               p: piece
  77             })
  78           );
  79         }
  80         if (
  81           V.PawnSpecs.twoSquares &&
  82           x == startRank &&
  83           y + 2 * shiftY >= 0 &&
  84           y + 2 * shiftY < sizeY &&
  85           this.board[x + 2 * shiftX][y + 2 * shiftY] == V.EMPTY
  86         ) {
  87           // Two squares jump
  88           moves.push(
  89             this.getBasicMove([x, y], [x + 2 * shiftX, y + 2 * shiftY])
  90           );
  91         }
  92       }
  93     }
  94     // Capture
  95     if (
  96       this.board[x + shiftX][y] != V.EMPTY &&
  97       this.canTake([x, y], [x + shiftX, y])
  98     ) {
  99       for (let piece of finalPieces)
 100         moves.push(
 101           this.getBasicMove([x, y], [x + shiftX, y], { c: color, p: piece })
 102         );
 103     }
 104
 105     // Next condition so that other variants could inherit from this class
 106     if (V.PawnSpecs.enPassant) {
 107       // En passant
 108       const Lep = this.epSquares.length;
 109       const epSquare = this.epSquares[Lep - 1]; //always at least one element
 110       if (
 111         !!epSquare &&
 112         epSquare[0].x == x + shiftX &&
 113         epSquare[0].y == y
 114       ) {
 115         let enpassantMove = this.getBasicMove([x, y], [x + shiftX, y]);
 116         enpassantMove.vanish.push({
 117           x: x,
 118           y: epSquare[1],
 119           p: "p",
 120           c: this.getColor(x, epSquare[1])
 121         });
 122         moves.push(enpassantMove);
 123       }
 124     }
 125
 126     return moves;
 127   }
 128
 129   isAttackedByPawn([x, y], color) {
 130     let pawnShift = (color == "w" ? 1 : -1);
 131     if (x + pawnShift >= 0 && x + pawnShift < V.size.x) {
 132       if (
 133         this.getPiece(x + pawnShift, y) == V.PAWN &&
 134         this.getColor(x + pawnShift, y) == color
 135       ) {
 136         return true;
 137       }
 138     }
 139     return false;
 140   }
 141
 142   static get SEARCH_DEPTH() {
 143     return 2;
 144   }
 145
 146   getNotation(move) {
 147     const piece = this.getPiece(move.start.x, move.start.y);
 148     if (piece == V.PAWN) {
 149       // Pawn move
 150       const finalSquare = V.CoordsToSquare(move.end);
 151       let notation = "";
 152       if (move.vanish.length == 2)
 153         //capture
 154         notation = "Px" + finalSquare;
 155       else {
 156         // No capture: indicate the initial square for potential ambiguity
 157         const startSquare = V.CoordsToSquare(move.start);
 158         notation = startSquare + finalSquare;
 159       }
 160       if (move.appear[0].p != V.PAWN)
 161         // Promotion
 162         notation += "=" + move.appear[0].p.toUpperCase();
 163       return notation;
 164     }
 165     return super.getNotation(move); //all other pieces are orthodox
 166   }
 167 };