5bb1bde47411b9efbd645f9c60f078807a69a0cd
1 import ChessRules
from "/base_rules";
2 import GiveawayRules
from "/variants/Giveaway";
3 import { ArrayFun
} from "/utils/array.js";
4 import { Random
} from "/utils/alea.js";
5 import PiPo
from "/utils/PiPo.js";
6 import Move
from "/utils/Move.js";
8 export class ChakartRules
extends ChessRules
{
10 static get Options() {
15 variable: "randomness",
18 {label: "Deterministic", value: 0},
19 {label: "Symmetric random", value: 1},
20 {label: "Asymmetric random", value: 2}
27 get pawnPromotions() {
28 return ['q', 'r', 'n', 'b', 'k'];
38 static get IMMOBILIZE_CODE() {
49 static get IMMOBILIZE_DECODE() {
60 static get INVISIBLE_QUEEN() {
64 // Fictive color 'a', bomb banana mushroom egg
69 return 'd'; //"Donkey"
74 static get MUSHROOM() {
78 genRandInitFen(seed
) {
79 const gr
= new GiveawayRules({mode: "suicide"}, true);
81 gr
.genRandInitFen(seed
).slice(0, -1) +
82 // Add Peach + Mario flags + capture counts
83 '{"flags":"1111","ccount":"000000000000"}'
90 ? "w" + f
.toLowerCase()
91 : (['w', 'd', 'e', 'm'].includes(f
) ? "a" : "b") + f
96 // King can send shell? Queen can be invisible?
98 w: {k: false, q: false},
99 b: {k: false, q: false}
101 for (let c
of ['w', 'b']) {
102 for (let p
of ['k', 'q']) {
103 this.powerFlags
[c
][p
] =
104 fenflags
.charAt((c
== "w" ? 0 : 2) + (p
== 'k' ? 0 : 1)) == "1";
110 return this.powerFlags
;
113 disaggregateFlags(flags
) {
114 this.powerFlags
= flags
;
118 return super.getFen() + " " + this.getCapturedFen();
122 return ['w', 'b'].map(c
=> {
123 return ['k', 'q'].map(p
=> this.powerFlags
[c
][p
] ? "1" : "0").join("");
128 const res
= ['w', 'b'].map(c
=> {
129 Object
.values(this.captured
[c
])
131 return res
[0].concat(res
[1]).join("");
134 setOtherVariables(fenParsed
) {
135 super.setOtherVariables(fenParsed
);
136 // Initialize captured pieces' counts from FEN
137 const allCapts
= fenParsed
.captured
.split("").map(x
=> parseInt(x
, 10));
138 const pieces
= ['p', 'r', 'n', 'b', 'q', 'k'];
140 w: Array
.toObject(pieces
, allCapts
.slice(0, 6)),
141 b: Array
.toObject(pieces
, allCapts
.slice(6, 12))
143 this.reserve
= { w: {}, b: {} }; //to be replaced by this.captured
147 // For Toadette bonus
148 getDropMovesFrom([c
, p
]) {
149 if (typeof c
!= "string" || this.reserve
[c
][p
] == 0)
152 const start
= (c
== 'w' && p
== 'p' ? 1 : 0);
153 const end
= (color
== 'b' && p
== 'p' ? 7 : 8);
154 for (let i
= start
; i
< end
; i
++) {
155 for (let j
= 0; j
< this.size
.y
; j
++) {
156 const pieceIJ
= this.getPiece(i
, j
);
158 this.board
[i
][j
] == "" ||
159 this.getColor(i
, j
) == 'a' ||
160 pieceIJ
== V
.INVISIBLE_QUEEN
165 appear: [new PiPo({x: i
, y: j
, c: c
, p: p
})],
168 // A drop move may remove a bonus (or hidden queen!)
169 if (this.board
[i
][j
] != "")
170 m
.vanish
.push(new PiPo({x: i
, y: j
, c: 'a', p: pieceIJ
}));
178 // Moving something. Potential effects resolved after playing
179 getPotentialMovesFrom([x
, y
], bonus
) {
181 if (bonus
== "toadette")
182 return this.getDropMovesFrom([x
, y
]);
183 if (bonus
== "kingboo") {
184 const initPiece
= this.getPiece(x
, y
);
185 const color
= this.getColor(x
, y
);
186 const oppCol
= C
.GetOppCol(color
);
187 // Only allow to swap pieces (TODO: restrict for pawns)
188 for (let i
=0; i
<this.size
.x
; i
++) {
189 for (let j
=0; j
<this.size
.y
; j
++) {
190 if ((i
!= x
|| j
!= y
) && this.board
[i
][j
] != "") {
191 let m
= this.getBasicMove([x
, y
], [i
, j
]);
193 new PiPo({x: x
, y: y
, p: this.getPiece(i
, j
), c: oppCol
}));
200 // Normal case (including bonus daisy)
201 switch (this.getPiece(x
, y
)) {
203 moves
= this.getPawnMovesFrom([x
, y
]); //apply promotions
206 moves
= this.getQueenMovesFrom([x
, y
]);
209 moves
= this.getKingMovesFrom([x
, y
]);
212 moves
= this.getKnightMovesFrom([x
, y
]);
216 // explicitely listing types to avoid moving immobilized piece
217 moves
= super.getPotentialMovesFrom([x
, y
]);
222 getPawnMovesFrom([x
, y
]) {
223 const color
= this.turn
;
224 const oppCol
= C
.GetOppCol(color
);
225 const shiftX
= (color
== 'w' ? -1 : 1);
226 const firstRank
= (color
== "w" ? this.size
.x
- 1 : 0);
229 this.board
[x
+ shiftX
][y
] == "" ||
230 this.getColor(x
+ shiftX
, y
) == 'a' ||
231 this.getPiece(x
+ shiftX
, y
) == V
.INVISIBLE_QUEEN
233 moves
.push(this.getBasicMove([x
, y
], [x
+ shiftX
, y
]));
235 [firstRank
, firstRank
+ shiftX
].includes(x
) &&
237 this.board
[x
+ 2 * shiftX
][y
] == "" ||
238 this.getColor(x
+ 2 * shiftX
, y
) == 'a' ||
239 this.getPiece(x
+ 2 * shiftX
, y
) == V
.INVISIBLE_QUEEN
242 moves
.push(this.getBasicMove([x
, y
], [x
+ 2 * shiftX
, y
]));
245 for (let shiftY
of [-1, 1]) {
248 y
+ shiftY
< sizeY
&&
249 this.board
[x
+ shiftX
][y
+ shiftY
] != "" &&
250 // Pawns cannot capture invisible queen this way!
251 this.getPiece(x
+ shiftX
, y
+ shiftY
) != V
.INVISIBLE_QUEEN
&&
252 ['a', oppCol
].includes(this.getColor(x
+ shiftX
, y
+ shiftY
))
254 moves
.push(this.getBasicMove([x
, y
], [x
+ shiftX
, y
+ shiftY
]));
257 super.pawnPostProcess(moves
, color
, oppCol
);
261 getQueenMovesFrom(sq
) {
262 const normalMoves
= super.getPotentialMovesOf('q', sq
);
263 // If flag allows it, add 'invisible movements'
264 let invisibleMoves
= [];
265 if (this.powerFlags
[this.turn
]['q']) {
266 normalMoves
.forEach(m
=> {
268 m
.appear
.length
== 1 &&
269 m
.vanish
.length
== 1 &&
270 // Only simple non-capturing moves:
273 let im
= JSON
.parse(JSON
.stringify(m
));
274 im
.appear
[0].p
= V
.INVISIBLE_QUEEN
;
275 im
.end
.noHighlight
= true;
276 invisibleMoves
.push(im
);
280 return normalMoves
.concat(invisibleMoves
);
283 getKingMovesFrom([x
, y
]) {
284 let moves
= super.getPotentialMovesOf('k', [x
, y
]);
285 // If flag allows it, add 'remote shell captures'
286 if (this.powerFlags
[this.turn
]['k']) {
287 super.pieces()['k'].moves
[0].steps
.forEach(step
=> {
288 let [i
, j
] = [x
+ step
[0], y
+ step
[1]];
290 this.onBoard(i
, j
) &&
292 this.board
[i
][j
] == "" ||
293 this.getPiece(i
, j
) == V
.INVISIBLE_QUEEN
||
295 this.getColor(i
, j
) == 'a' &&
296 [V
.EGG
, V
.MUSHROOM
].includes(this.getPiece(i
, j
))
303 if (this.onBoard(i
, j
)) {
304 const colIJ
= this.getColor(i
, j
);
305 if (colIJ
!= this.turn
) {
306 // May just destroy a bomb or banana:
313 new PiPo({x: i
, y: j
, c: colIJ
, p: this.getPiece(i
, j
)})
324 getKnightMovesFrom([x
, y
]) {
325 // Add egg on initial square:
326 return super.getPotentialMovesOf('n', [x
, y
]).map(m
=> {
327 m
.appear
.push(new PiPo({p: "e", c: "a", x: x
, y: y
}));
332 /// if any of my pieces was immobilized, it's not anymore.
333 //if play set a piece immobilized, then mark it
335 if (move.effect
== "toadette") {
336 this.reserve
= this.captured
;
337 this.re_drawReserve([this.turn
]);
339 else if (this.reserve
) {
340 this.reserve
= { w: {}, b: {} };
341 this.re_drawReserve([this.turn
]);
343 const color
= this.turn
;
345 move.vanish
.length
== 2 &&
346 move.vanish
[1].c
!= 'a' &&
347 move.appear
.length
== 1 //avoid king Boo!
349 // Capture: update this.captured
350 let capturedPiece
= move.vanish
[1].p
;
351 if (capturedPiece
== V
.INVISIBLE_QUEEN
)
352 capturedPiece
= V
.QUEEN
;
353 else if (Object
.keys(V
.IMMOBILIZE_DECODE
).includes(capturedPiece
))
354 capturedPiece
= V
.IMMOBILIZE_DECODE
[capturedPiece
];
355 this.captured
[move.vanish
[1].c
][capturedPiece
]++;
357 else if (move.vanish
.length
== 0) {
358 if (move.appear
.length
== 0 || move.appear
[0].c
== 'a')
360 // A piece is back on board
361 this.captured
[move.appear
[0].c
][move.appear
[0].p
]--;
363 if (move.appear
.length
== 0) {
364 // Three cases: king "shell capture", Chomp or Koopa
365 if (this.getPiece(move.start
.x
, move.start
.y
) == V
.KING
)
366 // King remote capture:
367 this.powerFlags
[color
][V
.KING
] = false;
368 else if (move.end
.effect
== "chomp")
369 this.captured
[color
][move.vanish
[0].p
]++;
371 else if (move.appear
[0].p
== V
.INVISIBLE_QUEEN
)
372 this.powerFlags
[move.appear
[0].c
][V
.QUEEN
] = false;
373 if (this.subTurn
== 2) return;
376 move.appear
.length
== 0 ||
377 !(Object
.keys(V
.IMMOBILIZE_DECODE
).includes(move.appear
[0].p
))
379 // Look for an immobilized piece of my color: it can now move
380 for (let i
=0; i
<8; i
++) {
381 for (let j
=0; j
<8; j
++) {
382 if (this.board
[i
][j
] != V
.EMPTY
) {
383 const piece
= this.getPiece(i
, j
);
385 this.getColor(i
, j
) == color
&&
386 Object
.keys(V
.IMMOBILIZE_DECODE
).includes(piece
)
388 this.board
[i
][j
] = color
+ V
.IMMOBILIZE_DECODE
[piece
];
389 move.wasImmobilized
= [i
, j
];
395 // Also make opponent invisible queen visible again, if any
396 const oppCol
= V
.GetOppCol(color
);
397 for (let i
=0; i
<8; i
++) {
398 for (let j
=0; j
<8; j
++) {
400 this.board
[i
][j
] != V
.EMPTY
&&
401 this.getColor(i
, j
) == oppCol
&&
402 this.getPiece(i
, j
) == V
.INVISIBLE_QUEEN
404 this.board
[i
][j
] = oppCol
+ V
.QUEEN
;
405 move.wasInvisible
= [i
, j
];
409 this.playOnBoard(move);
410 if (["kingboo", "toadette", "daisy"].includes(move.effect
)) {
411 this.effect
= move.effect
;
415 this.turn
= C
.GetOppCol(this.turn
);
425 // idée : on joue le coup, puis son effet est déterminé, puis la suite (si suite)
426 // est jouée automatiquement ou demande action utilisateur, etc jusqu'à coup terminal.
427 tryMoveFollowup(move, cb
) {
428 if (this.getColor(move.end
.x
, move.end
.y
) == 'a') {
429 // effect, or bonus/malus
430 const endType
= this.getPiece(m
.end
.x
, m
.end
.y
);
433 this.applyRandomBonus(move, cb
);
438 this.getRandomSquare([m
.end
.x
, m
.end
.y
],
440 ? [[1, 1], [1, -1], [-1, 1], [-1, -1]]
441 : [[1, 0], [-1, 0], [0, 1], [0, -1]]);
442 const nextMove
= this.getBasicMove([move.end
.x
, move.end
.y
], dest
);
447 // aller dans direction, saut par dessus pièce adverse
448 // ou amie (tjours), new step si roi caval pion
454 playVisual(move, r
) {
455 super.playVisual(move, r
);
457 alert(move.bonus
); //TODO: nicer display
460 applyRandomBonus(move, cb
) {
461 // TODO: determine bonus/malus, and then
464 // Helper to apply banana/bomb effect
465 getRandomSquare([x
, y
], steps
) {
466 const validSteps
= steps
.filter(s
=> this.onBoard(x
+ s
[0], y
+ s
[1]));
467 const step
= validSteps
[Random
.randInt(validSteps
.length
)];
468 return [x
+ step
[0], y
+ step
[1]];
471 // Warning: if play() is called, then move.end changed.
472 playPlusVisual(move, r
) {
473 this.moveStack
.push(move);
475 this.playVisual(move, r
);
476 this.tryMoveFollowup(move, (nextMove
) => {
478 this.playPlusVisual(nextMove
, r
);
480 this.afterPlay(this.moveStack
);