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

[vchess.git] / public / javascripts / variants / Switching.js

diff --git a/public/javascripts/variants/Switching.js b/public/javascripts/variants/Switching.js
index cc2febd..cedba3d 100644 (file)
--- a/public/javascripts/variants/Switching.js
+++ b/public/javascripts/variants/Switching.js
@@ -3,10 +3,12 @@ class SwitchingRules extends ChessRules
        // Build switch move between squares x1,y1 and x2,y2
        getSwitchMove_s([x1,y1],[x2,y2])
        {
-
                const c = this.getColor(x1,y1); //same as color at square 2
                const p1 = this.getPiece(x1,y1);
                const p2 = this.getPiece(x2,y2);
+               const V = VariantRules;
+               if (p1 == V.KING && p2 == V.ROOK)
+                       return []; //avoid duplicate moves (potential conflict with castle)
                let move = new Move({
                        appear: [
                                new PiPo({x:x2,y:y2,c:c,p:p1}),
@@ -22,28 +24,37 @@ class SwitchingRules extends ChessRules
                // Move completion: promote switched pawns (as in Magnetic)
                const sizeX = VariantRules.size[0];
                const lastRank = (c == "w" ? 0 : sizeX-1);
-               const V = VariantRules;
                let moves = [];
-               if (p1==V.PAWN && x2==lastRank) //TODO: also the case p2==V.PAWN and x1==lastRank! see Magnetic chess
+               if ((p1==V.PAWN && x2==lastRank) || (p2==V.PAWN && x1==lastRank))
                {
-                       move.appear[0].p = V.ROOK;
+                       const idx = (p1==V.PAWN ? 0 : 1);
+                       move.appear[idx].p = V.ROOK;
                        moves.push(move);
                        for (let piece of [V.KNIGHT, V.BISHOP, V.QUEEN])
                        {
                                let cmove = JSON.parse(JSON.stringify(move));
-                               cmove.appear[0].p = piece;
+                               cmove.appear[idx].p = piece;
                                moves.push(cmove);
                        }
+                       if (idx == 1)
+                       {
+                               // Swap moves[i].appear[0] and [1] for moves presentation [TODO...]
+                               moves.forEach(m => {
+                                       let tmp = m.appear[0];
+                                       m.appear[0] = m.appear[1];
+                                       m.appear[1] = tmp;
+                               });
+                       }
                }
                else //other cases
                        moves.push(move);
                return moves;
        }
 
-       getPotentialMovesFrom([x,y])
+       getPotentialMovesFrom([x,y], computer)
        {
                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);
@@ -54,6 +65,8 @@ class SwitchingRules extends ChessRules
                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)
@@ -69,5 +82,63 @@ class SwitchingRules extends ChessRules
                return moves;
        }
 
-       static get SEARCH_DEPTH() { return 2; } //branching factor is quite high
+       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);
+               if (move.appear.length == 2 && move.vanish.length == 2
+                       && move.appear[1].p == VariantRules.KING)
+               {
+                       // Switch with the king; not castle, and not handled by main class
+                       const color = this.getColor(move.start.x, move.start.y);
+                       this.kingPos[color] = [move.appear[1].x, move.appear[1].y];
+               }
+       }
+
+       unupdateVariables(move)
+       {
+               super.unupdateVariables(move);
+               if (move.appear.length == 2 && move.vanish.length == 2
+                       && move.appear[1].p == VariantRules.KING)
+               {
+                       const color = this.getColor(move.start.x, move.start.y);
+                       this.kingPos[color] = [move.appear[0].x, move.appear[0].y];
+               }
+       }
+
+       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;
+       }
 }