X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=public%2Fjavascripts%2Fvariants%2FWildebeest.js;h=293b3b153d1d4214b623a1980820c9427253e12a;hb=69f3d8014e594ef949792d04d97b8286e9c2c268;hp=28f74d9464deab692b12ed3deae13120b229fca4;hpb=cf1303697774a12ef9bb154014a38797716944cf;p=vchess.git diff --git a/public/javascripts/variants/Wildebeest.js b/public/javascripts/variants/Wildebeest.js index 28f74d94..293b3b15 100644 --- a/public/javascripts/variants/Wildebeest.js +++ b/public/javascripts/variants/Wildebeest.js @@ -1,29 +1,78 @@ -//https://www.chessvariants.com/large.dir/wildebeest.html class WildebeestRules extends ChessRules { static getPpath(b) { - const V = VariantRules; return ([V.CAMEL,V.WILDEBEEST].includes(b[1]) ? "Wildebeest/" : "") + b; } - static get size() { return [10,11]; } + static get size() { return {x:10,y:11}; } static get CAMEL() { return 'c'; } static get WILDEBEEST() { return 'w'; } - static get steps() { + static get PIECES() + { + return ChessRules.PIECES.concat([V.CAMEL,V.WILDEBEEST]); + } + + static get steps() + { return Object.assign( ChessRules.steps, //add camel moves: {'c': [ [-3,-1],[-3,1],[-1,-3],[-1,3],[1,-3],[1,3],[3,-1],[3,1] ]} ); } + static IsGoodEnpassant(enpassant) + { + if (enpassant != "-") + { + const squares = enpassant.split(","); + if (squares.length > 2) + return false; + for (let sq of squares) + { + const ep = V.SquareToCoords(sq); + if (isNaN(ep.x) || !V.OnBoard(ep)) + return false; + } + } + return true; + } + + // There may be 2 enPassant squares (if pawn jump 3 squares) + getEnpassantFen() + { + const L = this.epSquares.length; + if (!this.epSquares[L-1]) + return "-"; //no en-passant + let res = ""; + this.epSquares[L-1].forEach(sq => { + res += V.CoordsToSquare(sq) + ","; + }); + return res.slice(0,-1); //remove last comma + } + // En-passant after 2-sq or 3-sq jumps - getEpSquare(move) + getEpSquare(moveOrSquare) { + if (!moveOrSquare) + return undefined; + if (typeof moveOrSquare === "string") + { + const square = moveOrSquare; + if (square == "-") + return undefined; + let res = []; + square.split(",").forEach(sq => { + res.push(V.SquareToCoords(sq)); + }); + return res; + } + // Argument is a move: + const move = moveOrSquare; const [sx,sy,ex] = [move.start.x,move.start.y,move.end.x]; - if (this.getPiece(sx,sy) == VariantRules.PAWN && Math.abs(sx - ex) >= 2) + if (this.getPiece(sx,sy) == V.PAWN && Math.abs(sx - ex) >= 2) { const step = (ex-sx) / Math.abs(ex-sx); let res = [{ @@ -46,9 +95,9 @@ class WildebeestRules extends ChessRules { switch (this.getPiece(x,y)) { - case VariantRules.CAMEL: + case V.CAMEL: return this.getPotentialCamelMoves([x,y]); - case VariantRules.WILDEBEEST: + case V.WILDEBEEST: return this.getPotentialWildebeestMoves([x,y]); default: return super.getPotentialMovesFrom([x,y]) @@ -60,69 +109,67 @@ class WildebeestRules extends ChessRules { const color = this.turn; let moves = []; - const V = VariantRules; - const [sizeX,sizeY] = VariantRules.size; - const shift = (color == "w" ? -1 : 1); + const [sizeX,sizeY] = [V.size.x,V.size.y]; + const shiftX = (color == "w" ? -1 : 1); const startRanks = (color == "w" ? [sizeX-2,sizeX-3] : [1,2]); const lastRank = (color == "w" ? 0 : sizeX-1); + const finalPieces = x + shiftX == lastRank + ? [V.ROOK,V.KNIGHT,V.BISHOP,V.QUEEN] + : [V.PAWN]; - if (x+shift >= 0 && x+shift < sizeX && x+shift != lastRank) + if (this.board[x+shiftX][y] == V.EMPTY) { - // Normal moves - if (this.board[x+shift][y] == V.EMPTY) + // One square forward + for (let piece of finalPieces) + moves.push(this.getBasicMove([x,y], [x+shiftX,y], {c:color,p:piece})); + if (startRanks.includes(x)) { - moves.push(this.getBasicMove([x,y], [x+shift,y])); - if (startRanks.includes(x) && this.board[x+2*shift][y] == V.EMPTY) + if (this.board[x+2*shiftX][y] == V.EMPTY) { // Two squares jump - moves.push(this.getBasicMove([x,y], [x+2*shift,y])); - if (x == startRanks[0] && this.board[x+3*shift][y] == V.EMPTY) + moves.push(this.getBasicMove([x,y], [x+2*shiftX,y])); + if (x==startRanks[0] && this.board[x+3*shiftX][y] == V.EMPTY) { - // 3-squares jump - moves.push(this.getBasicMove([x,y], [x+3*shift,y])); + // Three squares jump + moves.push(this.getBasicMove([x,y], [x+3*shiftX,y])); } } } - // Captures - if (y>0 && this.canTake([x,y], [x+shift,y-1]) && this.board[x+shift][y-1] != V.EMPTY) - moves.push(this.getBasicMove([x,y], [x+shift,y-1])); - if (y { - // Normal move - if (this.board[x+shift][y] == V.EMPTY) - moves.push(this.getBasicMove([x,y], [x+shift,y], {c:color,p:p})); - // Captures - if (y>0 && this.canTake([x,y], [x+shift,y-1]) && this.board[x+shift][y-1] != V.EMPTY) - moves.push(this.getBasicMove([x,y], [x+shift,y-1], {c:color,p:p})); - if (y= 0 && y + shiftY < sizeY + && this.board[x+shiftX][y+shiftY] != V.EMPTY + && this.canTake([x,y], [x+shiftX,y+shiftY])) + { + for (let piece of finalPieces) + { + moves.push(this.getBasicMove([x,y], [x+shiftX,y+shiftY], + {c:color,p:piece})); + } + } } // En passant const Lep = this.epSquares.length; - const epSquare = Lep>0 ? this.epSquares[Lep-1] : undefined; + const epSquare = this.epSquares[Lep-1]; if (!!epSquare) { for (let epsq of epSquare) { // TODO: some redundant checks - if (epsq.x == x+shift && Math.abs(epsq.y - y) == 1) + if (epsq.x == x+shiftX && Math.abs(epsq.y - y) == 1) { - let epStep = epsq.y - y; - var enpassantMove = this.getBasicMove([x,y], [x+shift,y+epStep]); + var enpassantMove = this.getBasicMove([x,y], [epsq.x,epsq.y]); + // WARNING: the captured pawn may be diagonally behind us, + // if it's a 3-squares jump and we take on 1st passing square + const px = (this.board[x][epsq.y] != V.EMPTY ? x : x - shiftX); enpassantMove.vanish.push({ - x: x, - y: y+epStep, + x: px, + y: epsq.y, p: 'p', - c: this.getColor(x,y+epStep) + c: this.getColor(px,epsq.y) }); moves.push(enpassantMove); } @@ -136,13 +183,13 @@ class WildebeestRules extends ChessRules getPotentialCamelMoves(sq) { - return this.getSlideNJumpMoves(sq, VariantRules.steps[VariantRules.CAMEL], "oneStep"); + return this.getSlideNJumpMoves(sq, V.steps[V.CAMEL], "oneStep"); } getPotentialWildebeestMoves(sq) { - const V = VariantRules; - return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), "oneStep"); + return this.getSlideNJumpMoves( + sq, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), "oneStep"); } isAttacked(sq, colors) @@ -155,12 +202,11 @@ class WildebeestRules extends ChessRules isAttackedByCamel(sq, colors) { return this.isAttackedBySlideNJump(sq, colors, - VariantRules.CAMEL, VariantRules.steps[VariantRules.CAMEL], "oneStep"); + V.CAMEL, V.steps[V.CAMEL], "oneStep"); } isAttackedByWildebeest(sq, colors) { - const V = VariantRules; return this.isAttackedBySlideNJump(sq, colors, V.WILDEBEEST, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), "oneStep"); } @@ -182,54 +228,45 @@ class WildebeestRules extends ChessRules static GenRandInitFen() { - let pieces = [new Array(10), new Array(10)]; - // Shuffle pieces on first and last rank - for (let c = 0; c <= 1; c++) + let pieces = { "w": new Array(10), "b": new Array(10) }; + for (let c of ["w","b"]) { let positions = _.range(11); - // Get random squares for bishops - let randIndex = 2 * _.random(5); - let bishop1Pos = positions[randIndex]; - // The second bishop must be on a square of different color - let randIndex_tmp = 2 * _.random(4) + 1; - let 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 = _.random(8); + // Get random squares for bishops + camels (different colors) + let randIndexes = _.sample(_.range(6), 2).map(i => { return 2*i; }); + let bishop1Pos = positions[randIndexes[0]]; + let camel1Pos = positions[randIndexes[1]]; + // The second bishop (camel) must be on a square of different color + let randIndexes_tmp = _.sample(_.range(5), 2).map(i => { return 2*i+1; }); + let bishop2Pos = positions[randIndexes_tmp[0]]; + let camel2Pos = positions[randIndexes_tmp[1]]; + for (let idx of randIndexes.concat(randIndexes_tmp) + .sort((a,b) => { return b-a; })) //largest indices first + { + positions.splice(idx, 1); + } + + let randIndex = _.random(6); let knight1Pos = positions[randIndex]; positions.splice(randIndex, 1); - randIndex = _.random(7); + randIndex = _.random(5); let knight2Pos = positions[randIndex]; positions.splice(randIndex, 1); - // Get random square for queen - randIndex = _.random(6); - let queenPos = positions[randIndex]; - positions.splice(randIndex, 1); - - // ...random square for camels - randIndex = _.random(5); - let camel1Pos = positions[randIndex]; - positions.splice(randIndex, 1); randIndex = _.random(4); - let camel2Pos = positions[randIndex]; + let queenPos = positions[randIndex]; positions.splice(randIndex, 1); - // ...random square for wildebeest + // Random square for wildebeest randIndex = _.random(3); let wildebeestPos = positions[randIndex]; positions.splice(randIndex, 1); - // Rooks and king positions are now fixed, because of the ordering rook-king-rook let rook1Pos = positions[0]; let kingPos = positions[1]; let rook2Pos = positions[2]; - // Finally put the shuffled pieces in the board array pieces[c][rook1Pos] = 'r'; pieces[c][knight1Pos] = 'n'; pieces[c][bishop1Pos] = 'b'; @@ -242,10 +279,11 @@ class WildebeestRules extends ChessRules pieces[c][knight2Pos] = 'n'; pieces[c][rook2Pos] = 'r'; } - let fen = pieces[0].join("") + + return pieces["b"].join("") + "/ppppppppppp/11/11/11/11/11/11/PPPPPPPPPPP/" + - pieces[1].join("").toUpperCase() + - " 1111"; - return fen; + pieces["w"].join("").toUpperCase() + + " w 1111 -"; } } + +const VariantRules = WildebeestRules;