'update'
[vchess.git] / client / src / variants / Knightmate2.js
1 import { ChessRules } from "@/base_rules";
2
3 export class Knightmate2Rules extends ChessRules {
4
5 static get HasFlags() {
6 return false;
7 }
8
9 static get COMMONER() {
10 return "c";
11 }
12
13 static get PIECES() {
14 return ChessRules.PIECES.concat([V.COMMONER]);
15 }
16
17 getPpath(b) {
18 return ([V.KING, V.COMMONER].includes(b[1]) ? "Knightmate/" : "") + b;
19 }
20
21 static IsGoodPosition(position) {
22 if (position.length == 0) return false;
23 const rows = position.split("/");
24 if (rows.length != V.size.x) return false;
25 let kings = { "k": 0, "K": 0 };
26 for (let row of rows) {
27 let sumElts = 0;
28 for (let i = 0; i < row.length; i++) {
29 if (['K','k'].includes(row[i])) kings[row[i]]++;
30 if (V.PIECES.includes(row[i].toLowerCase())) sumElts++;
31 else {
32 const num = parseInt(row[i], 10);
33 if (isNaN(num) || num <= 0) return false;
34 sumElts += num;
35 }
36 }
37 if (sumElts != V.size.y) return false;
38 }
39 // 1 or 2 kings should be on board.
40 if (Object.values(kings).some(k => ![1, 2].includes(k))) return false;
41 return true;
42 }
43
44 scanKings() {}
45
46 static GenRandInitFen(options) {
47 return (
48 ChessRules.GenRandInitFen(options)
49 .replace(/k/g, 'c').replace(/K/g, 'C')
50 .replace(/n/g, 'k').replace(/N/g, 'K')
51 );
52 }
53
54 getPotentialMovesFrom([x, y]) {
55 switch (this.getPiece(x, y)) {
56 case V.COMMONER:
57 return this.getPotentialCommonerMoves([x, y]);
58 default:
59 return super.getPotentialMovesFrom([x, y]);
60 }
61 }
62
63 getPotentialCommonerMoves(sq) {
64 return this.getSlideNJumpMoves(
65 sq, V.steps[V.ROOK].concat(V.steps[V.BISHOP]), 1);
66 }
67
68 getPotentialKingMoves(sq) {
69 return super.getPotentialKnightMoves(sq);
70 }
71
72 isAttacked(sq, color) {
73 return (
74 this.isAttackedByCommoner(sq, color) ||
75 this.isAttackedByPawn(sq, color) ||
76 this.isAttackedByRook(sq, color) ||
77 this.isAttackedByBishop(sq, color) ||
78 this.isAttackedByQueen(sq, color) ||
79 this.isAttackedByKing(sq, color)
80 );
81 }
82
83 isAttackedByKing(sq, color) {
84 return this.isAttackedBySlideNJump(
85 sq, color, V.KING, V.steps[V.KNIGHT], 1);
86 }
87
88 isAttackedByCommoner(sq, color) {
89 return this.isAttackedBySlideNJump(
90 sq, color, V.COMMONER, V.steps[V.ROOK].concat(V.steps[V.BISHOP]), 1);
91 }
92
93 postPlay() {}
94 postUndo() {}
95
96 // NOTE: 4 next functions (almost) copy-paste from Spartan Chess
97 getKingsPos(color) {
98 let kings = [];
99 for (let i=0; i<8; i++) {
100 for (let j=0; j<8; j++) {
101 if (
102 this.board[i][j] != V.EMPTY &&
103 this.getColor(i, j) == color &&
104 this.getPiece(i, j) == V.KING
105 ) {
106 kings.push({ x: i, y: j });
107 }
108 }
109 }
110 return kings;
111 }
112
113 getCheckSquares() {
114 const color = this.turn;
115 const oppCol = V.GetOppCol(color);
116 const kings = this.getKingsPos(color);
117 let res = [];
118 for (let i of [0, 1]) {
119 if (
120 kings.length >= i+1 &&
121 this.isAttacked([kings[i].x, kings[i].y], oppCol)
122 ) {
123 res.push([kings[i].x, kings[i].y]);
124 }
125 }
126 return res;
127 }
128
129 filterValid(moves) {
130 if (moves.length == 0) return [];
131 const color = moves[0].vanish[0].c;
132 const oppCol = V.GetOppCol(color);
133 // Check if both kings under attack.
134 // If yes, moves must remove at least one attack.
135 const kings = this.getKingsPos(color);
136 return moves.filter(m => {
137 this.play(m);
138 let attacks = 0;
139 for (let k of kings) {
140 const curKingPos =
141 this.board[k.x][k.y] == V.EMPTY
142 ? [m.appear[0].x, m.appear[0].y] //king moved
143 : [k.x, k.y]
144 if (this.isAttacked(curKingPos, oppCol)) attacks++;
145 else break; //no need to check further
146 }
147 this.undo(m);
148 return (
149 (kings.length == 2 && attacks <= 1) ||
150 (kings.length == 1 && attacks == 0)
151 );
152 });
153 }
154
155 getCurrentScore() {
156 if (super.atLeastOneMove()) return "*";
157 // Count kings on board
158 const color = this.turn;
159 const oppCol = V.GetOppCol(color);
160 const kings = this.getKingsPos(color);
161 if (
162 this.isAttacked([kings[0].x, kings[0].y], oppCol) ||
163 (kings.length == 2 && this.isAttacked([kings[1].x, kings[1].y], oppCol))
164 ) {
165 return (color == 'w' ? "0-1" : "1-0");
166 }
167 return "1/2"; //stalemate
168 }
169
170 static get VALUES() {
171 return {
172 p: 1,
173 r: 5,
174 c: 5, //the commoner is valuable
175 b: 3,
176 q: 9,
177 k: 1000
178 };
179 }
180
181 };