X-Git-Url: https://git.auder.net/pieces/Checkered/cq.svg?a=blobdiff_plain;f=base_rules.js;h=311750689fdb7b797a1689e897db05b6af245c0e;hb=6d8c4fc35e9072806f91b29874753e12942c2bae;hp=d743c0e27f8301928dca99454094827a5998385d;hpb=15106e8201ee8e46ce14f1dd369cae960e9a860c;p=xogo.git
diff --git a/base_rules.js b/base_rules.js
index d743c0e..3117506 100644
--- a/base_rules.js
+++ b/base_rules.js
@@ -98,7 +98,7 @@ export default class ChessRules {
this.options["teleport"] && this.subTurnTeleport == 2 &&
this.board[coords.x][coords.y] == ""
) {
- return new Move({
+ let res = new Move({
start: {x: this.captured.x, y: this.captured.y},
appear: [
new PiPo({
@@ -108,9 +108,10 @@ export default class ChessRules {
p: this.captured.p
})
],
- vanish: [],
- drag: {c: this.captured.c, p: this.captured.p}
+ vanish: []
});
+ res.drag = {c: this.captured.c, p: this.captured.p};
+ return res;
}
return null;
}
@@ -118,13 +119,13 @@ export default class ChessRules {
////////////////////
// COORDINATES UTILS
- // a3 --> {x:10, y:3}
+ // 3a --> {x:3, y:10}
static SquareToCoords(sq) {
return ArrayFun.toObject(["x", "y"],
[0, 1].map(i => parseInt(sq[i], 36)));
}
- // {x:1, y:12} --> 1c
+ // {x:11, y:12} --> bc
static CoordsToSquare(cd) {
return Object.values(cd).map(c => c.toString(36)).join("");
}
@@ -162,12 +163,12 @@ export default class ChessRules {
// Turn "wb" into "B" (for FEN)
board2fen(b) {
- return b[0] == "w" ? b[1].toUpperCase() : b[1];
+ return (b[0] == "w" ? b[1].toUpperCase() : b[1]);
}
// Turn "p" into "bp" (for board)
fen2board(f) {
- return f.charCodeAt(0) <= 90 ? "w" + f.toLowerCase() : "b" + f;
+ return (f.charCodeAt(0) <= 90 ? "w" + f.toLowerCase() : "b" + f);
}
// Setup the initial random-or-not (asymmetric-or-not) position
@@ -289,19 +290,20 @@ export default class ChessRules {
return fen;
}
+ static FenEmptySquares(count) {
+ // if more than 9 consecutive free spaces, break the integer,
+ // otherwise FEN parsing will fail.
+ if (count <= 9)
+ return count;
+ // Most boards of size < 18:
+ if (count <= 18)
+ return "9" + (count - 9);
+ // Except Gomoku:
+ return "99" + (count - 18);
+ }
+
// Position part of the FEN string
getPosition() {
- const format = (count) => {
- // if more than 9 consecutive free spaces, break the integer,
- // otherwise FEN parsing will fail.
- if (count <= 9)
- return count;
- // Most boards of size < 18:
- if (count <= 18)
- return "9" + (count - 9);
- // Except Gomoku:
- return "99" + (count - 18);
- };
let position = "";
for (let i = 0; i < this.size.y; i++) {
let emptyCount = 0;
@@ -311,7 +313,7 @@ export default class ChessRules {
else {
if (emptyCount > 0) {
// Add empty squares in-between
- position += format(emptyCount);
+ position += C.FenEmptySquares(emptyCount);
emptyCount = 0;
}
position += this.board2fen(this.board[i][j]);
@@ -319,7 +321,7 @@ export default class ChessRules {
}
if (emptyCount > 0)
// "Flush remainder"
- position += format(emptyCount);
+ position += C.FenEmptySquares(emptyCount);
if (i < this.size.y - 1)
position += "/"; //separate rows
}
@@ -370,6 +372,11 @@ export default class ChessRules {
constructor(o) {
this.options = o.options;
+ // Fill missing options (always the case if random challenge)
+ (V.Options.select || []).concat(V.Options.input || []).forEach(opt => {
+ if (this.options[opt.variable] === undefined)
+ this.options[opt.variable] = opt.defaut;
+ });
this.playerColor = o.color;
this.afterPlay = o.afterPlay; //trigger some actions after playing a move
@@ -455,7 +462,7 @@ export default class ChessRules {
const steps = this.pieces(this.playerColor)["p"].attack[0].steps;
for (let step of steps) {
const x = this.epSquare.x - step[0],
- y = this.computeY(this.epSquare.y - step[1]);
+ y = this.getY(this.epSquare.y - step[1]);
if (
this.onBoard(x, y) &&
this.getColor(x, y) == this.playerColor &&
@@ -526,7 +533,8 @@ export default class ChessRules {
this.initMouseEvents();
const chessboard =
document.getElementById(this.containerId).querySelector(".chessboard");
- new ResizeObserver(this.rescale).observe(chessboard);
+ // TODO: calling with "this" seems required by Hex. Understand why...
+ new ResizeObserver(() => this.rescale(this)).observe(chessboard);
}
re_drawBoardElements() {
@@ -549,7 +557,7 @@ export default class ChessRules {
cbHeight = Math.min(window.innerHeight, 767);
cbWidth = cbHeight * this.size.ratio;
}
- if (this.reserve) {
+ if (this.hasReserve) {
const sqSize = cbWidth / this.size.y;
// NOTE: allocate space for reserves (up/down) even if they are empty
// Cannot use getReserveSquareSize() here, but sqSize is an upper bound.
@@ -581,8 +589,7 @@ export default class ChessRules {
let board = `
";
+ board += "";
return board;
}
@@ -638,15 +647,17 @@ export default class ChessRules {
this.g_pieces[i][j].classList.add(C.GetColorClass(color));
this.g_pieces[i][j].style.width = pieceWidth + "px";
this.g_pieces[i][j].style.height = pieceWidth + "px";
- const [ip, jp] = this.getPixelPosition(i, j, r);
- this.g_pieces[i][j].style.transform = `translate(${ip}px,${jp}px)`;
+ let [ip, jp] = this.getPixelPosition(i, j, r);
+ // Translate coordinates to use chessboard as reference:
+ this.g_pieces[i][j].style.transform =
+ `translate(${ip - r.x}px,${jp - r.y}px)`;
if (this.enlightened && !this.enlightened[i][j])
this.g_pieces[i][j].classList.add("hidden");
chessboard.appendChild(this.g_pieces[i][j]);
}
}
}
- if (this.reserve)
+ if (this.hasReserve)
this.re_drawReserve(['w', 'b'], r);
}
@@ -671,11 +682,10 @@ export default class ChessRules {
}
}
else
- this.r_pieces = { 'w': {}, 'b': {} };
- let chessboard =
- document.getElementById(this.containerId).querySelector(".chessboard");
+ this.r_pieces = { w: {}, b: {} };
+ let container = document.getElementById(this.containerId);
if (!r)
- r = chessboard.getBoundingClientRect();
+ r = container.querySelector(".chessboard").getBoundingClientRect();
for (let c of colors) {
if (!this.reserve[c])
continue;
@@ -694,7 +704,7 @@ export default class ChessRules {
// NOTE: +1 fix display bug on Firefox at least
rcontainer.style.width = (nbR * sqResSize + 1) + "px";
rcontainer.style.height = sqResSize + "px";
- chessboard.appendChild(rcontainer);
+ container.appendChild(rcontainer);
for (let p of Object.keys(this.reserve[c])) {
if (this.reserve[c][p] == 0)
continue;
@@ -748,13 +758,13 @@ export default class ChessRules {
for (let x=0; x this.size.ratio) {
- newWidth = r.height * this.size.ratio;
- chessboard.style.width = newWidth + "px";
- }
- else if (newRatio < this.size.ratio) {
- newHeight = r.width / this.size.ratio;
- chessboard.style.height = newHeight + "px";
- }
+ let r = chessboard.getBoundingClientRect();
+ let [newWidth, newHeight] = [r.width, r.height];
+ // Stay in window:
+ if (newWidth > window.innerWidth)
+ newWidth = window.innerWidth;
+ if (newHeight > window.innerHeight)
+ newHeight = window.innerHeight;
+ const newRatio = newWidth / newHeight;
+ const epsilon = 1e-4; //arbitrary small value to avoid instabilities
+ if (newRatio - self.size.ratio > epsilon)
+ newWidth = newHeight * self.size.ratio;
+ else if (newRatio - self.size.ratio < -epsilon)
+ newHeight = newWidth / self.size.ratio;
+ chessboard.style.width = newWidth + "px";
+ chessboard.style.height = newHeight + "px";
const newX = (window.innerWidth - newWidth) / 2;
chessboard.style.left = newX + "px";
const newY = (window.innerHeight - newHeight) / 2;
chessboard.style.top = newY + "px";
- const newR = { x: newX, y: newY, width: newWidth, height: newHeight };
- const pieceWidth = this.getPieceWidth(newWidth);
- for (let i=0; i < this.size.x; i++) {
- for (let j=0; j < this.size.y; j++) {
- if (this.g_pieces[i][j]) {
- // NOTE: could also use CSS transform "scale"
- this.g_pieces[i][j].style.width = pieceWidth + "px";
- this.g_pieces[i][j].style.height = pieceWidth + "px";
- const [ip, jp] = this.getPixelPosition(i, j, newR);
- this.g_pieces[i][j].style.transform = `translate(${ip}px,${jp}px)`;
+ const newR = {x: newX, y: newY, width: newWidth, height: newHeight};
+ const pieceWidth = self.getPieceWidth(newWidth);
+ // NOTE: next "if" for variants which use squares filling
+ // instead of "physical", moving pieces
+ if (this.g_pieces) {
+ for (let i=0; i < self.size.x; i++) {
+ for (let j=0; j < self.size.y; j++) {
+ if (self.g_pieces[i][j]) {
+ // NOTE: could also use CSS transform "scale"
+ self.g_pieces[i][j].style.width = pieceWidth + "px";
+ self.g_pieces[i][j].style.height = pieceWidth + "px";
+ const [ip, jp] = self.getPixelPosition(i, j, newR);
+ // Translate coordinates to use chessboard as reference:
+ self.g_pieces[i][j].style.transform =
+ `translate(${ip - newX}px,${jp - newY}px)`;
+ }
}
}
}
- if (this.reserve)
- this.rescaleReserve(newR);
+ if (self.hasReserve)
+ self.rescaleReserve(newR);
}
rescaleReserve(r) {
@@ -830,7 +849,7 @@ export default class ChessRules {
}
}
- // Return the absolute pixel coordinates (on board) given current position.
+ // Return the absolute pixel coordinates given current position.
// Our coordinate system differs from CSS one (x <--> y).
// We return here the CSS coordinates (more useful).
getPixelPosition(i, j, r) {
@@ -850,12 +869,12 @@ export default class ChessRules {
x = (flipped ? this.size.y - 1 - j : j) * sqSize;
y = (flipped ? this.size.x - 1 - i : i) * sqSize;
}
- return [x, y];
+ return [r.x + x, r.y + y];
}
initMouseEvents() {
- let chessboard =
- document.getElementById(this.containerId).querySelector(".chessboard");
+ let container = document.getElementById(this.containerId);
+ let chessboard = container.querySelector(".chessboard");
const getOffset = e => {
if (e.clientX)
@@ -876,8 +895,8 @@ export default class ChessRules {
const centerOnCursor = (piece, e) => {
const centerShift = this.getPieceWidth(r.width) / 2;
const offset = getOffset(e);
- piece.style.left = (offset.x - r.x - centerShift) + "px";
- piece.style.top = (offset.y - r.y - centerShift) + "px";
+ piece.style.left = (offset.x - centerShift) + "px";
+ piece.style.top = (offset.y - centerShift) + "px";
}
let start = null,
@@ -910,7 +929,7 @@ export default class ChessRules {
curPiece.style.width = pieceWidth + "px";
curPiece.style.height = pieceWidth + "px";
centerOnCursor(curPiece, e);
- chessboard.appendChild(curPiece);
+ container.appendChild(curPiece);
startPiece.style.opacity = "0.4";
chessboard.style.cursor = "none";
}
@@ -1043,7 +1062,7 @@ export default class ChessRules {
// Piece type on square (i,j)
getPieceType(i, j) {
- const p = (typeof i == "string" ? j : this.board[i][j].charAt(1));
+ const p = this.getPiece(i, j);
return C.CannibalKings[p] || p; //a cannibal king move as...
}
@@ -1065,13 +1084,7 @@ export default class ChessRules {
// Am I allowed to move thing at square x,y ?
canIplay(x, y) {
- return (
- this.playerColor == this.turn &&
- (
- (typeof x == "number" && this.getColor(x, y) == this.turn) ||
- (typeof x == "string" && x == this.turn) //reserve
- )
- );
+ return (this.playerColor == this.turn && this.getColor(x, y) == this.turn);
}
////////////////////////
@@ -1079,7 +1092,8 @@ export default class ChessRules {
pieces(color, x, y) {
const pawnShift = (color == "w" ? -1 : 1);
- const initRank = ((color == 'w' && x == 6) || (color == 'b' && x == 1));
+ // NOTE: jump 2 squares from first rank (pawns can be here sometimes)
+ const initRank = ((color == 'w' && x >= 6) || (color == 'b' && x <= 1));
return {
'p': {
"class": "pawn",
@@ -1161,7 +1175,7 @@ export default class ChessRules {
// MOVES GENERATION
// For Cylinder: get Y coordinate
- computeY(y) {
+ getY(y) {
if (!this.options["cylinder"])
return y;
let res = y % this.size.y;
@@ -1182,13 +1196,13 @@ export default class ChessRules {
const attacks = specs.attack || specs.moves;
for (let a of attacks) {
outerLoop: for (let step of a.steps) {
- let [ii, jj] = [i + step[0], this.computeY(j + step[1])];
+ let [ii, jj] = [i + step[0], this.getY(j + step[1])];
let stepCounter = 1;
while (this.onBoard(ii, jj) && this.board[ii][jj] == "") {
if (a.range <= stepCounter++)
continue outerLoop;
ii += step[0];
- jj = this.computeY(jj + step[1]);
+ jj = this.getY(jj + step[1]);
}
if (
this.onBoard(ii, jj) &&
@@ -1209,7 +1223,7 @@ export default class ChessRules {
getDropMovesFrom([c, p]) {
// NOTE: by design, this.reserve[c][p] >= 1 on user click
- // (but not necessarily otherwise)
+ // (but not necessarily otherwise: atLeastOneMove() etc)
if (this.reserve[c][p] == 0)
return [];
let moves = [];
@@ -1289,7 +1303,7 @@ export default class ChessRules {
this.options["rifle"]
) {
// In this case a rifle-capture from last rank may promote a pawn
- this.riflePromotePostProcess(moves);
+ this.riflePromotePostProcess(moves, color);
}
return moves;
@@ -1325,7 +1339,7 @@ export default class ChessRules {
];
for (let step of steps) {
let x = m.end.x + step[0];
- let y = this.computeY(m.end.y + step[1]);
+ let y = this.getY(m.end.y + step[1]);
if (
this.onBoard(x, y) &&
this.board[x][y] != "" &&
@@ -1342,7 +1356,7 @@ export default class ChessRules {
}
}
if (!this.options["rifle"])
- m.appear.pop(); //nothin appears
+ m.appear.pop(); //nothing appears
}
});
}
@@ -1352,7 +1366,6 @@ export default class ChessRules {
const lastRank = (color == "w" ? 0 : this.size.x - 1);
const initPiece = this.getPiece(moves[0].start.x, moves[0].start.y);
moves.forEach(m => {
- let finalPieces = ["p"];
const [x1, y1] = [m.start.x, m.start.y];
const [x2, y2] = [m.end.x, m.end.y];
const promotionOk = (
@@ -1361,41 +1374,37 @@ export default class ChessRules {
);
if (!promotionOk)
return; //nothing to do
- if (!this.options["pawnfall"]) {
- if (
- this.options["cannibal"] &&
- this.board[x2][y2] != "" &&
- this.getColor(x2, y2) == oppCol
- ) {
- finalPieces = [this.getPieceType(x2, y2)];
- }
- else
- finalPieces = this.pawnPromotions;
+ if (this.options["pawnfall"]) {
+ m.appear.shift();
+ return;
+ }
+ let finalPieces = ["p"];
+ if (
+ this.options["cannibal"] &&
+ this.board[x2][y2] != "" &&
+ this.getColor(x2, y2) == oppCol
+ ) {
+ finalPieces = [this.getPieceType(x2, y2)];
}
+ else
+ finalPieces = this.pawnPromotions;
m.appear[0].p = finalPieces[0];
if (initPiece == "!") //cannibal king-pawn
m.appear[0].p = C.CannibalKingCode[finalPieces[0]];
for (let i=1; i {
@@ -1406,7 +1415,6 @@ export default class ChessRules {
m.appear[0].x == m.start.x &&
m.appear[0].y == m.start.y
) {
- const promotionPiece0 = this.pawnSpecs.promotions[0];
m.appear[0].p = this.pawnPromotions[0];
for (let i=1; i {
+ let newMove = this.getBasicMove(start, end);
+ if (segments.length > 0) {
+ newMove.segments = JSON.parse(JSON.stringify(segments));
+ newMove.segments.push([[segStart[0], segStart[1]], [end[0], end[1]]]);
+ }
+ moves.push(newMove);
+ };
const findAddMoves = (type, stepArray) => {
for (let s of stepArray) {
- // TODO: if jump in y (computeY, Cylinder), move.segments
outerLoop: for (let step of s.steps) {
- let [i, j] = [x + step[0], this.computeY(y + step[1])];
- let stepCounter = 1;
- while (this.onBoard(i, j) && this.board[i][j] == "") {
- if (type != "attack" && !explored[i + "." + j]) {
+ segments = [];
+ segStart = [x, y];
+ let [i, j] = [x, y];
+ let stepCounter = 0;
+ while (
+ this.onBoard(i, j) &&
+ (this.board[i][j] == "" || (i == x && j == y))
+ ) {
+ if (
+ type != "attack" &&
+ !explored[i + "." + j] &&
+ (i != x || j != y)
+ ) {
explored[i + "." + j] = true;
- moves.push(this.getBasicMove([x, y], [i, j]));
+ addMove([x, y], [i, j]);
}
if (s.range <= stepCounter++)
continue outerLoop;
+ const oldIJ = [i, j];
i += step[0];
- j = this.computeY(j + step[1]);
+ j = this.getY(j + step[1]);
+ if (Math.abs(j - oldIJ[1]) > 1) {
+ // Boundary between segments (cylinder mode)
+ segments.push([[segStart[0], segStart[1]], oldIJ]);
+ segStart = [i, j];
+ }
}
if (!this.onBoard(i, j))
continue;
@@ -1521,7 +1553,7 @@ export default class ChessRules {
)
) {
explored[i + "." + j] = true;
- moves.push(this.getBasicMove([x, y], [i, j]));
+ addMove([x, y], [i, j]);
}
}
}
@@ -1531,28 +1563,29 @@ export default class ChessRules {
if (specialAttack)
findAddMoves("attack", stepSpec.attack);
findAddMoves(specialAttack ? "moveonly" : "all", stepSpec.moves);
- if (this.options["zen"])
- Array.prototype.push.apply(moves, this.findCapturesOn([x, y], true));
+ if (this.options["zen"]) {
+ Array.prototype.push.apply(moves,
+ this.findCapturesOn([x, y], {zen: true}));
+ }
return moves;
}
- findCapturesOn([x, y], zen) {
+ // Search for enemy (or not) pieces attacking [x, y]
+ findCapturesOn([x, y], args) {
let moves = [];
- // Find reverse captures (opponent takes)
- const color = this.getColor(x, y);
- const pieceType = this.getPieceType(x, y);
- const oppCol = C.GetOppCol(color);
+ if (!args.oppCol)
+ args.oppCol = C.GetOppCol(this.getColor(x, y) || this.turn);
for (let i=0; i= 1);
+ return (
+ this.findCapturesOn([x, y], {oppCol: oppCol, one: true}).length >= 1
+ );
}
// Stop at first king found (TODO: multi-kings)
@@ -1878,12 +1917,12 @@ export default class ChessRules {
let square = kingPos,
res = true; //a priori valid
if (m.vanish.some(v => {
- return (v.p == "k" || C.CannibalKings[v.p]) && v.c == color;
+ return C.CannibalKings[v.p] && v.c == color;
})) {
// Search king in appear array:
const newKingIdx =
m.appear.findIndex(a => {
- return (a.p == "k" || C.CannibalKings[a.p]) && a.c == color;
+ return C.CannibalKings[a.p] && a.c == color;
});
if (newKingIdx >= 0)
square = [m.appear[newKingIdx].x, m.appear[newKingIdx].y];
@@ -1914,13 +1953,17 @@ export default class ChessRules {
// Apply a move on board
playOnBoard(move) {
- for (let psq of move.vanish) this.board[psq.x][psq.y] = "";
- for (let psq of move.appear) this.board[psq.x][psq.y] = psq.c + psq.p;
+ for (let psq of move.vanish)
+ this.board[psq.x][psq.y] = "";
+ for (let psq of move.appear)
+ this.board[psq.x][psq.y] = psq.c + psq.p;
}
// Un-apply the played move
undoOnBoard(move) {
- for (let psq of move.appear) this.board[psq.x][psq.y] = "";
- for (let psq of move.vanish) this.board[psq.x][psq.y] = psq.c + psq.p;
+ for (let psq of move.appear)
+ this.board[psq.x][psq.y] = "";
+ for (let psq of move.vanish)
+ this.board[psq.x][psq.y] = psq.c + psq.p;
}
updateCastleFlags(move) {
@@ -1948,31 +1991,26 @@ export default class ChessRules {
prePlay(move) {
if (
- typeof move.start.x == "number" &&
- (!this.options["teleport"] || this.subTurnTeleport == 1)
+ this.hasCastle &&
+ // If flags already off, no need to re-check:
+ Object.keys(this.castleFlags).some(c => {
+ return this.castleFlags[c].some(val => val < this.size.y)})
) {
- // OK, not a drop move
- if (
- this.hasCastle &&
- // If flags already off, no need to re-check:
- Object.keys(this.castleFlags).some(c => {
- return this.castleFlags[c].some(val => val < this.size.y)})
- ) {
- this.updateCastleFlags(move);
- }
- const initSquare = C.CoordsToSquare(move.start);
- if (
- this.options["crazyhouse"] &&
- (!this.options["rifle"] || !move.capture)
- ) {
+ this.updateCastleFlags(move);
+ }
+ if (this.options["crazyhouse"]) {
+ move.vanish.forEach(v => {
+ const square = C.CoordsToSquare({x: v.x, y: v.y});
+ if (this.ispawn[square])
+ delete this.ispawn[square];
+ });
+ if (move.appear.length > 0 && move.vanish.length > 0) {
+ // Assumption: something is moving
+ const initSquare = C.CoordsToSquare(move.start);
const destSquare = C.CoordsToSquare(move.end);
- if (this.ispawn[initSquare]) {
- delete this.ispawn[initSquare];
- this.ispawn[destSquare] = true;
- }
- else if (
- move.vanish[0].p == "p" &&
- move.appear[0].p != "p"
+ if (
+ this.ispawn[initSquare] ||
+ (move.vanish[0].p == "p" && move.appear[0].p != "p")
) {
this.ispawn[destSquare] = true;
}
@@ -1986,18 +2024,28 @@ export default class ChessRules {
}
}
const minSize = Math.min(move.appear.length, move.vanish.length);
- if (this.hasReserve && !move.pawnfall) {
+ if (
+ this.hasReserve &&
+ // Warning; atomic pawn removal isn't a capture
+ (!this.options["atomic"] || !this.rempawn || this.movesCount >= 1)
+ ) {
const color = this.turn;
for (let i=minSize; i {
// TODO: next "if" shouldn't be required
@@ -2124,7 +2171,9 @@ export default class ChessRules {
this.g_pieces[a.x][a.y].style.width = pieceWidth + "px";
this.g_pieces[a.x][a.y].style.height = pieceWidth + "px";
const [ip, jp] = this.getPixelPosition(a.x, a.y, r);
- this.g_pieces[a.x][a.y].style.transform = `translate(${ip}px,${jp}px)`;
+ // Translate coordinates to use chessboard as reference:
+ this.g_pieces[a.x][a.y].style.transform =
+ `translate(${ip - r.x}px,${jp - r.y}px)`;
if (this.enlightened && !this.enlightened[a.x][a.y])
this.g_pieces[a.x][a.y].classList.add("hidden");
chessboard.appendChild(this.g_pieces[a.x][a.y]);
@@ -2153,18 +2202,26 @@ export default class ChessRules {
callback();
return;
}
- let movingPiece = this.getDomPiece(move.start.x, move.start.y);
- const initTransform = movingPiece.style.transform;
- let chessboard =
- document.getElementById(this.containerId).querySelector(".chessboard");
- const r = chessboard.getBoundingClientRect();
- const [ix, iy] = this.getPixelPosition(move.start.x, move.start.y, r);
+ let initPiece = this.getDomPiece(move.start.x, move.start.y);
+ if (!initPiece) { //TODO this shouldn't be required
+ callback();
+ return;
+ }
+ // NOTE: cloning generally not required, but light enough, and simpler
+ let movingPiece = initPiece.cloneNode();
+ initPiece.style.opacity = "0";
+ let container =
+ document.getElementById(this.containerId)
+ const r = container.querySelector(".chessboard").getBoundingClientRect();
+ if (typeof move.start.x == "string") {
+ // Need to bound width/height (was 100% for reserve pieces)
+ const pieceWidth = this.getPieceWidth(r.width);
+ movingPiece.style.width = pieceWidth + "px";
+ movingPiece.style.height = pieceWidth + "px";
+ }
const maxDist = this.getMaxDistance(r.width);
- // NOTE: move.drag could be generalized per-segment (usage?)
+ const pieces = this.pieces();
if (move.drag) {
- // Drag something else: require cloning
- movingPiece = movingPiece.cloneNode();
- const pieces = this.pieces();
const startCode = this.getPiece(move.start.x, move.start.y);
movingPiece.classList.remove(pieces[startCode]["class"]);
movingPiece.classList.add(pieces[move.drag.p]["class"]);
@@ -2173,41 +2230,43 @@ export default class ChessRules {
movingPiece.classList.remove(C.GetColorClass(apparentColor));
movingPiece.classList.add(C.GetColorClass(move.drag.c));
}
- chessboard.appendChild(movingPiece);
}
+ container.appendChild(movingPiece);
const animateSegment = (index, cb) => {
+ // NOTE: move.drag could be generalized per-segment (usage?)
const [i1, j1] = move.segments[index][0];
const [i2, j2] = move.segments[index][1];
const dep = this.getPixelPosition(i1, j1, r);
const arr = this.getPixelPosition(i2, j2, r);
- // Start from i1, j1:
- movingPiece.style.transform =
- `translate(${dep[0] - ix}px, ${dep[1] - iy}px)`;
movingPiece.style.transitionDuration = "0s";
+ movingPiece.style.transform = `translate(${dep[0]}px, ${dep[1]}px)`;
const distance =
Math.sqrt((arr[0] - dep[0]) ** 2 + (arr[1] - dep[1]) ** 2);
const duration = 0.2 + (distance / maxDist) * 0.3;
- movingPiece.style.transform =
- `translate(${arr[0] - dep[0]}px, ${arr[1] - dep[1]}px)`;
- movingPiece.style.transitionDuration = duration + "s";
- setTimeout(cb, duration * 1000);
+ // TODO: unclear why we need this new delay below:
+ setTimeout(() => {
+ movingPiece.style.transitionDuration = duration + "s";
+ // movingPiece is child of container: no need to adjust coordinates
+ movingPiece.style.transform = `translate(${arr[0]}px, ${arr[1]}px)`;
+ setTimeout(cb, duration * 1000);
+ }, 50);
};
- if (!move.segments)
- move.segments = [[move.start.x, move.start.y], [move.end.x, move.end.y]];
+ if (!move.segments) {
+ move.segments = [
+ [[move.start.x, move.start.y], [move.end.x, move.end.y]]
+ ];
+ }
let index = 0;
- animateSegment(index, () => {
+ const animateSegmentCallback = () => {
if (index < move.segments.length)
- animateSegment(++index);
+ animateSegment(index++, animateSegmentCallback);
else {
- if (move.drag)
- movingPiece.remove();
- else {
- movingPiece.style.transform = initTransform;
- movingPiece.style.transitionDuration = "0s";
- }
+ movingPiece.remove();
+ initPiece.style.opacity = "1";
callback();
}
- });
+ };
+ animateSegmentCallback();
}
playReceivedMove(moves, callback) {