import ChessRules from "/base_rules.js";
-import GiveawayRules from "/variants/Giveaway/class.js";
import {ArrayFun} from "/utils/array.js";
import {Random} from "/utils/alea.js";
+import {FenUtil} from "/utils/setupPieces.js";
import PiPo from "/utils/PiPo.js";
import Move from "/utils/Move.js";
{
'y': {
// Virtual piece for "king remote shell captures"
- moves: [],
attack: [
{
steps: [
);
}
- genRandInitFen(seed) {
- const options = Object.assign({mode: "suicide"}, this.options);
- const gr = new GiveawayRules({options: options, genFenOnly: true});
- const baseFen = gr.genRandInitFen(seed);
- const fenParts = baseFen.split(" ");
- let others = JSON.parse(fenParts[3]);
- delete others["enpassant"];
- others["flags"] = "1111"; //Peach + Mario flags
- return fenParts.slice(0, 3).join(" ") + " " + JSON.stringify(others);
+ isKing(x, y, p) {
+ if (!p)
+ p = this.getPiece(x, y);
+ return ['k', 'l'].includes(p);
+ }
+
+ genRandInitBaseFen() {
+ const s = FenUtil.setupPieces(
+ ['r', 'n', 'b', 'q', 'k', 'b', 'n', 'r'],
+ {
+ randomness: this.options["randomness"],
+ diffCol: ['b']
+ }
+ );
+ return {
+ fen: s.b.join("") + "/pppppppp/8/8/8/8/PPPPPPPP/" +
+ s.w.join("").toUpperCase(),
+ o: {flags: "1111"} //Peach + Mario
+ };
}
fen2board(f) {
moves = this.getDropMovesFrom([x, y]);
else if (this.egg == "kingboo") {
const color = this.turn;
- const oppCol = C.GetOppCol(color);
+ const oppCol = C.GetOppTurn(color);
// Only allow to swap (non-immobilized!) pieces
for (let i=0; i<this.size.x; i++) {
for (let j=0; j<this.size.y; j++) {
getPawnMovesFrom([x, y]) {
const color = this.turn;
- const oppCol = C.GetOppCol(color);
+ const oppCol = C.GetOppTurn(color);
const shiftX = (color == 'w' ? -1 : 1);
const firstRank = (color == "w" ? this.size.x - 1 : 0);
let moves = [];
moves.push(this.getBasicMove([x, y], [x + shiftX, nextY]));
}
}
- this.pawnPostProcess(moves, color, oppCol);
+ moves = super.pawnPostProcess(moves, color, oppCol);
// Add mushroom on before-last square (+ potential segments)
moves.forEach(m => {
let [mx, my] = [x, y];
play(move) {
const color = this.turn;
- const oppCol = C.GetOppCol(color);
- if (
- move.appear.length > 0 &&
- move.appear[0].p == 'p' &&
- (
- (color == 'w' && move.end.x == 0) ||
- (color == 'b' && move.end.x == this.size.x - 1)
- )
- ) {
- // "Forgotten" promotion, which occurred after some effect
- let moves = [move];
- super.pawnPostProcess(moves, color, oppCol);
- super.showChoices(moves);
- return false;
- }
- this.postPlay(move, color, oppCol);
- return true;
- }
-
- postPlay(move, color, oppCol) {
+ const oppCol = C.GetOppTurn(color);
this.egg = move.egg;
if (move.egg == "toadette") {
this.reserve = { w: {}, b: {} };
this.displayBonus(move);
}
+ buildMoveStack(move, r) {
+ const color = this.turn;
+ if (
+ move.appear.length > 0 &&
+ move.appear[0].p == 'p' &&
+ (
+ (color == 'w' && move.end.x == 0) ||
+ (color == 'b' && move.end.x == this.size.x - 1)
+ )
+ ) {
+ // "Forgotten" promotion, which occurred after some effect
+ let moves = super.pawnPostProcess([move], color, C.GetOppTurn(color));
+ super.showChoices(moves, r);
+ }
+ else
+ super.buildMoveStack(move, r);
+ }
+
computeNextMove(move) {
+ if (move.koopa)
+ return null;
// Set potential random effects, so that play() is deterministic
// from opponent viewpoint:
const endPiece = this.getPiece(move.end.x, move.end.y);
let bagOfPieces = [];
for (let i=0; i<this.size.x; i++) {
for (let j=0; j<this.size.y; j++) {
- if (this.getColor(i, j) == c && this.getPiece(i, j) != 'k')
+ const pieceIJ = this.getPiece(i, j);
+ if (
+ this.getColor(i, j) == c && pieceIJ != 'k' &&
+ (
+ // The color will change, so pawns on first rank are ineligible
+ pieceIJ != 'p' ||
+ (c == 'w' && i < this.size.x - 1) || (c == 'b' && i > 0)
+ )
+ ) {
bagOfPieces.push([i, j]);
+ }
}
}
if (bagOfPieces.length >= 1)
case "luigi":
case "waluigi":
// Change color of friendly or enemy piece, king excepted
- const oldColor = (move.egg == "waluigi" ? color : C.GetOppCol(color));
- const newColor = C.GetOppCol(oldColor);
+ const oldColor = (move.egg == "waluigi" ? color : C.GetOppTurn(color));
+ const newColor = C.GetOppTurn(oldColor);
const coords = getRandomPiece(oldColor);
if (coords) {
const piece = this.getPiece(coords[0], coords[1]);
+ if (coords[0] == move.start.x && coords[1] == move.start.y) {
+ // Moving piece change color: fix coords
+ coords = [move.end.x, move.end.y];
+ }
em = new Move({
appear: [
new PiPo({x: coords[0], y: coords[1], c: newColor, p: piece})
});
break;
case "koopa":
- // Reverse move
+ // Reverse move, if possible
em = new Move({
- appear: [
- new PiPo({
- x: move.start.x, y: move.start.y, c: color, p: move.appear[0].p
- })
- ],
+ appear: [],
vanish: [
new PiPo({
x: move.end.x, y: move.end.y, c: color, p: move.appear[0].p
})
- ]
+ ],
+ end: {x: move.start.x, y: move.start.y} //may be irrelevant
});
+ em.koopa = true; //avoid applying effect
+ if (move.vanish.length == 0)
+ // After toadette+drop, just erase piece
+ break;
+ em.appear.push(
+ new PiPo({
+ x: move.start.x, y: move.start.y, c: color, p: move.appear[0].p
+ })
+ );
if (this.board[move.start.x][move.start.y] != "") {
// Pawn or knight let something on init square
em.vanish.push(new PiPo({
}
displayBonus(move) {
- let divBonus = document.createElement("div");
- divBonus.classList.add("bonus-text");
- divBonus.innerHTML = move.egg;
- let container = document.getElementById(this.containerId);
- container.appendChild(divBonus);
- setTimeout(() => container.removeChild(divBonus), 2000);
+ super.displayMessage(null, move.egg, "bonus-text", 2000);
}
atLeastOneMove() {
projects / xogo.git / blobdiff