Step toward a one-page application

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

diff --git a/public/javascripts/variants/Extinction.js b/public/javascripts/variants/Extinction.js
index f0ebeab..aab359f 100644 (file)
--- a/public/javascripts/variants/Extinction.js
+++ b/public/javascripts/variants/Extinction.js
@@ -1,28 +1,30 @@
 class ExtinctionRules extends ChessRules
 {
-       initVariables(fen)
+       setOtherVariables(fen)
        {
-               super.initVariables(fen);
-               const V = VariantRules;
+               super.setOtherVariables(fen);
+               const pos = V.ParseFen(fen).position;
+               // NOTE: no need for safety "|| []", because each piece type must be present
+               // (otherwise game is already over!)
                this.material =
                {
                        "w":
                        {
-                               [V.KING]: 1,
-                               [V.QUEEN]: 1,
-                               [V.ROOK]: 2,
-                               [V.KNIGHT]: 2,
-                               [V.BISHOP]: 2,
-                               [V.PAWN]: 8
+                               [V.KING]: pos.match(/K/g).length,
+                               [V.QUEEN]: pos.match(/Q/g).length,
+                               [V.ROOK]: pos.match(/R/g).length,
+                               [V.KNIGHT]: pos.match(/N/g).length,
+                               [V.BISHOP]: pos.match(/B/g).length,
+                               [V.PAWN]: pos.match(/P/g).length
                        },
                        "b":
                        {
-                               [V.KING]: 1,
-                               [V.QUEEN]: 1,
-                               [V.ROOK]: 2,
-                               [V.KNIGHT]: 2,
-                               [V.BISHOP]: 2,
-                               [V.PAWN]: 8
+                               [V.KING]: pos.match(/k/g).length,
+                               [V.QUEEN]: pos.match(/q/g).length,
+                               [V.ROOK]: pos.match(/r/g).length,
+                               [V.KNIGHT]: pos.match(/n/g).length,
+                               [V.BISHOP]: pos.match(/b/g).length,
+                               [V.PAWN]: pos.match(/p/g).length
                        }
                };
        }
@@ -32,10 +34,8 @@ class ExtinctionRules extends ChessRules
                let moves = super.getPotentialPawnMoves([x,y]);
                // Add potential promotions into king
                const color = this.turn;
-               const V = VariantRules;
-               const [sizeX,sizeY] = V.size;
                const shift = (color == "w" ? -1 : 1);
-               const lastRank = (color == "w" ? 0 : sizeX-1);
+               const lastRank = (color == "w" ? 0 : V.size.x-1);
 
                if (x+shift == lastRank)
                {
@@ -43,13 +43,13 @@ class ExtinctionRules extends ChessRules
                        if (this.board[x+shift][y] == V.EMPTY)
                                moves.push(this.getBasicMove([x,y], [x+shift,y], {c:color,p:V.KING}));
                        // Captures
-                       if (y>0 && this.canTake([x,y], [x+shift,y-1])
-                               && this.board[x+shift][y-1] != V.EMPTY)
+                       if (y>0 && this.board[x+shift][y-1] != V.EMPTY
+                               && this.canTake([x,y], [x+shift,y-1]))
                        {
                                moves.push(this.getBasicMove([x,y], [x+shift,y-1], {c:color,p:V.KING}));
                        }
-                       if (y<sizeY-1 && this.canTake([x,y], [x+shift,y+1])
-                               && this.board[x+shift][y+1] != V.EMPTY)
+                       if (y<V.size.y-1 && this.board[x+shift][y+1] != V.EMPTY
+                               && this.canTake([x,y], [x+shift,y+1]))
                        {
                                moves.push(this.getBasicMove([x,y], [x+shift,y+1], {c:color,p:V.KING}));
                        }
@@ -64,12 +64,12 @@ class ExtinctionRules extends ChessRules
                return true; //always at least one possible move
        }
 
-       underCheck(move)
+       underCheck(color)
        {
                return false; //there is no check
        }
 
-       getCheckSquares(move)
+       getCheckSquares(color)
        {
                return [];
        }
@@ -81,7 +81,7 @@ class ExtinctionRules extends ChessRules
                if (move.appear[0].p != move.vanish[0].p)
                {
                        this.material[move.appear[0].c][move.appear[0].p]++;
-                       this.material[move.appear[0].c][VariantRules.PAWN]--;
+                       this.material[move.appear[0].c][V.PAWN]--;
                }
                if (move.vanish.length==2 && move.appear.length==1) //capture
                        this.material[move.vanish[1].c][move.vanish[1].p]--;
@@ -93,7 +93,7 @@ class ExtinctionRules extends ChessRules
                if (move.appear[0].p != move.vanish[0].p)
                {
                        this.material[move.appear[0].c][move.appear[0].p]--;
-                       this.material[move.appear[0].c][VariantRules.PAWN]++;
+                       this.material[move.appear[0].c][V.PAWN]++;
                }
                if (move.vanish.length==2 && move.appear.length==1)
                        this.material[move.vanish[1].c][move.vanish[1].p]++;
@@ -120,7 +120,7 @@ class ExtinctionRules extends ChessRules
 
        checkGameEnd()
        {
-               return this.turn == "w" ? "0-1" : "1-0";
+               return (this.turn == "w" ? "0-1" : "1-0");
        }
 
        evalPosition()
@@ -130,7 +130,7 @@ class ExtinctionRules extends ChessRules
                        p => { return this.material[color][p] == 0; }))
                {
                        // Very negative (resp. positive) if white (reps. black) pieces set is incomplete
-                       return (color=="w"?-1:1) * VariantRules.INFINITY;
+                       return (color=="w"?-1:1) * V.INFINITY;
                }
                return super.evalPosition();
        }