client/src/variants/Antiking1.js

   1 import { ChessRules } from "@/base_rules";
   2 import { BerolinaRules } from "@/variants/Berolina";
   3 import { ArrayFun } from "@/utils/array";
   4 import { randInt } from "@/utils/alea";
   5
   6 export class Antiking1Rules extends BerolinaRules {
   7
   8   static get PawnSpecs() {
   9     return Object.assign(
  10       {},
  11       ChessRules.PawnSpecs,
  12       { twoSquares: false }
  13     );
  14   }
  15
  16   static get HasCastle() {
  17     return false;
  18   }
  19
  20   static get ANTIKING() {
  21     return "a";
  22   }
  23
  24   static get PIECES() {
  25     return ChessRules.PIECES.concat([V.ANTIKING]);
  26   }
  27
  28   getPpath(b) {
  29     return b[1] == "a" ? "Antiking/" + b : b;
  30   }
  31
  32   static IsGoodPosition(position) {
  33     if (!ChessRules.IsGoodPosition(position)) return false;
  34     const rows = position.split("/");
  35     // Check that exactly one antiking of each color is there:
  36     let antikings = { 'a': 0, 'A': 0 };
  37     for (let row of rows) {
  38       for (let i = 0; i < row.length; i++)
  39         if (['A','a'].includes(row[i])) antikings[row[i]]++;
  40     }
  41     if (Object.values(antikings).some(v => v != 1)) return false;
  42     return true;
  43   }
  44
  45   setOtherVariables(fen) {
  46     super.setOtherVariables(fen);
  47     this.antikingPos = { w: [-1, -1], b: [-1, -1] };
  48     const rows = V.ParseFen(fen).position.split("/");
  49     for (let i = 0; i < rows.length; i++) {
  50       let k = 0;
  51       for (let j = 0; j < rows[i].length; j++) {
  52         switch (rows[i].charAt(j)) {
  53           case "a":
  54             this.antikingPos["b"] = [i, k];
  55             break;
  56           case "A":
  57             this.antikingPos["w"] = [i, k];
  58             break;
  59           default: {
  60             const num = parseInt(rows[i].charAt(j), 10);
  61             if (!isNaN(num)) k += num - 1;
  62           }
  63         }
  64         k++;
  65       }
  66     }
  67   }
  68
  69   // (Anti)King flags at 1 (true) if they can knight-jump
  70   setFlags(fenflags) {
  71     this.kingFlags = {
  72       // King then antiking
  73       w: [...Array(2).fill(false)],
  74       b: [...Array(2).fill(false)]
  75     };
  76     for (let c of ["w", "b"]) {
  77       for (let i = 0; i < 2; i++)
  78         this.kingFlags[c][i] = fenflags.charAt((c == "w" ? 0 : 2) + i) == "1";
  79     }
  80   }
  81
  82   aggregateFlags() {
  83     return this.kingFlags;
  84   }
  85
  86   disaggregateFlags(flags) {
  87     this.kingFlags = flags;
  88   }
  89
  90   getFlagsFen() {
  91     // Return kings flags
  92     let flags = "";
  93     for (let c of ["w", "b"]) {
  94       for (let i = 0; i < 2; i++) flags += this.kingFlags[c][i] ? "1" : "0";
  95     }
  96     return flags;
  97   }
  98
  99   canTake([x1, y1], [x2, y2]) {
 100     const piece1 = this.getPiece(x1, y1);
 101     const piece2 = this.getPiece(x2, y2);
 102     const color1 = this.getColor(x1, y1);
 103     const color2 = this.getColor(x2, y2);
 104     return (
 105       piece2 != "a" &&
 106       ((piece1 != "a" && color1 != color2) ||
 107         (piece1 == "a" && color1 == color2))
 108     );
 109   }
 110
 111   getPotentialMovesFrom([x, y]) {
 112     let moves = [];
 113     let addKnightJumps = false;
 114     const piece = this.getPiece(x, y);
 115     const color = this.getColor(x, y);
 116     if (piece == V.ANTIKING) {
 117       moves = this.getPotentialAntikingMoves([x, y]);
 118       addKnightJumps = this.kingFlags[color][1];
 119     } else {
 120       moves = super.getPotentialMovesFrom([x, y]);
 121       if (piece == V.KING) addKnightJumps = this.kingFlags[color][0];
 122     }
 123     if (addKnightJumps) {
 124       // Add potential knight jump to (anti)kings
 125       const knightJumps = super.getPotentialKnightMoves([x, y]);
 126       // Remove captures (TODO: could be done more efficiently...)
 127       moves = moves.concat(knightJumps.filter(m => m.vanish.length == 1));
 128     }
 129     return moves;
 130   }
 131
 132   getPotentialAntikingMoves(sq) {
 133     // The antiking moves like a king (only captured colors differ)
 134     return this.getSlideNJumpMoves(
 135       sq,
 136       V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
 137       "oneStep"
 138     );
 139   }
 140
 141   isAttacked(sq, color) {
 142     return (
 143       super.isAttacked(sq, color) ||
 144       this.isAttackedByAntiking(sq, color)
 145     );
 146   }
 147
 148   isAttackedByKing([x, y], color) {
 149     // Antiking is not attacked by king:
 150     if (this.getPiece(x, y) == V.ANTIKING) return false;
 151     return this.isAttackedBySlideNJump(
 152       [x, y],
 153       color,
 154       V.KING,
 155       V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
 156       "oneStep"
 157     );
 158   }
 159
 160   isAttackedByAntiking([x, y], color) {
 161     // (Anti)King is not attacked by antiking
 162     if ([V.KING, V.ANTIKING].includes(this.getPiece(x, y))) return false;
 163     return this.isAttackedBySlideNJump(
 164       [x, y],
 165       color,
 166       V.ANTIKING,
 167       V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
 168       "oneStep"
 169     );
 170   }
 171
 172   underCheck(color) {
 173     const oppCol = V.GetOppCol(color);
 174     let res =
 175       this.isAttacked(this.kingPos[color], oppCol) ||
 176       !this.isAttacked(this.antikingPos[color], oppCol);
 177     return res;
 178   }
 179
 180   getCheckSquares() {
 181     const color = this.turn;
 182     let res = [];
 183     const oppCol = V.GetOppCol(color);
 184     if (this.isAttacked(this.kingPos[color], oppCol))
 185       res.push(JSON.parse(JSON.stringify(this.kingPos[color])));
 186     if (!this.isAttacked(this.antikingPos[color], oppCol))
 187       res.push(JSON.parse(JSON.stringify(this.antikingPos[color])));
 188     return res;
 189   }
 190
 191   postPlay(move) {
 192     super.postPlay(move);
 193     const piece = move.vanish[0].p;
 194     const c = move.vanish[0].c;
 195     // Update antiking position, and kings flags
 196     if (piece == V.ANTIKING) {
 197       this.antikingPos[c][0] = move.appear[0].x;
 198       this.antikingPos[c][1] = move.appear[0].y;
 199       this.kingFlags[c][1] = false;
 200     } else if (piece == V.KING) this.kingFlags[c][0] = false;
 201   }
 202
 203   postUndo(move) {
 204     super.postUndo(move);
 205     const c = move.vanish[0].c;
 206     if (move.vanish[0].p == V.ANTIKING)
 207       this.antikingPos[c] = [move.start.x, move.start.y];
 208   }
 209
 210   static get VALUES() {
 211     return Object.assign(
 212       { a: 1000 },
 213       ChessRules.VALUES
 214     );
 215   }
 216
 217   static GenRandInitFen() {
 218     // Always deterministic setup
 219     return "2prbkqA/2p1nnbr/2pppppp/8/8/PPPPPP2/RBNN1P2/aQKBRP2 w 0 1111";
 220   }
 221
 222   static get SEARCH_DEPTH() {
 223     return 2;
 224   }
 225
 226 };