import { ChessRules } from "@/base_rules";
+import { randInt, shuffle } from "@/utils/alea";
+import { ArrayFun } from "@/utils/array";
export class AmbiguousRules extends ChessRules {
+
static get HasFlags() {
return false;
}
const oppCol = V.GetOppCol(color);
if (this.subTurn == 2) {
// Just play a normal move (which in fact only indicate a square)
+ let movesHash = {};
return (
super.getPotentialMovesFrom([x, y])
+ .filter(m => {
+ // Filter promotions: keep only one, since no choice now.
+ if (m.appear[0].p != m.vanish[0].p) {
+ const hash = V.CoordsToSquare(m.start) + V.CoordsToSquare(m.end);
+ if (!movesHash[hash]) {
+ movesHash[hash] = true;
+ return true;
+ }
+ return false;
+ }
+ return true;
+ })
.map(m => {
if (m.vanish.length == 1) m.appear[0].p = V.GOAL;
else m.appear[0].p = V.TARGET_CODE[m.vanish[1].p];
let potentialMoves = [];
for (let i = 0; i < V.size.x; i++) {
for (let j = 0; j < V.size.y; j++) {
+ const colIJ = this.getColor(i, j);
if (
this.board[i][j] != V.EMPTY &&
- this.getColor(i, j) == color &&
- this.board[i][j][1] != V.GOAL &&
- !(Object.keys(V.TARGET_DECODE).includes(this.board[i][j][1]))
+ (
+ (this.subTurn == 2 && colIJ == color) ||
+ (
+ this.subTurn == 1 && colIJ != color &&
+ this.board[i][j][1] != V.GOAL &&
+ !(Object.keys(V.TARGET_DECODE).includes(this.board[i][j][1]))
+ )
+ )
) {
Array.prototype.push.apply(
potentialMoves,
this.kingPos[this.turn] = [move.vanish[1].x, move.vanish[1].y];
}
- static GenRandInitFen(randomness) {
- if (randomness == 0)
+ static GenRandInitFen(options) {
+ if (options.randomness == 0)
return "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w 0 -";
let pieces = { w: new Array(8), b: new Array(8) };
for (let c of ["w", "b"]) {
- if (c == 'b' && randomness == 1) {
+ if (c == 'b' && options.randomness == 1) {
pieces['b'] = pieces['w'];
break;
}
if (rem2 == positions[1] % 2) {
// Fix bishops (on different colors)
for (let i=2; i<8; i++) {
- if (positions[i] % 2 != rem2)
+ 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];
);
}
+ getComputerMove() {
+ let moves = this.getAllValidMoves();
+ if (moves.length == 0) return null;
+ // Random mover for now
+ const color = this.turn;
+ const m1 = moves[randInt(moves.length)];
+ this.play(m1);
+ let m = undefined;
+ if (this.turn != color) m = m1;
+ else {
+ const moves2 = this.getAllValidMoves();
+ m = [m1, moves2[randInt(moves2.length)]];
+ }
+ this.undo(m1);
+ return m;
+ }
+
getNotation(move) {
if (this.subTurn == 2) return "T:" + V.CoordsToSquare(move.end);
// Remove and re-add target to get a good notation:
else move.vanish[1].p = V.TARGET_CODE[move.vanish[1].p];
return notation;
}
+
};