client/src/variants/Sittuyin.js

   1 import { ChessRules, Move, PiPo } from "@/base_rules";
   2
   3 export class SittuyinRules extends ChessRules {
   4   static get HasFlags() {
   5     return false;
   6   }
   7
   8   static get HasEnpassant() {
   9     return false;
  10   }
  11
  12   static get PawnSpecs() {
  13     return Object.assign(
  14       {},
  15       ChessRules.PawnSpecs,
  16       {
  17         twoSquares: false,
  18         // Promotions are handled differently here
  19         promotions: [V.QUEEN]
  20       }
  21     );
  22   }
  23
  24   static GenRandInitFen() {
  25     return "8/8/4pppp/pppp4/4PPPP/PPPP4/8/8 w 0";
  26   }
  27
  28   re_setReserve(subTurn) {
  29     const mc = this.movesCount;
  30     const wc = (mc == 0 ? 1 : 0);
  31     const bc = (mc <= 1 ? 1 : 0);
  32     this.reserve = {
  33       w: {
  34         [V.ROOK]: wc * 2,
  35         [V.KNIGHT]: wc * 2,
  36         [V.BISHOP]: wc * 2,
  37         [V.QUEEN]: wc,
  38         [V.KING]: wc
  39       },
  40       b: {
  41         [V.ROOK]: bc * 2,
  42         [V.KNIGHT]: bc * 2,
  43         [V.BISHOP]: bc * 2,
  44         [V.QUEEN]: bc,
  45         [V.KING]: bc
  46       }
  47     }
  48     this.subTurn = subTurn || 1;
  49   }
  50
  51   setOtherVariables(fen) {
  52     super.setOtherVariables(fen);
  53     if (this.movesCount <= 1) this.re_setReserve();
  54   }
  55
  56   getPpath(b) {
  57     return "Sittuyin/" + b;
  58   }
  59
  60   getColor(i, j) {
  61     if (i >= V.size.x) return i == V.size.x ? "w" : "b";
  62     return this.board[i][j].charAt(0);
  63   }
  64
  65   getPiece(i, j) {
  66     if (i >= V.size.x) return V.RESERVE_PIECES[j];
  67     return this.board[i][j].charAt(1);
  68   }
  69
  70   getReservePpath(index, color) {
  71     return "Sittuyin/" + color + V.RESERVE_PIECES[index];
  72   }
  73
  74   static get RESERVE_PIECES() {
  75     return [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN, V.KING];
  76   }
  77
  78   getPotentialMovesFrom([x, y]) {
  79     if (this.movesCount <= 1) {
  80       const color = this.turn;
  81       const p = V.RESERVE_PIECES[y];
  82       if (this.reserve[color][p] == 0) return [];
  83       const iBound =
  84         p != V.ROOK
  85           ? (color == 'w' ? [4, 7] : [0, 3])
  86           : (color == 'w' ? [7, 7] : [0, 0]);
  87       const jBound = (i) => {
  88         if (color == 'w' && i == 4) return [4, 7];
  89         if (color == 'b' && i == 3) return [0, 3];
  90         return [0, 7];
  91       };
  92       let moves = [];
  93       for (let i = iBound[0]; i <= iBound[1]; i++) {
  94         const jb = jBound(i);
  95         for (let j = jb[0]; j <= jb[1]; j++) {
  96           if (this.board[i][j] == V.EMPTY) {
  97             let mv = new Move({
  98               appear: [
  99                 new PiPo({
 100                   x: i,
 101                   y: j,
 102                   c: color,
 103                   p: p
 104                 })
 105               ],
 106               vanish: [],
 107               start: { x: x, y: y },
 108               end: { x: i, y: j }
 109             });
 110             moves.push(mv);
 111           }
 112         }
 113       }
 114       return moves;
 115     }
 116     return super.getPotentialMovesFrom([x, y]);
 117   }
 118
 119   getPotentialPawnMoves([x, y]) {
 120     const color = this.turn;
 121     const [sizeX, sizeY] = [V.size.x, V.size.y];
 122     const shiftX = V.PawnSpecs.directions[color];
 123     let moves = [];
 124     // NOTE: next condition is generally true (no pawn on last rank)
 125     if (x + shiftX >= 0 && x + shiftX < sizeX) {
 126       if (this.board[x + shiftX][y] == V.EMPTY) {
 127         // One square forward
 128         moves.push(this.getBasicMove([x, y], [x + shiftX, y]));
 129       }
 130       // Captures
 131       if (V.PawnSpecs.canCapture) {
 132         for (let shiftY of [-1, 1]) {
 133           if (
 134             y + shiftY >= 0 &&
 135             y + shiftY < sizeY
 136           ) {
 137             if (
 138               this.board[x + shiftX][y + shiftY] != V.EMPTY &&
 139               this.canTake([x, y], [x + shiftX, y + shiftY])
 140             ) {
 141               moves.push(this.getBasicMove([x, y], [x + shiftX, y + shiftY]));
 142             }
 143           }
 144         }
 145       }
 146     }
 147     let queenOnBoard = false;
 148     let pawnsCount = 0;
 149     outerLoop: for (let i=0; i<8; i++) {
 150       for (let j=0; j<8; j++) {
 151         if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) {
 152           const p = this.getPiece(i, j);
 153           if (p == V.QUEEN) {
 154             queenOnBoard = true;
 155             break outerLoop;
 156           }
 157           else if (p == V.PAWN && pawnsCount <= 1) pawnsCount++;
 158         }
 159       }
 160     }
 161     if (
 162       !queenOnBoard &&
 163       (
 164         pawnsCount == 1 ||
 165         (color == 'w' && ((y <= 3 && x == y) || (y >= 4 && x == 7 - y))) ||
 166         (color == 'b' && ((y >= 4 && x == y) || (y <= 3 && x == 7 - y)))
 167       )
 168     ) {
 169       // Add potential promotions
 170       const addPromotion = ([xx, yy], moveTo) => {
 171         moves.push(
 172           new Move({
 173             appear: [
 174               new PiPo({
 175                 x: !!moveTo ? xx : x,
 176                 y: yy, //yy == y if !!moveTo
 177                 c: color,
 178                 p: V.QUEEN
 179               })
 180             ],
 181             vanish: [
 182               new PiPo({
 183                 x: x,
 184                 y: y,
 185                 c: color,
 186                 p: V.PAWN
 187               })
 188             ],
 189             start: { x: x, y: y },
 190             end: { x: xx, y: yy }
 191           })
 192         );
 193       };
 194       // In-place promotion always possible:
 195       addPromotion([x - shiftX, y]);
 196       for (let step of V.steps[V.BISHOP]) {
 197         const [i, j] = [x + step[0], y + step[1]];
 198         if (V.OnBoard(i, j) && this.board[i][j] != V.EMPTY)
 199           addPromotion([i, j], "moveTo");
 200       }
 201     }
 202     return moves;
 203   }
 204
 205   getPotentialBishopMoves(sq) {
 206     const forward = (this.turn == 'w' ? -1 : 1);
 207     return this.getSlideNJumpMoves(
 208       sq,
 209       V.steps[V.BISHOP].concat([ [forward, 0] ]),
 210       "oneStep"
 211     );
 212   }
 213
 214   getPotentialQueenMoves(sq) {
 215     return this.getSlideNJumpMoves(
 216       sq,
 217       V.steps[V.BISHOP],
 218       "oneStep"
 219     );
 220   }
 221
 222   isAttackedByBishop(sq, color) {
 223     const forward = (this.turn == 'w' ? 1 : -1);
 224     return this.isAttackedBySlideNJump(
 225       sq,
 226       color,
 227       V.BISHOP,
 228       V.steps[V.BISHOP].concat([ [forward, 0] ]),
 229       "oneStep"
 230     );
 231   }
 232
 233   isAttackedByQueen(sq, color) {
 234     return this.isAttackedBySlideNJump(
 235       sq,
 236       color,
 237       V.QUEEN,
 238       V.steps[V.BISHOP],
 239       "oneStep"
 240     );
 241   }
 242
 243   underCheck(color) {
 244     if (this.movesCount <= 1) return false;
 245     return super.underCheck(color);
 246   }
 247
 248   play(move) {
 249     const color = move.appear[0].c;
 250     if (this.movesCount <= 1) {
 251       V.PlayOnBoard(this.board, move);
 252       const piece = move.appear[0].p;
 253       this.reserve[color][piece]--;
 254       if (piece == V.KING) this.kingPos[color] = [move.end.x, move.end.y];
 255       if (this.subTurn == 8) {
 256         // All placement moves are done
 257         this.movesCount++;
 258         this.turn = V.GetOppCol(color);
 259         if (this.movesCount == 1) this.subTurn = 1;
 260         else {
 261           // Initial placement is over
 262           delete this["reserve"];
 263           delete this["subTurn"];
 264         }
 265       }
 266       else this.subTurn++;
 267     }
 268     else super.play(move);
 269   }
 270
 271   undo(move) {
 272     const color = move.appear[0].c;
 273     if (this.movesCount <= 2) {
 274       V.UndoOnBoard(this.board, move);
 275       const piece = move.appear[0].p;
 276       if (piece == V.KING) this.kingPos[color] = [-1, -1];
 277       if (!this.subTurn || this.subTurn == 1) {
 278         // All placement moves are undone (if any)
 279         if (!this.subTurn) this.re_setReserve(8);
 280         else this.subTurn = 8;
 281         this.movesCount--;
 282         this.turn = color;
 283       }
 284       else this.subTurn--;
 285       this.reserve[color][piece]++;
 286     }
 287     else super.undo(move);
 288   }
 289
 290   getCheckSquares() {
 291     if (this.movesCount <= 1) return [];
 292     return super.getCheckSquares();
 293   }
 294
 295   getCurrentScore() {
 296     if (this.movesCount <= 1) return "*";
 297     return super.getCurrentScore();
 298   }
 299
 300   static get VALUES() {
 301     return {
 302       p: 1,
 303       r: 5,
 304       n: 3,
 305       b: 3,
 306       q: 2,
 307       k: 1000
 308     };
 309   }
 310
 311   getNotation(move) {
 312     // Do not note placement moves (complete move would be too long)
 313     if (move.vanish.length == 0) return "";
 314     return super.getNotation(move);
 315   }
 316 };
 317