Add Swap, Switching, pawns variants
[vchess.git] / client / src / variants / Grand.js
1 import { ChessRules } from "@/base_rules";
2 import { ArrayFun } from "@/utils/array";
3 import { randInt } from "@/utils/alea";
4
5 // NOTE: initial setup differs from the original; see
6 // https://www.chessvariants.com/large.dir/freeling.html
7 export class GrandRules extends ChessRules {
8 static IsGoodFen(fen) {
9 if (!ChessRules.IsGoodFen(fen)) return false;
10 const fenParsed = V.ParseFen(fen);
11 // 5) Check captures
12 if (!fenParsed.captured || !fenParsed.captured.match(/^[0-9]{12,12}$/))
13 return false;
14 return true;
15 }
16
17 static IsGoodEnpassant(enpassant) {
18 if (enpassant != "-") return !!enpassant.match(/^([a-j][0-9]{1,2},?)+$/);
19 return true;
20 }
21
22 static ParseFen(fen) {
23 const fenParts = fen.split(" ");
24 return Object.assign(
25 ChessRules.ParseFen(fen),
26 { captured: fenParts[5] }
27 );
28 }
29
30 getPpath(b) {
31 return ([V.MARSHALL, V.CARDINAL].includes(b[1]) ? "Grand/" : "") + b;
32 }
33
34 getFen() {
35 return super.getFen() + " " + this.getCapturedFen();
36 }
37
38 getFenForRepeat() {
39 return super.getFenForRepeat() + "_" + this.getCapturedFen();
40 }
41
42 getCapturedFen() {
43 let counts = [...Array(12).fill(0)];
44 let i = 0;
45 for (let j = 0; j < V.PIECES.length; j++) {
46 if ([V.KING, V.PAWN].includes(V.PIECES[j]))
47 // No king captured, and pawns don't promote in pawns
48 continue;
49 counts[i] = this.captured["w"][V.PIECES[j]];
50 counts[6 + i] = this.captured["b"][V.PIECES[j]];
51 i++;
52 }
53 return counts.join("");
54 }
55
56 setOtherVariables(fen) {
57 super.setOtherVariables(fen);
58 const fenParsed = V.ParseFen(fen);
59 // Initialize captured pieces' counts from FEN
60 this.captured = {
61 w: {
62 [V.ROOK]: parseInt(fenParsed.captured[0]),
63 [V.KNIGHT]: parseInt(fenParsed.captured[1]),
64 [V.BISHOP]: parseInt(fenParsed.captured[2]),
65 [V.QUEEN]: parseInt(fenParsed.captured[3]),
66 [V.MARSHALL]: parseInt(fenParsed.captured[4]),
67 [V.CARDINAL]: parseInt(fenParsed.captured[5])
68 },
69 b: {
70 [V.ROOK]: parseInt(fenParsed.captured[6]),
71 [V.KNIGHT]: parseInt(fenParsed.captured[7]),
72 [V.BISHOP]: parseInt(fenParsed.captured[8]),
73 [V.QUEEN]: parseInt(fenParsed.captured[9]),
74 [V.MARSHALL]: parseInt(fenParsed.captured[10]),
75 [V.CARDINAL]: parseInt(fenParsed.captured[11])
76 }
77 };
78 }
79
80 static get size() {
81 return { x: 10, y: 10 };
82 }
83
84 // Rook + knight:
85 static get MARSHALL() {
86 return "m";
87 }
88
89 // Bishop + knight
90 static get CARDINAL() {
91 return "c";
92 }
93
94 static get PIECES() {
95 return ChessRules.PIECES.concat([V.MARSHALL, V.CARDINAL]);
96 }
97
98 // There may be 2 enPassant squares (if pawn jump 3 squares)
99 getEnpassantFen() {
100 const L = this.epSquares.length;
101 if (!this.epSquares[L - 1]) return "-"; //no en-passant
102 let res = "";
103 this.epSquares[L - 1].forEach(sq => {
104 res += V.CoordsToSquare(sq) + ",";
105 });
106 return res.slice(0, -1); //remove last comma
107 }
108
109 // En-passant after 2-sq or 3-sq jumps
110 getEpSquare(moveOrSquare) {
111 if (!moveOrSquare) return undefined;
112 if (typeof moveOrSquare === "string") {
113 const square = moveOrSquare;
114 if (square == "-") return undefined;
115 let res = [];
116 square.split(",").forEach(sq => {
117 res.push(V.SquareToCoords(sq));
118 });
119 return res;
120 }
121 // Argument is a move:
122 const move = moveOrSquare;
123 const [sx, sy, ex] = [move.start.x, move.start.y, move.end.x];
124 if (this.getPiece(sx, sy) == V.PAWN && Math.abs(sx - ex) >= 2) {
125 const step = (ex - sx) / Math.abs(ex - sx);
126 let res = [
127 {
128 x: sx + step,
129 y: sy
130 }
131 ];
132 if (sx + 2 * step != ex) {
133 // 3-squares jump
134 res.push({
135 x: sx + 2 * step,
136 y: sy
137 });
138 }
139 return res;
140 }
141 return undefined; //default
142 }
143
144 getPotentialMovesFrom([x, y]) {
145 switch (this.getPiece(x, y)) {
146 case V.MARSHALL:
147 return this.getPotentialMarshallMoves([x, y]);
148 case V.CARDINAL:
149 return this.getPotentialCardinalMoves([x, y]);
150 default:
151 return super.getPotentialMovesFrom([x, y]);
152 }
153 }
154
155 // Special pawn rules: promotions to captured friendly pieces,
156 // optional on ranks 8-9 and mandatory on rank 10.
157 getPotentialPawnMoves([x, y]) {
158 const color = this.turn;
159 let moves = [];
160 const [sizeX, sizeY] = [V.size.x, V.size.y];
161 const shiftX = color == "w" ? -1 : 1;
162 const startRanks = color == "w" ? [sizeX - 2, sizeX - 3] : [1, 2];
163 const lastRanks =
164 color == "w" ? [0, 1, 2] : [sizeX - 1, sizeX - 2, sizeX - 3];
165 const promotionPieces = [
166 V.ROOK,
167 V.KNIGHT,
168 V.BISHOP,
169 V.QUEEN,
170 V.MARSHALL,
171 V.CARDINAL
172 ];
173
174 // Always x+shiftX >= 0 && x+shiftX < sizeX, because no pawns on last rank
175 let finalPieces = undefined;
176 if (lastRanks.includes(x + shiftX)) {
177 finalPieces = promotionPieces.filter(p => this.captured[color][p] > 0);
178 if (x + shiftX != lastRanks[0]) finalPieces.push(V.PAWN);
179 } else finalPieces = [V.PAWN];
180 if (this.board[x + shiftX][y] == V.EMPTY) {
181 // One square forward
182 for (let piece of finalPieces)
183 moves.push(
184 this.getBasicMove([x, y], [x + shiftX, y], { c: color, p: piece })
185 );
186 if (startRanks.includes(x)) {
187 if (this.board[x + 2 * shiftX][y] == V.EMPTY) {
188 // Two squares jump
189 moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
190 if (x == startRanks[0] && this.board[x + 3 * shiftX][y] == V.EMPTY) {
191 // Three squares jump
192 moves.push(this.getBasicMove([x, y], [x + 3 * shiftX, y]));
193 }
194 }
195 }
196 }
197 // Captures
198 for (let shiftY of [-1, 1]) {
199 if (
200 y + shiftY >= 0 &&
201 y + shiftY < sizeY &&
202 this.board[x + shiftX][y + shiftY] != V.EMPTY &&
203 this.canTake([x, y], [x + shiftX, y + shiftY])
204 ) {
205 for (let piece of finalPieces) {
206 moves.push(
207 this.getBasicMove([x, y], [x + shiftX, y + shiftY], {
208 c: color,
209 p: piece
210 })
211 );
212 }
213 }
214 }
215
216 // En passant
217 const Lep = this.epSquares.length;
218 const epSquare = this.epSquares[Lep - 1];
219 if (!!epSquare) {
220 for (let epsq of epSquare) {
221 // TODO: some redundant checks
222 if (epsq.x == x + shiftX && Math.abs(epsq.y - y) == 1) {
223 let enpassantMove = this.getBasicMove([x, y], [epsq.x, epsq.y]);
224 // WARNING: the captured pawn may be diagonally behind us,
225 // if it's a 3-squares jump and we take on 1st passing square
226 const px = this.board[x][epsq.y] != V.EMPTY ? x : x - shiftX;
227 enpassantMove.vanish.push({
228 x: px,
229 y: epsq.y,
230 p: "p",
231 c: this.getColor(px, epsq.y)
232 });
233 moves.push(enpassantMove);
234 }
235 }
236 }
237
238 return moves;
239 }
240
241 // TODO: different castle?
242
243 getPotentialMarshallMoves(sq) {
244 return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]).concat(
245 this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep")
246 );
247 }
248
249 getPotentialCardinalMoves(sq) {
250 return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]).concat(
251 this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep")
252 );
253 }
254
255 isAttacked(sq, color) {
256 return (
257 super.isAttacked(sq, color) ||
258 this.isAttackedByMarshall(sq, color) ||
259 this.isAttackedByCardinal(sq, color)
260 );
261 }
262
263 isAttackedByMarshall(sq, color) {
264 return (
265 this.isAttackedBySlideNJump(sq, color, V.MARSHALL, V.steps[V.ROOK]) ||
266 this.isAttackedBySlideNJump(
267 sq,
268 color,
269 V.MARSHALL,
270 V.steps[V.KNIGHT],
271 "oneStep"
272 )
273 );
274 }
275
276 isAttackedByCardinal(sq, color) {
277 return (
278 this.isAttackedBySlideNJump(sq, color, V.CARDINAL, V.steps[V.BISHOP]) ||
279 this.isAttackedBySlideNJump(
280 sq,
281 color,
282 V.CARDINAL,
283 V.steps[V.KNIGHT],
284 "oneStep"
285 )
286 );
287 }
288
289 postPlay(move) {
290 super.postPlay(move);
291 if (move.vanish.length == 2 && move.appear.length == 1)
292 // Capture: update this.captured
293 this.captured[move.vanish[1].c][move.vanish[1].p]++;
294 }
295
296 postUndo(move) {
297 super.postUndo(move);
298 if (move.vanish.length == 2 && move.appear.length == 1)
299 this.captured[move.vanish[1].c][move.vanish[1].p]--;
300 }
301
302 static get VALUES() {
303 return Object.assign(
304 { c: 5, m: 7 }, //experimental
305 ChessRules.VALUES
306 );
307 }
308
309 static get SEARCH_DEPTH() {
310 return 2;
311 }
312
313 static GenRandInitFen(randomness) {
314 if (randomness == 0) {
315 return (
316 "r8r/1nbqkmcbn1/pppppppppp/91/91/91/91/PPPPPPPPPP/1NBQKMCBN1/R8R " +
317 // No castling in the official initial setup
318 "w 0 zzzz - 00000000000000"
319 );
320 }
321
322 let pieces = { w: new Array(10), b: new Array(10) };
323 let flags = "";
324 // Shuffle pieces on first and last rank
325 for (let c of ["w", "b"]) {
326 if (c == 'b' && randomness == 1) {
327 pieces['b'] = pieces['w'];
328 flags += flags;
329 break;
330 }
331
332 let positions = ArrayFun.range(10);
333
334 // Get random squares for bishops
335 let randIndex = 2 * randInt(5);
336 let bishop1Pos = positions[randIndex];
337 // The second bishop must be on a square of different color
338 let randIndex_tmp = 2 * randInt(5) + 1;
339 let bishop2Pos = positions[randIndex_tmp];
340 // Remove chosen squares
341 positions.splice(Math.max(randIndex, randIndex_tmp), 1);
342 positions.splice(Math.min(randIndex, randIndex_tmp), 1);
343
344 // Get random squares for knights
345 randIndex = randInt(8);
346 let knight1Pos = positions[randIndex];
347 positions.splice(randIndex, 1);
348 randIndex = randInt(7);
349 let knight2Pos = positions[randIndex];
350 positions.splice(randIndex, 1);
351
352 // Get random square for queen
353 randIndex = randInt(6);
354 let queenPos = positions[randIndex];
355 positions.splice(randIndex, 1);
356
357 // ...random square for marshall
358 randIndex = randInt(5);
359 let marshallPos = positions[randIndex];
360 positions.splice(randIndex, 1);
361
362 // ...random square for cardinal
363 randIndex = randInt(4);
364 let cardinalPos = positions[randIndex];
365 positions.splice(randIndex, 1);
366
367 // Rooks and king positions are now fixed,
368 // because of the ordering rook-king-rook
369 let rook1Pos = positions[0];
370 let kingPos = positions[1];
371 let rook2Pos = positions[2];
372
373 // Finally put the shuffled pieces in the board array
374 pieces[c][rook1Pos] = "r";
375 pieces[c][knight1Pos] = "n";
376 pieces[c][bishop1Pos] = "b";
377 pieces[c][queenPos] = "q";
378 pieces[c][marshallPos] = "m";
379 pieces[c][cardinalPos] = "c";
380 pieces[c][kingPos] = "k";
381 pieces[c][bishop2Pos] = "b";
382 pieces[c][knight2Pos] = "n";
383 pieces[c][rook2Pos] = "r";
384 flags += V.CoordToColumn(rook1Pos) + V.CoordToColumn(rook2Pos);
385 }
386 return (
387 pieces["b"].join("") +
388 "/pppppppppp/91/91/91/91/91/91/PPPPPPPPPP/" +
389 pieces["w"].join("").toUpperCase() +
390 " w 0 " + flags + " - 00000000000000"
391 );
392 }
393 };