Fixes
[vchess.git] / client / src / variants / Dark.js
1 import { ChessRules } from "@/base_rules";
2 import { ArrayFun } from "@/utils/array";
3 import { randInt } from "@/utils/alea";
4
5 export const VariantRules = class DarkRules extends ChessRules {
6 // Analyse in Dark mode makes no sense
7 static get CanAnalyze() {
8 return false;
9 }
10
11 // Moves are revealed only when game ends
12 static get ShowMoves() {
13 return "none";
14 }
15
16 setOtherVariables(fen) {
17 super.setOtherVariables(fen);
18 const [sizeX, sizeY] = [V.size.x, V.size.y];
19 this.enlightened = {
20 w: ArrayFun.init(sizeX, sizeY),
21 b: ArrayFun.init(sizeX, sizeY)
22 };
23 // Setup enlightened: squares reachable by each side
24 // (TODO: one side would be enough ?)
25 this.updateEnlightened();
26 }
27
28 updateEnlightened() {
29 for (let i = 0; i < V.size.x; i++) {
30 for (let j = 0; j < V.size.y; j++) {
31 this.enlightened["w"][i][j] = false;
32 this.enlightened["b"][i][j] = false;
33 }
34 }
35 const pawnShift = { w: -1, b: 1 };
36 // Initialize with pieces positions (which are seen)
37 for (let i = 0; i < V.size.x; i++) {
38 for (let j = 0; j < V.size.y; j++) {
39 if (this.board[i][j] != V.EMPTY) {
40 const color = this.getColor(i, j);
41 this.enlightened[color][i][j] = true;
42 // Add potential squares visible by "impossible pawn capture"
43 if (this.getPiece(i, j) == V.PAWN) {
44 for (let shiftY of [-1, 1]) {
45 if (
46 V.OnBoard(i + pawnShift[color], j + shiftY) &&
47 this.board[i + pawnShift[color]][j + shiftY] == V.EMPTY
48 ) {
49 this.enlightened[color][i + pawnShift[color]][
50 j + shiftY
51 ] = true;
52 }
53 }
54 }
55 }
56 }
57 }
58 const currentTurn = this.turn;
59 this.turn = "w";
60 const movesWhite = this.getAllValidMoves();
61 this.turn = "b";
62 const movesBlack = this.getAllValidMoves();
63 this.turn = currentTurn;
64 for (let move of movesWhite)
65 this.enlightened["w"][move.end.x][move.end.y] = true;
66 for (let move of movesBlack)
67 this.enlightened["b"][move.end.x][move.end.y] = true;
68 }
69
70 // Has to be redefined to avoid an infinite loop
71 getAllValidMoves() {
72 const color = this.turn;
73 let potentialMoves = [];
74 for (let i = 0; i < V.size.x; i++) {
75 for (let j = 0; j < V.size.y; j++) {
76 if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color)
77 Array.prototype.push.apply(
78 potentialMoves,
79 this.getPotentialMovesFrom([i, j])
80 );
81 }
82 }
83 return potentialMoves; //because there are no checks
84 }
85
86 atLeastOneMove() {
87 if (this.kingPos[this.turn][0] < 0) return false;
88 return true; //TODO: is it right?
89 }
90
91 underCheck() {
92 return false; //there is no check
93 }
94
95 getCheckSquares() {
96 return [];
97 }
98
99 updateVariables(move) {
100 super.updateVariables(move);
101 if (move.vanish.length >= 2 && move.vanish[1].p == V.KING) {
102 // We took opponent king ! (because if castle vanish[1] is a rook)
103 this.kingPos[this.turn] = [-1, -1];
104 }
105
106 // Update lights for both colors:
107 this.updateEnlightened();
108 }
109
110 unupdateVariables(move) {
111 super.unupdateVariables(move);
112 const c = move.vanish[0].c;
113 const oppCol = V.GetOppCol(c);
114 if (this.kingPos[oppCol][0] < 0) {
115 // Last move took opponent's king
116 for (let psq of move.vanish) {
117 if (psq.p == "k") {
118 this.kingPos[oppCol] = [psq.x, psq.y];
119 break;
120 }
121 }
122 }
123
124 // Update lights for both colors:
125 this.updateEnlightened();
126 }
127
128 getCurrentScore() {
129 const color = this.turn;
130 const kp = this.kingPos[color];
131 if (kp[0] < 0)
132 //king disappeared
133 return color == "w" ? "0-1" : "1-0";
134 if (this.atLeastOneMove())
135 // game not over
136 return "*";
137 return "1/2"; //no moves but kings still there (seems impossible)
138 }
139
140 static get THRESHOLD_MATE() {
141 return 500; //checkmates evals may be slightly below 1000
142 }
143
144 // In this special situation, we just look 1 half move ahead
145 getComputerMove() {
146 const maxeval = V.INFINITY;
147 const color = this.turn;
148 const oppCol = V.GetOppCol(color);
149 const pawnShift = color == "w" ? -1 : 1;
150
151 // Do not cheat: the current enlightment is all we can see
152 const myLight = JSON.parse(JSON.stringify(this.enlightened[color]));
153
154 // Can a slider on (i,j) apparently take my king?
155 // NOTE: inaccurate because assume yes if some squares are shadowed
156 const sliderTake = ([i, j], piece) => {
157 const kp = this.kingPos[color];
158 let step = undefined;
159 if (piece == V.BISHOP) {
160 if (Math.abs(kp[0] - i) == Math.abs(kp[1] - j)) {
161 step = [
162 (i - kp[0]) / Math.abs(i - kp[0]),
163 (j - kp[1]) / Math.abs(j - kp[1])
164 ];
165 }
166 } else if (piece == V.ROOK) {
167 if (kp[0] == i) step = [0, (j - kp[1]) / Math.abs(j - kp[1])];
168 else if (kp[1] == j) step = [(i - kp[0]) / Math.abs(i - kp[0]), 0];
169 }
170 if (!step) return false;
171 // Check for obstacles
172 let obstacle = false;
173 for (
174 let x = kp[0] + step[0], y = kp[1] + step[1];
175 x != i && y != j;
176 x += step[0], y += step[1]
177 ) {
178 if (myLight[x][y] && this.board[x][y] != V.EMPTY) {
179 obstacle = true;
180 break;
181 }
182 }
183 if (!obstacle) return true;
184 return false;
185 };
186
187 // Do I see something which can take my king ?
188 const kingThreats = () => {
189 const kp = this.kingPos[color];
190 for (let i = 0; i < V.size.x; i++) {
191 for (let j = 0; j < V.size.y; j++) {
192 if (
193 myLight[i][j] &&
194 this.board[i][j] != V.EMPTY &&
195 this.getColor(i, j) != color
196 ) {
197 switch (this.getPiece(i, j)) {
198 case V.PAWN:
199 if (kp[0] + pawnShift == i && Math.abs(kp[1] - j) == 1)
200 return true;
201 break;
202 case V.KNIGHT:
203 if (
204 (Math.abs(kp[0] - i) == 2 && Math.abs(kp[1] - j) == 1) ||
205 (Math.abs(kp[0] - i) == 1 && Math.abs(kp[1] - j) == 2)
206 ) {
207 return true;
208 }
209 break;
210 case V.KING:
211 if (Math.abs(kp[0] - i) == 1 && Math.abs(kp[1] - j) == 1)
212 return true;
213 break;
214 case V.BISHOP:
215 if (sliderTake([i, j], V.BISHOP)) return true;
216 break;
217 case V.ROOK:
218 if (sliderTake([i, j], V.ROOK)) return true;
219 break;
220 case V.QUEEN:
221 if (sliderTake([i, j], V.BISHOP) || sliderTake([i, j], V.ROOK))
222 return true;
223 break;
224 }
225 }
226 }
227 }
228 return false;
229 };
230
231 let moves = this.getAllValidMoves();
232 for (let move of moves) {
233 this.play(move);
234 if (this.kingPos[oppCol][0] >= 0 && kingThreats()) {
235 // We didn't take opponent king, and our king will be captured: bad
236 move.eval = -maxeval;
237 }
238 this.undo(move);
239
240 if (move.eval) continue;
241
242 move.eval = 0; //a priori...
243
244 // Can I take something ? If yes, do it if it seems good...
245 if (move.vanish.length == 2 && move.vanish[1].c != color) {
246 //avoid castle
247 const myPieceVal = V.VALUES[move.appear[0].p];
248 const hisPieceVal = V.VALUES[move.vanish[1].p];
249 if (myPieceVal <= hisPieceVal) move.eval = hisPieceVal - myPieceVal + 2;
250 //favor captures
251 else {
252 // Taking a pawn with minor piece,
253 // or minor piece or pawn with a rook,
254 // or anything but a queen with a queen,
255 // or anything with a king.
256 // ==> Do it at random, although
257 // this is clearly inferior to what a human can deduce...
258 move.eval = Math.random() < 0.5 ? 1 : -1;
259 }
260 }
261 }
262
263 // TODO: also need to implement the case when an opponent piece (in light)
264 // is threatening something - maybe not the king, but e.g. pawn takes rook.
265
266 moves.sort((a, b) => b.eval - a.eval);
267 let candidates = [0];
268 for (let j = 1; j < moves.length && moves[j].eval == moves[0].eval; j++)
269 candidates.push(j);
270 return moves[candidates[randInt(candidates.length)]];
271 }
272 };