1 import { ChessRules
} from "@/base_rules";
2 import { randInt
} from "@/utils/alea";
4 export class SynchroneRules
extends ChessRules
{
5 static get CanAnalyze() {
9 static get ShowMoves() {
13 static IsGoodFen(fen
) {
14 if (!ChessRules
.IsGoodFen(fen
)) return false;
15 const fenParsed
= V
.ParseFen(fen
);
19 fenParsed
.turn
== "b" &&
20 // NOTE: do not check really JSON stringified move...
21 (!fenParsed
.whiteMove
|| fenParsed
.whiteMove
== "-")
24 (fenParsed
.turn
== "w" && fenParsed
.whiteMove
!= "-")
31 static IsGoodEnpassant(enpassant
) {
32 const epArray
= enpassant
.split(",");
33 if (![2, 3].includes(epArray
.length
)) return false;
34 epArray
.forEach(epsq
=> {
36 const ep
= V
.SquareToCoords(epsq
);
37 if (isNaN(ep
.x
) || !V
.OnBoard(ep
)) return false;
43 static ParseFen(fen
) {
44 const fenParts
= fen
.split(" ");
46 ChessRules
.ParseFen(fen
),
47 { whiteMove: fenParts
[5] }
51 static GenRandInitFen(randomness
) {
52 return ChessRules
.GenRandInitFen(randomness
).slice(0, -1) + "-,- -";
56 return super.getFen() + " " + this.getWhitemoveFen();
60 return super.getFenForRepeat() + "_" + this.getWhitemoveFen();
63 setOtherVariables(fen
) {
64 const parsedFen
= V
.ParseFen(fen
);
65 this.setFlags(parsedFen
.flags
);
66 const epArray
= parsedFen
.enpassant
.split(",");
68 epArray
.forEach(epsq
=> this.epSquares
.push(this.getEpSquare(epsq
)));
70 // Also init whiteMove
72 parsedFen
.whiteMove
!= "-"
73 ? JSON
.parse(parsedFen
.whiteMove
)
77 // After undo(): no need to re-set INIT_COL_KING
79 this.kingPos
= { w: [-1, -1], b: [-1, -1] };
80 for (let i
= 0; i
< V
.size
.x
; i
++) {
81 for (let j
= 0; j
< V
.size
.y
; j
++) {
82 if (this.getPiece(i
, j
) == V
.KING
)
83 this.kingPos
[this.getColor(i
, j
)] = [i
, j
];
89 const L
= this.epSquares
.length
;
91 const start
= L
- 2 - (this.turn
== 'b' ? 1 : 0);
92 for (let i
=start
; i
< L
; i
++) {
93 if (!this.epSquares
[i
]) res
+= "-,";
94 else res
+= V
.CoordsToSquare(this.epSquares
[i
]) + ",";
96 return res
.slice(0, -1);
100 if (!this.whiteMove
) return "-";
101 return JSON
.stringify({
102 start: this.whiteMove
.start
,
103 end: this.whiteMove
.end
,
104 appear: this.whiteMove
.appear
,
105 vanish: this.whiteMove
.vanish
109 getPossibleMovesFrom([x
, y
]) {
111 this.filterValid(super.getPotentialMovesFrom([x
, y
]))
112 // Augment with potential recaptures:
113 .concat(this.getRecaptures())
117 // Aux function used to find opponent and self captures
118 getCaptures(x
, y
, color
) {
119 const sliderAttack
= (xx
, yy
, allowedSteps
) => {
120 const deltaX
= xx
- x
,
121 absDeltaX
= Math
.abs(deltaX
);
122 const deltaY
= yy
- y
,
123 absDeltaY
= Math
.abs(deltaY
);
124 const step
= [ deltaX
/ absDeltaX
|| 0, deltaY
/ absDeltaY
|| 0 ];
126 // Check that the step is a priori valid:
127 (absDeltaX
!= absDeltaY
&& deltaX
!= 0 && deltaY
!= 0) ||
128 allowedSteps
.every(st
=> st
[0] != step
[0] || st
[1] != step
[1])
132 let sq
= [ x
+ step
[0], y
+ step
[1] ];
133 while (sq
[0] != xx
|| sq
[1] != yy
) {
134 // NOTE: no need to check OnBoard in this special case
135 if (this.board
[sq
[0]][sq
[1]] != V
.EMPTY
) return null;
139 return this.getBasicMove([xx
, yy
], [x
, y
]);
141 // Can I take on the square [x, y] ?
142 // If yes, return the (list of) capturing move(s)
144 for (let i
=0; i
<8; i
++) {
145 for (let j
=0; j
<8; j
++) {
146 if (this.getColor(i
, j
) == color
) {
147 switch (this.getPiece(i
, j
)) {
149 // Pushed pawns move as enemy pawns
150 const shift
= (color
== 'w' ? 1 : -1);
151 if (x
+ shift
== i
&& Math
.abs(y
- j
) == 1)
152 moves
.push(this.getBasicMove([i
, j
], [x
, y
]));
156 const deltaX
= Math
.abs(i
- x
);
157 const deltaY
= Math
.abs(j
- y
);
159 deltaX
+ deltaY
== 3 &&
160 [1, 2].includes(deltaX
) &&
161 [1, 2].includes(deltaY
)
163 moves
.push(this.getBasicMove([i
, j
], [x
, y
]));
168 if (Math
.abs(i
- x
) <= 1 && Math
.abs(j
- y
) <= 1)
169 moves
.push(this.getBasicMove([i
, j
], [x
, y
]));
172 const mv
= sliderAttack(i
, j
, V
.steps
[V
.ROOK
]);
173 if (!!mv
) moves
.push(mv
);
177 const mv
= sliderAttack(i
, j
, V
.steps
[V
.BISHOP
]);
178 if (!!mv
) moves
.push(mv
);
182 const mv
= sliderAttack(
183 i
, j
, V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
]));
184 if (!!mv
) moves
.push(mv
);
191 return this.filterValid(moves
);
195 // 1) Generate all opponent's capturing moves
196 let oppCaptureMoves
= [];
197 const color
= this.turn
;
198 const oppCol
= V
.GetOppCol(color
);
199 for (let i
=0; i
<8; i
++) {
200 for (let j
=0; j
<8; j
++) {
202 this.getColor(i
, j
) == color
&&
203 // Do not consider king captures: self-captures of king are forbidden
204 this.getPiece(i
, j
) != V
.KING
206 Array
.prototype.push
.apply(
208 this.getCaptures(i
, j
, oppCol
)
213 // 2) Play each opponent's capture, and see if back-captures are possible:
214 // Lookup table to quickly decide if a move is already in list:
217 oppCaptureMoves
.forEach(m
=> {
218 // If another opponent capture with same endpoint already processed, skip
219 const mHash
= "m" + m
.end
.x
+ m
.end
.y
;
220 if (!moveSet
[mHash
]) {
221 moveSet
[mHash
] = true;
222 // Just make enemy piece disappear, to clear potential path:
223 const justDisappear
= {
225 vanish: [m
.vanish
[0]]
227 V
.PlayOnBoard(this.board
, justDisappear
);
228 // Can I take on [m.end.x, m.end.y] ? If yes, add to list:
229 this.getCaptures(m
.end
.x
, m
.end
.y
, color
)
230 .forEach(cm
=> moves
.push(cm
));
231 V
.UndoOnBoard(this.board
, justDisappear
);
238 // Return possible moves + potential recaptures
239 return super.getAllValidMoves().concat(this.getRecaptures());
243 if (moves
.length
== 0) return [];
244 // filterValid can be called when it's "not our turn":
245 const color
= moves
[0].vanish
[0].c
;
246 return moves
.filter(m
=> {
247 const piece
= m
.vanish
[0].p
;
248 if (piece
== V
.KING
) {
249 this.kingPos
[color
][0] = m
.appear
[0].x
;
250 this.kingPos
[color
][1] = m
.appear
[0].y
;
252 V
.PlayOnBoard(this.board
, m
);
253 let res
= !this.underCheck(color
);
254 V
.UndoOnBoard(this.board
, m
);
255 if (piece
== V
.KING
) this.kingPos
[color
] = [m
.start
.x
, m
.start
.y
];
260 atLeastOneMove(color
) {
261 const curTurn
= this.turn
;
263 const res
= super.atLeastOneMove();
268 // White and black (partial) moves were played: merge
269 resolveSynchroneMove(move) {
270 const m1
= this.whiteMove
;
272 // For PlayOnBoard (no need for start / end, irrelevant)
280 if ((m1
.end
.x
!= m2
.end
.x
) || (m1
.end
.y
!= m2
.end
.y
)) {
281 // Easy case: two independant moves (which may (self-)capture)
282 smove
.appear
.push(m1
.appear
[0]);
283 smove
.appear
.push(m2
.appear
[0]);
284 // "Captured" pieces may have moved:
285 if (m1
.appear
.length
== 2) {
287 smove
.appear
.push(m1
.appear
[1]);
288 smove
.vanish
.push(m1
.vanish
[1]);
290 m1
.vanish
.length
== 2 &&
292 m1
.vanish
[1].x
!= m2
.start
.x
||
293 m1
.vanish
[1].y
!= m2
.start
.y
296 smove
.vanish
.push(m1
.vanish
[1]);
298 if (m2
.appear
.length
== 2) {
300 smove
.appear
.push(m2
.appear
[1]);
301 smove
.vanish
.push(m2
.vanish
[1]);
303 m2
.vanish
.length
== 2 &&
305 m2
.vanish
[1].x
!= m1
.start
.x
||
306 m2
.vanish
[1].y
!= m1
.start
.y
309 smove
.vanish
.push(m2
.vanish
[1]);
313 if (m1
.vanish
.length
== 1 && m2
.vanish
.length
== 1) {
314 // Easy case: both disappear except if one is a king
315 const p1
= m1
.vanish
[0].p
;
316 const p2
= m2
.vanish
[0].p
;
317 if ([p1
, p2
].includes(V
.KING
)) {
322 c: (p1
== V
.KING
? 'w' : 'b')
326 // One move is a self-capture and the other a normal capture:
327 // only the self-capture appears
328 const selfCaptureMove
=
329 m1
.vanish
[1].c
== m1
.vanish
[0].c
335 p: selfCaptureMove
.appear
[0].p
,
336 c: selfCaptureMove
.vanish
[0].c
341 p: selfCaptureMove
.vanish
[1].p
,
342 c: selfCaptureMove
.vanish
[0].c
350 move.flags
= JSON
.stringify(this.aggregateFlags()); //save flags (for undo)
351 this.epSquares
.push(this.getEpSquare(move));
352 // Do not play on board (would reveal the move...)
353 this.turn
= V
.GetOppCol(this.turn
);
358 updateCastleFlags(move) {
359 const firstRank
= { 'w': V
.size
.x
- 1, 'b': 0 };
360 move.appear
.concat(move.vanish
).forEach(av
=> {
361 for (let c
of ['w', 'b']) {
362 if (av
.x
== firstRank
[c
] && this.castleFlags
[c
].includes(av
.y
)) {
363 const flagIdx
= (av
.y
== this.castleFlags
[c
][0] ? 0 : 1);
364 this.castleFlags
[c
][flagIdx
] = 8;
371 if (this.turn
== 'b') {
372 // NOTE: whiteMove is used read-only, so no need to copy
373 this.whiteMove
= move;
377 // A full turn just ended:
378 const smove
= this.resolveSynchroneMove(move);
379 V
.PlayOnBoard(this.board
, smove
);
380 move.whiteMove
= this.whiteMove
; //for undo
381 this.whiteMove
= null;
383 // Update king position + flags
384 let kingAppear
= { 'w': false, 'b': false };
385 for (let i
=0; i
<smove
.appear
.length
; i
++) {
386 if (smove
.appear
[i
].p
== V
.KING
) {
387 const c
= smove
.appear
[i
].c
;
388 kingAppear
[c
] = true;
389 this.kingPos
[c
][0] = smove
.appear
[i
].x
;
390 this.kingPos
[c
][1] = smove
.appear
[i
].y
;
393 for (let i
=0; i
<smove
.vanish
.length
; i
++) {
394 if (smove
.vanish
[i
].p
== V
.KING
) {
395 const c
= smove
.vanish
[i
].c
;
396 if (!kingAppear
[c
]) {
397 this.kingPos
[c
][0] = -1;
398 this.kingPos
[c
][1] = -1;
403 this.updateCastleFlags(smove
);
408 this.epSquares
.pop();
409 this.disaggregateFlags(JSON
.parse(move.flags
));
410 if (this.turn
== 'w')
411 // Back to the middle of the move
412 V
.UndoOnBoard(this.board
, move.smove
);
413 this.turn
= V
.GetOppCol(this.turn
);
419 if (this.turn
== 'w') {
420 // Reset king positions: scan board
422 // Also reset whiteMove
423 this.whiteMove
= null;
424 } else this.whiteMove
= move.whiteMove
;
427 getCheckSquares(color
) {
429 // kingPos must be reset for appropriate highlighting:
430 var lastMove
= JSON
.parse(JSON
.stringify(this.whiteMove
));
431 this.undo(lastMove
); //will erase whiteMove, thus saved above
434 if (this.kingPos
['w'][0] >= 0 && this.underCheck('w'))
435 res
.push(JSON
.parse(JSON
.stringify(this.kingPos
['w'])));
436 if (this.kingPos
['b'][0] >= 0 && this.underCheck('b'))
437 res
.push(JSON
.parse(JSON
.stringify(this.kingPos
['b'])));
438 if (color
== 'b') this.play(lastMove
);
443 if (this.turn
== 'b')
444 // Turn (white + black) not over yet
446 // Was a king captured?
447 if (this.kingPos
['w'][0] < 0) return "0-1";
448 if (this.kingPos
['b'][0] < 0) return "1-0";
449 const whiteCanMove
= this.atLeastOneMove('w');
450 const blackCanMove
= this.atLeastOneMove('b');
451 if (whiteCanMove
&& blackCanMove
) return "*";
453 const whiteInCheck
= this.underCheck('w');
454 const blackInCheck
= this.underCheck('b');
456 (whiteCanMove
&& !this.underCheck('b')) ||
457 (blackCanMove
&& !this.underCheck('w'))
461 // Checkmate: could be mutual
462 if (!whiteCanMove
&& !blackCanMove
) return "1/2";
463 return (whiteCanMove
? "1-0" : "0-1");
467 const maxeval
= V
.INFINITY
;
468 const color
= this.turn
;
469 let moves
= this.getAllValidMoves();
470 if (moves
.length
== 0)
471 // TODO: this situation should not happen
474 if (Math
.random() < 0.5)
475 // Return a random move
476 return moves
[randInt(moves
.length
)];
478 // Rank moves at depth 1:
479 // try to capture something (not re-capturing)
481 V
.PlayOnBoard(this.board
, m
);
482 m
.eval
= this.evalPosition();
483 V
.UndoOnBoard(this.board
, m
);
485 moves
.sort((a
, b
) => {
486 return (color
== "w" ? 1 : -1) * (b
.eval
- a
.eval
);
488 let candidates
= [0];
489 for (let i
= 1; i
< moves
.length
&& moves
[i
].eval
== moves
[0].eval
; i
++)
491 return moves
[candidates
[randInt(candidates
.length
)]];
495 if (move.appear
.length
== 2 && move.appear
[0].p
== V
.KING
)
497 return move.end
.y
< move.start
.y
? "0-0-0" : "0-0";
498 // Basic system: piece + init + dest square
500 move.vanish
[0].p
.toUpperCase() +
501 V
.CoordsToSquare(move.start
) +
502 V
.CoordsToSquare(move.end
)