Attempt to fix SYnchrone2 getCurrentScore()
[vchess.git] / client / src / variants / Fusion.js
1 import { ChessRules, Move, PiPo } from "@/base_rules";
2
3 export class FusionRules extends ChessRules {
4
5 static get PawnSpecs() {
6 return (
7 Object.assign(
8 { promotions: [V.ROOK, V.KNIGHT, V.BISHOP] },
9 ChessRules.PawnSpecs
10 )
11 );
12 }
13
14 static IsGoodPosition(position) {
15 if (position.length == 0) return false;
16 const rows = position.split("/");
17 if (rows.length != V.size.x) return false;
18 let kings = { "k": 0, "K": 0 };
19 for (let row of rows) {
20 let sumElts = 0;
21 for (let i = 0; i < row.length; i++) {
22 if (['K', 'F', 'G', 'C'].includes(row[i])) kings['K']++;
23 else if (['k', 'f', 'g', 'c'].includes(row[i])) kings['k']++;
24 if (V.PIECES.includes(row[i].toLowerCase())) sumElts++;
25 else {
26 const num = parseInt(row[i], 10);
27 if (isNaN(num) || num <= 0) return false;
28 sumElts += num;
29 }
30 }
31 if (sumElts != V.size.y) return false;
32 }
33 if (Object.values(kings).some(v => v != 1)) return false;
34 return true;
35 }
36
37 scanKings(fen) {
38 this.kingPos = { w: [-1, -1], b: [-1, -1] };
39 const fenRows = V.ParseFen(fen).position.split("/");
40 for (let i = 0; i < fenRows.length; i++) {
41 let k = 0;
42 for (let j = 0; j < fenRows[i].length; j++) {
43 const ch_ij = fenRows[i].charAt(j);
44 if (['k', 'f', 'g', 'c'].includes(ch_ij))
45 this.kingPos["b"] = [i, k];
46 else if (['K', 'F', 'G', 'C'].includes(ch_ij))
47 this.kingPos["w"] = [i, k];
48 else {
49 const num = parseInt(fenRows[i].charAt(j), 10);
50 if (!isNaN(num)) k += num - 1;
51 }
52 k++;
53 }
54 }
55 }
56
57 canTake([x1, y1], [x2, y2]) {
58 if (this.getColor(x1, y1) !== this.getColor(x2, y2)) return true;
59 const p1 = this.getPiece(x1, y1);
60 const p2 = this.getPiece(x2, y2);
61 return (
62 p1 != p2 &&
63 [V.ROOK, V.KNIGHT, V.BISHOP].includes(p1) &&
64 [V.KING, V.ROOK, V.KNIGHT, V.BISHOP].includes(p2)
65 );
66 }
67
68 getPpath(b) {
69 if ([V.BN, V.RN, V.KB, V.KR, V.KN].includes(b[1])) return "Fusion/" + b;
70 return b;
71 }
72
73 // Three new pieces: rook+knight, bishop+knight and queen+knight
74 static get RN() {
75 // Marshall
76 return 'm';
77 }
78 static get BN() {
79 // Paladin
80 return 'd';
81 }
82 static get KB() {
83 // Pontiff
84 return 'f';
85 }
86 static get KR() {
87 // Dragon King
88 return 'g';
89 }
90 static get KN() {
91 // Cavalier King
92 return 'c';
93 }
94
95 static get PIECES() {
96 return ChessRules.PIECES.concat([V.RN, V.BN, V.KB, V.KR, V.KN]);
97 }
98
99 static Fusion(p1, p2) {
100 if (p2 == V.KING) {
101 switch (p1) {
102 case V.ROOK: return V.KR;
103 case V.BISHOP: return V.KB;
104 case V.KNIGHT: return V.KN;
105 }
106 }
107 if ([p1, p2].includes(V.KNIGHT)) {
108 if ([p1, p2].includes(V.ROOK)) return V.RN;
109 return V.BN;
110 }
111 // Only remaining combination is rook + bishop = queen
112 return V.QUEEN;
113 }
114
115 getPotentialMovesFrom(sq) {
116 let moves = [];
117 const piece = this.getPiece(sq[0], sq[1]);
118 switch (piece) {
119 case V.RN:
120 moves =
121 super.getPotentialRookMoves(sq).concat(
122 super.getPotentialKnightMoves(sq)).concat(
123 this.getFissionMoves(sq));
124 break;
125 case V.BN:
126 moves =
127 super.getPotentialBishopMoves(sq).concat(
128 super.getPotentialKnightMoves(sq)).concat(
129 this.getFissionMoves(sq));
130 break;
131 case V.KN:
132 moves =
133 super.getPotentialKingMoves(sq).concat(
134 this.getPotentialKingAsKnightMoves(sq)).concat(
135 this.getFissionMoves(sq));
136 break;
137 case V.KB:
138 moves =
139 super.getPotentialKingMoves(sq).concat(
140 this.getPotentialKingAsBishopMoves(sq)).concat(
141 this.getFissionMoves(sq));
142 break;
143 case V.KR:
144 moves =
145 super.getPotentialKingMoves(sq).concat(
146 this.getPotentialKingAsRookMoves(sq)).concat(
147 this.getFissionMoves(sq));
148 break;
149 case V.QUEEN:
150 moves =
151 super.getPotentialQueenMoves(sq).concat(this.getFissionMoves(sq));
152 break;
153 default:
154 moves = super.getPotentialMovesFrom(sq);
155 break;
156 }
157 moves.forEach(m => {
158 if (
159 m.vanish.length == 2 &&
160 m.appear.length == 1 &&
161 m.vanish[0].c == m.vanish[1].c
162 ) {
163 // Augment pieces abilities in case of self-captures
164 m.appear[0].p = V.Fusion(piece, m.vanish[1].p);
165 }
166 });
167 return moves;
168 }
169
170 getSlideNJumpMoves_fission([x, y], moving, staying, steps, oneStep) {
171 let moves = [];
172 const c = this.getColor(x, y);
173 outerLoop: for (let step of steps) {
174 let i = x + step[0];
175 let j = y + step[1];
176 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
177 moves.push(
178 new Move({
179 appear: [
180 new PiPo({ x: i, y: j, c: c, p: moving }),
181 new PiPo({ x: x, y: y, c: c, p: staying }),
182 ],
183 vanish: [
184 new PiPo({ x: x, y: y, c: c, p: this.getPiece(x, y) })
185 ]
186 })
187 );
188 if (!!oneStep) continue outerLoop;
189 i += step[0];
190 j += step[1];
191 }
192 }
193 return moves;
194 }
195
196 getFissionMoves(sq) {
197 // Square attacked by opponent?
198 const color = this.getColor(sq[0], sq[1]);
199 const oppCol = V.GetOppCol(color);
200 if (this.isAttacked(sq, oppCol)) return [];
201 // Ok, fission a priori valid
202 const kSteps = V.steps[V.BISHOP].concat(V.steps[V.BISHOP]);
203 switch (this.getPiece(sq[0], sq[1])) {
204 case V.BN:
205 return (
206 this.getSlideNJumpMoves_fission(
207 sq, V.BISHOP, V.KNIGHT, V.steps[V.BISHOP])
208 .concat(this.getSlideNJumpMoves_fission(
209 sq, V.KNIGHT, V.BISHOP, V.steps[V.KNIGHT], "oneStep"))
210 );
211 case V.RN:
212 return (
213 this.getSlideNJumpMoves_fission(
214 sq, V.ROOK, V.KNIGHT, V.steps[V.ROOK])
215 .concat(this.getSlideNJumpMoves_fission(
216 sq, V.KNIGHT, V.ROOK, V.steps[V.KNIGHT], "oneStep"))
217 );
218 case V.KN:
219 return (
220 this.getSlideNJumpMoves_fission(sq, V.KING, V.KNIGHT, kSteps)
221 .concat(this.getSlideNJumpMoves_fission(
222 sq, V.KNIGHT, V.KING, V.steps[V.KNIGHT], "oneStep"))
223 );
224 case V.KB:
225 return (
226 this.getSlideNJumpMoves_fission(sq, V.KING, V.BISHOP, kSteps)
227 .concat(this.getSlideNJumpMoves_fission(
228 sq, V.BISHOP, V.KING, V.steps[V.BISHOP]))
229 );
230 case V.KR:
231 return (
232 this.getSlideNJumpMoves_fission(sq, V.KING, V.ROOK, kSteps)
233 .concat(this.getSlideNJumpMoves_fission(
234 sq, V.ROOK, V.KING, V.steps[V.ROOK]))
235 );
236 case V.QUEEN:
237 return (
238 this.getSlideNJumpMoves_fission(
239 sq, V.BISHOP, V.ROOK, V.steps[V.BISHOP])
240 .concat(this.getSlideNJumpMoves_fission(
241 sq, V.ROOK, V.BISHOP, V.steps[V.ROOK]))
242 );
243 }
244 }
245
246 intermediateSquaresFromKnightStep(step) {
247 if (step[0] == 2) return [ [1, 0], [1, step[1]] ];
248 if (step[0] == -2) return [ [-1, 0], [-1, step[1]] ];
249 if (step[1] == 2) return [ [0, 1], [step[1], 1] ];
250 // step[1] == -2:
251 return [ [0, -1], [step[1], -1] ];
252 }
253
254 getPotentialKingAsKnightMoves([x, y]) {
255 const oppCol = V.GetOppCol(this.turn);
256 let moves = [];
257 let intermediateOk = {};
258 for (let s of V.steps[V.KNIGHT]) {
259 const [i, j] = [x + s[0], y + s[1]];
260 if (!V.OnBoard(i, j) || this.board[i][j] != V.EMPTY) continue;
261 const iSq = this.intermediateSquaresFromKnightStep(s);
262 let moveOk = false;
263 for (let sq of iSq) {
264 const key = sq[0] + "_" + sq[1];
265 if (Object.keys(intermediateOk).includes(key)) {
266 if (intermediateOk[key]) moveOk = true;
267 }
268 else {
269 moveOk = !this.isAttacked([x + sq[0], y + sq[1]], oppCol);
270 intermediateOk[key] = moveOk;
271 }
272 if (moveOk) break;
273 }
274 if (moveOk) moves.push(this.getBasicMove([x, y], [i, j]));
275 }
276 return moves;
277 }
278
279 getPotentialKingMovesAsSlider([x, y], slider) {
280 const oppCol = V.GetOppCol(this.turn);
281 let moves = [];
282 for (let s of V.steps[slider]) {
283 let [i, j] = [x + s[0], y + s[1]];
284 if (
285 !V.OnBoard(i, j) ||
286 this.board[i][j] != V.EMPTY ||
287 this.isAttacked([i, j], oppCol)
288 ) {
289 continue;
290 }
291 i += s[0];
292 j += s[1];
293 while (
294 V.OnBoard(i, j) &&
295 this.board[i][j] == V.EMPTY &&
296 // TODO: this test will be done twice (also in filterValid())
297 !this.isAttacked([i, j], oppCol)
298 ) {
299 moves.push(this.getBasicMove([x, y], [i, j]));
300 i += s[0];
301 j += s[1];
302 }
303 }
304 return moves;
305 }
306
307 getPotentialKingAsBishopMoves(sq) {
308 return this.getPotentialKingMovesAsSlider(sq, V.BISHOP);
309 }
310
311 getPotentialKingAsRookMoves(sq) {
312 return this.getPotentialKingMovesAsSlider(sq, V.ROOK);
313 }
314
315 isAttacked(sq, color) {
316 return (
317 super.isAttacked(sq, color) ||
318 this.isAttackedByBN(sq, color) ||
319 this.isAttackedByRN(sq, color) ||
320 this.isAttackedByKN(sq, color) ||
321 this.isAttackedByKB(sq, color) ||
322 this.isAttackedByKR(sq, color)
323 );
324 }
325
326 isAttackedByBN(sq, color) {
327 return (
328 this.isAttackedBySlideNJump(sq, color, V.BN, V.steps[V.BISHOP]) ||
329 this.isAttackedBySlideNJump(
330 sq, color, V.BN, V.steps[V.KNIGHT], "oneStep")
331 );
332 }
333
334 isAttackedByRN(sq, color) {
335 return (
336 this.isAttackedBySlideNJump(sq, color, V.RN, V.steps[V.ROOK]) ||
337 this.isAttackedBySlideNJump(
338 sq, color, V.RN, V.steps[V.KNIGHT], "oneStep")
339 );
340 }
341
342 isAttackedByKN(sq, color) {
343 const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
344 return (
345 this.isAttackedBySlideNJump(sq, color, V.KN, steps, "oneStep") ||
346 this.isAttackedBySlideNJump(
347 sq, color, V.KN, V.steps[V.KNIGHT], "oneStep")
348 );
349 }
350
351 isAttackedByKB(sq, color) {
352 const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
353 return (
354 this.isAttackedBySlideNJump(sq, color, V.KB, steps, "oneStep") ||
355 this.isAttackedBySlideNJump(sq, color, V.KB, V.steps[V.BISHOP])
356 );
357 }
358
359 isAttackedByKR(sq, color) {
360 const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
361 return (
362 this.isAttackedBySlideNJump(sq, color, V.KR, steps, "oneStep") ||
363 this.isAttackedBySlideNJump(sq, color, V.KR, V.steps[V.ROOK])
364 );
365 }
366
367 updateCastleFlags(move, piece) {
368 const c = V.GetOppCol(this.turn);
369 const firstRank = (c == "w" ? V.size.x - 1 : 0);
370 const oppCol = this.turn;
371 const oppFirstRank = V.size.x - 1 - firstRank;
372 if (piece == V.KING)
373 this.castleFlags[c] = [V.size.y, V.size.y];
374 else if (
375 move.start.x == firstRank && //our rook moves?
376 this.castleFlags[c].includes(move.start.y)
377 ) {
378 const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1);
379 this.castleFlags[c][flagIdx] = V.size.y;
380 }
381 // Check move endpoint: if my king or any rook position, flags off
382 if (move.end.x == this.kingPos[c][0] && move.end.y == this.kingPos[c][1])
383 this.castleFlags[c] = [V.size.y, V.size.y];
384 else if (
385 move.end.x == firstRank &&
386 this.castleFlags[c].includes(move.end.y)
387 ) {
388 const flagIdx = (move.end.y == this.castleFlags[c][0] ? 0 : 1);
389 this.castleFlags[c][flagIdx] = V.size.y;
390 }
391 else if (
392 move.end.x == oppFirstRank &&
393 this.castleFlags[oppCol].includes(move.end.y)
394 ) {
395 const flagIdx = (move.end.y == this.castleFlags[oppCol][0] ? 0 : 1);
396 this.castleFlags[oppCol][flagIdx] = V.size.y;
397 }
398 }
399
400 postPlay(move) {
401 const c = V.GetOppCol(this.turn);
402 move.kingMove = (
403 [V.KING, V.KN, V.KB, V.KR].includes(move.appear[0].p) &&
404 [V.KING, V.KN, V.KB, V.KR].includes(move.vanish[0].p)
405 );
406 if (move.kingMove) this.kingPos[c] = [move.appear[0].x, move.appear[0].y];
407 this.updateCastleFlags(move, move.appear[0].p);
408 }
409
410 postUndo(move) {
411 const c = this.getColor(move.start.x, move.start.y);
412 if (!!move.kingMove) this.kingPos[c] = [move.start.x, move.start.y];
413 }
414
415 static get VALUES() {
416 // Values such that sum of values = value of sum
417 return Object.assign(
418 { m: 8, d: 6, f: 1003, g: 1005, c: 1003 },
419 ChessRules.VALUES
420 );
421 }
422
423 static get SEARCH_DEPTH() {
424 return 2;
425 }
426
427 getNotation(move) {
428 if (move.appear.length == 2 && move.vanish.length == 1) {
429 // Fission (because no capture in this case)
430 return (
431 move.appear[0].p.toUpperCase() + V.CoordsToSquare(move.end) +
432 "/f:" + move.appear[1].p.toUpperCase() + V.CoordsToSquare(move.start)
433 );
434 }
435 let notation = super.getNotation(move);
436 if (move.vanish[0].p != V.PAWN && move.appear[0].p != move.vanish[0].p)
437 // Fusion (not from a pawn: handled in ChessRules)
438 notation += "=" + move.appear[0].p.toUpperCase();
439 return notation;
440 }
441
442 };