4ff23a00abd1c3a8944ffed20eb7ac9c997ee772
1 import { ChessRules
, PiPo
, Move
} from "@/base_rules";
2 import { ArrayFun
} from "@/utils/array";
3 import { shuffle
} from "@/utils/alea";
5 export class BaroqueRules
extends ChessRules
{
6 static get HasFlags() {
10 static get HasEnpassant() {
15 return ChessRules
.PIECES
.concat([V
.IMMOBILIZER
]);
20 //'m' for Immobilizer (I is too similar to 1)
21 return "Baroque/" + b
;
22 return b
; //usual piece
25 // No castling, but checks, so keep track of kings
26 setOtherVariables(fen
) {
27 this.kingPos
= { w: [-1, -1], b: [-1, -1] };
28 const fenParts
= fen
.split(" ");
29 const position
= fenParts
[0].split("/");
30 for (let i
= 0; i
< position
.length
; i
++) {
32 for (let j
= 0; j
< position
[i
].length
; j
++) {
33 switch (position
[i
].charAt(j
)) {
35 this.kingPos
["b"] = [i
, k
];
38 this.kingPos
["w"] = [i
, k
];
41 const num
= parseInt(position
[i
].charAt(j
), 10);
42 if (!isNaN(num
)) k
+= num
- 1;
50 static get IMMOBILIZER() {
53 // Although other pieces keep their names here for coding simplicity,
55 // - a "rook" is a coordinator, capturing by coordinating with the king
56 // - a "knight" is a long-leaper, capturing as in draughts
57 // - a "bishop" is a chameleon, capturing as its prey
58 // - a "queen" is a withdrawer, capturing by moving away from pieces
60 // Is piece on square (x,y) immobilized?
61 isImmobilized([x
, y
]) {
62 const piece
= this.getPiece(x
, y
);
63 const color
= this.getColor(x
, y
);
64 const oppCol
= V
.GetOppCol(color
);
65 const adjacentSteps
= V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
]);
66 for (let step
of adjacentSteps
) {
67 const [i
, j
] = [x
+ step
[0], y
+ step
[1]];
70 this.board
[i
][j
] != V
.EMPTY
&&
71 this.getColor(i
, j
) == oppCol
73 const oppPiece
= this.getPiece(i
, j
);
74 if (oppPiece
== V
.IMMOBILIZER
) {
75 // Moving is possible only if this immobilizer is neutralized
76 for (let step2
of adjacentSteps
) {
77 const [i2
, j2
] = [i
+ step2
[0], j
+ step2
[1]];
78 if (i2
== x
&& j2
== y
) continue; //skip initial piece!
81 this.board
[i2
][j2
] != V
.EMPTY
&&
82 this.getColor(i2
, j2
) == color
84 if ([V
.BISHOP
, V
.IMMOBILIZER
].includes(this.getPiece(i2
, j2
)))
88 return true; //immobilizer isn't neutralized
90 // Chameleons can't be immobilized twice,
91 // because there is only one immobilizer
92 if (oppPiece
== V
.BISHOP
&& piece
== V
.IMMOBILIZER
) return true;
98 getPotentialMovesFrom([x
, y
]) {
99 // Pre-check: is thing on this square immobilized?
100 if (this.isImmobilized([x
, y
])) return [];
101 switch (this.getPiece(x
, y
)) {
103 return this.getPotentialImmobilizerMoves([x
, y
]);
105 return super.getPotentialMovesFrom([x
, y
]);
109 getSlideNJumpMoves([x
, y
], steps
, oneStep
) {
110 const piece
= this.getPiece(x
, y
);
112 outerLoop: for (let step
of steps
) {
115 while (V
.OnBoard(i
, j
) && this.board
[i
][j
] == V
.EMPTY
) {
116 moves
.push(this.getBasicMove([x
, y
], [i
, j
]));
117 if (oneStep
!== undefined) continue outerLoop
;
121 // Only king can take on occupied square:
122 if (piece
== V
.KING
&& V
.OnBoard(i
, j
) && this.canTake([x
, y
], [i
, j
]))
123 moves
.push(this.getBasicMove([x
, y
], [i
, j
]));
128 // Modify capturing moves among listed pawn moves
129 addPawnCaptures(moves
, byChameleon
) {
130 const steps
= V
.steps
[V
.ROOK
];
131 const color
= this.turn
;
132 const oppCol
= V
.GetOppCol(color
);
134 if (!!byChameleon
&& m
.start
.x
!= m
.end
.x
&& m
.start
.y
!= m
.end
.y
)
135 // Chameleon not moving as pawn
137 // Try capturing in every direction
138 for (let step
of steps
) {
139 const sq2
= [m
.end
.x
+ 2 * step
[0], m
.end
.y
+ 2 * step
[1]];
141 V
.OnBoard(sq2
[0], sq2
[1]) &&
142 this.board
[sq2
[0]][sq2
[1]] != V
.EMPTY
&&
143 this.getColor(sq2
[0], sq2
[1]) == color
146 const sq1
= [m
.end
.x
+ step
[0], m
.end
.y
+ step
[1]];
148 this.board
[sq1
[0]][sq1
[1]] != V
.EMPTY
&&
149 this.getColor(sq1
[0], sq1
[1]) == oppCol
151 const piece1
= this.getPiece(sq1
[0], sq1
[1]);
152 if (!byChameleon
|| piece1
== V
.PAWN
) {
169 getPotentialPawnMoves([x
, y
]) {
170 let moves
= super.getPotentialRookMoves([x
, y
]);
171 this.addPawnCaptures(moves
);
175 addRookCaptures(moves
, byChameleon
) {
176 const color
= this.turn
;
177 const oppCol
= V
.GetOppCol(color
);
178 const kp
= this.kingPos
[color
];
180 // Check piece-king rectangle (if any) corners for enemy pieces
181 if (m
.end
.x
== kp
[0] || m
.end
.y
== kp
[1]) return; //"flat rectangle"
182 const corner1
= [m
.end
.x
, kp
[1]];
183 const corner2
= [kp
[0], m
.end
.y
];
184 for (let [i
, j
] of [corner1
, corner2
]) {
185 if (this.board
[i
][j
] != V
.EMPTY
&& this.getColor(i
, j
) == oppCol
) {
186 const piece
= this.getPiece(i
, j
);
187 if (!byChameleon
|| piece
== V
.ROOK
) {
203 getPotentialRookMoves(sq
) {
204 let moves
= super.getPotentialQueenMoves(sq
);
205 this.addRookCaptures(moves
);
209 getKnightCaptures(startSquare
, byChameleon
) {
210 // Look in every direction for captures
211 const steps
= V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
]);
212 const color
= this.turn
;
213 const oppCol
= V
.GetOppCol(color
);
215 const [x
, y
] = [startSquare
[0], startSquare
[1]];
216 const piece
= this.getPiece(x
, y
); //might be a chameleon!
217 outerLoop: for (let step
of steps
) {
218 let [i
, j
] = [x
+ step
[0], y
+ step
[1]];
219 while (V
.OnBoard(i
, j
) && this.board
[i
][j
] == V
.EMPTY
) {
225 this.getColor(i
, j
) == color
||
226 (!!byChameleon
&& this.getPiece(i
, j
) != V
.KNIGHT
)
230 // last(thing), cur(thing) : stop if "cur" is our color,
231 // or beyond board limits, or if "last" isn't empty and cur neither.
232 // Otherwise, if cur is empty then add move until cur square;
233 // if cur is occupied then stop if !!byChameleon and the square not
234 // occupied by a leaper.
236 let cur
= [i
+ step
[0], j
+ step
[1]];
237 let vanished
= [new PiPo({ x: x
, y: y
, c: color
, p: piece
})];
238 while (V
.OnBoard(cur
[0], cur
[1])) {
239 if (this.board
[last
[0]][last
[1]] != V
.EMPTY
) {
240 const oppPiece
= this.getPiece(last
[0], last
[1]);
241 if (!!byChameleon
&& oppPiece
!= V
.KNIGHT
) continue outerLoop
;
244 new PiPo({ x: last
[0], y: last
[1], c: oppCol
, p: oppPiece
})
247 if (this.board
[cur
[0]][cur
[1]] != V
.EMPTY
) {
249 this.getColor(cur
[0], cur
[1]) == color
||
250 this.board
[last
[0]][last
[1]] != V
.EMPTY
252 //TODO: redundant test
258 appear: [new PiPo({ x: cur
[0], y: cur
[1], c: color
, p: piece
})],
259 vanish: JSON
.parse(JSON
.stringify(vanished
)), //TODO: required?
260 start: { x: x
, y: y
},
261 end: { x: cur
[0], y: cur
[1] }
265 last
= [last
[0] + step
[0], last
[1] + step
[1]];
266 cur
= [cur
[0] + step
[0], cur
[1] + step
[1]];
273 getPotentialKnightMoves(sq
) {
274 return super.getPotentialQueenMoves(sq
).concat(this.getKnightCaptures(sq
));
278 getPotentialBishopMoves([x
, y
]) {
280 .getPotentialQueenMoves([x
, y
])
281 .concat(this.getKnightCaptures([x
, y
], "asChameleon"));
282 // No "king capture" because king cannot remain under check
283 this.addPawnCaptures(moves
, "asChameleon");
284 this.addRookCaptures(moves
, "asChameleon");
285 this.addQueenCaptures(moves
, "asChameleon");
286 // Post-processing: merge similar moves, concatenating vanish arrays
287 let mergedMoves
= {};
289 const key
= m
.end
.x
+ V
.size
.x
* m
.end
.y
;
290 if (!mergedMoves
[key
]) mergedMoves
[key
] = m
;
292 for (let i
= 1; i
< m
.vanish
.length
; i
++)
293 mergedMoves
[key
].vanish
.push(m
.vanish
[i
]);
296 return Object
.values(mergedMoves
);
299 addQueenCaptures(moves
, byChameleon
) {
300 if (moves
.length
== 0) return;
301 const [x
, y
] = [moves
[0].start
.x
, moves
[0].start
.y
];
302 const adjacentSteps
= V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
]);
303 let capturingDirections
= [];
304 const color
= this.turn
;
305 const oppCol
= V
.GetOppCol(color
);
306 adjacentSteps
.forEach(step
=> {
307 const [i
, j
] = [x
+ step
[0], y
+ step
[1]];
310 this.board
[i
][j
] != V
.EMPTY
&&
311 this.getColor(i
, j
) == oppCol
&&
312 (!byChameleon
|| this.getPiece(i
, j
) == V
.QUEEN
)
314 capturingDirections
.push(step
);
319 m
.end
.x
!= x
? (m
.end
.x
- x
) / Math
.abs(m
.end
.x
- x
) : 0,
320 m
.end
.y
!= y
? (m
.end
.y
- y
) / Math
.abs(m
.end
.y
- y
) : 0
322 // NOTE: includes() and even _.isEqual() functions fail...
323 // TODO: this test should be done only once per direction
325 capturingDirections
.some(dir
=> {
326 return dir
[0] == -step
[0] && dir
[1] == -step
[1];
329 const [i
, j
] = [x
- step
[0], y
- step
[1]];
334 p: this.getPiece(i
, j
),
343 getPotentialQueenMoves(sq
) {
344 let moves
= super.getPotentialQueenMoves(sq
);
345 this.addQueenCaptures(moves
);
349 getPotentialImmobilizerMoves(sq
) {
350 // Immobilizer doesn't capture
351 return super.getPotentialQueenMoves(sq
);
354 // isAttacked() is OK because the immobilizer doesn't take
356 isAttackedByPawn([x
, y
], color
) {
357 // Square (x,y) must be surroundable by two enemy pieces,
358 // and one of them at least should be a pawn (moving).
363 const steps
= V
.steps
[V
.ROOK
];
364 for (let dir
of dirs
) {
365 const [i1
, j1
] = [x
- dir
[0], y
- dir
[1]]; //"before"
366 const [i2
, j2
] = [x
+ dir
[0], y
+ dir
[1]]; //"after"
367 if (V
.OnBoard(i1
, j1
) && V
.OnBoard(i2
, j2
)) {
370 this.board
[i1
][j1
] != V
.EMPTY
&&
371 this.getColor(i1
, j1
) == color
&&
372 this.board
[i2
][j2
] == V
.EMPTY
376 this.board
[i2
][j2
] != V
.EMPTY
&&
377 this.getColor(i2
, j2
) == color
&&
378 this.board
[i1
][j1
] == V
.EMPTY
381 // Search a movable enemy pawn landing on the empty square
382 for (let step
of steps
) {
383 let [ii
, jj
] = this.board
[i1
][j1
] == V
.EMPTY
? [i1
, j1
] : [i2
, j2
];
384 let [i3
, j3
] = [ii
+ step
[0], jj
+ step
[1]];
385 while (V
.OnBoard(i3
, j3
) && this.board
[i3
][j3
] == V
.EMPTY
) {
391 this.getColor(i3
, j3
) == color
&&
392 this.getPiece(i3
, j3
) == V
.PAWN
&&
393 !this.isImmobilized([i3
, j3
])
404 isAttackedByRook([x
, y
], color
) {
405 // King must be on same column or row,
406 // and a rook should be able to reach a capturing square
407 const sameRow
= x
== this.kingPos
[color
][0];
408 const sameColumn
= y
== this.kingPos
[color
][1];
409 if (sameRow
|| sameColumn
) {
410 // Look for the enemy rook (maximum 1)
411 for (let i
= 0; i
< V
.size
.x
; i
++) {
412 for (let j
= 0; j
< V
.size
.y
; j
++) {
414 this.board
[i
][j
] != V
.EMPTY
&&
415 this.getColor(i
, j
) == color
&&
416 this.getPiece(i
, j
) == V
.ROOK
418 if (this.isImmobilized([i
, j
]))
419 // Because only one rook:
421 // Can it reach a capturing square? Easy but quite suboptimal way
422 // (TODO: generate all moves (turn is OK))
423 const moves
= this.getPotentialMovesFrom([i
, j
]);
424 for (let move of moves
) {
426 (sameRow
&& move.end
.y
== y
) ||
427 (sameColumn
&& move.end
.x
== x
)
439 isAttackedByKnight([x
, y
], color
) {
440 // Square (x,y) must be on same line as a knight,
441 // and there must be empty square(s) behind.
442 const steps
= V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
]);
443 outerLoop: for (let step
of steps
) {
444 const [i0
, j0
] = [x
+ step
[0], y
+ step
[1]];
445 if (V
.OnBoard(i0
, j0
) && this.board
[i0
][j0
] == V
.EMPTY
) {
446 // Try in opposite direction:
447 let [i
, j
] = [x
- step
[0], y
- step
[1]];
448 while (V
.OnBoard(i
, j
)) {
449 while (V
.OnBoard(i
, j
) && this.board
[i
][j
] == V
.EMPTY
) {
453 if (V
.OnBoard(i
, j
)) {
454 if (this.getColor(i
, j
) == color
) {
456 this.getPiece(i
, j
) == V
.KNIGHT
&&
457 !this.isImmobilized([i
, j
])
464 // could be captured *if there was an empty space*
465 if (this.board
[i
+ step
[0]][j
+ step
[1]] != V
.EMPTY
)
476 isAttackedByBishop([x
, y
], color
) {
477 // We cheat a little here: since this function is used exclusively for
478 // the king, it's enough to check the immediate surrounding of the square.
479 const adjacentSteps
= V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
]);
480 for (let step
of adjacentSteps
) {
481 const [i
, j
] = [x
+ step
[0], y
+ step
[1]];
484 this.board
[i
][j
] != V
.EMPTY
&&
485 this.getColor(i
, j
) == color
&&
486 this.getPiece(i
, j
) == V
.BISHOP
&&
487 !this.isImmobilized([i
, j
])
495 isAttackedByQueen([x
, y
], color
) {
496 // Square (x,y) must be adjacent to a queen, and the queen must have
497 // some free space in the opposite direction from (x,y)
498 const adjacentSteps
= V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
]);
499 for (let step
of adjacentSteps
) {
500 const sq2
= [x
+ 2 * step
[0], y
+ 2 * step
[1]];
501 if (V
.OnBoard(sq2
[0], sq2
[1]) && this.board
[sq2
[0]][sq2
[1]] == V
.EMPTY
) {
502 const sq1
= [x
+ step
[0], y
+ step
[1]];
504 this.board
[sq1
[0]][sq1
[1]] != V
.EMPTY
&&
505 this.getColor(sq1
[0], sq1
[1]) == color
&&
506 this.getPiece(sq1
[0], sq1
[1]) == V
.QUEEN
&&
507 !this.isImmobilized(sq1
)
516 isAttackedByKing([x
, y
], color
) {
517 const steps
= V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
]);
518 for (let step
of steps
) {
519 let rx
= x
+ step
[0],
523 this.getPiece(rx
, ry
) === V
.KING
&&
524 this.getColor(rx
, ry
) == color
&&
525 !this.isImmobilized([rx
, ry
])
533 static GenRandInitFen(randomness
) {
536 return "rnbkqbnm/pppppppp/8/8/8/8/PPPPPPPP/MNBQKBNR w 0";
538 let pieces
= { w: new Array(8), b: new Array(8) };
539 // Shuffle pieces on first and last rank
540 for (let c
of ["w", "b"]) {
541 if (c
== 'b' && randomness
== 1) {
542 pieces
['b'] = pieces
['w'];
546 // Get random squares for every piece, totally freely
547 let positions
= shuffle(ArrayFun
.range(8));
548 const composition
= ['r', 'n', 'b', 'q', 'k', 'b', 'n', 'm'];
549 for (let i
= 0; i
< 8; i
++) pieces
[c
][positions
[i
]] = composition
[i
];
552 pieces
["b"].join("") +
553 "/pppppppp/8/8/8/8/PPPPPPPP/" +
554 pieces
["w"].join("").toUpperCase() +
559 static get VALUES() {
571 static get SEARCH_DEPTH() {
576 const initialSquare
= V
.CoordsToSquare(move.start
);
577 const finalSquare
= V
.CoordsToSquare(move.end
);
578 let notation
= undefined;
579 if (move.appear
[0].p
== V
.PAWN
) {
580 // Pawn: generally ambiguous short notation, so we use full description
581 notation
= "P" + initialSquare
+ finalSquare
;
582 } else if (move.appear
[0].p
== V
.KING
)
583 notation
= "K" + (move.vanish
.length
> 1 ? "x" : "") + finalSquare
;
584 else notation
= move.appear
[0].p
.toUpperCase() + finalSquare
;
585 // Add a capture mark (not describing what is captured...):
586 if (move.vanish
.length
> 1 && move.appear
[0].p
!= V
.KING
) notation
+= "X";