import { ChessRules } from "@/base_rules";
-export const VariantRules = class ArenaRules extends ChessRules {
- static get hasFlags() {
+export class ArenaRules extends ChessRules {
+
+ static get Lines() {
+ return [
+ [[2, 0], [2, 8]],
+ [[6, 0], [6, 8]]
+ ];
+ }
+
+ static get HasFlags() {
return false;
}
- static GenRandInitFen(randomness) {
- return ChessRules
- .GenRandInitFen(randomness)
- .replace("w 0 1111 -", "w 0 -");
+ static get PawnSpecs() {
+ return Object.assign(
+ {},
+ ChessRules.PawnSpecs,
+ { captureBackward: true }
+ );
+ }
+
+ static IsGoodPosition(position) {
+ if (position.length == 0) return false;
+ const rows = position.split("/");
+ if (rows.length != V.size.x) return false;
+ // At most and at least one king or queen per color
+ let royals = { "k": 0, "K": 0, "q": 0, "Q": 0 };
+ for (let row of rows) {
+ let sumElts = 0;
+ for (let i = 0; i < row.length; i++) {
+ if (['K','k','Q','q'].includes(row[i])) royals[row[i]]++;
+ if (V.PIECES.includes(row[i].toLowerCase())) sumElts++;
+ else {
+ const num = parseInt(row[i], 10);
+ if (isNaN(num)) return false;
+ sumElts += num;
+ }
+ }
+ if (sumElts != V.size.y) return false;
+ }
+ if (
+ Object.values(royals).some(v => v >= 2) ||
+ royals['K'] + royals['Q'] == 0 ||
+ royals['k'] + royals['q'] == 0
+ ) {
+ return false;
+ }
+ return true;
+ }
+
+ scanKings() {}
+
+ static GenRandInitFen(options) {
+ return ChessRules.GenRandInitFen(options).slice(0, -6) + "-";
}
static InArena(x) {
return moves;
}
- getPotentialPawnMoves([x, y]) {
- const color = this.turn;
- let moves = [];
- const [sizeX, sizeY] = [V.size.x, V.size.y];
- const shiftX = color == "w" ? -1 : 1;
- const startRank = color == "w" ? sizeX - 2 : 1;
-
- if (this.board[x + shiftX][y] == V.EMPTY) {
- // One square forward
- moves.push(this.getBasicMove([x, y], [x + shiftX, y]));
- // Next condition because pawns on 1st rank can generally jump
- if (
- x == startRank &&
- this.board[x + 2 * shiftX][y] == V.EMPTY
- ) {
- // Two squares jump
- moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
- }
- }
- // Captures: also possible backward
- for (let shiftY of [-1, 1]) {
- if (y + shiftY >= 0 && y + shiftY < sizeY) {
- for (let direction of [-1,1]) {
- if (
- this.board[x + direction][y + shiftY] != V.EMPTY &&
- this.canTake([x, y], [x + direction, y + shiftY])
- ) {
- moves.push(this.getBasicMove([x, y], [x + direction, y + shiftY]));
- }
- }
- }
- }
-
- // En passant
- const Lep = this.epSquares.length;
- const epSquare = this.epSquares[Lep - 1]; //always at least one element
- if (
- !!epSquare &&
- epSquare.x == x + shiftX &&
- Math.abs(epSquare.y - y) == 1
- ) {
- let enpassantMove = this.getBasicMove([x, y], [epSquare.x, epSquare.y]);
- enpassantMove.vanish.push({
- x: x,
- y: epSquare.y,
- p: "p",
- c: this.getColor(x, epSquare.y)
- });
- moves.push(enpassantMove);
- }
-
- return moves;
- }
-
getPotentialQueenMoves(sq) {
- return this.getSlideNJumpMoves(
- sq,
- V.steps[V.ROOK].concat(V.steps[V.BISHOP])
- ).filter(m => {
- // Filter out moves longer than 3 squares
- return Math.max(
- Math.abs(m.end.x - m.start.x),
- Math.abs(m.end.y - m.start.y)) <= 3;
- });
+ return super.getSlideNJumpMoves(
+ sq, V.steps[V.ROOK].concat(V.steps[V.BISHOP]), 3);
}
getPotentialKingMoves(sq) {
- return this.getSlideNJumpMoves(
- sq,
- V.steps[V.ROOK].concat(V.steps[V.BISHOP])
- ).filter(m => {
- // Filter out moves longer than 3 squares
- return Math.max(
- Math.abs(m.end.x - m.start.x),
- Math.abs(m.end.y - m.start.y)) <= 3;
- });
+ return super.getSlideNJumpMoves(
+ sq, V.steps[V.ROOK].concat(V.steps[V.BISHOP]), 3);
}
getCheckSquares() {
return moves;
}
+ postPlay() {} //no kingPos no castleFlags
+ postUndo() {}
+
getCurrentScore() {
const color = this.turn;
if (!this.atLeastOneMove())
}
return "*";
}
+
+ static get SEARCH_DEPTH() {
+ return 4;
+ }
+
};