constructor(o) {
this.appear = o.appear;
this.vanish = o.vanish;
- this.start = o.start ? o.start : { x: o.vanish[0].x, y: o.vanish[0].y };
- this.end = o.end ? o.end : { x: o.appear[0].x, y: o.appear[0].y };
+ this.start = o.start || { x: o.vanish[0].x, y: o.vanish[0].y };
+ this.end = o.end || { x: o.appear[0].x, y: o.appear[0].y };
}
};
//////////////
// MISC UTILS
+ static get Options() {
+ return {
+ select: [
+ {
+ label: "Randomness",
+ variable: "randomness",
+ defaut: 2,
+ options: [
+ { label: "Deterministic", value: 0 },
+ { label: "Symmetric random", value: 1 },
+ { label: "Asymmetric random", value: 2 }
+ ]
+ }
+ ],
+ check: []
+ };
+ }
+
+ static AbbreviateOptions(opts) {
+ return "";
+ // Randomness is a special option: (TODO?)
+ //return "R" + opts.randomness;
+ }
+
// Some variants don't have flags:
static get HasFlags() {
return true;
static get LoseOnRepetition() {
return false;
}
+ // And in some others (Iceage), repetitions should be ignored:
+ static get IgnoreRepetition() {
+ return false;
+ }
+ loseOnRepetition() {
+ // In some variants, result depends on the position:
+ return V.LoseOnRepetition;
+ }
+
+ // At some stages, some games could wait clicks only:
+ onlyClick() {
+ return false;
+ }
// Some variants use click infos:
doClick() {
// FEN UTILS
// Setup the initial random (asymmetric) position
- static GenRandInitFen(randomness) {
- if (randomness == 0)
+ static GenRandInitFen(options) {
+ if (!options.randomness || options.randomness == 0)
// Deterministic:
return "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w 0 ahah -";
let flags = "";
// Shuffle pieces on first (and last rank if randomness == 2)
for (let c of ["w", "b"]) {
- if (c == 'b' && randomness == 1) {
+ if (c == 'b' && options.randomness == 1) {
pieces['b'] = pieces['w'];
flags += flags;
break;
// if more than 9 consecutive free spaces, break the integer,
// otherwise FEN parsing will fail.
if (count <= 9) return count;
- // Currently only boards of size up to 11 or 12:
- return "9" + (count - 9);
+ // Most boards of size < 18:
+ if (count <= 18) return "9" + (count - 9);
+ // Except Gomoku:
+ return "99" + (count - 18);
};
let position = "";
for (let i = 0; i < V.size.x; i++) {
if (!!promotions) finalPieces = promotions;
else if (!!V.PawnSpecs.promotions) finalPieces = V.PawnSpecs.promotions;
}
- let tr = null;
for (let piece of finalPieces) {
- tr = (piece != V.PAWN ? { c: color, p: piece } : null);
+ const tr = (piece != V.PAWN ? { c: color, p: piece } : null);
moves.push(this.getBasicMove([x1, y1], [x2, y2], tr));
}
}
// Stop at the first move found
// TODO: not really, it explores all moves from a square (one is enough).
+ // Possible fix: add extra arg "oneMove" to getPotentialMovesFrom,
+ // and then return only boolean true at first move found
+ // (in all getPotentialXXXMoves() ... for all variants ...)
atLeastOneMove() {
const color = this.turn;
for (let i = 0; i < V.size.x; i++) {