Bugs fixing, finalization of rules in french+english

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

diff --git a/public/javascripts/variants/Berolina.js b/public/javascripts/variants/Berolina.js
index be72e2d..31630ab 100644 (file)
--- a/public/javascripts/variants/Berolina.js
+++ b/public/javascripts/variants/Berolina.js
@@ -44,37 +44,34 @@ class BerolinaRules extends ChessRules
                const firstRank = (color == 'w' ? sizeX-1 : 0);
                const startRank = (color == "w" ? sizeX-2 : 1);
                const lastRank = (color == "w" ? 0 : sizeX-1);
+               const finalPieces = x + shiftX == lastRank
+                       ? [V.ROOK,V.KNIGHT,V.BISHOP,V.QUEEN]
+                       : [V.PAWN];
 
-               if (x+shiftX >= 0 && x+shiftX < sizeX) //TODO: always true
+               // One square diagonally
+               for (let shiftY of [-1,1])
                {
-                       const finalPieces = x + shiftX == lastRank
-                               ? [V.ROOK,V.KNIGHT,V.BISHOP,V.QUEEN]
-                               : [V.PAWN]
-                       // One square diagonally
-                       for (let shiftY of [-1,1])
+                       if (this.board[x+shiftX][y+shiftY] == V.EMPTY)
                        {
-                               if (this.board[x+shiftX][y+shiftY] == V.EMPTY)
+                               for (let piece of finalPieces)
                                {
-                                       for (let piece of finalPieces)
-                                       {
-                                               moves.push(this.getBasicMove([x,y], [x+shiftX,y+shiftY],
-                                                       {c:color,p:piece}));
-                                       }
-                                       if (x == startRank && y+2*shiftY>=0 && y+2*shiftY<sizeY
-                                               && this.board[x+2*shiftX][y+2*shiftY] == V.EMPTY)
-                                       {
-                                               // Two squares jump
-                                               moves.push(this.getBasicMove([x,y], [x+2*shiftX,y+2*shiftY]));
-                                       }
+                                       moves.push(this.getBasicMove([x,y], [x+shiftX,y+shiftY],
+                                               {c:color,p:piece}));
+                               }
+                               if (x == startRank && y+2*shiftY>=0 && y+2*shiftY<sizeY
+                                       && this.board[x+2*shiftX][y+2*shiftY] == V.EMPTY)
+                               {
+                                       // Two squares jump
+                                       moves.push(this.getBasicMove([x,y], [x+2*shiftX,y+2*shiftY]));
                                }
                        }
-                       // Capture
-                       if (this.board[x+shiftX][y] != V.EMPTY
-                               && this.canTake([x,y], [x+shiftX,y]))
-                       {
-                               for (let piece of finalPieces)
-                                       moves.push(this.getBasicMove([x,y], [x+shiftX,y], {c:color,p:piece}));
-                       }
+               }
+               // Capture
+               if (this.board[x+shiftX][y] != V.EMPTY
+                       && this.canTake([x,y], [x+shiftX,y]))
+               {
+                       for (let piece of finalPieces)
+                               moves.push(this.getBasicMove([x,y], [x+shiftX,y], {c:color,p:piece}));
                }
 
                // En passant
@@ -119,14 +116,15 @@ class BerolinaRules extends ChessRules
                if (piece == V.PAWN)
                {
                        // Pawn move
+                       const finalSquare = V.CoordsToSquare(move.end);
                        let notation = "";
                        if (move.vanish.length == 2) //capture
-                               notation = finalSquare;
+                               notation = "Px" + finalSquare;
                        else
                        {
-                               // No capture
-                               const startColumn = V.CoordToColumn(move.start.y);
-                               notation = startColumn + "x" + finalSquare;
+                               // No capture: indicate the initial square for potential ambiguity
+                               const startSquare = V.CoordsToSquare(move.start);
+                               notation = startSquare + finalSquare;
                        }
                        if (move.appear[0].p != V.PAWN) //promotion
                                notation += "=" + move.appear[0].p.toUpperCase();