client/src/variants/Checkered.js

   1 import { ChessRules } from "@/base_rules";
   2
   3 export const VariantRules = class CheckeredRules extends ChessRules {
   4   static getPpath(b) {
   5     return b[0] == "c" ? "Checkered/" + b : b;
   6   }
   7
   8   static board2fen(b) {
   9     const checkered_codes = {
  10       p: "s",
  11       q: "t",
  12       r: "u",
  13       b: "c",
  14       n: "o"
  15     };
  16     if (b[0] == "c") return checkered_codes[b[1]];
  17     return ChessRules.board2fen(b);
  18   }
  19
  20   static fen2board(f) {
  21     // Tolerate upper-case versions of checkered pieces (why not?)
  22     const checkered_pieces = {
  23       s: "p",
  24       S: "p",
  25       t: "q",
  26       T: "q",
  27       u: "r",
  28       U: "r",
  29       c: "b",
  30       C: "b",
  31       o: "n",
  32       O: "n"
  33     };
  34     if (Object.keys(checkered_pieces).includes(f))
  35       return "c" + checkered_pieces[f];
  36     return ChessRules.fen2board(f);
  37   }
  38
  39   static get PIECES() {
  40     return ChessRules.PIECES.concat(["s", "t", "u", "c", "o"]);
  41   }
  42
  43   setOtherVariables(fen) {
  44     super.setOtherVariables(fen);
  45     // Local stack of non-capturing checkered moves:
  46     this.cmoves = [];
  47     const cmove = fen.split(" ")[5];
  48     if (cmove == "-") this.cmoves.push(null);
  49     else {
  50       this.cmoves.push({
  51         start: ChessRules.SquareToCoords(cmove.substr(0, 2)),
  52         end: ChessRules.SquareToCoords(cmove.substr(2))
  53       });
  54     }
  55   }
  56
  57   static IsGoodFen(fen) {
  58     if (!ChessRules.IsGoodFen(fen)) return false;
  59     const fenParts = fen.split(" ");
  60     if (fenParts.length != 6) return false;
  61     if (fenParts[5] != "-" && !fenParts[5].match(/^([a-h][1-8]){2}$/))
  62       return false;
  63     return true;
  64   }
  65
  66   static IsGoodFlags(flags) {
  67     // 4 for castle + 16 for pawns
  68     return !!flags.match(/^[01]{20,20}$/);
  69   }
  70
  71   setFlags(fenflags) {
  72     super.setFlags(fenflags); //castleFlags
  73     this.pawnFlags = {
  74       w: [...Array(8).fill(true)], //pawns can move 2 squares?
  75       b: [...Array(8).fill(true)]
  76     };
  77     if (!fenflags) return;
  78     const flags = fenflags.substr(4); //skip first 4 digits, for castle
  79     for (let c of ["w", "b"]) {
  80       for (let i = 0; i < 8; i++)
  81         this.pawnFlags[c][i] = flags.charAt((c == "w" ? 0 : 8) + i) == "1";
  82     }
  83   }
  84
  85   aggregateFlags() {
  86     return [this.castleFlags, this.pawnFlags];
  87   }
  88
  89   disaggregateFlags(flags) {
  90     this.castleFlags = flags[0];
  91     this.pawnFlags = flags[1];
  92   }
  93
  94   getCmove(move) {
  95     if (move.appear[0].c == "c" && move.vanish.length == 1)
  96       return { start: move.start, end: move.end };
  97     return null;
  98   }
  99
 100   canTake([x1, y1], [x2, y2]) {
 101     const color1 = this.getColor(x1, y1);
 102     const color2 = this.getColor(x2, y2);
 103     // Checkered aren't captured
 104     return (
 105       color1 != color2 &&
 106       color2 != "c" &&
 107       (color1 != "c" || color2 != this.turn)
 108     );
 109   }
 110
 111   // Post-processing: apply "checkerization" of standard moves
 112   getPotentialMovesFrom([x, y]) {
 113     let standardMoves = super.getPotentialMovesFrom([x, y]);
 114     const lastRank = this.turn == "w" ? 0 : 7;
 115     if (this.getPiece(x, y) == V.KING) return standardMoves; //king has to be treated differently (for castles)
 116     let moves = [];
 117     standardMoves.forEach(m => {
 118       if (m.vanish[0].p == V.PAWN) {
 119         if (
 120           Math.abs(m.end.x - m.start.x) == 2 &&
 121           !this.pawnFlags[this.turn][m.start.y]
 122         )
 123           return; //skip forbidden 2-squares jumps
 124         if (
 125           this.board[m.end.x][m.end.y] == V.EMPTY &&
 126           m.vanish.length == 2 &&
 127           this.getColor(m.start.x, m.start.y) == "c"
 128         ) {
 129           return; //checkered pawns cannot take en-passant
 130         }
 131       }
 132       if (m.vanish.length == 1) moves.push(m);
 133       //no capture
 134       else {
 135         // A capture occured (m.vanish.length == 2)
 136         m.appear[0].c = "c";
 137         moves.push(m);
 138         if (
 139           m.appear[0].p != m.vanish[1].p && //avoid promotions (already treated):
 140           (m.vanish[0].p != V.PAWN || m.end.x != lastRank)
 141         ) {
 142           // Add transformation into captured piece
 143           let m2 = JSON.parse(JSON.stringify(m));
 144           m2.appear[0].p = m.vanish[1].p;
 145           moves.push(m2);
 146         }
 147       }
 148     });
 149     return moves;
 150   }
 151
 152   canIplay(side, [x, y]) {
 153     return side == this.turn && [side, "c"].includes(this.getColor(x, y));
 154   }
 155
 156   // Does m2 un-do m1 ? (to disallow undoing checkered moves)
 157   oppositeMoves(m1, m2) {
 158     return (
 159       !!m1 &&
 160       m2.appear[0].c == "c" &&
 161       m2.appear.length == 1 &&
 162       m2.vanish.length == 1 &&
 163       m1.start.x == m2.end.x &&
 164       m1.end.x == m2.start.x &&
 165       m1.start.y == m2.end.y &&
 166       m1.end.y == m2.start.y
 167     );
 168   }
 169
 170   filterValid(moves) {
 171     if (moves.length == 0) return [];
 172     const color = this.turn;
 173     return moves.filter(m => {
 174       const L = this.cmoves.length; //at least 1: init from FEN
 175       if (this.oppositeMoves(this.cmoves[L - 1], m)) return false;
 176       this.play(m);
 177       const res = !this.underCheck(color);
 178       this.undo(m);
 179       return res;
 180     });
 181   }
 182
 183   isAttackedByPawn([x, y], colors) {
 184     for (let c of colors) {
 185       const color = c == "c" ? this.turn : c;
 186       let pawnShift = color == "w" ? 1 : -1;
 187       if (x + pawnShift >= 0 && x + pawnShift < 8) {
 188         for (let i of [-1, 1]) {
 189           if (
 190             y + i >= 0 &&
 191             y + i < 8 &&
 192             this.getPiece(x + pawnShift, y + i) == V.PAWN &&
 193             this.getColor(x + pawnShift, y + i) == c
 194           ) {
 195             return true;
 196           }
 197         }
 198       }
 199     }
 200     return false;
 201   }
 202
 203   underCheck(color) {
 204     return this.isAttacked(this.kingPos[color], [V.GetOppCol(color), "c"]);
 205   }
 206
 207   getCheckSquares(color) {
 208     // Artifically change turn, for checkered pawns
 209     this.turn = V.GetOppCol(color);
 210     const kingAttacked = this.isAttacked(this.kingPos[color], [
 211       V.GetOppCol(color),
 212       "c"
 213     ]);
 214     let res = kingAttacked
 215       ? [JSON.parse(JSON.stringify(this.kingPos[color]))] //need to duplicate!
 216       : [];
 217     this.turn = color;
 218     return res;
 219   }
 220
 221   updateVariables(move) {
 222     super.updateVariables(move);
 223     // Does this move turn off a 2-squares pawn flag?
 224     const secondRank = [1, 6];
 225     if (secondRank.includes(move.start.x) && move.vanish[0].p == V.PAWN)
 226       this.pawnFlags[move.start.x == 6 ? "w" : "b"][move.start.y] = false;
 227   }
 228
 229   getCurrentScore() {
 230     if (this.atLeastOneMove())
 231       // game not over
 232       return "*";
 233
 234     const color = this.turn;
 235     // Artifically change turn, for checkered pawns
 236     this.turn = V.GetOppCol(this.turn);
 237     const res = this.isAttacked(this.kingPos[color], [V.GetOppCol(color), "c"])
 238       ? color == "w"
 239         ? "0-1"
 240         : "1-0"
 241       : "1/2";
 242     this.turn = V.GetOppCol(this.turn);
 243     return res;
 244   }
 245
 246   evalPosition() {
 247     let evaluation = 0;
 248     //Just count material for now, considering checkered neutral (...)
 249     for (let i = 0; i < V.size.x; i++) {
 250       for (let j = 0; j < V.size.y; j++) {
 251         if (this.board[i][j] != V.EMPTY) {
 252           const sqColor = this.getColor(i, j);
 253           const sign = sqColor == "w" ? 1 : sqColor == "b" ? -1 : 0;
 254           evaluation += sign * V.VALUES[this.getPiece(i, j)];
 255         }
 256       }
 257     }
 258     return evaluation;
 259   }
 260
 261   static GenRandInitFen() {
 262     const randFen = ChessRules.GenRandInitFen();
 263     // Add 16 pawns flags + empty cmove:
 264     return randFen.replace(" w 0 1111", " w 0 11111111111111111111 -");
 265   }
 266
 267   static ParseFen(fen) {
 268     return Object.assign({}, ChessRules.ParseFen(fen), {
 269       cmove: fen.split(" ")[5]
 270     });
 271   }
 272
 273   getFen() {
 274     const L = this.cmoves.length;
 275     const cmoveFen = !this.cmoves[L - 1]
 276       ? "-"
 277       : ChessRules.CoordsToSquare(this.cmoves[L - 1].start) +
 278         ChessRules.CoordsToSquare(this.cmoves[L - 1].end);
 279     return super.getFen() + " " + cmoveFen;
 280   }
 281
 282   getFlagsFen() {
 283     let fen = super.getFlagsFen();
 284     // Add pawns flags
 285     for (let c of ["w", "b"]) {
 286       for (let i = 0; i < 8; i++) fen += this.pawnFlags[c][i] ? "1" : "0";
 287     }
 288     return fen;
 289   }
 290
 291   // TODO (design): this cmove update here or in (un)updateVariables ?
 292   play(move) {
 293     this.cmoves.push(this.getCmove(move));
 294     super.play(move);
 295   }
 296
 297   undo(move) {
 298     this.cmoves.pop();
 299     super.undo(move);
 300   }
 301
 302   getNotation(move) {
 303     if (move.appear.length == 2) {
 304       // Castle
 305       if (move.end.y < move.start.y) return "0-0-0";
 306       return "0-0";
 307     }
 308
 309     // Translate final square
 310     const finalSquare = V.CoordsToSquare(move.end);
 311
 312     const piece = this.getPiece(move.start.x, move.start.y);
 313     if (piece == V.PAWN) {
 314       // Pawn move
 315       let notation = "";
 316       if (move.vanish.length > 1) {
 317         // Capture
 318         const startColumn = V.CoordToColumn(move.start.y);
 319         notation =
 320           startColumn +
 321           "x" +
 322           finalSquare +
 323           "=" +
 324           move.appear[0].p.toUpperCase();
 325       } //no capture
 326       else {
 327         notation = finalSquare;
 328         if (move.appear.length > 0 && piece != move.appear[0].p)
 329           //promotion
 330           notation += "=" + move.appear[0].p.toUpperCase();
 331       }
 332       return notation;
 333     }
 334     // Piece movement
 335     return (
 336       piece.toUpperCase() +
 337       (move.vanish.length > 1 ? "x" : "") +
 338       finalSquare +
 339       (move.vanish.length > 1 ? "=" + move.appear[0].p.toUpperCase() : "")
 340     );
 341   }
 342 };