Commit | Line | Data |
---|---|---|
cd49e617 BA |
1 | import { ChessRules, PiPo, Move } from "@/base_rules"; |
2 | import { ArrayFun } from "@/utils/array"; | |
b4f2488a | 3 | import { sample, shuffle } from "@/utils/alea"; |
cd49e617 BA |
4 | |
5 | export class ShogiRules extends ChessRules { | |
6 | static get HasFlags() { | |
7 | return false; | |
8 | } | |
9 | ||
10 | static get HasEnpassant() { | |
11 | return false; | |
12 | } | |
13 | ||
107dc1bd BA |
14 | static get Monochrome() { |
15 | return true; | |
16 | } | |
17 | ||
b4f2488a BA |
18 | static get Notoodark() { |
19 | return true; | |
20 | } | |
21 | ||
cd49e617 BA |
22 | static IsGoodFen(fen) { |
23 | if (!ChessRules.IsGoodFen(fen)) return false; | |
24 | const fenParsed = V.ParseFen(fen); | |
25 | // 3) Check reserves | |
26 | if (!fenParsed.reserve || !fenParsed.reserve.match(/^[0-9]{14,14}$/)) | |
27 | return false; | |
28 | return true; | |
29 | } | |
30 | ||
31 | static ParseFen(fen) { | |
32 | const fenParts = fen.split(" "); | |
33 | return Object.assign( | |
34 | ChessRules.ParseFen(fen), | |
35 | { reserve: fenParts[3] } | |
36 | ); | |
37 | } | |
38 | ||
39 | // pawns, rooks, knights, bishops and king kept from ChessRules | |
40 | static get GOLD_G() { | |
41 | return "g"; | |
42 | } | |
43 | static get SILVER_G() { | |
44 | return "s"; | |
45 | } | |
e2f204ed | 46 | static get LANCE() { |
cd49e617 BA |
47 | return "l"; |
48 | } | |
49 | ||
50 | // Promoted pieces: | |
51 | static get P_PAWN() { | |
52 | return 'q'; | |
53 | } | |
54 | static get P_KNIGHT() { | |
55 | return 'o'; | |
56 | } | |
57 | static get P_SILVER() { | |
58 | return 't'; | |
59 | } | |
e2f204ed | 60 | static get P_LANCE() { |
cd49e617 BA |
61 | return 'm'; |
62 | } | |
63 | static get P_ROOK() { | |
64 | return 'd'; | |
65 | } | |
66 | static get P_BISHOP() { | |
67 | return 'h'; | |
68 | } | |
69 | ||
70 | static get PIECES() { | |
71 | return [ | |
72 | ChessRules.PAWN, | |
73 | ChessRules.ROOK, | |
74 | ChessRules.KNIGHT, | |
75 | ChessRules.BISHOP, | |
76 | ChessRules.KING, | |
77 | V.GOLD_G, | |
78 | V.SILVER_G, | |
e2f204ed | 79 | V.LANCE, |
cd49e617 BA |
80 | V.P_PAWN, |
81 | V.P_KNIGHT, | |
82 | V.P_SILVER, | |
e2f204ed | 83 | V.P_LANCE, |
cd49e617 BA |
84 | V.P_ROOK, |
85 | V.P_BISHOP | |
86 | ]; | |
87 | } | |
88 | ||
89 | getPpath(b, color, score, orientation) { | |
90 | // 'i' for "inversed": | |
91 | const suffix = (b[0] == orientation ? "" : "i"); | |
92 | return "Shogi/" + b + suffix; | |
93 | } | |
94 | ||
95 | getPPpath(m, orientation) { | |
96 | return ( | |
97 | this.getPpath( | |
98 | m.appear[0].c + m.appear[0].p, | |
99 | null, | |
100 | null, | |
101 | orientation | |
102 | ) | |
103 | ); | |
104 | } | |
105 | ||
ad2494bd BA |
106 | static GenRandInitFen(randomness) { |
107 | if (randomness == 0) { | |
108 | return ( | |
109 | "lnsgkgsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL " + | |
110 | "w 0 00000000000000" | |
111 | ); | |
112 | } | |
b4f2488a BA |
113 | // Randomization following these indications: |
114 | // http://www.shogi.net/shogi-l/Archive/2007/Nmar16-02.txt | |
115 | let pieces1 = { w: new Array(4), b: new Array(4) }; | |
116 | let positions2 = { w: new Array(2), b: new Array(2) }; | |
ad2494bd BA |
117 | for (let c of ["w", "b"]) { |
118 | if (c == 'b' && randomness == 1) { | |
b4f2488a BA |
119 | pieces1['b'] = JSON.parse(JSON.stringify(pieces1['w'])).reverse(); |
120 | positions2['b'] = | |
121 | JSON.parse(JSON.stringify(positions2['w'])).reverse() | |
122 | .map(p => 8 - p); | |
ad2494bd BA |
123 | break; |
124 | } | |
b4f2488a BA |
125 | let positions = shuffle(ArrayFun.range(4)); |
126 | const composition = ['s', 's', 'g', 'g']; | |
127 | for (let i = 0; i < 4; i++) pieces1[c][positions[i]] = composition[i]; | |
128 | positions2[c] = sample(ArrayFun.range(9), 2).sort(); | |
ad2494bd | 129 | } |
cd49e617 | 130 | return ( |
b4f2488a BA |
131 | ( |
132 | "ln" + | |
133 | pieces1["b"].slice(0, 2).join("") + | |
134 | "k" + | |
135 | pieces1["b"].slice(2, 4).join("") + | |
136 | "nl/" | |
137 | ) + | |
138 | ( | |
139 | (positions2['b'][0] || "") + 'r' + | |
140 | (positions2['b'][1] - positions2['b'][0] - 1 || "") + 'b' + | |
141 | (8 - positions2['b'][1] || "") | |
142 | ) + | |
143 | "/ppppppppp/9/9/9/PPPPPPPPP/" + | |
144 | ( | |
145 | (positions2['w'][0] || "") + 'B' + | |
146 | (positions2['w'][1] - positions2['w'][0] - 1 || "") + 'R' + | |
147 | (8 - positions2['w'][1] || "") | |
148 | ) + | |
149 | ( | |
150 | "/LN" + | |
151 | pieces1["w"].slice(0, 2).join("").toUpperCase() + | |
152 | "K" + | |
153 | pieces1["w"].slice(2, 4).join("").toUpperCase() + | |
154 | "NL" | |
155 | ) + | |
ad2494bd | 156 | " w 0 00000000000000" |
cd49e617 BA |
157 | ); |
158 | } | |
159 | ||
160 | getFen() { | |
161 | return super.getFen() + " " + this.getReserveFen(); | |
162 | } | |
163 | ||
164 | getFenForRepeat() { | |
165 | return super.getFenForRepeat() + "_" + this.getReserveFen(); | |
166 | } | |
167 | ||
168 | getReserveFen() { | |
169 | let counts = new Array(14); | |
170 | for (let i = 0; i < V.RESERVE_PIECES.length; i++) { | |
171 | counts[i] = this.reserve["w"][V.RESERVE_PIECES[i]]; | |
edfb07b1 | 172 | counts[7 + i] = this.reserve["b"][V.RESERVE_PIECES[i]]; |
cd49e617 BA |
173 | } |
174 | return counts.join(""); | |
175 | } | |
176 | ||
177 | setOtherVariables(fen) { | |
178 | super.setOtherVariables(fen); | |
cd49e617 | 179 | // Also init reserves (used by the interface to show landable pieces) |
e50a8025 BA |
180 | const reserve = |
181 | V.ParseFen(fen).reserve.split("").map(x => parseInt(x, 10)); | |
cd49e617 BA |
182 | this.reserve = { |
183 | w: { | |
e50a8025 BA |
184 | [V.PAWN]: reserve[0], |
185 | [V.ROOK]: reserve[1], | |
186 | [V.BISHOP]: reserve[2], | |
187 | [V.GOLD_G]: reserve[3], | |
188 | [V.SILVER_G]: reserve[4], | |
189 | [V.KNIGHT]: reserve[5], | |
190 | [V.LANCE]: reserve[6] | |
cd49e617 BA |
191 | }, |
192 | b: { | |
e50a8025 BA |
193 | [V.PAWN]: reserve[7], |
194 | [V.ROOK]: reserve[8], | |
195 | [V.BISHOP]: reserve[9], | |
196 | [V.GOLD_G]: reserve[10], | |
197 | [V.SILVER_G]: reserve[11], | |
198 | [V.KNIGHT]: reserve[12], | |
199 | [V.LANCE]: reserve[13] | |
cd49e617 BA |
200 | } |
201 | }; | |
202 | } | |
203 | ||
204 | getColor(i, j) { | |
205 | if (i >= V.size.x) return i == V.size.x ? "w" : "b"; | |
206 | return this.board[i][j].charAt(0); | |
207 | } | |
208 | ||
209 | getPiece(i, j) { | |
210 | if (i >= V.size.x) return V.RESERVE_PIECES[j]; | |
211 | return this.board[i][j].charAt(1); | |
212 | } | |
213 | ||
214 | static get size() { | |
215 | return { x: 9, y: 9}; | |
216 | } | |
217 | ||
218 | getReservePpath(index, color, orientation) { | |
219 | return ( | |
220 | "Shogi/" + color + V.RESERVE_PIECES[index] + | |
221 | (color != orientation ? 'i' : '') | |
222 | ); | |
223 | } | |
224 | ||
225 | // Ordering on reserve pieces | |
226 | static get RESERVE_PIECES() { | |
227 | return ( | |
e2f204ed | 228 | [V.PAWN, V.ROOK, V.BISHOP, V.GOLD_G, V.SILVER_G, V.KNIGHT, V.LANCE] |
cd49e617 BA |
229 | ); |
230 | } | |
231 | ||
232 | getReserveMoves([x, y]) { | |
233 | const color = this.turn; | |
234 | const p = V.RESERVE_PIECES[y]; | |
235 | if (p == V.PAWN) { | |
236 | var oppCol = V.GetOppCol(color); | |
237 | var allowedFiles = | |
238 | [...Array(9).keys()].filter(j => | |
239 | [...Array(9).keys()].every(i => { | |
240 | return ( | |
241 | this.board[i][j] == V.EMPTY || | |
242 | this.getColor(i, j) != color || | |
243 | this.getPiece(i, j) != V.PAWN | |
244 | ); | |
245 | }) | |
246 | ) | |
247 | } | |
248 | if (this.reserve[color][p] == 0) return []; | |
249 | let moves = []; | |
250 | const forward = color == 'w' ? -1 : 1; | |
251 | const lastRanks = color == 'w' ? [0, 1] : [8, 7]; | |
252 | for (let i = 0; i < V.size.x; i++) { | |
253 | if ( | |
e2f204ed | 254 | (i == lastRanks[0] && [V.PAWN, V.KNIGHT, V.LANCE].includes(p)) || |
cd49e617 BA |
255 | (i == lastRanks[1] && p == V.KNIGHT) |
256 | ) { | |
257 | continue; | |
258 | } | |
259 | for (let j = 0; j < V.size.y; j++) { | |
260 | if ( | |
261 | this.board[i][j] == V.EMPTY && | |
262 | (p != V.PAWN || allowedFiles.includes(j)) | |
263 | ) { | |
264 | let mv = new Move({ | |
265 | appear: [ | |
266 | new PiPo({ | |
267 | x: i, | |
268 | y: j, | |
269 | c: color, | |
270 | p: p | |
271 | }) | |
272 | ], | |
273 | vanish: [], | |
274 | start: { x: x, y: y }, //a bit artificial... | |
275 | end: { x: i, y: j } | |
276 | }); | |
277 | if (p == V.PAWN) { | |
278 | // Do not drop on checkmate: | |
279 | this.play(mv); | |
280 | const res = (this.underCheck(oppCol) && !this.atLeastOneMove()); | |
281 | this.undo(mv); | |
282 | if (res) continue; | |
283 | } | |
284 | moves.push(mv); | |
285 | } | |
286 | } | |
287 | } | |
288 | return moves; | |
289 | } | |
290 | ||
291 | getPotentialMovesFrom([x, y]) { | |
292 | if (x >= V.size.x) { | |
293 | // Reserves, outside of board: x == sizeX(+1) | |
294 | return this.getReserveMoves([x, y]); | |
295 | } | |
296 | switch (this.getPiece(x, y)) { | |
297 | case V.PAWN: | |
298 | return this.getPotentialPawnMoves([x, y]); | |
299 | case V.ROOK: | |
300 | return this.getPotentialRookMoves([x, y]); | |
301 | case V.KNIGHT: | |
302 | return this.getPotentialKnightMoves([x, y]); | |
303 | case V.BISHOP: | |
304 | return this.getPotentialBishopMoves([x, y]); | |
305 | case V.SILVER_G: | |
306 | return this.getPotentialSilverMoves([x, y]); | |
e2f204ed BA |
307 | case V.LANCE: |
308 | return this.getPotentialLanceMoves([x, y]); | |
cd49e617 BA |
309 | case V.KING: |
310 | return this.getPotentialKingMoves([x, y]); | |
311 | case V.P_ROOK: | |
312 | return this.getPotentialDragonMoves([x, y]); | |
313 | case V.P_BISHOP: | |
314 | return this.getPotentialHorseMoves([x, y]); | |
315 | case V.GOLD_G: | |
316 | case V.P_PAWN: | |
317 | case V.P_SILVER: | |
318 | case V.P_KNIGHT: | |
e2f204ed | 319 | case V.P_LANCE: |
cd49e617 BA |
320 | return this.getPotentialGoldMoves([x, y]); |
321 | } | |
322 | return []; //never reached | |
323 | } | |
324 | ||
325 | // Modified to take promotions into account | |
326 | getSlideNJumpMoves([x, y], steps, options) { | |
118cff5c | 327 | options = options || {}; |
cd49e617 BA |
328 | const color = this.turn; |
329 | const oneStep = options.oneStep; | |
330 | const forcePromoteOnLastRank = options.force; | |
331 | const promoteInto = options.promote; | |
332 | const lastRanks = (color == 'w' ? [0, 1, 2] : [9, 8, 7]); | |
333 | let moves = []; | |
334 | outerLoop: for (let step of steps) { | |
335 | let i = x + step[0]; | |
336 | let j = y + step[1]; | |
337 | while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) { | |
338 | if (i != lastRanks[0] || !forcePromoteOnLastRank) | |
339 | moves.push(this.getBasicMove([x, y], [i, j])); | |
340 | if (!!promoteInto && lastRanks.includes(i)) { | |
341 | moves.push( | |
342 | this.getBasicMove( | |
343 | [x, y], [i, j], { c: color, p: promoteInto }) | |
344 | ); | |
345 | } | |
346 | if (oneStep) continue outerLoop; | |
347 | i += step[0]; | |
348 | j += step[1]; | |
349 | } | |
350 | if (V.OnBoard(i, j) && this.canTake([x, y], [i, j])) { | |
351 | if (i != lastRanks[0] || !forcePromoteOnLastRank) | |
352 | moves.push(this.getBasicMove([x, y], [i, j])); | |
353 | if (!!promoteInto && lastRanks.includes(i)) { | |
354 | moves.push( | |
355 | this.getBasicMove( | |
356 | [x, y], [i, j], { c: color, p: promoteInto }) | |
357 | ); | |
358 | } | |
359 | } | |
360 | } | |
361 | return moves; | |
362 | } | |
363 | ||
364 | getPotentialGoldMoves(sq) { | |
365 | const forward = (this.turn == 'w' ? -1 : 1); | |
366 | return this.getSlideNJumpMoves( | |
367 | sq, | |
368 | V.steps[V.ROOK].concat([ [forward, 1], [forward, -1] ]), | |
369 | { oneStep: true } | |
370 | ); | |
371 | } | |
372 | ||
373 | getPotentialPawnMoves(sq) { | |
374 | const forward = (this.turn == 'w' ? -1 : 1); | |
375 | return ( | |
376 | this.getSlideNJumpMoves( | |
377 | sq, | |
378 | [[forward, 0]], | |
379 | { | |
380 | oneStep: true, | |
381 | promote: V.P_PAWN, | |
382 | force: true | |
383 | } | |
384 | ) | |
385 | ); | |
386 | } | |
387 | ||
388 | getPotentialSilverMoves(sq) { | |
389 | const forward = (this.turn == 'w' ? -1 : 1); | |
390 | return this.getSlideNJumpMoves( | |
391 | sq, | |
392 | V.steps[V.BISHOP].concat([ [forward, 0] ]), | |
393 | { | |
394 | oneStep: true, | |
395 | promote: V.P_SILVER | |
396 | } | |
397 | ); | |
398 | } | |
399 | ||
400 | getPotentialKnightMoves(sq) { | |
401 | const forward = (this.turn == 'w' ? -2 : 2); | |
402 | return this.getSlideNJumpMoves( | |
403 | sq, | |
404 | [ [forward, 1], [forward, -1] ], | |
405 | { | |
406 | oneStep: true, | |
407 | promote: V.P_KNIGHT, | |
408 | force: true | |
409 | } | |
410 | ); | |
411 | } | |
412 | ||
6c7cbfed BA |
413 | getPotentialLanceMoves(sq) { |
414 | const forward = (this.turn == 'w' ? -1 : 1); | |
415 | return this.getSlideNJumpMoves( | |
416 | sq, | |
417 | [[forward, 0]], | |
418 | { | |
419 | promote: V.P_LANCE, | |
420 | force: true | |
421 | } | |
422 | ); | |
423 | } | |
424 | ||
cd49e617 BA |
425 | getPotentialRookMoves(sq) { |
426 | return this.getSlideNJumpMoves( | |
427 | sq, V.steps[V.ROOK], { promote: V.P_ROOK }); | |
428 | } | |
429 | ||
430 | getPotentialBishopMoves(sq) { | |
431 | return this.getSlideNJumpMoves( | |
432 | sq, V.steps[V.BISHOP], { promote: V.P_BISHOP }); | |
433 | } | |
434 | ||
cd49e617 BA |
435 | getPotentialDragonMoves(sq) { |
436 | return ( | |
437 | this.getSlideNJumpMoves(sq, V.steps[V.ROOK]).concat( | |
438 | this.getSlideNJumpMoves(sq, V.steps[V.BISHOP], { oneStep: true })) | |
439 | ); | |
440 | } | |
441 | ||
442 | getPotentialHorseMoves(sq) { | |
443 | return ( | |
444 | this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]).concat( | |
445 | this.getSlideNJumpMoves(sq, V.steps[V.ROOK], { oneStep: true })) | |
446 | ); | |
447 | } | |
448 | ||
449 | getPotentialKingMoves(sq) { | |
450 | return this.getSlideNJumpMoves( | |
451 | sq, | |
452 | V.steps[V.ROOK].concat(V.steps[V.BISHOP]), | |
453 | { oneStep: true } | |
454 | ); | |
455 | } | |
456 | ||
457 | isAttacked(sq, color) { | |
458 | return ( | |
459 | this.isAttackedByPawn(sq, color) || | |
460 | this.isAttackedByRook(sq, color) || | |
461 | this.isAttackedByDragon(sq, color) || | |
462 | this.isAttackedByKnight(sq, color) || | |
463 | this.isAttackedByBishop(sq, color) || | |
464 | this.isAttackedByHorse(sq, color) || | |
e2f204ed | 465 | this.isAttackedByLance(sq, color) || |
cd49e617 BA |
466 | this.isAttackedBySilver(sq, color) || |
467 | this.isAttackedByGold(sq, color) || | |
468 | this.isAttackedByKing(sq, color) | |
469 | ); | |
470 | } | |
471 | ||
472 | isAttackedByGold([x, y], color) { | |
473 | const shift = (color == 'w' ? 1 : -1); | |
474 | for (let step of V.steps[V.ROOK].concat([[shift, 1], [shift, -1]])) { | |
475 | const [i, j] = [x + step[0], y + step[1]]; | |
476 | if ( | |
477 | V.OnBoard(i, j) && | |
478 | this.board[i][j] != V.EMPTY && | |
479 | this.getColor(i, j) == color && | |
e2f204ed | 480 | [V.GOLD_G, V.P_PAWN, V.P_SILVER, V.P_KNIGHT, V.P_LANCE] |
cd49e617 BA |
481 | .includes(this.getPiece(i, j)) |
482 | ) { | |
483 | return true; | |
484 | } | |
485 | } | |
486 | return false; | |
487 | } | |
488 | ||
489 | isAttackedBySilver([x, y], color) { | |
490 | const shift = (color == 'w' ? 1 : -1); | |
491 | for (let step of V.steps[V.BISHOP].concat([[shift, 0]])) { | |
492 | const [i, j] = [x + step[0], y + step[1]]; | |
493 | if ( | |
494 | V.OnBoard(i, j) && | |
495 | this.board[i][j] != V.EMPTY && | |
496 | this.getColor(i, j) == color && | |
497 | this.getPiece(i, j) == V.SILVER_G | |
498 | ) { | |
499 | return true; | |
500 | } | |
501 | } | |
502 | return false; | |
503 | } | |
504 | ||
505 | isAttackedByPawn([x, y], color) { | |
506 | const shift = (color == 'w' ? 1 : -1); | |
507 | const [i, j] = [x + shift, y]; | |
508 | return ( | |
509 | V.OnBoard(i, j) && | |
510 | this.board[i][j] != V.EMPTY && | |
511 | this.getColor(i, j) == color && | |
512 | this.getPiece(i, j) == V.PAWN | |
513 | ); | |
514 | } | |
515 | ||
516 | isAttackedByKnight(sq, color) { | |
517 | const forward = (color == 'w' ? 2 : -2); | |
518 | return this.isAttackedBySlideNJump( | |
519 | sq, color, V.KNIGHT, [[forward, 1], [forward, -1]], "oneStep"); | |
520 | } | |
521 | ||
e2f204ed | 522 | isAttackedByLance(sq, color) { |
cd49e617 | 523 | const forward = (color == 'w' ? 1 : -1); |
e2f204ed | 524 | return this.isAttackedBySlideNJump(sq, color, V.LANCE, [[forward, 0]]); |
cd49e617 BA |
525 | } |
526 | ||
527 | isAttackedByDragon(sq, color) { | |
528 | return ( | |
529 | this.isAttackedBySlideNJump(sq, color, V.P_ROOK, V.steps[V.ROOK]) || | |
530 | this.isAttackedBySlideNJump( | |
edfb07b1 | 531 | sq, color, V.P_ROOK, V.steps[V.BISHOP], "oneStep") |
cd49e617 BA |
532 | ); |
533 | } | |
534 | ||
535 | isAttackedByHorse(sq, color) { | |
536 | return ( | |
537 | this.isAttackedBySlideNJump(sq, color, V.P_BISHOP, V.steps[V.BISHOP]) || | |
538 | this.isAttackedBySlideNJump( | |
edfb07b1 | 539 | sq, color, V.P_BISHOP, V.steps[V.ROOK], "oneStep") |
cd49e617 BA |
540 | ); |
541 | } | |
542 | ||
543 | getAllValidMoves() { | |
544 | let moves = super.getAllPotentialMoves(); | |
545 | const color = this.turn; | |
546 | for (let i = 0; i < V.RESERVE_PIECES.length; i++) { | |
547 | moves = moves.concat( | |
548 | this.getReserveMoves([V.size.x + (color == "w" ? 0 : 1), i]) | |
549 | ); | |
550 | } | |
551 | return this.filterValid(moves); | |
552 | } | |
553 | ||
554 | atLeastOneMove() { | |
555 | if (!super.atLeastOneMove()) { | |
556 | // Search one reserve move | |
557 | for (let i = 0; i < V.RESERVE_PIECES.length; i++) { | |
558 | let moves = this.filterValid( | |
559 | this.getReserveMoves([V.size.x + (this.turn == "w" ? 0 : 1), i]) | |
560 | ); | |
561 | if (moves.length > 0) return true; | |
562 | } | |
563 | return false; | |
564 | } | |
565 | return true; | |
566 | } | |
567 | ||
568 | static get P_CORRESPONDANCES() { | |
569 | return { | |
570 | q: 'p', | |
571 | o: 'n', | |
572 | t: 's', | |
573 | m: 'l', | |
574 | d: 'r', | |
575 | h: 'b' | |
576 | }; | |
577 | } | |
578 | ||
579 | static MayDecode(piece) { | |
580 | if (Object.keys(V.P_CORRESPONDANCES).includes(piece)) | |
581 | return V.P_CORRESPONDANCES[piece]; | |
582 | return piece; | |
583 | } | |
584 | ||
585 | postPlay(move) { | |
586 | super.postPlay(move); | |
587 | const color = move.appear[0].c; | |
588 | if (move.vanish.length == 0) | |
589 | // Drop unpromoted piece: | |
590 | this.reserve[color][move.appear[0].p]--; | |
591 | else if (move.vanish.length == 2) | |
592 | // May capture a promoted piece: | |
593 | this.reserve[color][V.MayDecode(move.vanish[1].p)]++; | |
594 | } | |
595 | ||
596 | postUndo(move) { | |
597 | super.postUndo(move); | |
598 | const color = this.turn; | |
599 | if (move.vanish.length == 0) | |
600 | this.reserve[color][move.appear[0].p]++; | |
601 | else if (move.vanish.length == 2) | |
602 | this.reserve[color][V.MayDecode(move.vanish[1].p)]--; | |
603 | } | |
604 | ||
605 | static get SEARCH_DEPTH() { | |
606 | return 2; | |
607 | } | |
608 | ||
609 | static get VALUES() { | |
610 | // TODO: very arbitrary and wrong | |
611 | return { | |
612 | p: 1, | |
613 | q: 3, | |
614 | r: 5, | |
615 | d: 6, | |
616 | n: 2, | |
617 | o: 3, | |
618 | b: 3, | |
619 | h: 4, | |
620 | s: 3, | |
621 | t: 3, | |
622 | l: 2, | |
623 | m: 3, | |
624 | g: 3, | |
625 | k: 1000, | |
626 | } | |
627 | } | |
628 | ||
629 | evalPosition() { | |
630 | let evaluation = super.evalPosition(); | |
631 | // Add reserves: | |
632 | for (let i = 0; i < V.RESERVE_PIECES.length; i++) { | |
633 | const p = V.RESERVE_PIECES[i]; | |
634 | evaluation += this.reserve["w"][p] * V.VALUES[p]; | |
635 | evaluation -= this.reserve["b"][p] * V.VALUES[p]; | |
636 | } | |
637 | return evaluation; | |
638 | } | |
639 | ||
640 | getNotation(move) { | |
641 | const finalSquare = V.CoordsToSquare(move.end); | |
642 | if (move.vanish.length == 0) { | |
643 | // Rebirth: | |
644 | const piece = move.appear[0].p.toUpperCase(); | |
645 | return (piece != 'P' ? piece : "") + "@" + finalSquare; | |
646 | } | |
647 | const piece = move.vanish[0].p.toUpperCase(); | |
648 | return ( | |
649 | (piece != 'P' || move.vanish.length == 2 ? piece : "") + | |
650 | (move.vanish.length == 2 ? "x" : "") + | |
651 | finalSquare + | |
652 | ( | |
653 | move.appear[0].p != move.vanish[0].p | |
654 | ? "=" + move.appear[0].p.toUpperCase() | |
655 | : "" | |
656 | ) | |
657 | ); | |
658 | } | |
659 | }; |