client/src/variants/Xiangqi.js

   1 import { ChessRules } from "@/base_rules";
   2
   3 export class XiangqiRules extends ChessRules {
   4
   5   static get Options() {
   6     return null;
   7   }
   8
   9   // NOTE (TODO?) scanKings() could be more efficient (in Jangqi too)
  10
  11   static get Monochrome() {
  12     return true;
  13   }
  14
  15   static get Notoodark() {
  16     return true;
  17   }
  18
  19   static get Lines() {
  20     let lines = [];
  21     // Draw all inter-squares lines, shifted:
  22     for (let i = 0; i < V.size.x; i++)
  23       lines.push([[i+0.5, 0.5], [i+0.5, V.size.y-0.5]]);
  24     for (let j = 0; j < V.size.y; j++)
  25       lines.push([[0.5, j+0.5], [V.size.x-0.5, j+0.5]]);
  26     // Add palaces:
  27     lines.push([[0.5, 3.5], [2.5, 5.5]]);
  28     lines.push([[0.5, 5.5], [2.5, 3.5]]);
  29     lines.push([[9.5, 3.5], [7.5, 5.5]]);
  30     lines.push([[9.5, 5.5], [7.5, 3.5]]);
  31     // Show river:
  32     lines.push([[4.5, 0.5], [5.5, 8.5]]);
  33     lines.push([[5.5, 0.5], [4.5, 8.5]]);
  34     return lines;
  35   }
  36
  37   static get HasFlags() {
  38     return false;
  39   }
  40
  41   static get HasEnpassant() {
  42     return false;
  43   }
  44
  45   static get LoseOnRepetition() {
  46     return true;
  47   }
  48
  49   static get ELEPHANT() {
  50     return "e";
  51   }
  52
  53   static get CANNON() {
  54     return "c";
  55   }
  56
  57   static get ADVISOR() {
  58     return "a";
  59   }
  60
  61   static get PIECES() {
  62     return [V.PAWN, V.ROOK, V.KNIGHT, V.ELEPHANT, V.ADVISOR, V.KING, V.CANNON];
  63   }
  64
  65   getPpath(b) {
  66     return "Xiangqi/" + b;
  67   }
  68
  69   static get size() {
  70     return { x: 10, y: 9};
  71   }
  72
  73   getPotentialMovesFrom(sq) {
  74     let moves = [];
  75     const piece = this.getPiece(sq[0], sq[1]);
  76     switch (piece) {
  77       case V.PAWN:
  78         moves = this.getPotentialPawnMoves(sq);
  79         break;
  80       case V.ROOK:
  81         moves = super.getPotentialRookMoves(sq);
  82         break;
  83       case V.KNIGHT:
  84         moves = this.getPotentialKnightMoves(sq);
  85         break;
  86       case V.ELEPHANT:
  87         moves = this.getPotentialElephantMoves(sq);
  88         break;
  89       case V.ADVISOR:
  90         moves = this.getPotentialAdvisorMoves(sq);
  91         break;
  92       case V.KING:
  93         moves = this.getPotentialKingMoves(sq);
  94         break;
  95       case V.CANNON:
  96         moves = this.getPotentialCannonMoves(sq);
  97         break;
  98     }
  99     if (piece != V.KING && this.kingPos['w'][1] != this.kingPos['b'][1])
 100       return moves;
 101     if (this.kingPos['w'][1] == this.kingPos['b'][1]) {
 102       const colKing = this.kingPos['w'][1];
 103       let intercept = 0; //count intercepting pieces
 104       for (let i = this.kingPos['b'][0] + 1; i < this.kingPos['w'][0]; i++) {
 105         if (this.board[i][colKing] != V.EMPTY) intercept++;
 106       }
 107       if (intercept >= 2) return moves;
 108       // intercept == 1 (0 is impossible):
 109       // Any move not removing intercept is OK
 110       return moves.filter(m => {
 111         return (
 112           // From another column?
 113           m.start.y != colKing ||
 114           // From behind a king? (including kings themselves!)
 115           m.start.x <= this.kingPos['b'][0] ||
 116           m.start.x >= this.kingPos['w'][0] ||
 117           // Intercept piece moving: must remain in-between
 118           (
 119             m.end.y == colKing &&
 120             m.end.x > this.kingPos['b'][0] &&
 121             m.end.x < this.kingPos['w'][0]
 122           )
 123         );
 124       });
 125     }
 126     // piece == king: check only if move.end.y == enemy king column
 127     const color = this.getColor(sq[0], sq[1]);
 128     const oppCol = V.GetOppCol(color);
 129     // colCheck == -1 if unchecked, 1 if checked and occupied,
 130     //              0 if checked and clear
 131     let colCheck = -1;
 132     return moves.filter(m => {
 133       if (m.end.y != this.kingPos[oppCol][1]) return true;
 134       if (colCheck < 0) {
 135         // Do the check:
 136         colCheck = 0;
 137         for (let i = this.kingPos['b'][0] + 1; i < this.kingPos['w'][0]; i++) {
 138           if (this.board[i][m.end.y] != V.EMPTY) {
 139             colCheck++;
 140             break;
 141           }
 142         }
 143         return colCheck == 1;
 144       }
 145       // Check already done:
 146       return colCheck == 1;
 147     });
 148   }
 149
 150   getPotentialPawnMoves([x, y]) {
 151     const c = this.getColor(x, y);
 152     const shiftX = (c == 'w' ? -1 : 1);
 153     const crossedRiver = (c == 'w' && x <= 4 || c == 'b' && x >= 5);
 154     const lastRank = (c == 'w' && x == 0 || c == 'b' && x == 9);
 155     let steps = [];
 156     if (!lastRank) steps.push([shiftX, 0]);
 157     if (crossedRiver) {
 158       if (y > 0) steps.push([0, -1]);
 159       if (y < 9) steps.push([0, 1]);
 160     }
 161     return super.getSlideNJumpMoves([x, y], steps, 1);
 162   }
 163
 164   knightStepsFromRookStep(step) {
 165     if (step[0] == 0) return [ [1, 2*step[1]], [-1, 2*step[1]] ];
 166     return [ [2*step[0], 1], [2*step[0], -1] ];
 167   }
 168
 169   getPotentialKnightMoves([x, y]) {
 170     let steps = [];
 171     for (let rookStep of ChessRules.steps[V.ROOK]) {
 172       const [i, j] = [x + rookStep[0], y + rookStep[1]];
 173       if (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
 174         Array.prototype.push.apply(steps,
 175           // These moves might be impossible, but need to be checked:
 176           this.knightStepsFromRookStep(rookStep));
 177       }
 178     }
 179     return super.getSlideNJumpMoves([x, y], steps, 1);
 180   }
 181
 182   getPotentialElephantMoves([x, y]) {
 183     let steps = [];
 184     const c = this.getColor(x, y);
 185     for (let bishopStep of ChessRules.steps[V.BISHOP]) {
 186       const [i, j] = [x + bishopStep[0], y + bishopStep[1]];
 187       if (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
 188         const [newX, newY] = [x + 2*bishopStep[0], y + 2*bishopStep[1]];
 189         if ((c == 'w' && newX >= 5) || (c == 'b' && newX <= 4))
 190           // A priori valid (elephant don't cross the river)
 191           steps.push(bishopStep.map(s => 2*s));
 192           // "out of board" checks delayed to next method
 193       }
 194     }
 195     return super.getSlideNJumpMoves([x, y], steps, 1);
 196   }
 197
 198   getPotentialAdvisorMoves([x, y]) {
 199     // Diagonal steps inside palace
 200     const c = this.getColor(x, y);
 201     if (
 202       y != 4 ||
 203       (c == 'w' && x != V.size.x - 2) ||
 204       (c == 'b' && x != 1)
 205     ) {
 206       // In a corner: only one step available
 207       let step = null;
 208       const direction = (c == 'w' ? -1 : 1);
 209       if ((c == 'w' && x == V.size.x - 1) || (c == 'b' && x == 0)) {
 210         // On first line
 211         if (y == 3) step = [direction, 1];
 212         else step = [direction, -1];
 213       }
 214       else {
 215         // On third line
 216         if (y == 3) step = [-direction, 1];
 217         else step = [-direction, -1];
 218       }
 219       return super.getSlideNJumpMoves([x, y], [step], 1);
 220     }
 221     // In the middle of the palace:
 222     return (
 223       super.getSlideNJumpMoves([x, y], ChessRules.steps[V.BISHOP], 1)
 224     );
 225   }
 226
 227   getPotentialKingMoves([x, y]) {
 228     // Orthogonal steps inside palace
 229     const c = this.getColor(x, y);
 230     if (
 231       y != 4 ||
 232       (c == 'w' && x != V.size.x - 2) ||
 233       (c == 'b' && x != 1)
 234     ) {
 235       // On the edge: only two steps available
 236       let steps = [];
 237       if (x < (c == 'w' ? V.size.x - 1 : 2)) steps.push([1, 0]);
 238       if (x > (c == 'w' ? V.size.x - 3 : 0)) steps.push([-1, 0]);
 239       if (y > 3) steps.push([0, -1]);
 240       if (y < 5) steps.push([0, 1]);
 241       return super.getSlideNJumpMoves([x, y], steps, 1);
 242     }
 243     // In the middle of the palace:
 244     return (
 245       super.getSlideNJumpMoves([x, y], ChessRules.steps[V.ROOK], 1)
 246     );
 247   }
 248
 249   // NOTE: duplicated from Shako (TODO?)
 250   getPotentialCannonMoves([x, y]) {
 251     const oppCol = V.GetOppCol(this.turn);
 252     let moves = [];
 253     // Look in every direction until an obstacle (to jump) is met
 254     for (const step of V.steps[V.ROOK]) {
 255       let i = x + step[0];
 256       let j = y + step[1];
 257       while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
 258         moves.push(this.getBasicMove([x, y], [i, j]));
 259         i += step[0];
 260         j += step[1];
 261       }
 262       // Then, search for an enemy
 263       i += step[0];
 264       j += step[1];
 265       while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
 266         i += step[0];
 267         j += step[1];
 268       }
 269       if (V.OnBoard(i, j) && this.getColor(i, j) == oppCol)
 270         moves.push(this.getBasicMove([x, y], [i, j]));
 271     }
 272     return moves;
 273   }
 274
 275   // (King) Never attacked by advisor, since it stays in the palace
 276   // Also, never attacked by elephants since they don't cross the river.
 277   isAttacked(sq, color) {
 278     return (
 279       this.isAttackedByPawn(sq, color) ||
 280       super.isAttackedByRook(sq, color) ||
 281       this.isAttackedByKnight(sq, color) ||
 282       this.isAttackedByCannon(sq, color)
 283     );
 284   }
 285
 286   isAttackedByPawn([x, y], color) {
 287     // The pawn necessarily crossed the river (attack on king)
 288     const shiftX = (color == 'w' ? 1 : -1); //shift from king
 289     return super.isAttackedBySlideNJump(
 290       [x, y], color, V.PAWN, [[shiftX, 0], [0, 1], [0, -1]], 1);
 291   }
 292
 293   knightStepsFromBishopStep(step) {
 294     return [ [2*step[0], step[1]], [step[0], 2*step[1]] ];
 295   }
 296
 297   isAttackedByKnight([x, y], color) {
 298     // Check bishop steps: if empty, look continuation knight step
 299     let steps = [];
 300     for (let s of ChessRules.steps[V.BISHOP]) {
 301       const [i, j] = [x + s[0], y + s[1]];
 302       if (
 303         V.OnBoard(i, j) &&
 304         this.board[i][j] == V.EMPTY
 305       ) {
 306         Array.prototype.push.apply(steps, this.knightStepsFromBishopStep(s));
 307       }
 308     }
 309     return (
 310       super.isAttackedBySlideNJump([x, y], color, V.KNIGHT, steps, 1)
 311     );
 312   }
 313
 314   // NOTE: duplicated from Shako (TODO?)
 315   isAttackedByCannon([x, y], color) {
 316     // Reversed process: is there an obstacle in line,
 317     // and a cannon next in the same line?
 318     for (const step of V.steps[V.ROOK]) {
 319       let [i, j] = [x+step[0], y+step[1]];
 320       while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
 321         i += step[0];
 322         j += step[1];
 323       }
 324       if (V.OnBoard(i, j)) {
 325         // Keep looking in this direction
 326         i += step[0];
 327         j += step[1];
 328         while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
 329           i += step[0];
 330           j += step[1];
 331         }
 332         if (
 333           V.OnBoard(i, j) &&
 334           this.getPiece(i, j) == V.CANNON &&
 335           this.getColor(i, j) == color
 336         ) {
 337           return true;
 338         }
 339       }
 340     }
 341     return false;
 342   }
 343
 344   getCurrentScore() {
 345     if (this.atLeastOneMove()) return "*";
 346     // Game over
 347     const color = this.turn;
 348     // No valid move: I lose!
 349     return (color == "w" ? "0-1" : "1-0");
 350   }
 351
 352   static get VALUES() {
 353     return {
 354       p: 1,
 355       r: 9,
 356       n: 4,
 357       e: 2.5,
 358       a: 2,
 359       c: 4.5,
 360       k: 1000
 361     };
 362   }
 363
 364   evalPosition() {
 365     let evaluation = 0;
 366     for (let i = 0; i < V.size.x; i++) {
 367       for (let j = 0; j < V.size.y; j++) {
 368         if (this.board[i][j] != V.EMPTY) {
 369           const c = this.getColor(i, j);
 370           const sign = (c == 'w' ? 1 : -1);
 371           const piece = this.getPiece(i, j);
 372           let pieceEval = V.VALUES[this.getPiece(i, j)];
 373           if (
 374             piece == V.PAWN &&
 375             (
 376               (c == 'w' && i <= 4) ||
 377               (c == 'b' && i >= 5)
 378             )
 379           ) {
 380             // Pawn crossed the river: higher value
 381             pieceEval++;
 382           }
 383           evaluation += sign * pieceEval;
 384         }
 385       }
 386     }
 387     return evaluation;
 388   }
 389
 390   static get SEARCH_DEPTH() {
 391     return 2;
 392   }
 393
 394   static GenRandInitFen() {
 395     // No randomization here (TODO?)
 396     return "rneakaenr/9/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/9/RNEAKAENR w 0";
 397   }
 398
 399   getNotation(move) {
 400     let notation = super.getNotation(move);
 401     if (move.vanish.length == 2 && move.vanish[0].p == V.PAWN)
 402       notation = "P" + notation.substr(1);
 403     return notation;
 404   }
 405
 406 };