First draft of Emergo - still buggish. Fix Fanorona, avoid underscore in FEN and...
[vchess.git] / client / src / variants / Fanorona.js
1 import { ChessRules, Move, PiPo } from "@/base_rules";
2 import { randInt } from "@/utils/alea";
3
4 export class FanoronaRules 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 Lines() {
19 let lines = [];
20 // Draw all inter-squares lines, shifted:
21 for (let i = 0; i < V.size.x; i++)
22 lines.push([[i+0.5, 0.5], [i+0.5, V.size.y-0.5]]);
23 for (let j = 0; j < V.size.y; j++)
24 lines.push([[0.5, j+0.5], [V.size.x-0.5, j+0.5]]);
25 const columnDiags = [
26 [[0.5, 0.5], [2.5, 2.5]],
27 [[0.5, 2.5], [2.5, 0.5]],
28 [[2.5, 0.5], [4.5, 2.5]],
29 [[4.5, 0.5], [2.5, 2.5]]
30 ];
31 for (let j of [0, 2, 4, 6]) {
32 lines = lines.concat(
33 columnDiags.map(L => [[L[0][0], L[0][1] + j], [L[1][0], L[1][1] + j]])
34 );
35 }
36 return lines;
37 }
38
39 static get Notoodark() {
40 return true;
41 }
42
43 static GenRandInitFen() {
44 return "ppppppppp/ppppppppp/pPpP1pPpP/PPPPPPPPP/PPPPPPPPP w 0";
45 }
46
47 setOtherVariables(fen) {
48 // Local stack of captures during a turn (squares + directions)
49 this.captures = [ [] ];
50 }
51
52 static get size() {
53 return { x: 5, y: 9 };
54 }
55
56 getPiece() {
57 return V.PAWN;
58 }
59
60 static IsGoodPosition(position) {
61 if (position.length == 0) return false;
62 const rows = position.split("/");
63 if (rows.length != V.size.x) return false;
64 for (let row of rows) {
65 let sumElts = 0;
66 for (let i = 0; i < row.length; i++) {
67 if (row[i].toLowerCase() == V.PAWN) sumElts++;
68 else {
69 const num = parseInt(row[i], 10);
70 if (isNaN(num) || num <= 0) return false;
71 sumElts += num;
72 }
73 }
74 if (sumElts != V.size.y) return false;
75 }
76 return true;
77 }
78
79 getPpath(b) {
80 return "Fanorona/" + b;
81 }
82
83 getPPpath(m) {
84 // m.vanish.length >= 2, first capture gives direction
85 const ref = (Math.abs(m.vanish[1].x - m.start.x) == 1 ? m.start : m.end);
86 const step = [m.vanish[1].x - ref.x, m.vanish[1].y - ref.y];
87 const normalizedStep = [
88 step[0] / Math.abs(step[0]),
89 step[1] / Math.abs(step[1])
90 ];
91 return (
92 "Fanorona/arrow_" +
93 (normalizedStep[0] || 0) + "_" + (normalizedStep[1] || 0)
94 );
95 }
96
97 // After moving, add stones captured in "step" direction from new location
98 // [x, y] to mv.vanish (if any captured stone!)
99 addCapture([x, y], step, move) {
100 let [i, j] = [x + step[0], y + step[1]];
101 const oppCol = V.GetOppCol(move.vanish[0].c);
102 while (
103 V.OnBoard(i, j) &&
104 this.board[i][j] != V.EMPTY &&
105 this.getColor(i, j) == oppCol
106 ) {
107 move.vanish.push(new PiPo({ x: i, y: j, c: oppCol, p: V.PAWN }));
108 i += step[0];
109 j += step[1];
110 }
111 return (move.vanish.length >= 2);
112 }
113
114 getPotentialMovesFrom([x, y]) {
115 const L0 = this.captures.length;
116 const captures = this.captures[L0 - 1];
117 const L = captures.length;
118 if (L > 0) {
119 var c = captures[L-1];
120 if (x != c.square.x + c.step[0] || y != c.square.y + c.step[1])
121 return [];
122 }
123 const oppCol = V.GetOppCol(this.turn);
124 let steps = V.steps[V.ROOK];
125 if ((x + y) % 2 == 0) steps = steps.concat(V.steps[V.BISHOP]);
126 let moves = [];
127 for (let s of steps) {
128 if (L > 0 && c.step[0] == s[0] && c.step[1] == s[1]) {
129 // Add a move to say "I'm done capturing"
130 moves.push(
131 new Move({
132 appear: [],
133 vanish: [],
134 start: { x: x, y: y },
135 end: { x: x - s[0], y: y - s[1] }
136 })
137 );
138 continue;
139 }
140 let [i, j] = [x + s[0], y + s[1]];
141 if (captures.some(c => c.square.x == i && c.square.y == j)) continue;
142 if (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
143 // The move is potentially allowed. Might lead to 2 different captures
144 let mv = super.getBasicMove([x, y], [i, j]);
145 const capt = this.addCapture([i, j], s, mv);
146 if (capt) {
147 moves.push(mv);
148 mv = super.getBasicMove([x, y], [i, j]);
149 }
150 const capt_bw = this.addCapture([x, y], [-s[0], -s[1]], mv);
151 if (capt_bw) moves.push(mv);
152 // Captures take priority (if available)
153 if (!capt && !capt_bw && L == 0) moves.push(mv);
154 }
155 }
156 return moves;
157 }
158
159 atLeastOneCapture() {
160 const color = this.turn;
161 const oppCol = V.GetOppCol(color);
162 const L0 = this.captures.length;
163 const captures = this.captures[L0 - 1];
164 const L = captures.length;
165 if (L > 0) {
166 // If some adjacent enemy stone, with free space to capture it,
167 // toward a square not already visited, through a different step
168 // from last one: then yes.
169 const c = captures[L-1];
170 const [x, y] = [c.square.x + c.step[0], c.square.y + c.step[1]];
171 let steps = V.steps[V.ROOK];
172 if ((x + y) % 2 == 0) steps = steps.concat(V.steps[V.BISHOP]);
173 // TODO: half of the steps explored are redundant
174 for (let s of steps) {
175 if (s[0] == c.step[0] && s[1] == c.step[1]) continue;
176 const [i, j] = [x + s[0], y + s[1]];
177 if (
178 !V.OnBoard(i, j) ||
179 this.board[i][j] != V.EMPTY ||
180 captures.some(c => c.square.x == i && c.square.y == j)
181 ) {
182 continue;
183 }
184 if (
185 V.OnBoard(i + s[0], j + s[1]) &&
186 this.board[i + s[0]][j + s[1]] != V.EMPTY &&
187 this.getColor(i + s[0], j + s[1]) == oppCol
188 ) {
189 return true;
190 }
191 if (
192 V.OnBoard(x - s[0], y - s[1]) &&
193 this.board[x - s[0]][y - s[1]] != V.EMPTY &&
194 this.getColor(x - s[0], y - s[1]) == oppCol
195 ) {
196 return true;
197 }
198 }
199 return false;
200 }
201 for (let i = 0; i < V.size.x; i++) {
202 for (let j = 0; j < V.size.y; j++) {
203 if (
204 this.board[i][j] != V.EMPTY &&
205 this.getColor(i, j) == color &&
206 // TODO: this could be more efficient
207 this.getPotentialMovesFrom([i, j]).some(m => m.vanish.length >= 2)
208 ) {
209 return true;
210 }
211 }
212 }
213 return false;
214 }
215
216 static KeepCaptures(moves) {
217 return moves.filter(m => m.vanish.length >= 2);
218 }
219
220 getPossibleMovesFrom(sq) {
221 let moves = this.getPotentialMovesFrom(sq);
222 const L0 = this.captures.length;
223 const captures = this.captures[L0 - 1];
224 if (captures.length > 0) return this.getPotentialMovesFrom(sq);
225 const captureMoves = V.KeepCaptures(moves);
226 if (captureMoves.length > 0) return captureMoves;
227 if (this.atLeastOneCapture()) return [];
228 return moves;
229 }
230
231 getAllValidMoves() {
232 const moves = super.getAllValidMoves();
233 if (moves.some(m => m.vanish.length >= 2)) return V.KeepCaptures(moves);
234 return moves;
235 }
236
237 filterValid(moves) {
238 return moves;
239 }
240
241 getCheckSquares() {
242 return [];
243 }
244
245 play(move) {
246 const color = this.turn;
247 move.turn = color; //for undo
248 V.PlayOnBoard(this.board, move);
249 if (move.vanish.length >= 2) {
250 const L0 = this.captures.length;
251 let captures = this.captures[L0 - 1];
252 captures.push({
253 square: move.start,
254 step: [move.end.x - move.start.x, move.end.y - move.start.y]
255 });
256 if (this.atLeastOneCapture())
257 // There could be other captures (optional)
258 move.notTheEnd = true;
259 }
260 if (!move.notTheEnd) {
261 this.turn = V.GetOppCol(color);
262 this.movesCount++;
263 this.captures.push([]);
264 }
265 }
266
267 undo(move) {
268 V.UndoOnBoard(this.board, move);
269 if (!move.notTheEnd) {
270 this.turn = move.turn;
271 this.movesCount--;
272 this.captures.pop();
273 }
274 if (move.vanish.length >= 2) {
275 const L0 = this.captures.length;
276 let captures = this.captures[L0 - 1];
277 captures.pop();
278 }
279 }
280
281 getCurrentScore() {
282 const color = this.turn;
283 // If no stones on board, I lose
284 if (
285 this.board.every(b => {
286 return b.every(cell => {
287 return (cell == "" || cell[0] != color);
288 });
289 })
290 ) {
291 return (color == 'w' ? "0-1" : "1-0");
292 }
293 return "*";
294 }
295
296 getComputerMove() {
297 const moves = this.getAllValidMoves();
298 if (moves.length == 0) return null;
299 const color = this.turn;
300 // Capture available? If yes, play it
301 let captures = moves.filter(m => m.vanish.length >= 2);
302 let mvArray = [];
303 while (captures.length >= 1) {
304 // Then just pick random captures (trying to maximize)
305 let candidates = captures.filter(c => !!c.notTheEnd);
306 let mv = null;
307 if (candidates.length >= 1) mv = candidates[randInt(candidates.length)];
308 else mv = captures[randInt(captures.length)];
309 this.play(mv);
310 mvArray.push(mv);
311 captures = (this.turn == color ? this.getAllValidMoves() : []);
312 }
313 if (mvArray.length >= 1) {
314 for (let i = mvArray.length - 1; i >= 0; i--) this.undo(mvArray[i]);
315 return mvArray;
316 }
317 // Just play a random move, which if possible does not let a capture
318 let candidates = [];
319 for (let m of moves) {
320 this.play(m);
321 if (!this.atLeastOneCapture()) candidates.push(m);
322 this.undo(m);
323 }
324 if (candidates.length >= 1) return candidates[randInt(candidates.length)];
325 return moves[randInt(moves.length)];
326 }
327
328 getNotation(move) {
329 if (move.appear.length == 0) return "stop";
330 return (
331 V.CoordsToSquare(move.start) +
332 V.CoordsToSquare(move.end) +
333 (move.vanish.length >= 2 ? "X" : "")
334 );
335 }
336
337 };