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