Commit | Line | Data |
---|---|---|
270968d6 | 1 | class AliceRules extends ChessRules |
5bfb0956 | 2 | { |
0cd8f2bd | 3 | static get ALICE_PIECES() |
5bfb0956 | 4 | { |
270968d6 BA |
5 | return { |
6 | 's': 'p', | |
7 | 't': 'q', | |
8 | 'u': 'r', | |
9 | 'c': 'b', | |
10 | 'o': 'n', | |
11 | 'l': 'k', | |
12 | }; | |
13 | } | |
14 | static get ALICE_CODES() | |
15 | { | |
16 | return { | |
17 | 'p': 's', | |
18 | 'q': 't', | |
19 | 'r': 'u', | |
20 | 'b': 'c', | |
21 | 'n': 'o', | |
22 | 'k': 'l', | |
23 | }; | |
5bfb0956 | 24 | } |
a3eb4cc5 | 25 | |
0cd8f2bd BA |
26 | static getPpath(b) |
27 | { | |
270968d6 | 28 | return (Object.keys(this.ALICE_PIECES).includes(b[1]) ? "Alice/" : "") + b; |
0cd8f2bd BA |
29 | } |
30 | ||
0b5fa571 BA |
31 | initVariables(fen) |
32 | { | |
33 | super.initVariables(fen); | |
34 | const fenParts = fen.split(" "); | |
35 | const position = fenParts[0].split("/"); | |
36 | if (this.kingPos["w"][0] < 0 || this.kingPos["b"][0] < 0) | |
37 | { | |
38 | // INIT_COL_XXX won't be used, so no need to set them for Alice kings | |
39 | for (let i=0; i<position.length; i++) | |
40 | { | |
41 | let k = 0; //column index on board | |
42 | for (let j=0; j<position[i].length; j++) | |
43 | { | |
44 | switch (position[i].charAt(j)) | |
45 | { | |
46 | case 'l': | |
47 | this.kingPos['b'] = [i,k]; | |
48 | break; | |
49 | case 'L': | |
50 | this.kingPos['w'] = [i,k]; | |
51 | break; | |
52 | default: | |
53 | let num = parseInt(position[i].charAt(j)); | |
54 | if (!isNaN(num)) | |
55 | k += (num-1); | |
56 | } | |
57 | k++; | |
58 | } | |
59 | } | |
60 | } | |
61 | } | |
62 | ||
270968d6 | 63 | getBoardOfPiece([x,y]) |
0cd8f2bd | 64 | { |
270968d6 BA |
65 | const V = VariantRules; |
66 | // Build board where the piece is | |
67 | const mirrorSide = (Object.keys(V.ALICE_CODES).includes(this.getPiece(x,y)) ? 1 : 2); | |
68 | // Build corresponding board from complete board | |
69 | const [sizeX,sizeY] = V.size; | |
70 | let sideBoard = doubleArray(sizeX, sizeY, ""); | |
0cd8f2bd BA |
71 | for (let i=0; i<sizeX; i++) |
72 | { | |
73 | for (let j=0; j<sizeY; j++) | |
74 | { | |
75 | const piece = this.getPiece(i,j); | |
270968d6 BA |
76 | if (mirrorSide==1 && Object.keys(V.ALICE_CODES).includes(piece)) |
77 | sideBoard[i][j] = this.board[i][j]; | |
78 | else if (mirrorSide==2 && Object.keys(V.ALICE_PIECES).includes(piece)) | |
79 | sideBoard[i][j] = this.getColor(i,j) + V.ALICE_PIECES[piece]; | |
0cd8f2bd BA |
80 | } |
81 | } | |
270968d6 BA |
82 | return sideBoard; |
83 | } | |
0cd8f2bd | 84 | |
0b5fa571 | 85 | // TODO: move board building one level up (findAllMoves()) to avoid re-building at every piece... |
55eb331d BA |
86 | // NOTE: castle & enPassant https://www.chessvariants.com/other.dir/alice.html |
87 | // --> Should be OK as is. | |
270968d6 BA |
88 | getPotentialMovesFrom([x,y]) |
89 | { | |
90 | let sideBoard = this.getBoardOfPiece([x,y]); | |
0cd8f2bd | 91 | |
270968d6 BA |
92 | // Search valid moves on sideBoard |
93 | let saveBoard = this.board; | |
94 | this.board = sideBoard; | |
95 | let moves = super.getPotentialMovesFrom([x,y]); | |
0cd8f2bd BA |
96 | this.board = saveBoard; |
97 | ||
06ddfe34 BA |
98 | const pieces = Object.keys(VariantRules.ALICE_CODES); |
99 | const codes = Object.keys(VariantRules.ALICE_PIECES); | |
100 | ||
0cd8f2bd | 101 | // Finally filter impossible moves |
06ddfe34 | 102 | const mirrorSide = (pieces.includes(this.getPiece(x,y)) ? 1 : 2); |
270968d6 | 103 | return moves.filter(m => { |
55eb331d | 104 | if (m.appear.length == 2) //castle |
270968d6 | 105 | { |
55eb331d BA |
106 | // If appear[i] not in vanish array, then must be empty square on other board |
107 | m.appear.forEach(psq => { | |
108 | if (this.board[psq.x][psq.y] != VariantRules.EMPTY && | |
109 | ![m.vanish[0].y,m.vanish[1].y].includes(psq.y)) | |
110 | { | |
111 | return false; | |
112 | } | |
113 | }); | |
114 | } | |
115 | else if (this.board[m.end.x][m.end.y] != VariantRules.EMPTY) | |
116 | { | |
117 | // Attempt to capture | |
270968d6 | 118 | const piece = this.getPiece(m.end.x,m.end.y); |
06ddfe34 BA |
119 | if ((mirrorSide==1 && codes.includes(piece)) |
120 | || (mirrorSide==2 && pieces.includes(piece))) | |
270968d6 BA |
121 | { |
122 | return false; | |
123 | } | |
124 | } | |
f6cc7faf BA |
125 | // If the move is computed on board1, m.appear change for Alice pieces. |
126 | if (mirrorSide==1) | |
127 | { | |
128 | m.appear.forEach(psq => { //forEach: castling taken into account | |
270968d6 | 129 | psq.p = VariantRules.ALICE_CODES[psq.p]; //goto board2 |
f6cc7faf BA |
130 | }); |
131 | } | |
0b5fa571 BA |
132 | else //move on board2: mark vanishing pieces as Alice |
133 | { | |
134 | m.vanish.forEach(psq => { | |
135 | psq.p = VariantRules.ALICE_CODES[psq.p]; | |
136 | }); | |
137 | } | |
9de73b71 BA |
138 | // Fix en-passant captures |
139 | if (m.vanish.length == 2 && this.board[m.end.x][m.end.y] == VariantRules.EMPTY) | |
06ddfe34 | 140 | { |
9de73b71 | 141 | m.vanish[1].c = this.getOppCol(this.getColor(x,y)); |
06ddfe34 BA |
142 | // In the special case of en-passant, if |
143 | // - board1 takes board2 : vanish[1] --> Alice | |
144 | // - board2 takes board1 : vanish[1] --> normal | |
145 | let van = m.vanish[1]; | |
146 | if (mirrorSide==1 && codes.includes(this.getPiece(van.x,van.y))) | |
147 | van.p = VariantRules.ALICE_CODES[van.p]; | |
148 | else if (mirrorSide==2 && pieces.includes(this.getPiece(van.x,van.y))) | |
149 | van.p = VariantRules.ALICE_PIECES[van.p]; | |
150 | } | |
270968d6 BA |
151 | return true; |
152 | }); | |
0cd8f2bd BA |
153 | } |
154 | ||
155 | underCheck(move) | |
156 | { | |
0cd8f2bd BA |
157 | const color = this.turn; |
158 | this.play(move); | |
270968d6 BA |
159 | let sideBoard = this.getBoardOfPiece(this.kingPos[color]); |
160 | let saveBoard = this.board; | |
161 | this.board = sideBoard; | |
0cd8f2bd | 162 | let res = this.isAttacked(this.kingPos[color], this.getOppCol(color)); |
270968d6 | 163 | this.board = saveBoard; |
0cd8f2bd BA |
164 | this.undo(move); |
165 | return res; | |
166 | } | |
167 | ||
270968d6 | 168 | getCheckSquares(move) |
0cd8f2bd | 169 | { |
270968d6 BA |
170 | this.play(move); |
171 | const color = this.turn; //opponent | |
172 | let sideBoard = this.getBoardOfPiece(this.kingPos[color]); | |
173 | let saveBoard = this.board; | |
174 | this.board = sideBoard; | |
175 | let res = this.isAttacked(this.kingPos[color], this.getOppCol(color)) | |
176 | ? [ JSON.parse(JSON.stringify(this.kingPos[color])) ] | |
177 | : [ ]; | |
178 | this.board = saveBoard; | |
179 | this.undo(move); | |
180 | return res; | |
0cd8f2bd | 181 | } |
270968d6 | 182 | |
0b5fa571 BA |
183 | updateVariables(move) |
184 | { | |
185 | super.updateVariables(move); //standard king | |
186 | const piece = this.getPiece(move.start.x,move.start.y); | |
187 | const c = this.getColor(move.start.x,move.start.y); | |
188 | // "l" = Alice king | |
189 | if (piece == "l") | |
190 | { | |
191 | this.kingPos[c][0] = move.appear[0].x; | |
192 | this.kingPos[c][1] = move.appear[0].y; | |
193 | this.castleFlags[c] = [false,false]; | |
194 | } | |
195 | } | |
196 | ||
197 | unupdateVariables(move) | |
198 | { | |
199 | super.unupdateVariables(move); | |
200 | const c = this.getColor(move.start.x,move.start.y); | |
201 | if (this.getPiece(move.start.x,move.start.y) == "l") | |
202 | this.kingPos[c] = [move.start.x, move.start.y]; | |
203 | } | |
204 | ||
0cd8f2bd BA |
205 | checkGameEnd() |
206 | { | |
207 | const color = this.turn; | |
270968d6 BA |
208 | let sideBoard = this.getBoardOfPiece(this.kingPos[color]); |
209 | let saveBoard = this.board; | |
210 | this.board = sideBoard; | |
211 | let res = "*"; | |
0cd8f2bd | 212 | if (!this.isAttacked(this.kingPos[color], this.getOppCol(color))) |
270968d6 BA |
213 | res = "1/2"; |
214 | else | |
215 | res = (color == "w" ? "0-1" : "1-0"); | |
216 | this.board = saveBoard; | |
217 | return res; | |
0cd8f2bd | 218 | } |
9de73b71 BA |
219 | |
220 | static get VALUES() { | |
221 | return { | |
222 | 'p': 1, | |
223 | 's': 1, | |
224 | 'r': 5, | |
225 | 'u': 5, | |
226 | 'n': 3, | |
227 | 'o': 3, | |
228 | 'b': 3, | |
229 | 'c': 3, | |
230 | 'q': 9, | |
231 | 't': 9, | |
232 | 'k': 1000, | |
233 | 'l': 1000 | |
234 | }; | |
235 | } | |
0f51ef98 BA |
236 | |
237 | getNotation(move) | |
238 | { | |
239 | if (move.appear.length == 2 && move.appear[0].p == VariantRules.KING) | |
240 | { | |
241 | if (move.end.y < move.start.y) | |
242 | return "0-0-0"; | |
243 | else | |
244 | return "0-0"; | |
245 | } | |
246 | ||
247 | const finalSquare = | |
248 | String.fromCharCode(97 + move.end.y) + (VariantRules.size[0]-move.end.x); | |
249 | const piece = this.getPiece(move.start.x, move.start.y); | |
250 | ||
251 | const captureMark = (move.vanish.length > move.appear.length ? "x" : ""); | |
252 | let pawnMark = ""; | |
253 | if (["p","s"].includes(piece) && captureMark.length == 1) | |
254 | pawnMark = String.fromCharCode(97 + move.start.y); //start column | |
255 | ||
256 | // Piece or pawn movement | |
257 | let notation = piece.toUpperCase() + pawnMark + captureMark + finalSquare; | |
258 | if (['s','p'].includes(piece) && !['s','p'].includes(move.appear[0].p)) | |
259 | { | |
260 | // Promotion | |
261 | notation += "=" + move.appear[0].p.toUpperCase(); | |
262 | } | |
263 | return notation; | |
264 | } | |
5bfb0956 | 265 | } |