Play computer move in webworker to not freeze interface

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

diff --git a/public/javascripts/variants/Loser.js b/public/javascripts/variants/Loser.js
index 6a322b9..6731d32 100644 (file)
--- a/public/javascripts/variants/Loser.js
+++ b/public/javascripts/variants/Loser.js
@@ -1,15 +1,15 @@
 class LoserRules extends ChessRules
 {
-       initVariables(fen)
-       {
-               const epSq = this.moves.length > 0 ? this.getEpSquare(this.lastMove) : undefined;
-               this.epSquares = [ epSq ];
-       }
+       static get HasFlags() { return false; }
 
-       setFlags(fen)
+       setOtherVariables(fen)
        {
-               // No castling, hence no flags; but flags defined for compatibility
-               this.castleFlags = { "w":[false,false], "b":[false,false] };
+               const parsedFen = V.ParseFen(fen);
+               const epSq = parsedFen.enpassant != "-"
+                       ? V.SquareToCoords(parsedFen.enpassant)
+                       : undefined;
+               this.epSquares = [ epSq ];
+               this.scanKingsRooks(fen);
        }
 
        getPotentialPawnMoves([x,y])
@@ -18,10 +18,8 @@ class LoserRules extends ChessRules
 
                // Complete with promotion(s) into king, if possible
                const color = this.turn;
-               const V = VariantRules;
-               const [sizeX,sizeY] = VariantRules.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)
                {
                        // Normal move
@@ -33,7 +31,7 @@ class LoserRules extends ChessRules
                        {
                                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])
+                       if (y<V.size.y-1 && this.canTake([x,y], [x+shift,y+1])
                                && this.board[x+shift][y+1] != V.EMPTY)
                        {
                                moves.push(this.getBasicMove([x,y], [x+shift,y+1], {c:color,p:V.KING}));
@@ -45,7 +43,7 @@ class LoserRules extends ChessRules
 
        getPotentialKingMoves(sq)
        {
-               const V = VariantRules;
+               // No castle:
                return this.getSlideNJumpMoves(sq,
                        V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep");
        }
@@ -55,12 +53,11 @@ class LoserRules extends ChessRules
        {
                const color = this.turn;
                const oppCol = this.getOppCol(color);
-               const [sizeX,sizeY] = VariantRules.size;
-               for (let i=0; i<sizeX; i++)
+               for (let i=0; i<V.size.x; i++)
                {
-                       for (let j=0; j<sizeY; j++)
+                       for (let j=0; j<V.size.y; j++)
                        {
-                               if (this.board[i][j] != VariantRules.EMPTY && this.getColor(i,j) != oppCol)
+                               if (this.board[i][j] != V.EMPTY && this.getColor(i,j) != oppCol)
                                {
                                        const moves = this.getPotentialMovesFrom([i,j]);
                                        if (moves.length > 0)
@@ -88,7 +85,7 @@ class LoserRules extends ChessRules
                let moves = this.filterValid( this.getPotentialMovesFrom(sq) );
                // This is called from interface: we need to know if a capture is possible
                if (this.atLeastOneCapture())
-                       moves = VariantRules.KeepCaptures(moves);
+                       moves = V.KeepCaptures(moves);
                return moves;
        }
 
@@ -96,7 +93,7 @@ class LoserRules extends ChessRules
        {
                let moves = super.getAllValidMoves();
                if (moves.some(m => { return m.vanish.length == 2; }))
-                       moves = VariantRules.KeepCaptures(moves);
+                       moves = V.KeepCaptures(moves);
                return moves;
        }
 
@@ -110,22 +107,19 @@ class LoserRules extends ChessRules
                return [];
        }
 
-       // Unused:
+       // No variables update because no castling
        updateVariables(move) { }
        unupdateVariables(move) { }
 
-       getFlagsFen()
-       {
-               return "-";
-       }
-
        checkGameEnd()
        {
                // No valid move: you win!
                return this.turn == "w" ? "1-0" : "0-1";
        }
 
-       static get VALUES() { //experimental...
+       static get VALUES()
+       {
+               // Experimental...
                return {
                        'p': 1,
                        'r': 7,
@@ -196,6 +190,8 @@ class LoserRules extends ChessRules
                return pieces["b"].join("") +
                        "/pppppppp/8/8/8/8/PPPPPPPP/" +
                        pieces["w"].join("").toUpperCase() +
-                       " 0000"; //add flags (TODO?!)
+                       " w -"; //no en-passant
        }
 }
+
+const VariantRules = LoserRules;