Commit | Line | Data |
---|---|---|
83cecc0f | 1 | import { ChessRules, Move, PiPo } from "@/base_rules"; |
0c3fe8a6 BA |
2 | import { ArrayFun } from "@/utils/array"; |
3 | import { sample, randInt } from "@/utils/alea"; | |
4 | ||
32f6285e | 5 | export class WildebeestRules extends ChessRules { |
7e8a7ea1 | 6 | |
6808d7a1 BA |
7 | static get size() { |
8 | return { x: 10, y: 11 }; | |
9 | } | |
8a196305 | 10 | |
6808d7a1 BA |
11 | static get CAMEL() { |
12 | return "c"; | |
13 | } | |
14 | static get WILDEBEEST() { | |
15 | return "w"; | |
16 | } | |
a37076f1 | 17 | |
6808d7a1 BA |
18 | static get PIECES() { |
19 | return ChessRules.PIECES.concat([V.CAMEL, V.WILDEBEEST]); | |
dac39588 | 20 | } |
7931e479 | 21 | |
6808d7a1 | 22 | static get steps() { |
dac39588 | 23 | return Object.assign( |
6f2f9437 BA |
24 | {}, |
25 | ChessRules.steps, | |
26 | // Add camel moves: | |
6808d7a1 BA |
27 | { |
28 | c: [ | |
29 | [-3, -1], | |
30 | [-3, 1], | |
31 | [-1, -3], | |
32 | [-1, 3], | |
33 | [1, -3], | |
34 | [1, 3], | |
35 | [3, -1], | |
36 | [3, 1] | |
37 | ] | |
38 | } | |
dac39588 BA |
39 | ); |
40 | } | |
a37076f1 | 41 | |
6808d7a1 | 42 | static IsGoodEnpassant(enpassant) { |
472c0c4f | 43 | if (enpassant != "-") return !!enpassant.match(/^([a-j][0-9]{1,2},?)+$/); |
dac39588 BA |
44 | return true; |
45 | } | |
6e62b1c7 | 46 | |
241bf8f2 BA |
47 | getPpath(b) { |
48 | return ([V.CAMEL, V.WILDEBEEST].includes(b[1]) ? "Wildebeest/" : "") + b; | |
49 | } | |
50 | ||
dac39588 | 51 | // There may be 2 enPassant squares (if pawn jump 3 squares) |
6808d7a1 | 52 | getEnpassantFen() { |
dac39588 | 53 | const L = this.epSquares.length; |
6808d7a1 | 54 | if (!this.epSquares[L - 1]) return "-"; //no en-passant |
dac39588 | 55 | let res = ""; |
6808d7a1 | 56 | this.epSquares[L - 1].forEach(sq => { |
dac39588 BA |
57 | res += V.CoordsToSquare(sq) + ","; |
58 | }); | |
6808d7a1 | 59 | return res.slice(0, -1); //remove last comma |
dac39588 | 60 | } |
2d7194bd | 61 | |
dac39588 | 62 | // En-passant after 2-sq or 3-sq jumps |
6808d7a1 BA |
63 | getEpSquare(moveOrSquare) { |
64 | if (!moveOrSquare) return undefined; | |
65 | if (typeof moveOrSquare === "string") { | |
dac39588 | 66 | const square = moveOrSquare; |
6808d7a1 | 67 | if (square == "-") return undefined; |
dac39588 BA |
68 | let res = []; |
69 | square.split(",").forEach(sq => { | |
70 | res.push(V.SquareToCoords(sq)); | |
71 | }); | |
72 | return res; | |
73 | } | |
74 | // Argument is a move: | |
75 | const move = moveOrSquare; | |
6808d7a1 BA |
76 | const [sx, sy, ex] = [move.start.x, move.start.y, move.end.x]; |
77 | if (this.getPiece(sx, sy) == V.PAWN && Math.abs(sx - ex) >= 2) { | |
78 | const step = (ex - sx) / Math.abs(ex - sx); | |
79 | let res = [ | |
80 | { | |
81 | x: sx + step, | |
82 | y: sy | |
83 | } | |
84 | ]; | |
85 | if (sx + 2 * step != ex) { | |
a538d4b0 | 86 | // 3-squares move |
dac39588 | 87 | res.push({ |
6808d7a1 | 88 | x: sx + 2 * step, |
dac39588 BA |
89 | y: sy |
90 | }); | |
91 | } | |
92 | return res; | |
93 | } | |
94 | return undefined; //default | |
95 | } | |
a37076f1 | 96 | |
6808d7a1 BA |
97 | getPotentialMovesFrom([x, y]) { |
98 | switch (this.getPiece(x, y)) { | |
dac39588 | 99 | case V.CAMEL: |
6808d7a1 | 100 | return this.getPotentialCamelMoves([x, y]); |
dac39588 | 101 | case V.WILDEBEEST: |
6808d7a1 | 102 | return this.getPotentialWildebeestMoves([x, y]); |
dac39588 | 103 | default: |
6808d7a1 | 104 | return super.getPotentialMovesFrom([x, y]); |
dac39588 BA |
105 | } |
106 | } | |
a37076f1 | 107 | |
dac39588 | 108 | // Pawns jump 2 or 3 squares, and promote to queen or wildebeest |
6808d7a1 | 109 | getPotentialPawnMoves([x, y]) { |
dac39588 BA |
110 | const color = this.turn; |
111 | let moves = []; | |
6808d7a1 BA |
112 | const [sizeX, sizeY] = [V.size.x, V.size.y]; |
113 | const shiftX = color == "w" ? -1 : 1; | |
114 | const startRanks = color == "w" ? [sizeX - 2, sizeX - 3] : [1, 2]; | |
278a28a1 BA |
115 | const lastRanks = color == "w" ? [0, 1] : [sizeX - 1, sizeX -2]; |
116 | let finalPieces = [V.PAWN]; | |
117 | if (x + shiftX == lastRanks[1]) | |
118 | Array.prototype.push.apply(finalPieces, [V.WILDEBEEST, V.QUEEN]); | |
119 | else if (x + shiftX == lastRanks[0]) | |
120 | finalPieces = [V.WILDEBEEST, V.QUEEN]; | |
a37076f1 | 121 | |
6808d7a1 | 122 | if (this.board[x + shiftX][y] == V.EMPTY) { |
dac39588 BA |
123 | // One square forward |
124 | for (let piece of finalPieces) | |
6808d7a1 BA |
125 | moves.push( |
126 | this.getBasicMove([x, y], [x + shiftX, y], { c: color, p: piece }) | |
127 | ); | |
128 | if (startRanks.includes(x)) { | |
129 | if (this.board[x + 2 * shiftX][y] == V.EMPTY) { | |
dac39588 | 130 | // Two squares jump |
6808d7a1 BA |
131 | moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y])); |
132 | if (x == startRanks[0] && this.board[x + 3 * shiftX][y] == V.EMPTY) { | |
dac39588 | 133 | // Three squares jump |
6808d7a1 | 134 | moves.push(this.getBasicMove([x, y], [x + 3 * shiftX, y])); |
dac39588 BA |
135 | } |
136 | } | |
137 | } | |
138 | } | |
139 | // Captures | |
6808d7a1 BA |
140 | for (let shiftY of [-1, 1]) { |
141 | if ( | |
142 | y + shiftY >= 0 && | |
143 | y + shiftY < sizeY && | |
144 | this.board[x + shiftX][y + shiftY] != V.EMPTY && | |
145 | this.canTake([x, y], [x + shiftX, y + shiftY]) | |
146 | ) { | |
147 | for (let piece of finalPieces) { | |
148 | moves.push( | |
149 | this.getBasicMove([x, y], [x + shiftX, y + shiftY], { | |
150 | c: color, | |
151 | p: piece | |
152 | }) | |
153 | ); | |
dac39588 BA |
154 | } |
155 | } | |
156 | } | |
a37076f1 | 157 | |
dac39588 BA |
158 | // En passant |
159 | const Lep = this.epSquares.length; | |
6808d7a1 | 160 | const epSquare = this.epSquares[Lep - 1]; |
472c0c4f | 161 | if (!!epSquare) { |
6808d7a1 | 162 | for (let epsq of epSquare) { |
dac39588 | 163 | // TODO: some redundant checks |
6808d7a1 | 164 | if (epsq.x == x + shiftX && Math.abs(epsq.y - y) == 1) { |
f52671e5 | 165 | let enpassantMove = this.getBasicMove([x, y], [epsq.x, epsq.y]); |
dac39588 BA |
166 | // WARNING: the captured pawn may be diagonally behind us, |
167 | // if it's a 3-squares jump and we take on 1st passing square | |
6808d7a1 | 168 | const px = this.board[x][epsq.y] != V.EMPTY ? x : x - shiftX; |
dac39588 BA |
169 | enpassantMove.vanish.push({ |
170 | x: px, | |
171 | y: epsq.y, | |
6808d7a1 BA |
172 | p: "p", |
173 | c: this.getColor(px, epsq.y) | |
dac39588 BA |
174 | }); |
175 | moves.push(enpassantMove); | |
176 | } | |
177 | } | |
178 | } | |
a37076f1 | 179 | |
dac39588 BA |
180 | return moves; |
181 | } | |
a37076f1 | 182 | |
6808d7a1 | 183 | getPotentialCamelMoves(sq) { |
4313762d | 184 | return this.getSlideNJumpMoves(sq, V.steps[V.CAMEL], 1); |
dac39588 | 185 | } |
a37076f1 | 186 | |
6808d7a1 | 187 | getPotentialWildebeestMoves(sq) { |
dac39588 | 188 | return this.getSlideNJumpMoves( |
4313762d | 189 | sq, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), 1); |
dac39588 | 190 | } |
a37076f1 | 191 | |
83cecc0f BA |
192 | getPPpath(m) { |
193 | if ( | |
194 | m.appear.length == 2 && m.vanish.length == 2 && | |
195 | Math.abs(m.end.y - m.start.y) == 1 && | |
196 | this.board[m.end.x][m.end.y] == V.EMPTY | |
197 | ) { | |
198 | // Castle, king moved by one square only, not directly onto rook | |
199 | return "Wildebeest/castle"; | |
200 | } | |
201 | return super.getPPpath(m); | |
202 | } | |
203 | ||
204 | // Special Wildebeest castling rules: | |
205 | getCastleMoves([x, y]) { | |
206 | const c = this.getColor(x, y); | |
207 | const oppCol = V.GetOppCol(c); | |
208 | let moves = []; | |
209 | let i = 0; | |
210 | const castlingKing = this.board[x][y].charAt(1); | |
211 | castlingCheck: for ( | |
212 | let castleSide = 0; | |
213 | castleSide < 2; | |
214 | castleSide++ //"large", then "small" | |
215 | ) { | |
216 | if (this.castleFlags[c][castleSide] >= V.size.y) continue; | |
217 | // Rook and king are on initial position | |
218 | const rookPos = this.castleFlags[c][castleSide]; | |
219 | const range = (castleSide == 0 ? [rookPos, y] : [y, rookPos]); | |
220 | ||
221 | // King and rook must be connected: | |
222 | for (let i = range[0] + 1; i <= range[1] - 1; i++) { | |
223 | if (this.board[x][i] != V.EMPTY) continue castlingCheck; | |
224 | } | |
225 | const step = 2 * castleSide - 1; | |
226 | // No attacks on the path of the king ? | |
227 | for (let i = range[0]; i <= range[1]; i++) { | |
228 | if (i != rookPos && this.isAttacked([x, i], oppCol)) | |
229 | continue castlingCheck; | |
a538d4b0 BA |
230 | if ( |
231 | i != y && | |
232 | // Do not end in the corner, except if starting square is too near | |
233 | (i > 0 || y == 1) && | |
234 | (i < V.size.y - 1 || y == V.size.y - 2) | |
235 | ) { | |
83cecc0f BA |
236 | // Found a possible castle move: |
237 | moves.push( | |
238 | new Move({ | |
239 | appear: [ | |
240 | new PiPo({ | |
241 | x: x, | |
242 | y: i, | |
243 | p: V.KING, | |
244 | c: c | |
245 | }), | |
246 | new PiPo({ | |
247 | x: x, | |
248 | y: i - step, | |
249 | p: V.ROOK, | |
250 | c: c | |
251 | }) | |
252 | ], | |
253 | vanish: [ | |
254 | new PiPo({ x: x, y: y, p: V.KING, c: c }), | |
255 | new PiPo({ x: x, y: rookPos, p: V.ROOK, c: c }) | |
256 | ] | |
257 | }) | |
258 | ); | |
259 | } | |
260 | } | |
261 | } | |
262 | ||
263 | return moves; | |
264 | } | |
265 | ||
68e19a44 | 266 | isAttacked(sq, color) { |
6808d7a1 | 267 | return ( |
68e19a44 BA |
268 | super.isAttacked(sq, color) || |
269 | this.isAttackedByCamel(sq, color) || | |
270 | this.isAttackedByWildebeest(sq, color) | |
6808d7a1 | 271 | ); |
dac39588 | 272 | } |
a37076f1 | 273 | |
68e19a44 | 274 | isAttackedByCamel(sq, color) { |
6808d7a1 | 275 | return this.isAttackedBySlideNJump( |
4313762d | 276 | sq, color, V.CAMEL, V.steps[V.CAMEL], 1); |
dac39588 | 277 | } |
a37076f1 | 278 | |
68e19a44 | 279 | isAttackedByWildebeest(sq, color) { |
6808d7a1 | 280 | return this.isAttackedBySlideNJump( |
4313762d | 281 | sq, color, V.WILDEBEEST, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), 1); |
dac39588 | 282 | } |
a37076f1 | 283 | |
6808d7a1 | 284 | getCurrentScore() { |
bb688df5 | 285 | if (this.atLeastOneMove()) return "*"; |
dac39588 | 286 | // No valid move: game is lost (stalemate is a win) |
6808d7a1 | 287 | return this.turn == "w" ? "0-1" : "1-0"; |
dac39588 | 288 | } |
efb20746 | 289 | |
dac39588 BA |
290 | static get VALUES() { |
291 | return Object.assign( | |
a97bdbda BA |
292 | { c: 3, w: 7 }, //experimental |
293 | ChessRules.VALUES | |
dac39588 BA |
294 | ); |
295 | } | |
a37076f1 | 296 | |
6808d7a1 BA |
297 | static get SEARCH_DEPTH() { |
298 | return 2; | |
299 | } | |
3c09dc49 | 300 | |
4313762d BA |
301 | static GenRandInitFen(options) { |
302 | if (options.randomness == 0) { | |
2c5d7b20 BA |
303 | return ( |
304 | "rnccwkqbbnr/ppppppppppp/92/92/92/92/92/92/PPPPPPPPPPP/RNBBQKWCCNR " + | |
305 | "w 0 akak -" | |
306 | ); | |
307 | } | |
7ba4a5bc | 308 | |
6f2f9437 | 309 | let pieces = { w: new Array(11), b: new Array(11) }; |
3a2a7b5f | 310 | let flags = ""; |
6808d7a1 | 311 | for (let c of ["w", "b"]) { |
4313762d | 312 | if (c == 'b' && options.randomness == 1) { |
7ba4a5bc | 313 | pieces['b'] = pieces['w']; |
3a2a7b5f | 314 | flags += flags; |
7ba4a5bc BA |
315 | break; |
316 | } | |
317 | ||
dac39588 | 318 | let positions = ArrayFun.range(11); |
a37076f1 | 319 | |
dac39588 | 320 | // Get random squares for bishops + camels (different colors) |
6808d7a1 BA |
321 | let randIndexes = sample(ArrayFun.range(6), 2).map(i => { |
322 | return 2 * i; | |
323 | }); | |
dac39588 BA |
324 | let bishop1Pos = positions[randIndexes[0]]; |
325 | let camel1Pos = positions[randIndexes[1]]; | |
326 | // The second bishop (camel) must be on a square of different color | |
6808d7a1 BA |
327 | let randIndexes_tmp = sample(ArrayFun.range(5), 2).map(i => { |
328 | return 2 * i + 1; | |
329 | }); | |
dac39588 BA |
330 | let bishop2Pos = positions[randIndexes_tmp[0]]; |
331 | let camel2Pos = positions[randIndexes_tmp[1]]; | |
6808d7a1 BA |
332 | for (let idx of randIndexes.concat(randIndexes_tmp).sort((a, b) => { |
333 | return b - a; | |
334 | })) { | |
7ba4a5bc | 335 | // Largest indices first |
dac39588 BA |
336 | positions.splice(idx, 1); |
337 | } | |
a37076f1 | 338 | |
dac39588 BA |
339 | let randIndex = randInt(7); |
340 | let knight1Pos = positions[randIndex]; | |
341 | positions.splice(randIndex, 1); | |
342 | randIndex = randInt(6); | |
343 | let knight2Pos = positions[randIndex]; | |
344 | positions.splice(randIndex, 1); | |
a37076f1 | 345 | |
dac39588 BA |
346 | randIndex = randInt(5); |
347 | let queenPos = positions[randIndex]; | |
348 | positions.splice(randIndex, 1); | |
8a196305 | 349 | |
dac39588 BA |
350 | // Random square for wildebeest |
351 | randIndex = randInt(4); | |
352 | let wildebeestPos = positions[randIndex]; | |
353 | positions.splice(randIndex, 1); | |
8a196305 | 354 | |
dac39588 BA |
355 | let rook1Pos = positions[0]; |
356 | let kingPos = positions[1]; | |
357 | let rook2Pos = positions[2]; | |
a37076f1 | 358 | |
6808d7a1 BA |
359 | pieces[c][rook1Pos] = "r"; |
360 | pieces[c][knight1Pos] = "n"; | |
361 | pieces[c][bishop1Pos] = "b"; | |
362 | pieces[c][queenPos] = "q"; | |
363 | pieces[c][camel1Pos] = "c"; | |
364 | pieces[c][camel2Pos] = "c"; | |
365 | pieces[c][wildebeestPos] = "w"; | |
366 | pieces[c][kingPos] = "k"; | |
367 | pieces[c][bishop2Pos] = "b"; | |
368 | pieces[c][knight2Pos] = "n"; | |
369 | pieces[c][rook2Pos] = "r"; | |
3a2a7b5f | 370 | flags += V.CoordToColumn(rook1Pos) + V.CoordToColumn(rook2Pos); |
dac39588 | 371 | } |
6808d7a1 BA |
372 | return ( |
373 | pieces["b"].join("") + | |
6f2f9437 | 374 | "/ppppppppppp/92/92/92/92/92/92/PPPPPPPPPPP/" + |
dac39588 | 375 | pieces["w"].join("").toUpperCase() + |
3a2a7b5f | 376 | " w 0 " + flags + " -" |
6808d7a1 | 377 | ); |
dac39588 | 378 | } |
7e8a7ea1 | 379 | |
6808d7a1 | 380 | }; |