client/src/variants/Fullcavalry.js

   1 import { ArrayFun } from "@/utils/array";
   2 import { randInt } from "@/utils/alea";
   3 import { ChessRules, PiPo, Move } from "@/base_rules";
   4
   5 export class FullcavalryRules extends ChessRules {
   6
   7   static get LANCER() {
   8     return "l";
   9   }
  10
  11   static get IMAGE_EXTENSION() {
  12     // Temporarily, for the time SVG pieces are being designed:
  13     return ".png";
  14   }
  15
  16   // Lancer directions *from white perspective*
  17   static get LANCER_DIRS() {
  18     return {
  19       'c': [-1, 0], //north
  20       'd': [-1, 1], //N-E
  21       'e': [0, 1], //east
  22       'f': [1, 1], //S-E
  23       'g': [1, 0], //south
  24       'h': [1, -1], //S-W
  25       'm': [0, -1], //west
  26       'o': [-1, -1] //N-W
  27     };
  28   }
  29
  30   static get PIECES() {
  31     return ChessRules.PIECES.concat(Object.keys(V.LANCER_DIRS));
  32   }
  33
  34   getPiece(i, j) {
  35     const piece = this.board[i][j].charAt(1);
  36     // Special lancer case: 8 possible orientations
  37     if (Object.keys(V.LANCER_DIRS).includes(piece)) return V.LANCER;
  38     return piece;
  39   }
  40
  41   getPpath(b, color, score, orientation) {
  42     if (Object.keys(V.LANCER_DIRS).includes(b[1])) {
  43       if (orientation == 'w') return "Eightpieces/tmp_png/" + b;
  44       // Find opposite direction for adequate display:
  45       let oppDir = '';
  46       switch (b[1]) {
  47         case 'c':
  48           oppDir = 'g';
  49           break;
  50         case 'g':
  51           oppDir = 'c';
  52           break;
  53         case 'd':
  54           oppDir = 'h';
  55           break;
  56         case 'h':
  57           oppDir = 'd';
  58           break;
  59         case 'e':
  60           oppDir = 'm';
  61           break;
  62         case 'm':
  63           oppDir = 'e';
  64           break;
  65         case 'f':
  66           oppDir = 'o';
  67           break;
  68         case 'o':
  69           oppDir = 'f';
  70           break;
  71       }
  72       return "Eightpieces/tmp_png/" + b[0] + oppDir;
  73     }
  74     // TODO: after we have SVG pieces, remove the folder and next prefix:
  75     return "Eightpieces/tmp_png/" + b;
  76   }
  77
  78   getPPpath(m, orientation) {
  79     return (
  80       this.getPpath(
  81         m.appear[0].c + m.appear[0].p,
  82         null,
  83         null,
  84         orientation
  85       )
  86     );
  87   }
  88
  89   static GenRandInitFen(randomness) {
  90     if (randomness == 0)
  91       // Deterministic:
  92       return "efbqkbnm/pppppppp/8/8/8/8/PPPPPPPP/EDBQKBNM w 0 ahah -";
  93
  94     const baseFen = ChessRules.GenRandInitFen(randomness);
  95     // Replace black rooks by lancers oriented south,
  96     // and white rooks by lancers oriented north:
  97     return baseFen.replace(/r/g, 'g').replace(/R/g, 'C');
  98   }
  99
 100   // Because of the lancers, getPiece() could be wrong:
 101   // use board[x][y][1] instead (always valid).
 102   // TODO: base implementation now uses this too (no?)
 103   getBasicMove([sx, sy], [ex, ey], tr) {
 104     const initColor = this.getColor(sx, sy);
 105     const initPiece = this.board[sx][sy].charAt(1);
 106     let mv = new Move({
 107       appear: [
 108         new PiPo({
 109           x: ex,
 110           y: ey,
 111           c: tr ? tr.c : initColor,
 112           p: tr ? tr.p : initPiece
 113         })
 114       ],
 115       vanish: [
 116         new PiPo({
 117           x: sx,
 118           y: sy,
 119           c: initColor,
 120           p: initPiece
 121         })
 122       ]
 123     });
 124
 125     // The opponent piece disappears if we take it
 126     if (this.board[ex][ey] != V.EMPTY) {
 127       mv.vanish.push(
 128         new PiPo({
 129           x: ex,
 130           y: ey,
 131           c: this.getColor(ex, ey),
 132           p: this.board[ex][ey].charAt(1)
 133         })
 134       );
 135     }
 136
 137     return mv;
 138   }
 139
 140   getPotentialMovesFrom([x, y]) {
 141     if (this.getPiece(x, y) == V.LANCER)
 142       return this.getPotentialLancerMoves([x, y]);
 143     return super.getPotentialMovesFrom([x, y]);
 144   }
 145
 146   // Obtain all lancer moves in "step" direction
 147   getPotentialLancerMoves_aux([x, y], step, tr) {
 148     let moves = [];
 149     // Add all moves to vacant squares until opponent is met:
 150     const color = this.getColor(x, y);
 151     const oppCol = V.GetOppCol(color)
 152     let sq = [x + step[0], y + step[1]];
 153     while (V.OnBoard(sq[0], sq[1]) && this.getColor(sq[0], sq[1]) != oppCol) {
 154       if (this.board[sq[0]][sq[1]] == V.EMPTY)
 155         moves.push(this.getBasicMove([x, y], sq, tr));
 156       sq[0] += step[0];
 157       sq[1] += step[1];
 158     }
 159     if (V.OnBoard(sq[0], sq[1]))
 160       // Add capturing move
 161       moves.push(this.getBasicMove([x, y], sq, tr));
 162     return moves;
 163   }
 164
 165   getPotentialLancerMoves([x, y]) {
 166     let moves = [];
 167     // Add all lancer possible orientations, similar to pawn promotions.
 168     const color = this.getColor(x, y);
 169     const dirCode = this.board[x][y][1];
 170     const curDir = V.LANCER_DIRS[dirCode];
 171     const monodirMoves =
 172       this.getPotentialLancerMoves_aux([x, y], V.LANCER_DIRS[dirCode]);
 173     monodirMoves.forEach(m => {
 174       Object.keys(V.LANCER_DIRS).forEach(k => {
 175         const newDir = V.LANCER_DIRS[k];
 176         // Prevent orientations toward outer board:
 177         if (V.OnBoard(m.end.x + newDir[0], m.end.y + newDir[1])) {
 178           let mk = JSON.parse(JSON.stringify(m));
 179           mk.appear[0].p = k;
 180           moves.push(mk);
 181         }
 182       });
 183     });
 184     return moves;
 185   }
 186
 187   isAttacked(sq, color) {
 188     return (
 189       super.isAttacked(sq, color) ||
 190       this.isAttackedByLancer(sq, color)
 191     );
 192   }
 193
 194   isAttackedByLancer([x, y], color) {
 195     for (let step of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) {
 196       // If in this direction there are only enemy pieces and empty squares,
 197       // and we meet a lancer: can he reach us?
 198       // NOTE: do not stop at first lancer, there might be several!
 199       let coord = { x: x + step[0], y: y + step[1] };
 200       let lancerPos = [];
 201       while (
 202         V.OnBoard(coord.x, coord.y) &&
 203         (
 204           this.board[coord.x][coord.y] == V.EMPTY ||
 205           this.getColor(coord.x, coord.y) == color
 206         )
 207       ) {
 208         if (
 209           this.getPiece(coord.x, coord.y) == V.LANCER &&
 210           !this.isImmobilized([coord.x, coord.y])
 211         ) {
 212           lancerPos.push({x: coord.x, y: coord.y});
 213         }
 214         coord.x += step[0];
 215         coord.y += step[1];
 216       }
 217       for (let xy of lancerPos) {
 218         const dir = V.LANCER_DIRS[this.board[xy.x][xy.y].charAt(1)];
 219         if (dir[0] == -step[0] && dir[1] == -step[1]) return true;
 220       }
 221     }
 222     return false;
 223   }
 224
 225   static get VALUES() {
 226     return Object.assign(
 227       { l: 4.8 }, //Jeff K. estimation (for Eightpieces)
 228       ChessRules.VALUES
 229     );
 230   }
 231
 232   // For moves notation:
 233   static get LANCER_DIRNAMES() {
 234     return {
 235       'c': "N",
 236       'd': "NE",
 237       'e': "E",
 238       'f': "SE",
 239       'g': "S",
 240       'h': "SW",
 241       'm': "W",
 242       'o': "NW"
 243     };
 244   }
 245
 246   filterValid(moves) {
 247     // At move 1, forbid captures (in case of...):
 248     if (this.movesCount >= 2) return moves;
 249     return moves.filter(m => m.vanish.length == 1);
 250   }
 251
 252   getNotation(move) {
 253     let notation = super.getNotation(move);
 254     if (Object.keys(V.LANCER_DIRNAMES).includes(move.vanish[0].p))
 255       // Lancer: add direction info
 256       notation += "=" + V.LANCER_DIRNAMES[move.appear[0].p];
 257     else if (
 258       move.vanish[0].p == V.PAWN &&
 259       Object.keys(V.LANCER_DIRNAMES).includes(move.appear[0].p)
 260     ) {
 261       // Fix promotions in lancer:
 262       notation = notation.slice(0, -1) +
 263         "L:" + V.LANCER_DIRNAMES[move.appear[0].p];
 264     }
 265     return notation;
 266   }
 267
 268 };