1 import { ChessRules
, PiPo
, Move
} from "@/base_rules";
3 export class Allmate2Rules
extends ChessRules
{
4 static get HasEnpassant() {
13 static GenRandInitFen(randomness
) {
14 return ChessRules
.GenRandInitFen(randomness
).slice(0, -2);
17 getPotentialMovesFrom([x
, y
]) {
18 let moves
= super.getPotentialMovesFrom([x
, y
]);
19 // Remove standard captures (without removing castling):
20 moves
= moves
.filter(m
=> {
21 return m
.vanish
.length
== 1 || m
.appear
.length
== 2;
24 // Augment moves with "mate-captures":
25 // TODO: this is coded in a highly inefficient way...
26 const color
= this.turn
;
27 const oppCol
= V
.GetOppCol(this.turn
);
31 // 1) What is attacked?
33 for (let i
=0; i
<V
.size
.x
; i
++) {
34 for (let j
=0; j
<V
.size
.y
; j
++) {
35 if (this.getColor(i
,j
) == oppCol
&& this.isAttacked([i
,j
], color
))
36 attacked
[i
+"_"+j
] = [i
,j
];
40 // 2) Among attacked pieces, which cannot escape capture?
41 // --> without (normal-)capturing: difference with Allmate1 variant
42 // Avoid "oppMoves = this.getAllValidMoves();" => infinite recursion
43 outerLoop: for (let i
=0; i
<V
.size
.x
; i
++) {
44 for (let j
=0; j
<V
.size
.y
; j
++) {
45 if (this.getColor(i
,j
) == oppCol
) {
47 switch (this.getPiece(i
, j
)) {
49 oppMoves
= this.getPotentialPawnMoves([i
, j
]);
52 oppMoves
= this.getPotentialRookMoves([i
, j
]);
55 oppMoves
= this.getPotentialKnightMoves([i
, j
]);
58 oppMoves
= this.getPotentialBishopMoves([i
, j
]);
61 oppMoves
= this.getPotentialQueenMoves([i
, j
]);
64 // Do not allow castling to escape from check
65 oppMoves
= super.getSlideNJumpMoves(
67 V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
]),
72 for (let om
of oppMoves
) {
73 if (om
.vanish
.length
== 2)
74 // Skip captures: forbidden in this mode
76 V
.PlayOnBoard(this.board
, om
);
77 Object
.values(attacked
).forEach(sq
=> {
78 const origSq
= [sq
[0], sq
[1]];
79 if (om
.start
.x
== sq
[0] && om
.start
.y
== sq
[1])
81 sq
= [om
.appear
[0].x
, om
.appear
[0].y
];
82 if (!this.isAttacked(sq
, color
))
83 delete attacked
[origSq
[0]+"_"+origSq
[1]];
85 V
.UndoOnBoard(this.board
, om
);
86 if (Object
.keys(attacked
).length
== 0)
87 // No need to explore more moves
95 // 3) Add mate-captures:
96 Object
.values(attacked
).forEach(sq
=> {
97 m
.vanish
.push(new PiPo({
101 p: this.getPiece(sq
[0], sq
[1])
109 // No "under check" conditions in castling
111 return super.getCastleMoves(sq
, "castleInCheck");
114 // TODO: allow pieces to "commit suicide"? (Currently yes except king)
116 // Remove moves which let the king mate-captured:
117 if (moves
.length
== 0) return [];
118 const color
= this.turn
;
119 const oppCol
= V
.GetOppCol(color
);
120 return moves
.filter(m
=> {
123 if (this.underCheck(color
)) {
125 const attacked
= this.kingPos
[color
];
126 // Try to find a move to escape check
127 // TODO: very inefficient method.
128 outerLoop: for (let i
=0; i
<V
.size
.x
; i
++) {
129 for (let j
=0; j
<V
.size
.y
; j
++) {
130 if (this.getColor(i
,j
) == color
) {
132 // Artficial turn change to "play twice":
134 switch (this.getPiece(i
, j
)) {
136 emoves
= this.getPotentialPawnMoves([i
, j
]);
139 emoves
= this.getPotentialRookMoves([i
, j
]);
142 emoves
= this.getPotentialKnightMoves([i
, j
]);
145 emoves
= this.getPotentialBishopMoves([i
, j
]);
148 emoves
= this.getPotentialQueenMoves([i
, j
]);
151 emoves
= this.getPotentialKingMoves([i
, j
]);
155 for (let em
of emoves
) {
156 V
.PlayOnBoard(this.board
, em
);
158 if (em
.start
.x
== attacked
[0] && em
.start
.y
== attacked
[1])
160 sq
= [em
.appear
[0].x
, em
.appear
[0].y
];
161 if (!this.isAttacked(sq
, oppCol
))
163 V
.UndoOnBoard(this.board
, em
);
165 // No need to explore more moves
178 super.postPlay(move);
179 if (move.vanish
.length
>= 2 && move.appear
.length
== 1) {
180 for (let i
= 1; i
<move.vanish
.length
; i
++) {
181 const v
= move.vanish
[i
];
182 // Did opponent king disappeared?
184 this.kingPos
[this.turn
] = [-1, -1];
186 else if (v
.p
== V
.ROOK
) {
187 if (v
.y
< this.INIT_COL_KING
[v
.c
])
188 this.castleFlags
[v
.c
][0] = 8;
190 // v.y > this.INIT_COL_KING[v.c]
191 this.castleFlags
[v
.c
][1] = 8;
199 const oppCol
= this.turn
;
200 if (move.vanish
.length
>= 2 && move.appear
.length
== 1) {
201 // Did opponent king disappeared?
202 const psq
= move.vanish
.find(v
=> v
.p
== V
.KING
&& v
.c
== oppCol
)
204 this.kingPos
[psq
.c
] = [psq
.x
, psq
.y
];
209 const color
= this.turn
;
210 const kp
= this.kingPos
[color
];
213 return color
== "w" ? "0-1" : "1-0";
214 if (this.atLeastOneMove()) return "*";
215 // Kings still there, no moves:
219 static get SEARCH_DEPTH() {
224 let notation
= super.getNotation(move);
225 // Add a capture mark (not describing what is captured...):
226 if (move.vanish
.length
> 1 && move.appear
.length
== 1) {
227 if (!!(notation
.match(/^[a-h]x/)))
228 // Pawn capture: remove initial "b" in bxc4 for example
229 notation
= notation
.substr(1);
230 notation
= notation
.replace("x","") + "X";