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 c556f51..31630ab 100644 (file)
--- a/public/javascripts/variants/Berolina.js
+++ b/public/javascripts/variants/Berolina.js
@@ -10,23 +10,31 @@ class BerolinaRules extends ChessRules
                        const square = moveOrSquare;
                        if (square == "-")
                                return undefined;
-                       return V.SquareToCoords(square);
+                       // Enemy pawn initial column must be given too:
+                       let res = [];
+                       const epParts = square.split(",");
+                       res.push(V.SquareToCoords(epParts[0]));
+                       res.push(V.ColumnToCoord(epParts[1]));
+                       return res;
                }
                // Argument is a move:
                const move = moveOrSquare;
                const [sx,ex,sy] = [move.start.x,move.end.x,move.start.y];
                if (this.getPiece(sx,sy) == V.PAWN && Math.abs(sx - ex) == 2)
                {
-                       return {
-                               x: ex,
-                               y: (move.end.y + sy)/2
-                       };
+                       return
+                       [
+                               {
+                                       x: (ex + sx)/2,
+                                       y: (move.end.y + sy)/2
+                               },
+                               move.end.y
+                       ];
                }
                return undefined; //default
        }
 
-       // Special pawn rules: promotions to captured friendly pieces,
-       // optional on ranks 8-9 and mandatory on rank 10.
+       // Special pawns movements
        getPotentialPawnMoves([x,y])
        {
                const color = this.turn;
@@ -36,58 +44,94 @@ 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)
-                               {
-                                       for (let piece of finalPieces)
-                                       {
-                                               moves.push(this.getBasicMove([x,y], [x+shiftX,y+shiftY],
-                                                       {c:pawnColor,p:piece}));
-                                       }
-                                       if (x == startRank && this.board[x+2*shiftX][y] == 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]))
+                       if (this.board[x+shiftX][y+shiftY] == V.EMPTY)
                        {
                                for (let piece of finalPieces)
                                {
                                        moves.push(this.getBasicMove([x,y], [x+shiftX,y+shiftY],
-                                               {c:pawnColor,p:piece}));
+                                               {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}));
+               }
 
                // En passant
                const Lep = this.epSquares.length;
                const epSquare = this.epSquares[Lep-1]; //always at least one element
-               if (!!epSquare && epSquare.x == x+shiftX && epSquare.y == y)
+               if (!!epSquare && epSquare[0].x == x+shiftX && epSquare[0].y == y
+                       && Math.abs(epSquare[1] - y) == 1)
                {
-                       let enpassantMove = this.getBasicMove([x,y], [x+shift,y]);
+                       let enpassantMove = this.getBasicMove([x,y], [x+shiftX,y]);
                        enpassantMove.vanish.push({
-                               x: epSquare.x,
-                               y: y,
+                               x: x,
+                               y: epSquare[1],
                                p: 'p',
-                               c: this.getColor(epSquare.x,y)
+                               c: this.getColor(x,epSquare[1])
                        });
                        moves.push(enpassantMove);
                }
 
                return moves;
        }
+
+       isAttackedByPawn([x,y], colors)
+       {
+               for (let c of colors)
+               {
+                       let pawnShift = (c=="w" ? 1 : -1);
+                       if (x+pawnShift>=0 && x+pawnShift<V.size.x)
+                       {
+                               if (this.getPiece(x+pawnShift,y)==V.PAWN
+                                       && this.getColor(x+pawnShift,y)==c)
+                               {
+                                       return true;
+                               }
+                       }
+               }
+               return false;
+       }
+
+       getNotation(move)
+       {
+               const piece = this.getPiece(move.start.x, move.start.y);
+               if (piece == V.PAWN)
+               {
+                       // Pawn move
+                       const finalSquare = V.CoordsToSquare(move.end);
+                       let notation = "";
+                       if (move.vanish.length == 2) //capture
+                               notation = "Px" + finalSquare;
+                       else
+                       {
+                               // 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();
+                       return notation;
+               }
+               return super.getNotation(move); //all other pieces are orthodox
+       }
 }
 
 const VariantRules = BerolinaRules;