Add temporary patch for preset challenges
[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 export class GrandRules extends ChessRules {
6
7 static get HasFlags() {
8 return false;
9 }
10
11 static IsGoodEnpassant(enpassant) {
12 if (enpassant != "-") return !!enpassant.match(/^([a-j][0-9]{1,2},?)+$/);
13 return true;
14 }
15
16 getPpath(b) {
17 return ([V.MARSHALL, V.CARDINAL].includes(b[1]) ? "Grand/" : "") + b;
18 }
19
20 static get size() {
21 return { x: 10, y: 10 };
22 }
23
24 // Rook + knight:
25 static get MARSHALL() {
26 return "m";
27 }
28
29 // Bishop + knight
30 static get CARDINAL() {
31 return "c";
32 }
33
34 static get PIECES() {
35 return ChessRules.PIECES.concat([V.MARSHALL, V.CARDINAL]);
36 }
37
38 getPotentialMovesFrom([x, y]) {
39 switch (this.getPiece(x, y)) {
40 case V.MARSHALL:
41 return this.getPotentialMarshallMoves([x, y]);
42 case V.CARDINAL:
43 return this.getPotentialCardinalMoves([x, y]);
44 default:
45 return super.getPotentialMovesFrom([x, y]);
46 }
47 }
48
49 // Special pawn rules: promotions to captured friendly pieces,
50 // optional on ranks 8-9 and mandatory on rank 10.
51 getPotentialPawnMoves([x, y]) {
52 const color = this.turn;
53 let moves = [];
54 const [sizeX, sizeY] = [V.size.x, V.size.y];
55 const shiftX = color == "w" ? -1 : 1;
56 const startRank = (color == "w" ? sizeX - 3 : 2);
57 const lastRanks =
58 color == "w" ? [0, 1, 2] : [sizeX - 1, sizeX - 2, sizeX - 3];
59 // Always x+shiftX >= 0 && x+shiftX < sizeX, because no pawns on last rank
60 let finalPieces = [V.PAWN];
61 if (lastRanks.includes(x + shiftX)) {
62 // Determine which promotion pieces are available:
63 let promotionPieces = {
64 [V.ROOK]: 2,
65 [V.KNIGHT]: 2,
66 [V.BISHOP]: 2,
67 [V.QUEEN]: 1,
68 [V.MARSHALL]: 1,
69 [V.CARDINAL]: 1
70 };
71 for (let i=0; i<10; i++) {
72 for (let j=0; j<10; j++) {
73 if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) {
74 const p = this.getPiece(i, j);
75 if (![V.PAWN, V.KING].includes(p)) promotionPieces[p]--;
76 }
77 }
78 }
79 const availablePieces =
80 Object.keys(promotionPieces).filter(k => promotionPieces[k] > 0);
81 if (x + shiftX == lastRanks[0]) finalPieces = availablePieces;
82 else Array.prototype.push.apply(finalPieces, availablePieces);
83 }
84 if (this.board[x + shiftX][y] == V.EMPTY) {
85 // One square forward
86 for (let piece of finalPieces)
87 moves.push(
88 this.getBasicMove([x, y], [x + shiftX, y], { c: color, p: piece })
89 );
90 if (x == startRank && this.board[x + 2 * shiftX][y] == V.EMPTY)
91 // Two squares jump
92 moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
93 }
94 // Captures
95 for (let shiftY of [-1, 1]) {
96 if (
97 y + shiftY >= 0 &&
98 y + shiftY < sizeY &&
99 this.board[x + shiftX][y + shiftY] != V.EMPTY &&
100 this.canTake([x, y], [x + shiftX, y + shiftY])
101 ) {
102 for (let piece of finalPieces) {
103 moves.push(
104 this.getBasicMove([x, y], [x + shiftX, y + shiftY], {
105 c: color,
106 p: piece
107 })
108 );
109 }
110 }
111 }
112
113 // En passant
114 Array.prototype.push.apply(
115 moves,
116 this.getEnpassantCaptures([x, y], shiftX)
117 );
118
119 return moves;
120 }
121
122 getPotentialMarshallMoves(sq) {
123 return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]).concat(
124 this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep")
125 );
126 }
127
128 getPotentialCardinalMoves(sq) {
129 return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]).concat(
130 this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep")
131 );
132 }
133
134 isAttacked(sq, color) {
135 return (
136 super.isAttacked(sq, color) ||
137 this.isAttackedByMarshall(sq, color) ||
138 this.isAttackedByCardinal(sq, color)
139 );
140 }
141
142 isAttackedByMarshall(sq, color) {
143 return (
144 this.isAttackedBySlideNJump(sq, color, V.MARSHALL, V.steps[V.ROOK]) ||
145 this.isAttackedBySlideNJump(
146 sq,
147 color,
148 V.MARSHALL,
149 V.steps[V.KNIGHT],
150 "oneStep"
151 )
152 );
153 }
154
155 isAttackedByCardinal(sq, color) {
156 return (
157 this.isAttackedBySlideNJump(sq, color, V.CARDINAL, V.steps[V.BISHOP]) ||
158 this.isAttackedBySlideNJump(
159 sq,
160 color,
161 V.CARDINAL,
162 V.steps[V.KNIGHT],
163 "oneStep"
164 )
165 );
166 }
167
168 static get VALUES() {
169 return Object.assign(
170 { c: 5, m: 7 }, //experimental
171 ChessRules.VALUES
172 );
173 }
174
175 static get SEARCH_DEPTH() {
176 return 2;
177 }
178
179 static GenRandInitFen(randomness) {
180 if (randomness == 0) {
181 return (
182 "r8r/1nbqkmcbn1/pppppppppp/91/91/91/91/PPPPPPPPPP/1NBQKMCBN1/R8R " +
183 "w 0 -"
184 );
185 }
186
187 let pieces = { w: new Array(8), b: new Array(8) };
188 // Shuffle pieces on second and before-last rank
189 for (let c of ["w", "b"]) {
190 if (c == 'b' && randomness == 1) {
191 pieces['b'] = pieces['w'];
192 break;
193 }
194
195 let positions = ArrayFun.range(8);
196
197 // Get random squares for bishops
198 let randIndex = 2 * randInt(4);
199 const bishop1Pos = positions[randIndex];
200 // The second bishop must be on a square of different color
201 let randIndex_tmp = 2 * randInt(4) + 1;
202 const bishop2Pos = positions[randIndex_tmp];
203 // Remove chosen squares
204 positions.splice(Math.max(randIndex, randIndex_tmp), 1);
205 positions.splice(Math.min(randIndex, randIndex_tmp), 1);
206
207 // Get random squares for knights
208 randIndex = randInt(6);
209 const knight1Pos = positions[randIndex];
210 positions.splice(randIndex, 1);
211 randIndex = randInt(5);
212 const knight2Pos = positions[randIndex];
213 positions.splice(randIndex, 1);
214
215 // Get random square for queen
216 randIndex = randInt(4);
217 const queenPos = positions[randIndex];
218 positions.splice(randIndex, 1);
219
220 // ...random square for marshall
221 randIndex = randInt(3);
222 const marshallPos = positions[randIndex];
223 positions.splice(randIndex, 1);
224
225 // ...random square for cardinal
226 randIndex = randInt(2);
227 const cardinalPos = positions[randIndex];
228 positions.splice(randIndex, 1);
229
230 // King position is now fixed,
231 const kingPos = positions[0];
232
233 // Finally put the shuffled pieces in the board array
234 pieces[c][knight1Pos] = "n";
235 pieces[c][bishop1Pos] = "b";
236 pieces[c][queenPos] = "q";
237 pieces[c][marshallPos] = "m";
238 pieces[c][cardinalPos] = "c";
239 pieces[c][kingPos] = "k";
240 pieces[c][bishop2Pos] = "b";
241 pieces[c][knight2Pos] = "n";
242 }
243 return (
244 "r8r/1" + pieces["b"].join("") + "1/" +
245 "pppppppppp/91/91/91/91/PPPPPPPPPP/" +
246 "1" + pieces["w"].join("").toUpperCase() + "1/R8R" +
247 " w 0 -"
248 );
249 }
250
251 };