0b9678613623990eeef03d1e0f17b4f1e8b06c0b
[vchess.git] / client / src / variants / Yote.js
1 import { ChessRules, Move, PiPo } from "@/base_rules";
2 import { randInt } from "@/utils/alea";
3
4 export class YoteRules extends ChessRules {
5
6 static get HasFlags() {
7 return false;
8 }
9
10 static get HasEnpassant() {
11 return false;
12 }
13
14 static get Monochrome() {
15 return true;
16 }
17
18 static get Notoodark() {
19 return true;
20 }
21
22 static get ReverseColors() {
23 return true;
24 }
25
26 static IsGoodFen(fen) {
27 if (!ChessRules.IsGoodFen(fen)) return false;
28 const fenParsed = V.ParseFen(fen);
29 // 3) Check reserves
30 if (
31 !fenParsed.reserve ||
32 !fenParsed.reserve.match(/^([0-9]{1,2},?){2,2}$/)
33 ) {
34 return false;
35 }
36 // 4) Check lastMove
37 if (!fenParsed.lastMove) return false;
38 const lmParts = fenParsed.lastMove.split(",");
39 for (lp of lmParts) {
40 if (lp != "-" && !lp.match(/^([a-f][1-5]){2,2}$/)) return false;
41 }
42 return true;
43 }
44
45 static ParseFen(fen) {
46 const fenParts = fen.split(" ");
47 return Object.assign(
48 ChessRules.ParseFen(fen),
49 {
50 reserve: fenParts[3],
51 lastMove: fenParts[4]
52 }
53 );
54 }
55
56 static GenRandInitFen(randomness) {
57 return "6/6/6/6/6 w 0 12,12 -,-";
58 }
59
60 getFen() {
61 return (
62 super.getFen() + " " +
63 this.getReserveFen() + " " +
64 this.getLastmoveFen()
65 );
66 }
67
68 getFenForRepeat() {
69 return super.getFenForRepeat() + "_" + this.getReserveFen();
70 }
71
72 getReserveFen() {
73 return (
74 (!this.reserve["w"] ? 0 : this.reserve["w"][V.PAWN]) + "," +
75 (!this.reserve["b"] ? 0 : this.reserve["b"][V.PAWN])
76 );
77 }
78
79 getLastmoveFen() {
80 const L = this.lastMove.length;
81 const lm = this.lastMove[L-1];
82 return (
83 (
84 !lm['w']
85 ? '-'
86 : V.CoordsToSquare(lm['w'].start) + V.CoordsToSquare(lm['w'].end)
87 )
88 + "," +
89 (
90 !lm['b']
91 ? '-'
92 : V.CoordsToSquare(lm['b'].start) + V.CoordsToSquare(lm['b'].end)
93 )
94 );
95 }
96
97 setOtherVariables(fen) {
98 const fenParsed = V.ParseFen(fen);
99 const reserve = fenParsed.reserve.split(",").map(x => parseInt(x, 10));
100 this.reserve = {
101 w: { [V.PAWN]: reserve[0] },
102 b: { [V.PAWN]: reserve[1] }
103 };
104 // And last moves (to avoid undoing your last move)
105 const lmParts = fenParsed.lastMove.split(",");
106 this.lastMove = [{ w: null, b: null }];
107 ['w', 'b'].forEach((c, i) => {
108 if (lmParts[i] != '-') {
109 this.lastMove[0][c] = {
110 start: V.SquareToCoords(lmParts[i].substr(0, 2)),
111 end: V.SquareToCoords(lmParts[i].substr(2))
112 };
113 }
114 });
115 // Local stack to know if (current) last move captured something
116 this.captures = [false];
117 }
118
119 static get size() {
120 return { x: 5, y: 6 };
121 }
122
123 static get PIECES() {
124 return [V.PAWN];
125 }
126
127 getColor(i, j) {
128 if (i >= V.size.x) return i == V.size.x ? "w" : "b";
129 return this.board[i][j].charAt(0);
130 }
131
132 getPiece() {
133 return V.PAWN;
134 }
135
136 getPpath(b) {
137 return "Yote/" + b;
138 }
139
140 getReservePpath(index, color) {
141 return "Yote/" + color + V.PAWN;
142 }
143
144 static get RESERVE_PIECES() {
145 return [V.PAWN];
146 }
147
148 canIplay(side, [x, y]) {
149 if (this.turn != side) return false;
150 const L = this.captures.length;
151 if (!this.captures[L-1]) return this.getColor(x, y) == side;
152 return (x < V.size.x && this.getColor(x, y) != side);
153 }
154
155 // TODO: hoverHighlight() would well take an arg "side"...
156 hoverHighlight(x, y) {
157 const L = this.captures.length;
158 if (!this.captures[L-1]) return false;
159 const oppCol = V.GetOppCol(this.turn);
160 return (this.board[x][y] != V.EMPTY && this.getColor(x, y) == oppCol);
161 }
162
163 // TODO: onlyClick() doesn't fulfill exactly its role.
164 // Seems that there is some lag... TOFIX
165 onlyClick([x, y]) {
166 const L = this.captures.length;
167 return (this.captures[L-1] && this.getColor(x, y) != this.turn);
168 }
169
170 // PATCH related to above TO-DO:
171 getPossibleMovesFrom([x, y]) {
172 if (x < V.size.x && this.board[x][y] == V.EMPTY) return [];
173 return super.getPossibleMovesFrom([x, y]);
174 }
175
176 doClick([x, y]) {
177 const L = this.captures.length;
178 if (!this.captures[L-1]) return null;
179 const oppCol = V.GetOppCol(this.turn);
180 if (this.board[x][y] == V.EMPTY || this.getColor(x, y) != oppCol)
181 return null;
182 return new Move({
183 appear: [],
184 vanish: [ new PiPo({ x: x, y: y, c: oppCol, p: V.PAWN }) ],
185 end: { x: x, y: y }
186 });
187 }
188
189 getReserveMoves(x) {
190 const color = this.turn;
191 const L = this.captures.length;
192 if (
193 this.captures[L-1] ||
194 !this.reserve[color] ||
195 this.reserve[color][V.PAWN] == 0
196 ) {
197 return [];
198 }
199 let moves = [];
200 for (let i = 0; i < V.size.x; i++) {
201 for (let j = 0; j < V.size.y; j++) {
202 if (this.board[i][j] == V.EMPTY) {
203 let mv = new Move({
204 appear: [
205 new PiPo({
206 x: i,
207 y: j,
208 c: color,
209 p: V.PAWN
210 })
211 ],
212 vanish: [],
213 start: { x: x, y: 0 }, //a bit artificial...
214 end: { x: i, y: j }
215 });
216 moves.push(mv);
217 }
218 }
219 }
220 return moves;
221 }
222
223 getPotentialMovesFrom([x, y]) {
224 const L = this.captures.length;
225 if (this.captures[L-1]) {
226 if (x >= V.size.x) return [];
227 const mv = this.doClick([x, y]);
228 return (!!mv ? [mv] : []);
229 }
230 if (x >= V.size.x) return this.getReserveMoves([x, y]);
231 return this.getPotentialPawnMoves([x, y]);
232 }
233
234 getPotentialPawnMoves([x, y]) {
235 let moves = [];
236 const color = this.turn;
237 const L = this.lastMove.length;
238 const lm = this.lastMove[L-1];
239 let forbiddenStep = null;
240 if (!!lm[color] && x == lm[color].end.x && y == lm[color].end.y) {
241 forbiddenStep = [
242 lm[color].start.x - lm[color].end.x,
243 lm[color].start.y - lm[color].end.y
244 ];
245 }
246 const oppCol = V.GetOppCol(color);
247 for (let s of V.steps[V.ROOK]) {
248 const [i1, j1] = [x + s[0], y + s[1]];
249 if (V.OnBoard(i1, j1)) {
250 if (this.board[i1][j1] == V.EMPTY) {
251 if (
252 !forbiddenStep ||
253 s[0] != forbiddenStep[0] ||
254 s[1] != forbiddenStep[1]
255 ) {
256 moves.push(super.getBasicMove([x, y], [i1, j1]));
257 }
258 }
259 else if (this.getColor(i1, j1) == oppCol) {
260 const [i2, j2] = [i1 + s[0], j1 + s[1]];
261 if (V.OnBoard(i2, j2) && this.board[i2][j2] == V.EMPTY) {
262 let mv = new Move({
263 appear: [
264 new PiPo({ x: i2, y: j2, c: color, p: V.PAWN })
265 ],
266 vanish: [
267 new PiPo({ x: x, y: y, c: color, p: V.PAWN }),
268 new PiPo({ x: i1, y: j1, c: oppCol, p: V.PAWN })
269 ]
270 });
271 moves.push(mv);
272 }
273 }
274 }
275 }
276 return moves;
277 }
278
279 getAllPotentialMoves() {
280 const L = this.captures.length;
281 const color = (this.captures[L-1] ? V.GetOppCol(this.turn) : this.turn);
282 let potentialMoves = [];
283 for (let i = 0; i < V.size.x; i++) {
284 for (let j = 0; j < V.size.y; j++) {
285 if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) {
286 Array.prototype.push.apply(
287 potentialMoves,
288 this.getPotentialMovesFrom([i, j])
289 );
290 }
291 }
292 }
293 potentialMoves = potentialMoves.concat(
294 this.getReserveMoves(V.size.x + (color == "w" ? 0 : 1)));
295 return potentialMoves;
296 }
297
298 filterValid(moves) {
299 return moves;
300 }
301
302 getCheckSquares() {
303 return [];
304 }
305
306 atLeastOneMove() {
307 if (!super.atLeastOneMove()) {
308 // Search one reserve move
309 const moves =
310 this.getReserveMoves(V.size.x + (this.turn == "w" ? 0 : 1));
311 if (moves.length > 0) return true;
312 return false;
313 }
314 return true;
315 }
316
317 play(move) {
318 const color = this.turn;
319 move.turn = color; //for undo
320 const L = this.lastMove.length;
321 if (color == 'w')
322 this.lastMove.push({ w: null, b: this.lastMove[L-1]['b'] });
323 if (move.appear.length == move.vanish.length) { //== 1
324 // Normal move (non-capturing, non-dropping, non-removal)
325 let lm = this.lastMove[L - (color == 'w' ? 0 : 1)];
326 if (!lm[color]) lm[color] = {};
327 lm[color].start = move.start;
328 lm[color].end = move.end;
329 }
330 const oppCol = V.GetOppCol(color);
331 V.PlayOnBoard(this.board, move);
332 const captureNotEnding = (
333 move.vanish.length == 2 &&
334 this.board.some(b => b.some(cell => cell != "" && cell[0] == oppCol))
335 );
336 this.captures.push(captureNotEnding);
337 // Change turn unless I just captured something,
338 // and an opponent stone can be removed from board.
339 if (!captureNotEnding) {
340 this.turn = oppCol;
341 this.movesCount++;
342 }
343 this.postPlay(move);
344 }
345
346 undo(move) {
347 V.UndoOnBoard(this.board, move);
348 if (this.turn == 'b') this.lastMove.pop();
349 else this.lastMove['b'] = null;
350 this.captures.pop();
351 if (move.turn != this.turn) {
352 this.turn = move.turn;
353 this.movesCount--;
354 }
355 this.postUndo(move);
356 }
357
358 postPlay(move) {
359 if (move.vanish.length == 0) {
360 const color = move.appear[0].c;
361 this.reserve[color][V.PAWN]--;
362 if (this.reserve[color][V.PAWN] == 0) delete this.reserve[color];
363 }
364 }
365
366 postUndo(move) {
367 if (move.vanish.length == 0) {
368 const color = move.appear[0].c;
369 if (!this.reserve[color]) this.reserve[color] = { [V.PAWN]: 0 };
370 this.reserve[color][V.PAWN]++;
371 }
372 }
373
374 getCurrentScore() {
375 if (this.movesCount <= 2) return "*";
376 const color = this.turn;
377 // If no stones on board, or no move available, I lose
378 if (
379 this.board.every(b => {
380 return b.every(cell => {
381 return (cell == "" || cell[0] != color);
382 });
383 })
384 ||
385 !this.atLeastOneMove()
386 ) {
387 return (color == 'w' ? "0-1" : "1-0");
388 }
389 return "*";
390 }
391
392 getComputerMove() {
393 const moves = super.getAllValidMoves();
394 if (moves.length == 0) return null;
395 const color = this.turn;
396 const oppCol = V.GetOppCol(color);
397 // Capture available? If yes, play it
398 const captures = moves.filter(m => m.vanish.length == 2);
399 if (captures.length >= 1) {
400 const m1 = captures[randInt(captures.length)];
401 this.play(m1);
402 const moves2 = super.getAllValidMoves();
403 // Remove a stone which was about to capture one of ours, if possible
404 let candidates = [];
405 for (let m2 of moves2) {
406 const [x, y] = [m2.start.x, m2.start.y];
407 for (let s of V.steps[V.ROOK]) {
408 const [i, j] = [x + 2*s[0], y + 2*s[1]];
409 if (
410 V.OnBoard(i, j) &&
411 this.board[i][j] == V.EMPTY &&
412 this.board[i - s[0], j - s[1]] != V.EMPTY &&
413 this.getColor(i - s[0], j - s[1]) == color
414 ) {
415 candidates.push(m2);
416 break;
417 }
418 }
419 }
420 this.undo(m1);
421 if (candidates.length >= 1)
422 return [m1, candidates[randInt(candidates.length)]];
423 return [m1, moves2[randInt(moves2.length)]];
424 }
425 // Just play a random move, which if possible do not let a capture
426 let candidates = [];
427 for (let m of moves) {
428 this.play(m);
429 const moves2 = super.getAllValidMoves();
430 if (moves2.every(m2 => m2.vanish.length <= 1))
431 candidates.push(m);
432 this.undo(m);
433 }
434 if (candidates.length >= 1) return candidates[randInt(candidates.length)];
435 return moves[randInt(moves.length)];
436 }
437
438 evalPosition() {
439 let evaluation = super.evalPosition();
440 // Add reserves:
441 evaluation += this.reserve["w"][V.PAWN];
442 evaluation -= this.reserve["b"][V.PAWN];
443 return evaluation;
444 }
445
446 getNotation(move) {
447 if (move.vanish.length == 0)
448 // Placement:
449 return "@" + V.CoordsToSquare(move.end);
450 if (move.appear.length == 0)
451 // Removal after capture:
452 return V.CoordsToSquare(move.start) + "X";
453 return (
454 V.CoordsToSquare(move.start) +
455 (move.vanish.length == 2 ? "x" : "") +
456 V.CoordsToSquare(move.end)
457 );
458 }
459
460 };