client/src/variants/Dark.js

   1 import { ChessRules } from "@/base_rules";
   2 import { ArrayFun} from "@/utils/array";
   3 import { randInt } from "@/utils/alea";
   4
   5 export const VariantRules = class DarkRules extends ChessRules
   6 {
   7     // Standard rules, in the shadow
   8     setOtherVariables(fen)
   9     {
  10         super.setOtherVariables(fen);
  11         const [sizeX,sizeY] = [V.size.x,V.size.y];
  12         this.enlightened = {
  13             "w": ArrayFun.init(sizeX,sizeY),
  14             "b": ArrayFun.init(sizeX,sizeY)
  15         };
  16         // Setup enlightened: squares reachable by each side
  17         // (TODO: one side would be enough ?)
  18         this.updateEnlightened();
  19     }
  20
  21     updateEnlightened()
  22     {
  23         for (let i=0; i<V.size.x; i++)
  24         {
  25             for (let j=0; j<V.size.y; j++)
  26             {
  27                 this.enlightened["w"][i][j] = false;
  28                 this.enlightened["b"][i][j] = false;
  29             }
  30         }
  31         const pawnShift = {"w":-1, "b":1};
  32         // Initialize with pieces positions (which are seen)
  33         for (let i=0; i<V.size.x; i++)
  34         {
  35             for (let j=0; j<V.size.y; j++)
  36             {
  37                 if (this.board[i][j] != V.EMPTY)
  38                 {
  39                     const color = this.getColor(i,j);
  40                     this.enlightened[color][i][j] = true;
  41                     // Add potential squares visible by "impossible pawn capture"
  42                     if (this.getPiece(i,j) == V.PAWN)
  43                     {
  44                         for (let shiftY of [-1,1])
  45                         {
  46                             if (V.OnBoard(i+pawnShift[color],j+shiftY)
  47                                 && this.board[i+pawnShift[color]][j+shiftY] == V.EMPTY)
  48                             {
  49                                 this.enlightened[color][i+pawnShift[color]][j+shiftY] = true;
  50                             }
  51                         }
  52                     }
  53                 }
  54             }
  55         }
  56         const currentTurn = this.turn;
  57         this.turn = "w";
  58         const movesWhite = this.getAllValidMoves();
  59         this.turn = "b";
  60         const movesBlack = this.getAllValidMoves();
  61         this.turn = currentTurn;
  62         for (let move of movesWhite)
  63             this.enlightened["w"][move.end.x][move.end.y] = true;
  64         for (let move of movesBlack)
  65             this.enlightened["b"][move.end.x][move.end.y] = true;
  66     }
  67
  68     // Has to be redefined to avoid an infinite loop
  69     getAllValidMoves()
  70     {
  71         const color = this.turn;
  72         const oppCol = V.GetOppCol(color);
  73         let potentialMoves = [];
  74         for (let i=0; i<V.size.x; i++)
  75         {
  76             for (let j=0; j<V.size.y; j++)
  77             {
  78                 if (this.board[i][j] != V.EMPTY && this.getColor(i,j) == color)
  79                     Array.prototype.push.apply(potentialMoves, this.getPotentialMovesFrom([i,j]));
  80             }
  81         }
  82         return potentialMoves; //because there are no checks
  83     }
  84
  85     atLeastOneMove()
  86     {
  87         if (this.kingPos[this.turn][0] < 0)
  88             return false;
  89         return true; //TODO: is it right?
  90     }
  91
  92     underCheck(color)
  93     {
  94         return false; //there is no check
  95     }
  96
  97     getCheckSquares(color)
  98     {
  99         return [];
 100     }
 101
 102     updateVariables(move)
 103     {
 104         super.updateVariables(move);
 105         if (move.vanish.length >= 2 && move.vanish[1].p == V.KING)
 106         {
 107             // We took opponent king ! (because if castle vanish[1] is a rook)
 108             this.kingPos[this.turn] = [-1,-1];
 109         }
 110
 111         // Update lights for both colors:
 112         this.updateEnlightened();
 113     }
 114
 115     unupdateVariables(move)
 116     {
 117         super.unupdateVariables(move);
 118         const c = move.vanish[0].c;
 119         const oppCol = V.GetOppCol(c);
 120         if (this.kingPos[oppCol][0] < 0)
 121         {
 122             // Last move took opponent's king
 123             for (let psq of move.vanish)
 124             {
 125                 if (psq.p == 'k')
 126                 {
 127                     this.kingPos[oppCol] = [psq.x, psq.y];
 128                     break;
 129                 }
 130             }
 131         }
 132
 133         // Update lights for both colors:
 134         this.updateEnlightened();
 135     }
 136
 137   getCurrentScore()
 138   {
 139         const color = this.turn;
 140         const kp = this.kingPos[color];
 141         if (kp[0] < 0) //king disappeared
 142             return (color == "w" ? "0-1" : "1-0");
 143     if (this.atLeastOneMove()) // game not over
 144       return "*";
 145     return "1/2"; //no moves but kings still there (seems impossible)
 146     }
 147
 148     static get THRESHOLD_MATE()
 149     {
 150         return 500; //checkmates evals may be slightly below 1000
 151     }
 152
 153     // In this special situation, we just look 1 half move ahead
 154     getComputerMove()
 155     {
 156         const maxeval = V.INFINITY;
 157         const color = this.turn;
 158         const oppCol = V.GetOppCol(color);
 159         const pawnShift = (color == "w" ? -1 : 1);
 160
 161         // Do not cheat: the current enlightment is all we can see
 162         const myLight = JSON.parse(JSON.stringify(this.enlightened[color]));
 163
 164         // Can a slider on (i,j) apparently take my king?
 165         // NOTE: inaccurate because assume yes if some squares are shadowed
 166         const sliderTake = ([i,j], piece) => {
 167           const kp = this.kingPos[color];
 168             let step = undefined;
 169             if (piece == V.BISHOP)
 170             {
 171                 if (Math.abs(kp[0] - i) == Math.abs(kp[1] - j))
 172                 {
 173                     step =
 174                     [
 175                         (i-kp[0]) / Math.abs(i-kp[0]),
 176                         (j-kp[1]) / Math.abs(j-kp[1])
 177                     ];
 178                 }
 179             }
 180             else if (piece == V.ROOK)
 181             {
 182                 if (kp[0] == i)
 183                     step = [0, (j-kp[1]) / Math.abs(j-kp[1])];
 184                 else if (kp[1] == j)
 185                     step = [(i-kp[0]) / Math.abs(i-kp[0]), 0];
 186             }
 187             if (!step)
 188                 return false;
 189             // Check for obstacles
 190             let obstacle = false;
 191             for (
 192         let x=kp[0]+step[0], y=kp[1]+step[1];
 193               x != i && y != j;
 194                 x += step[0], y += step[1])
 195       {
 196                 if (myLight[x][y] && this.board[x][y] != V.EMPTY)
 197                 {
 198                     obstacle = true;
 199                     break;
 200                 }
 201             }
 202             if (!obstacle)
 203                 return true;
 204             return false;
 205         };
 206
 207         // Do I see something which can take my king ?
 208         const kingThreats = () => {
 209           const kp = this.kingPos[color];
 210             for (let i=0; i<V.size.x; i++)
 211             {
 212                 for (let j=0; j<V.size.y; j++)
 213                 {
 214                     if (myLight[i][j] && this.board[i][j] != V.EMPTY
 215                         && this.getColor(i,j) != color)
 216                     {
 217                         switch (this.getPiece(i,j))
 218                         {
 219                             case V.PAWN:
 220                                 if (kp[0] + pawnShift == i && Math.abs(kp[1]-j) == 1)
 221                                     return true;
 222                                 break;
 223                             case V.KNIGHT:
 224                                 if ((Math.abs(kp[0] - i) == 2 && Math.abs(kp[1] - j) == 1) ||
 225                                     (Math.abs(kp[0] - i) == 1 && Math.abs(kp[1] - j) == 2))
 226                                 {
 227                                     return true;
 228                                 }
 229                                 break;
 230                             case V.KING:
 231                                 if (Math.abs(kp[0] - i) == 1 && Math.abs(kp[1] - j) == 1)
 232                                     return true;
 233                                 break;
 234                             case V.BISHOP:
 235                                 if (sliderTake([i,j], V.BISHOP))
 236                                     return true;
 237                                 break;
 238                             case V.ROOK:
 239                                 if (sliderTake([i,j], V.ROOK))
 240                                     return true;
 241                                 break;
 242                             case V.QUEEN:
 243                                 if (sliderTake([i,j], V.BISHOP) || sliderTake([i,j], V.ROOK))
 244                                     return true;
 245                                 break;
 246                         }
 247                     }
 248                 }
 249             }
 250             return false;
 251         };
 252
 253         let moves = this.getAllValidMoves();
 254         for (let move of moves)
 255         {
 256             this.play(move);
 257             if (this.kingPos[oppCol][0] >= 0 && kingThreats())
 258             {
 259                 // We didn't take opponent king, and our king will be captured: bad
 260                 move.eval = -maxeval;
 261             }
 262             this.undo(move);
 263
 264       if (!!move.eval)
 265                 continue;
 266
 267             move.eval = 0; //a priori...
 268
 269             // Can I take something ? If yes, do it if it seems good...
 270             if (move.vanish.length == 2 && move.vanish[1].c != color) //avoid castle
 271             {
 272                 const myPieceVal = V.VALUES[move.appear[0].p];
 273                 const hisPieceVal = V.VALUES[move.vanish[1].p];
 274                 if (myPieceVal <= hisPieceVal)
 275                     move.eval = hisPieceVal - myPieceVal + 2; //favor captures
 276                 else
 277                 {
 278                     // Taking a pawn with minor piece,
 279                     // or minor piece or pawn with a rook,
 280                     // or anything but a queen with a queen,
 281                     // or anything with a king.
 282                     // ==> Do it at random, although
 283                     //     this is clearly inferior to what a human can deduce...
 284                     move.eval = (Math.random() < 0.5 ? 1 : -1);
 285                 }
 286             }
 287         }
 288
 289         // TODO: also need to implement the case when an opponent piece (in light)
 290         // is threatening something - maybe not the king, but e.g. pawn takes rook.
 291
 292         moves.sort((a,b) => b.eval - a.eval);
 293         let candidates = [0];
 294         for (let j=1; j<moves.length && moves[j].eval == moves[0].eval; j++)
 295             candidates.push(j);
 296         return moves[candidates[randInt(candidates.length)]];
 297     }
 298 }