client/src/variants/Koopa.js

   1 import { ChessRules, PiPo } from "@/base_rules";
   2
   3 export class KoopaRules extends ChessRules {
   4
   5   static get HasEnpassant() {
   6     return false;
   7   }
   8
   9   static get STUNNED() {
  10     return ['s', 'u', 'o', 'c', 't', 'l'];
  11   }
  12
  13   static get PIECES() {
  14     return ChessRules.PIECES.concat(V.STUNNED);
  15   }
  16
  17   static ParseFen(fen) {
  18     let res = ChessRules.ParseFen(fen);
  19     const fenParts = fen.split(" ");
  20     res.stunned = fenParts[4];
  21     return res;
  22   }
  23
  24   static IsGoodFen(fen) {
  25     if (!ChessRules.IsGoodFen(fen)) return false;
  26     const fenParsed = V.ParseFen(fen);
  27     // 5) Check "stunned"
  28     if (
  29       !fenParsed.stunned ||
  30       (
  31         fenParsed.stunned != "-" &&
  32         !fenParsed.stunned.match(/^([a-h][1-8][1-4],?)*$/)
  33       )
  34     ) {
  35       return false;
  36     }
  37     return true;
  38   }
  39
  40   getPpath(b) {
  41     return (V.STUNNED.includes(b[1]) ? "Koopa/" : "") + b;
  42   }
  43
  44   getFen() {
  45     return super.getFen() + " " + this.getStunnedFen();
  46   }
  47
  48   getFenForRepeat() {
  49     return super.getFenForRepeat() + "_" + this.getStunnedFen();
  50   }
  51
  52   getStunnedFen() {
  53     const squares = Object.keys(this.stunned);
  54     if (squares.length == 0) return "-";
  55     return squares.map(square => square + this.stunned[square]).join(",");
  56   }
  57
  58   // Base GenRandInitFen() is fine because en-passant indicator will
  59   // stand for stunned indicator.
  60
  61   scanKings(fen) {
  62     // Squares of white and black king:
  63     this.kingPos = { w: [-1, -1], b: [-1, -1] };
  64     const fenRows = V.ParseFen(fen).position.split("/");
  65     const startRow = { 'w': V.size.x - 1, 'b': 0 };
  66     for (let i = 0; i < fenRows.length; i++) {
  67       let k = 0; //column index on board
  68       for (let j = 0; j < fenRows[i].length; j++) {
  69         switch (fenRows[i].charAt(j)) {
  70           case "k":
  71           case "l":
  72             this.kingPos["b"] = [i, k];
  73             break;
  74           case "K":
  75           case "L":
  76             this.kingPos["w"] = [i, k];
  77             break;
  78           default: {
  79             const num = parseInt(fenRows[i].charAt(j), 10);
  80             if (!isNaN(num)) k += num - 1;
  81           }
  82         }
  83         k++;
  84       }
  85     }
  86   }
  87
  88   setOtherVariables(fen) {
  89     super.setOtherVariables(fen);
  90     let stunnedArray = [];
  91     const stunnedFen = V.ParseFen(fen).stunned;
  92     if (stunnedFen != "-") {
  93       stunnedArray =
  94         stunnedFen
  95         .split(",")
  96         .map(s => {
  97           return {
  98             square: s.substr(0, 2),
  99             state: parseInt(s[2], 10)
 100           };
 101         });
 102     }
 103     this.stunned = {};
 104     stunnedArray.forEach(s => {
 105       this.stunned[s.square] = s.state;
 106     });
 107   }
 108
 109   getNormalizedStep(step) {
 110     const [deltaX, deltaY] = [Math.abs(step[0]), Math.abs(step[1])];
 111     if (deltaX == 0 || deltaY == 0 || deltaX == deltaY)
 112       return [step[0] / deltaX || 0, step[1] / deltaY || 0];
 113     // Knight:
 114     const divisor = Math.min(deltaX, deltaY)
 115     return [step[0] / divisor, step[1] / divisor];
 116   }
 117
 118   getPotentialMovesFrom([x, y]) {
 119     let moves = super.getPotentialMovesFrom([x, y]).filter(m => {
 120       if (
 121         m.vanish[0].p != V.PAWN ||
 122         m.appear[0].p == V.PAWN ||
 123         m.vanish.length == 1
 124       ) {
 125         return true;
 126       }
 127       // Pawn promotion, "capturing": remove duplicates
 128       return m.appear[0].p == V.QUEEN;
 129     });
 130     // Complete moves: stuns & kicks
 131     let promoteAfterStun = [];
 132     const color = this.turn;
 133     moves.forEach(m => {
 134       if (m.vanish.length == 2 && m.appear.length == 1) {
 135         const step =
 136           this.getNormalizedStep([m.end.x - m.start.x, m.end.y - m.start.y]);
 137         // "Capture" something: is target stunned?
 138         if (V.STUNNED.includes(m.vanish[1].p)) {
 139           // Kick it: continue movement in the same direction,
 140           // destroying all on its path.
 141           let [i, j] = [m.end.x + step[0], m.end.y + step[1]];
 142           while (V.OnBoard(i, j)) {
 143             if (this.board[i][j] != V.EMPTY) {
 144               m.vanish.push(
 145                 new PiPo({
 146                   x: i,
 147                   y: j,
 148                   c: this.getColor(i, j),
 149                   p: this.getPiece(i, j)
 150                 })
 151               );
 152             }
 153             i += step[0];
 154             j += step[1];
 155           }
 156         }
 157         else {
 158           // The piece is now stunned
 159           m.appear.push(JSON.parse(JSON.stringify(m.vanish[1])));
 160           const pIdx = ChessRules.PIECES.findIndex(p => p == m.appear[1].p);
 161           m.appear[1].p = V.STUNNED[pIdx];
 162           // And the capturer continue in the same direction until an empty
 163           // square or the edge of the board, maybe stunning other pieces.
 164           let [i, j] = [m.end.x + step[0], m.end.y + step[1]];
 165           while (V.OnBoard(i, j) && this.board[i][j] != V.EMPTY) {
 166             const colIJ = this.getColor(i, j);
 167             const pieceIJ = this.getPiece(i, j);
 168             let pIdx = ChessRules.PIECES.findIndex(p => p == pieceIJ);
 169             if (pIdx >= 0) {
 170               // The piece isn't already stunned
 171               m.vanish.push(
 172                 new PiPo({
 173                   x: i,
 174                   y: j,
 175                   c: colIJ,
 176                   p: pieceIJ
 177                 })
 178               );
 179               m.appear.push(
 180                 new PiPo({
 181                   x: i,
 182                   y: j,
 183                   c: colIJ,
 184                   p: V.STUNNED[pIdx]
 185                 })
 186               );
 187             }
 188             i += step[0];
 189             j += step[1];
 190           }
 191           if (V.OnBoard(i, j)) {
 192             m.appear[0].x = i;
 193             m.appear[0].y = j;
 194             // Is it a pawn on last rank?
 195             if (
 196               m.appear[0].p == V.PAWN &&
 197               ((color == 'w' && i == 0) || (color == 'b' && i == 7))
 198             ) {
 199               m.appear[0].p = V.ROOK;
 200               for (let ppiece of [V.KNIGHT, V.BISHOP, V.QUEEN]) {
 201                 let mp = JSON.parse(JSON.stringify(m));
 202                 mp.appear[0].p = ppiece;
 203                 promoteAfterStun.push(mp);
 204               }
 205             }
 206           }
 207           else
 208             // The piece is out
 209             m.appear.shift();
 210         }
 211       }
 212     });
 213     return moves.concat(promoteAfterStun);
 214   }
 215
 216   getPotentialKingMoves(sq) {
 217     return (
 218       this.getSlideNJumpMoves(
 219         sq,
 220         V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
 221         "oneStep"
 222       ).concat(super.getCastleMoves(sq, null, true, ['r']))
 223     );
 224   }
 225
 226   filterValid(moves) {
 227     // Forbid kicking own king out
 228     const color = this.turn;
 229     return moves.filter(m => {
 230       const kingVanish =
 231         m.vanish.some(v => v.c == color && ['k', 'l'].includes(v.p));
 232       if (kingVanish) {
 233         const kingAppear =
 234           m.appear.some(a => a.c == color && ['k', 'l'].includes(a.p));
 235         return kingAppear;
 236       }
 237       return true;
 238     });
 239   }
 240
 241   getCheckSquares() {
 242     return [];
 243   }
 244
 245   getCurrentScore() {
 246     if (this.kingPos['w'][0] < 0) return "0-1";
 247     if (this.kingPos['b'][0] < 0) return "1-0";
 248     if (!this.atLeastOneMove()) return "1/2";
 249     return "*";
 250   }
 251
 252   postPlay(move) {
 253     // Base method is fine because a stunned king (which won't be detected)
 254     // can still castle after going back to normal.
 255     super.postPlay(move);
 256     const color = this.turn;
 257     const kp = this.kingPos[color];
 258     if (
 259       this.board[kp[0], kp[1]] == V.EMPTY ||
 260       !['k', 'l'].includes(this.getPiece(kp[0], kp[1])) ||
 261       this.getColor(kp[0], kp[1]) != color
 262     ) {
 263       // King didn't move by itself, and vanished => game over
 264       this.kingPos[color] = [-1, -1];
 265     }
 266     move.stunned = JSON.stringify(this.stunned);
 267     // Array of stunned stage 1 pieces (just back to normal then)
 268     Object.keys(this.stunned).forEach(square => {
 269       // All (formerly) stunned pieces progress by 1 level, if still on board
 270       const coords = V.SquareToCoords(square);
 271       const [x, y] = [coords.x, coords.y];
 272       if (V.STUNNED.includes(this.board[x][y][1])) {
 273         // Stunned piece still on board
 274         this.stunned[square]--;
 275         if (this.stunned[square] == 0) {
 276           delete this.stunned[square];
 277           const color = this.getColor(x, y);
 278           const piece = this.getPiece(x, y);
 279           const pIdx = V.STUNNED.findIndex(p => p == piece);
 280           this.board[x][y] = color + ChessRules.PIECES[pIdx];
 281         }
 282       }
 283       else delete this.stunned[square];
 284     });
 285     // Any new stunned pieces?
 286     move.appear.forEach(a => {
 287       if (V.STUNNED.includes(a.p))
 288         // Set to maximum stun level:
 289         this.stunned[V.CoordsToSquare({ x: a.x, y: a.y })] = 4;
 290     });
 291   }
 292
 293   postUndo(move) {
 294     super.postUndo(move);
 295     const oppCol = V.GetOppCol(this.turn);
 296     if (this.kingPos[oppCol][0] < 0) {
 297       // Opponent's king vanished
 298       const psq =
 299         move.vanish.find((v,i) => i >= 1 && ['k', 'l'].includes(v.p));
 300       this.kingPos[oppCol] = [psq.x, psq.y];
 301     }
 302     this.stunned = JSON.parse(move.stunned);
 303     for (let i=0; i<8; i++) {
 304       for (let j=0; j<8; j++) {
 305         const square = V.CoordsToSquare({ x: i, y: j });
 306         const pieceIJ = this.getPiece(i, j);
 307         if (!this.stunned[square]) {
 308           const pIdx = V.STUNNED.findIndex(p => p == pieceIJ);
 309           if (pIdx >= 0)
 310             this.board[i][j] = this.getColor(i, j) + ChessRules.PIECES[pIdx];
 311         }
 312         else {
 313           const pIdx = ChessRules.PIECES.findIndex(p => p == pieceIJ);
 314           if (pIdx >= 0)
 315             this.board[i][j] = this.getColor(i, j) + V.STUNNED[pIdx];
 316         }
 317       }
 318     }
 319   }
 320
 321   static get VALUES() {
 322     return Object.assign(
 323       {
 324         s: 1,
 325         u: 5,
 326         o: 3,
 327         c: 3,
 328         t: 9,
 329         l: 1000
 330       },
 331       ChessRules.VALUES
 332     );
 333   }
 334
 335   static get SEARCH_DEPTH() {
 336     return 2;
 337   }
 338
 339   getNotation(move) {
 340     if (
 341       move.appear.length == 2 &&
 342       move.vanish.length == 2 &&
 343       move.appear.concat(move.vanish).every(
 344         av => ChessRules.PIECES.includes(av.p)) &&
 345       move.appear[0].p == V.KING
 346     ) {
 347       if (move.end.y < move.start.y) return "0-0-0";
 348       return "0-0";
 349     }
 350     const finalSquare = V.CoordsToSquare(move.end);
 351     const piece = this.getPiece(move.start.x, move.start.y);
 352     const captureMark = move.vanish.length >= 2 ? "x" : "";
 353     let pawnMark = "";
 354     if (piece == 'p' && captureMark.length == 1)
 355       pawnMark = V.CoordToColumn(move.start.y); //start column
 356     // Piece or pawn movement
 357     let notation =
 358       (piece == V.PAWN ? pawnMark : piece.toUpperCase()) +
 359       captureMark + finalSquare;
 360     if (
 361       piece == 'p' &&
 362       move.appear[0].c == move.vanish[0].c &&
 363       move.appear[0].p != 'p'
 364     ) {
 365       // Promotion
 366       notation += "=" + move.appear[0].p.toUpperCase();
 367     }
 368     return notation;
 369   }
 370
 371 };