// Variants generally inherit from it, and modify some parts.
import { ArrayFun } from "@/utils/array";
-import { random, sample, shuffle } from "@/utils/alea";
+import { randInt, shuffle } from "@/utils/alea";
export const PiPo = class PiPo //Piece+Position
{
// Argument is a move:
const move = moveOrSquare;
const [sx,sy,ex] = [move.start.x,move.start.y,move.end.x];
- // TODO: next conditions are first for Atomic, and last for Checkered
+ // NOTE: next conditions are first for Atomic, and last for Checkered
if (move.appear.length > 0 && Math.abs(sx - ex) == 2
&& move.appear[0].p == V.PAWN && ["w","b"].includes(move.appear[0].c))
{
let positions = ArrayFun.range(8);
// Get random squares for bishops
- let randIndex = 2 * random(4);
+ let randIndex = 2 * randInt(4);
const bishop1Pos = positions[randIndex];
// The second bishop must be on a square of different color
- let randIndex_tmp = 2 * random(4) + 1;
+ let randIndex_tmp = 2 * randInt(4) + 1;
const bishop2Pos = positions[randIndex_tmp];
// Remove chosen squares
positions.splice(Math.max(randIndex,randIndex_tmp), 1);
positions.splice(Math.min(randIndex,randIndex_tmp), 1);
// Get random squares for knights
- randIndex = random(6);
+ randIndex = randInt(6);
const knight1Pos = positions[randIndex];
positions.splice(randIndex, 1);
- randIndex = random(5);
+ randIndex = randInt(5);
const knight2Pos = positions[randIndex];
positions.splice(randIndex, 1);
// Get random square for queen
- randIndex = random(4);
+ randIndex = randInt(4);
const queenPos = positions[randIndex];
positions.splice(randIndex, 1);
return (color=="w" ? "b" : "w");
}
- // Get next color (for compatibility with 3 and 4 players games)
- static GetNextCol(color)
- {
- return V.GetOppCol(color);
- }
-
// Pieces codes (for a clearer code)
static get PAWN() { return 'p'; }
static get ROOK() { return 'r'; }
continue;
// If this code is reached, rooks and king are on initial position
- // Nothing on the path of the king ?
- // (And no checks; OK also if y==finalSquare)
- let step = finalSquares[castleSide][0] < y ? -1 : 1;
- for (i=y; i!=finalSquares[castleSide][0]; i+=step)
+ // Nothing on the path of the king ? (and no checks)
+ const finDist = finalSquares[castleSide][0] - y;
+ let step = finDist / Math.max(1, Math.abs(finDist));
+ i = y;
+ do
{
if (this.isAttacked([x,i], [oppCol]) || (this.board[x][i] != V.EMPTY &&
// NOTE: next check is enough, because of chessboard constraints
{
continue castlingCheck;
}
+ i += step;
}
+ while (i!=finalSquares[castleSide][0]);
// Nothing on the path to the rook?
- step = castleSide == 0 ? -1 : 1;
+ step = (castleSide == 0 ? -1 : 1);
for (i = y + step; i != this.INIT_COL_ROOK[c][castleSide]; i += step)
{
if (this.board[x][i] != V.EMPTY)
move.flags = JSON.stringify(this.aggregateFlags()); //save flags (for undo)
if (V.HasEnpassant)
this.epSquares.push( this.getEpSquare(move) );
- if (!move.color)
- move.color = this.turn; //for interface
V.PlayOnBoard(this.board, move);
this.turn = V.GetOppCol(this.turn);
this.movesCount++;
// Search depth: 2 for high branching factor, 4 for small (Loser chess, eg.)
static get SEARCH_DEPTH() { return 3; }
- // Assumption: at least one legal move
// NOTE: works also for extinction chess because depth is 3...
getComputerMove()
{
// 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
+ return null;
// Can I mate in 1 ? (for Magnetic & Extinction)
for (let i of shuffle(ArrayFun.range(moves1.length)))
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)];
-
- // From here, depth >= 3: may take a while, so we control time
- const timeStart = Date.now();
+ let currentBest = moves1[candidates[randInt(candidates.length)]];
// Skip depth 3+ if we found a checkmate (or if we are checkmated in 1...)
if (V.SEARCH_DEPTH >= 3 && Math.abs(moves1[0].eval) < V.THRESHOLD_MATE)
{
+ // From here, depth >= 3: may take a while, so we control time
+ const timeStart = Date.now();
for (let i=0; i<moves1.length; i++)
{
if (Date.now()-timeStart >= 5000) //more than 5 seconds
candidates = [0];
for (let j=1; j<moves1.length && moves1[j].eval == moves1[0].eval; j++)
candidates.push(j);
- return moves1[sample(candidates)];
+ return moves1[candidates[randInt(candidates.length)]];
}
alphabeta(depth, alpha, beta)