Improve Switching chess: avoid duplicate moves for analysis, better notation

diff --git a/TODO b/TODO
index 1aae2fb..26aabd5 100644 (file)
--- a/TODO
+++ b/TODO
@@ -1,3 +1,4 @@
+Allow to navigate in game after it's over (back/play)

 For animation, moves should contains "moving" and "fading" maybe...
 (But it's really just for Magnetic chess)
 setInterval "CRON" task in sockets.js to check connected clients
 For animation, moves should contains "moving" and "fading" maybe...
 (But it's really just for Magnetic chess)
 setInterval "CRON" task in sockets.js to check connected clients

diff --git a/public/javascripts/base_rules.js b/public/javascripts/base_rules.js
index 48a5602..ee5ddd0 100644 (file)
--- a/public/javascripts/base_rules.js
+++ b/public/javascripts/base_rules.js
@@ -821,7 +821,9 @@ class ChessRules
                this.shouldReturn = false;
                const maxeval = VariantRules.INFINITY;
                const color = this.turn;
                this.shouldReturn = false;
                const maxeval = VariantRules.INFINITY;
                const color = this.turn;

-               let moves1 = this.getAllValidMoves();
+               // Some variants may show a bigger moves list to the human (Switching),
+               // thus the argument "computer" below (which is generally ignored)
+               let moves1 = this.getAllValidMoves("computer");

 
                // Can I mate in 1 ? (for Magnetic & Extinction)
                for (let i of _.shuffle(_.range(moves1.length)))
 
                // Can I mate in 1 ? (for Magnetic & Extinction)
                for (let i of _.shuffle(_.range(moves1.length)))


@@ -843,7 +845,7 @@ class ChessRules
                        {
                                eval2 = (color=="w" ? 1 : -1) * maxeval; //initialized with checkmate value
                                // Second half-move:
                        {
                                eval2 = (color=="w" ? 1 : -1) * maxeval; //initialized with checkmate value
                                // Second half-move:

-                               let moves2 = this.getAllValidMoves();
+                               let moves2 = this.getAllValidMoves("computer");

                                for (let j=0; j<moves2.length; j++)
                                {
                                        this.play(moves2[j]);
                                for (let j=0; j<moves2.length; j++)
                                {
                                        this.play(moves2[j]);


@@ -921,7 +923,7 @@ class ChessRules
                }
                if (depth == 0)
       return this.evalPosition();
                }
                if (depth == 0)
       return this.evalPosition();

-               const moves = this.getAllValidMoves();
+               const moves = this.getAllValidMoves("computer");

     let v = color=="w" ? -maxeval : maxeval;
                if (color == "w")
                {
     let v = color=="w" ? -maxeval : maxeval;
                if (color == "w")
                {


@@ -1082,14 +1084,8 @@ class ChessRules
        // Context: just before move is played, turn hasn't changed
        getNotation(move)
        {
        // Context: just before move is played, turn hasn't changed
        getNotation(move)
        {

-               if (move.appear.length == 2 && move.appear[0].p == VariantRules.KING)
-               {
-                       // Castle
-                       if (move.end.y < move.start.y)
-                               return "0-0-0";
-                       else
-                               return "0-0";
-               }
+               if (move.appear.length == 2 && move.appear[0].p == VariantRules.KING) //castle
+                       return (move.end.y < move.start.y ? "0-0-0" : "0-0");

 
                // Translate final square
                const finalSquare =
 
                // Translate final square
                const finalSquare =

diff --git a/public/javascripts/variants/Switching.js b/public/javascripts/variants/Switching.js
index af934f3..cedba3d 100644 (file)
--- a/public/javascripts/variants/Switching.js
+++ b/public/javascripts/variants/Switching.js
@@ -51,10 +51,10 @@ class SwitchingRules extends ChessRules
                return moves;
        }
 
                return moves;
        }
 

-       getPotentialMovesFrom([x,y])
+       getPotentialMovesFrom([x,y], computer)

        {
                let moves = super.getPotentialMovesFrom([x,y]);
        {
                let moves = super.getPotentialMovesFrom([x,y]);

-               // Add switches:
+               // Add switches: respecting chessboard ordering if "computer" is on

                const V = VariantRules;
                const color = this.turn;
                const piece = this.getPiece(x,y);
                const V = VariantRules;
                const color = this.turn;
                const piece = this.getPiece(x,y);


@@ -65,6 +65,8 @@ class SwitchingRules extends ChessRules
                for (let step of steps)
                {
                        let [i,j] = [x+step[0],y+step[1]];
                for (let step of steps)
                {
                        let [i,j] = [x+step[0],y+step[1]];

+                       if (!!computer && (i<x || (i==x && j<y)))
+                               continue; //only switch with superior indices

                        if (i>=0 && i<sizeX && j>=0 && j<sizeY && this.board[i][j]!=V.EMPTY
                                && this.getColor(i,j)==color && this.getPiece(i,j)!=piece
                                // No switching under check (theoretically non-king pieces could, but not)
                        if (i>=0 && i<sizeX && j>=0 && j<sizeY && this.board[i][j]!=V.EMPTY
                                && this.getColor(i,j)==color && this.getPiece(i,j)!=piece
                                // No switching under check (theoretically non-king pieces could, but not)


@@ -80,6 +82,26 @@ class SwitchingRules extends ChessRules
                return moves;
        }
 
                return moves;
        }
 

+       getAllValidMoves(computer)
+       {
+               const color = this.turn;
+               const oppCol = this.getOppCol(color);
+               let potentialMoves = [];
+               const [sizeX,sizeY] = VariantRules.size;
+               for (let i=0; i<sizeX; i++)
+               {
+                       for (let j=0; j<sizeY; j++)
+                       {
+                               if (this.board[i][j] != VariantRules.EMPTY && this.getColor(i,j) == color)
+                               {
+                                       Array.prototype.push.apply(potentialMoves,
+                                               this.getPotentialMovesFrom([i,j], computer));
+                               }
+                       }
+               }
+               return this.filterValid(potentialMoves);
+       }
+

        updateVariables(move)
        {
                super.updateVariables(move);
        updateVariables(move)
        {
                super.updateVariables(move);


@@ -103,5 +125,20 @@ class SwitchingRules extends ChessRules
                }
        }
 
                }
        }
 

-       static get SEARCH_DEPTH() { return 2; } //branching factor is quite high
+       static get SEARCH_DEPTH() { return 2; } //high branching factor
+
+       getNotation(move)
+       {
+               if (move.appear.length == 1)
+                       return super.getNotation(move); //no switch
+               // Switch or castle
+               if (move.appear[0].p == VariantRules.KING && move.appear[1].p == VariantRules.ROOK)
+                       return (move.end.y < move.start.y ? "0-0-0" : "0-0");
+               // Switch:
+               const startSquare =
+                       String.fromCharCode(97 + move.start.y) + (VariantRules.size[0]-move.start.x);
+               const finalSquare =
+                       String.fromCharCode(97 + move.end.y) + (VariantRules.size[0]-move.end.x);
+               return "S" + startSquare + finalSquare;
+       }

 }
 }