-//https://www.chessvariants.com/large.dir/wildebeest.html
class WildebeestRules extends ChessRules
{
static getPpath(b)
const V = VariantRules;
const [sizeX,sizeY] = VariantRules.size;
const shift = (color == "w" ? -1 : 1);
- const startRanks = (color == "w" ? [sizeY-2,sizeY-3] : [1,2]);
- const lastRank = (color == "w" ? 0 : sizeY-1);
+ const startRanks = (color == "w" ? [sizeX-2,sizeX-3] : [1,2]);
+ const lastRank = (color == "w" ? 0 : sizeX-1);
if (x+shift >= 0 && x+shift < sizeX && x+shift != lastRank)
{
}
}
// Captures
- if (y>0 && this.canTake([x,y], [x+shift,y-1]) && this.board[x+shift][y-1] != V.EMPTY)
+ 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<sizeY-1 && this.canTake([x,y], [x+shift,y+1]) && this.board[x+shift][y+1] != V.EMPTY)
+ }
+ if (y<sizeY-1 && 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 (x+shift == lastRank)
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)
+ 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<sizeY-1 && this.canTake([x,y], [x+shift,y+1]) && this.board[x+shift][y+1] != V.EMPTY)
+ }
+ if (y<sizeY-1 && 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}));
+ }
});
}
getPotentialCamelMoves(sq)
{
- return this.getSlideNJumpMoves(sq, VariantRules.steps[VariantRules.CAMEL], "oneStep");
+ return this.getSlideNJumpMoves(
+ sq, VariantRules.steps[VariantRules.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)
isAttackedByCamel(sq, colors)
{
return this.isAttackedBySlideNJump(sq, colors,
- VariantRules.CAMEL, VariantRules.steps[VariantRules.CAMEL]);
+ VariantRules.CAMEL, VariantRules.steps[VariantRules.CAMEL], "oneStep");
}
isAttackedByWildebeest(sq, colors)
{
const V = VariantRules;
return this.isAttackedBySlideNJump(sq, colors, V.WILDEBEEST,
- V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]));
+ V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), "oneStep");
}
- // TODO: stalemate is a win (?!)
+ checkGameEnd()
+ {
+ // No valid move: game is lost (stalemate is a win)
+ return this.turn == "w" ? "0-1" : "1-0";
+ }
static get VALUES() {
return Object.assign(
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';
pieces[c][knight2Pos] = 'n';
pieces[c][rook2Pos] = 'r';
}
- let fen = pieces[0].join("") +
+ let fen = pieces["b"].join("") +
"/ppppppppppp/11/11/11/11/11/11/PPPPPPPPPPP/" +
- pieces[1].join("").toUpperCase() +
+ pieces["w"].join("").toUpperCase() +
" 1111";
return fen;
}