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