Step toward a one-page application

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

diff --git a/public/javascripts/variants/Antiking.js b/public/javascripts/variants/Antiking.js
index e741168..66eb9f0 100644 (file)
--- a/public/javascripts/variants/Antiking.js
+++ b/public/javascripts/variants/Antiking.js
@@ -6,18 +6,23 @@ class AntikingRules extends ChessRules
        }
 
        static get ANTIKING() { return 'a'; }
-       
-       initVariables(fen)
+
+       static get PIECES()
+       {
+               return ChessRules.PIECES.concat([V.ANTIKING]);
+       }
+
+       setOtherVariables(fen)
        {
-               super.initVariables(fen);
+               super.setOtherVariables(fen);
                this.antikingPos = {'w':[-1,-1], 'b':[-1,-1]};
-               const position = fen.split(" ")[0].split("/");
-               for (let i=0; i<position.length; i++)
+               const rows = V.ParseFen(fen).position.split("/");
+               for (let i=0; i<rows.length; i++)
                {
                        let k = 0;
-                       for (let j=0; j<position[i].length; j++)
+                       for (let j=0; j<rows[i].length; j++)
                        {
-                               switch (position[i].charAt(j))
+                               switch (rows[i].charAt(j))
                                {
                                        case 'a':
                                                this.antikingPos['b'] = [i,k];
@@ -26,7 +31,7 @@ class AntikingRules extends ChessRules
                                                this.antikingPos['w'] = [i,k];
                                                break;
                                        default:
-                                               let num = parseInt(position[i].charAt(j));
+                                               const num = parseInt(rows[i].charAt(j));
                                                if (!isNaN(num))
                                                        k += (num-1);
                                }
@@ -83,33 +88,27 @@ class AntikingRules extends ChessRules
                        V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep");
        }
 
-       underCheck(move)
+       underCheck(color)
        {
-               const c = this.turn;
-               const oppCol = this.getOppCol(c);
-               this.play(move)
-               let res = this.isAttacked(this.kingPos[c], [oppCol])
-                       || !this.isAttacked(this.antikingPos[c], [oppCol]);
-               this.undo(move);
+               const oppCol = V.GetOppCol(color);
+               let res = this.isAttacked(this.kingPos[color], [oppCol])
+                       || !this.isAttacked(this.antikingPos[color], [oppCol]);
                return res;
        }
 
-       getCheckSquares(move)
+       getCheckSquares(color)
        {
-               let res = super.getCheckSquares(move);
-               this.play(move);
-               const c = this.turn;
-               if (!this.isAttacked(this.antikingPos[c], [this.getOppCol(c)]))
-                       res.push(JSON.parse(JSON.stringify(this.antikingPos[c])));
-               this.undo(move);
+               let res = super.getCheckSquares(color);
+               if (!this.isAttacked(this.antikingPos[color], [V.GetOppCol(color)]))
+                       res.push(JSON.parse(JSON.stringify(this.antikingPos[color])));
                return res;
        }
 
        updateVariables(move)
        {
                super.updateVariables(move);
-               const piece = this.getPiece(move.start.x,move.start.y);
-               const c = this.getColor(move.start.x,move.start.y);
+               const piece = move.vanish[0].p;
+               const c = move.vanish[0].c;
                // Update antiking position
                if (piece == V.ANTIKING)
                {
@@ -121,15 +120,15 @@ class AntikingRules extends ChessRules
        unupdateVariables(move)
        {
                super.unupdateVariables(move);
-               const c = this.getColor(move.start.x,move.start.y);
-               if (this.getPiece(move.start.x,move.start.y) == V.ANTIKING)
+               const c = move.vanish[0].c;
+               if (move.vanish[0].p == V.ANTIKING)
                        this.antikingPos[c] = [move.start.x, move.start.y];
        }
 
        checkGameEnd()
        {
                const color = this.turn;
-               const oppCol = this.getOppCol(color);
+               const oppCol = V.GetOppCol(color);
                if (!this.isAttacked(this.kingPos[color], [oppCol])
                        && this.isAttacked(this.antikingPos[color], [oppCol]))
                {
@@ -193,10 +192,9 @@ class AntikingRules extends ChessRules
                        + "A" + (antikingPos["w"]<7?7-antikingPos["w"]:"");
                const ranks23_white = (antikingPos["b"]>0?antikingPos["b"]:"") + "a"
                        + (antikingPos["b"]<7?7-antikingPos["b"]:"") + "/PPPPPPPP";
-               let fen = pieces["b"].join("") + "/" + ranks23_black +
+               return pieces["b"].join("") + "/" + ranks23_black +
                        "/8/8/" +
                        ranks23_white + "/" + pieces["w"].join("").toUpperCase() +
-                       " 1111";
-               return fen;
+                       " w 1111 -";
        }
 }