Eightpieces almost ready
[vchess.git] / client / src / variants / Crazyhouse.js
1 import { ChessRules, PiPo, Move } from "@/base_rules";
2 import { ArrayFun } from "@/utils/array";
3
4 export const VariantRules = class CrazyhouseRules extends ChessRules {
5 static IsGoodFen(fen) {
6 if (!ChessRules.IsGoodFen(fen)) return false;
7 const fenParsed = V.ParseFen(fen);
8 // 5) Check reserves
9 if (!fenParsed.reserve || !fenParsed.reserve.match(/^[0-9]{10,10}$/))
10 return false;
11 // 6) Check promoted array
12 if (!fenParsed.promoted) return false;
13 if (fenParsed.promoted == "-") return true; //no promoted piece on board
14 const squares = fenParsed.promoted.split(",");
15 for (let square of squares) {
16 const c = V.SquareToCoords(square);
17 if (c.y < 0 || c.y > V.size.y || isNaN(c.x) || c.x < 0 || c.x > V.size.x)
18 return false;
19 }
20 return true;
21 }
22
23 static ParseFen(fen) {
24 const fenParts = fen.split(" ");
25 return Object.assign(ChessRules.ParseFen(fen), {
26 reserve: fenParts[5],
27 promoted: fenParts[6]
28 });
29 }
30
31 getEpSquare(moveOrSquare) {
32 if (typeof moveOrSquare !== "object" || moveOrSquare.vanish.length > 0)
33 return super.getEpSquare(moveOrSquare);
34 // Landing move: no en-passant
35 return undefined;
36 }
37
38 static GenRandInitFen(randomness) {
39 return ChessRules.GenRandInitFen(randomness) + " 0000000000 -";
40 }
41
42 getFen() {
43 return (
44 super.getFen() + " " +
45 this.getReserveFen() + " " +
46 this.getPromotedFen()
47 );
48 }
49
50 getFenForRepeat() {
51 return (
52 super.getFenForRepeat() + "_" +
53 this.getReserveFen() + "_" +
54 this.getPromotedFen()
55 );
56 }
57
58 getReserveFen() {
59 let counts = new Array(10);
60 for (
61 let i = 0;
62 i < V.PIECES.length - 1;
63 i++ //-1: no king reserve
64 ) {
65 counts[i] = this.reserve["w"][V.PIECES[i]];
66 counts[5 + i] = this.reserve["b"][V.PIECES[i]];
67 }
68 return counts.join("");
69 }
70
71 getPromotedFen() {
72 let res = "";
73 for (let i = 0; i < V.size.x; i++) {
74 for (let j = 0; j < V.size.y; j++) {
75 if (this.promoted[i][j]) res += V.CoordsToSquare({ x: i, y: j }) + ",";
76 }
77 }
78 // Remove last comma:
79 if (res.length > 0) res = res.slice(0, -1);
80 else res = "-";
81 return res;
82 }
83
84 setOtherVariables(fen) {
85 super.setOtherVariables(fen);
86 const fenParsed = V.ParseFen(fen);
87 // Also init reserves (used by the interface to show landable pieces)
88 this.reserve = {
89 w: {
90 [V.PAWN]: parseInt(fenParsed.reserve[0]),
91 [V.ROOK]: parseInt(fenParsed.reserve[1]),
92 [V.KNIGHT]: parseInt(fenParsed.reserve[2]),
93 [V.BISHOP]: parseInt(fenParsed.reserve[3]),
94 [V.QUEEN]: parseInt(fenParsed.reserve[4])
95 },
96 b: {
97 [V.PAWN]: parseInt(fenParsed.reserve[5]),
98 [V.ROOK]: parseInt(fenParsed.reserve[6]),
99 [V.KNIGHT]: parseInt(fenParsed.reserve[7]),
100 [V.BISHOP]: parseInt(fenParsed.reserve[8]),
101 [V.QUEEN]: parseInt(fenParsed.reserve[9])
102 }
103 };
104 this.promoted = ArrayFun.init(V.size.x, V.size.y, false);
105 if (fenParsed.promoted != "-") {
106 for (let square of fenParsed.promoted.split(",")) {
107 const coords = V.SquareToCoords(square);
108 this.promoted[coords.x][coords.y] = true;
109 }
110 }
111 }
112
113 getColor(i, j) {
114 if (i >= V.size.x) return i == V.size.x ? "w" : "b";
115 return this.board[i][j].charAt(0);
116 }
117
118 getPiece(i, j) {
119 if (i >= V.size.x) return V.RESERVE_PIECES[j];
120 return this.board[i][j].charAt(1);
121 }
122
123 // Used by the interface:
124 getReservePpath(index, color) {
125 return color + V.RESERVE_PIECES[index];
126 }
127 // // Version if some day I have pieces with numbers printed on it:
128 // getReservePpath(index, color) {
129 // return (
130 // "Crazyhouse/" +
131 // color + V.RESERVE_PIECES[index] +
132 // "_" + this.vr.reserve[playingColor][V.RESERVE_PIECES[i]]
133 // );
134 // }
135
136 // Ordering on reserve pieces
137 static get RESERVE_PIECES() {
138 return [V.PAWN, V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN];
139 }
140
141 getReserveMoves([x, y]) {
142 const color = this.turn;
143 const p = V.RESERVE_PIECES[y];
144 if (this.reserve[color][p] == 0) return [];
145 let moves = [];
146 const pawnShift = p == V.PAWN ? 1 : 0;
147 for (let i = pawnShift; i < V.size.x - pawnShift; i++) {
148 for (let j = 0; j < V.size.y; j++) {
149 if (this.board[i][j] == V.EMPTY) {
150 let mv = new Move({
151 appear: [
152 new PiPo({
153 x: i,
154 y: j,
155 c: color,
156 p: p
157 })
158 ],
159 vanish: [],
160 start: { x: x, y: y }, //a bit artificial...
161 end: { x: i, y: j }
162 });
163 moves.push(mv);
164 }
165 }
166 }
167 return moves;
168 }
169
170 getPotentialMovesFrom([x, y]) {
171 if (x >= V.size.x) {
172 // Reserves, outside of board: x == sizeX(+1)
173 return this.getReserveMoves([x, y]);
174 }
175 // Standard moves
176 return super.getPotentialMovesFrom([x, y]);
177 }
178
179 getAllValidMoves() {
180 let moves = super.getAllValidMoves();
181 const color = this.turn;
182 for (let i = 0; i < V.RESERVE_PIECES.length; i++)
183 moves = moves.concat(
184 this.getReserveMoves([V.size.x + (color == "w" ? 0 : 1), i])
185 );
186 return this.filterValid(moves);
187 }
188
189 atLeastOneMove() {
190 if (!super.atLeastOneMove()) {
191 // Search one reserve move
192 for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
193 let moves = this.filterValid(
194 this.getReserveMoves([V.size.x + (this.turn == "w" ? 0 : 1), i])
195 );
196 if (moves.length > 0) return true;
197 }
198 return false;
199 }
200 return true;
201 }
202
203 updateVariables(move) {
204 super.updateVariables(move);
205 if (move.vanish.length == 2 && move.appear.length == 2) return; //skip castle
206 const color = move.appear[0].c;
207 if (move.vanish.length == 0) {
208 this.reserve[color][move.appear[0].p]--;
209 return;
210 }
211 move.movePromoted = this.promoted[move.start.x][move.start.y];
212 move.capturePromoted = this.promoted[move.end.x][move.end.y];
213 this.promoted[move.start.x][move.start.y] = false;
214 this.promoted[move.end.x][move.end.y] =
215 move.movePromoted ||
216 (move.vanish[0].p == V.PAWN && move.appear[0].p != V.PAWN);
217 if (move.capturePromoted) this.reserve[color][V.PAWN]++;
218 else if (move.vanish.length == 2) this.reserve[color][move.vanish[1].p]++;
219 }
220
221 unupdateVariables(move) {
222 super.unupdateVariables(move);
223 if (move.vanish.length == 2 && move.appear.length == 2) return;
224 const color = this.turn;
225 if (move.vanish.length == 0) {
226 this.reserve[color][move.appear[0].p]++;
227 return;
228 }
229 if (move.movePromoted) this.promoted[move.start.x][move.start.y] = true;
230 this.promoted[move.end.x][move.end.y] = move.capturePromoted;
231 if (move.capturePromoted) this.reserve[color][V.PAWN]--;
232 else if (move.vanish.length == 2) this.reserve[color][move.vanish[1].p]--;
233 }
234
235 static get SEARCH_DEPTH() {
236 return 2;
237 }
238
239 evalPosition() {
240 let evaluation = super.evalPosition();
241 // Add reserves:
242 for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
243 const p = V.RESERVE_PIECES[i];
244 evaluation += this.reserve["w"][p] * V.VALUES[p];
245 evaluation -= this.reserve["b"][p] * V.VALUES[p];
246 }
247 return evaluation;
248 }
249
250 getNotation(move) {
251 if (move.vanish.length > 0) return super.getNotation(move);
252 // Rebirth:
253 const piece =
254 move.appear[0].p != V.PAWN ? move.appear[0].p.toUpperCase() : "";
255 return piece + "@" + V.CoordsToSquare(move.end);
256 }
257 };