Improve Alice variant

diff --git a/TODO.pgn b/TODO.pgn
deleted file mode 100644 (file)
index dfffdf1..0000000
--- a/TODO.pgn
+++ /dev/null
@@ -1,11 +0,0 @@
-[Site "vchess.club"]
-[Variant "Alice"]
-[Date "2018-11-23"]
-[White "Computer"]
-[Black "Myself"]
-[Fen "nrkbbqrn/pppppppp/8/8/8/8/PPPPPPPP/BRKQRNNB"]
-[Result "1-0"]
-
-1.Pb4 Pc5 2.Sbxc5 Pb5 3.Rxb8 1-0
-
-Move 3.Rxb8 erronously flip b5 pawn

diff --git a/public/javascripts/base_rules.js b/public/javascripts/base_rules.js
index ab197b6..0f637c5 100644 (file)
--- a/public/javascripts/base_rules.js
+++ b/public/javascripts/base_rules.js
@@ -479,8 +479,7 @@ class ChessRules
        {
                if (moves.length == 0)
                        return [];
-               let color = this.turn;
-               return moves.filter(m => { return !this.underCheck(m, color); });
+               return moves.filter(m => { return !this.underCheck(m); });
        }
 
        // Search for all valid moves considering current turn (for engine and game end)

diff --git a/public/javascripts/components/game.js b/public/javascripts/components/game.js
index 1f47b60..b91d72c 100644 (file)
--- a/public/javascripts/components/game.js
+++ b/public/javascripts/components/game.js
@@ -574,6 +574,7 @@ Vue.component('my-game', {
                        this.newGame("computer");
                },
                newGame: function(mode, fenInit, color, oppId, moves, continuation) {
+                       //const fen = "qrbnkbrn/pppppppp/8/8/8/8/PPPPPPPP/BNNBRKRQ 1111";//fenInit || VariantRules.GenRandInitFen();
                        const fen = fenInit || VariantRules.GenRandInitFen();
                        console.log(fen); //DEBUG
                        this.score = "*";
@@ -634,7 +635,6 @@ Vue.component('my-game', {
                        }
                        else //against computer
                        {
-                               //this.mycolor = "w";
                                this.mycolor = Math.random() < 0.5 ? 'w' : 'b';
                                if (this.mycolor == 'b')
                                        setTimeout(this.playComputerMove, 500);

diff --git a/public/javascripts/variants/Alice.js b/public/javascripts/variants/Alice.js
index dd023bb..7616827 100644 (file)
--- a/public/javascripts/variants/Alice.js
+++ b/public/javascripts/variants/Alice.js
@@ -60,11 +60,10 @@ class AliceRules extends ChessRules
                }
        }
 
-       getBoardOfPiece([x,y])
+       // Build board of the given (mirror)side
+       getSideBoard(mirrorSide)
        {
                const V = VariantRules;
-               // Build board where the piece is
-               const mirrorSide = (Object.keys(V.ALICE_CODES).includes(this.getPiece(x,y)) ? 1 : 2);
                // Build corresponding board from complete board
                const [sizeX,sizeY] = V.size;
                let sideBoard = doubleArray(sizeX, sizeY, "");
@@ -82,25 +81,22 @@ class AliceRules extends ChessRules
                return sideBoard;
        }
 
-       // TODO: move board building one level up (findAllMoves()) to avoid re-building at every piece...
        // NOTE: castle & enPassant https://www.chessvariants.com/other.dir/alice.html
        // --> Should be OK as is.
-       getPotentialMovesFrom([x,y])
+       getPotentialMovesFrom([x,y], sideBoard)
        {
-               let sideBoard = this.getBoardOfPiece([x,y]);
+               const pieces = Object.keys(VariantRules.ALICE_CODES);
+               const codes = Object.keys(VariantRules.ALICE_PIECES);
+               const mirrorSide = (pieces.includes(this.getPiece(x,y)) ? 1 : 2);
 
                // Search valid moves on sideBoard
                let saveBoard = this.board;
-               this.board = sideBoard;
+               this.board = sideBoard || this.getSideBoard(mirrorSide);
                let moves = super.getPotentialMovesFrom([x,y]);
                this.board = saveBoard;
 
-               const pieces = Object.keys(VariantRules.ALICE_CODES);
-               const codes = Object.keys(VariantRules.ALICE_PIECES);
-
                // Finally filter impossible moves
-               const mirrorSide = (pieces.includes(this.getPiece(x,y)) ? 1 : 2);
-               return moves.filter(m => {
+               let res = moves.filter(m => {
                        if (m.appear.length == 2) //castle
                        {
                                // If appear[i] not in vanish array, then must be empty square on other board
@@ -150,15 +146,54 @@ class AliceRules extends ChessRules
                        }
                        return true;
                });
+               return res;
+       }
+
+       // NOTE: alternative implementation, recompute sideBoard's in this function
+       filterValid(moves, sideBoard)
+       {
+               if (moves.length == 0)
+                       return [];
+               const pieces = Object.keys(VariantRules.ALICE_CODES);
+               return moves.filter(m => {
+                       // WARNING: for underCheck(), we need the sideBoard of the arrival world !
+                       const mirrorSide = (pieces.includes(this.getPiece(m.start.x,m.start.y)) ? 2 : 1);
+                       return !this.underCheck(m, !!sideBoard ? sideBoard[mirrorSide-1] : null);
+               });
        }
 
-       underCheck(move)
+       getAllValidMoves()
+       {
+               const color = this.turn;
+               const oppCol = this.getOppCol(color);
+               var potentialMoves = [];
+               let [sizeX,sizeY] = VariantRules.size;
+               let sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
+               for (var i=0; i<sizeX; i++)
+               {
+                       for (var j=0; j<sizeY; j++)
+                       {
+                               if (this.board[i][j] != VariantRules.EMPTY && this.getColor(i,j) == color)
+                               {
+                                       const mirrorSide =
+                                               (Object.keys(VariantRules.ALICE_CODES).includes(this.getPiece(i,j)) ? 1 : 2);
+                                       Array.prototype.push.apply(potentialMoves,
+                                               this.getPotentialMovesFrom([i,j], sideBoard[mirrorSide-1]));
+                               }
+                       }
+               }
+               return this.filterValid(potentialMoves, sideBoard);
+       }
+
+       underCheck(move, sideBoard)
        {
                const color = this.turn;
                this.play(move);
-               let sideBoard = this.getBoardOfPiece(this.kingPos[color]);
+               const pieces = Object.keys(VariantRules.ALICE_CODES);
+               const kp = this.kingPos[color];
+               const mirrorSide = (pieces.includes(this.getPiece(kp[0],kp[1])) ? 1 : 2);
                let saveBoard = this.board;
-               this.board = sideBoard;
+               this.board = sideBoard || this.getSideBoard(mirrorSide);
                let res = this.isAttacked(this.kingPos[color], this.getOppCol(color));
                this.board = saveBoard;
                this.undo(move);
@@ -169,7 +204,10 @@ class AliceRules extends ChessRules
        {
                this.play(move);
                const color = this.turn; //opponent
-               let sideBoard = this.getBoardOfPiece(this.kingPos[color]);
+               const pieces = Object.keys(VariantRules.ALICE_CODES);
+               const kp = this.kingPos[color];
+               const mirrorSide = (pieces.includes(this.getPiece(kp[0],kp[1])) ? 1 : 2);
+               let sideBoard = this.getSideBoard(mirrorSide);
                let saveBoard = this.board;
                this.board = sideBoard;
                let res = this.isAttacked(this.kingPos[color], this.getOppCol(color))
@@ -204,8 +242,11 @@ class AliceRules extends ChessRules
 
        checkGameEnd()
        {
+               const pieces = Object.keys(VariantRules.ALICE_CODES);
                const color = this.turn;
-               let sideBoard = this.getBoardOfPiece(this.kingPos[color]);
+               const kp = this.kingPos[color];
+               const mirrorSide = (pieces.includes(this.getPiece(kp[0],kp[1])) ? 1 : 2);
+               let sideBoard = this.getSideBoard(mirrorSide);
                let saveBoard = this.board;
                this.board = sideBoard;
                let res = "*";