1 import { ChessRules
} from "@/base_rules";
3 export const VariantRules
= class BerolinaRules
extends ChessRules
{
4 // En-passant after 2-sq jump
5 getEpSquare(moveOrSquare
) {
6 if (!moveOrSquare
) return undefined;
7 if (typeof moveOrSquare
=== "string") {
8 const square
= moveOrSquare
;
9 if (square
== "-") return undefined;
10 // Enemy pawn initial column must be given too:
12 const epParts
= square
.split(",");
13 res
.push(V
.SquareToCoords(epParts
[0]));
14 res
.push(V
.ColumnToCoord(epParts
[1]));
17 // Argument is a move:
18 const move = moveOrSquare
;
19 const [sx
, ex
, sy
] = [move.start
.x
, move.end
.x
, move.start
.y
];
20 if (this.getPiece(sx
, sy
) == V
.PAWN
&& Math
.abs(sx
- ex
) == 2) {
24 y: (move.end
.y
+ sy
) / 2
26 // The arrival column must be remembered, because
27 // potentially two pawns could be candidates to be captured:
28 // one on our left, and one on our right.
32 return undefined; //default
35 static IsGoodEnpassant(enpassant
) {
36 if (enpassant
!= "-") {
37 const epParts
= enpassant
.split(",");
38 const epSq
= V
.SquareToCoords(epParts
[0]);
39 if (isNaN(epSq
.x
) || isNaN(epSq
.y
) || !V
.OnBoard(epSq
)) return false;
40 const arrCol
= V
.ColumnToCoord(epParts
[1]);
41 if (isNaN(arrCol
) || arrCol
< 0 || arrCol
>= V
.size
.y
) return false;
47 const L
= this.epSquares
.length
;
48 if (!this.epSquares
[L
- 1]) return "-"; //no en-passant
50 V
.CoordsToSquare(this.epSquares
[L
- 1][0]) +
52 V
.CoordToColumn(this.epSquares
[L
- 1][1])
56 // Special pawns movements
57 getPotentialPawnMoves([x
, y
]) {
58 const color
= this.turn
;
60 const [sizeX
, sizeY
] = [V
.size
.x
, V
.size
.y
];
61 const shiftX
= color
== "w" ? -1 : 1;
62 const startRank
= color
== "w" ? sizeX
- 2 : 1;
63 const lastRank
= color
== "w" ? 0 : sizeX
- 1;
65 x
+ shiftX
== lastRank
? [V
.ROOK
, V
.KNIGHT
, V
.BISHOP
, V
.QUEEN
] : [V
.PAWN
];
67 // One square diagonally
68 for (let shiftY
of [-1, 1]) {
69 if (this.board
[x
+ shiftX
][y
+ shiftY
] == V
.EMPTY
) {
70 for (let piece
of finalPieces
) {
72 this.getBasicMove([x
, y
], [x
+ shiftX
, y
+ shiftY
], {
80 y
+ 2 * shiftY
>= 0 &&
81 y
+ 2 * shiftY
< sizeY
&&
82 this.board
[x
+ 2 * shiftX
][y
+ 2 * shiftY
] == V
.EMPTY
86 this.getBasicMove([x
, y
], [x
+ 2 * shiftX
, y
+ 2 * shiftY
])
93 this.board
[x
+ shiftX
][y
] != V
.EMPTY
&&
94 this.canTake([x
, y
], [x
+ shiftX
, y
])
96 for (let piece
of finalPieces
)
98 this.getBasicMove([x
, y
], [x
+ shiftX
, y
], { c: color
, p: piece
})
103 const Lep
= this.epSquares
.length
;
104 const epSquare
= this.epSquares
[Lep
- 1]; //always at least one element
107 epSquare
[0].x
== x
+ shiftX
&&
110 let enpassantMove
= this.getBasicMove([x
, y
], [x
+ shiftX
, y
]);
111 enpassantMove
.vanish
.push({
115 c: this.getColor(x
, epSquare
[1])
117 moves
.push(enpassantMove
);
123 isAttackedByPawn([x
, y
], colors
) {
124 for (let c
of colors
) {
125 let pawnShift
= c
== "w" ? 1 : -1;
126 if (x
+ pawnShift
>= 0 && x
+ pawnShift
< V
.size
.x
) {
128 this.getPiece(x
+ pawnShift
, y
) == V
.PAWN
&&
129 this.getColor(x
+ pawnShift
, y
) == c
139 const piece
= this.getPiece(move.start
.x
, move.start
.y
);
140 if (piece
== V
.PAWN
) {
142 const finalSquare
= V
.CoordsToSquare(move.end
);
144 if (move.vanish
.length
== 2)
146 notation
= "Px" + finalSquare
;
148 // No capture: indicate the initial square for potential ambiguity
149 const startSquare
= V
.CoordsToSquare(move.start
);
150 notation
= startSquare
+ finalSquare
;
152 if (move.appear
[0].p
!= V
.PAWN
)
154 notation
+= "=" + move.appear
[0].p
.toUpperCase();
157 return super.getNotation(move); //all other pieces are orthodox