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
== "w" &&
20 // NOTE: do not check really JSON stringified move...
21 (!fenParsed
.whiteMove
|| fenParsed
.whiteMove
== "-")
24 (fenParsed
.turn
== "b" && 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 // NOTE: lazy unefficient implementation (for now. TODO?)
110 getPossibleMovesFrom([x
, y
]) {
111 const moves
= this.getAllValidMoves();
112 return moves
.filter(m
=> {
113 return m
.start
.x
== x
&& m
.start
.y
== y
;
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 const color
= this.turn
;
196 // 0) Generate our possible moves
197 let myMoves
= super.getAllValidMoves();
198 // 1) Generate all opponent's capturing moves
199 let oppCaptureMoves
= [];
200 const oppCol
= V
.GetOppCol(color
);
201 for (let i
=0; i
<8; i
++) {
202 for (let j
=0; j
<8; j
++) {
204 this.getColor(i
, j
) == color
&&
205 // Do not consider king captures: self-captures of king are forbidden
206 this.getPiece(i
, j
) != V
.KING
208 Array
.prototype.push
.apply(
210 this.getCaptures(i
, j
, oppCol
)
215 // 2) Play each opponent's capture, and see if back-captures are possible:
216 // Lookup table to quickly decide if a move is already in list:
218 oppCaptureMoves
.forEach(m
=> {
219 // If another opponent capture with same endpoint already processed, skip:
220 const mHash
= "m" + m
.end
.x
+ m
.end
.y
;
221 if (!moveSet
[mHash
]) {
222 moveSet
[mHash
] = true;
223 // Just make enemy piece disappear, to clear potential path:
224 const justDisappear
= {
226 vanish: [m
.vanish
[0]]
228 V
.PlayOnBoard(this.board
, justDisappear
);
229 // Can I take on [m.end.x, m.end.y] ? If yes, add to list:
230 this.getCaptures(m
.end
.x
, m
.end
.y
, color
).forEach(cm
=> myMoves
.push(cm
));
231 V
.UndoOnBoard(this.board
, justDisappear
);
238 if (moves
.length
== 0) return [];
239 // filterValid can be called when it's "not our turn":
240 const color
= moves
[0].vanish
[0].c
;
241 return moves
.filter(m
=> {
242 const piece
= m
.vanish
[0].p
;
243 if (piece
== V
.KING
) {
244 this.kingPos
[color
][0] = m
.appear
[0].x
;
245 this.kingPos
[color
][1] = m
.appear
[0].y
;
247 V
.PlayOnBoard(this.board
, m
);
248 let res
= !this.underCheck(color
);
249 V
.UndoOnBoard(this.board
, m
);
250 if (piece
== V
.KING
) this.kingPos
[color
] = [m
.start
.x
, m
.start
.y
];
255 atLeastOneMove(color
) {
256 const curTurn
= this.turn
;
258 const res
= super.atLeastOneMove();
263 // White and black (partial) moves were played: merge
264 resolveSynchroneMove(move) {
265 const m1
= this.whiteMove
;
267 // For PlayOnBoard (no need for start / end, irrelevant)
275 if ((m1
.end
.x
!= m2
.end
.x
) || (m1
.end
.y
!= m2
.end
.y
)) {
276 // Easy case: two independant moves (which may (self-)capture)
277 smove
.appear
.push(m1
.appear
[0]);
278 smove
.appear
.push(m2
.appear
[0]);
279 // "Captured" pieces may have moved:
280 if (m1
.appear
.length
== 2) {
282 smove
.appear
.push(m1
.appear
[1]);
283 smove
.vanish
.push(m1
.vanish
[1]);
285 m1
.vanish
.length
== 2 &&
287 m1
.vanish
[1].x
!= m2
.start
.x
||
288 m1
.vanish
[1].y
!= m2
.start
.y
291 smove
.vanish
.push(m1
.vanish
[1]);
293 if (m2
.appear
.length
== 2) {
295 smove
.appear
.push(m2
.appear
[1]);
296 smove
.vanish
.push(m2
.vanish
[1]);
298 m2
.vanish
.length
== 2 &&
300 m2
.vanish
[1].x
!= m1
.start
.x
||
301 m2
.vanish
[1].y
!= m1
.start
.y
304 smove
.vanish
.push(m2
.vanish
[1]);
308 if (m1
.vanish
.length
== 1 && m2
.vanish
.length
== 1) {
309 // Easy case: both disappear except if one is a king
310 const p1
= m1
.vanish
[0].p
;
311 const p2
= m2
.vanish
[0].p
;
312 if ([p1
, p2
].includes(V
.KING
)) {
317 c: (p1
== V
.KING
? 'w' : 'b')
321 // One move is a self-capture and the other a normal capture:
322 // only the self-capture appears
323 const selfCaptureMove
=
324 m1
.vanish
[1].c
== m1
.vanish
[0].c
330 p: selfCaptureMove
.appear
[0].p
,
331 c: selfCaptureMove
.vanish
[0].c
336 p: selfCaptureMove
.vanish
[1].p
,
337 c: selfCaptureMove
.vanish
[0].c
345 move.flags
= JSON
.stringify(this.aggregateFlags()); //save flags (for undo)
346 this.epSquares
.push(this.getEpSquare(move));
347 // Do not play on board (would reveal the move...)
348 this.turn
= V
.GetOppCol(this.turn
);
353 updateCastleFlags(move) {
354 const firstRank
= { 'w': V
.size
.x
- 1, 'b': 0 };
355 move.appear
.concat(move.vanish
).forEach(av
=> {
356 for (let c
of ['w', 'b']) {
357 if (av
.x
== firstRank
[c
] && this.castleFlags
[c
].includes(av
.y
)) {
358 const flagIdx
= (av
.y
== this.castleFlags
[c
][0] ? 0 : 1);
359 this.castleFlags
[c
][flagIdx
] = 8;
366 if (this.turn
== 'b') {
367 // NOTE: whiteMove is used read-only, so no need to copy
368 this.whiteMove
= move;
372 // A full turn just ended:
373 const smove
= this.resolveSynchroneMove(move);
374 V
.PlayOnBoard(this.board
, smove
);
375 move.whiteMove
= this.whiteMove
; //for undo
376 this.whiteMove
= null;
378 // Update king position + flags
379 let kingAppear
= { 'w': false, 'b': false };
380 for (let i
=0; i
<smove
.appear
.length
; i
++) {
381 if (smove
.appear
[i
].p
== V
.KING
) {
382 const c
= smove
.appear
[i
].c
;
383 kingAppear
[c
] = true;
384 this.kingPos
[c
][0] = smove
.appear
[i
].x
;
385 this.kingPos
[c
][1] = smove
.appear
[i
].y
;
388 for (let i
=0; i
<smove
.vanish
.length
; i
++) {
389 if (smove
.vanish
[i
].p
== V
.KING
) {
390 const c
= smove
.vanish
[i
].c
;
391 if (!kingAppear
[c
]) {
392 this.kingPos
[c
][0] = -1;
393 this.kingPos
[c
][1] = -1;
398 this.updateCastleFlags(smove
);
403 this.epSquares
.pop();
404 this.disaggregateFlags(JSON
.parse(move.flags
));
405 if (this.turn
== 'w')
406 // Back to the middle of the move
407 V
.UndoOnBoard(this.board
, move.smove
);
408 this.turn
= V
.GetOppCol(this.turn
);
414 if (this.turn
== 'w') {
415 // Reset king positions: scan board
417 // Also reset whiteMove
418 this.whiteMove
= null;
419 } else this.whiteMove
= move.whiteMove
;
422 getCheckSquares(color
) {
424 // kingPos must be reset for appropriate highlighting:
425 var lastMove
= JSON
.parse(JSON
.stringify(this.whiteMove
));
426 this.undo(lastMove
); //will erase whiteMove, thus saved above
429 if (this.underCheck('w'))
430 res
.push(JSON
.parse(JSON
.stringify(this.kingPos
['w'])));
431 if (this.underCheck('b'))
432 res
.push(JSON
.parse(JSON
.stringify(this.kingPos
['b'])));
433 if (color
== 'b') this.play(lastMove
);
438 if (this.turn
== 'b')
439 // Turn (white + black) not over yet
441 // Was a king captured?
442 if (this.kingPos
['w'][0] < 0) return "0-1";
443 if (this.kingPos
['b'][0] < 0) return "1-0";
444 const whiteCanMove
= this.atLeastOneMove('w');
445 const blackCanMove
= this.atLeastOneMove('b');
446 if (whiteCanMove
&& blackCanMove
) return "*";
448 const whiteInCheck
= this.underCheck('w');
449 const blackInCheck
= this.underCheck('b');
451 (whiteCanMove
&& !this.underCheck('b')) ||
452 (blackCanMove
&& !this.underCheck('w'))
456 // Checkmate: could be mutual
457 if (!whiteCanMove
&& !blackCanMove
) return "1/2";
458 return (whiteCanMove
? "1-0" : "0-1");
462 const maxeval
= V
.INFINITY
;
463 const color
= this.turn
;
464 let moves
= this.getAllValidMoves();
465 if (moves
.length
== 0)
466 // TODO: this situation should not happen
469 if (Math
.random() < 0.5)
470 // Return a random move
471 return moves
[randInt(moves
.length
)];
473 // Rank moves at depth 1:
474 // try to capture something (not re-capturing)
476 V
.PlayOnBoard(this.board
, m
);
477 m
.eval
= this.evalPosition();
478 V
.UndoOnBoard(this.board
, m
);
480 moves
.sort((a
, b
) => {
481 return (color
== "w" ? 1 : -1) * (b
.eval
- a
.eval
);
483 let candidates
= [0];
484 for (let i
= 1; i
< moves
.length
&& moves
[i
].eval
== moves
[0].eval
; i
++)
486 return moves
[candidates
[randInt(candidates
.length
)]];
490 if (move.appear
.length
== 2 && move.appear
[0].p
== V
.KING
)
492 return move.end
.y
< move.start
.y
? "0-0-0" : "0-0";
493 // Basic system: piece + init + dest square
495 move.vanish
[0].p
.toUpperCase() +
496 V
.CoordsToSquare(move.start
) +
497 V
.CoordsToSquare(move.end
)