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