Update Cwda - RR pieces
[vchess.git] / client / src / variants / Cwda.js
CommitLineData
4313762d 1import { ChessRules } from "@/base_rules";
801e2870 2
cee75a57 3export class CwdaRules extends ChessRules {
7e8a7ea1 4
4313762d
BA
5 static get Options() {
6 return {
7 select: ChessRules.Options.select.concat([
8 {
9 label: "Army 1",
10 variable: "army1",
11 defaut: 'C',
12 options: [
13 { label: "Colorbound Clobberers", value: 'C' },
14 { label: "Nutty Knights", value: 'N' },
15 { label: "Remarkable Rookies", value: 'R' },
16 { label: "Fide", value: 'F' }
17 ]
18 },
19 {
20 label: "Army 2",
21 variable: "army2",
22 defaut: 'C',
23 options: [
24 { label: "Colorbound Clobberers", value: 'C' },
25 { label: "Nutty Knights", value: 'N' },
26 { label: "Remarkable Rookies", value: 'R' },
27 { label: "Fide", value: 'F' }
28 ]
29 }
30 ])
31 };
32 }
33
34 static AbbreviateOptions(opts) {
35 return opts["army1"] + opts["army2"];
36 }
37
38 static IsValidOptions(opts) {
39 // Both armies filled, avoid Fide vs Fide
40 return (
41 opts.army1 && opts.army2 &&
42 (opts.army1 != 'F' || opts.army2 != 'F')
801e2870
BA
43 );
44 }
45
46 getPpath(b) {
4313762d
BA
47 return (ChessRules.PIECES.includes(b[1]) ? "" : "Cwda/") + b;
48 }
49
50 static get PiecesMap() {
51 return {
52 // Colorbound Clobberers
53 'C': {
54 'r': 'd',
55 'n': 'w',
56 'b': 'f',
57 'q': 'c',
74afb57d
BA
58 'k': 'k',
59 'p': 'p'
4313762d
BA
60 },
61 // Nutty Knights
62 'N': {
63 'r': 'g',
64 'n': 'i',
65 'b': 't',
66 'q': 'l',
74afb57d
BA
67 'k': 'k', //TODO: e
68 'p': 'p' //TODO: v
4313762d
BA
69 },
70 // Remarkable Rookies
71 'R': {
72 'r': 's',
73 'n': 'y',
74 'b': 'h',
75 'q': 'o',
74afb57d
BA
76 'k': 'a',
77 'p': 'u'
4313762d 78 }
801e2870 79 };
4313762d 80 }
801e2870 81
4313762d
BA
82 static GenRandInitFen(options) {
83 const baseFen = ChessRules.GenRandInitFen(options.randomness);
74afb57d 84 let blackLine = baseFen.substr(0, 8), blackPawns = "pppppppp";
4313762d
BA
85 if (options.army2 != 'F') {
86 blackLine = blackLine.split('')
87 .map(p => V.PiecesMap[options.army2][p]).join('');
74afb57d 88 blackPawns = V.PiecesMap[options.army2]['p'].repeat(8);
4313762d 89 }
74afb57d 90 let whiteLine = baseFen.substr(35, 8), whitePawns = "PPPPPPPP";
4313762d
BA
91 if (options.army1 != 'F') {
92 whiteLine = whiteLine.split('')
93 .map(p => V.PiecesMap[options.army1][p.toLowerCase()])
94 .join('').toUpperCase();
74afb57d 95 whitePawns = V.PiecesMap[options.army1]['p'].toUpperCase().repeat(8);
4313762d 96 }
801e2870 97 return (
74afb57d
BA
98 blackLine + "/" + blackPawns +
99 baseFen.substring(17, 26) +
100 whitePawns + "/" + whiteLine +
4313762d 101 baseFen.substr(43) + " " + options.army1 + options.army2
801e2870
BA
102 );
103 }
104
4313762d
BA
105 setOtherVariables(fen) {
106 super.setOtherVariables(fen);
107 const armies = V.ParseFen(fen).armies;
108 this.army1 = armies.charAt(0);
109 this.army2 = armies.charAt(1);
110 }
111
112 static ParseFen(fen) {
113 return Object.assign(
114 { armies: fen.split(" ")[5] },
115 ChessRules.ParseFen(fen)
116 );
117 }
118
119 static IsGoodFen(fen) {
120 if (!ChessRules.IsGoodFen(fen)) return false;
121 const armies = V.ParseFen(fen).armies;
10cceb25 122 return (!!armies && armies.match(/^[CNRF]{2,2}$/));
4313762d
BA
123 }
124
125 getFen() {
126 return super.getFen() + " " + this.army1 + this.army2;
127 }
128
801e2870
BA
129 static get C_ROOK() {
130 return 'd';
131 }
132 static get C_KNIGHT() {
4313762d 133 return 'w';
801e2870
BA
134 }
135 static get C_BISHOP() {
4313762d 136 return 'f';
801e2870
BA
137 }
138 static get C_QUEEN() {
4313762d
BA
139 return 'c';
140 }
141 static get N_ROOK() {
142 return 'g';
143 }
144 static get N_KNIGHT() {
145 return 'i';
146 }
147 static get N_BISHOP() {
148 return 't';
149 }
150 static get N_QUEEN() {
151 return 'l';
152 }
74afb57d
BA
153 static get N_KING() {
154 return 'e';
155 }
156 static get N_PAWN() {
157 return 'v';
158 }
4313762d 159 static get R_ROOK() {
801e2870
BA
160 return 's';
161 }
4313762d
BA
162 static get R_KNIGHT() {
163 return 'y';
164 }
165 static get R_BISHOP() {
166 return 'h';
167 }
168 static get R_QUEEN() {
169 return 'o';
170 }
74afb57d
BA
171 static get R_KING() {
172 return 'a';
173 }
174 static get R_PAWN() {
175 return 'u';
176 }
177
178 getPiece(x, y) {
179 const p = this.board[x][y][1];
180 if (['u', 'v'].includes(p)) return 'p';
181 if (['a', 'e'].includes(p)) return 'k';
182 return p;
183 }
801e2870
BA
184
185 static get PIECES() {
4313762d 186 return ChessRules.PIECES.concat(
74afb57d
BA
187 [
188 V.C_ROOK, V.C_KNIGHT, V.C_BISHOP, V.C_QUEEN,
189 V.N_ROOK, V.N_KNIGHT, V.N_BISHOP, V.N_QUEEN, V.N_KING, V.N_PAWN,
190 V.R_ROOK, V.R_KNIGHT, V.R_BISHOP, V.R_QUEEN, V.R_KING, V.R_PAWN
191 ]
192 );
801e2870
BA
193 }
194
4313762d
BA
195 getPotentialMovesFrom(sq) {
196 switch (this.getPiece(sq[0], sq[1])) {
197 case V.C_ROOK: return this.getPotentialC_rookMoves(sq);
198 case V.C_KNIGHT: return this.getPotentialC_knightMoves(sq);
199 case V.C_BISHOP: return this.getPotentialC_bishopMoves(sq);
200 case V.C_QUEEN: return this.getPotentialC_queenMoves(sq);
201 case V.N_ROOK: return this.getPotentialN_rookMoves(sq);
202 case V.N_KNIGHT: return this.getPotentialN_knightMoves(sq);
203 case V.N_BISHOP: return this.getPotentialN_bishopMoves(sq);
204 case V.N_QUEEN: return this.getPotentialN_queenMoves(sq);
205 case V.R_ROOK: return this.getPotentialR_rookMoves(sq);
206 case V.R_KNIGHT: return this.getPotentialR_knightMoves(sq);
207 case V.R_BISHOP: return this.getPotentialR_bishopMoves(sq);
208 case V.R_QUEEN: return this.getPotentialR_queenMoves(sq);
209 case V.PAWN: {
210 // Can promote in anything from the two current armies
211 let promotions = [];
212 for (let army of ["army1", "army2"]) {
213 if (army == "army2" && this.army2 == this.army1) break;
214 switch (this[army]) {
215 case 'C': {
216 Array.prototype.push.apply(promotions,
217 [V.C_ROOK, V.C_KNIGHT, V.C_BISHOP, V.C_QUEEN]);
218 break;
219 }
220 case 'N': {
221 Array.prototype.push.apply(promotions,
222 [V.N_ROOK, V.N_KNIGHT, V.N_BISHOP, V.N_QUEEN]);
223 break;
224 }
225 case 'R': {
226 Array.prototype.push.apply(promotions,
227 [V.R_ROOK, V.R_KNIGHT, V.R_BISHOP, V.R_QUEEN]);
228 break;
229 }
230 case 'F': {
231 Array.prototype.push.apply(promotions,
232 [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]);
233 break;
234 }
235 }
236 }
237 return super.getPotentialPawnMoves(sq, promotions);
238 }
239 default: return super.getPotentialMovesFrom(sq);
801e2870
BA
240 }
241 return [];
242 }
243
244 static get steps() {
245 return Object.assign(
801e2870
BA
246 {
247 // Dabbabah
248 'd': [
249 [-2, 0],
250 [0, -2],
251 [2, 0],
252 [0, 2]
253 ],
254 // Alfil
255 'a': [
256 [2, 2],
257 [2, -2],
258 [-2, 2],
259 [-2, -2]
260 ],
261 // Ferz
262 'f': [
263 [1, 1],
264 [1, -1],
265 [-1, 1],
266 [-1, -1]
4313762d
BA
267 ],
268 // Wazir
269 'w': [
270 [-1, 0],
271 [0, -1],
272 [1, 0],
273 [0, 1]
274 ],
275 // Threeleaper
276 '$3': [
277 [-3, 0],
278 [0, -3],
279 [3, 0],
280 [0, 3]
281 ],
282 // Narrow knight
283 '$n': [
284 [-2, -1],
285 [-2, 1],
286 [2, -1],
287 [2, 1]
801e2870 288 ]
4313762d
BA
289 },
290 ChessRules.steps,
801e2870
BA
291 );
292 }
293
294 getPotentialC_rookMoves(sq) {
295 return (
4313762d
BA
296 this.getSlideNJumpMoves(sq, V.steps.b).concat(
297 this.getSlideNJumpMoves(sq, V.steps.d, 1))
801e2870
BA
298 );
299 }
300
301 getPotentialC_knightMoves(sq) {
302 return (
4313762d
BA
303 this.getSlideNJumpMoves(sq, V.steps.a, 1).concat(
304 this.getSlideNJumpMoves(sq, V.steps.r, 1))
801e2870
BA
305 );
306 }
307
308 getPotentialC_bishopMoves(sq) {
309 return (
4313762d
BA
310 this.getSlideNJumpMoves(sq, V.steps.d, 1).concat(
311 this.getSlideNJumpMoves(sq, V.steps.a, 1)).concat(
312 this.getSlideNJumpMoves(sq, V.steps.b, 1))
801e2870
BA
313 );
314 }
315
316 getPotentialC_queenMoves(sq) {
317 return (
4313762d
BA
318 this.getSlideNJumpMoves(sq, V.steps.b).concat(
319 this.getSlideNJumpMoves(sq, V.steps.n, 1))
320 );
321 }
322
323 getPotentialN_rookMoves(sq) {
324 const c = this.turn;
325 const rookSteps = [ [0, -1], [0, 1], [c == 'w' ? -1 : 1, 0] ];
326 const backward = (c == 'w' ? 1 : -1);
327 const kingSteps = [ [backward, -1], [backward, 0], [backward, 1] ];
328 return (
329 this.getSlideNJumpMoves(sq, rookSteps).concat(
330 this.getSlideNJumpMoves(sq, kingSteps, 1))
331 );
332 }
333
334 getPotentialN_knightMoves(sq) {
4313762d
BA
335 return (
336 this.getSlideNJumpMoves(sq, V.steps.$n, 1).concat(
902378e6 337 this.getSlideNJumpMoves(sq, V.steps.f, 1))
4313762d
BA
338 );
339 }
340
341 getPotentialN_bishopMoves(sq) {
342 const backward = (this.turn == 'w' ? 1 : -1);
343 const kingSteps = [
344 [0, -1], [0, 1], [backward, -1], [backward, 0], [backward, 1]
345 ];
346 const forward = -backward;
347 const knightSteps = [
348 [2*forward, -1], [2*forward, 1], [forward, -2], [forward, 2]
349 ];
350 return (
351 this.getSlideNJumpMoves(sq, knightSteps, 1).concat(
352 this.getSlideNJumpMoves(sq, kingSteps, 1))
353 );
354 }
355
356 getPotentialN_queenMoves(sq) {
357 const backward = (this.turn == 'w' ? 1 : -1);
358 const forward = -backward;
359 const kingSteps = [
360 [forward, -1], [forward, 1],
361 [backward, -1], [backward, 0], [backward, 1]
362 ];
363 const knightSteps = [
364 [2*forward, -1], [2*forward, 1], [forward, -2], [forward, 2]
365 ];
366 const rookSteps = [ [0, -1], [0, 1], [forward, 0] ];
367 return (
368 this.getSlideNJumpMoves(sq, rookSteps).concat(
369 this.getSlideNJumpMoves(sq, kingSteps, 1)).concat(
370 this.getSlideNJumpMoves(sq, knightSteps, 1))
371 );
372 }
373
374 getPotentialR_rookMoves(sq) {
375 return this.getSlideNJumpMoves(sq, V.steps.r, 4);
376 }
377
378 getPotentialR_knightMoves(sq) {
379 return (
380 this.getSlideNJumpMoves(sq, V.steps.d, 1).concat(
381 this.getSlideNJumpMoves(sq, V.steps.w, 1))
382 );
383 }
384
385 getPotentialR_bishopMoves(sq) {
386 return (
387 this.getSlideNJumpMoves(sq, V.steps.d, 1).concat(
388 this.getSlideNJumpMoves(sq, V.steps.f, 1)).concat(
389 this.getSlideNJumpMoves(sq, V.steps.$3, 1))
390 );
391 }
392
393 getPotentialR_queenMoves(sq) {
394 return (
395 this.getSlideNJumpMoves(sq, V.steps.r).concat(
396 this.getSlideNJumpMoves(sq, V.steps.n, 1))
801e2870
BA
397 );
398 }
399
801e2870 400 getCastleMoves([x, y]) {
7e8a7ea1 401 const color = this.getColor(x, y);
4313762d
BA
402 let finalSquares = [ [2, 3], [V.size.y - 2, V.size.y - 3] ];
403 if (
404 (color == 'w' && this.army1 == 'C') ||
405 (color == 'b' && this.army2 == 'C')
406 ) {
407 // Colorbound castle long in an unusual way:
408 finalSquares[0] = [1, 2];
409 }
7e8a7ea1 410 return super.getCastleMoves([x, y], finalSquares);
801e2870
BA
411 }
412
413 isAttacked(sq, color) {
4313762d
BA
414 if (super.isAttackedByPawn(sq, color) || super.isAttackedByKing(sq, color))
415 return true;
416 for (let army of ['C', 'N', 'R', 'F']) {
417 if (
418 [this.army1, this.army2].includes(army) &&
419 (
420 this["isAttackedBy" + army + "_rook"](sq, color) ||
421 this["isAttackedBy" + army + "_knight"](sq, color) ||
422 this["isAttackedBy" + army + "_bishop"](sq, color) ||
423 this["isAttackedBy" + army + "_queen"](sq, color)
424 )
425 ) {
426 return true;
427 }
428 }
429 return false;
801e2870
BA
430 }
431
432 isAttackedByC_rook(sq, color) {
433 return (
4313762d
BA
434 this.isAttackedBySlideNJump(sq, color, V.C_ROOK, V.steps.b) ||
435 this.isAttackedBySlideNJump(sq, color, V.C_ROOK, V.steps.d, 1)
801e2870
BA
436 );
437 }
438
439 isAttackedByC_knight(sq, color) {
440 return (
4313762d
BA
441 this.isAttackedBySlideNJump(sq, color, V.C_KNIGHT, V.steps.r, 1) ||
442 this.isAttackedBySlideNJump(sq, color, V.C_KNIGHT, V.steps.a, 1)
801e2870
BA
443 );
444 }
445
446 isAttackedByC_bishop(sq, color) {
447 return (
4313762d
BA
448 this.isAttackedBySlideNJump(sq, color, V.C_BISHOP, V.steps.d, 1) ||
449 this.isAttackedBySlideNJump(sq, color, V.C_BISHOP, V.steps.a, 1) ||
450 this.isAttackedBySlideNJump(sq, color, V.C_BISHOP, V.steps.f, 1)
801e2870
BA
451 );
452 }
453
454 isAttackedByC_queen(sq, color) {
455 return (
4313762d
BA
456 this.isAttackedBySlideNJump(sq, color, V.C_QUEEN, V.steps.b) ||
457 this.isAttackedBySlideNJump(sq, color, V.C_QUEEN, V.steps.n, 1)
458 );
459 }
460
461 isAttackedByN_rook(sq, color) {
462 const rookSteps = [ [0, -1], [0, 1], [color == 'w' ? 1 : -1, 0] ];
463 const backward = (color == 'w' ? -1 : 1);
464 const kingSteps = [ [backward, -1], [backward, 0], [backward, 1] ];
465 return (
466 this.isAttackedBySlideNJump(sq, color, V.N_ROOK, rookSteps) ||
467 this.isAttackedBySlideNJump(sq, color, V.N_ROOK, kingSteps, 1)
468 );
469 }
470
471 isAttackedByN_knight(sq, color) {
4313762d 472 return (
902378e6
BA
473 this.isAttackedBySlideNJump(sq, color, V.N_KNIGHT, V.steps.$n, 1) ||
474 this.isAttackedBySlideNJump(sq, color, V.N_KNIGHT, V.steps.f, 1)
4313762d
BA
475 );
476 }
477
478 isAttackedByN_bishop(sq, color) {
479 const backward = (color == 'w' ? -1 : 1);
480 const kingSteps = [
481 [0, -1], [0, 1], [backward, -1], [backward, 0], [backward, 1]
482 ];
483 const forward = -backward;
484 const knightSteps = [
485 [2*forward, -1], [2*forward, 1], [forward, -2], [forward, 2]
486 ];
487 return (
488 this.isAttackedBySlideNJump(sq, color, V.N_BISHOP, knightSteps, 1) ||
489 this.isAttackedBySlideNJump(sq, color, V.N_BISHOP, kingSteps, 1)
490 );
491 }
492
493 isAttackedByN_queen(sq, color) {
494 const backward = (color == 'w' ? -1 : 1);
495 const forward = -backward;
496 const kingSteps = [
497 [forward, -1], [forward, 1],
498 [backward, -1], [backward, 0], [backward, 1]
499 ];
500 const knightSteps = [
501 [2*forward, -1], [2*forward, 1], [forward, -2], [forward, 2]
502 ];
503 const rookSteps = [ [0, -1], [0, 1], [forward, 0] ];
504 return (
505 this.isAttackedBySlideNJump(sq, color, V.N_QUEEN, knightSteps, 1) ||
506 this.isAttackedBySlideNJump(sq, color, V.N_QUEEN, kingSteps, 1) ||
507 this.isAttackedBySlideNJump(sq, color, V.N_QUEEN, rookSteps)
508 );
509 }
510
511 isAttackedByR_rook(sq, color) {
512 return this.isAttackedBySlideNJump(sq, color, V.R_ROOK, V.steps.r, 4);
513 }
514
515 isAttackedByR_knight(sq, color) {
516 return (
517 this.isAttackedBySlideNJump(sq, color, V.R_KNIGHT, V.steps.d, 1) ||
518 this.isAttackedBySlideNJump(sq, color, V.R_KNIGHT, V.steps.w, 1)
519 );
520 }
521
522 isAttackedByR_bishop(sq, color) {
523 return (
524 this.isAttackedBySlideNJump(sq, color, V.R_BISHOP, V.steps.d, 1) ||
525 this.isAttackedBySlideNJump(sq, color, V.R_BISHOP, V.steps.f, 1) ||
526 this.isAttackedBySlideNJump(sq, color, V.R_BISHOP, V.steps.$3, 1)
527 );
528 }
529
530 isAttackedByR_queen(sq, color) {
531 return (
532 this.isAttackedBySlideNJump(sq, color, V.R_QUEEN, V.steps.r) ||
533 this.isAttackedBySlideNJump(sq, color, V.R_QUEEN, V.steps.n, 1)
801e2870
BA
534 );
535 }
536
b2f43cc3
BA
537 // [HACK] So that the function above works also on Fide army:
538 isAttackedByF_rook(sq, color) {
539 return super.isAttackedByRook(sq, color);
540 }
541 isAttackedByF_knight(sq, color) {
542 return super.isAttackedByKnight(sq, color);
543 }
544 isAttackedByF_bishop(sq, color) {
545 return super.isAttackedByBishop(sq, color);
546 }
547 isAttackedByF_queen(sq, color) {
548 return super.isAttackedByQueen(sq, color);
549 }
550
801e2870
BA
551 static get VALUES() {
552 return Object.assign(
801e2870
BA
553 {
554 d: 4,
4313762d
BA
555 w: 3,
556 f: 5,
557 c: 7,
558 g: 4,
559 i: 3,
560 t: 4,
561 l: 7,
562 s: 4,
563 y: 3,
564 h: 4,
565 o: 8
566 },
567 ChessRules.VALUES
801e2870
BA
568 );
569 }
48252022
BA
570
571 static get SEARCH_DEPTH() {
572 return 2;
573 }
7e8a7ea1 574
801e2870 575};