client/src/variants/Football.js

   1 import { ChessRules } from "@/base_rules";
   2 import { randInt, shuffle } from "@/utils/alea";
   3 import { ArrayFun } from "@/utils/array";
   4
   5 export class FootballRules extends ChessRules {
   6
   7   static get HasEnpassant() {
   8     return false;
   9   }
  10
  11   static get HasFlags() {
  12     return false;
  13   }
  14
  15   static get size() {
  16     return { x: 9, y: 9 };
  17   }
  18
  19   static get Lines() {
  20     return [
  21       // White goal:
  22       [[0, 4], [0, 5]],
  23       [[0, 5], [1, 5]],
  24       [[1, 4], [0, 4]],
  25       // Black goal:
  26       [[9, 4], [9, 5]],
  27       [[9, 5], [8, 5]],
  28       [[8, 4], [9, 4]]
  29     ];
  30   }
  31
  32   static get BALL() {
  33     // 'b' is already taken:
  34     return "aa";
  35   }
  36
  37   // Check that exactly one ball is on the board
  38   // + at least one piece per color.
  39   static IsGoodPosition(position) {
  40     if (position.length == 0) return false;
  41     const rows = position.split("/");
  42     if (rows.length != V.size.x) return false;
  43     let pieces = { "w": 0, "b": 0 };
  44     let ballCount = 0;
  45     for (let row of rows) {
  46       let sumElts = 0;
  47       for (let i = 0; i < row.length; i++) {
  48         const lowerRi = row[i].toLowerCase();
  49         if (!!lowerRi.match(/^[a-z]$/)) {
  50           if (V.PIECES.includes(lowerRi))
  51             pieces[row[i] == lowerRi ? "b" : "w"]++;
  52           else if (lowerRi == 'a') ballCount++;
  53           else return false;
  54           sumElts++;
  55         }
  56         else {
  57           const num = parseInt(row[i], 10);
  58           if (isNaN(num)) return false;
  59           sumElts += num;
  60         }
  61       }
  62       if (sumElts != V.size.y) return false;
  63     }
  64     if (ballCount != 1 || Object.values(pieces).some(v => v == 0))
  65       return false;
  66     return true;
  67   }
  68
  69   static board2fen(b) {
  70     if (b == V.BALL) return 'a';
  71     return ChessRules.board2fen(b);
  72   }
  73
  74   static fen2board(f) {
  75     if (f == 'a') return V.BALL;
  76     return ChessRules.fen2board(f);
  77   }
  78
  79   getPpath(b) {
  80     if (b == V.BALL) return "Football/ball";
  81     return b;
  82   }
  83
  84   canIplay(side, [x, y]) {
  85     return (
  86       side == this.turn &&
  87       (this.board[x][y] == V.BALL || this.getColor(x, y) == side)
  88     );
  89   }
  90
  91   // No checks or king tracking etc. But, track ball
  92   setOtherVariables() {
  93     // Stack of "kicked by" coordinates, to avoid infinite loops
  94     this.kickedBy = [ {} ];
  95     this.subTurn = 1;
  96     this.ballPos = [-1, -1];
  97     for (let i=0; i < V.size.x; i++) {
  98       for (let j=0; j< V.size.y; j++) {
  99         if (this.board[i][j] == V.BALL) {
 100           this.ballPos = [i, j];
 101           return;
 102         }
 103       }
 104     }
 105   }
 106
 107   static GenRandInitFen(randomness) {
 108     if (randomness == 0)
 109       return "rnbq1knbr/9/9/9/4a4/9/9/9/RNBQ1KNBR w 0";
 110
 111     let pieces = { w: new Array(8), b: new Array(8) };
 112     for (let c of ["w", "b"]) {
 113       if (c == 'b' && randomness == 1) {
 114         pieces['b'] = pieces['w'];
 115         break;
 116       }
 117
 118       // Get random squares for every piece, totally freely
 119       let positions = shuffle(ArrayFun.range(8));
 120       const composition = ['b', 'b', 'r', 'r', 'n', 'n', 'k', 'q'];
 121       // Fix bishops (on different colors)
 122       const realOddity =
 123         (pos) => { return (pos <= 3 ? pos % 2 : (pos + 1) % 2); };
 124       const rem2 = realOddity(positions[0]);
 125       if (rem2 == realOddity(positions[1])) {
 126         for (let i=2; i<8; i++) {
 127           if (realOddity(positions[i]) != rem2) {
 128             [positions[1], positions[i]] = [positions[i], positions[1]];
 129             break;
 130           }
 131         }
 132       }
 133       for (let i = 0; i < 8; i++) pieces[c][positions[i]] = composition[i];
 134     }
 135     const piecesB = pieces["b"].join("") ;
 136     const piecesW = pieces["w"].join("").toUpperCase();
 137     return (
 138       piecesB.substr(0, 4) + "1" + piecesB.substr(4) +
 139       "/9/9/9/4a4/9/9/9/" +
 140       piecesW.substr(0, 4) + "1" + piecesW.substr(4) +
 141       " w 0"
 142     );
 143   }
 144
 145   tryKickFrom([x, y]) {
 146     const bp = this.ballPos;
 147     const emptySquare = (i, j) => {
 148       return V.OnBoard(i, j) && this.board[i][j] == V.EMPTY;
 149     };
 150     // Kick the (adjacent) ball from x, y with current turn:
 151     const step = [bp[0] - x, bp[1] - y];
 152     const piece = this.getPiece(x, y);
 153     let moves = [];
 154     if (piece == V.KNIGHT) {
 155       // The knight case is particular
 156       V.steps[V.KNIGHT].forEach(s => {
 157         const [i, j] = [bp[0] + s[0], bp[1] + s[1]];
 158         if (
 159           V.OnBoard(i, j) &&
 160           this.board[i][j] == V.EMPTY &&
 161           (
 162             // In a corner? The, allow all ball moves
 163             ([0, 8].includes(bp[0]) && [0, 8].includes(bp[1])) ||
 164             // Do not end near the knight
 165             (Math.abs(i - x) >= 2 || Math.abs(j - y) >= 2)
 166           )
 167         ) {
 168           moves.push(super.getBasicMove(bp, [i, j]));
 169         }
 170       });
 171     }
 172     else {
 173       let compatible = false,
 174           oneStep = false;
 175       switch (piece) {
 176         case V.ROOK:
 177           compatible = (step[0] == 0 || step[1] == 0);
 178           break;
 179         case V.BISHOP:
 180           compatible = (step[0] != 0 && step[1] != 0);
 181           break;
 182         case V.QUEEN:
 183           compatible = true;
 184           break;
 185         case V.KING:
 186           compatible = true;
 187           oneStep = true;
 188           break;
 189       }
 190       if (!compatible) return [];
 191       let [i, j] = [bp[0] + step[0], bp[1] + step[1]];
 192       const horizontalStepOnGoalRow =
 193         ([0, 8].includes(bp[0]) && step.some(s => s == 0));
 194       if (
 195         emptySquare(i, j) &&
 196         (this.movesCount >= 2 || j != 4 || ![0, 8].includes(i)) &&
 197         (!horizontalStepOnGoalRow || j != 4)
 198       ) {
 199         moves.push(super.getBasicMove(bp, [i, j]));
 200         if (!oneStep) {
 201           do {
 202             i += step[0];
 203             j += step[1];
 204             if (!emptySquare(i, j)) break;
 205             if (
 206               (this.movesCount >= 2 || j != 4 || ![0, 8].includes(i)) &&
 207               (!horizontalStepOnGoalRow || j != 4)
 208             ) {
 209               moves.push(super.getBasicMove(bp, [i, j]));
 210             }
 211           } while (true);
 212         }
 213       }
 214       // Try the other direction (TODO: experimental)
 215       [i, j] = [bp[0] - 2*step[0], bp[1] - 2*step[1]];
 216       if (
 217         emptySquare(i, j) &&
 218         (this.movesCount >= 2 || j != 4 || ![0, 8].includes(i)) &&
 219         (!horizontalStepOnGoalRow || j != 4)
 220       ) {
 221         moves.push(super.getBasicMove(bp, [i, j]));
 222         if (!oneStep) {
 223           do {
 224             i -= step[0];
 225             j -= step[1];
 226             if (!emptySquare(i, j)) break;
 227             if (
 228               (this.movesCount >= 2 || j != 4 || ![0, 8].includes(i)) &&
 229               (!horizontalStepOnGoalRow || j != 4)
 230             ) {
 231               moves.push(super.getBasicMove(bp, [i, j]));
 232             }
 233           } while (true);
 234         }
 235       }
 236     }
 237     const kickedFrom = x + "-" + y;
 238     moves.forEach(m => m.start.by = kickedFrom)
 239     return moves;
 240   }
 241
 242   getPotentialMovesFrom([x, y], computer) {
 243     const piece = this.getPiece(x, y);
 244     if (V.PIECES.includes(piece)) {
 245       if (this.subTurn > 1) return [];
 246       const moves = super.getPotentialMovesFrom([x, y])
 247                     .filter(m => m.end.y != 4 || ![0, 8].includes(m.end.x));
 248       // If bishop stuck in a corner: allow to jump over the next obstacle
 249       if (moves.length == 0 && piece == V.BISHOP) {
 250         if (
 251           x == 0 && y == 0 &&
 252           this.board[1][1] != V.EMPTY &&
 253           this.board[2][2] == V.EMPTY
 254         ) {
 255           return [super.getBasicMove([x, y], [2, 2])];
 256         }
 257         if (
 258           x == 0 && y == 8 &&
 259           this.board[1][7] != V.EMPTY &&
 260           this.board[2][6] == V.EMPTY
 261         ) {
 262           return [super.getBasicMove([x, y], [2, 6])];
 263         }
 264         if (
 265           x == 8 && y == 0 &&
 266           this.board[7][1] != V.EMPTY &&
 267           this.board[6][2] == V.EMPTY
 268         ) {
 269           return [super.getBasicMove([x, y], [6, 2])];
 270         }
 271         if (
 272           x == 8 && y == 8 &&
 273           this.board[7][7] != V.EMPTY &&
 274           this.board[6][6] == V.EMPTY
 275         ) {
 276           return [super.getBasicMove([x, y], [6, 6])];
 277         }
 278       }
 279       return moves;
 280     }
 281     // Kicking the ball: look for adjacent pieces.
 282     const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
 283     const c = this.turn;
 284     let moves = [];
 285     let atLeastOnePotentialKick = false;
 286     for (let s of steps) {
 287       const [i, j] = [x + s[0], y + s[1]];
 288       if (
 289         V.OnBoard(i, j) &&
 290         this.board[i][j] != V.EMPTY &&
 291         this.getColor(i, j) == c
 292       ) {
 293         if (!atLeastOnePotentialKick) atLeastOnePotentialKick = true;
 294         Array.prototype.push.apply(moves, this.tryKickFrom([i, j]));
 295       }
 296     }
 297     if (atLeastOnePotentialKick) {
 298       // And, always add the "end" move. For computer, keep only one
 299       outerLoop: for (let i=0; i < V.size.x; i++) {
 300         for (let j=0; j < V.size.y; j++) {
 301           if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == c) {
 302             moves.push(super.getBasicMove([x, y], [i, j]));
 303             if (!!computer) break outerLoop;
 304           }
 305         }
 306       }
 307     }
 308     return moves;
 309   }
 310
 311   // No captures:
 312   getSlideNJumpMoves([x, y], steps, oneStep) {
 313     let moves = [];
 314     outerLoop: for (let step of steps) {
 315       let i = x + step[0];
 316       let j = y + step[1];
 317       let stepCount = 1;
 318       while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
 319         moves.push(this.getBasicMove([x, y], [i, j]));
 320         if (!!oneStep) continue outerLoop;
 321         i += step[0];
 322         j += step[1];
 323         stepCount++;
 324       }
 325     }
 326     return moves;
 327   }
 328
 329   // Extra arg "computer" to avoid trimming all redundant pass moves:
 330   getAllPotentialMoves(computer) {
 331     const color = this.turn;
 332     let potentialMoves = [];
 333     for (let i = 0; i < V.size.x; i++) {
 334       for (let j = 0; j < V.size.y; j++) {
 335         if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) {
 336           Array.prototype.push.apply(
 337             potentialMoves,
 338             this.getPotentialMovesFrom([i, j], computer)
 339           );
 340         }
 341       }
 342     }
 343     return potentialMoves;
 344   }
 345
 346   getAllValidMoves() {
 347     return this.filterValid(this.getAllPotentialMoves("computer"));
 348   }
 349
 350   filterValid(moves) {
 351     const L = this.kickedBy.length;
 352     const kb = this.kickedBy[L-1];
 353     return moves.filter(m => !m.start.by || !kb[m.start.by]);
 354   }
 355
 356   getCheckSquares() {
 357     return [];
 358   }
 359
 360   allowAnotherPass(color) {
 361     // Two cases: a piece moved, or the ball moved.
 362     // In both cases, check our pieces and ball proximity,
 363     // so the move played doesn't matter (if ball position updated)
 364     const bp = this.ballPos;
 365     const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
 366     for (let s of steps) {
 367       const [i, j] = [this.ballPos[0] + s[0], this.ballPos[1] + s[1]];
 368       if (
 369         V.OnBoard(i, j) &&
 370         this.board[i][j] != V.EMPTY &&
 371         this.getColor(i, j) == color
 372       ) {
 373         return true; //potentially...
 374       }
 375     }
 376     return false;
 377   }
 378
 379   prePlay(move) {
 380     if (move.appear[0].p == 'a')
 381       this.ballPos = [move.appear[0].x, move.appear[0].y];
 382   }
 383
 384   play(move) {
 385     // Special message saying "passes are over"
 386     const passesOver = (move.vanish.length == 2);
 387     if (!passesOver) {
 388       this.prePlay(move);
 389       V.PlayOnBoard(this.board, move);
 390     }
 391     move.turn = [this.turn, this.subTurn]; //easier undo
 392     if (passesOver || !this.allowAnotherPass(this.turn)) {
 393       this.turn = V.GetOppCol(this.turn);
 394       this.subTurn = 1;
 395       this.movesCount++;
 396       this.kickedBy.push( {} );
 397     }
 398     else {
 399       this.subTurn++;
 400       if (!!move.start.by) {
 401         const L = this.kickedBy.length;
 402         this.kickedBy[L-1][move.start.by] = true;
 403       }
 404     }
 405   }
 406
 407   undo(move) {
 408     const passesOver = (move.vanish.length == 2);
 409     if (move.turn[0] != this.turn) {
 410       [this.turn, this.subTurn] = move.turn;
 411       this.movesCount--;
 412       this.kickedBy.pop();
 413     }
 414     else {
 415       this.subTurn--;
 416       if (!!move.start.by) {
 417         const L = this.kickedBy.length;
 418         delete this.kickedBy[L-1][move.start.by];
 419       }
 420     }
 421     if (!passesOver) {
 422       V.UndoOnBoard(this.board, move);
 423       this.postUndo(move);
 424     }
 425   }
 426
 427   postUndo(move) {
 428     if (move.vanish[0].p == 'a')
 429       this.ballPos = [move.vanish[0].x, move.vanish[0].y];
 430   }
 431
 432   getCurrentScore() {
 433     if (this.board[0][4] == V.BALL) return "1-0";
 434     if (this.board[8][4] == V.BALL) return "0-1";
 435     return "*";
 436   }
 437
 438   getComputerMove() {
 439     let initMoves = this.getAllValidMoves();
 440     if (initMoves.length == 0) return null;
 441     let moves = JSON.parse(JSON.stringify(initMoves));
 442     let mvArray = [];
 443     let mv = null;
 444     // Just play random moves (for now at least. TODO?)
 445     const c = this.turn;
 446     while (moves.length > 0) {
 447       mv = moves[randInt(moves.length)];
 448       mvArray.push(mv);
 449       this.play(mv);
 450       if (mv.vanish.length == 1 && this.allowAnotherPass(c))
 451         // Potential kick
 452         moves = this.getPotentialMovesFrom(this.ballPos);
 453       else break;
 454     }
 455     for (let i = mvArray.length - 1; i >= 0; i--) this.undo(mvArray[i]);
 456     return (mvArray.length > 1 ? mvArray : mvArray[0]);
 457   }
 458
 459   // NOTE: evalPosition() is wrong, but unused since bot plays at random
 460
 461   getNotation(move) {
 462     if (move.vanish.length == 2) return "pass";
 463     if (move.vanish[0].p != 'a') return super.getNotation(move);
 464     // Kick: simple notation (TODO?)
 465     return V.CoordsToSquare(move.end);
 466   }
 467
 468 };