getCastleMoves([x,y])
{
const c = this.getColor(x,y);
- if (x != (c=="w" ? 7 : 0) || y != this.INIT_COL_KING[c])
+ const [sizeX,sizeY] = VariantRules.size;
+ if (x != (c=="w" ? sizeX-1 : 0) || y != this.INIT_COL_KING[c])
return []; //x isn't first rank, or king has moved (shortcut)
const V = VariantRules;
const oppCol = this.getOppCol(c);
let moves = [];
let i = 0;
- const finalSquares = [ [2,3], [6,5] ]; //king, then rook
+ const finalSquares = [ [2,3], [sizeY-2,sizeY-3] ]; //king, then rook
castlingCheck:
for (let castleSide=0; castleSide < 2; castleSide++) //large, then small
{
{
const color = this.turn;
const oppCol = this.getOppCol(color);
- var potentialMoves = [];
- let [sizeX,sizeY] = VariantRules.size;
+ let potentialMoves = [];
+ const [sizeX,sizeY] = VariantRules.size;
for (var i=0; i<sizeX; i++)
{
for (var j=0; j<sizeY; j++)
{
const color = this.turn;
const oppCol = this.getOppCol(color);
- let [sizeX,sizeY] = VariantRules.size;
+ const [sizeX,sizeY] = VariantRules.size;
for (let i=0; i<sizeX; i++)
{
for (let j=0; j<sizeY; j++)
{
const piece = this.getPiece(move.start.x,move.start.y);
const c = this.getColor(move.start.x,move.start.y);
- const firstRank = (c == "w" ? 7 : 0);
+ const [sizeX,sizeY] = VariantRules.size;
+ const firstRank = (c == "w" ? sizeX-1 : 0);
// Update king position + flags
if (piece == VariantRules.KING && move.appear.length > 0)
return;
}
const oppCol = this.getOppCol(c);
- const oppFirstRank = 7 - firstRank;
+ const oppFirstRank = (sizeX-1) - firstRank;
if (move.start.x == firstRank //our rook moves?
&& this.INIT_COL_ROOK[c].includes(move.start.y))
{
return VariantRules.INFINITY;
}
+ static get SEARCH_DEPTH() {
+ return 3; //2 for high branching factor, 4 for small (Loser chess)
+ }
+
// Assumption: at least one legal move
getComputerMove(moves1) //moves1 might be precomputed (Magnetic chess)
{
+ this.shouldReturn = false;
const maxeval = VariantRules.INFINITY;
const color = this.turn;
if (!moves1)
}
moves1.sort( (a,b) => { return (color=="w" ? 1 : -1) * (b.eval - a.eval); });
+ let candidates = [0]; //indices of candidates moves
+ for (let j=1; j<moves1.length && moves1[j].eval == moves1[0].eval; j++)
+ candidates.push(j);
+ let currentBest = moves1[_.sample(candidates, 1)];
+
// Skip depth 3 if we found a checkmate (or if we are checkmated in 1...)
- if (Math.abs(moves1[0].eval) < VariantRules.THRESHOLD_MATE)
+ if (VariantRules.SEARCH_DEPTH >= 3
+ && Math.abs(moves1[0].eval) < VariantRules.THRESHOLD_MATE)
{
// TODO: show current analyzed move for depth 3, allow stopping eval (return moves1[0])
for (let i=0; i<moves1.length; i++)
{
+ if (this.shouldReturn)
+ return currentBest; //depth-2, minimum
this.play(moves1[i]);
// 0.1 * oldEval : heuristic to avoid some bad moves (not all...)
- moves1[i].eval = 0.1*moves1[i].eval + this.alphabeta(2, -maxeval, maxeval);
+ moves1[i].eval = 0.1*moves1[i].eval +
+ this.alphabeta(VariantRules.SEARCH_DEPTH-1, -maxeval, maxeval);
this.undo(moves1[i]);
}
moves1.sort( (a,b) => { return (color=="w" ? 1 : -1) * (b.eval - a.eval); });
}
+ else
+ return currentBest;
- let candidates = [0]; //indices of candidates moves
+ candidates = [0];
for (let j=1; j<moves1.length && moves1[j].eval == moves1[0].eval; j++)
candidates.push(j);
// console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; }));