// Build switch move between squares x1,y1 and x2,y2
getSwitchMove_s([x1,y1],[x2,y2])
{
-
const c = this.getColor(x1,y1); //same as color at square 2
const p1 = this.getPiece(x1,y1);
const p2 = this.getPiece(x2,y2);
+ if (p1 == V.KING && p2 == V.ROOK)
+ return []; //avoid duplicate moves (potential conflict with castle)
let move = new Move({
appear: [
new PiPo({x:x2,y:y2,c:c,p:p1}),
end: {x:x2,y:y2}
});
// Move completion: promote switched pawns (as in Magnetic)
- const sizeX = VariantRules.size[0];
- const lastRank = (c == "w" ? 0 : sizeX-1);
- const V = VariantRules;
+ const lastRank = (c == "w" ? 0 : V.size.x-1);
let moves = [];
- if (p1==V.PAWN && x2==lastRank) //TODO: also the case p2==V.PAWN and x1==lastRank! see Magnetic chess
+ if ((p1==V.PAWN && x2==lastRank) || (p2==V.PAWN && x1==lastRank))
{
- move.appear[0].p = V.ROOK;
+ const idx = (p1==V.PAWN ? 0 : 1);
+ move.appear[idx].p = V.ROOK;
moves.push(move);
for (let piece of [V.KNIGHT, V.BISHOP, V.QUEEN])
{
let cmove = JSON.parse(JSON.stringify(move));
- cmove.appear[0].p = piece;
+ cmove.appear[idx].p = piece;
moves.push(cmove);
}
+ if (idx == 1)
+ {
+ // Swap moves[i].appear[0] and [1] for moves presentation [TODO...]
+ moves.forEach(m => {
+ let tmp = m.appear[0];
+ m.appear[0] = m.appear[1];
+ m.appear[1] = tmp;
+ });
+ }
}
else //other cases
moves.push(move);
return moves;
}
- getPotentialMovesFrom([x,y])
+ getPotentialMovesFrom([x,y], computer)
{
let moves = super.getPotentialMovesFrom([x,y]);
- // Add switches:
- const V = VariantRules;
+ // Add switches: respecting chessboard ordering if "computer" is on
const color = this.turn;
const piece = this.getPiece(x,y);
- const [sizeX,sizeY] = V.size;
const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
const kp = this.kingPos[color];
const oppCol = this.getOppCol(color);
for (let step of steps)
{
let [i,j] = [x+step[0],y+step[1]];
- if (i>=0 && i<sizeX && j>=0 && j<sizeY && this.board[i][j]!=V.EMPTY
+ if (!!computer && (i<x || (i==x && j<y)))
+ continue; //only switch with superior indices
+ if (V.OnBoard(i,j) && this.board[i][j]!=V.EMPTY
&& this.getColor(i,j)==color && this.getPiece(i,j)!=piece
// No switching under check (theoretically non-king pieces could, but not)
&& !this.isAttacked(kp, [oppCol]))
return moves;
}
- static get SEARCH_DEPTH() { return 2; } //branching factor is quite high
+ getAllValidMoves(computer)
+ {
+ const color = this.turn;
+ const oppCol = this.getOppCol(color);
+ let potentialMoves = [];
+ 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) == color)
+ {
+ Array.prototype.push.apply(potentialMoves,
+ this.getPotentialMovesFrom([i,j], computer));
+ }
+ }
+ }
+ return this.filterValid(potentialMoves);
+ }
+
+ updateVariables(move)
+ {
+ super.updateVariables(move);
+ if (move.appear.length == 2 && move.vanish.length == 2
+ && move.appear[1].p == V.KING)
+ {
+ // Switch with the king; not castle, and not handled by main class
+ const color = this.getColor(move.start.x, move.start.y);
+ this.kingPos[color] = [move.appear[1].x, move.appear[1].y];
+ }
+ }
+
+ unupdateVariables(move)
+ {
+ super.unupdateVariables(move);
+ if (move.appear.length == 2 && move.vanish.length == 2
+ && move.appear[1].p == V.KING)
+ {
+ const color = this.getColor(move.start.x, move.start.y);
+ this.kingPos[color] = [move.appear[0].x, move.appear[0].y];
+ }
+ }
+
+ static get SEARCH_DEPTH() { return 2; } //high branching factor
+
+ getNotation(move)
+ {
+ if (move.appear.length == 1)
+ return super.getNotation(move); //no switch
+ // Switch or castle
+ if (move.appear[0].p == V.KING && move.appear[1].p == V.ROOK)
+ return (move.end.y < move.start.y ? "0-0-0" : "0-0");
+ // Switch:
+ const startSquare =
+ String.fromCharCode(97 + move.start.y) + (V.size.x-move.start.x);
+ const finalSquare =
+ String.fromCharCode(97 + move.end.y) + (V.size.x-move.end.x);
+ return "S" + startSquare + finalSquare;
+ }
}