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({
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;
}
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;
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]);
}
if (emptyCount > 0)
// "Flush remainder"
- position += format(emptyCount);
+ position += C.FenEmptySquares(emptyCount);
if (i < this.size.y - 1)
position += "/"; //separate rows
}
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.
}
}
}
- if (this.reserve)
+ if (this.hasReserve)
this.re_drawReserve(['w', 'b'], r);
}
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);
- // Translate coordinates to use chessboard as reference:
- this.g_pieces[i][j].style.transform =
- `translate(${ip - newX}px,${jp - newY}px)`;
+ // NOTE: next "if" for variants which use squares filling
+ // instead of "physical", moving pieces
+ if (this.g_pieces) {
+ 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);
+ // Translate coordinates to use chessboard as reference:
+ this.g_pieces[i][j].style.transform =
+ `translate(${ip - newX}px,${jp - newY}px)`;
+ }
}
}
}
- if (this.reserve)
+ if (this.hasReserve)
this.rescaleReserve(newR);
}
////////////////////
// MOVES GENERATION
- // Return negative y to say "h to a" or "a to h"
- getY_withSign(y) {
+ // For Cylinder: get Y coordinate
+ getY(y) {
if (!this.options["cylinder"])
return y;
let res = y % this.size.y;
if (res < 0)
- // Off-board, "teleportation" marked with negative sign:
- return - (res + this.size.y);
+ res += this.size.y;
return res;
}
- // For Cylinder: get Y coordinate
- getY(y) {
- return Math.abs(this.getY_withSign(y));
- }
-
// Stop at the first capture found
atLeastOneCapture(color) {
color = color || this.turn;
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 = [];
const color = this.getColor(x, y);
const stepSpec = this.pieces(color, x, y)[piece];
let moves = [];
- let explored = {}; //for Cylinder mode
+ // Next 3 for Cylinder mode:
+ let explored = {};
+ let segments = [];
+ let segStart = [];
+
+ const addMove = (start, end) => {
+ 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) {
outerLoop: for (let step of s.steps) {
- let segments = [];
- let segStart = [x, y],
- segEnd = [];
+ segments = [];
+ segStart = [x, y];
let [i, j] = [x, y];
let stepCounter = 0;
while (
(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.getY_withSign(j + step[1]);
- if (j < 0) {
+ j = this.getY(j + step[1]);
+ if (Math.abs(j - oldIJ[1]) > 1) {
// Boundary between segments (cylinder mode)
- j = -j;
- segEnd = oldIJ;
- segments.push(JSON.parse(JSON.stringify([segStart, segEnd])));
- segStart = [];
+ segments.push([[segStart[0], segStart[1]], oldIJ]);
+ segStart = [i, j];
}
- else if (segStart.length == 0)
- segStart = oldIJ;
}
if (!this.onBoard(i, j))
continue;
)
) {
explored[i + "." + j] = true;
- moves.push(this.getBasicMove([x, y], [i, j]));
+ addMove([x, y], [i, j]);
}
}
}
// TODO: unclear why we need this new delay below:
setTimeout(() => {
movingPiece.style.transitionDuration = duration + "s";
- // movingPiece is child of container: no need to adjust cordinates
+ // 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);
projects / xogo.git / blobdiff