1 import { ChessRules
, PiPo
, Move
} from "@/base_rules";
3 export class Allmate1Rules
extends ChessRules
{
5 static get HasEnpassant() {
14 static GenRandInitFen(randomness
) {
15 return ChessRules
.GenRandInitFen(randomness
).slice(0, -2);
18 getPotentialMovesFrom([x
, y
]) {
19 let moves
= super.getPotentialMovesFrom([x
, y
]);
20 // Remove standard captures (without removing castling):
21 moves
= moves
.filter(m
=> {
22 return m
.vanish
.length
== 1 || m
.appear
.length
== 2;
25 // Augment moves with "mate-captures":
26 // TODO: this is coded in a highly inefficient way...
27 const color
= this.turn
;
28 const oppCol
= V
.GetOppCol(this.turn
);
33 // While something has been captured:
34 // remove it, and keep looking for captures
35 outerLoop: while (true) {
37 // 1) What is attacked?
39 for (let i
=0; i
<V
.size
.x
; i
++) {
40 for (let j
=0; j
<V
.size
.y
; j
++) {
41 if (this.getColor(i
,j
) == oppCol
&& this.isAttacked([i
,j
], color
))
42 attacked
[i
+"_"+j
] = [i
,j
];
45 if (Object
.keys(attacked
).length
== 0) break outerLoop
;
47 // 2) Among attacked pieces, which cannot escape capture?
48 // Avoid "oppMoves = this.getAllValidMoves();" => infinite recursion
49 for (let i
=0; i
<V
.size
.x
; i
++) {
50 for (let j
=0; j
<V
.size
.y
; j
++) {
51 if (this.getColor(i
,j
) == oppCol
) {
53 switch (this.getPiece(i
, j
)) {
55 oppMoves
= this.getPotentialPawnMoves([i
, j
]);
58 oppMoves
= this.getPotentialRookMoves([i
, j
]);
61 oppMoves
= this.getPotentialKnightMoves([i
, j
]);
64 oppMoves
= this.getPotentialBishopMoves([i
, j
]);
67 oppMoves
= this.getPotentialQueenMoves([i
, j
]);
70 // Do not allow castling to escape from check
71 oppMoves
= super.getSlideNJumpMoves(
73 V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
]),
78 for (let om
of oppMoves
) {
79 V
.PlayOnBoard(this.board
, om
);
80 Object
.values(attacked
).forEach(sq
=> {
81 const origSq
= [sq
[0], sq
[1]];
82 if (om
.start
.x
== sq
[0] && om
.start
.y
== sq
[1])
84 sq
= [om
.appear
[0].x
, om
.appear
[0].y
];
85 if (!this.isAttacked(sq
, color
))
86 delete attacked
[origSq
[0]+"_"+origSq
[1]];
88 V
.UndoOnBoard(this.board
, om
);
89 if (Object
.keys(attacked
).length
== 0)
90 // No need to explore more moves
97 // 3) Add mate-captures and remove pieces from board:
98 Object
.keys(attacked
).forEach(k
=> {
101 p: this.getPiece(attacked
[k
][0], attacked
[k
][1])
103 this.board
[attacked
[k
][0]][attacked
[k
][1]] = V
.EMPTY
;
107 // Put removed pieces back on board:
108 allAttacks
.forEach(v
=> {
109 this.board
[v
.sq
[0]][v
.sq
[1]] = oppCol
+ v
.p
;
112 allAttacks
.forEach(v
=> {
127 // No "under check" conditions in castling
129 return super.getCastleMoves(sq
, null, "castleInCheck");
132 // TODO: allow pieces to "commit suicide"? (Currently yes except king)
134 // Remove moves which let the king mate-captured:
135 if (moves
.length
== 0) return [];
136 const color
= this.turn
;
137 const oppCol
= V
.GetOppCol(color
);
138 return moves
.filter(m
=> {
141 if (this.underCheck(color
)) {
143 const attacked
= this.kingPos
[color
];
144 // Try to find a move to escape check
145 // TODO: very inefficient method.
146 outerLoop: for (let i
=0; i
<V
.size
.x
; i
++) {
147 for (let j
=0; j
<V
.size
.y
; j
++) {
148 if (this.getColor(i
,j
) == color
) {
150 // Artficial turn change to "play twice":
152 switch (this.getPiece(i
, j
)) {
154 emoves
= this.getPotentialPawnMoves([i
, j
]);
157 emoves
= this.getPotentialRookMoves([i
, j
]);
160 emoves
= this.getPotentialKnightMoves([i
, j
]);
163 emoves
= this.getPotentialBishopMoves([i
, j
]);
166 emoves
= this.getPotentialQueenMoves([i
, j
]);
169 emoves
= this.getPotentialKingMoves([i
, j
]);
173 for (let em
of emoves
) {
174 V
.PlayOnBoard(this.board
, em
);
176 if (em
.start
.x
== attacked
[0] && em
.start
.y
== attacked
[1])
178 sq
= [em
.appear
[0].x
, em
.appear
[0].y
];
179 if (!this.isAttacked(sq
, oppCol
))
181 V
.UndoOnBoard(this.board
, em
);
183 // No need to explore more moves
196 super.postPlay(move);
197 if (move.vanish
.length
>= 2 && move.appear
.length
== 1) {
198 for (let i
= 1; i
<move.vanish
.length
; i
++) {
199 const v
= move.vanish
[i
];
200 // Did opponent king disappeared?
202 this.kingPos
[this.turn
] = [-1, -1];
204 else if (v
.p
== V
.ROOK
) {
205 if (v
.y
< this.kingPos
[v
.c
][1])
206 this.castleFlags
[v
.c
][0] = 8;
208 // v.y > this.kingPos[v.c][1]
209 this.castleFlags
[v
.c
][1] = 8;
217 const oppCol
= this.turn
;
218 if (move.vanish
.length
>= 2 && move.appear
.length
== 1) {
219 // Did opponent king disappeared?
220 const psq
= move.vanish
.find(v
=> v
.p
== V
.KING
&& v
.c
== oppCol
)
222 this.kingPos
[psq
.c
] = [psq
.x
, psq
.y
];
227 const color
= this.turn
;
228 const kp
= this.kingPos
[color
];
231 return color
== "w" ? "0-1" : "1-0";
232 if (this.atLeastOneMove()) return "*";
233 // Kings still there, no moves:
237 static get SEARCH_DEPTH() {
242 let notation
= super.getNotation(move);
243 // Add a capture mark (not describing what is captured...):
244 if (move.vanish
.length
> 1 && move.appear
.length
== 1) {
245 if (!!(notation
.match(/^[a-h]x/)))
246 // Pawn capture: remove initial "b" in bxc4 for example
247 notation
= notation
.substr(1);
248 notation
= notation
.replace("x","") + "X";