Commit | Line | Data |
---|---|---|
41534b92 BA |
1 | import { Random } from "/utils/alea.js"; |
2 | import { ArrayFun } from "/utils/array.js"; | |
3 | import PiPo from "/utils/PiPo.js"; | |
4 | import Move from "/utils/Move.js"; | |
5 | ||
6 | // NOTE: x coords: top to bottom (white perspective); y: left to right | |
cc2c7183 | 7 | // NOTE: ChessRules is aliased as window.C, and variants as window.V |
41534b92 BA |
8 | export default class ChessRules { |
9 | ||
e5f93427 | 10 | static get Aliases() { |
3caec36f | 11 | return {'C': ChessRules}; |
e5f93427 BA |
12 | } |
13 | ||
41534b92 BA |
14 | ///////////////////////// |
15 | // VARIANT SPECIFICATIONS | |
16 | ||
17 | // Some variants have specific options, like the number of pawns in Monster, | |
18 | // or the board size for Pandemonium. | |
19 | // Users can generally select a randomness level from 0 to 2. | |
20 | static get Options() { | |
21 | return { | |
41534b92 BA |
22 | select: [{ |
23 | label: "Randomness", | |
24 | variable: "randomness", | |
25 | defaut: 0, | |
26 | options: [ | |
b4ae3ff6 BA |
27 | {label: "Deterministic", value: 0}, |
28 | {label: "Symmetric random", value: 1}, | |
29 | {label: "Asymmetric random", value: 2} | |
41534b92 BA |
30 | ] |
31 | }], | |
f8b43ef7 BA |
32 | check: [ |
33 | { | |
34 | label: "Capture king", | |
35 | defaut: false, | |
36 | variable: "taking" | |
37 | }, | |
38 | { | |
39 | label: "Falling pawn", | |
40 | defaut: false, | |
41 | variable: "pawnfall" | |
42 | } | |
43 | ], | |
41534b92 BA |
44 | // Game modifiers (using "elementary variants"). Default: false |
45 | styles: [ | |
46 | "atomic", | |
47 | "balance", //takes precedence over doublemove & progressive | |
48 | "cannibal", | |
49 | "capture", | |
50 | "crazyhouse", | |
51 | "cylinder", //ok with all | |
52 | "dark", | |
53 | "doublemove", | |
54 | "madrasi", | |
55 | "progressive", //(natural) priority over doublemove | |
56 | "recycle", | |
57 | "rifle", | |
58 | "teleport", | |
59 | "zen" | |
60 | ] | |
61 | }; | |
62 | } | |
63 | ||
c9ab0340 BA |
64 | get pawnPromotions() { |
65 | return ['q', 'r', 'n', 'b']; | |
41534b92 BA |
66 | } |
67 | ||
68 | // Some variants don't have flags: | |
69 | get hasFlags() { | |
70 | return true; | |
71 | } | |
72 | // Or castle | |
73 | get hasCastle() { | |
74 | return this.hasFlags; | |
75 | } | |
76 | ||
77 | // En-passant captures allowed? | |
78 | get hasEnpassant() { | |
79 | return true; | |
80 | } | |
81 | ||
82 | get hasReserve() { | |
83 | return ( | |
84 | !!this.options["crazyhouse"] || | |
85 | (!!this.options["recycle"] && !this.options["teleport"]) | |
86 | ); | |
87 | } | |
88 | ||
89 | get noAnimate() { | |
90 | return !!this.options["dark"]; | |
91 | } | |
92 | ||
93 | // Some variants use click infos: | |
15106e82 BA |
94 | doClick(coords) { |
95 | if (typeof coords.x != "number") | |
b4ae3ff6 | 96 | return null; //click on reserves |
41534b92 | 97 | if ( |
cc2c7183 | 98 | this.options["teleport"] && this.subTurnTeleport == 2 && |
15106e82 | 99 | this.board[coords.x][coords.y] == "" |
41534b92 BA |
100 | ) { |
101 | return new Move({ | |
102 | start: {x: this.captured.x, y: this.captured.y}, | |
103 | appear: [ | |
104 | new PiPo({ | |
15106e82 BA |
105 | x: coords.x, |
106 | y: coords.y, | |
41534b92 BA |
107 | c: this.captured.c, //this.turn, |
108 | p: this.captured.p | |
109 | }) | |
110 | ], | |
15106e82 BA |
111 | vanish: [], |
112 | drag: {c: this.captured.c, p: this.captured.p} | |
41534b92 BA |
113 | }); |
114 | } | |
115 | return null; | |
116 | } | |
117 | ||
118 | //////////////////// | |
119 | // COORDINATES UTILS | |
120 | ||
15106e82 | 121 | // a3 --> {x:10, y:3} |
41534b92 | 122 | static SquareToCoords(sq) { |
15106e82 BA |
123 | return ArrayFun.toObject(["x", "y"], |
124 | [0, 1].map(i => parseInt(sq[i], 36))); | |
41534b92 BA |
125 | } |
126 | ||
15106e82 BA |
127 | // {x:1, y:12} --> 1c |
128 | static CoordsToSquare(cd) { | |
129 | return Object.values(cd).map(c => c.toString(36)).join(""); | |
41534b92 BA |
130 | } |
131 | ||
15106e82 BA |
132 | coordsToId(cd) { |
133 | if (typeof cd.x == "number") { | |
134 | return ( | |
135 | `${this.containerId}|sq-${cd.x.toString(36)}-${cd.y.toString(36)}` | |
136 | ); | |
137 | } | |
41534b92 | 138 | // Reserve : |
15106e82 | 139 | return `${this.containerId}|rsq-${cd.x}-${cd.y}`; |
41534b92 BA |
140 | } |
141 | ||
142 | idToCoords(targetId) { | |
b4ae3ff6 BA |
143 | if (!targetId) |
144 | return null; //outside page, maybe... | |
41534b92 BA |
145 | const idParts = targetId.split('|'); //prefix|sq-2-3 (start at 0 => 3,4) |
146 | if ( | |
147 | idParts.length < 2 || | |
148 | idParts[0] != this.containerId || | |
149 | !idParts[1].match(/sq-[0-9a-zA-Z]-[0-9a-zA-Z]/) | |
150 | ) { | |
151 | return null; | |
152 | } | |
153 | const squares = idParts[1].split('-'); | |
154 | if (squares[0] == "sq") | |
15106e82 BA |
155 | return {x: parseInt(squares[1], 36), y: parseInt(squares[2], 36)}; |
156 | // squares[0] == "rsq" : reserve, 'c' + 'p' (letters color & piece) | |
157 | return {x: squares[1], y: squares[2]}; | |
41534b92 BA |
158 | } |
159 | ||
160 | ///////////// | |
161 | // FEN UTILS | |
162 | ||
163 | // Turn "wb" into "B" (for FEN) | |
164 | board2fen(b) { | |
165 | return b[0] == "w" ? b[1].toUpperCase() : b[1]; | |
166 | } | |
167 | ||
168 | // Turn "p" into "bp" (for board) | |
169 | fen2board(f) { | |
170 | return f.charCodeAt(0) <= 90 ? "w" + f.toLowerCase() : "b" + f; | |
171 | } | |
172 | ||
173 | // Setup the initial random-or-not (asymmetric-or-not) position | |
174 | genRandInitFen(seed) { | |
175 | Random.setSeed(seed); | |
176 | ||
177 | let fen, flags = "0707"; | |
cc2c7183 | 178 | if (!this.options.randomness) |
41534b92 BA |
179 | // Deterministic: |
180 | fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w 0"; | |
181 | ||
182 | else { | |
183 | // Randomize | |
184 | let pieces = { w: new Array(8), b: new Array(8) }; | |
185 | flags = ""; | |
186 | // Shuffle pieces on first (and last rank if randomness == 2) | |
187 | for (let c of ["w", "b"]) { | |
188 | if (c == 'b' && this.options.randomness == 1) { | |
189 | pieces['b'] = pieces['w']; | |
190 | flags += flags; | |
191 | break; | |
192 | } | |
193 | ||
194 | let positions = ArrayFun.range(8); | |
195 | ||
196 | // Get random squares for bishops | |
197 | let randIndex = 2 * Random.randInt(4); | |
198 | const bishop1Pos = positions[randIndex]; | |
199 | // The second bishop must be on a square of different color | |
200 | let randIndex_tmp = 2 * Random.randInt(4) + 1; | |
201 | const bishop2Pos = positions[randIndex_tmp]; | |
202 | // Remove chosen squares | |
203 | positions.splice(Math.max(randIndex, randIndex_tmp), 1); | |
204 | positions.splice(Math.min(randIndex, randIndex_tmp), 1); | |
205 | ||
206 | // Get random squares for knights | |
207 | randIndex = Random.randInt(6); | |
208 | const knight1Pos = positions[randIndex]; | |
209 | positions.splice(randIndex, 1); | |
210 | randIndex = Random.randInt(5); | |
211 | const knight2Pos = positions[randIndex]; | |
212 | positions.splice(randIndex, 1); | |
213 | ||
214 | // Get random square for queen | |
215 | randIndex = Random.randInt(4); | |
216 | const queenPos = positions[randIndex]; | |
217 | positions.splice(randIndex, 1); | |
218 | ||
219 | // Rooks and king positions are now fixed, | |
220 | // because of the ordering rook-king-rook | |
221 | const rook1Pos = positions[0]; | |
222 | const kingPos = positions[1]; | |
223 | const rook2Pos = positions[2]; | |
224 | ||
225 | // Finally put the shuffled pieces in the board array | |
226 | pieces[c][rook1Pos] = "r"; | |
227 | pieces[c][knight1Pos] = "n"; | |
228 | pieces[c][bishop1Pos] = "b"; | |
229 | pieces[c][queenPos] = "q"; | |
230 | pieces[c][kingPos] = "k"; | |
231 | pieces[c][bishop2Pos] = "b"; | |
232 | pieces[c][knight2Pos] = "n"; | |
233 | pieces[c][rook2Pos] = "r"; | |
234 | flags += rook1Pos.toString() + rook2Pos.toString(); | |
235 | } | |
236 | fen = ( | |
237 | pieces["b"].join("") + | |
238 | "/pppppppp/8/8/8/8/PPPPPPPP/" + | |
239 | pieces["w"].join("").toUpperCase() + | |
240 | " w 0" | |
241 | ); | |
242 | } | |
243 | // Add turn + flags + enpassant (+ reserve) | |
244 | let parts = []; | |
b4ae3ff6 BA |
245 | if (this.hasFlags) |
246 | parts.push(`"flags":"${flags}"`); | |
247 | if (this.hasEnpassant) | |
248 | parts.push('"enpassant":"-"'); | |
249 | if (this.hasReserve) | |
250 | parts.push('"reserve":"000000000000"'); | |
251 | if (this.options["crazyhouse"]) | |
252 | parts.push('"ispawn":"-"'); | |
253 | if (parts.length >= 1) | |
254 | fen += " {" + parts.join(",") + "}"; | |
41534b92 BA |
255 | return fen; |
256 | } | |
257 | ||
258 | // "Parse" FEN: just return untransformed string data | |
259 | parseFen(fen) { | |
260 | const fenParts = fen.split(" "); | |
261 | let res = { | |
262 | position: fenParts[0], | |
263 | turn: fenParts[1], | |
264 | movesCount: fenParts[2] | |
265 | }; | |
b4ae3ff6 BA |
266 | if (fenParts.length > 3) |
267 | res = Object.assign(res, JSON.parse(fenParts[3])); | |
41534b92 BA |
268 | return res; |
269 | } | |
270 | ||
271 | // Return current fen (game state) | |
272 | getFen() { | |
273 | let fen = ( | |
15106e82 | 274 | this.getPosition() + " " + |
41534b92 BA |
275 | this.getTurnFen() + " " + |
276 | this.movesCount | |
277 | ); | |
278 | let parts = []; | |
b4ae3ff6 BA |
279 | if (this.hasFlags) |
280 | parts.push(`"flags":"${this.getFlagsFen()}"`); | |
41534b92 BA |
281 | if (this.hasEnpassant) |
282 | parts.push(`"enpassant":"${this.getEnpassantFen()}"`); | |
b4ae3ff6 BA |
283 | if (this.hasReserve) |
284 | parts.push(`"reserve":"${this.getReserveFen()}"`); | |
41534b92 BA |
285 | if (this.options["crazyhouse"]) |
286 | parts.push(`"ispawn":"${this.getIspawnFen()}"`); | |
b4ae3ff6 BA |
287 | if (parts.length >= 1) |
288 | fen += " {" + parts.join(",") + "}"; | |
41534b92 BA |
289 | return fen; |
290 | } | |
291 | ||
292 | // Position part of the FEN string | |
15106e82 | 293 | getPosition() { |
41534b92 BA |
294 | const format = (count) => { |
295 | // if more than 9 consecutive free spaces, break the integer, | |
296 | // otherwise FEN parsing will fail. | |
b4ae3ff6 BA |
297 | if (count <= 9) |
298 | return count; | |
41534b92 | 299 | // Most boards of size < 18: |
b4ae3ff6 BA |
300 | if (count <= 18) |
301 | return "9" + (count - 9); | |
41534b92 BA |
302 | // Except Gomoku: |
303 | return "99" + (count - 18); | |
304 | }; | |
305 | let position = ""; | |
306 | for (let i = 0; i < this.size.y; i++) { | |
307 | let emptyCount = 0; | |
308 | for (let j = 0; j < this.size.x; j++) { | |
b4ae3ff6 BA |
309 | if (this.board[i][j] == "") |
310 | emptyCount++; | |
41534b92 BA |
311 | else { |
312 | if (emptyCount > 0) { | |
313 | // Add empty squares in-between | |
314 | position += format(emptyCount); | |
315 | emptyCount = 0; | |
316 | } | |
317 | position += this.board2fen(this.board[i][j]); | |
318 | } | |
319 | } | |
320 | if (emptyCount > 0) | |
321 | // "Flush remainder" | |
322 | position += format(emptyCount); | |
b4ae3ff6 BA |
323 | if (i < this.size.y - 1) |
324 | position += "/"; //separate rows | |
41534b92 BA |
325 | } |
326 | return position; | |
327 | } | |
328 | ||
329 | getTurnFen() { | |
330 | return this.turn; | |
331 | } | |
332 | ||
333 | // Flags part of the FEN string | |
334 | getFlagsFen() { | |
335 | return ["w", "b"].map(c => { | |
15106e82 | 336 | return this.castleFlags[c].map(x => x.toString(36)).join(""); |
41534b92 BA |
337 | }).join(""); |
338 | } | |
339 | ||
340 | // Enpassant part of the FEN string | |
341 | getEnpassantFen() { | |
b4ae3ff6 BA |
342 | if (!this.epSquare) |
343 | return "-"; //no en-passant | |
cc2c7183 | 344 | return C.CoordsToSquare(this.epSquare); |
41534b92 BA |
345 | } |
346 | ||
347 | getReserveFen() { | |
348 | return ( | |
349 | ["w","b"].map(c => Object.values(this.reserve[c]).join("")).join("") | |
350 | ); | |
351 | } | |
352 | ||
353 | getIspawnFen() { | |
15106e82 BA |
354 | const squares = Object.keys(this.ispawn); |
355 | if (squares.length == 0) | |
b4ae3ff6 | 356 | return "-"; |
15106e82 | 357 | return squares.join(","); |
41534b92 BA |
358 | } |
359 | ||
360 | // Set flags from fen (castle: white a,h then black a,h) | |
361 | setFlags(fenflags) { | |
362 | this.castleFlags = { | |
15106e82 BA |
363 | w: [0, 1].map(i => parseInt(fenflags.charAt(i), 36)), |
364 | b: [2, 3].map(i => parseInt(fenflags.charAt(i), 36)) | |
41534b92 BA |
365 | }; |
366 | } | |
367 | ||
368 | ////////////////// | |
369 | // INITIALIZATION | |
370 | ||
41534b92 BA |
371 | constructor(o) { |
372 | this.options = o.options; | |
373 | this.playerColor = o.color; | |
15106e82 | 374 | this.afterPlay = o.afterPlay; //trigger some actions after playing a move |
41534b92 | 375 | |
c9ab0340 | 376 | // Fen string fully describes the game state |
b4ae3ff6 BA |
377 | if (!o.fen) |
378 | o.fen = this.genRandInitFen(o.seed); | |
41534b92 BA |
379 | const fenParsed = this.parseFen(o.fen); |
380 | this.board = this.getBoard(fenParsed.position); | |
381 | this.turn = fenParsed.turn; | |
382 | this.movesCount = parseInt(fenParsed.movesCount, 10); | |
383 | this.setOtherVariables(fenParsed); | |
384 | ||
385 | // Graphical (can use variables defined above) | |
386 | this.containerId = o.element; | |
387 | this.graphicalInit(); | |
388 | } | |
389 | ||
390 | // Turn position fen into double array ["wb","wp","bk",...] | |
391 | getBoard(position) { | |
392 | const rows = position.split("/"); | |
393 | let board = ArrayFun.init(this.size.x, this.size.y, ""); | |
394 | for (let i = 0; i < rows.length; i++) { | |
395 | let j = 0; | |
396 | for (let indexInRow = 0; indexInRow < rows[i].length; indexInRow++) { | |
397 | const character = rows[i][indexInRow]; | |
398 | const num = parseInt(character, 10); | |
399 | // If num is a number, just shift j: | |
b4ae3ff6 BA |
400 | if (!isNaN(num)) |
401 | j += num; | |
41534b92 | 402 | // Else: something at position i,j |
b4ae3ff6 BA |
403 | else |
404 | board[i][j++] = this.fen2board(character); | |
41534b92 BA |
405 | } |
406 | } | |
407 | return board; | |
408 | } | |
409 | ||
410 | // Some additional variables from FEN (variant dependant) | |
411 | setOtherVariables(fenParsed) { | |
412 | // Set flags and enpassant: | |
b4ae3ff6 BA |
413 | if (this.hasFlags) |
414 | this.setFlags(fenParsed.flags); | |
41534b92 BA |
415 | if (this.hasEnpassant) |
416 | this.epSquare = this.getEpSquare(fenParsed.enpassant); | |
b4ae3ff6 BA |
417 | if (this.hasReserve) |
418 | this.initReserves(fenParsed.reserve); | |
419 | if (this.options["crazyhouse"]) | |
420 | this.initIspawn(fenParsed.ispawn); | |
41534b92 | 421 | this.subTurn = 1; //may be unused |
cc2c7183 BA |
422 | if (this.options["teleport"]) { |
423 | this.subTurnTeleport = 1; | |
424 | this.captured = null; | |
425 | } | |
41534b92 | 426 | if (this.options["dark"]) { |
41534b92 | 427 | // Setup enlightened: squares reachable by player side |
c9ab0340 BA |
428 | this.enlightened = ArrayFun.init(this.size.x, this.size.y, false); |
429 | this.updateEnlightened(); | |
41534b92 BA |
430 | } |
431 | } | |
432 | ||
c9ab0340 BA |
433 | updateEnlightened() { |
434 | this.oldEnlightened = this.enlightened; | |
435 | this.enlightened = ArrayFun.init(this.size.x, this.size.y, false); | |
41534b92 | 436 | // Add pieces positions + all squares reachable by moves (includes Zen): |
41534b92 BA |
437 | for (let x=0; x<this.size.x; x++) { |
438 | for (let y=0; y<this.size.y; y++) { | |
439 | if (this.board[x][y] != "" && this.getColor(x, y) == this.playerColor) | |
440 | { | |
c9ab0340 | 441 | this.enlightened[x][y] = true; |
41534b92 | 442 | this.getPotentialMovesFrom([x, y]).forEach(m => { |
c9ab0340 | 443 | this.enlightened[m.end.x][m.end.y] = true; |
41534b92 BA |
444 | }); |
445 | } | |
446 | } | |
447 | } | |
b4ae3ff6 | 448 | if (this.epSquare) |
c9ab0340 | 449 | this.enlightEnpassant(); |
41534b92 BA |
450 | } |
451 | ||
c9ab0340 BA |
452 | // Include square of the en-passant capturing square: |
453 | enlightEnpassant() { | |
454 | // NOTE: shortcut, pawn has only one attack type, doesn't depend on square | |
455 | const steps = this.pieces(this.playerColor)["p"].attack[0].steps; | |
41534b92 BA |
456 | for (let step of steps) { |
457 | const x = this.epSquare.x - step[0], | |
458 | y = this.computeY(this.epSquare.y - step[1]); | |
459 | if ( | |
460 | this.onBoard(x, y) && | |
461 | this.getColor(x, y) == this.playerColor && | |
cc2c7183 | 462 | this.getPieceType(x, y) == "p" |
41534b92 | 463 | ) { |
c9ab0340 | 464 | this.enlightened[x][this.epSquare.y] = true; |
41534b92 BA |
465 | break; |
466 | } | |
467 | } | |
468 | } | |
469 | ||
c9ab0340 | 470 | // ordering as in pieces() p,r,n,b,q,k (+ count in base 30 if needed) |
41534b92 BA |
471 | initReserves(reserveStr) { |
472 | const counts = reserveStr.split("").map(c => parseInt(c, 30)); | |
473 | this.reserve = { w: {}, b: {} }; | |
c9ab0340 BA |
474 | const pieceName = ['p', 'r', 'n', 'b', 'q', 'k']; |
475 | const L = pieceName.length; | |
476 | for (let i of ArrayFun.range(2 * L)) { | |
477 | if (i < L) | |
b4ae3ff6 BA |
478 | this.reserve['w'][pieceName[i]] = counts[i]; |
479 | else | |
c9ab0340 | 480 | this.reserve['b'][pieceName[i-L]] = counts[i]; |
41534b92 BA |
481 | } |
482 | } | |
483 | ||
484 | initIspawn(ispawnStr) { | |
15106e82 BA |
485 | if (ispawnStr != "-") |
486 | this.ispawn = ArrayFun.toObject(ispawnStr.split(","), true); | |
b4ae3ff6 BA |
487 | else |
488 | this.ispawn = {}; | |
41534b92 BA |
489 | } |
490 | ||
491 | getNbReservePieces(color) { | |
492 | return ( | |
493 | Object.values(this.reserve[color]).reduce( | |
494 | (oldV,newV) => oldV + (newV > 0 ? 1 : 0), 0) | |
495 | ); | |
496 | } | |
497 | ||
15106e82 BA |
498 | getRankInReserve(c, p) { |
499 | const pieces = Object.keys(this.pieces()); | |
500 | const lastIndex = pieces.findIndex(pp => pp == p) | |
501 | let toTest = pieces.slice(0, lastIndex); | |
502 | return toTest.reduce( | |
503 | (oldV,newV) => oldV + (this.reserve[c][newV] > 0 ? 1 : 0), 0); | |
504 | } | |
505 | ||
41534b92 BA |
506 | ////////////// |
507 | // VISUAL PART | |
508 | ||
509 | getPieceWidth(rwidth) { | |
510 | return (rwidth / this.size.y); | |
511 | } | |
512 | ||
41534b92 | 513 | getReserveSquareSize(rwidth, nbR) { |
15106e82 | 514 | const sqSize = this.getPieceWidth(rwidth); |
41534b92 BA |
515 | return Math.min(sqSize, rwidth / nbR); |
516 | } | |
517 | ||
518 | getReserveNumId(color, piece) { | |
519 | return `${this.containerId}|rnum-${color}${piece}`; | |
520 | } | |
521 | ||
522 | graphicalInit() { | |
523 | // NOTE: not window.onresize = this.re_drawBoardElts because scope (this) | |
524 | window.onresize = () => this.re_drawBoardElements(); | |
525 | this.re_drawBoardElements(); | |
526 | this.initMouseEvents(); | |
3c61449b BA |
527 | const chessboard = |
528 | document.getElementById(this.containerId).querySelector(".chessboard"); | |
529 | new ResizeObserver(this.rescale).observe(chessboard); | |
41534b92 BA |
530 | } |
531 | ||
532 | re_drawBoardElements() { | |
533 | const board = this.getSvgChessboard(); | |
cc2c7183 | 534 | const oppCol = C.GetOppCol(this.playerColor); |
3c61449b BA |
535 | let chessboard = |
536 | document.getElementById(this.containerId).querySelector(".chessboard"); | |
537 | chessboard.innerHTML = ""; | |
538 | chessboard.insertAdjacentHTML('beforeend', board); | |
41534b92 BA |
539 | // Compare window ratio width / height to aspectRatio: |
540 | const windowRatio = window.innerWidth / window.innerHeight; | |
541 | let cbWidth, cbHeight; | |
15106e82 | 542 | if (windowRatio <= this.size.ratio) { |
41534b92 BA |
543 | // Limiting dimension is width: |
544 | cbWidth = Math.min(window.innerWidth, 767); | |
15106e82 | 545 | cbHeight = cbWidth / this.size.ratio; |
41534b92 BA |
546 | } |
547 | else { | |
548 | // Limiting dimension is height: | |
549 | cbHeight = Math.min(window.innerHeight, 767); | |
15106e82 | 550 | cbWidth = cbHeight * this.size.ratio; |
41534b92 BA |
551 | } |
552 | if (this.reserve) { | |
553 | const sqSize = cbWidth / this.size.y; | |
554 | // NOTE: allocate space for reserves (up/down) even if they are empty | |
15106e82 | 555 | // Cannot use getReserveSquareSize() here, but sqSize is an upper bound. |
41534b92 BA |
556 | if ((window.innerHeight - cbHeight) / 2 < sqSize + 5) { |
557 | cbHeight = window.innerHeight - 2 * (sqSize + 5); | |
15106e82 | 558 | cbWidth = cbHeight * this.size.ratio; |
41534b92 BA |
559 | } |
560 | } | |
3c61449b BA |
561 | chessboard.style.width = cbWidth + "px"; |
562 | chessboard.style.height = cbHeight + "px"; | |
41534b92 BA |
563 | // Center chessboard: |
564 | const spaceLeft = (window.innerWidth - cbWidth) / 2, | |
565 | spaceTop = (window.innerHeight - cbHeight) / 2; | |
3c61449b BA |
566 | chessboard.style.left = spaceLeft + "px"; |
567 | chessboard.style.top = spaceTop + "px"; | |
41534b92 BA |
568 | // Give sizes instead of recomputing them, |
569 | // because chessboard might not be drawn yet. | |
570 | this.setupPieces({ | |
571 | width: cbWidth, | |
572 | height: cbHeight, | |
573 | x: spaceLeft, | |
574 | y: spaceTop | |
575 | }); | |
576 | } | |
577 | ||
578 | // Get SVG board (background, no pieces) | |
579 | getSvgChessboard() { | |
41534b92 BA |
580 | const flipped = (this.playerColor == 'b'); |
581 | let board = ` | |
582 | <svg | |
583 | viewBox="0 0 80 80" | |
3c61449b | 584 | class="chessboard_SVG"> |
41534b92 | 585 | <g>`; |
728cb1e3 BA |
586 | for (let i=0; i < this.size.x; i++) { |
587 | for (let j=0; j < this.size.y; j++) { | |
41534b92 BA |
588 | const ii = (flipped ? this.size.x - 1 - i : i); |
589 | const jj = (flipped ? this.size.y - 1 - j : j); | |
c7bf7b1b BA |
590 | let classes = this.getSquareColorClass(ii, jj); |
591 | if (this.enlightened && !this.enlightened[ii][jj]) | |
592 | classes += " in-shadow"; | |
41534b92 | 593 | // NOTE: x / y reversed because coordinates system is reversed. |
c7bf7b1b BA |
594 | board += `<rect |
595 | class="${classes}" | |
15106e82 | 596 | id="${this.coordsToId({x: ii, y: jj})}" |
41534b92 BA |
597 | width="10" |
598 | height="10" | |
599 | x="${10*j}" | |
600 | y="${10*i}" />`; | |
601 | } | |
602 | } | |
603 | board += "</g></svg>"; | |
604 | return board; | |
605 | } | |
606 | ||
cc2c7183 | 607 | // Generally light square bottom-right |
15106e82 BA |
608 | getSquareColorClass(x, y) { |
609 | return ((x+y) % 2 == 0 ? "light-square": "dark-square"); | |
41534b92 BA |
610 | } |
611 | ||
612 | setupPieces(r) { | |
613 | if (this.g_pieces) { | |
614 | // Refreshing: delete old pieces first | |
615 | for (let i=0; i<this.size.x; i++) { | |
616 | for (let j=0; j<this.size.y; j++) { | |
617 | if (this.g_pieces[i][j]) { | |
618 | this.g_pieces[i][j].remove(); | |
619 | this.g_pieces[i][j] = null; | |
620 | } | |
621 | } | |
622 | } | |
623 | } | |
b4ae3ff6 BA |
624 | else |
625 | this.g_pieces = ArrayFun.init(this.size.x, this.size.y, null); | |
3c61449b BA |
626 | let chessboard = |
627 | document.getElementById(this.containerId).querySelector(".chessboard"); | |
b4ae3ff6 BA |
628 | if (!r) |
629 | r = chessboard.getBoundingClientRect(); | |
41534b92 BA |
630 | const pieceWidth = this.getPieceWidth(r.width); |
631 | for (let i=0; i < this.size.x; i++) { | |
632 | for (let j=0; j < this.size.y; j++) { | |
c9ab0340 | 633 | if (this.board[i][j] != "") { |
41534b92 | 634 | const color = this.getColor(i, j); |
cc2c7183 | 635 | const piece = this.getPiece(i, j); |
41534b92 BA |
636 | this.g_pieces[i][j] = document.createElement("piece"); |
637 | this.g_pieces[i][j].classList.add(this.pieces()[piece]["class"]); | |
15106e82 | 638 | this.g_pieces[i][j].classList.add(C.GetColorClass(color)); |
41534b92 BA |
639 | this.g_pieces[i][j].style.width = pieceWidth + "px"; |
640 | this.g_pieces[i][j].style.height = pieceWidth + "px"; | |
641 | const [ip, jp] = this.getPixelPosition(i, j, r); | |
642 | this.g_pieces[i][j].style.transform = `translate(${ip}px,${jp}px)`; | |
c9ab0340 BA |
643 | if (this.enlightened && !this.enlightened[i][j]) |
644 | this.g_pieces[i][j].classList.add("hidden"); | |
3c61449b | 645 | chessboard.appendChild(this.g_pieces[i][j]); |
41534b92 BA |
646 | } |
647 | } | |
648 | } | |
b4ae3ff6 BA |
649 | if (this.reserve) |
650 | this.re_drawReserve(['w', 'b'], r); | |
41534b92 BA |
651 | } |
652 | ||
653 | // NOTE: assume !!this.reserve | |
654 | re_drawReserve(colors, r) { | |
655 | if (this.r_pieces) { | |
656 | // Remove (old) reserve pieces | |
657 | for (let c of colors) { | |
b4ae3ff6 BA |
658 | if (!this.reserve[c]) |
659 | continue; | |
41534b92 BA |
660 | Object.keys(this.reserve[c]).forEach(p => { |
661 | if (this.r_pieces[c][p]) { | |
662 | this.r_pieces[c][p].remove(); | |
663 | delete this.r_pieces[c][p]; | |
664 | const numId = this.getReserveNumId(c, p); | |
665 | document.getElementById(numId).remove(); | |
666 | } | |
667 | }); | |
668 | let reservesDiv = document.getElementById("reserves_" + c); | |
b4ae3ff6 BA |
669 | if (reservesDiv) |
670 | reservesDiv.remove(); | |
41534b92 BA |
671 | } |
672 | } | |
b4ae3ff6 BA |
673 | else |
674 | this.r_pieces = { 'w': {}, 'b': {} }; | |
15106e82 BA |
675 | let chessboard = |
676 | document.getElementById(this.containerId).querySelector(".chessboard"); | |
b4ae3ff6 | 677 | if (!r) |
15106e82 | 678 | r = chessboard.getBoundingClientRect(); |
41534b92 | 679 | for (let c of colors) { |
b4ae3ff6 BA |
680 | if (!this.reserve[c]) |
681 | continue; | |
41534b92 | 682 | const nbR = this.getNbReservePieces(c); |
b4ae3ff6 BA |
683 | if (nbR == 0) |
684 | continue; | |
41534b92 BA |
685 | const sqResSize = this.getReserveSquareSize(r.width, nbR); |
686 | let ridx = 0; | |
687 | const vShift = (c == this.playerColor ? r.height + 5 : -sqResSize - 5); | |
688 | const [i0, j0] = [r.x, r.y + vShift]; | |
689 | let rcontainer = document.createElement("div"); | |
690 | rcontainer.id = "reserves_" + c; | |
691 | rcontainer.classList.add("reserves"); | |
692 | rcontainer.style.left = i0 + "px"; | |
693 | rcontainer.style.top = j0 + "px"; | |
1aa9054d BA |
694 | // NOTE: +1 fix display bug on Firefox at least |
695 | rcontainer.style.width = (nbR * sqResSize + 1) + "px"; | |
41534b92 | 696 | rcontainer.style.height = sqResSize + "px"; |
15106e82 | 697 | chessboard.appendChild(rcontainer); |
41534b92 | 698 | for (let p of Object.keys(this.reserve[c])) { |
b4ae3ff6 BA |
699 | if (this.reserve[c][p] == 0) |
700 | continue; | |
41534b92 | 701 | let r_cell = document.createElement("div"); |
15106e82 | 702 | r_cell.id = this.coordsToId({x: c, y: p}); |
41534b92 | 703 | r_cell.classList.add("reserve-cell"); |
1aa9054d BA |
704 | r_cell.style.width = sqResSize + "px"; |
705 | r_cell.style.height = sqResSize + "px"; | |
41534b92 BA |
706 | rcontainer.appendChild(r_cell); |
707 | let piece = document.createElement("piece"); | |
c9ab0340 | 708 | const pieceSpec = this.pieces()[p]; |
41534b92 | 709 | piece.classList.add(pieceSpec["class"]); |
15106e82 | 710 | piece.classList.add(C.GetColorClass(c)); |
41534b92 BA |
711 | piece.style.width = "100%"; |
712 | piece.style.height = "100%"; | |
713 | this.r_pieces[c][p] = piece; | |
714 | r_cell.appendChild(piece); | |
715 | let number = document.createElement("div"); | |
716 | number.textContent = this.reserve[c][p]; | |
717 | number.classList.add("reserve-num"); | |
718 | number.id = this.getReserveNumId(c, p); | |
719 | const fontSize = "1.3em"; | |
720 | number.style.fontSize = fontSize; | |
721 | number.style.fontSize = fontSize; | |
722 | r_cell.appendChild(number); | |
723 | ridx++; | |
724 | } | |
725 | } | |
726 | } | |
727 | ||
728 | updateReserve(color, piece, count) { | |
55a15dcb | 729 | if (this.options["cannibal"] && C.CannibalKings[piece]) |
cc2c7183 | 730 | piece = "k"; //capturing cannibal king: back to king form |
41534b92 BA |
731 | const oldCount = this.reserve[color][piece]; |
732 | this.reserve[color][piece] = count; | |
733 | // Redrawing is much easier if count==0 | |
b4ae3ff6 BA |
734 | if ([oldCount, count].includes(0)) |
735 | this.re_drawReserve([color]); | |
41534b92 BA |
736 | else { |
737 | const numId = this.getReserveNumId(color, piece); | |
738 | document.getElementById(numId).textContent = count; | |
739 | } | |
740 | } | |
741 | ||
15106e82 BA |
742 | // Apply diff this.enlightened --> oldEnlightened on board |
743 | graphUpdateEnlightened() { | |
744 | let chessboard = | |
745 | document.getElementById(this.containerId).querySelector(".chessboard"); | |
746 | const r = chessboard.getBoundingClientRect(); | |
747 | const pieceWidth = this.getPieceWidth(r.width); | |
748 | for (let x=0; x<this.size.x; x++) { | |
749 | for (let y=0; y<this.size.y; y++) { | |
750 | if (!this.enlightened[x][y] && this.oldEnlightened[x][y]) { | |
751 | let elt = document.getElementById(this.coordsToId(x, y)); | |
752 | elt.classList.add("in-shadow"); | |
753 | if (this.g_pieces[x][y]) | |
754 | this.g_pieces[x][y].classList.add("hidden"); | |
755 | } | |
756 | else if (this.enlightened[x][y] && !this.oldEnlightened[x][y]) { | |
757 | let elt = document.getElementById(this.coordsToId(x, y)); | |
758 | elt.classList.remove("in-shadow"); | |
759 | if (this.g_pieces[x][y]) | |
760 | this.g_pieces[x][y].classList.remove("hidden"); | |
761 | } | |
762 | } | |
763 | } | |
764 | } | |
765 | ||
41534b92 BA |
766 | // After resize event: no need to destroy/recreate pieces |
767 | rescale() { | |
3c61449b | 768 | const container = document.getElementById(this.containerId); |
b4ae3ff6 BA |
769 | if (!container) |
770 | return; //useful at initial loading | |
3c61449b BA |
771 | let chessboard = container.querySelector(".chessboard"); |
772 | const r = chessboard.getBoundingClientRect(); | |
41534b92 | 773 | const newRatio = r.width / r.height; |
41534b92 BA |
774 | let newWidth = r.width, |
775 | newHeight = r.height; | |
15106e82 BA |
776 | if (newRatio > this.size.ratio) { |
777 | newWidth = r.height * this.size.ratio; | |
3c61449b | 778 | chessboard.style.width = newWidth + "px"; |
41534b92 | 779 | } |
15106e82 BA |
780 | else if (newRatio < this.size.ratio) { |
781 | newHeight = r.width / this.size.ratio; | |
3c61449b | 782 | chessboard.style.height = newHeight + "px"; |
41534b92 BA |
783 | } |
784 | const newX = (window.innerWidth - newWidth) / 2; | |
3c61449b | 785 | chessboard.style.left = newX + "px"; |
41534b92 | 786 | const newY = (window.innerHeight - newHeight) / 2; |
3c61449b | 787 | chessboard.style.top = newY + "px"; |
41534b92 BA |
788 | const newR = { x: newX, y: newY, width: newWidth, height: newHeight }; |
789 | const pieceWidth = this.getPieceWidth(newWidth); | |
790 | for (let i=0; i < this.size.x; i++) { | |
791 | for (let j=0; j < this.size.y; j++) { | |
c9ab0340 | 792 | if (this.g_pieces[i][j]) { |
41534b92 BA |
793 | // NOTE: could also use CSS transform "scale" |
794 | this.g_pieces[i][j].style.width = pieceWidth + "px"; | |
795 | this.g_pieces[i][j].style.height = pieceWidth + "px"; | |
796 | const [ip, jp] = this.getPixelPosition(i, j, newR); | |
797 | this.g_pieces[i][j].style.transform = `translate(${ip}px,${jp}px)`; | |
798 | } | |
799 | } | |
800 | } | |
b4ae3ff6 BA |
801 | if (this.reserve) |
802 | this.rescaleReserve(newR); | |
41534b92 BA |
803 | } |
804 | ||
805 | rescaleReserve(r) { | |
41534b92 | 806 | for (let c of ['w','b']) { |
b4ae3ff6 BA |
807 | if (!this.reserve[c]) |
808 | continue; | |
41534b92 | 809 | const nbR = this.getNbReservePieces(c); |
b4ae3ff6 BA |
810 | if (nbR == 0) |
811 | continue; | |
41534b92 BA |
812 | // Resize container first |
813 | const sqResSize = this.getReserveSquareSize(r.width, nbR); | |
814 | const vShift = (c == this.playerColor ? r.height + 5 : -sqResSize - 5); | |
815 | const [i0, j0] = [r.x, r.y + vShift]; | |
816 | let rcontainer = document.getElementById("reserves_" + c); | |
817 | rcontainer.style.left = i0 + "px"; | |
818 | rcontainer.style.top = j0 + "px"; | |
1aa9054d | 819 | rcontainer.style.width = (nbR * sqResSize + 1) + "px"; |
41534b92 BA |
820 | rcontainer.style.height = sqResSize + "px"; |
821 | // And then reserve cells: | |
822 | const rpieceWidth = this.getReserveSquareSize(r.width, nbR); | |
823 | Object.keys(this.reserve[c]).forEach(p => { | |
b4ae3ff6 BA |
824 | if (this.reserve[c][p] == 0) |
825 | return; | |
15106e82 | 826 | let r_cell = document.getElementById(this.coordsToId({x: c, y: p})); |
1aa9054d BA |
827 | r_cell.style.width = sqResSize + "px"; |
828 | r_cell.style.height = sqResSize + "px"; | |
41534b92 BA |
829 | }); |
830 | } | |
831 | } | |
832 | ||
3c61449b | 833 | // Return the absolute pixel coordinates (on board) given current position. |
41534b92 BA |
834 | // Our coordinate system differs from CSS one (x <--> y). |
835 | // We return here the CSS coordinates (more useful). | |
836 | getPixelPosition(i, j, r) { | |
b4ae3ff6 BA |
837 | if (i < 0 || j < 0) |
838 | return [0, 0]; //piece vanishes | |
15106e82 BA |
839 | let x, y; |
840 | if (typeof i == "string") { | |
841 | // Reserves: need to know the rank of piece | |
842 | const nbR = this.getNbReservePieces(i); | |
843 | const rsqSize = this.getReserveSquareSize(r.width, nbR); | |
844 | x = this.getRankInReserve(i, j) * rsqSize; | |
845 | y = (this.playerColor == i ? y = r.height + 5 : - 5 - rsqSize); | |
846 | } | |
847 | else { | |
848 | const sqSize = r.width / this.size.y; | |
849 | const flipped = (this.playerColor == 'b'); | |
850 | x = (flipped ? this.size.y - 1 - j : j) * sqSize; | |
851 | y = (flipped ? this.size.x - 1 - i : i) * sqSize; | |
852 | } | |
41534b92 BA |
853 | return [x, y]; |
854 | } | |
855 | ||
856 | initMouseEvents() { | |
3c61449b BA |
857 | let chessboard = |
858 | document.getElementById(this.containerId).querySelector(".chessboard"); | |
41534b92 BA |
859 | |
860 | const getOffset = e => { | |
3c61449b BA |
861 | if (e.clientX) |
862 | // Mouse | |
863 | return {x: e.clientX, y: e.clientY}; | |
41534b92 BA |
864 | let touchLocation = null; |
865 | if (e.targetTouches && e.targetTouches.length >= 1) | |
866 | // Touch screen, dragstart | |
867 | touchLocation = e.targetTouches[0]; | |
868 | else if (e.changedTouches && e.changedTouches.length >= 1) | |
869 | // Touch screen, dragend | |
870 | touchLocation = e.changedTouches[0]; | |
871 | if (touchLocation) | |
11625344 | 872 | return {x: touchLocation.clientX, y: touchLocation.clientY}; |
57b8015b | 873 | return {x: 0, y: 0}; //shouldn't reach here =) |
41534b92 BA |
874 | } |
875 | ||
876 | const centerOnCursor = (piece, e) => { | |
15106e82 | 877 | const centerShift = this.getPieceWidth(r.width) / 2; |
41534b92 | 878 | const offset = getOffset(e); |
3c61449b BA |
879 | piece.style.left = (offset.x - r.x - centerShift) + "px"; |
880 | piece.style.top = (offset.y - r.y - centerShift) + "px"; | |
41534b92 BA |
881 | } |
882 | ||
883 | let start = null, | |
884 | r = null, | |
885 | startPiece, curPiece = null, | |
15106e82 | 886 | pieceWidth; |
41534b92 | 887 | const mousedown = (e) => { |
cb17fed8 | 888 | // Disable zoom on smartphones: |
b4ae3ff6 BA |
889 | if (e.touches && e.touches.length > 1) |
890 | e.preventDefault(); | |
3c61449b | 891 | r = chessboard.getBoundingClientRect(); |
15106e82 BA |
892 | pieceWidth = this.getPieceWidth(r.width); |
893 | const cd = this.idToCoords(e.target.id); | |
894 | if (cd) { | |
895 | const move = this.doClick(cd); | |
b4ae3ff6 BA |
896 | if (move) |
897 | this.playPlusVisual(move); | |
41534b92 | 898 | else { |
15106e82 BA |
899 | const [x, y] = Object.values(cd); |
900 | if (typeof x != "number") | |
901 | startPiece = this.r_pieces[x][y]; | |
902 | else | |
903 | startPiece = this.g_pieces[x][y]; | |
904 | if (startPiece && this.canIplay(x, y)) { | |
41534b92 | 905 | e.preventDefault(); |
15106e82 | 906 | start = cd; |
41534b92 BA |
907 | curPiece = startPiece.cloneNode(); |
908 | curPiece.style.transform = "none"; | |
909 | curPiece.style.zIndex = 5; | |
15106e82 BA |
910 | curPiece.style.width = pieceWidth + "px"; |
911 | curPiece.style.height = pieceWidth + "px"; | |
41534b92 | 912 | centerOnCursor(curPiece, e); |
3c61449b | 913 | chessboard.appendChild(curPiece); |
41534b92 | 914 | startPiece.style.opacity = "0.4"; |
3c61449b | 915 | chessboard.style.cursor = "none"; |
41534b92 BA |
916 | } |
917 | } | |
918 | } | |
919 | }; | |
920 | ||
921 | const mousemove = (e) => { | |
922 | if (start) { | |
923 | e.preventDefault(); | |
924 | centerOnCursor(curPiece, e); | |
925 | } | |
11625344 BA |
926 | else if (e.changedTouches && e.changedTouches.length >= 1) |
927 | // Attempt to prevent horizontal swipe... | |
928 | e.preventDefault(); | |
41534b92 BA |
929 | }; |
930 | ||
931 | const mouseup = (e) => { | |
3c61449b | 932 | const newR = chessboard.getBoundingClientRect(); |
41534b92 BA |
933 | if (newR.width != r.width || newR.height != r.height) { |
934 | this.rescale(); | |
935 | return; | |
936 | } | |
b4ae3ff6 BA |
937 | if (!start) |
938 | return; | |
41534b92 BA |
939 | const [x, y] = [start.x, start.y]; |
940 | start = null; | |
941 | e.preventDefault(); | |
3c61449b | 942 | chessboard.style.cursor = "pointer"; |
41534b92 BA |
943 | startPiece.style.opacity = "1"; |
944 | const offset = getOffset(e); | |
945 | const landingElt = document.elementFromPoint(offset.x, offset.y); | |
15106e82 BA |
946 | const cd = |
947 | (landingElt ? this.idToCoords(landingElt.id) : undefined); | |
948 | if (cd) { | |
41534b92 BA |
949 | // NOTE: clearly suboptimal, but much easier, and not a big deal. |
950 | const potentialMoves = this.getPotentialMovesFrom([x, y]) | |
15106e82 | 951 | .filter(m => m.end.x == cd.x && m.end.y == cd.y); |
41534b92 | 952 | const moves = this.filterValid(potentialMoves); |
b4ae3ff6 BA |
953 | if (moves.length >= 2) |
954 | this.showChoices(moves, r); | |
955 | else if (moves.length == 1) | |
956 | this.playPlusVisual(moves[0], r); | |
41534b92 BA |
957 | } |
958 | curPiece.remove(); | |
959 | }; | |
960 | ||
961 | if ('onmousedown' in window) { | |
962 | document.addEventListener("mousedown", mousedown); | |
963 | document.addEventListener("mousemove", mousemove); | |
964 | document.addEventListener("mouseup", mouseup); | |
965 | } | |
966 | if ('ontouchstart' in window) { | |
cb17fed8 BA |
967 | // https://stackoverflow.com/a/42509310/12660887 |
968 | document.addEventListener("touchstart", mousedown, {passive: false}); | |
969 | document.addEventListener("touchmove", mousemove, {passive: false}); | |
970 | document.addEventListener("touchend", mouseup, {passive: false}); | |
41534b92 | 971 | } |
11625344 | 972 | // TODO: onpointerdown/move/up ? See reveal.js /controllers/touch.js |
41534b92 BA |
973 | } |
974 | ||
975 | showChoices(moves, r) { | |
976 | let container = document.getElementById(this.containerId); | |
3c61449b | 977 | let chessboard = container.querySelector(".chessboard"); |
41534b92 BA |
978 | let choices = document.createElement("div"); |
979 | choices.id = "choices"; | |
980 | choices.style.width = r.width + "px"; | |
981 | choices.style.height = r.height + "px"; | |
982 | choices.style.left = r.x + "px"; | |
983 | choices.style.top = r.y + "px"; | |
3c61449b BA |
984 | chessboard.style.opacity = "0.5"; |
985 | container.appendChild(choices); | |
15106e82 | 986 | const squareWidth = r.width / this.size.y; |
41534b92 BA |
987 | const firstUpLeft = (r.width - (moves.length * squareWidth)) / 2; |
988 | const firstUpTop = (r.height - squareWidth) / 2; | |
989 | const color = moves[0].appear[0].c; | |
990 | const callback = (m) => { | |
3c61449b BA |
991 | chessboard.style.opacity = "1"; |
992 | container.removeChild(choices); | |
41534b92 BA |
993 | this.playPlusVisual(m, r); |
994 | } | |
995 | for (let i=0; i < moves.length; i++) { | |
996 | let choice = document.createElement("div"); | |
997 | choice.classList.add("choice"); | |
998 | choice.style.width = squareWidth + "px"; | |
999 | choice.style.height = squareWidth + "px"; | |
1000 | choice.style.left = (firstUpLeft + i * squareWidth) + "px"; | |
1001 | choice.style.top = firstUpTop + "px"; | |
1002 | choice.style.backgroundColor = "lightyellow"; | |
1003 | choice.onclick = () => callback(moves[i]); | |
1004 | const piece = document.createElement("piece"); | |
c9ab0340 | 1005 | const pieceSpec = this.pieces()[moves[i].appear[0].p]; |
41534b92 | 1006 | piece.classList.add(pieceSpec["class"]); |
15106e82 | 1007 | piece.classList.add(C.GetColorClass(color)); |
41534b92 BA |
1008 | piece.style.width = "100%"; |
1009 | piece.style.height = "100%"; | |
1010 | choice.appendChild(piece); | |
1011 | choices.appendChild(choice); | |
1012 | } | |
1013 | } | |
1014 | ||
1015 | ////////////// | |
1016 | // BASIC UTILS | |
1017 | ||
1018 | get size() { | |
15106e82 BA |
1019 | return { |
1020 | x: 8, | |
1021 | y: 8, | |
1022 | ratio: 1 //for rectangular board = y / x | |
1023 | }; | |
41534b92 BA |
1024 | } |
1025 | ||
1026 | // Color of thing on square (i,j). 'undefined' if square is empty | |
1027 | getColor(i, j) { | |
15106e82 BA |
1028 | if (typeof i == "string") |
1029 | return i; //reserves | |
41534b92 BA |
1030 | return this.board[i][j].charAt(0); |
1031 | } | |
1032 | ||
15106e82 BA |
1033 | static GetColorClass(c) { |
1034 | return (c == 'w' ? "white" : "black"); | |
1035 | } | |
1036 | ||
cc2c7183 | 1037 | // Assume square i,j isn't empty |
41534b92 | 1038 | getPiece(i, j) { |
15106e82 BA |
1039 | if (typeof j == "string") |
1040 | return j; //reserves | |
41534b92 BA |
1041 | return this.board[i][j].charAt(1); |
1042 | } | |
1043 | ||
cc2c7183 BA |
1044 | // Piece type on square (i,j) |
1045 | getPieceType(i, j) { | |
15106e82 | 1046 | const p = (typeof i == "string" ? j : this.board[i][j].charAt(1)); |
cc2c7183 BA |
1047 | return C.CannibalKings[p] || p; //a cannibal king move as... |
1048 | } | |
1049 | ||
41534b92 BA |
1050 | // Get opponent color |
1051 | static GetOppCol(color) { | |
1052 | return (color == "w" ? "b" : "w"); | |
1053 | } | |
1054 | ||
c9ab0340 | 1055 | // Can thing on square1 capture (no return) thing on square2? |
41534b92 | 1056 | canTake([x1, y1], [x2, y2]) { |
c9ab0340 | 1057 | return (this.getColor(x1, y1) !== this.getColor(x2, y2)); |
41534b92 BA |
1058 | } |
1059 | ||
1060 | // Is (x,y) on the chessboard? | |
1061 | onBoard(x, y) { | |
b99ce1fb BA |
1062 | return (x >= 0 && x < this.size.x && |
1063 | y >= 0 && y < this.size.y); | |
41534b92 BA |
1064 | } |
1065 | ||
15106e82 | 1066 | // Am I allowed to move thing at square x,y ? |
41534b92 BA |
1067 | canIplay(x, y) { |
1068 | return ( | |
1069 | this.playerColor == this.turn && | |
1070 | ( | |
1071 | (typeof x == "number" && this.getColor(x, y) == this.turn) || | |
1072 | (typeof x == "string" && x == this.turn) //reserve | |
1073 | ) | |
1074 | ); | |
1075 | } | |
1076 | ||
1077 | //////////////////////// | |
1078 | // PIECES SPECIFICATIONS | |
1079 | ||
c9ab0340 | 1080 | pieces(color, x, y) { |
41534b92 | 1081 | const pawnShift = (color == "w" ? -1 : 1); |
c9ab0340 | 1082 | const initRank = ((color == 'w' && x == 6) || (color == 'b' && x == 1)); |
41534b92 BA |
1083 | return { |
1084 | 'p': { | |
1085 | "class": "pawn", | |
c9ab0340 BA |
1086 | moves: [ |
1087 | { | |
1088 | steps: [[pawnShift, 0]], | |
1089 | range: (initRank ? 2 : 1) | |
1090 | } | |
1091 | ], | |
1092 | attack: [ | |
1093 | { | |
1094 | steps: [[pawnShift, 1], [pawnShift, -1]], | |
1095 | range: 1 | |
1096 | } | |
1097 | ] | |
41534b92 BA |
1098 | }, |
1099 | // rook | |
1100 | 'r': { | |
1101 | "class": "rook", | |
c9ab0340 BA |
1102 | moves: [ |
1103 | {steps: [[0, 1], [0, -1], [1, 0], [-1, 0]]} | |
1104 | ] | |
41534b92 BA |
1105 | }, |
1106 | // knight | |
1107 | 'n': { | |
1108 | "class": "knight", | |
c9ab0340 BA |
1109 | moves: [ |
1110 | { | |
1111 | steps: [ | |
1112 | [1, 2], [1, -2], [-1, 2], [-1, -2], | |
1113 | [2, 1], [-2, 1], [2, -1], [-2, -1] | |
1114 | ], | |
1115 | range: 1 | |
1116 | } | |
1117 | ] | |
41534b92 BA |
1118 | }, |
1119 | // bishop | |
1120 | 'b': { | |
1121 | "class": "bishop", | |
c9ab0340 BA |
1122 | moves: [ |
1123 | {steps: [[1, 1], [1, -1], [-1, 1], [-1, -1]]} | |
1124 | ] | |
41534b92 BA |
1125 | }, |
1126 | // queen | |
1127 | 'q': { | |
1128 | "class": "queen", | |
c9ab0340 BA |
1129 | moves: [ |
1130 | { | |
1131 | steps: [ | |
1132 | [0, 1], [0, -1], [1, 0], [-1, 0], | |
1133 | [1, 1], [1, -1], [-1, 1], [-1, -1] | |
1134 | ] | |
1135 | } | |
41534b92 BA |
1136 | ] |
1137 | }, | |
1138 | // king | |
1139 | 'k': { | |
1140 | "class": "king", | |
c9ab0340 BA |
1141 | moves: [ |
1142 | { | |
1143 | steps: [ | |
1144 | [0, 1], [0, -1], [1, 0], [-1, 0], | |
1145 | [1, 1], [1, -1], [-1, 1], [-1, -1] | |
1146 | ], | |
1147 | range: 1 | |
1148 | } | |
1149 | ] | |
cc2c7183 BA |
1150 | }, |
1151 | // Cannibal kings: | |
c9ab0340 BA |
1152 | '!': {"class": "king-pawn", moveas: "p"}, |
1153 | '#': {"class": "king-rook", moveas: "r"}, | |
1154 | '$': {"class": "king-knight", moveas: "n"}, | |
1155 | '%': {"class": "king-bishop", moveas: "b"}, | |
1156 | '*': {"class": "king-queen", moveas: "q"} | |
41534b92 BA |
1157 | }; |
1158 | } | |
1159 | ||
41534b92 BA |
1160 | //////////////////// |
1161 | // MOVES GENERATION | |
1162 | ||
1163 | // For Cylinder: get Y coordinate | |
1164 | computeY(y) { | |
b4ae3ff6 BA |
1165 | if (!this.options["cylinder"]) |
1166 | return y; | |
41534b92 | 1167 | let res = y % this.size.y; |
b4ae3ff6 BA |
1168 | if (res < 0) |
1169 | res += this.size.y; | |
41534b92 BA |
1170 | return res; |
1171 | } | |
1172 | ||
1173 | // Stop at the first capture found | |
1174 | atLeastOneCapture(color) { | |
1175 | color = color || this.turn; | |
cc2c7183 | 1176 | const oppCol = C.GetOppCol(color); |
41534b92 BA |
1177 | for (let i = 0; i < this.size.x; i++) { |
1178 | for (let j = 0; j < this.size.y; j++) { | |
1179 | if (this.board[i][j] != "" && this.getColor(i, j) == color) { | |
c9ab0340 BA |
1180 | const allSpecs = this.pieces(color, i, j) |
1181 | let specs = allSpecs[this.getPieceType(i, j)]; | |
1182 | const attacks = specs.attack || specs.moves; | |
1183 | for (let a of attacks) { | |
1184 | outerLoop: for (let step of a.steps) { | |
1185 | let [ii, jj] = [i + step[0], this.computeY(j + step[1])]; | |
1186 | let stepCounter = 1; | |
1187 | while (this.onBoard(ii, jj) && this.board[ii][jj] == "") { | |
1188 | if (a.range <= stepCounter++) | |
1189 | continue outerLoop; | |
1190 | ii += step[0]; | |
1191 | jj = this.computeY(jj + step[1]); | |
1192 | } | |
1193 | if ( | |
1194 | this.onBoard(ii, jj) && | |
1195 | this.getColor(ii, jj) == oppCol && | |
1196 | this.filterValid( | |
1197 | [this.getBasicMove([i, j], [ii, jj])] | |
1198 | ).length >= 1 | |
1199 | ) { | |
1200 | return true; | |
1201 | } | |
41534b92 BA |
1202 | } |
1203 | } | |
1204 | } | |
1205 | } | |
1206 | } | |
1207 | return false; | |
1208 | } | |
1209 | ||
1210 | getDropMovesFrom([c, p]) { | |
1211 | // NOTE: by design, this.reserve[c][p] >= 1 on user click | |
1212 | // (but not necessarily otherwise) | |
b4ae3ff6 BA |
1213 | if (this.reserve[c][p] == 0) |
1214 | return []; | |
41534b92 BA |
1215 | let moves = []; |
1216 | for (let i=0; i<this.size.x; i++) { | |
1217 | for (let j=0; j<this.size.y; j++) { | |
41534b92 BA |
1218 | if ( |
1219 | this.board[i][j] == "" && | |
c9ab0340 | 1220 | (!this.enlightened || this.enlightened[i][j]) && |
41534b92 | 1221 | ( |
cc2c7183 | 1222 | p != "p" || |
41534b92 BA |
1223 | (c == 'w' && i < this.size.x - 1) || |
1224 | (c == 'b' && i > 0) | |
1225 | ) | |
1226 | ) { | |
1227 | moves.push( | |
1228 | new Move({ | |
1229 | start: {x: c, y: p}, | |
1230 | end: {x: i, y: j}, | |
1231 | appear: [new PiPo({x: i, y: j, c: c, p: p})], | |
1232 | vanish: [] | |
1233 | }) | |
1234 | ); | |
1235 | } | |
1236 | } | |
1237 | } | |
1238 | return moves; | |
1239 | } | |
1240 | ||
1241 | // All possible moves from selected square | |
c7bf7b1b | 1242 | getPotentialMovesFrom(sq, color) { |
8b301184 BA |
1243 | if (this.subTurnTeleport == 2) |
1244 | return []; | |
b4ae3ff6 BA |
1245 | if (typeof sq[0] == "string") |
1246 | return this.getDropMovesFrom(sq); | |
57b8015b | 1247 | if (this.isImmobilized(sq)) |
b4ae3ff6 | 1248 | return []; |
cc2c7183 | 1249 | const piece = this.getPieceType(sq[0], sq[1]); |
c9ab0340 BA |
1250 | let moves = this.getPotentialMovesOf(piece, sq); |
1251 | if ( | |
1252 | piece == "p" && | |
1253 | this.hasEnpassant && | |
1254 | this.epSquare | |
1255 | ) { | |
1256 | Array.prototype.push.apply(moves, this.getEnpassantCaptures(sq)); | |
1257 | } | |
41534b92 | 1258 | if ( |
cc2c7183 | 1259 | piece == "k" && |
41534b92 BA |
1260 | this.hasCastle && |
1261 | this.castleFlags[color || this.turn].some(v => v < this.size.y) | |
1262 | ) { | |
1263 | Array.prototype.push.apply(moves, this.getCastleMoves(sq)); | |
1264 | } | |
1265 | return this.postProcessPotentialMoves(moves); | |
1266 | } | |
1267 | ||
1268 | postProcessPotentialMoves(moves) { | |
b4ae3ff6 BA |
1269 | if (moves.length == 0) |
1270 | return []; | |
41534b92 | 1271 | const color = this.getColor(moves[0].start.x, moves[0].start.y); |
cc2c7183 | 1272 | const oppCol = C.GetOppCol(color); |
41534b92 | 1273 | |
57b8015b BA |
1274 | if (this.options["capture"] && this.atLeastOneCapture()) |
1275 | moves = this.capturePostProcess(moves, oppCol); | |
41534b92 | 1276 | |
57b8015b BA |
1277 | if (this.options["atomic"]) |
1278 | this.atomicPostProcess(moves, oppCol); | |
cc2c7183 | 1279 | |
c9ab0340 BA |
1280 | if ( |
1281 | moves.length > 0 && | |
1282 | this.getPieceType(moves[0].start.x, moves[0].start.y) == "p" | |
1283 | ) { | |
57b8015b | 1284 | this.pawnPostProcess(moves, color, oppCol); |
c9ab0340 BA |
1285 | } |
1286 | ||
cc2c7183 BA |
1287 | if ( |
1288 | this.options["cannibal"] && | |
57b8015b | 1289 | this.options["rifle"] |
cc2c7183 BA |
1290 | ) { |
1291 | // In this case a rifle-capture from last rank may promote a pawn | |
57b8015b BA |
1292 | this.riflePromotePostProcess(moves); |
1293 | } | |
1294 | ||
1295 | return moves; | |
1296 | } | |
1297 | ||
1298 | capturePostProcess(moves, oppCol) { | |
1299 | // Filter out non-capturing moves (not using m.vanish because of | |
1300 | // self captures of Recycle and Teleport). | |
1301 | return moves.filter(m => { | |
1302 | return ( | |
1303 | this.board[m.end.x][m.end.y] != "" && | |
1304 | this.getColor(m.end.x, m.end.y) == oppCol | |
1305 | ); | |
1306 | }); | |
1307 | } | |
1308 | ||
1309 | atomicPostProcess(moves, oppCol) { | |
1310 | moves.forEach(m => { | |
1311 | if ( | |
1312 | this.board[m.end.x][m.end.y] != "" && | |
1313 | this.getColor(m.end.x, m.end.y) == oppCol | |
1314 | ) { | |
1315 | // Explosion! | |
1316 | let steps = [ | |
1317 | [-1, -1], | |
1318 | [-1, 0], | |
1319 | [-1, 1], | |
1320 | [0, -1], | |
1321 | [0, 1], | |
1322 | [1, -1], | |
1323 | [1, 0], | |
1324 | [1, 1] | |
1325 | ]; | |
1326 | for (let step of steps) { | |
1327 | let x = m.end.x + step[0]; | |
1328 | let y = this.computeY(m.end.y + step[1]); | |
1329 | if ( | |
1330 | this.onBoard(x, y) && | |
1331 | this.board[x][y] != "" && | |
1332 | this.getPieceType(x, y) != "p" | |
1333 | ) { | |
1334 | m.vanish.push( | |
1335 | new PiPo({ | |
1336 | p: this.getPiece(x, y), | |
1337 | c: this.getColor(x, y), | |
1338 | x: x, | |
1339 | y: y | |
1340 | }) | |
1341 | ); | |
1342 | } | |
1343 | } | |
1344 | if (!this.options["rifle"]) | |
1345 | m.appear.pop(); //nothin appears | |
1346 | } | |
1347 | }); | |
1348 | } | |
1349 | ||
639afc98 BA |
1350 | // TODO: pawnfall + Cannibal issues |
1351 | ||
57b8015b BA |
1352 | pawnPostProcess(moves, color, oppCol) { |
1353 | let moreMoves = []; | |
1354 | const lastRank = (color == "w" ? 0 : this.size.x - 1); | |
1355 | const initPiece = this.getPiece(moves[0].start.x, moves[0].start.y); | |
1356 | moves.forEach(m => { | |
1357 | let finalPieces = ["p"]; | |
1358 | const [x1, y1] = [m.start.x, m.start.y]; | |
1359 | const [x2, y2] = [m.end.x, m.end.y]; | |
1360 | const promotionOk = ( | |
1361 | x2 == lastRank && | |
1362 | (!this.options["rifle"] || this.board[x2][y2] == "") | |
1363 | ); | |
1364 | if (!promotionOk) | |
1365 | return; //nothing to do | |
8cc2f6d0 BA |
1366 | if (this.options["pawnfall"]) { |
1367 | m.appear.shift(); | |
1368 | m.pawnfall = true; //required in prePlay() /// ???????????? | |
1369 | return; | |
1370 | } | |
1371 | //if (!this.options["pawnfall"]) { --> OK | |
cc2c7183 | 1372 | if ( |
57b8015b BA |
1373 | this.options["cannibal"] && |
1374 | this.board[x2][y2] != "" && | |
1375 | this.getColor(x2, y2) == oppCol | |
cc2c7183 | 1376 | ) { |
57b8015b | 1377 | finalPieces = [this.getPieceType(x2, y2)]; |
cc2c7183 | 1378 | } |
57b8015b BA |
1379 | else |
1380 | finalPieces = this.pawnPromotions; | |
8cc2f6d0 | 1381 | //} |
57b8015b BA |
1382 | m.appear[0].p = finalPieces[0]; |
1383 | if (initPiece == "!") //cannibal king-pawn | |
1384 | m.appear[0].p = C.CannibalKingCode[finalPieces[0]]; | |
1385 | for (let i=1; i<finalPieces.length; i++) { | |
1386 | const piece = finalPieces[i]; | |
1387 | let tr = null; | |
1388 | if (!this.options["pawnfall"]) { | |
1389 | tr = { | |
1390 | c: color, | |
1391 | p: (initPiece != "!" ? piece : C.CannibalKingCode[piece]) | |
1392 | }; | |
1393 | } | |
1394 | let newMove = this.getBasicMove([x1, y1], [x2, y2], tr); | |
1395 | if (this.options["pawnfall"]) { | |
57b8015b BA |
1396 | } |
1397 | moreMoves.push(newMove); | |
1398 | } | |
1399 | }); | |
1400 | Array.prototype.push.apply(moves, moreMoves); | |
1401 | } | |
cc2c7183 | 1402 | |
57b8015b BA |
1403 | riflePromotePostProcess(moves) { |
1404 | const lastRank = (color == "w" ? 0 : this.size.x - 1); | |
1405 | let newMoves = []; | |
1406 | moves.forEach(m => { | |
1407 | if ( | |
1408 | m.start.x == lastRank && | |
1409 | m.appear.length >= 1 && | |
1410 | m.appear[0].p == "p" && | |
1411 | m.appear[0].x == m.start.x && | |
1412 | m.appear[0].y == m.start.y | |
1413 | ) { | |
1414 | const promotionPiece0 = this.pawnSpecs.promotions[0]; | |
1415 | m.appear[0].p = this.pawnPromotions[0]; | |
1416 | for (let i=1; i<this.pawnPromotions.length; i++) { | |
1417 | let newMv = JSON.parse(JSON.stringify(m)); | |
1418 | newMv.appear[0].p = this.pawnSpecs.promotions[i]; | |
1419 | newMoves.push(newMv); | |
1420 | } | |
1421 | } | |
1422 | }); | |
1423 | Array.prototype.push.apply(moves, newMoves); | |
41534b92 BA |
1424 | } |
1425 | ||
b99ce1fb | 1426 | // NOTE: using special symbols to not interfere with variants' pieces codes |
cc2c7183 BA |
1427 | static get CannibalKings() { |
1428 | return { | |
b99ce1fb BA |
1429 | "!": "p", |
1430 | "#": "r", | |
1431 | "$": "n", | |
1432 | "%": "b", | |
1433 | "*": "q" | |
cc2c7183 BA |
1434 | }; |
1435 | } | |
1436 | ||
1437 | static get CannibalKingCode() { | |
1438 | return { | |
b99ce1fb BA |
1439 | "p": "!", |
1440 | "r": "#", | |
1441 | "n": "$", | |
1442 | "b": "%", | |
1443 | "q": "*", | |
cc2c7183 BA |
1444 | "k": "k" |
1445 | }; | |
1446 | } | |
1447 | ||
1448 | isKing(symbol) { | |
1449 | return ( | |
1450 | symbol == 'k' || | |
1451 | (this.options["cannibal"] && C.CannibalKings[symbol]) | |
1452 | ); | |
1453 | } | |
1454 | ||
41534b92 BA |
1455 | // For Madrasi: |
1456 | // (redefined in Baroque etc, where Madrasi condition doesn't make sense) | |
1457 | isImmobilized([x, y]) { | |
57b8015b BA |
1458 | if (!this.options["madrasi"]) |
1459 | return false; | |
41534b92 | 1460 | const color = this.getColor(x, y); |
cc2c7183 | 1461 | const oppCol = C.GetOppCol(color); |
c9ab0340 | 1462 | const piece = this.getPieceType(x, y); //ok not cannibal king |
57b8015b | 1463 | const stepSpec = this.pieces(color, x, y)[piece]; |
c9ab0340 BA |
1464 | const attacks = stepSpec.attack || stepSpec.moves; |
1465 | for (let a of attacks) { | |
1466 | outerLoop: for (let step of a.steps) { | |
1467 | let [i, j] = [x + step[0], y + step[1]]; | |
1468 | let stepCounter = 1; | |
1469 | while (this.onBoard(i, j) && this.board[i][j] == "") { | |
1470 | if (a.range <= stepCounter++) | |
1471 | continue outerLoop; | |
1472 | i += step[0]; | |
1473 | j = this.computeY(j + step[1]); | |
1474 | } | |
1475 | if ( | |
1476 | this.onBoard(i, j) && | |
1477 | this.getColor(i, j) == oppCol && | |
1478 | this.getPieceType(i, j) == piece | |
1479 | ) { | |
1480 | return true; | |
1481 | } | |
41534b92 BA |
1482 | } |
1483 | } | |
1484 | return false; | |
1485 | } | |
1486 | ||
1487 | // Generic method to find possible moves of "sliding or jumping" pieces | |
1488 | getPotentialMovesOf(piece, [x, y]) { | |
1489 | const color = this.getColor(x, y); | |
c9ab0340 | 1490 | const stepSpec = this.pieces(color, x, y)[piece]; |
41534b92 BA |
1491 | let moves = []; |
1492 | let explored = {}; //for Cylinder mode | |
c9ab0340 BA |
1493 | |
1494 | const findAddMoves = (type, stepArray) => { | |
1495 | for (let s of stepArray) { | |
15106e82 | 1496 | // TODO: if jump in y (computeY, Cylinder), move.segments |
c9ab0340 BA |
1497 | outerLoop: for (let step of s.steps) { |
1498 | let [i, j] = [x + step[0], this.computeY(y + step[1])]; | |
1499 | let stepCounter = 1; | |
1500 | while (this.onBoard(i, j) && this.board[i][j] == "") { | |
1501 | if (type != "attack" && !explored[i + "." + j]) { | |
1502 | explored[i + "." + j] = true; | |
1503 | moves.push(this.getBasicMove([x, y], [i, j])); | |
1504 | } | |
1505 | if (s.range <= stepCounter++) | |
1506 | continue outerLoop; | |
1507 | i += step[0]; | |
1508 | j = this.computeY(j + step[1]); | |
1509 | } | |
1510 | if (!this.onBoard(i, j)) | |
1511 | continue; | |
1512 | const pieceIJ = this.getPieceType(i, j); | |
1513 | if ( | |
1514 | type != "moveonly" && | |
1515 | !explored[i + "." + j] && | |
1516 | ( | |
1517 | !this.options["zen"] || | |
1518 | pieceIJ == "k" | |
1519 | ) && | |
1520 | ( | |
1521 | this.canTake([x, y], [i, j]) || | |
1522 | ( | |
1523 | (this.options["recycle"] || this.options["teleport"]) && | |
1524 | pieceIJ != "k" | |
1525 | ) | |
1526 | ) | |
1527 | ) { | |
1528 | explored[i + "." + j] = true; | |
1529 | moves.push(this.getBasicMove([x, y], [i, j])); | |
1530 | } | |
1531 | } | |
41534b92 | 1532 | } |
c9ab0340 BA |
1533 | }; |
1534 | ||
1535 | const specialAttack = !!stepSpec.attack; | |
1536 | if (specialAttack) | |
1537 | findAddMoves("attack", stepSpec.attack); | |
1538 | findAddMoves(specialAttack ? "moveonly" : "all", stepSpec.moves); | |
41534b92 | 1539 | if (this.options["zen"]) |
c9ab0340 | 1540 | Array.prototype.push.apply(moves, this.findCapturesOn([x, y], true)); |
41534b92 BA |
1541 | return moves; |
1542 | } | |
1543 | ||
c9ab0340 | 1544 | findCapturesOn([x, y], zen) { |
41534b92 BA |
1545 | let moves = []; |
1546 | // Find reverse captures (opponent takes) | |
1547 | const color = this.getColor(x, y); | |
cc2c7183 BA |
1548 | const pieceType = this.getPieceType(x, y); |
1549 | const oppCol = C.GetOppCol(color); | |
c9ab0340 BA |
1550 | for (let i=0; i<this.size.x; i++) { |
1551 | for (let j=0; j<this.size.y; j++) { | |
57b8015b BA |
1552 | if ( |
1553 | this.board[i][j] != "" && | |
1554 | this.canTake([i, j], [x, y]) && | |
1555 | !this.isImmobilized([i, j]) | |
1556 | ) { | |
c9ab0340 BA |
1557 | const piece = this.getPieceType(i, j); |
1558 | if (zen && C.CannibalKingCode[piece]) | |
1559 | continue; //king not captured in this way | |
1560 | const stepSpec = this.pieces(oppCol, i, j)[piece]; | |
1561 | const attacks = stepSpec.attack || stepSpec.moves; | |
1562 | for (let a of attacks) { | |
1563 | for (let s of a.steps) { | |
1564 | // Quick check: if step isn't compatible, don't even try | |
57b8015b | 1565 | if (!C.CompatibleStep([i, j], [x, y], s, a.range)) |
c9ab0340 BA |
1566 | continue; |
1567 | // Finally verify that nothing stand in-between | |
1568 | let [ii, jj] = [i + s[0], this.computeY(j + s[1])]; | |
1569 | let stepCounter = 1; | |
1570 | while (this.onBoard(ii, jj) && this.board[ii][jj] == "") { | |
1571 | ii += s[0]; | |
1572 | jj = this.computeY(jj + s[1]); | |
1573 | } | |
1574 | if (ii == x && jj == y) { | |
1575 | moves.push(this.getBasicMove([x, y], [i, j])); | |
1576 | if (!zen) | |
1577 | return moves; //test for underCheck | |
1578 | } | |
1579 | } | |
1580 | } | |
41534b92 | 1581 | } |
c9ab0340 BA |
1582 | } |
1583 | } | |
41534b92 BA |
1584 | return moves; |
1585 | } | |
1586 | ||
57b8015b BA |
1587 | static CompatibleStep([x1, y1], [x2, y2], step, range) { |
1588 | const rx = (x2 - x1) / step[0], | |
1589 | ry = (y2 - y1) / step[1]; | |
1590 | if ( | |
1591 | (!Number.isFinite(rx) && !Number.isNaN(rx)) || | |
1592 | (!Number.isFinite(ry) && !Number.isNaN(ry)) | |
1593 | ) { | |
1594 | return false; | |
1595 | } | |
1596 | let distance = (Number.isNaN(rx) ? ry : rx); | |
1597 | // TODO: 1e-7 here is totally arbitrary | |
1598 | if (Math.abs(distance - Math.round(distance)) > 1e-7) | |
1599 | return false; | |
1600 | distance = Math.round(distance); //in case of (numerical...) | |
1601 | if (range < distance) | |
1602 | return false; | |
1603 | return true; | |
1604 | } | |
1605 | ||
41534b92 BA |
1606 | // Build a regular move from its initial and destination squares. |
1607 | // tr: transformation | |
1608 | getBasicMove([sx, sy], [ex, ey], tr) { | |
1609 | const initColor = this.getColor(sx, sy); | |
cc2c7183 | 1610 | const initPiece = this.getPiece(sx, sy); |
41534b92 BA |
1611 | const destColor = (this.board[ex][ey] != "" ? this.getColor(ex, ey) : ""); |
1612 | let mv = new Move({ | |
1613 | appear: [], | |
1614 | vanish: [], | |
15106e82 BA |
1615 | start: {x: sx, y: sy}, |
1616 | end: {x: ex, y: ey} | |
41534b92 BA |
1617 | }); |
1618 | if ( | |
1619 | !this.options["rifle"] || | |
1620 | this.board[ex][ey] == "" || | |
1621 | destColor == initColor //Recycle, Teleport | |
1622 | ) { | |
1623 | mv.appear = [ | |
1624 | new PiPo({ | |
1625 | x: ex, | |
1626 | y: ey, | |
1627 | c: !!tr ? tr.c : initColor, | |
1628 | p: !!tr ? tr.p : initPiece | |
1629 | }) | |
1630 | ]; | |
1631 | mv.vanish = [ | |
1632 | new PiPo({ | |
1633 | x: sx, | |
1634 | y: sy, | |
1635 | c: initColor, | |
1636 | p: initPiece | |
1637 | }) | |
1638 | ]; | |
1639 | } | |
1640 | if (this.board[ex][ey] != "") { | |
1641 | mv.vanish.push( | |
1642 | new PiPo({ | |
1643 | x: ex, | |
1644 | y: ey, | |
1645 | c: this.getColor(ex, ey), | |
cc2c7183 | 1646 | p: this.getPiece(ex, ey) |
41534b92 BA |
1647 | }) |
1648 | ); | |
1649 | if (this.options["rifle"]) | |
1650 | // Rifle captures are tricky in combination with Atomic etc, | |
1651 | // so it's useful to mark the move : | |
1652 | mv.capture = true; | |
1653 | if (this.options["cannibal"] && destColor != initColor) { | |
1654 | const lastIdx = mv.vanish.length - 1; | |
cc2c7183 BA |
1655 | let trPiece = mv.vanish[lastIdx].p; |
1656 | if (this.isKing(this.getPiece(sx, sy))) | |
1657 | trPiece = C.CannibalKingCode[trPiece]; | |
b4ae3ff6 BA |
1658 | if (mv.appear.length >= 1) |
1659 | mv.appear[0].p = trPiece; | |
41534b92 BA |
1660 | else if (this.options["rifle"]) { |
1661 | mv.appear.unshift( | |
1662 | new PiPo({ | |
1663 | x: sx, | |
1664 | y: sy, | |
1665 | c: initColor, | |
cc2c7183 | 1666 | p: trPiece |
41534b92 BA |
1667 | }) |
1668 | ); | |
1669 | mv.vanish.unshift( | |
1670 | new PiPo({ | |
1671 | x: sx, | |
1672 | y: sy, | |
1673 | c: initColor, | |
1674 | p: initPiece | |
1675 | }) | |
1676 | ); | |
1677 | } | |
1678 | } | |
1679 | } | |
1680 | return mv; | |
1681 | } | |
1682 | ||
1683 | // En-passant square, if any | |
1684 | getEpSquare(moveOrSquare) { | |
1685 | if (typeof moveOrSquare === "string") { | |
1686 | const square = moveOrSquare; | |
b4ae3ff6 BA |
1687 | if (square == "-") |
1688 | return undefined; | |
cc2c7183 | 1689 | return C.SquareToCoords(square); |
41534b92 BA |
1690 | } |
1691 | // Argument is a move: | |
1692 | const move = moveOrSquare; | |
1693 | const s = move.start, | |
1694 | e = move.end; | |
1695 | if ( | |
1696 | s.y == e.y && | |
1697 | Math.abs(s.x - e.x) == 2 && | |
1698 | // Next conditions for variants like Atomic or Rifle, Recycle... | |
cc2c7183 BA |
1699 | (move.appear.length > 0 && move.appear[0].p == "p") && |
1700 | (move.vanish.length > 0 && move.vanish[0].p == "p") | |
41534b92 BA |
1701 | ) { |
1702 | return { | |
1703 | x: (s.x + e.x) / 2, | |
1704 | y: s.y | |
1705 | }; | |
1706 | } | |
1707 | return undefined; //default | |
1708 | } | |
1709 | ||
1710 | // Special case of en-passant captures: treated separately | |
c9ab0340 | 1711 | getEnpassantCaptures([x, y]) { |
41534b92 | 1712 | const color = this.getColor(x, y); |
c9ab0340 | 1713 | const shiftX = (color == 'w' ? -1 : 1); |
cc2c7183 | 1714 | const oppCol = C.GetOppCol(color); |
41534b92 BA |
1715 | let enpassantMove = null; |
1716 | if ( | |
1717 | !!this.epSquare && | |
1718 | this.epSquare.x == x + shiftX && | |
1719 | Math.abs(this.computeY(this.epSquare.y - y)) == 1 && | |
1720 | this.getColor(x, this.epSquare.y) == oppCol //Doublemove guard... | |
1721 | ) { | |
1722 | const [epx, epy] = [this.epSquare.x, this.epSquare.y]; | |
1723 | this.board[epx][epy] = oppCol + "p"; | |
1724 | enpassantMove = this.getBasicMove([x, y], [epx, epy]); | |
1725 | this.board[epx][epy] = ""; | |
1726 | const lastIdx = enpassantMove.vanish.length - 1; //think Rifle | |
1727 | enpassantMove.vanish[lastIdx].x = x; | |
1728 | } | |
1729 | return !!enpassantMove ? [enpassantMove] : []; | |
1730 | } | |
1731 | ||
41534b92 BA |
1732 | // "castleInCheck" arg to let some variants castle under check |
1733 | getCastleMoves([x, y], finalSquares, castleInCheck, castleWith) { | |
1734 | const c = this.getColor(x, y); | |
1735 | ||
1736 | // Castling ? | |
cc2c7183 | 1737 | const oppCol = C.GetOppCol(c); |
41534b92 BA |
1738 | let moves = []; |
1739 | // King, then rook: | |
1740 | finalSquares = | |
1741 | finalSquares || [ [2, 3], [this.size.y - 2, this.size.y - 3] ]; | |
cc2c7183 | 1742 | const castlingKing = this.getPiece(x, y); |
41534b92 BA |
1743 | castlingCheck: for ( |
1744 | let castleSide = 0; | |
1745 | castleSide < 2; | |
1746 | castleSide++ //large, then small | |
1747 | ) { | |
b4ae3ff6 BA |
1748 | if (this.castleFlags[c][castleSide] >= this.size.y) |
1749 | continue; | |
41534b92 BA |
1750 | // If this code is reached, rook and king are on initial position |
1751 | ||
1752 | // NOTE: in some variants this is not a rook | |
1753 | const rookPos = this.castleFlags[c][castleSide]; | |
cc2c7183 | 1754 | const castlingPiece = this.getPiece(x, rookPos); |
41534b92 BA |
1755 | if ( |
1756 | this.board[x][rookPos] == "" || | |
1757 | this.getColor(x, rookPos) != c || | |
1758 | (!!castleWith && !castleWith.includes(castlingPiece)) | |
1759 | ) { | |
1760 | // Rook is not here, or changed color (see Benedict) | |
1761 | continue; | |
1762 | } | |
1763 | // Nothing on the path of the king ? (and no checks) | |
1764 | const finDist = finalSquares[castleSide][0] - y; | |
1765 | let step = finDist / Math.max(1, Math.abs(finDist)); | |
1766 | let i = y; | |
1767 | do { | |
1768 | if ( | |
1769 | (!castleInCheck && this.underCheck([x, i], oppCol)) || | |
1770 | ( | |
1771 | this.board[x][i] != "" && | |
1772 | // NOTE: next check is enough, because of chessboard constraints | |
1773 | (this.getColor(x, i) != c || ![rookPos, y].includes(i)) | |
1774 | ) | |
1775 | ) { | |
1776 | continue castlingCheck; | |
1777 | } | |
1778 | i += step; | |
1779 | } while (i != finalSquares[castleSide][0]); | |
1780 | // Nothing on the path to the rook? | |
1781 | step = (castleSide == 0 ? -1 : 1); | |
1782 | for (i = y + step; i != rookPos; i += step) { | |
b4ae3ff6 BA |
1783 | if (this.board[x][i] != "") |
1784 | continue castlingCheck; | |
41534b92 BA |
1785 | } |
1786 | ||
1787 | // Nothing on final squares, except maybe king and castling rook? | |
1788 | for (i = 0; i < 2; i++) { | |
1789 | if ( | |
1790 | finalSquares[castleSide][i] != rookPos && | |
1791 | this.board[x][finalSquares[castleSide][i]] != "" && | |
1792 | ( | |
1793 | finalSquares[castleSide][i] != y || | |
1794 | this.getColor(x, finalSquares[castleSide][i]) != c | |
1795 | ) | |
1796 | ) { | |
1797 | continue castlingCheck; | |
1798 | } | |
1799 | } | |
1800 | ||
1801 | // If this code is reached, castle is valid | |
1802 | moves.push( | |
1803 | new Move({ | |
1804 | appear: [ | |
1805 | new PiPo({ | |
1806 | x: x, | |
1807 | y: finalSquares[castleSide][0], | |
1808 | p: castlingKing, | |
1809 | c: c | |
1810 | }), | |
1811 | new PiPo({ | |
1812 | x: x, | |
1813 | y: finalSquares[castleSide][1], | |
1814 | p: castlingPiece, | |
1815 | c: c | |
1816 | }) | |
1817 | ], | |
1818 | vanish: [ | |
1819 | // King might be initially disguised (Titan...) | |
1820 | new PiPo({ x: x, y: y, p: castlingKing, c: c }), | |
1821 | new PiPo({ x: x, y: rookPos, p: castlingPiece, c: c }) | |
1822 | ], | |
1823 | end: | |
1824 | Math.abs(y - rookPos) <= 2 | |
c9ab0340 BA |
1825 | ? {x: x, y: rookPos} |
1826 | : {x: x, y: y + 2 * (castleSide == 0 ? -1 : 1)} | |
41534b92 BA |
1827 | }) |
1828 | ); | |
1829 | } | |
1830 | ||
1831 | return moves; | |
1832 | } | |
1833 | ||
1834 | //////////////////// | |
1835 | // MOVES VALIDATION | |
1836 | ||
1837 | // Is (king at) given position under check by "color" ? | |
1838 | underCheck([x, y], color) { | |
b4ae3ff6 BA |
1839 | if (this.options["taking"] || this.options["dark"]) |
1840 | return false; | |
c9ab0340 | 1841 | return (this.findCapturesOn([x, y]).length >= 1); |
41534b92 BA |
1842 | } |
1843 | ||
1844 | // Stop at first king found (TODO: multi-kings) | |
1845 | searchKingPos(color) { | |
1846 | for (let i=0; i < this.size.x; i++) { | |
1847 | for (let j=0; j < this.size.y; j++) { | |
cc2c7183 BA |
1848 | if (this.getColor(i, j) == color && this.isKing(this.getPiece(i, j))) |
1849 | return [i, j]; | |
41534b92 BA |
1850 | } |
1851 | } | |
1852 | return [-1, -1]; //king not found | |
1853 | } | |
1854 | ||
1855 | filterValid(moves) { | |
b4ae3ff6 BA |
1856 | if (moves.length == 0) |
1857 | return []; | |
41534b92 | 1858 | const color = this.turn; |
cc2c7183 | 1859 | const oppCol = C.GetOppCol(color); |
41534b92 BA |
1860 | if (this.options["balance"] && [1, 3].includes(this.movesCount)) { |
1861 | // Forbid moves either giving check or exploding opponent's king: | |
1862 | const oppKingPos = this.searchKingPos(oppCol); | |
1863 | moves = moves.filter(m => { | |
1864 | if ( | |
cc2c7183 BA |
1865 | m.vanish.some(v => v.c == oppCol && v.p == "k") && |
1866 | m.appear.every(a => a.c != oppCol || a.p != "k") | |
41534b92 BA |
1867 | ) |
1868 | return false; | |
1869 | this.playOnBoard(m); | |
1870 | const res = !this.underCheck(oppKingPos, color); | |
1871 | this.undoOnBoard(m); | |
1872 | return res; | |
1873 | }); | |
1874 | } | |
b4ae3ff6 BA |
1875 | if (this.options["taking"] || this.options["dark"]) |
1876 | return moves; | |
41534b92 BA |
1877 | const kingPos = this.searchKingPos(color); |
1878 | let filtered = {}; //avoid re-checking similar moves (promotions...) | |
1879 | return moves.filter(m => { | |
1880 | const key = m.start.x + m.start.y + '.' + m.end.x + m.end.y; | |
1881 | if (!filtered[key]) { | |
1882 | this.playOnBoard(m); | |
1883 | let square = kingPos, | |
1884 | res = true; //a priori valid | |
cc2c7183 BA |
1885 | if (m.vanish.some(v => { |
1886 | return (v.p == "k" || C.CannibalKings[v.p]) && v.c == color; | |
1887 | })) { | |
41534b92 BA |
1888 | // Search king in appear array: |
1889 | const newKingIdx = | |
cc2c7183 BA |
1890 | m.appear.findIndex(a => { |
1891 | return (a.p == "k" || C.CannibalKings[a.p]) && a.c == color; | |
1892 | }); | |
41534b92 BA |
1893 | if (newKingIdx >= 0) |
1894 | square = [m.appear[newKingIdx].x, m.appear[newKingIdx].y]; | |
b4ae3ff6 BA |
1895 | else |
1896 | res = false; | |
41534b92 BA |
1897 | } |
1898 | res &&= !this.underCheck(square, oppCol); | |
1899 | this.undoOnBoard(m); | |
1900 | filtered[key] = res; | |
1901 | return res; | |
1902 | } | |
1903 | return filtered[key]; | |
1904 | }); | |
1905 | } | |
1906 | ||
1907 | ///////////////// | |
1908 | // MOVES PLAYING | |
1909 | ||
1910 | // Aggregate flags into one object | |
1911 | aggregateFlags() { | |
1912 | return this.castleFlags; | |
1913 | } | |
1914 | ||
1915 | // Reverse operation | |
1916 | disaggregateFlags(flags) { | |
1917 | this.castleFlags = flags; | |
1918 | } | |
1919 | ||
1920 | // Apply a move on board | |
1921 | playOnBoard(move) { | |
1922 | for (let psq of move.vanish) this.board[psq.x][psq.y] = ""; | |
1923 | for (let psq of move.appear) this.board[psq.x][psq.y] = psq.c + psq.p; | |
1924 | } | |
1925 | // Un-apply the played move | |
1926 | undoOnBoard(move) { | |
1927 | for (let psq of move.appear) this.board[psq.x][psq.y] = ""; | |
1928 | for (let psq of move.vanish) this.board[psq.x][psq.y] = psq.c + psq.p; | |
1929 | } | |
1930 | ||
1931 | updateCastleFlags(move) { | |
1932 | // Update castling flags if start or arrive from/at rook/king locations | |
1933 | move.appear.concat(move.vanish).forEach(psq => { | |
1934 | if ( | |
1935 | this.board[psq.x][psq.y] != "" && | |
cc2c7183 | 1936 | this.getPieceType(psq.x, psq.y) == "k" |
41534b92 BA |
1937 | ) { |
1938 | this.castleFlags[psq.c] = [this.size.y, this.size.y]; | |
1939 | } | |
1940 | // NOTE: not "else if" because king can capture enemy rook... | |
cc2c7183 | 1941 | let c = ""; |
b4ae3ff6 BA |
1942 | if (psq.x == 0) |
1943 | c = "b"; | |
1944 | else if (psq.x == this.size.x - 1) | |
1945 | c = "w"; | |
cc2c7183 | 1946 | if (c != "") { |
41534b92 | 1947 | const fidx = this.castleFlags[c].findIndex(f => f == psq.y); |
b4ae3ff6 BA |
1948 | if (fidx >= 0) |
1949 | this.castleFlags[c][fidx] = this.size.y; | |
41534b92 BA |
1950 | } |
1951 | }); | |
1952 | } | |
1953 | ||
8cc2f6d0 BA |
1954 | |
1955 | // TODO: englober + de cas ici... | |
1956 | // + generique start/end board or reserve | |
1957 | // + bien séparer les options... ? | |
1958 | ||
41534b92 BA |
1959 | prePlay(move) { |
1960 | if ( | |
1961 | typeof move.start.x == "number" && | |
cc2c7183 | 1962 | (!this.options["teleport"] || this.subTurnTeleport == 1) |
41534b92 BA |
1963 | ) { |
1964 | // OK, not a drop move | |
1965 | if ( | |
1966 | this.hasCastle && | |
1967 | // If flags already off, no need to re-check: | |
1968 | Object.keys(this.castleFlags).some(c => { | |
1969 | return this.castleFlags[c].some(val => val < this.size.y)}) | |
1970 | ) { | |
1971 | this.updateCastleFlags(move); | |
1972 | } | |
cc2c7183 | 1973 | const initSquare = C.CoordsToSquare(move.start); |
41534b92 BA |
1974 | if ( |
1975 | this.options["crazyhouse"] && | |
1976 | (!this.options["rifle"] || !move.capture) | |
1977 | ) { | |
f429756d | 1978 | const destSquare = C.CoordsToSquare(move.end); |
41534b92 BA |
1979 | if (this.ispawn[initSquare]) { |
1980 | delete this.ispawn[initSquare]; | |
f429756d | 1981 | this.ispawn[destSquare] = true; |
41534b92 BA |
1982 | } |
1983 | else if ( | |
cc2c7183 BA |
1984 | move.vanish[0].p == "p" && |
1985 | move.appear[0].p != "p" | |
41534b92 | 1986 | ) { |
f429756d BA |
1987 | this.ispawn[destSquare] = true; |
1988 | } | |
1989 | else if ( | |
1990 | this.ispawn[destSquare] && | |
1991 | this.getColor(move.end.x, move.end.y) != move.vanish[0].c | |
1992 | ) { | |
1993 | move.vanish[1].p = "p"; | |
1994 | delete this.ispawn[destSquare]; | |
41534b92 BA |
1995 | } |
1996 | } | |
1997 | } | |
1998 | const minSize = Math.min(move.appear.length, move.vanish.length); | |
f8b43ef7 | 1999 | if (this.hasReserve && !move.pawnfall) { |
41534b92 BA |
2000 | const color = this.turn; |
2001 | for (let i=minSize; i<move.appear.length; i++) { | |
2002 | // Something appears = dropped on board (some exceptions, Chakart...) | |
2003 | const piece = move.appear[i].p; | |
2004 | this.updateReserve(color, piece, this.reserve[color][piece] - 1); | |
2005 | } | |
2006 | for (let i=minSize; i<move.vanish.length; i++) { | |
2007 | // Something vanish: add to reserve except if recycle & opponent | |
2008 | const piece = move.vanish[i].p; | |
2009 | if (this.options["crazyhouse"] || move.vanish[i].c == color) | |
2010 | this.updateReserve(color, piece, this.reserve[color][piece] + 1); | |
2011 | } | |
2012 | } | |
2013 | } | |
2014 | ||
2015 | play(move) { | |
2016 | this.prePlay(move); | |
b4ae3ff6 BA |
2017 | if (this.hasEnpassant) |
2018 | this.epSquare = this.getEpSquare(move); | |
41534b92 BA |
2019 | this.playOnBoard(move); |
2020 | this.postPlay(move); | |
2021 | } | |
2022 | ||
2023 | postPlay(move) { | |
2024 | const color = this.turn; | |
cc2c7183 | 2025 | const oppCol = C.GetOppCol(color); |
b4ae3ff6 | 2026 | if (this.options["dark"]) |
c9ab0340 | 2027 | this.updateEnlightened(); |
41534b92 BA |
2028 | if (this.options["teleport"]) { |
2029 | if ( | |
cc2c7183 | 2030 | this.subTurnTeleport == 1 && |
41534b92 BA |
2031 | move.vanish.length > move.appear.length && |
2032 | move.vanish[move.vanish.length - 1].c == color | |
2033 | ) { | |
2034 | const v = move.vanish[move.vanish.length - 1]; | |
2035 | this.captured = {x: v.x, y: v.y, c: v.c, p: v.p}; | |
cc2c7183 | 2036 | this.subTurnTeleport = 2; |
41534b92 BA |
2037 | return; |
2038 | } | |
cc2c7183 | 2039 | this.subTurnTeleport = 1; |
41534b92 BA |
2040 | this.captured = null; |
2041 | } | |
2042 | if (this.options["balance"]) { | |
b4ae3ff6 BA |
2043 | if (![1, 3].includes(this.movesCount)) |
2044 | this.turn = oppCol; | |
41534b92 BA |
2045 | } |
2046 | else { | |
2047 | if ( | |
2048 | ( | |
2049 | this.options["doublemove"] && | |
2050 | this.movesCount >= 1 && | |
2051 | this.subTurn == 1 | |
2052 | ) || | |
2053 | (this.options["progressive"] && this.subTurn <= this.movesCount) | |
2054 | ) { | |
2055 | const oppKingPos = this.searchKingPos(oppCol); | |
6f74b81a BA |
2056 | if ( |
2057 | oppKingPos[0] >= 0 && | |
2058 | ( | |
2059 | this.options["taking"] || | |
2060 | !this.underCheck(oppKingPos, color) | |
2061 | ) | |
2062 | ) { | |
41534b92 BA |
2063 | this.subTurn++; |
2064 | return; | |
2065 | } | |
2066 | } | |
2067 | this.turn = oppCol; | |
2068 | } | |
2069 | this.movesCount++; | |
2070 | this.subTurn = 1; | |
2071 | } | |
2072 | ||
2073 | // "Stop at the first move found" | |
2074 | atLeastOneMove(color) { | |
2075 | color = color || this.turn; | |
2076 | for (let i = 0; i < this.size.x; i++) { | |
2077 | for (let j = 0; j < this.size.y; j++) { | |
2078 | if (this.board[i][j] != "" && this.getColor(i, j) == color) { | |
cc2c7183 BA |
2079 | // NOTE: in fact searching for all potential moves from i,j. |
2080 | // I don't believe this is an issue, for now at least. | |
41534b92 | 2081 | const moves = this.getPotentialMovesFrom([i, j]); |
b4ae3ff6 BA |
2082 | if (moves.some(m => this.filterValid([m]).length >= 1)) |
2083 | return true; | |
41534b92 BA |
2084 | } |
2085 | } | |
2086 | } | |
2087 | if (this.hasReserve && this.reserve[color]) { | |
2088 | for (let p of Object.keys(this.reserve[color])) { | |
2089 | const moves = this.getDropMovesFrom([color, p]); | |
b4ae3ff6 BA |
2090 | if (moves.some(m => this.filterValid([m]).length >= 1)) |
2091 | return true; | |
41534b92 BA |
2092 | } |
2093 | } | |
2094 | return false; | |
2095 | } | |
2096 | ||
2097 | // What is the score ? (Interesting if game is over) | |
2098 | getCurrentScore(move) { | |
2099 | const color = this.turn; | |
cc2c7183 | 2100 | const oppCol = C.GetOppCol(color); |
41534b92 | 2101 | const kingPos = [this.searchKingPos(color), this.searchKingPos(oppCol)]; |
b4ae3ff6 BA |
2102 | if (kingPos[0][0] < 0 && kingPos[1][0] < 0) |
2103 | return "1/2"; | |
2104 | if (kingPos[0][0] < 0) | |
2105 | return (color == "w" ? "0-1" : "1-0"); | |
2106 | if (kingPos[1][0] < 0) | |
2107 | return (color == "w" ? "1-0" : "0-1"); | |
2108 | if (this.atLeastOneMove()) | |
2109 | return "*"; | |
41534b92 | 2110 | // No valid move: stalemate or checkmate? |
c9ab0340 | 2111 | if (!this.underCheck(kingPos[0], color)) |
b4ae3ff6 | 2112 | return "1/2"; |
41534b92 BA |
2113 | // OK, checkmate |
2114 | return (color == "w" ? "0-1" : "1-0"); | |
2115 | } | |
2116 | ||
cc2c7183 | 2117 | // NOTE: quite suboptimal for eg. Benedict (not a big deal I think) |
41534b92 BA |
2118 | playVisual(move, r) { |
2119 | move.vanish.forEach(v => { | |
c9ab0340 BA |
2120 | // TODO: next "if" shouldn't be required |
2121 | if (this.g_pieces[v.x][v.y]) | |
2122 | this.g_pieces[v.x][v.y].remove(); | |
2123 | this.g_pieces[v.x][v.y] = null; | |
41534b92 | 2124 | }); |
3c61449b BA |
2125 | let chessboard = |
2126 | document.getElementById(this.containerId).querySelector(".chessboard"); | |
b4ae3ff6 BA |
2127 | if (!r) |
2128 | r = chessboard.getBoundingClientRect(); | |
41534b92 BA |
2129 | const pieceWidth = this.getPieceWidth(r.width); |
2130 | move.appear.forEach(a => { | |
41534b92 BA |
2131 | this.g_pieces[a.x][a.y] = document.createElement("piece"); |
2132 | this.g_pieces[a.x][a.y].classList.add(this.pieces()[a.p]["class"]); | |
2133 | this.g_pieces[a.x][a.y].classList.add(a.c == "w" ? "white" : "black"); | |
2134 | this.g_pieces[a.x][a.y].style.width = pieceWidth + "px"; | |
2135 | this.g_pieces[a.x][a.y].style.height = pieceWidth + "px"; | |
2136 | const [ip, jp] = this.getPixelPosition(a.x, a.y, r); | |
2137 | this.g_pieces[a.x][a.y].style.transform = `translate(${ip}px,${jp}px)`; | |
c9ab0340 BA |
2138 | if (this.enlightened && !this.enlightened[a.x][a.y]) |
2139 | this.g_pieces[a.x][a.y].classList.add("hidden"); | |
3c61449b | 2140 | chessboard.appendChild(this.g_pieces[a.x][a.y]); |
41534b92 | 2141 | }); |
c9ab0340 BA |
2142 | if (this.options["dark"]) |
2143 | this.graphUpdateEnlightened(); | |
41534b92 BA |
2144 | } |
2145 | ||
2146 | playPlusVisual(move, r) { | |
41534b92 | 2147 | this.play(move); |
c9ab0340 | 2148 | this.playVisual(move, r); |
41534b92 BA |
2149 | this.afterPlay(move); //user method |
2150 | } | |
2151 | ||
15106e82 BA |
2152 | getMaxDistance(rwidth) { |
2153 | // Works for all rectangular boards: | |
2154 | return Math.sqrt(rwidth ** 2 + (rwidth / this.size.ratio) ** 2); | |
2155 | } | |
2156 | ||
2157 | getDomPiece(x, y) { | |
2158 | return (typeof x == "string" ? this.r_pieces : this.g_pieces)[x][y]; | |
41534b92 BA |
2159 | } |
2160 | ||
2161 | animate(move, callback) { | |
15106e82 | 2162 | if (this.noAnimate || move.noAnimate) { |
e8b85c86 BA |
2163 | callback(); |
2164 | return; | |
2165 | } | |
15106e82 | 2166 | let movingPiece = this.getDomPiece(move.start.x, move.start.y); |
639afc98 BA |
2167 | if (!movingPiece) { //TODO this shouldn't be required |
2168 | callback(); | |
2169 | return; | |
2170 | } | |
15106e82 | 2171 | const initTransform = movingPiece.style.transform; |
3c61449b BA |
2172 | let chessboard = |
2173 | document.getElementById(this.containerId).querySelector(".chessboard"); | |
15106e82 BA |
2174 | const r = chessboard.getBoundingClientRect(); |
2175 | const [ix, iy] = this.getPixelPosition(move.start.x, move.start.y, r); | |
2176 | const maxDist = this.getMaxDistance(r.width); | |
2177 | // NOTE: move.drag could be generalized per-segment (usage?) | |
2178 | if (move.drag) { | |
2179 | // Drag something else: require cloning | |
2180 | movingPiece = movingPiece.cloneNode(); | |
2181 | const pieces = this.pieces(); | |
2182 | const startCode = this.getPiece(move.start.x, move.start.y); | |
2183 | movingPiece.classList.remove(pieces[startCode]["class"]); | |
2184 | movingPiece.classList.add(pieces[move.drag.p]["class"]); | |
2185 | const apparentColor = this.getColor(move.start.x, move.start.y); | |
2186 | if (apparentColor != move.drag.c) { | |
2187 | movingPiece.classList.remove(C.GetColorClass(apparentColor)); | |
2188 | movingPiece.classList.add(C.GetColorClass(move.drag.c)); | |
41534b92 | 2189 | } |
15106e82 | 2190 | chessboard.appendChild(movingPiece); |
41534b92 | 2191 | } |
15106e82 BA |
2192 | const animateSegment = (index, cb) => { |
2193 | const [i1, j1] = move.segments[index][0]; | |
2194 | const [i2, j2] = move.segments[index][1]; | |
2195 | const dep = this.getPixelPosition(i1, j1, r); | |
2196 | const arr = this.getPixelPosition(i2, j2, r); | |
15106e82 BA |
2197 | const distance = |
2198 | Math.sqrt((arr[0] - dep[0]) ** 2 + (arr[1] - dep[1]) ** 2); | |
2199 | const duration = 0.2 + (distance / maxDist) * 0.3; | |
449d72e3 | 2200 | movingPiece.style.transform = `translate(${arr[0]}px, ${arr[1]}px)`; |
15106e82 BA |
2201 | movingPiece.style.transitionDuration = duration + "s"; |
2202 | setTimeout(cb, duration * 1000); | |
2203 | }; | |
635418a5 BA |
2204 | if (!move.segments) { |
2205 | move.segments = [ | |
2206 | [[move.start.x, move.start.y], [move.end.x, move.end.y]] | |
2207 | ]; | |
2208 | } | |
15106e82 | 2209 | let index = 0; |
635418a5 | 2210 | const animateSegmentCallback = () => { |
15106e82 | 2211 | if (index < move.segments.length) |
635418a5 | 2212 | animateSegment(index++, animateSegmentCallback); |
15106e82 BA |
2213 | else { |
2214 | if (move.drag) | |
2215 | movingPiece.remove(); | |
bc34b505 | 2216 | else { |
15106e82 BA |
2217 | movingPiece.style.transform = initTransform; |
2218 | movingPiece.style.transitionDuration = "0s"; | |
bc34b505 | 2219 | } |
41534b92 | 2220 | callback(); |
15106e82 | 2221 | } |
635418a5 BA |
2222 | }; |
2223 | animateSegmentCallback(); | |
41534b92 BA |
2224 | } |
2225 | ||
2226 | playReceivedMove(moves, callback) { | |
21e8e712 | 2227 | const launchAnimation = () => { |
3c61449b | 2228 | const r = container.querySelector(".chessboard").getBoundingClientRect(); |
21e8e712 BA |
2229 | const animateRec = i => { |
2230 | this.animate(moves[i], () => { | |
21e8e712 | 2231 | this.play(moves[i]); |
57b8015b | 2232 | this.playVisual(moves[i], r); |
b4ae3ff6 BA |
2233 | if (i < moves.length - 1) |
2234 | setTimeout(() => animateRec(i+1), 300); | |
2235 | else | |
2236 | callback(); | |
21e8e712 BA |
2237 | }); |
2238 | }; | |
2239 | animateRec(0); | |
2240 | }; | |
e081c5eb BA |
2241 | // Delay if user wasn't focused: |
2242 | const checkDisplayThenAnimate = (delay) => { | |
3c61449b | 2243 | if (container.style.display == "none") { |
21e8e712 BA |
2244 | alert("New move! Let's go back to game..."); |
2245 | document.getElementById("gameInfos").style.display = "none"; | |
3c61449b | 2246 | container.style.display = "block"; |
21e8e712 BA |
2247 | setTimeout(launchAnimation, 700); |
2248 | } | |
b4ae3ff6 BA |
2249 | else |
2250 | setTimeout(launchAnimation, delay || 0); | |
21e8e712 | 2251 | }; |
3c61449b | 2252 | let container = document.getElementById(this.containerId); |
016306e3 BA |
2253 | if (document.hidden) { |
2254 | document.onvisibilitychange = () => { | |
2255 | document.onvisibilitychange = undefined; | |
e081c5eb | 2256 | checkDisplayThenAnimate(700); |
fd31883b | 2257 | }; |
fd31883b | 2258 | } |
b4ae3ff6 BA |
2259 | else |
2260 | checkDisplayThenAnimate(); | |
41534b92 BA |
2261 | } |
2262 | ||
2263 | }; |