Add temporary patch for preset challenges
[vchess.git] / client / src / variants / Alice.js
1 import { ChessRules } from "@/base_rules";
2 import { ArrayFun } from "@/utils/array";
3
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
9 static get ALICE_PIECES() {
10 return {
11 s: "p",
12 t: "q",
13 u: "r",
14 c: "b",
15 o: "n",
16 l: "k"
17 };
18 }
19 static get ALICE_CODES() {
20 return {
21 p: "s",
22 q: "t",
23 r: "u",
24 b: "c",
25 n: "o",
26 k: "l"
27 };
28 }
29
30 static get PIECES() {
31 return ChessRules.PIECES.concat(Object.keys(V.ALICE_PIECES));
32 }
33
34 getPpath(b) {
35 return (Object.keys(V.ALICE_PIECES).includes(b[1]) ? "Alice/" : "") + b;
36 }
37
38 getEpSquare(moveOrSquare) {
39 if (!moveOrSquare) return undefined;
40 if (typeof moveOrSquare === "string") {
41 const square = moveOrSquare;
42 if (square == "-") return undefined;
43 return V.SquareToCoords(square);
44 }
45 // Argument is a move:
46 const move = moveOrSquare;
47 const s = move.start,
48 e = move.end;
49 if (
50 s.y == e.y &&
51 Math.abs(s.x - e.x) == 2 &&
52 // Special conditions: a pawn can be on the other side
53 ['p','s'].includes(move.appear[0].p) &&
54 ['p','s'].includes(move.vanish[0].p)
55 ) {
56 return {
57 x: (s.x + e.x) / 2,
58 y: s.y
59 };
60 }
61 return undefined; //default
62 }
63
64 // king can be l or L (on the other mirror side)
65 static IsGoodPosition(position) {
66 if (position.length == 0) return false;
67 const rows = position.split("/");
68 if (rows.length != V.size.x) return false;
69 let kings = { "k": 0, "K": 0, 'l': 0, 'L': 0 };
70 for (let row of rows) {
71 let sumElts = 0;
72 for (let i = 0; i < row.length; i++) {
73 if (['K','k','L','l'].includes(row[i])) kings[row[i]]++;
74 if (V.PIECES.includes(row[i].toLowerCase())) sumElts++;
75 else {
76 const num = parseInt(row[i], 10);
77 if (isNaN(num)) return false;
78 sumElts += num;
79 }
80 }
81 if (sumElts != V.size.y) return false;
82 }
83 if (kings['k'] + kings['l'] != 1 || kings['K'] + kings['L'] != 1)
84 return false;
85 return true;
86 }
87
88 setOtherVariables(fen) {
89 super.setOtherVariables(fen);
90 const rows = V.ParseFen(fen).position.split("/");
91 if (this.kingPos["w"][0] < 0 || this.kingPos["b"][0] < 0) {
92 // INIT_COL_XXX won't be required if Alice kings are found
93 // (it means 'king moved')
94 for (let i = 0; i < rows.length; i++) {
95 let k = 0; //column index on board
96 for (let j = 0; j < rows[i].length; j++) {
97 switch (rows[i].charAt(j)) {
98 case "l":
99 this.kingPos["b"] = [i, k];
100 break;
101 case "L":
102 this.kingPos["w"] = [i, k];
103 break;
104 default: {
105 const num = parseInt(rows[i].charAt(j), 10);
106 if (!isNaN(num)) k += num - 1;
107 }
108 }
109 k++;
110 }
111 }
112 }
113 }
114
115 // Return the (standard) color+piece notation at a square for a board
116 getSquareOccupation(i, j, mirrorSide) {
117 const piece = this.getPiece(i, j);
118 if (mirrorSide == 1 && Object.keys(V.ALICE_CODES).includes(piece))
119 return this.board[i][j];
120 if (mirrorSide == 2 && Object.keys(V.ALICE_PIECES).includes(piece))
121 return this.getColor(i, j) + V.ALICE_PIECES[piece];
122 return "";
123 }
124
125 // Build board of the given (mirror)side
126 getSideBoard(mirrorSide) {
127 // Build corresponding board from complete board
128 let sideBoard = ArrayFun.init(V.size.x, V.size.y, "");
129 for (let i = 0; i < V.size.x; i++) {
130 for (let j = 0; j < V.size.y; j++)
131 sideBoard[i][j] = this.getSquareOccupation(i, j, mirrorSide);
132 }
133 return sideBoard;
134 }
135
136 // NOTE: castle & enPassant
137 // https://www.chessvariants.com/other.dir/alice.html
138 getPotentialMovesFrom([x, y], sideBoard) {
139 const pieces = Object.keys(V.ALICE_CODES);
140 const codes = Object.keys(V.ALICE_PIECES);
141 const mirrorSide = pieces.includes(this.getPiece(x, y)) ? 1 : 2;
142 if (!sideBoard) sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
143 const color = this.getColor(x, y);
144
145 // Search valid moves on sideBoard
146 const saveBoard = this.board;
147 this.board = sideBoard[mirrorSide - 1];
148 const moves = super.getPotentialMovesFrom([x, y]).filter(m => {
149 // Filter out king moves which result in under-check position on
150 // current board (before mirror traversing)
151 let aprioriValid = true;
152 if (m.appear[0].p == V.KING) {
153 this.play(m);
154 if (this.underCheck(color, sideBoard)) aprioriValid = false;
155 this.undo(m);
156 }
157 return aprioriValid;
158 });
159 this.board = saveBoard;
160
161 // Finally filter impossible moves
162 const res = moves.filter(m => {
163 if (m.appear.length == 2) {
164 // Castle: appear[i] must be an empty square on the other board
165 for (let psq of m.appear) {
166 if (
167 this.getSquareOccupation(psq.x, psq.y, 3 - mirrorSide) != V.EMPTY
168 ) {
169 return false;
170 }
171 }
172 }
173 else if (this.board[m.end.x][m.end.y] != V.EMPTY) {
174 // Attempt to capture
175 const piece = this.getPiece(m.end.x, m.end.y);
176 if (
177 (mirrorSide == 1 && codes.includes(piece)) ||
178 (mirrorSide == 2 && pieces.includes(piece))
179 ) {
180 return false;
181 }
182 }
183 // If the move is computed on board1, m.appear change for Alice pieces.
184 if (mirrorSide == 1) {
185 m.appear.forEach(psq => {
186 // forEach: castling taken into account
187 psq.p = V.ALICE_CODES[psq.p]; //goto board2
188 });
189 }
190 else {
191 // Move on board2: mark vanishing pieces as Alice
192 m.vanish.forEach(psq => {
193 psq.p = V.ALICE_CODES[psq.p];
194 });
195 }
196 // Fix en-passant captures
197 if (
198 m.vanish[0].p == V.PAWN &&
199 m.vanish.length == 2 &&
200 this.board[m.end.x][m.end.y] == V.EMPTY
201 ) {
202 m.vanish[1].c = V.GetOppCol(this.turn);
203 const [epX, epY] = [m.vanish[1].x, m.vanish[1].y];
204 m.vanish[1].p = this.getPiece(epX, epY);
205 }
206 return true;
207 });
208 return res;
209 }
210
211 filterValid(moves, sideBoard) {
212 if (moves.length == 0) return [];
213 if (!sideBoard) sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
214 const color = this.turn;
215 return moves.filter(m => {
216 this.playSide(m, sideBoard); //no need to track flags
217 const res = !this.underCheck(color, sideBoard);
218 this.undoSide(m, sideBoard);
219 return res;
220 });
221 }
222
223 getAllValidMoves() {
224 const color = this.turn;
225 let potentialMoves = [];
226 const sideBoard = [this.getSideBoard(1), this.getSideBoard(2)];
227 for (var i = 0; i < V.size.x; i++) {
228 for (var j = 0; j < V.size.y; j++) {
229 if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) {
230 Array.prototype.push.apply(
231 potentialMoves,
232 this.getPotentialMovesFrom([i, j], sideBoard)
233 );
234 }
235 }
236 }
237 return this.filterValid(potentialMoves, sideBoard);
238 }
239
240 // Play on sideboards [TODO: only one sideBoard required]
241 playSide(move, sideBoard) {
242 const pieces = Object.keys(V.ALICE_CODES);
243 move.vanish.forEach(psq => {
244 const mirrorSide = pieces.includes(psq.p) ? 1 : 2;
245 sideBoard[mirrorSide - 1][psq.x][psq.y] = V.EMPTY;
246 });
247 move.appear.forEach(psq => {
248 const mirrorSide = pieces.includes(psq.p) ? 1 : 2;
249 const piece = mirrorSide == 1 ? psq.p : V.ALICE_PIECES[psq.p];
250 sideBoard[mirrorSide - 1][psq.x][psq.y] = psq.c + piece;
251 if (piece == V.KING) this.kingPos[psq.c] = [psq.x, psq.y];
252 });
253 }
254
255 // Undo on sideboards
256 undoSide(move, sideBoard) {
257 const pieces = Object.keys(V.ALICE_CODES);
258 move.appear.forEach(psq => {
259 const mirrorSide = pieces.includes(psq.p) ? 1 : 2;
260 sideBoard[mirrorSide - 1][psq.x][psq.y] = V.EMPTY;
261 });
262 move.vanish.forEach(psq => {
263 const mirrorSide = pieces.includes(psq.p) ? 1 : 2;
264 const piece = mirrorSide == 1 ? psq.p : V.ALICE_PIECES[psq.p];
265 sideBoard[mirrorSide - 1][psq.x][psq.y] = psq.c + piece;
266 if (piece == V.KING) this.kingPos[psq.c] = [psq.x, psq.y];
267 });
268 }
269
270 // sideBoard: arg containing both boards (see getAllValidMoves())
271 underCheck(color, sideBoard) {
272 const kp = this.kingPos[color];
273 const mirrorSide = sideBoard[0][kp[0]][kp[1]] != V.EMPTY ? 1 : 2;
274 let saveBoard = this.board;
275 this.board = sideBoard[mirrorSide - 1];
276 let res = this.isAttacked(kp, [V.GetOppCol(color)]);
277 this.board = saveBoard;
278 return res;
279 }
280
281 getCheckSquares() {
282 const color = this.turn;
283 const pieces = Object.keys(V.ALICE_CODES);
284 const kp = this.kingPos[color];
285 const mirrorSide = pieces.includes(this.getPiece(kp[0], kp[1])) ? 1 : 2;
286 let sideBoard = this.getSideBoard(mirrorSide);
287 let saveBoard = this.board;
288 this.board = sideBoard;
289 let res = this.isAttacked(this.kingPos[color], [V.GetOppCol(color)])
290 ? [JSON.parse(JSON.stringify(this.kingPos[color]))]
291 : [];
292 this.board = saveBoard;
293 return res;
294 }
295
296 postPlay(move) {
297 super.postPlay(move); //standard king
298 const piece = move.vanish[0].p;
299 const c = move.vanish[0].c;
300 // "l" = Alice king
301 if (piece == "l") {
302 this.kingPos[c][0] = move.appear[0].x;
303 this.kingPos[c][1] = move.appear[0].y;
304 this.castleFlags[c] = [8, 8];
305 }
306 }
307
308 postUndo(move) {
309 super.postUndo(move);
310 const c = move.vanish[0].c;
311 if (move.vanish[0].p == "l")
312 this.kingPos[c] = [move.start.x, move.start.y];
313 }
314
315 getCurrentScore() {
316 if (this.atLeastOneMove()) return "*";
317 const pieces = Object.keys(V.ALICE_CODES);
318 const color = this.turn;
319 const kp = this.kingPos[color];
320 const mirrorSide = pieces.includes(this.getPiece(kp[0], kp[1])) ? 1 : 2;
321 let sideBoard = this.getSideBoard(mirrorSide);
322 let saveBoard = this.board;
323 this.board = sideBoard;
324 let res = "*";
325 if (!this.isAttacked(this.kingPos[color], [V.GetOppCol(color)]))
326 res = "1/2";
327 else res = color == "w" ? "0-1" : "1-0";
328 this.board = saveBoard;
329 return res;
330 }
331
332 static get VALUES() {
333 return Object.assign(
334 {
335 s: 1,
336 u: 5,
337 o: 3,
338 c: 3,
339 t: 9,
340 l: 1000
341 },
342 ChessRules.VALUES
343 );
344 }
345
346 static get SEARCH_DEPTH() {
347 return 2;
348 }
349
350 getNotation(move) {
351 if (move.appear.length == 2) {
352 if (move.end.y < move.start.y) return "0-0-0";
353 return "0-0";
354 }
355
356 const finalSquare = V.CoordsToSquare(move.end);
357 const piece = this.getPiece(move.start.x, move.start.y);
358
359 const captureMark = move.vanish.length > move.appear.length ? "x" : "";
360 let pawnMark = "";
361 if (["p", "s"].includes(piece) && captureMark.length == 1)
362 pawnMark = V.CoordToColumn(move.start.y); //start column
363
364 // Piece or pawn movement
365 let notation = piece.toUpperCase() + pawnMark + captureMark + finalSquare;
366 if (["s", "p"].includes(piece) && !["s", "p"].includes(move.appear[0].p))
367 // Promotion
368 notation += "=" + move.appear[0].p.toUpperCase();
369 return notation;
370 }
371
372 };