X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=client%2Fsrc%2Fbase_rules.js;h=7c1c8232698368cebb01288c8aeef90c9e41618e;hb=4313762da3237b04f204e121a20cab3ba7bb5dd2;hp=c849626dd29a73213d138a8ea5692f9d3ad46559;hpb=2fac4d67083700a1f1e85ed8662c176c24cdea6b;p=vchess.git diff --git a/client/src/base_rules.js b/client/src/base_rules.js index c849626d..7c1c8232 100644 --- a/client/src/base_rules.js +++ b/client/src/base_rules.js @@ -22,8 +22,8 @@ export const Move = class Move { 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 }; } }; @@ -34,6 +34,34 @@ export const ChessRules = class ChessRules { ////////////// // MISC UTILS + static get Options() { + return { + select: [ + { + label: "Randomness", + variable: "randomness", + defaut: 0, + 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; + } + + static IsValidOptions(opts) { + return true; + } + // Some variants don't have flags: static get HasFlags() { return true; @@ -135,6 +163,19 @@ export const ChessRules = class ChessRules { 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() { @@ -330,8 +371,8 @@ export const ChessRules = class ChessRules { // 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 -"; @@ -339,7 +380,7 @@ export const ChessRules = class ChessRules { 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; @@ -437,8 +478,10 @@ export const ChessRules = class ChessRules { // 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++) { @@ -662,7 +705,7 @@ export const ChessRules = class ChessRules { case V.QUEEN: return this.getPotentialQueenMoves(sq); case V.KING: return this.getPotentialKingMoves(sq); } - return []; //never reached + return []; //never reached (but some variants may use it: Bario...) } // Build a regular move from its initial and destination squares. @@ -706,14 +749,15 @@ export const ChessRules = class ChessRules { // Generic method to find possible moves of non-pawn pieces: // "sliding or jumping" - getSlideNJumpMoves([x, y], steps, oneStep) { + getSlideNJumpMoves([x, y], steps, nbSteps) { let moves = []; outerLoop: for (let step of steps) { let i = x + step[0]; let j = y + step[1]; + let stepCounter = 0; while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) { moves.push(this.getBasicMove([x, y], [i, j])); - if (oneStep) continue outerLoop; + if (nbSteps && ++stepCounter >= nbSteps) continue outerLoop; i += step[0]; j += step[1]; } @@ -754,9 +798,8 @@ export const ChessRules = class ChessRules { 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)); } } @@ -856,7 +899,7 @@ export const ChessRules = class ChessRules { // What are the knight moves from square x,y ? getPotentialKnightMoves(sq) { - return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep"); + return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], 1); } // What are the bishop moves from square x,y ? @@ -867,19 +910,14 @@ export const ChessRules = class ChessRules { // What are the queen moves from square x,y ? getPotentialQueenMoves(sq) { return this.getSlideNJumpMoves( - sq, - V.steps[V.ROOK].concat(V.steps[V.BISHOP]) - ); + sq, V.steps[V.ROOK].concat(V.steps[V.BISHOP])); } // What are the king moves from square x,y ? getPotentialKingMoves(sq) { // Initialize with normal moves let moves = this.getSlideNJumpMoves( - sq, - V.steps[V.ROOK].concat(V.steps[V.BISHOP]), - "oneStep" - ); + sq, V.steps[V.ROOK].concat(V.steps[V.BISHOP]), 1); if (V.HasCastle && this.castleFlags[this.turn].some(v => v < V.size.y)) moves = moves.concat(this.getCastleMoves(sq)); return moves; @@ -1030,6 +1068,9 @@ export const ChessRules = class ChessRules { // 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++) { @@ -1060,13 +1101,18 @@ export const ChessRules = class ChessRules { // Generic method for non-pawn pieces ("sliding or jumping"): // is x,y attacked by a piece of given color ? - isAttackedBySlideNJump([x, y], color, piece, steps, oneStep) { + isAttackedBySlideNJump([x, y], color, piece, steps, nbSteps) { for (let step of steps) { let rx = x + step[0], ry = y + step[1]; - while (V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && !oneStep) { + let stepCounter = 1; + while ( + V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && + (!nbSteps || stepCounter < nbSteps) + ) { rx += step[0]; ry += step[1]; + stepCounter++; } if ( V.OnBoard(rx, ry) &&