// After move is played, update variables + flags
updateVariables(move) {
let piece = undefined;
+ // TODO: update variables before move is played, and just use this.turn ?
+ // (doesn't work in general, think MarseilleChess)
let c = undefined;
if (move.vanish.length >= 1) {
// Usual case, something is moved
piece = move.appear[0].p;
c = move.appear[0].c;
}
- if (c == "c") {
- //if (!["w","b"].includes(c))
- // 'c = move.vanish[0].c' doesn't work for Checkered
+ if (!['w','b'].includes(c)) {
+ // Checkered, for example
c = V.GetOppCol(this.turn);
}
const firstRank = c == "w" ? V.size.x - 1 : 0;
// Capture
const startColumn = V.CoordToColumn(move.start.y);
notation = startColumn + "x" + finalSquare;
- } //no capture
+ }
else notation = finalSquare;
if (move.appear.length > 0 && move.appear[0].p != V.PAWN)
- //promotion
+ // Promotion
notation += "=" + move.appear[0].p.toUpperCase();
return notation;
}
"Lose all pieces": "Lose all pieces",
"Move twice": "Move twice",
"Pawns move diagonally": "Pawns move diagonally",
+ "Reuse pieces": "Reuse pieces",
"Reverse captures": "Reverse captures",
"Shared pieces": "Shared pieces",
"Standard rules": "Standard rules"
"Lose all pieces": "Perder todas las piezas",
"Move twice": "Mover dos veces",
"Pawns move diagonally": "Peones se mueven en diagonal",
+ "Reuse pieces": "Reutilizar piezas",
"Reverse captures": "Capturas invertidas",
"Shared pieces": "Piezas compartidas",
"Standard rules": "Reglas estandar"
"Lose all pieces": "Perdez toutes les pièces",
"Move twice": "Jouer deux coups",
"Pawns move diagonally": "Les pions vont en diagonale",
+ "Reuse pieces": "Réutiliser les pièces",
"Reverse captures": "Captures inversées",
"Shared pieces": "Pièces partagées",
"Standard rules": "Règles usuelles"
p
| This variant is very popular, a possible starting point is
- a(href="https://www.chessvariants.com/other.dir/crazyhouse.html") lichess.org
+ a(href="https://lichess.org/variant/crazyhouse") lichess.org
| .
--- /dev/null
+p.boxed
+ | Capturing your own pieces is possible: captured units
+ | can be landed anywhere instead of moving a piece.
+
+p
+ | Orthodox rules apply, with only one change:
+ | at each turn you can choose to eat one of your pieces, augmenting your
+ | "reserve" of waiting pieces with this figure. At every move, you may
+ | choose to land one of your reserve pieces anywhere on the board
+ | (except first and last ranks for pawns), instead of playing a regular move.
+
+p.
+ Move notation: an arobase '@' indicate piece landing. For example B@d4 means
+ a bishop rebirth on d4 square, and @f3 is a pawn landing on f3.
+
+figure.diagram-container
+ .diagram
+ | fen:rnbqkb1r/ppppnppp/8/4N3/3p4/8/PPPPPPPP/1RBQKBNR:
+ figcaption After 1.Rxb1 Nxe7 2.N@e5 @d4
+
+p.
+ Note: when a pawn reaches the 8th(1st) rank, it will get removed from the board.
+ It will not be replaced by another piece. It does not promote.
+
+h3 Source
+
+p
+ a(href="https://www.chessvariants.com/difftaking.dir/recyclechess.html") Recycle chess
+ | on chessvariants.com.
--- /dev/null
+p.boxed
+ | Puedes capturar tus propias piezas: estas pueden ser
+ | colocándo a cualquier casilla en lugar de moverlo.
+
+p.
+ Se aplican reglas ortodoxas, con un solo cambio:
+ cada turno puedes elegir comer una de tus propias piezas,
+ aumentando su "reserva" de piezas de espera con esta unidad.
+ Con cada movimiento puedes elegir poner una de estas piezas en reserva
+ (en cualquier lugar, excepto las filas 1 y 8 para los peones) en lugar
+ de jugar una jugada habitual.
+
+p.
+ Notación: un signo '@' indica la llegada de una pieza de reserva.
+ Por ejemplo, B@d4 significa que un alfil se mete en d4, y @f3 significa
+ renacimiento de peón en f3.
+
+figure.diagram-container
+ .diagram
+ | fen:rnbqkb1r/ppppnppp/8/4N3/3p4/8/PPPPPPPP/1RBQKBNR:
+ figcaption Después de 1.Rxb1 Nxe7 2.N@e5 @d4
+
+p.
+ Nota: cuando un peón alcanza la 8va(1ra) fila, se retira del juego.
+ No se reemplaza por otra pieza. No hay promoción
+
+h3 Fuente
+
+p
+ | La
+ a(href="https://www.chessvariants.com/difftaking.dir/recyclechess.html") variante Reciclaje
+ | en chessvariants.com.
--- /dev/null
+p.boxed
+ | Vous pouvez capturer vos propres pièces : celles-ci peuvent ensuite être
+ | parachutées n'importe où au lieu d'effectuer un déplacement.
+
+p.
+ Les règles orthodoxes s'appliquent, avec un seul changement :
+ à chaque tour vous pouvez choisir de manger une de vos propres pièces,
+ augmentant votre "réserve" de pièces en attente avec cette unité.
+ À chaque coup vous pouvez choisir de poser une de ces pièces en réserve
+ (n'importe où, sauf rangées 1 et 8 pour les pions) au lieu de jouer un
+ coup habituel.
+
+p.
+ Notation : une arobase '@' indique l'arrivée d'une pièce de réserve.
+ Par exemple, B@d4 signifie un parachutage de fou en d4, et @f3 une
+ renaissance de pion en f3.
+
+figure.diagram-container
+ .diagram
+ | fen:rnbqkb1r/ppppnppp/8/4N3/3p4/8/PPPPPPPP/1RBQKBNR:
+ figcaption After 1.Rxb1 Nxe7 2.N@e5 @d4
+
+p.
+ Note : quand un pion atteint la 8eme(1ere) rangée, il est retiré du jeu.
+ Il n'est pas remplacé par une autre pièce. Il n'y a pas de promotion.
+
+h3 Source
+
+p
+ | La
+ a(href="https://www.chessvariants.com/difftaking.dir/recyclechess.html") variante Recyclage
+ | sur chessvariants.com.
getCurrentScore() {
if (this.atLeastOneMove())
- // game not over
return "*";
const color = this.turn;
return moves;
}
- // Long-leaper
getKnightCaptures(startSquare, byChameleon) {
// Look in every direction for captures
const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
return super.getPotentialQueenMoves(sq).concat(this.getKnightCaptures(sq));
}
+ // Chameleon
getPotentialBishopMoves([x, y]) {
let moves = super
.getPotentialQueenMoves([x, y])
return moves;
}
- // Withdrawer
addQueenCaptures(moves, byChameleon) {
if (moves.length == 0) return;
const [x, y] = [moves[0].start.x, moves[0].start.y];
});
}
+ // Withdrawer
getPotentialQueenMoves(sq) {
let moves = super.getPotentialQueenMoves(sq);
this.addQueenCaptures(moves);
}
static get SEARCH_DEPTH() {
+ // High branching factor
return 2;
- } //high branching factor
+ }
evalPosition() {
let evaluation = super.evalPosition();
move.appear[0].p != V.PAWN ? move.appear[0].p.toUpperCase() : "";
return piece + "@" + V.CoordsToSquare(move.end);
}
-
- getLongNotation(move) {
- if (move.vanish.length > 0) return super.getLongNotation(move);
- return "@" + V.CoordsToSquare(move.end);
- }
};
let moves = [];
const [sizeX, sizeY] = [V.size.x, V.size.y];
const shiftX = color == "w" ? -1 : 1;
- const firstRank = color == "w" ? sizeX - 1 : 0;
const startRank = color == "w" ? sizeX - 2 : 1;
const lastRank = color == "w" ? 0 : sizeX - 1;
- const pawnColor = this.getColor(x, y); //can be different for checkered
- // NOTE: next condition is generally true (no pawn on last rank)
- if (x + shiftX >= 0 && x + shiftX < sizeX) {
- const finalPieces =
- x + shiftX == lastRank
- ? [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]
- : [V.PAWN];
- // One square forward
- if (this.board[x + shiftX][y] == V.EMPTY) {
+ const finalPieces =
+ x + shiftX == lastRank
+ ? [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]
+ : [V.PAWN];
+ // One square forward
+ if (this.board[x + shiftX][y] == V.EMPTY) {
+ for (let piece of finalPieces) {
+ moves.push(
+ this.getBasicMove([x, y], [x + shiftX, y], {
+ c: color,
+ p: piece
+ })
+ );
+ }
+ if (
+ x == startRank &&
+ this.board[x + 2 * shiftX][y] == V.EMPTY
+ ) {
+ // Two squares jump
+ moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
+ }
+ }
+ // Captures
+ for (let shiftY of [-1, 1]) {
+ if (
+ y + shiftY >= 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], {
- c: pawnColor,
+ this.getBasicMove([x, y], [x + shiftX, y + shiftY], {
+ c: color,
p: piece
})
);
}
- // Next condition because pawns on 1st rank can generally jump
- if (
- [startRank, firstRank].includes(x) &&
- this.board[x + 2 * shiftX][y] == V.EMPTY
- ) {
- // Two squares jump
- moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
- }
- }
- // Captures
- for (let shiftY of [-1, 1]) {
- if (
- y + shiftY >= 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: pawnColor,
- p: piece
- })
- );
- }
- }
}
}
--- /dev/null
+import { ChessRules, PiPo, Move } from "@/base_rules";
+import { ArrayFun } from "@/utils/array";
+
+export const VariantRules = class RecycleRules extends ChessRules {
+ static IsGoodFen(fen) {
+ if (!ChessRules.IsGoodFen(fen)) return false;
+ const fenParsed = V.ParseFen(fen);
+ // 5) Check reserves
+ if (!fenParsed.reserve || !fenParsed.reserve.match(/^[0-9]{10,10}$/))
+ return false;
+ return true;
+ }
+
+ static ParseFen(fen) {
+ const fenParts = fen.split(" ");
+ return Object.assign(ChessRules.ParseFen(fen), {
+ reserve: fenParts[5],
+ });
+ }
+
+ static GenRandInitFen() {
+ return ChessRules.GenRandInitFen() + " 0000000000";
+ }
+
+ getFen() {
+ return (
+ super.getFen() + " " + this.getReserveFen()
+ );
+ }
+
+ getReserveFen() {
+ let counts = new Array(10);
+ for (
+ let i = 0;
+ i < V.PIECES.length - 1;
+ i++ //-1: no king reserve
+ ) {
+ counts[i] = this.reserve["w"][V.PIECES[i]];
+ counts[5 + i] = this.reserve["b"][V.PIECES[i]];
+ }
+ return counts.join("");
+ }
+
+ setOtherVariables(fen) {
+ super.setOtherVariables(fen);
+ const fenParsed = V.ParseFen(fen);
+ // Also init reserves (used by the interface to show landable pieces)
+ this.reserve = {
+ w: {
+ [V.PAWN]: parseInt(fenParsed.reserve[0]),
+ [V.ROOK]: parseInt(fenParsed.reserve[1]),
+ [V.KNIGHT]: parseInt(fenParsed.reserve[2]),
+ [V.BISHOP]: parseInt(fenParsed.reserve[3]),
+ [V.QUEEN]: parseInt(fenParsed.reserve[4])
+ },
+ b: {
+ [V.PAWN]: parseInt(fenParsed.reserve[5]),
+ [V.ROOK]: parseInt(fenParsed.reserve[6]),
+ [V.KNIGHT]: parseInt(fenParsed.reserve[7]),
+ [V.BISHOP]: parseInt(fenParsed.reserve[8]),
+ [V.QUEEN]: parseInt(fenParsed.reserve[9])
+ }
+ };
+ }
+
+ getColor(i, j) {
+ if (i >= V.size.x) return i == V.size.x ? "w" : "b";
+ return this.board[i][j].charAt(0);
+ }
+
+ getPiece(i, j) {
+ if (i >= V.size.x) return V.RESERVE_PIECES[j];
+ return this.board[i][j].charAt(1);
+ }
+
+ // Used by the interface:
+ getReservePpath(color, index) {
+ return color + V.RESERVE_PIECES[index];
+ }
+
+ // Ordering on reserve pieces
+ static get RESERVE_PIECES() {
+ return [V.PAWN, V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN];
+ }
+
+ getReserveMoves([x, y]) {
+ const color = this.turn;
+ const p = V.RESERVE_PIECES[y];
+ if (this.reserve[color][p] == 0) return [];
+ let moves = [];
+ const pawnShift = p == V.PAWN ? 1 : 0;
+ for (let i = pawnShift; i < V.size.x - pawnShift; i++) {
+ for (let j = 0; j < V.size.y; j++) {
+ if (this.board[i][j] == V.EMPTY) {
+ let mv = new Move({
+ appear: [
+ new PiPo({
+ x: i,
+ y: j,
+ c: color,
+ p: p
+ })
+ ],
+ vanish: [],
+ start: { x: x, y: y }, //a bit artificial...
+ end: { x: i, y: j }
+ });
+ moves.push(mv);
+ }
+ }
+ }
+ return moves;
+ }
+
+ getPotentialMovesFrom([x, y]) {
+ if (x >= V.size.x) {
+ // Reserves, outside of board: x == sizeX(+1)
+ return this.getReserveMoves([x, y]);
+ }
+ // Standard moves
+ return super.getPotentialMovesFrom([x, y]);
+ }
+
+ getPotentialPawnMoves([x, y]) {
+ const color = this.turn;
+ let moves = [];
+ const [sizeX, sizeY] = [V.size.x, V.size.y];
+ const shiftX = color == "w" ? -1 : 1;
+ const startRank = color == "w" ? sizeX - 2 : 1;
+ const lastRank = color == "w" ? 0 : sizeX - 1;
+
+ // One square forward
+ if (this.board[x + shiftX][y] == V.EMPTY) {
+ moves.push(
+ this.getBasicMove([x, y], [x + shiftX, y])
+ );
+ // Next condition because pawns on 1st rank can generally jump
+ if (
+ x == startRank &&
+ this.board[x + 2 * shiftX][y] == V.EMPTY
+ ) {
+ // Two squares jump
+ moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
+ }
+ }
+ // Captures
+ for (let shiftY of [-1, 1]) {
+ if (
+ y + shiftY >= 0 &&
+ y + shiftY < sizeY &&
+ this.board[x + shiftX][y + shiftY] != V.EMPTY &&
+ this.canTake([x, y], [x + shiftX, y + shiftY])
+ ) {
+ moves.push(
+ this.getBasicMove([x, y], [x + shiftX, y + shiftY])
+ );
+ }
+ }
+
+ // En passant
+ const Lep = this.epSquares.length;
+ const epSquare = this.epSquares[Lep - 1]; //always at least one element
+ if (
+ !!epSquare &&
+ epSquare.x == x + shiftX &&
+ Math.abs(epSquare.y - y) == 1
+ ) {
+ let enpassantMove = this.getBasicMove([x, y], [epSquare.x, epSquare.y]);
+ enpassantMove.vanish.push({
+ x: x,
+ y: epSquare.y,
+ p: "p",
+ c: this.getColor(x, epSquare.y)
+ });
+ moves.push(enpassantMove);
+ }
+
+ // Post-processing: remove falling pawns
+ if (x + shiftX == lastRank) {
+ moves.forEach(m => {
+ m.appear.pop();
+ });
+ }
+
+ return moves;
+ }
+
+ getAllValidMoves() {
+ let moves = super.getAllValidMoves();
+ const color = this.turn;
+ for (let i = 0; i < V.RESERVE_PIECES.length; i++)
+ moves = moves.concat(
+ this.getReserveMoves([V.size.x + (color == "w" ? 0 : 1), i])
+ );
+ return this.filterValid(moves);
+ }
+
+ atLeastOneMove() {
+ if (!super.atLeastOneMove()) {
+ // Search one reserve move
+ for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
+ let moves = this.filterValid(
+ this.getReserveMoves([V.size.x + (this.turn == "w" ? 0 : 1), i])
+ );
+ if (moves.length > 0) return true;
+ }
+ return false;
+ }
+ return true;
+ }
+
+ canTake([x1, y1], [x2, y2]) {
+ // Self-captures allowed, except for the king:
+ return this.getPiece(x2, y2) != V.KING;
+ }
+
+ updateVariables(move) {
+ super.updateVariables(move);
+ if (move.vanish.length == 2 && move.appear.length == 2) return; //skip castle
+ const color = V.GetOppCol(this.turn);
+ if (move.vanish.length == 0) {
+ this.reserve[color][move.appear[0].p]--;
+ return;
+ }
+ else if (move.vanish.length == 2 && move.vanish[1].c == color) {
+ // Self-capture
+ this.reserve[color][move.vanish[1].p]++;
+ }
+ }
+
+ unupdateVariables(move) {
+ super.unupdateVariables(move);
+ if (move.vanish.length == 2 && move.appear.length == 2) return;
+ const color = this.turn;
+ if (move.vanish.length == 0) {
+ this.reserve[color][move.appear[0].p]++;
+ return;
+ }
+ else if (move.vanish.length == 2 && move.vanish[1].c == color) {
+ this.reserve[color][move.vanish[1].p]--;
+ }
+ }
+
+ static get SEARCH_DEPTH() {
+ return 2;
+ }
+
+ evalPosition() {
+ let evaluation = super.evalPosition();
+ // Add reserves:
+ for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
+ const p = V.RESERVE_PIECES[i];
+ evaluation += this.reserve["w"][p] * V.VALUES[p];
+ evaluation -= this.reserve["b"][p] * V.VALUES[p];
+ }
+ return evaluation;
+ }
+
+ getNotation(move) {
+ const finalSquare = V.CoordsToSquare(move.end);
+ if (move.vanish.length > 0) {
+ if (move.appear.length > 0) {
+ // Standard move
+ return super.getNotation(move);
+ } else {
+ // Pawn fallen: capturing or not
+ let res = "";
+ if (move.vanish.length == 2)
+ res += V.CoordToColumn(move.start.y) + "x";
+ return res + finalSquare;
+ }
+ }
+ // Rebirth:
+ const piece =
+ move.appear[0].p != V.PAWN ? move.appear[0].p.toUpperCase() : "";
+ return piece + "@" + V.CoordsToSquare(move.end);
+ }
+};
('Losers', 'Lose all pieces'),
('Magnetic', 'Laws of attraction'),
('Marseille', 'Move twice'),
+ ('Recycle', 'Reuse pieces'),
('Upsidedown', 'Board upside down'),
('Wildebeest', 'Balanced sliders & leapers'),
('Zen', 'Reverse captures');
projects / vchess.git / commitdiff