Fix notation and pieces setup for random asymmetric in Eightpieces
[vchess.git] / client / src / variants / Ball.js
CommitLineData
6f2f9437
BA
1import { ChessRules, Move, PiPo } from "@/base_rules";
2import { WildebeestRules } from "@/variants/Wildebeest";
3import { ArrayFun } from "@/utils/array";
4import { shuffle } from "@/utils/alea";
5
6export class BallRules extends ChessRules {
7 static get PawnSpecs() {
8 return Object.assign(
9 {},
10 ChessRules.PawnSpecs,
11 { promotions: ChessRules.PawnSpecs.promotions.concat([V.WILDEBEEST]) }
12 );
13 }
14
15 static get HasFlags() {
16 return false;
17 }
18 static get HasCastle() {
19 return false;
20 }
21
22 static get WILDEBEEST() {
23 return 'w';
24 }
25
26 static get BALL() {
27 // 'b' is already taken:
28 return "aa";
29 }
30
31 // Special code for "something to fill space" (around goals)
32 // --> If goal is outside the board (current prototype: it's inside)
33// static get FILL() {
34// return "ff";
35// }
36
37 static get HAS_BALL_CODE() {
38 return {
39 'p': 's',
40 'r': 'u',
41 'n': 'o',
42 'b': 'c',
43 'q': 't',
44 'k': 'l',
45 'w': 'y'
46 };
47 }
48
49 static get HAS_BALL_DECODE() {
50 return {
51 's': 'p',
52 'u': 'r',
53 'o': 'n',
54 'c': 'b',
55 't': 'q',
56 'l': 'k',
57 'y': 'w'
58 };
59 }
60
61 static get PIECES() {
62 return ChessRules.PIECES
63 .concat([V.WILDEBEEST])
64 .concat(Object.keys(V.HAS_BALL_DECODE))
65 .concat(['a']);
66 }
67
68 static board2fen(b) {
69 if (b == V.BALL) return 'a';
70 return ChessRules.board2fen(b);
71 }
72
73 static fen2board(f) {
74 if (f == 'a') return V.BALL;
75 return ChessRules.fen2board(f);
76 }
77
78 // Check that exactly one ball is on the board
79 // + at least one piece per color.
80 static IsGoodPosition(position) {
81 if (position.length == 0) return false;
82 const rows = position.split("/");
83 if (rows.length != V.size.x) return false;
84 let pieces = { "w": 0, "b": 0 };
85 const withBall = Object.keys(V.HAS_BALL_DECODE).concat([V.BALL]);
86 let ballCount = 0;
87 for (let row of rows) {
88 let sumElts = 0;
89 for (let i = 0; i < row.length; i++) {
90 const lowerRi = row[i].toLowerCase();
91 if (V.PIECES.includes(lowerRi)) {
92 if (lowerRi != V.BALL) pieces[row[i] == lowerRi ? "b" : "w"]++;
93 if (withBall.includes(lowerRi)) ballCount++;
94 sumElts++;
95 } else {
96 const num = parseInt(row[i]);
97 if (isNaN(num)) return false;
98 sumElts += num;
99 }
100 }
101 if (sumElts != V.size.y) return false;
102 }
103 if (ballCount != 1 || Object.values(pieces).some(v => v == 0))
104 return false;
105 return true;
106 }
107
108 getPpath(b) {
109 let prefix = "";
110 const withPrefix =
111 Object.keys(V.HAS_BALL_DECODE)
112 .concat([V.WILDEBEEST])
113 .concat(['a']);
114 if (withPrefix.includes(b[1])) prefix = "Ball/";
115 return prefix + b;
116 }
117
118 canTake([x1, y1], [x2, y2]) {
119 // Capture enemy or pass ball to friendly pieces
120 return (
121 this.getColor(x1, y1) !== this.getColor(x2, y2) ||
122 Object.keys(V.HAS_BALL_DECODE).includes(this.board[x1][y1].charAt(1))
123 );
124 }
125
126 getCheckSquares(color) {
127 return [];
128 }
129
130 static GenRandInitFen(randomness) {
131 if (randomness == 0)
305ede7e 132 return "rnbqkwnbr/ppppppppp/9/9/4a4/9/9/PPPPPPPPP/RNBQKWNBR w 0 -";
6f2f9437
BA
133
134 let pieces = { w: new Array(9), b: new Array(9) };
135 for (let c of ["w", "b"]) {
136 if (c == 'b' && randomness == 1) {
137 pieces['b'] = pieces['w'];
138 break;
139 }
140
141 // Get random squares for every piece, totally freely
142 let positions = shuffle(ArrayFun.range(9));
143 const composition = ['b', 'b', 'r', 'r', 'n', 'n', 'k', 'q', 'w'];
144 const rem2 = positions[0] % 2;
145 if (rem2 == positions[1] % 2) {
146 // Fix bishops (on different colors)
147 for (let i=2; i<9; i++) {
148 if (positions[i] % 2 != rem2)
149 [positions[1], positions[i]] = [positions[i], positions[1]];
150 }
151 }
152 for (let i = 0; i < 9; i++) pieces[c][positions[i]] = composition[i];
153 }
154 return (
155 pieces["b"].join("") +
156 "/ppppppppp/9/9/4a4/9/9/PPPPPPPPP/" +
157 pieces["w"].join("").toUpperCase() +
158 // En-passant allowed, but no flags
159 " w 0 -"
160 );
161 }
162
163 scanKings(fen) {}
164
165 static get size() {
166 return { x: 9, y: 9 };
167 }
168
169 getPiece(i, j) {
170 const p = this.board[i][j].charAt(1);
171 if (Object.keys(V.HAS_BALL_DECODE).includes(p))
172 return V.HAS_BALL_DECODE[p];
173 return p;
174 }
175
176 static get steps() {
177 return WildebeestRules.steps;
178 }
179
180 // Because of the ball, getPiece() could be wrong:
181 // use board[x][y][1] instead (always valid).
182 getBasicMove([sx, sy], [ex, ey], tr) {
183 const initColor = this.getColor(sx, sy);
184 const initPiece = this.board[sx][sy].charAt(1);
185 let mv = new Move({
186 appear: [
187 new PiPo({
188 x: ex,
189 y: ey,
190 c: tr ? tr.c : initColor,
191 p: tr ? tr.p : initPiece
192 })
193 ],
194 vanish: [
195 new PiPo({
196 x: sx,
197 y: sy,
198 c: initColor,
199 p: initPiece
200 })
201 ]
202 });
203
204 // Fix "ball holding" indication in case of promotions:
205 if (!!tr && Object.keys(V.HAS_BALL_DECODE).includes(initPiece))
206 mv.appear[0].p = V.HAS_BALL_CODE[tr.p];
207
208 // The opponent piece disappears if we take it
209 if (this.board[ex][ey] != V.EMPTY) {
210 mv.vanish.push(
211 new PiPo({
212 x: ex,
213 y: ey,
214 c: this.getColor(ex, ey),
215 p: this.board[ex][ey].charAt(1)
216 })
217 );
218 }
219
220 // Post-processing: maybe the ball was taken, or a piece + ball
221 if (mv.vanish.length == 2) {
222 if (
223 // Take the ball?
224 mv.vanish[1].c == 'a' ||
225 // Capture a ball-holding piece?
226 Object.keys(V.HAS_BALL_DECODE).includes(mv.vanish[1].p)
227 ) {
228 mv.appear[0].p = V.HAS_BALL_CODE[mv.appear[0].p];
229 } else if (mv.vanish[1].c == mv.vanish[0].c) {
230 // Pass the ball: the passing unit does not disappear
231 mv.appear.push(JSON.parse(JSON.stringify(mv.vanish[0])));
232 mv.appear[0].p = V.HAS_BALL_CODE[mv.vanish[1].p];
233 mv.appear[1].p = V.HAS_BALL_DECODE[mv.appear[1].p];
234 }
235 // Else: standard capture
236 }
237
238 return mv;
239 }
240
241 // NOTE: if a pawn is captured en-passant, he doesn't hold the ball
242 // So base implementation is fine.
243
244 getPotentialMovesFrom([x, y]) {
245 if (this.getPiece(x, y) == V.WILDEBEEST)
246 return this.getPotentialWildebeestMoves([x, y]);
247 return super.getPotentialMovesFrom([x, y]);
248 }
249
250 getPotentialWildebeestMoves(sq) {
251 return this.getSlideNJumpMoves(
252 sq,
253 V.steps[V.KNIGHT].concat(V.steps[WildebeestRules.CAMEL]),
254 "oneStep"
255 );
256 }
257
258 filterValid(moves) {
259 return moves;
260 }
261
262 // isAttacked: unused here (no checks)
263
264 postPlay() {}
265 postUndo() {}
266
267 getCurrentScore() {
268 // Turn has changed:
269 const color = V.GetOppCol(this.turn);
270 const lastRank = (color == "w" ? 0 : 8);
271 if ([3,4,5].some(
272 i => {
273 return (
274 Object.keys(V.HAS_BALL_DECODE).includes(
275 this.board[lastRank][i].charAt(1)) &&
276 this.getColor(lastRank, i) == color
277 );
278 }
279 )) {
280 // Goal scored!
281 return color == "w" ? "1-0" : "0-1";
282 }
283 if (this.atLeastOneMove()) return "*";
284 // Stalemate (quite unlikely?)
285 return "1/2";
286 }
287
288 static get VALUES() {
289 return {
290 p: 1,
291 r: 5,
292 n: 3,
293 b: 3,
294 q: 9,
295 w: 7,
296 k: 5,
297 a: 0 //ball: neutral
298 };
299 }
300
301 static get SEARCH_DEPTH() {
302 return 2;
303 }
304
305 evalPosition() {
306 // Count material:
307 let evaluation = super.evalPosition();
308 if (this.board[4][4] == V.BALL)
309 // Ball not captured yet
310 return evaluation;
311 // Ponder depending on ball position
312 for (let i=0; i<9; i++) {
313 for (let j=0; j<9; j++) {
314 if (Object.keys(V.HAS_BALL_DECODE).includes(this.board[i][j][1]))
315 return evaluation/2 + (this.getColor(i, j) == "w" ? 8 - i : -i);
316 }
317 }
318 return 0; //never reached
319 }
320
321 getNotation(move) {
322 const finalSquare = V.CoordsToSquare(move.end);
323 if (move.appear.length == 2)
324 // A pass: special notation
325 return V.CoordsToSquare(move.start) + "P" + finalSquare;
326 const piece = this.getPiece(move.start.x, move.start.y);
327 if (piece == V.PAWN) {
328 // Pawn move
329 let notation = "";
330 if (move.vanish.length > move.appear.length) {
331 // Capture
332 const startColumn = V.CoordToColumn(move.start.y);
333 notation = startColumn + "x" + finalSquare;
334 }
335 else notation = finalSquare;
336 if (![V.PAWN, V.HAS_BALL_CODE[V.PAWN]].includes(move.appear[0].p)) {
337 // Promotion
338 const promotePiece =
339 V.HAS_BALL_DECODE[move.appear[0].p] || move.appear[0].p;
340 notation += "=" + promotePiece.toUpperCase();
341 }
342 return notation;
343 }
344 // Piece movement
345 return (
346 piece.toUpperCase() +
347 (move.vanish.length > move.appear.length ? "x" : "") +
348 finalSquare
349 );
350 }
351};