Fix captures and some moves for Grand & Wildebeest

[vchess.git] / public / javascripts / base_rules.js

diff --git a/public/javascripts/base_rules.js b/public/javascripts/base_rules.js
index d4315c7..42775da 100644 (file)
--- a/public/javascripts/base_rules.js
+++ b/public/javascripts/base_rules.js
@@ -284,7 +284,7 @@ class ChessRules
                                i += step[0];
                                j += step[1];
                        }
-                       if (i>=0 && i<8 && j>=0 && j<8 && this.canTake([x,y], [i,j]))
+                       if (i>=0 && i<sizeX && j>=0 && j<sizeY && this.canTake([x,y], [i,j]))
                                moves.push(this.getBasicMove([x,y], [i,j]));
                }
                return moves;
@@ -547,14 +547,15 @@ class ChessRules
        // Is square x,y attacked by pawns of color c ?
        isAttackedByPawn([x,y], colors)
        {
+               const [sizeX,sizeY] = VariantRules.size;
                for (let c of colors)
                {
                        let pawnShift = (c=="w" ? 1 : -1);
-                       if (x+pawnShift>=0 && x+pawnShift<8)
+                       if (x+pawnShift>=0 && x+pawnShift<sizeX)
                        {
                                for (let i of [-1,1])
                                {
-                                       if (y+i>=0 && y+i<8 && this.getPiece(x+pawnShift,y+i)==VariantRules.PAWN
+                                       if (y+i>=0 && y+i<sizeY && this.getPiece(x+pawnShift,y+i)==VariantRules.PAWN
                                                && this.getColor(x+pawnShift,y+i)==c)
                                        {
                                                return true;
@@ -605,16 +606,18 @@ class ChessRules
        // Generic method for non-pawn pieces ("sliding or jumping"): is x,y attacked by piece != color ?
        isAttackedBySlideNJump([x,y], colors, piece, steps, oneStep)
        {
+               const [sizeX,sizeY] = VariantRules.size;
                for (let step of steps)
                {
                        let rx = x+step[0], ry = y+step[1];
-                       while (rx>=0 && rx<8 && ry>=0 && ry<8 && this.board[rx][ry] == VariantRules.EMPTY
-                               && !oneStep)
+                       while (rx>=0 && rx<sizeX && ry>=0 && ry<sizeY
+                               && this.board[rx][ry] == VariantRules.EMPTY && !oneStep)
                        {
                                rx += step[0];
                                ry += step[1];
                        }
-                       if (rx>=0 && rx<8 && ry>=0 && ry<8 && this.board[rx][ry] != VariantRules.EMPTY
+                       if (rx>=0 && rx<sizeX && ry>=0 && ry<sizeY
+                               && this.board[rx][ry] != VariantRules.EMPTY
                                && this.getPiece(rx,ry) == piece && colors.includes(this.getColor(rx,ry)))
                        {
                                return true;
@@ -800,9 +803,14 @@ class ChessRules
                return VariantRules.INFINITY;
        }
 
+       static get SEARCH_DEPTH() {
+               return 3; //2 for high branching factor, 4 for small (Loser chess)
+       }
+
        // Assumption: at least one legal move
        getComputerMove(moves1) //moves1 might be precomputed (Magnetic chess)
        {
+               this.shouldReturn = false;
                const maxeval = VariantRules.INFINITY;
                const color = this.turn;
                if (!moves1)
@@ -834,21 +842,32 @@ class ChessRules
                }
                moves1.sort( (a,b) => { return (color=="w" ? 1 : -1) * (b.eval - a.eval); });
 
+               let candidates = [0]; //indices of candidates moves
+               for (let j=1; j<moves1.length && moves1[j].eval == moves1[0].eval; j++)
+                       candidates.push(j);
+               let currentBest = moves1[_.sample(candidates, 1)];
+
                // Skip depth 3 if we found a checkmate (or if we are checkmated in 1...)
-               if (Math.abs(moves1[0].eval) < VariantRules.THRESHOLD_MATE)
+               if (VariantRules.SEARCH_DEPTH >= 3
+                       && Math.abs(moves1[0].eval) < VariantRules.THRESHOLD_MATE)
                {
                        // TODO: show current analyzed move for depth 3, allow stopping eval (return moves1[0])
                        for (let i=0; i<moves1.length; i++)
                        {
+                               if (this.shouldReturn)
+                                       return currentBest; //depth-2, minimum
                                this.play(moves1[i]);
                                // 0.1 * oldEval : heuristic to avoid some bad moves (not all...)
-                               moves1[i].eval = 0.1*moves1[i].eval + this.alphabeta(2, -maxeval, maxeval);
+                               moves1[i].eval = 0.1*moves1[i].eval +
+                                       this.alphabeta(VariantRules.SEARCH_DEPTH-1, -maxeval, maxeval);
                                this.undo(moves1[i]);
                        }
                        moves1.sort( (a,b) => { return (color=="w" ? 1 : -1) * (b.eval - a.eval); });
                }
+               else
+                       return currentBest;
 
-               let candidates = [0]; //indices of candidates moves
+               candidates = [0];
                for (let j=1; j<moves1.length && moves1[j].eval == moves1[0].eval; j++)
                        candidates.push(j);
 //             console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; }));