client/src/variants/Magnetic.js

   1 import { ChessRules, PiPo } from "@/base_rules";
   2
   3 export class MagneticRules extends ChessRules {
   4
   5   static get HasEnpassant() {
   6     return false;
   7   }
   8
   9   getPotentialMovesFrom([x, y]) {
  10     let standardMoves = super.getPotentialMovesFrom([x, y]);
  11     let moves = [];
  12     standardMoves.forEach(m => {
  13       let newMove_s = this.applyMagneticLaws(m);
  14       if (newMove_s.length == 1) moves.push(newMove_s[0]);
  15       //promotion
  16       else moves = moves.concat(newMove_s);
  17     });
  18     return moves;
  19   }
  20
  21   // Complete a move with magnetic actions
  22   // TODO: job is done multiple times for (normal) promotions.
  23   applyMagneticLaws(move) {
  24     // Exception: kings are not charged
  25     if (move.appear[0].p == V.KING && move.appear.length == 1) return [move];
  26     // If castling, rook is charged:
  27     const aIdx = move.appear[0].p != V.KING ? 0 : 1;
  28     const [x, y] = [move.appear[aIdx].x, move.appear[aIdx].y];
  29     const color = this.turn;
  30     const lastRank = color == "w" ? 0 : 7;
  31     const standardMove = JSON.parse(JSON.stringify(move));
  32     this.play(standardMove);
  33     for (let step of [
  34       [-1, 0],
  35       [1, 0],
  36       [0, -1],
  37       [0, 1]
  38     ]) {
  39       let [i, j] = [x + step[0], y + step[1]];
  40       while (V.OnBoard(i, j)) {
  41         if (this.board[i][j] != V.EMPTY) {
  42           // Found something. Same color or not?
  43           if (this.getColor(i, j) != color) {
  44             // Attraction
  45             if (
  46               (Math.abs(i - x) >= 2 || Math.abs(j - y) >= 2) &&
  47               this.getPiece(i, j) != V.KING
  48             ) {
  49               move.vanish.push(
  50                 new PiPo({
  51                   p: this.getPiece(i, j),
  52                   c: this.getColor(i, j),
  53                   x: i,
  54                   y: j
  55                 })
  56               );
  57               move.appear.push(
  58                 new PiPo({
  59                   p: this.getPiece(i, j),
  60                   c: this.getColor(i, j),
  61                   x: x + step[0],
  62                   y: y + step[1]
  63                 })
  64               );
  65             }
  66           } else {
  67             // Repulsion
  68             if (this.getPiece(i, j) != V.KING) {
  69               // Push it until we meet an obstacle or edge of the board
  70               let [ii, jj] = [i + step[0], j + step[1]];
  71               while (V.OnBoard(ii, jj)) {
  72                 if (this.board[ii][jj] != V.EMPTY) break;
  73                 ii += step[0];
  74                 jj += step[1];
  75               }
  76               ii -= step[0];
  77               jj -= step[1];
  78               if (Math.abs(ii - i) >= 1 || Math.abs(jj - j) >= 1) {
  79                 move.vanish.push(
  80                   new PiPo({
  81                     p: this.getPiece(i, j),
  82                     c: this.getColor(i, j),
  83                     x: i,
  84                     y: j
  85                   })
  86                 );
  87                 move.appear.push(
  88                   new PiPo({
  89                     p: this.getPiece(i, j),
  90                     c: this.getColor(i, j),
  91                     x: ii,
  92                     y: jj
  93                   })
  94                 );
  95               }
  96             }
  97           }
  98           break;
  99         }
 100         i += step[0];
 101         j += step[1];
 102       }
 103     }
 104     this.undo(standardMove);
 105     let moves = [];
 106     // Scan move for pawn (max 1) on 8th rank
 107     for (let i = 1; i < move.appear.length; i++) {
 108       if (
 109         move.appear[i].p == V.PAWN &&
 110         move.appear[i].c == color &&
 111         move.appear[i].x == lastRank
 112       ) {
 113         move.appear[i].p = V.ROOK;
 114         moves.push(move);
 115         for (let piece of [V.KNIGHT, V.BISHOP, V.QUEEN]) {
 116           let cmove = JSON.parse(JSON.stringify(move));
 117           cmove.appear[i].p = piece;
 118           moves.push(cmove);
 119         }
 120         // Swap appear[i] and appear[0] for moves presentation
 121         // (TODO: this is awkward)
 122         moves.forEach(m => {
 123           let tmp = m.appear[0];
 124           m.appear[0] = m.appear[i];
 125           m.appear[i] = tmp;
 126         });
 127         break;
 128       }
 129     }
 130     if (moves.length == 0)
 131       //no pawn on 8th rank
 132       moves.push(move);
 133     return moves;
 134   }
 135
 136   atLeastOneMove() {
 137     if (this.kingPos[this.turn][0] < 0) return false;
 138     return true; //TODO: is it right?
 139   }
 140
 141   filterValid(moves) {
 142     // There are no checks
 143     return moves;
 144   }
 145
 146   getCheckSquares() {
 147     return [];
 148   }
 149
 150   postPlay(move) {
 151     super.postPlay(move);
 152     const c = move.vanish[0].c;
 153     if (move.vanish.length >= 2 && move.vanish[1].p == V.KING) {
 154       // We took opponent king !
 155       const oppCol = V.GetOppCol(c);
 156       this.kingPos[oppCol] = [-1, -1];
 157       this.castleFlags[oppCol] = [8, 8];
 158     }
 159     // Did we magnetically move our (init) rooks or opponents' ones ?
 160     const firstRank = c == "w" ? 7 : 0;
 161     const oppFirstRank = 7 - firstRank;
 162     const oppCol = V.GetOppCol(c);
 163     move.vanish.forEach(psq => {
 164       if (
 165         psq.x == firstRank &&
 166         this.castleFlags[c].includes(psq.y)
 167       ) {
 168         this.castleFlags[c][psq.y == this.castleFlags[c][0] ? 0 : 1] = 8;
 169       }
 170       else if (
 171         psq.x == oppFirstRank &&
 172         this.castleFlags[oppCol].includes(psq.y)
 173       ) {
 174         const flagIdx = (psq.y == this.castleFlags[oppCol][0] ? 0 : 1);
 175         this.castleFlags[oppCol][flagIdx] = 8;
 176       }
 177     });
 178   }
 179
 180   postUndo(move) {
 181     super.postUndo(move);
 182     const c = move.vanish[0].c;
 183     const oppCol = V.GetOppCol(c);
 184     if (this.kingPos[oppCol][0] < 0) {
 185       // Last move took opponent's king
 186       for (let psq of move.vanish) {
 187         if (psq.p == "k") {
 188           this.kingPos[oppCol] = [psq.x, psq.y];
 189           break;
 190         }
 191       }
 192     }
 193   }
 194
 195   getCurrentScore() {
 196     const color = this.turn;
 197     const kp = this.kingPos[color];
 198     if (kp[0] < 0)
 199       // King disappeared
 200       return color == "w" ? "0-1" : "1-0";
 201     if (this.atLeastOneMove())
 202       // Game not over
 203       return "*";
 204     return "1/2"; //no moves but kings still there
 205   }
 206
 207   static get THRESHOLD_MATE() {
 208     return 500; //checkmates evals may be slightly below 1000
 209   }
 210
 211   static get SEARCH_DEPTH() {
 212     return 2;
 213   }
 214
 215 };