Attempt to clarify installation instructions a little
[vchess.git] / client / src / variants / Shogun.js
1 import { ChessRules, PiPo, Move } from "@/base_rules";
2 import { ArrayFun } from "@/utils/array";
3
4 export class ShogunRules extends ChessRules {
5
6 static get CAPTAIN() {
7 return 'c';
8 }
9 static get GENERAL() {
10 return 'g';
11 }
12 static get ARCHBISHOP() {
13 return 'a';
14 }
15 static get MORTAR() {
16 return 'm';
17 }
18 static get DUCHESS() {
19 return 'f';
20 }
21
22 static get PIECES() {
23 return (
24 ChessRules.PIECES
25 .concat([V.CAPTAIN, V.GENERAL, V.ARCHBISHOP, V.MORTAR, V.DUCHESS])
26 );
27 }
28
29 getPpath(b) {
30 return "Shogun/" + b;
31 }
32
33 getReservePpath(index, color) {
34 return "Shogun/" + color + V.RESERVE_PIECES[index];
35 }
36
37 static IsGoodFen(fen) {
38 if (!ChessRules.IsGoodFen(fen)) return false;
39 const fenParsed = V.ParseFen(fen);
40 // 5) Check reserves
41 if (!fenParsed.reserve || !fenParsed.reserve.match(/^[0-9]{10,10}$/))
42 return false;
43 return true;
44 }
45
46 static ParseFen(fen) {
47 const fenParts = fen.split(" ");
48 return Object.assign(
49 ChessRules.ParseFen(fen),
50 { reserve: fenParts[5] }
51 );
52 }
53
54 static GenRandInitFen(options) {
55 return ChessRules.GenRandInitFen(options) + " 0000000000";
56 }
57
58 getFen() {
59 return super.getFen() + " " + this.getReserveFen();
60 }
61
62 getFenForRepeat() {
63 return super.getFenForRepeat() + "_" + this.getReserveFen();
64 }
65
66 getReserveFen() {
67 let counts = new Array(10);
68 for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
69 counts[i] = this.reserve["w"][V.RESERVE_PIECES[i]];
70 counts[5 + i] = this.reserve["b"][V.RESERVE_PIECES[i]];
71 }
72 return counts.join("");
73 }
74
75 setOtherVariables(fen) {
76 super.setOtherVariables(fen);
77 // Also init reserves (used by the interface to show landable pieces)
78 const reserve =
79 V.ParseFen(fen).reserve.split("").map(x => parseInt(x, 10));
80 this.reserve = {
81 w: {
82 [V.PAWN]: reserve[0],
83 [V.ROOK]: reserve[1],
84 [V.KNIGHT]: reserve[2],
85 [V.BISHOP]: reserve[3],
86 [V.DUCHESS]: reserve[4]
87 },
88 b: {
89 [V.PAWN]: reserve[5],
90 [V.ROOK]: reserve[6],
91 [V.KNIGHT]: reserve[7],
92 [V.BISHOP]: reserve[8],
93 [V.DUCHESS]: reserve[9]
94 }
95 };
96 }
97
98 getColor(i, j) {
99 if (i >= V.size.x) return i == V.size.x ? "w" : "b";
100 return this.board[i][j].charAt(0);
101 }
102
103 getPiece(i, j) {
104 if (i >= V.size.x) return V.RESERVE_PIECES[j];
105 return this.board[i][j].charAt(1);
106 }
107
108 // Ordering on reserve pieces
109 static get RESERVE_PIECES() {
110 return [V.PAWN, V.ROOK, V.KNIGHT, V.BISHOP, V.DUCHESS];
111 }
112
113 getReserveMoves([x, y]) {
114 const color = this.turn;
115 const iZone = (color == 'w' ? [3, 4, 5, 6, 7] : [0, 1, 2, 3, 4]);
116 const p = V.RESERVE_PIECES[y];
117 if (this.reserve[color][p] == 0) return [];
118 let moves = [];
119 for (let i of iZone) {
120 for (let j = 0; j < V.size.y; j++) {
121 if (this.board[i][j] == V.EMPTY) {
122 let mv = new Move({
123 appear: [
124 new PiPo({
125 x: i,
126 y: j,
127 c: color,
128 p: p
129 })
130 ],
131 vanish: [],
132 start: { x: x, y: y }, //a bit artificial...
133 end: { x: i, y: j }
134 });
135 moves.push(mv);
136 }
137 }
138 }
139 return moves;
140 }
141
142 static get MapUnpromoted() {
143 return {
144 f: 'q',
145 r: 'm',
146 b: 'a',
147 p: 'c',
148 n: 'g'
149 };
150 }
151
152 getPotentialMovesFrom([x, y]) {
153 if (x >= V.size.x)
154 // Reserves, outside of board: x == sizeX(+1)
155 return this.getReserveMoves([x, y]);
156 // Standard moves
157 const piece = this.getPiece(x, y);
158 const sq = [x, y];
159 if (piece == V.KING) return super.getPotentialKingMoves(sq);
160 let moves = [];
161 switch (piece) {
162 // Unpromoted
163 case V.PAWN:
164 return this.getPotentialPawnMoves(sq);
165 case V.ROOK:
166 moves = super.getPotentialRookMoves(sq);
167 break;
168 case V.KNIGHT:
169 moves = super.getPotentialKnightMoves(sq);
170 break;
171 case V.BISHOP:
172 moves = super.getPotentialBishopMoves(sq);
173 break;
174 case V.DUCHESS:
175 moves = this.getPotentialDuchessMoves(sq);
176 break;
177 }
178 if ([V.ROOK, V.KNIGHT, V.BISHOP, V.DUCHESS].includes(piece)) {
179 let extraMoves = [];
180 // Check that no promoted form is already on board:
181 const promotedForm = V.MapUnpromoted[piece];
182 const c = this.turn;
183 if (
184 this.board.some(b =>
185 b.some(cell =>
186 cell[0] == c && cell[1] == promotedForm)
187 )
188 ) {
189 return moves;
190 }
191 const promotionZone = (this.turn == 'w' ? [0, 1, 2] : [5, 6, 7]);
192 moves.forEach(m => {
193 if (
194 promotionZone.includes(m.end.x) ||
195 promotionZone.includes(m.start.x)
196 ) {
197 let newMove = JSON.parse(JSON.stringify(m));
198 newMove.appear[0].p = promotedForm;
199 extraMoves.push(newMove);
200 }
201 });
202 return moves.concat(extraMoves);
203 }
204 switch (piece) {
205 // Promoted
206 case V.CAPTAIN: return this.getPotentialCaptainMoves(sq);
207 case V.MORTAR: return this.getPotentialMortarMoves(sq);
208 case V.GENERAL: return this.getPotentialGeneralMoves(sq);
209 case V.ARCHBISHOP: return this.getPotentialArchbishopMoves(sq);
210 case V.QUEEN: return super.getPotentialQueenMoves(sq);
211 }
212 return []; //never reached
213 }
214
215 getPotentialPawnMoves([x, y]) {
216 // NOTE: apply promotion freely, but not on en-passant
217 const c = this.turn;
218 const oppCol = V.GetOppCol(c);
219 const forward = (c == 'w' ? -1 : 1);
220 const initialRank = (c == 'w' ? 6 : 1);
221 let moves = [];
222 // Pawn push
223 let [i, j] = [x + forward, y];
224 if (this.board[i][j] == V.EMPTY) {
225 moves.push(this.getBasicMove([x, y], [i, j]));
226 if (x == initialRank && this.board[i + forward][j] == V.EMPTY)
227 moves.push(this.getBasicMove([x, y], [i + forward, j]));
228 }
229 // Captures
230 for (let shiftY of [-1, 1]) {
231 [i, j] = [x + forward, y + shiftY];
232 if (
233 V.OnBoard(i, j) &&
234 this.board[i][j] != V.EMPTY &&
235 this.getColor(i, j) == oppCol
236 ) {
237 moves.push(this.getBasicMove([x, y], [i, j]));
238 }
239 }
240 let extraMoves = [];
241 const promotionZone = (this.turn == 'w' ? [1, 2] : [5, 6]);
242 const lastRank = (c == 'w' ? 0 : 7);
243 moves.forEach(m => {
244 if (m.end.x == lastRank)
245 // Force promotion
246 m.appear[0].p = V.CAPTAIN;
247 else if (promotionZone.includes(m.end.x)) {
248 let newMove = JSON.parse(JSON.stringify(m));
249 newMove.appear[0].p = V.CAPTAIN;
250 extraMoves.push(newMove);
251 }
252 });
253 return (
254 moves.concat(extraMoves)
255 .concat(super.getEnpassantCaptures([x, y], forward))
256 );
257 }
258
259 getPotentialDuchessMoves(sq) {
260 return super.getSlideNJumpMoves(sq, V.steps[V.BISHOP], 1);
261 }
262
263 getPotentialCaptainMoves(sq) {
264 const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
265 return super.getSlideNJumpMoves(sq, steps, 1);
266 }
267
268 getPotentialMortarMoves(sq) {
269 return (
270 super.getSlideNJumpMoves(sq, V.steps[V.ROOK])
271 .concat(super.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], 1))
272 );
273 }
274
275 getPotentialGeneralMoves(sq) {
276 const steps =
277 V.steps[V.BISHOP].concat(V.steps[V.ROOK]).concat(V.steps[V.KNIGHT]);
278 return super.getSlideNJumpMoves(sq, steps, 1);
279 }
280
281 getPotentialArchbishopMoves(sq) {
282 return (
283 super.getSlideNJumpMoves(sq, V.steps[V.BISHOP])
284 .concat(super.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], 1))
285 );
286 }
287
288 isAttacked(sq, color) {
289 return (
290 super.isAttacked(sq, color) ||
291 this.isAttackedByDuchess(sq, color) ||
292 this.isAttackedByCaptain(sq, color) ||
293 this.isAttackedByMortar(sq, color) ||
294 this.isAttackedByGeneral(sq, color) ||
295 this.isAttackedByArchbishop(sq, color)
296 );
297 }
298
299 isAttackedByDuchess(sq, color) {
300 return (
301 super.isAttackedBySlideNJump(
302 sq, color, V.DUCHESS, V.steps[V.BISHOP], 1)
303 );
304 }
305
306 isAttackedByCaptain(sq, color) {
307 const steps = V.steps[V.BISHOP].concat(V.steps[V.ROOK]);
308 return (
309 super.isAttackedBySlideNJump(sq, color, V.CAPTAIN, steps, 1)
310 );
311 }
312
313 isAttackedByMortar(sq, color) {
314 return (
315 super.isAttackedBySlideNJump(sq, color, V.MORTAR, V.steps[V.ROOK]) ||
316 super.isAttackedBySlideNJump(
317 sq, color, V.MORTAR, V.steps[V.KNIGHT], 1)
318 );
319 }
320
321 isAttackedByGeneral(sq, color) {
322 const steps =
323 V.steps[V.BISHOP].concat(V.steps[V.ROOK]).concat(V.steps[V.KNIGHT]);
324 return (
325 super.isAttackedBySlideNJump(sq, color, V.GENERAL, steps, 1)
326 );
327 }
328
329 isAttackedByArchbishop(sq, color) {
330 return (
331 super.isAttackedBySlideNJump(sq, color, V.ARCHBISHOP, V.steps[V.BISHOP])
332 ||
333 super.isAttackedBySlideNJump(
334 sq, color, V.ARCHBISHOP, V.steps[V.KNIGHT], 1)
335 );
336 }
337
338 getAllValidMoves() {
339 let moves = super.getAllPotentialMoves();
340 const color = this.turn;
341 for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
342 moves = moves.concat(
343 this.getReserveMoves([V.size.x + (color == "w" ? 0 : 1), i])
344 );
345 }
346 return this.filterValid(moves);
347 }
348
349 atLeastOneMove() {
350 if (!super.atLeastOneMove()) {
351 // Search one reserve move
352 for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
353 let moves = this.filterValid(
354 this.getReserveMoves([V.size.x + (this.turn == "w" ? 0 : 1), i])
355 );
356 if (moves.length > 0) return true;
357 }
358 return false;
359 }
360 return true;
361 }
362
363 static get MapPromoted() {
364 return {
365 q: 'f',
366 m: 'r',
367 a: 'b',
368 c: 'p',
369 g: 'n'
370 };
371 }
372
373 getUnpromotedForm(piece) {
374 if (Object.keys(V.MapPromoted).includes(piece))
375 return V.MapPromoted[piece];
376 return piece;
377 }
378
379 postPlay(move) {
380 super.postPlay(move);
381 // Skip castle:
382 if (move.vanish.length == 2 && move.appear.length == 2) return;
383 const color = move.appear[0].c;
384 if (move.vanish.length == 0) this.reserve[color][move.appear[0].p]--;
385 else if (move.vanish.length == 2)
386 this.reserve[color][this.getUnpromotedForm(move.vanish[1].p)]++;
387 }
388
389 postUndo(move) {
390 super.postUndo(move);
391 if (move.vanish.length == 2 && move.appear.length == 2) return;
392 const color = this.turn;
393 if (move.vanish.length == 0) this.reserve[color][move.appear[0].p]++;
394 else if (move.vanish.length == 2)
395 this.reserve[color][this.getUnpromotedForm(move.vanish[1].p)]--;
396 }
397
398 static get SEARCH_DEPTH() {
399 return 2;
400 }
401
402 static get VALUES() {
403 return (
404 Object.assign(
405 {
406 c: 4,
407 g: 5,
408 a: 7,
409 m: 7,
410 f: 2
411 },
412 ChessRules.VALUES
413 )
414 );
415 }
416
417 evalPosition() {
418 let evaluation = super.evalPosition();
419 // Add reserves:
420 for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
421 const p = V.RESERVE_PIECES[i];
422 evaluation += this.reserve["w"][p] * V.VALUES[p];
423 evaluation -= this.reserve["b"][p] * V.VALUES[p];
424 }
425 return evaluation;
426 }
427
428 getNotation(move) {
429 if (move.vanish.length > 0) return super.getNotation(move);
430 // Rebirth:
431 const piece =
432 move.appear[0].p != V.PAWN ? move.appear[0].p.toUpperCase() : "";
433 return piece + "@" + V.CoordsToSquare(move.end);
434 }
435
436 };