15e629a4024f9e42c30d3918e6f16bbdb080d213
1 import { ChessRules
} from "@/base_rules";
2 import { ArrayFun
} from "@/utils/array";
4 // NOTE: alternative implementation, probably cleaner = use only 1 board
5 // TODO? atLeastOneMove() would be more efficient if rewritten here
6 // (less sideBoard computations)
7 export class AliceRules
extends ChessRules
{
8 static get ALICE_PIECES() {
18 static get ALICE_CODES() {
30 return ChessRules
.PIECES
.concat(Object
.keys(V
.ALICE_PIECES
));
34 return (Object
.keys(V
.ALICE_PIECES
).includes(b
[1]) ? "Alice/" : "") + b
;
37 getEpSquare(moveOrSquare
) {
38 if (!moveOrSquare
) return undefined;
39 if (typeof moveOrSquare
=== "string") {
40 const square
= moveOrSquare
;
41 if (square
== "-") return undefined;
42 return V
.SquareToCoords(square
);
44 // Argument is a move:
45 const move = moveOrSquare
;
50 Math
.abs(s
.x
- e
.x
) == 2 &&
51 // Special conditions: a pawn can be on the other side
52 ['p','s'].includes(move.appear
[0].p
) &&
53 ['p','s'].includes(move.vanish
[0].p
)
60 return undefined; //default
63 setOtherVariables(fen
) {
64 super.setOtherVariables(fen
);
65 const rows
= V
.ParseFen(fen
).position
.split("/");
66 if (this.kingPos
["w"][0] < 0 || this.kingPos
["b"][0] < 0) {
67 // INIT_COL_XXX won't be required if Alice kings are found
68 // (it means 'king moved')
69 for (let i
= 0; i
< rows
.length
; i
++) {
70 let k
= 0; //column index on board
71 for (let j
= 0; j
< rows
[i
].length
; j
++) {
72 switch (rows
[i
].charAt(j
)) {
74 this.kingPos
["b"] = [i
, k
];
77 this.kingPos
["w"] = [i
, k
];
80 const num
= parseInt(rows
[i
].charAt(j
));
81 if (!isNaN(num
)) k
+= num
- 1;
90 // Return the (standard) color+piece notation at a square for a board
91 getSquareOccupation(i
, j
, mirrorSide
) {
92 const piece
= this.getPiece(i
, j
);
93 if (mirrorSide
== 1 && Object
.keys(V
.ALICE_CODES
).includes(piece
))
94 return this.board
[i
][j
];
95 if (mirrorSide
== 2 && Object
.keys(V
.ALICE_PIECES
).includes(piece
))
96 return this.getColor(i
, j
) + V
.ALICE_PIECES
[piece
];
100 // Build board of the given (mirror)side
101 getSideBoard(mirrorSide
) {
102 // Build corresponding board from complete board
103 let sideBoard
= ArrayFun
.init(V
.size
.x
, V
.size
.y
, "");
104 for (let i
= 0; i
< V
.size
.x
; i
++) {
105 for (let j
= 0; j
< V
.size
.y
; j
++)
106 sideBoard
[i
][j
] = this.getSquareOccupation(i
, j
, mirrorSide
);
111 // NOTE: castle & enPassant
112 // https://www.chessvariants.com/other.dir/alice.html
113 getPotentialMovesFrom([x
, y
], sideBoard
) {
114 const pieces
= Object
.keys(V
.ALICE_CODES
);
115 const codes
= Object
.keys(V
.ALICE_PIECES
);
116 const mirrorSide
= pieces
.includes(this.getPiece(x
, y
)) ? 1 : 2;
117 if (!sideBoard
) sideBoard
= [this.getSideBoard(1), this.getSideBoard(2)];
118 const color
= this.getColor(x
, y
);
120 // Search valid moves on sideBoard
121 const saveBoard
= this.board
;
122 this.board
= sideBoard
[mirrorSide
- 1];
123 const moves
= super.getPotentialMovesFrom([x
, y
]).filter(m
=> {
124 // Filter out king moves which result in under-check position on
125 // current board (before mirror traversing)
126 let aprioriValid
= true;
127 if (m
.appear
[0].p
== V
.KING
) {
129 if (this.underCheck(color
, sideBoard
)) aprioriValid
= false;
134 this.board
= saveBoard
;
136 // Finally filter impossible moves
137 const res
= moves
.filter(m
=> {
138 if (m
.appear
.length
== 2) {
139 // Castle: appear[i] must be an empty square on the other board
140 for (let psq
of m
.appear
) {
142 this.getSquareOccupation(psq
.x
, psq
.y
, 3 - mirrorSide
) != V
.EMPTY
147 } else if (this.board
[m
.end
.x
][m
.end
.y
] != V
.EMPTY
) {
148 // Attempt to capture
149 const piece
= this.getPiece(m
.end
.x
, m
.end
.y
);
151 (mirrorSide
== 1 && codes
.includes(piece
)) ||
152 (mirrorSide
== 2 && pieces
.includes(piece
))
157 // If the move is computed on board1, m.appear change for Alice pieces.
158 if (mirrorSide
== 1) {
159 m
.appear
.forEach(psq
=> {
160 // forEach: castling taken into account
161 psq
.p
= V
.ALICE_CODES
[psq
.p
]; //goto board2
165 // Move on board2: mark vanishing pieces as Alice
166 m
.vanish
.forEach(psq
=> {
167 psq
.p
= V
.ALICE_CODES
[psq
.p
];
170 // Fix en-passant captures
172 m
.vanish
[0].p
== V
.PAWN
&&
173 m
.vanish
.length
== 2 &&
174 this.board
[m
.end
.x
][m
.end
.y
] == V
.EMPTY
176 m
.vanish
[1].c
= V
.GetOppCol(this.turn
);
177 const [epX
, epY
] = [m
.vanish
[1].x
, m
.vanish
[1].y
];
178 m
.vanish
[1].p
= this.getPiece(epX
, epY
);
185 filterValid(moves
, sideBoard
) {
186 if (moves
.length
== 0) return [];
187 if (!sideBoard
) sideBoard
= [this.getSideBoard(1), this.getSideBoard(2)];
188 const color
= this.turn
;
189 return moves
.filter(m
=> {
190 this.playSide(m
, sideBoard
); //no need to track flags
191 const res
= !this.underCheck(color
, sideBoard
);
192 this.undoSide(m
, sideBoard
);
198 const color
= this.turn
;
199 let potentialMoves
= [];
200 const sideBoard
= [this.getSideBoard(1), this.getSideBoard(2)];
201 for (var i
= 0; i
< V
.size
.x
; i
++) {
202 for (var j
= 0; j
< V
.size
.y
; j
++) {
203 if (this.board
[i
][j
] != V
.EMPTY
&& this.getColor(i
, j
) == color
) {
204 Array
.prototype.push
.apply(
206 this.getPotentialMovesFrom([i
, j
], sideBoard
)
211 return this.filterValid(potentialMoves
, sideBoard
);
214 // Play on sideboards [TODO: only one sideBoard required]
215 playSide(move, sideBoard
) {
216 const pieces
= Object
.keys(V
.ALICE_CODES
);
217 move.vanish
.forEach(psq
=> {
218 const mirrorSide
= pieces
.includes(psq
.p
) ? 1 : 2;
219 sideBoard
[mirrorSide
- 1][psq
.x
][psq
.y
] = V
.EMPTY
;
221 move.appear
.forEach(psq
=> {
222 const mirrorSide
= pieces
.includes(psq
.p
) ? 1 : 2;
223 const piece
= mirrorSide
== 1 ? psq
.p : V
.ALICE_PIECES
[psq
.p
];
224 sideBoard
[mirrorSide
- 1][psq
.x
][psq
.y
] = psq
.c
+ piece
;
225 if (piece
== V
.KING
) this.kingPos
[psq
.c
] = [psq
.x
, psq
.y
];
229 // Undo on sideboards
230 undoSide(move, sideBoard
) {
231 const pieces
= Object
.keys(V
.ALICE_CODES
);
232 move.appear
.forEach(psq
=> {
233 const mirrorSide
= pieces
.includes(psq
.p
) ? 1 : 2;
234 sideBoard
[mirrorSide
- 1][psq
.x
][psq
.y
] = V
.EMPTY
;
236 move.vanish
.forEach(psq
=> {
237 const mirrorSide
= pieces
.includes(psq
.p
) ? 1 : 2;
238 const piece
= mirrorSide
== 1 ? psq
.p : V
.ALICE_PIECES
[psq
.p
];
239 sideBoard
[mirrorSide
- 1][psq
.x
][psq
.y
] = psq
.c
+ piece
;
240 if (piece
== V
.KING
) this.kingPos
[psq
.c
] = [psq
.x
, psq
.y
];
244 // sideBoard: arg containing both boards (see getAllValidMoves())
245 underCheck(color
, sideBoard
) {
246 const kp
= this.kingPos
[color
];
247 const mirrorSide
= sideBoard
[0][kp
[0]][kp
[1]] != V
.EMPTY
? 1 : 2;
248 let saveBoard
= this.board
;
249 this.board
= sideBoard
[mirrorSide
- 1];
250 let res
= this.isAttacked(kp
, [V
.GetOppCol(color
)]);
251 this.board
= saveBoard
;
256 const color
= this.turn
;
257 const pieces
= Object
.keys(V
.ALICE_CODES
);
258 const kp
= this.kingPos
[color
];
259 const mirrorSide
= pieces
.includes(this.getPiece(kp
[0], kp
[1])) ? 1 : 2;
260 let sideBoard
= this.getSideBoard(mirrorSide
);
261 let saveBoard
= this.board
;
262 this.board
= sideBoard
;
263 let res
= this.isAttacked(this.kingPos
[color
], [V
.GetOppCol(color
)])
264 ? [JSON
.parse(JSON
.stringify(this.kingPos
[color
]))]
266 this.board
= saveBoard
;
271 super.postPlay(move); //standard king
272 const piece
= move.vanish
[0].p
;
273 const c
= move.vanish
[0].c
;
276 this.kingPos
[c
][0] = move.appear
[0].x
;
277 this.kingPos
[c
][1] = move.appear
[0].y
;
278 this.castleFlags
[c
] = [8, 8];
283 super.postUndo(move);
284 const c
= move.vanish
[0].c
;
285 if (move.vanish
[0].p
== "l")
286 this.kingPos
[c
] = [move.start
.x
, move.start
.y
];
290 if (this.atLeastOneMove()) return "*";
291 const pieces
= Object
.keys(V
.ALICE_CODES
);
292 const color
= this.turn
;
293 const kp
= this.kingPos
[color
];
294 const mirrorSide
= pieces
.includes(this.getPiece(kp
[0], kp
[1])) ? 1 : 2;
295 let sideBoard
= this.getSideBoard(mirrorSide
);
296 let saveBoard
= this.board
;
297 this.board
= sideBoard
;
299 if (!this.isAttacked(this.kingPos
[color
], [V
.GetOppCol(color
)]))
301 else res
= color
== "w" ? "0-1" : "1-0";
302 this.board
= saveBoard
;
306 static get VALUES() {
307 return Object
.assign(
320 static get SEARCH_DEPTH() {
325 if (move.appear
.length
== 2 && move.appear
[0].p
== V
.KING
) {
326 if (move.end
.y
< move.start
.y
) return "0-0-0";
330 const finalSquare
= V
.CoordsToSquare(move.end
);
331 const piece
= this.getPiece(move.start
.x
, move.start
.y
);
333 const captureMark
= move.vanish
.length
> move.appear
.length
? "x" : "";
335 if (["p", "s"].includes(piece
) && captureMark
.length
== 1)
336 pawnMark
= V
.CoordToColumn(move.start
.y
); //start column
338 // Piece or pawn movement
339 let notation
= piece
.toUpperCase() + pawnMark
+ captureMark
+ finalSquare
;
340 if (["s", "p"].includes(piece
) && !["s", "p"].includes(move.appear
[0].p
)) {
342 notation
+= "=" + move.appear
[0].p
.toUpperCase();