client/src/variants/Gomoku.js

   1 import { ChessRules, Move, PiPo } from "@/base_rules";
   2 import { randInt } from "@/utils/alea";
   3
   4 export class GomokuRules extends ChessRules {
   5
   6   static get Monochrome() {
   7     return true;
   8   }
   9
  10   static get Notoodark() {
  11     return true;
  12   }
  13
  14   static get Lines() {
  15     let lines = [];
  16     // Draw all inter-squares lines, shifted:
  17     for (let i = 0; i < V.size.x; i++)
  18       lines.push([[i+0.5, 0.5], [i+0.5, V.size.y-0.5]]);
  19     for (let j = 0; j < V.size.y; j++)
  20       lines.push([[0.5, j+0.5], [V.size.x-0.5, j+0.5]]);
  21     return lines;
  22   }
  23
  24   static get HasFlags() {
  25     return false;
  26   }
  27
  28   static get HasEnpassant() {
  29     return false;
  30   }
  31
  32   static get ReverseColors() {
  33     return true;
  34   }
  35
  36   static IsGoodPosition(position) {
  37     if (position.length == 0) return false;
  38     const rows = position.split("/");
  39     if (rows.length != V.size.x) return false;
  40     for (let row of rows) {
  41       let sumElts = 0;
  42       for (let i = 0; i < row.length; i++) {
  43         if (row[i].toLowerCase() == V.PAWN) sumElts++;
  44         else {
  45           const num = parseInt(row[i], 10);
  46           if (isNaN(num) || num <= 0) return false;
  47           sumElts += num;
  48         }
  49       }
  50       if (sumElts != V.size.y) return false;
  51     }
  52     return true;
  53   }
  54
  55   static get size() {
  56     return { x: 19, y: 19 };
  57   }
  58
  59   static GenRandInitFen() {
  60     return [...Array(19)].map(e => "991").join('/') + " w 0";
  61   }
  62
  63   setOtherVariables() {}
  64
  65   getPiece() {
  66     return V.PAWN;
  67   }
  68
  69   getPpath(b) {
  70     return "Gomoku/" + b;
  71   }
  72
  73   onlyClick() {
  74     return true;
  75   }
  76
  77   canIplay(side, [x, y]) {
  78     return (side == this.turn && this.board[x][y] == V.EMPTY);
  79   }
  80
  81   hoverHighlight([x, y], side) {
  82     if (!!side && side != this.turn) return false;
  83     return (this.board[x][y] == V.EMPTY);
  84   }
  85
  86   doClick([x, y]) {
  87     return (
  88       new Move({
  89         appear: [
  90           new PiPo({ x: x, y: y, c: this.turn, p: V.PAWN })
  91         ],
  92         vanish: [],
  93         start: { x: -1, y: -1 },
  94       })
  95     );
  96   }
  97
  98   getPotentialMovesFrom([x, y]) {
  99     return [this.doClick([x, y])];
 100   }
 101
 102   getAllPotentialMoves() {
 103     let moves = [];
 104     for (let i = 0; i < 19; i++) {
 105       for (let j=0; j < 19; j++) {
 106         if (this.board[i][j] == V.EMPTY) moves.push(this.doClick([i, j]));
 107       }
 108     }
 109     return moves;
 110   }
 111
 112   filterValid(moves) {
 113     return moves;
 114   }
 115
 116   getCheckSquares() {
 117     return [];
 118   }
 119
 120   postPlay() {}
 121   postUndo() {}
 122
 123   countAlignedStones([x, y], color) {
 124     let maxInLine = 0;
 125     for (let s of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) {
 126       // Skip half of steps, since we explore both directions
 127       if (s[0] == -1 || (s[0] == 0 && s[1] == -1)) continue;
 128       let countInLine = 1;
 129       for (let dir of [-1, 1]) {
 130         let [i, j] = [x + dir * s[0], y + dir * s[1]];
 131         while (
 132           V.OnBoard(i, j) &&
 133           this.board[i][j] != V.EMPTY &&
 134           this.getColor(i, j) == color
 135         ) {
 136           countInLine++;
 137           i += dir * s[0];
 138           j += dir * s[1];
 139         }
 140       }
 141       if (countInLine > maxInLine) maxInLine = countInLine;
 142     }
 143     return maxInLine;
 144   }
 145
 146   getCurrentScore() {
 147     let fiveAlign = { w: false, b: false, wNextTurn: false };
 148     for (let i=0; i<19; i++) {
 149       for (let j=0; j<19; j++) {
 150         if (this.board[i][j] == V.EMPTY) {
 151           if (
 152             !fiveAlign.wNextTurn &&
 153             this.countAlignedStones([i, j], 'b') >= 5
 154           ) {
 155             fiveAlign.wNextTurn = true;
 156           }
 157         }
 158         else {
 159           const c = this.getColor(i, j);
 160           if (!fiveAlign[c] && this.countAlignedStones([i, j], c) >= 5)
 161             fiveAlign[c] = true;
 162         }
 163       }
 164     }
 165     if (fiveAlign['w']) {
 166       if (fiveAlign['b']) return "1/2";
 167       if (this.turn == 'b' && fiveAlign.wNextTurn) return "*";
 168       return "1-0";
 169     }
 170     if (fiveAlign['b']) return "0-1";
 171     return "*";
 172   }
 173
 174   getComputerMove() {
 175     const color = this.turn;
 176     let candidates = [];
 177     let curMax = 0;
 178     for (let i=0; i<19; i++) {
 179       for (let j=0; j<19; j++) {
 180         if (this.board[i][j] == V.EMPTY) {
 181           const nbAligned = this.countAlignedStones([i, j], color);
 182           if (nbAligned >= curMax) {
 183             const move = new Move({
 184               appear: [
 185                 new PiPo({ x: i, y: j, c: color, p: V.PAWN })
 186               ],
 187               vanish: [],
 188               start: { x: -1, y: -1 }
 189             });
 190             if (nbAligned > curMax) {
 191               curMax = nbAligned;
 192               candidates = [move];
 193             }
 194             else candidates.push(move);
 195           }
 196         }
 197       }
 198     }
 199     // Among a priori equivalent moves, select the most central ones.
 200     // Of course this is not good, but can help this ultra-basic bot.
 201     let bestCentrality = 0;
 202     candidates.forEach(c => {
 203       const deltaX = Math.min(c.end.x, 18 - c.end.x);
 204       const deltaY = Math.min(c.end.y, 18 - c.end.y);
 205       c.centrality = deltaX * deltaX + deltaY * deltaY;
 206       if (c.centrality > bestCentrality) bestCentrality = c.centrality;
 207     });
 208     const threshold = Math.min(32, bestCentrality);
 209     const finalCandidates = candidates.filter(c => c.centrality >= threshold);
 210     return finalCandidates[randInt(finalCandidates.length)];
 211   }
 212
 213   getNotation(move) {
 214     return V.CoordsToSquare(move.end);
 215   }
 216
 217 };