client/src/variants/Zen.js

   1 import { ChessRules } from "@/base_rules";
   2
   3 export class ZenRules extends ChessRules {
   4
   5   getEpSquare(moveOrSquare) {
   6     if (!moveOrSquare) return undefined;
   7     if (typeof moveOrSquare === "string") {
   8       const square = moveOrSquare;
   9       if (square == "-") return undefined;
  10       return V.SquareToCoords(square);
  11     }
  12     const move = moveOrSquare;
  13     const s = move.start,
  14           e = move.end;
  15     if (
  16       // Exclude captures (of rooks for example)
  17       move.vanish.length == 1 &&
  18       s.y == e.y &&
  19       Math.abs(s.x - e.x) == 2 &&
  20       move.appear[0].p == V.PAWN
  21     ) {
  22       return {
  23         x: (s.x + e.x) / 2,
  24         y: s.y
  25       };
  26     }
  27     return undefined;
  28   }
  29
  30   // TODO(?): some duplicated code in 2 next functions
  31   getSlideNJumpMoves([x, y], steps, oneStep) {
  32     let moves = [];
  33     outerLoop: for (let loop = 0; loop < steps.length; loop++) {
  34       const step = steps[loop];
  35       let i = x + step[0];
  36       let j = y + step[1];
  37       while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
  38         moves.push(this.getBasicMove([x, y], [i, j]));
  39         if (oneStep) continue outerLoop;
  40         i += step[0];
  41         j += step[1];
  42       }
  43       // No capture check: handled elsewhere (next method)
  44     }
  45     return moves;
  46   }
  47
  48   // follow steps from x,y until something is met.
  49   // if met piece is opponent and same movement (asA): eat it!
  50   findCaptures_aux([x, y], asA) {
  51     const color = this.getColor(x, y);
  52     let moves = [];
  53     const steps =
  54       asA != V.PAWN
  55         ? asA == V.QUEEN
  56           ? V.steps[V.ROOK].concat(V.steps[V.BISHOP])
  57           : V.steps[asA]
  58         : color == "w"
  59           ? [
  60             [-1, -1],
  61             [-1, 1]
  62           ]
  63           : [
  64             [1, -1],
  65             [1, 1]
  66           ];
  67     const oneStep = [V.KNIGHT,V.PAWN].includes(asA); //we don't capture king
  68     const lastRank = color == "w" ? 0 : V.size.x - 1;
  69     const promotionPieces = [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN];
  70     const oppCol = V.GetOppCol(color);
  71     outerLoop: for (let loop = 0; loop < steps.length; loop++) {
  72       const step = steps[loop];
  73       let i = x + step[0];
  74       let j = y + step[1];
  75       while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
  76         if (oneStep) continue outerLoop;
  77         i += step[0];
  78         j += step[1];
  79       }
  80       if (
  81         V.OnBoard(i, j) &&
  82         this.board[i][j] != V.EMPTY &&
  83         this.getColor(i, j) == oppCol &&
  84         this.getPiece(i, j) == asA
  85       ) {
  86         // eat!
  87         if (this.getPiece(x, y) == V.PAWN && i == lastRank) {
  88           // Special case of promotion:
  89           promotionPieces.forEach(p => {
  90             moves.push(this.getBasicMove([x, y], [i, j], { c: color, p: p }));
  91           });
  92         }
  93         else {
  94           // All other cases
  95           moves.push(this.getBasicMove([x, y], [i, j]));
  96         }
  97       }
  98     }
  99     return moves;
 100   }
 101
 102   // Find possible captures from a square: look in every direction!
 103   findCaptures(sq) {
 104     let moves = [];
 105     Array.prototype.push.apply(moves, this.findCaptures_aux(sq, V.PAWN));
 106     Array.prototype.push.apply(moves, this.findCaptures_aux(sq, V.ROOK));
 107     Array.prototype.push.apply(moves, this.findCaptures_aux(sq, V.KNIGHT));
 108     Array.prototype.push.apply(moves, this.findCaptures_aux(sq, V.BISHOP));
 109     Array.prototype.push.apply(moves, this.findCaptures_aux(sq, V.QUEEN));
 110     return moves;
 111   }
 112
 113   canTake(sq1, sq2) {
 114     return false; //captures handled separately
 115   }
 116
 117   getPotentialMovesFrom(sq) {
 118     return super.getPotentialMovesFrom(sq).concat(this.findCaptures(sq));
 119   }
 120
 121   getNotation(move) {
 122     // Recognize special moves first
 123     if (move.appear.length == 2) {
 124       // castle
 125       if (move.end.y < move.start.y) return "0-0-0";
 126       return "0-0";
 127     }
 128
 129     // Translate initial square (because pieces may fly unusually!)
 130     const initialSquare = V.CoordsToSquare(move.start);
 131
 132     // Translate final square
 133     const finalSquare = V.CoordsToSquare(move.end);
 134
 135     let notation = "";
 136     const piece = this.getPiece(move.start.x, move.start.y);
 137     if (piece == V.PAWN) {
 138       // pawn move (TODO: enPassant indication)
 139       if (move.vanish.length == 2) {
 140         // capture
 141         notation = initialSquare + "x" + finalSquare;
 142       }
 143       else notation = finalSquare;
 144       if (piece != move.appear[0].p)
 145         //promotion
 146         notation += "=" + move.appear[0].p.toUpperCase();
 147     }
 148     else {
 149       // Piece movement
 150       notation = piece.toUpperCase();
 151       if (move.vanish.length > 1) notation += initialSquare + "x";
 152       notation += finalSquare;
 153     }
 154     return notation;
 155   }
 156
 157   static get VALUES() {
 158     return {
 159       p: 1,
 160       r: 3,
 161       n: 2,
 162       b: 2,
 163       q: 5,
 164       k: 1000
 165     };
 166   }
 167
 168 };