}
// Some variants cannot have analyse mode
- static get CanAnalyse() {
+ static get CanAnalyze() {
return true;
}
+ // Patch: issues with javascript OOP, objects can't access static fields.
+ get canAnalyze() {
+ return V.CanAnalyze;
+ }
// Some variants show incomplete information,
// and thus show only a partial moves list or no list at all.
static get ShowMoves() {
return "all";
}
+ get showMoves() {
+ return V.ShowMoves;
+ }
- // Path to pieces
- static getPpath(b) {
- return b; //usual pieces in pieces/ folder
+ // Some variants always show the same orientation
+ static get CanFlip() {
+ return true;
+ }
+ get canFlip() {
+ return V.CanFlip;
}
// Turn "wb" into "B" (for FEN)
if (position.length == 0) return false;
const rows = position.split("/");
if (rows.length != V.size.x) return false;
+ let kings = {};
for (let row of rows) {
let sumElts = 0;
for (let i = 0; i < row.length; i++) {
+ if (['K','k'].includes(row[i]))
+ kings[row[i]] = true;
if (V.PIECES.includes(row[i].toLowerCase())) sumElts++;
else {
const num = parseInt(row[i]);
}
if (sumElts != V.size.y) return false;
}
+ // Both kings should be on board:
+ if (Object.keys(kings).length != 2)
+ return false;
return true;
}
return V.CoordToColumn(coords.y) + (V.size.x - coords.x);
}
+ // Path to pieces
+ getPpath(b) {
+ return b; //usual pieces in pieces/ folder
+ }
+
// Aggregates flags into one object
aggregateFlags() {
return this.castleFlags;
}
// Argument is a move:
const move = moveOrSquare;
- const [sx, sy, ex] = [move.start.x, move.start.y, move.end.x];
+ const s = move.start,
+ e = move.end;
// NOTE: next conditions are first for Atomic, and last for Checkered
if (
move.appear.length > 0 &&
- Math.abs(sx - ex) == 2 &&
+ Math.abs(s.x - e.x) == 2 &&
+ s.y == e.y &&
move.appear[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
pieces[c][knight2Pos] = "n";
pieces[c][rook2Pos] = "r";
}
+ // Add turn + flags + enpassant
return (
pieces["b"].join("") +
"/pppppppp/8/8/8/8/PPPPPPPP/" +
pieces["w"].join("").toUpperCase() +
" w 0 1111 -"
- ); //add turn + flags + enpassant
+ );
}
// "Parse" FEN: just return untransformed string data
for (let indexInRow = 0; indexInRow < rows[i].length; indexInRow++) {
const character = rows[i][indexInRow];
const num = parseInt(character);
+ // If num is a number, just shift j:
if (!isNaN(num)) j += num;
- //just shift j
- //something at position i,j
+ // Else: something at position i,j
else board[i][j++] = V.fen2board(character);
}
}
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) {
- this.re_init(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
if (V.HasEnpassant) {
const epSq =
parsedFen.enpassant != "-"
- ? V.SquareToCoords(parsedFen.enpassant)
+ ? this.getEpSquare(parsedFen.enpassant)
: undefined;
this.epSquares = [epSq];
}
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;
}
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], {
const oppCol = V.GetOppCol(c);
let moves = [];
let i = 0;
+ // King, then rook:
const finalSquares = [
[2, 3],
[V.size.y - 2, V.size.y - 3]
- ]; //king, then rook
+ ];
castlingCheck: for (
let castleSide = 0;
castleSide < 2;
// After move is played, update variables + flags
updateVariables(move) {
let piece = undefined;
+ // TODO: update variables before move is played, and just use this.turn ?
+ // (doesn't work in general, think MarseilleChess)
let c = undefined;
if (move.vanish.length >= 1) {
// Usual case, something is moved
piece = move.appear[0].p;
c = move.appear[0].c;
}
- if (c == "c") {
- //if (!["w","b"].includes(c))
- // 'c = move.vanish[0].c' doesn't work for Checkered
+ if (!['w','b'].includes(c)) {
+ // Checkered, for example
c = V.GetOppCol(this.turn);
}
const firstRank = c == "w" ? V.size.x - 1 : 0;
play(move) {
// DEBUG:
- // if (!this.states) this.states = [];
- // const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen();
- // this.states.push(stateFen);
+// if (!this.states) this.states = [];
+// const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen();
+// this.states.push(stateFen);
if (V.HasFlags) move.flags = JSON.stringify(this.aggregateFlags()); //save flags (for undo)
if (V.HasEnpassant) this.epSquares.push(this.getEpSquare(move));
this.unupdateVariables(move);
// DEBUG:
- // const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen();
- // if (stateFen != this.states[this.states.length-1]) debugger;
- // this.states.pop();
+// const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen();
+// if (stateFen != this.states[this.states.length-1]) debugger;
+// this.states.pop();
}
///////////////
// What is the score ? (Interesting if game is over)
getCurrentScore() {
if (this.atLeastOneMove())
- // game not over
return "*";
// Game over
// 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");
+
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)
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++)
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));
// TODO: un-ambiguous notation (switch on piece type, check directions...)
getNotation(move) {
if (move.appear.length == 2 && move.appear[0].p == V.KING)
- //castle
+ // Castle
return move.end.y < move.start.y ? "0-0-0" : "0-0";
// Translate final square
// Capture
const startColumn = V.CoordToColumn(move.start.y);
notation = startColumn + "x" + finalSquare;
- } //no capture
+ }
else notation = finalSquare;
if (move.appear.length > 0 && move.appear[0].p != V.PAWN)
- //promotion
+ // Promotion
notation += "=" + move.appear[0].p.toUpperCase();
return notation;
}
projects / vchess.git / blobdiff