Fix Atomic when an init rook is taken

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

diff --git a/public/javascripts/variants/Atomic.js b/public/javascripts/variants/Atomic.js
index f32e21d..633e70a 100644 (file)
--- a/public/javascripts/variants/Atomic.js
+++ b/public/javascripts/variants/Atomic.js
@@ -30,10 +30,11 @@ class AtomicRules extends ChessRules
 
        getPotentialKingMoves([x,y])
        {
+               const V = VariantRules;
                // King cannot capture:
                let moves = [];
-               let [sizeX,sizeY] = VariantRules.size;
-               const steps = VariantRules.steps[VariantRules.QUEEN];
+               let [sizeX,sizeY] = V.size;
+               const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
                for (let step of steps)
                {
                        var i = x + step[0];
@@ -65,14 +66,26 @@ class AtomicRules extends ChessRules
                        && this.board[move.end.x][move.end.y] != VariantRules.EMPTY)
                {
                        const oppCol = this.getOppCol(c);
-                       const oppFirstRank = (oppCol == "w" ? 7 : 0);
+                       const firstRank = (c == "w" ? 7 : 0);
+                       const oppFirstRank = 7 - firstRank;
 
                        // Did we explode our king ? (TODO: remove move earlier)
                        if (Math.abs(this.kingPos[c][0]-move.end.x) <= 1
                                && Math.abs(this.kingPos[c][1]-move.end.y) <= 1)
                        {
                                this.kingPos[c] = [-1,-1];
-                               this.flags[c] = [false,false];
+                               this.castleFlags[c] = [false,false];
+                       }
+                       else
+                       {
+                               // Now check if our init rook(s) exploded
+                               if (Math.abs(move.end.x-firstRank) <= 1)
+                               {
+                                       if (Math.abs(move.end.y-this.INIT_COL_ROOK[oppCol][0]) <= 1)
+                                               this.castleFlags[c][0] = false;
+                                       if (Math.abs(move.end.y-this.INIT_COL_ROOK[oppCol][1]) <= 1)
+                                               this.castleFlags[c][1] = false;
+                               }
                        }
 
                        // Did we explode opponent king ?
@@ -80,7 +93,7 @@ class AtomicRules extends ChessRules
                                && Math.abs(this.kingPos[oppCol][1]-move.end.y) <= 1)
                        {
                                this.kingPos[oppCol] = [-1,-1];
-                               this.flags[oppCol] = [false,false];
+                               this.castleFlags[oppCol] = [false,false];
                        }
                        else
                        {
@@ -88,9 +101,9 @@ class AtomicRules extends ChessRules
                                if (Math.abs(move.end.x-oppFirstRank) <= 1)
                                {
                                        if (Math.abs(move.end.y-this.INIT_COL_ROOK[oppCol][0]) <= 1)
-                                               this.flags[oppCol][0] = false;
+                                               this.castleFlags[oppCol][0] = false;
                                        if (Math.abs(move.end.y-this.INIT_COL_ROOK[oppCol][1]) <= 1)
-                                               this.flags[oppCol][1] = false;
+                                               this.castleFlags[oppCol][1] = false;
                                }
                        }
                }
@@ -126,7 +139,7 @@ class AtomicRules extends ChessRules
                        res = false;
                // Otherwise, if we remain under check, move is not valid
                else
-                       res = this.isAttacked(this.kingPos[c], oppCol);
+                       res = this.isAttacked(this.kingPos[c], [oppCol]);
                this.undo(move);
                return res;
        }
@@ -140,7 +153,7 @@ class AtomicRules extends ChessRules
                let res = [ ];
                if (this.kingPos[c][0] < 0)
                        res = [saveKingPos];
-               else if (this.isAttacked(this.kingPos[c], this.getOppCol(c)))
+               else if (this.isAttacked(this.kingPos[c], [this.getOppCol(c)]))
                        res = [ JSON.parse(JSON.stringify(this.kingPos[c])) ]
                this.undo(move);
                return res;
@@ -152,7 +165,7 @@ class AtomicRules extends ChessRules
                const kp = this.kingPos[color];
                if (kp[0] < 0) //king disappeared
                        return color == "w" ? "0-1" : "1-0";
-               if (!this.isAttacked(kp, this.getOppCol(color)))
+               if (!this.isAttacked(kp, [this.getOppCol(color)]))
                        return "1/2";
                // Checkmate
                return color == "w" ? "0-1" : "1-0";