import { ChessRules, PiPo, Move } from "@/base_rules";
import { ArrayFun } from "@/utils/array";
-import { randInt, shuffle } from "@/utils/alea";
+import { shuffle } from "@/utils/alea";
+
+export class CircularRules extends ChessRules {
+
+ static get HasCastle() {
+ return false;
+ }
-export const VariantRules = class CircularRules extends ChessRules {
static get HasEnpassant() {
return false;
}
this.pawnFlags = flags;
}
- static GenRandInitFen(randomness) {
- if (!randomness) randomness = 2;
- if (randomness == 0)
- return "8/8/pppppppp/rnbqkbnr/8/8/PPPPPPPP/RNBQKBNR w 0 1111111111111111";
+ static GenRandInitFen(options) {
+ if (options.randomness == 0) {
+ return "8/8/pppppppp/rnbqkbnr/8/8/PPPPPPPP/RNBQKBNR " +
+ "w 0 1111111111111111";
+ }
let pieces = { w: new Array(8), b: new Array(8) };
- // Shuffle pieces on first and fifth rank
+ // Shuffle pieces on first and last rank
for (let c of ["w", "b"]) {
- if (c == 'b' && randomness == 1) {
+ if (c == 'b' && options.randomness == 1) {
pieces['b'] = pieces['w'];
break;
}
- let positions = ArrayFun.range(8);
-
- // Get random squares for bishops
- let randIndex = 2 * randInt(4);
- const bishop1Pos = positions[randIndex];
- // The second bishop must be on a square of different color
- 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 = randInt(6);
- const knight1Pos = positions[randIndex];
- positions.splice(randIndex, 1);
- randIndex = randInt(5);
- const knight2Pos = positions[randIndex];
- positions.splice(randIndex, 1);
-
- // Get random square for queen
- randIndex = randInt(4);
- const queenPos = positions[randIndex];
- positions.splice(randIndex, 1);
-
- // Rooks and king positions are now fixed,
- // because of the ordering rook-king-rook
- const rook1Pos = positions[0];
- const kingPos = positions[1];
- const rook2Pos = positions[2];
-
- // Finally put the shuffled pieces in the board array
- pieces[c][rook1Pos] = "r";
- pieces[c][knight1Pos] = "n";
- pieces[c][bishop1Pos] = "b";
- pieces[c][queenPos] = "q";
- pieces[c][kingPos] = "k";
- pieces[c][bishop2Pos] = "b";
- pieces[c][knight2Pos] = "n";
- pieces[c][rook2Pos] = "r";
+ // Get random squares for every piece, totally freely
+ let positions = shuffle(ArrayFun.range(8));
+ const composition = ['b', 'b', 'r', 'r', 'n', 'n', 'k', 'q'];
+ const rem2 = positions[0] % 2;
+ if (rem2 == positions[1] % 2) {
+ // Fix bishops (on different colors)
+ for (let i=2; i<8; i++) {
+ if (positions[i] % 2 != rem2) {
+ [positions[1], positions[i]] = [positions[i], positions[1]];
+ break;
+ }
+ }
+ }
+ for (let i = 0; i < 8; i++) pieces[c][positions[i]] = composition[i];
}
return (
"8/8/pppppppp/" +
getSlideNJumpMoves([x, y], steps, oneStep) {
let moves = [];
+ // Don't add move twice when running on an infinite file:
+ let infiniteSteps = {};
outerLoop: for (let step of steps) {
+ if (!!infiniteSteps[(-step[0]) + "." + (-step[1])]) continue;
let i = V.ComputeX(x + step[0]);
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 = V.ComputeX(i + step[0]);
j += step[1];
}
- if (V.OnBoard(i, j) && this.canTake([x, y], [i, j]))
- moves.push(this.getBasicMove([x, y], [i, j]));
+ if (V.OnBoard(i, j)) {
+ if (i == x && j == y)
+ // Looped back onto initial square
+ infiniteSteps[step[0] + "." + step[1]] = true;
+ else if (this.canTake([x, y], [i, j]))
+ moves.push(this.getBasicMove([x, y], [i, j]));
+ }
}
return moves;
}
return moves;
}
- getPotentialKingMoves(sq) {
- return this.getSlideNJumpMoves(
- sq,
- V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
- "oneStep"
- );
- }
-
filterValid(moves) {
const filteredMoves = super.filterValid(moves);
// If at least one full move made, everything is allowed:
- if (this.movesCount >= 2)
- return filteredMoves;
+ if (this.movesCount >= 2) return filteredMoves;
// Else, forbid check:
const oppCol = V.GetOppCol(this.turn);
return filteredMoves.filter(m => {
});
}
- isAttackedByPawn([x, y], colors) {
- const pawnShift = 1;
- const attackerRow = V.ComputeX(x + pawnShift);
- for (let c of colors) {
- for (let i of [-1, 1]) {
- if (
- y + i >= 0 &&
- y + i < V.size.y &&
- this.getPiece(attackerRow, y + i) == V.PAWN &&
- this.getColor(attackerRow, y + i) == c
- ) {
- return true;
- }
+ isAttackedByPawn([x, y], color) {
+ // pawn shift is always 1 (all pawns go the same way)
+ const attackerRow = V.ComputeX(x + 1);
+ for (let i of [-1, 1]) {
+ if (
+ y + i >= 0 &&
+ y + i < V.size.y &&
+ this.getPiece(attackerRow, y + i) == V.PAWN &&
+ this.getColor(attackerRow, y + i) == color
+ ) {
+ return true;
}
}
return false;
}
- isAttackedBySlideNJump([x, y], colors, piece, steps, oneStep) {
+ isAttackedBySlideNJump([x, y], color, piece, steps, oneStep) {
for (let step of steps) {
let rx = V.ComputeX(x + step[0]),
ry = y + step[1];
}
if (
V.OnBoard(rx, ry) &&
- this.getPiece(rx, ry) === piece &&
- colors.includes(this.getColor(rx, ry))
+ this.getPiece(rx, ry) == piece &&
+ this.getColor(rx, ry) == color
) {
return true;
}
return flags;
}
- updateVariables(move) {
+ postPlay(move) {
+ super.postPlay(move);
const c = move.vanish[0].c;
- const secondRank = {"w":6, "b":2};
- // Update king position + flags
- if (move.vanish[0].p == V.KING && move.appear.length > 0) {
- this.kingPos[c][0] = move.appear[0].x;
- this.kingPos[c][1] = move.appear[0].y;
- }
- else if (move.vanish[0].p == V.PAWN && secondRank[c] == move.start.x)
+ const secondRank = { "w": 6, "b": 2 };
+ if (move.vanish[0].p == V.PAWN && secondRank[c] == move.start.x)
// This move turns off a 2-squares pawn flag
this.pawnFlags[c][move.start.y] = false;
}
k: 1000
};
}
+
+ static get SEARCH_DEPTH() {
+ return 2;
+ }
+
};
projects / vchess.git / blobdiff