return V.ShowMoves;
}
+ // Some variants always show the same orientation
+ static get CanFlip() {
+ return true;
+ }
+ get canFlip() {
+ return V.CanFlip;
+ }
+
// Turn "wb" into "B" (for FEN)
static board2fen(b) {
return b[0] == "w" ? b[1].toUpperCase() : b[1];
}
// Argument is a move:
const move = moveOrSquare;
- const [sx, sy, ex] = [move.start.x, move.start.y, move.end.x];
- // NOTE: next conditions are first for Atomic, and last for Checkered
+ const s = move.start,
+ e = move.end;
+ // NOTE: next conditions are first for Crazyhouse, and last for Checkered
+ // TODO: Checkered exceptions are too weird and should move in its own file.
if (
- move.appear.length > 0 &&
- Math.abs(sx - ex) == 2 &&
- move.appear[0].p == V.PAWN &&
+ move.vanish.length > 0 &&
+ Math.abs(s.x - e.x) == 2 &&
+ s.y == e.y &&
+ move.vanish[0].p == V.PAWN &&
["w", "b"].includes(move.appear[0].c)
) {
return {
- x: (sx + ex) / 2,
- y: sy
+ x: (s.x + e.x) / 2,
+ y: s.y
};
}
return undefined; //default
/////////////
// FEN UTILS
- // Setup the initial random (assymetric) position
- static GenRandInitFen() {
+ // Setup the initial random (asymmetric) position
+ static GenRandInitFen(randomness) {
+ if (randomness == 0)
+ // Deterministic:
+ return "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w 0 1111 -";
+
let pieces = { w: new Array(8), b: new Array(8) };
- // Shuffle pieces on first and last rank
+ // Shuffle pieces on first (and last rank if randomness == 2)
for (let c of ["w", "b"]) {
+ if (c == 'b' && randomness == 1) {
+ pieces['b'] = pieces['w'];
+ break;
+ }
+
let positions = ArrayFun.range(8);
// Get random squares for bishops
// Return current fen (game state)
getFen() {
return (
- this.getBaseFen() +
- " " +
- this.getTurnFen() +
- " " +
+ this.getBaseFen() + " " +
+ this.getTurnFen() + " " +
this.movesCount +
(V.HasFlags ? " " + this.getFlagsFen() : "") +
(V.HasEnpassant ? " " + this.getEnpassantFen() : "")
);
}
+ getFenForRepeat() {
+ // Omit movesCount, only variable allowed to differ
+ return (
+ this.getBaseFen() + "_" +
+ this.getTurnFen() +
+ (V.HasFlags ? "_" + this.getFlagsFen() : "") +
+ (V.HasEnpassant ? "_" + this.getEnpassantFen() : "")
+ );
+ }
+
// Position part of the FEN string
getBaseFen() {
let position = "";
setFlags(fenflags) {
// white a-castle, h-castle, black a-castle, h-castle
this.castleFlags = { w: [true, true], b: [true, true] };
- if (!fenflags) return;
for (let i = 0; i < 4; i++)
this.castleFlags[i < 2 ? "w" : "b"][i % 2] = fenflags.charAt(i) == "1";
}
//////////////////
// INITIALIZATION
- constructor(fen) {
- // In printDiagram() fen isn't supply because only getPpath() is used
- if (fen)
- this.re_init(fen);
- }
-
// Fen string fully describes the game state
- re_init(fen) {
+ constructor(fen) {
+ if (!fen)
+ // In printDiagram() fen isn't supply because only getPpath() is used
+ // TODO: find a better solution!
+ return;
const fenParsed = V.ParseFen(fen);
this.board = V.GetBoard(fenParsed.position);
this.turn = fenParsed.turn[0]; //[0] to work with MarseilleRules
return { x: 8, y: 8 };
}
- // Color of thing on suqare (i,j). 'undefined' if square is empty
+ // Color of thing on square (i,j). 'undefined' if square is empty
getColor(i, j) {
return this.board[i][j].charAt(0);
}
////////////////////
// MOVES GENERATION
- // All possible moves from selected square (assumption: color is OK)
+ // All possible moves from selected square
getPotentialMovesFrom([x, y]) {
switch (this.getPiece(x, y)) {
case V.PAWN:
})
);
}
+
return mv;
}
let j = y + step[1];
while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
moves.push(this.getBasicMove([x, y], [i, j]));
- if (oneStep !== undefined) continue outerLoop;
+ if (oneStep) continue outerLoop;
i += step[0];
j += step[1];
}
x + shiftX == lastRank
? [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]
: [V.PAWN];
- // One square forward
if (this.board[x + shiftX][y] == V.EMPTY) {
+ // One square forward
for (let piece of finalPieces) {
moves.push(
this.getBasicMove([x, y], [x + shiftX, y], {
// (for engine and game end)
getAllValidMoves() {
const color = this.turn;
- const oppCol = V.GetOppCol(color);
let potentialMoves = [];
for (let i = 0; i < V.size.x; i++) {
for (let j = 0; j < V.size.y; j++) {
- // Next condition "!= oppCol" to work with checkered variant
- if (this.board[i][j] != V.EMPTY && this.getColor(i, j) != oppCol) {
+ if (this.getColor(i, j) == color) {
Array.prototype.push.apply(
potentialMoves,
this.getPotentialMovesFrom([i, j])
// Stop at the first move found
atLeastOneMove() {
const color = this.turn;
- const oppCol = V.GetOppCol(color);
for (let i = 0; i < V.size.x; i++) {
for (let j = 0; j < V.size.y; j++) {
- if (this.board[i][j] != V.EMPTY && this.getColor(i, j) != oppCol) {
+ if (this.getColor(i, j) == color) {
const moves = this.getPotentialMovesFrom([i, j]);
if (moves.length > 0) {
for (let k = 0; k < moves.length; k++) {
);
}
+ // Generic method for non-pawn pieces ("sliding or jumping"):
+ // is x,y attacked by a piece of color in array 'colors' ?
+ isAttackedBySlideNJump([x, y], colors, piece, steps, oneStep) {
+ for (let step of steps) {
+ let rx = x + step[0],
+ ry = y + step[1];
+ while (V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && !oneStep) {
+ rx += step[0];
+ ry += step[1];
+ }
+ if (
+ V.OnBoard(rx, ry) &&
+ this.getPiece(rx, ry) === piece &&
+ colors.includes(this.getColor(rx, ry))
+ ) {
+ return true;
+ }
+ }
+ return false;
+ }
+
// Is square x,y attacked by 'colors' pawns ?
isAttackedByPawn([x, y], colors) {
for (let c of colors) {
- let pawnShift = c == "w" ? 1 : -1;
+ const pawnShift = c == "w" ? 1 : -1;
if (x + pawnShift >= 0 && x + pawnShift < V.size.x) {
for (let i of [-1, 1]) {
if (
);
}
- // Generic method for non-pawn pieces ("sliding or jumping"):
- // is x,y attacked by a piece of color in array 'colors' ?
- isAttackedBySlideNJump([x, y], colors, piece, steps, oneStep) {
- for (let step of steps) {
- let rx = x + step[0],
- ry = y + step[1];
- while (V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && !oneStep) {
- rx += step[0];
- ry += step[1];
- }
- if (
- V.OnBoard(rx, ry) &&
- this.getPiece(rx, ry) === piece &&
- colors.includes(this.getColor(rx, ry))
- ) {
- return true;
- }
- }
- return false;
- }
-
// Is color under check after his move ?
underCheck(color) {
return this.isAttacked(this.kingPos[color], [V.GetOppCol(color)]);
return 3;
}
- // NOTE: works also for extinction chess because depth is 3...
getComputerMove() {
const maxeval = V.INFINITY;
const color = this.turn;
// Some variants may show a bigger moves list to the human (Switching),
// thus the argument "computer" below (which is generally ignored)
- let moves1 = this.getAllValidMoves("computer");
+ let moves1 = this.getAllValidMoves();
+
if (moves1.length == 0)
- //TODO: this situation should not happen
+ // TODO: this situation should not happen
return null;
- // Can I mate in 1 ? (for Magnetic & Extinction)
- for (let i of shuffle(ArrayFun.range(moves1.length))) {
- this.play(moves1[i]);
- let finish = Math.abs(this.evalPosition()) >= V.THRESHOLD_MATE;
- if (!finish) {
- const score = this.getCurrentScore();
- if (["1-0", "0-1"].includes(score)) finish = true;
- }
- this.undo(moves1[i]);
- if (finish) return moves1[i];
- }
-
// Rank moves using a min-max at depth 2
for (let i = 0; i < moves1.length; i++) {
// Initial self evaluation is very low: "I'm checkmated"
// Initial enemy evaluation is very low too, for him
eval2 = (color == "w" ? 1 : -1) * maxeval;
// Second half-move:
- let moves2 = this.getAllValidMoves("computer");
+ let moves2 = this.getAllValidMoves();
for (let j = 0; j < moves2.length; j++) {
this.play(moves2[j]);
const score2 = this.getCurrentScore();
moves1.sort((a, b) => {
return (color == "w" ? 1 : -1) * (b.eval - a.eval);
});
+// console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; }));
let candidates = [0]; //indices of candidates moves
for (let j = 1; j < moves1.length && moves1[j].eval == moves1[0].eval; j++)
return (color == "w" ? 1 : -1) * (b.eval - a.eval);
});
} else return currentBest;
- // console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; }));
+// console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; }));
candidates = [0];
for (let j = 1; j < moves1.length && moves1[j].eval == moves1[0].eval; j++)
if (score != "*")
return score == "1/2" ? 0 : (score == "1-0" ? 1 : -1) * maxeval;
if (depth == 0) return this.evalPosition();
- const moves = this.getAllValidMoves("computer");
+ const moves = this.getAllValidMoves();
let v = color == "w" ? -maxeval : maxeval;
if (color == "w") {
for (let i = 0; i < moves.length; i++) {
alpha = Math.max(alpha, v);
if (alpha >= beta) break; //beta cutoff
}
- } //color=="b"
+ }
else {
+ // color=="b"
for (let i = 0; i < moves.length; i++) {
this.play(moves[i]);
v = Math.min(v, this.alphabeta(depth - 1, alpha, beta));