Commit | Line | Data |
---|---|---|
32cfcea4 BA |
1 | class UltimaRules extends ChessRules |
2 | { | |
2eef6db6 BA |
3 | static getPpath(b) |
4 | { | |
5 | if (b[1] == "m") //'m' for Immobilizer (I is too similar to 1) | |
6 | return "Ultima/" + b; | |
7 | return b; //usual piece | |
8 | } | |
32cfcea4 | 9 | |
2eef6db6 BA |
10 | initVariables(fen) |
11 | { | |
12 | this.kingPos = {'w':[-1,-1], 'b':[-1,-1]}; | |
13 | const fenParts = fen.split(" "); | |
14 | const position = fenParts[0].split("/"); | |
15 | for (let i=0; i<position.length; i++) | |
16 | { | |
17 | let k = 0; | |
18 | for (let j=0; j<position[i].length; j++) | |
19 | { | |
20 | switch (position[i].charAt(j)) | |
21 | { | |
22 | case 'k': | |
23 | this.kingPos['b'] = [i,k]; | |
24 | break; | |
25 | case 'K': | |
26 | this.kingPos['w'] = [i,k]; | |
27 | break; | |
28 | default: | |
29 | let num = parseInt(position[i].charAt(j)); | |
30 | if (!isNaN(num)) | |
31 | k += (num-1); | |
32 | } | |
33 | k++; | |
34 | } | |
35 | } | |
36 | this.epSquares = []; //no en-passant here | |
37 | } | |
38 | ||
39 | setFlags(fen) | |
40 | { | |
41 | // TODO: for compatibility? | |
42 | this.castleFlags = {"w":[false,false], "b":[false,false]}; | |
43 | } | |
44 | ||
45 | static get IMMOBILIZER() { return 'm'; } | |
46 | // Although other pieces keep their names here for coding simplicity, | |
47 | // keep in mind that: | |
48 | // - a "rook" is a coordinator, capturing by coordinating with the king | |
49 | // - a "knight" is a long-leaper, capturing as in draughts | |
50 | // - a "bishop" is a chameleon, capturing as its prey | |
51 | // - a "queen" is a withdrawer, capturing by moving away from pieces | |
52 | ||
53 | getPotentialMovesFrom([x,y]) | |
54 | { | |
7688bf77 BA |
55 | // Pre-check: is thing on this square immobilized? |
56 | // In this case add potential suicide as a move "taking the immobilizer" | |
57 | const piece = this.getPiece(x,y); | |
58 | const color = this.getColor(x,y); | |
59 | const oppCol = this.getOppCol(color); | |
60 | const V = VariantRules; | |
61 | const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]); | |
62 | const [sizeX,sizeY] = V.size; | |
63 | for (let step of adjacentSteps) | |
64 | { | |
65 | const [i,j] = [x+step[0],y+step[1]]; | |
66 | if (i>=0 && i<sizeX && j>=0 && j<sizeY && this.board[i][j] != V.EMPTY | |
67 | && this.getColor(i,j) == oppCol) | |
68 | { | |
69 | const oppPiece = this.getPiece(i,j); | |
70 | if (oppPiece == V.IMMOBILIZER | |
71 | || (oppPiece == V.BISHOP && piece == V.IMMOBILIZER)) | |
72 | { | |
73 | return [ new Move({ | |
74 | appear: [], | |
a3c86ec9 | 75 | vanish: [new PiPo({x:x,y:y,p:piece,c:color})], |
7688bf77 BA |
76 | start: {x:x,y:y}, |
77 | end: {x:i,y:j} | |
78 | }) ]; | |
79 | } | |
80 | } | |
81 | } | |
2eef6db6 BA |
82 | switch (this.getPiece(x,y)) |
83 | { | |
84 | case VariantRules.IMMOBILIZER: | |
85 | return this.getPotentialImmobilizerMoves([x,y]); | |
86 | default: | |
87 | return super.getPotentialMovesFrom([x,y]); | |
88 | } | |
2eef6db6 BA |
89 | } |
90 | ||
91 | getSlideNJumpMoves([x,y], steps, oneStep) | |
92 | { | |
93 | const color = this.getColor(x,y); | |
94 | const piece = this.getPiece(x,y); | |
95 | let moves = []; | |
96 | const [sizeX,sizeY] = VariantRules.size; | |
97 | outerLoop: | |
98 | for (let step of steps) | |
99 | { | |
100 | let i = x + step[0]; | |
101 | let j = y + step[1]; | |
102 | while (i>=0 && i<sizeX && j>=0 && j<sizeY | |
103 | && this.board[i][j] == VariantRules.EMPTY) | |
104 | { | |
105 | moves.push(this.getBasicMove([x,y], [i,j])); | |
106 | if (oneStep !== undefined) | |
107 | continue outerLoop; | |
108 | i += step[0]; | |
109 | j += step[1]; | |
110 | } | |
111 | // Only king can take on occupied square: | |
112 | if (piece==VariantRules.KING && i>=0 && i<sizeX && j>=0 | |
113 | && j<sizeY && this.canTake([x,y], [i,j])) | |
114 | { | |
115 | moves.push(this.getBasicMove([x,y], [i,j])); | |
116 | } | |
117 | } | |
118 | return moves; | |
119 | } | |
120 | ||
a3c86ec9 BA |
121 | // Modify capturing moves among listed pawn moves |
122 | addPawnCaptures(moves, byChameleon) | |
123 | { | |
124 | const steps = VariantRules.steps[VariantRules.ROOK]; | |
125 | const [sizeX,sizeY] = VariantRules.size; | |
126 | const color = this.turn; | |
127 | const oppCol = this.getOppCol(color); | |
128 | moves.forEach(m => { | |
129 | if (!!byChameleon && m.start.x!=m.end.x && m.start.y!=m.end.y) | |
130 | return; //chameleon not moving as pawn | |
131 | // Try capturing in every direction | |
132 | for (let step of steps) | |
133 | { | |
134 | const sq2 = [m.end.x+2*step[0],m.end.y+2*step[1]]; | |
135 | if (sq2[0]>=0 && sq2[0]<sizeX && sq2[1]>=0 && sq2[1]<sizeY | |
136 | && this.board[sq2[0]][sq2[1]] != VariantRules.EMPTY | |
137 | && this.getColor(sq2[0],sq2[1]) == color) | |
138 | { | |
139 | // Potential capture | |
140 | const sq1 = [m.end.x+step[0],m.end.y+step[1]]; | |
141 | if (this.board[sq1[0]][sq1[1]] != VariantRules.EMPTY | |
142 | && this.getColor(sq1[0],sq1[1]) == oppCol) | |
143 | { | |
144 | const piece1 = this.getPiece(sq1[0],sq1[1]); | |
145 | if (!byChameleon || piece1 == VariantRules.PAWN) | |
146 | { | |
147 | m.vanish.push(new PiPo({ | |
148 | x:sq1[0], | |
149 | y:sq1[1], | |
150 | c:oppCol, | |
151 | p:piece1 | |
152 | })); | |
153 | } | |
154 | } | |
155 | } | |
156 | } | |
157 | }); | |
158 | } | |
159 | ||
7688bf77 | 160 | // "Pincher" |
2eef6db6 BA |
161 | getPotentialPawnMoves([x,y]) |
162 | { | |
7688bf77 | 163 | let moves = super.getPotentialRookMoves([x,y]); |
a3c86ec9 BA |
164 | this.addPawnCaptures(moves); |
165 | return moves; | |
2eef6db6 BA |
166 | } |
167 | ||
a3c86ec9 | 168 | addRookCaptures(moves, byChameleon) |
2eef6db6 | 169 | { |
a3c86ec9 | 170 | const color = this.turn; |
7688bf77 BA |
171 | const oppCol = this.getOppCol(color); |
172 | const kp = this.kingPos[color]; | |
7688bf77 BA |
173 | moves.forEach(m => { |
174 | // Check piece-king rectangle (if any) corners for enemy pieces | |
175 | if (m.end.x == kp[0] || m.end.y == kp[1]) | |
176 | return; //"flat rectangle" | |
177 | const corner1 = [Math.max(m.end.x,kp[0]), Math.min(m.end.y,kp[1])]; | |
178 | const corner2 = [Math.min(m.end.x,kp[0]), Math.max(m.end.y,kp[1])]; | |
179 | for (let [i,j] of [corner1,corner2]) | |
180 | { | |
181 | if (this.board[i][j] != VariantRules.EMPTY && this.getColor(i,j) == oppCol) | |
182 | { | |
a3c86ec9 BA |
183 | const piece = this.getPiece(i,j); |
184 | if (!byChameleon || piece == VariantRules.ROOK) | |
185 | { | |
186 | m.vanish.push( new PiPo({ | |
187 | x:i, | |
188 | y:j, | |
189 | p:piece, | |
190 | c:oppCol | |
191 | }) ); | |
192 | } | |
7688bf77 BA |
193 | } |
194 | } | |
195 | }); | |
a3c86ec9 BA |
196 | } |
197 | ||
198 | // Coordinator | |
199 | getPotentialRookMoves(sq) | |
200 | { | |
201 | let moves = super.getPotentialQueenMoves(sq); | |
202 | this.addRookCaptures(moves); | |
7688bf77 | 203 | return moves; |
2eef6db6 BA |
204 | } |
205 | ||
7688bf77 | 206 | // Long-leaper |
a3c86ec9 | 207 | getKnightCaptures(startSquare, byChameleon) |
2eef6db6 | 208 | { |
7688bf77 BA |
209 | // Look in every direction for captures |
210 | const V = VariantRules; | |
211 | const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]); | |
212 | const [sizeX,sizeY] = V.size; | |
a3c86ec9 BA |
213 | const color = this.turn; |
214 | const oppCol = this.getOppCol(color); | |
215 | let moves = []; | |
216 | const [x,y] = [startSquare[0],startSquare[1]]; | |
217 | const piece = this.getPiece(x,y); //might be a chameleon! | |
218 | outerLoop: | |
7688bf77 BA |
219 | for (let step of steps) |
220 | { | |
221 | let [i,j] = [x+step[0], y+step[1]]; | |
222 | while (i>=0 && i<sizeX && j>=0 && j<sizeY && this.board[i][j]==V.EMPTY) | |
223 | { | |
224 | i += step[0]; | |
225 | j += step[1]; | |
226 | } | |
a3c86ec9 BA |
227 | if (i<0 || i>=sizeX || j<0 || j>=sizeY || this.getColor(i,j)==color |
228 | || (!!byChameleon && this.getPiece(i,j)!=V.KNIGHT)) | |
229 | { | |
7688bf77 | 230 | continue; |
a3c86ec9 BA |
231 | } |
232 | // last(thing), cur(thing) : stop if "cur" is our color, or beyond board limits, | |
233 | // or if "last" isn't empty and cur neither. Otherwise, if cur is empty then | |
234 | // add move until cur square; if cur is occupied then stop if !!byChameleon and | |
235 | // the square not occupied by a leaper. | |
236 | let last = [i,j]; | |
237 | let cur = [i+step[0],j+step[1]]; | |
238 | let vanished = [ new PiPo({x:x,y:y,c:color,p:piece}) ]; | |
239 | while (cur[0]>=0 && cur[0]<sizeX && cur[1]>=0 && cur[1]<sizeY) | |
240 | { | |
241 | if (this.board[last[0]][last[1]] != V.EMPTY) | |
242 | { | |
243 | const oppPiece = this.getPiece(last[0],last[1]); | |
244 | if (!!byChameleon && oppPiece != V.KNIGHT) | |
245 | continue outerLoop; | |
246 | // Something to eat: | |
247 | vanished.push( new PiPo({x:last[0],y:last[1],c:oppCol,p:oppPiece}) ); | |
248 | } | |
249 | if (this.board[cur[0]][cur[1]] != V.EMPTY) | |
250 | { | |
251 | if (this.getColor(cur[0],cur[1]) == color | |
252 | || this.board[last[0]][last[1]] != V.EMPTY) //TODO: redundant test | |
253 | { | |
254 | continue outerLoop; | |
255 | } | |
256 | } | |
257 | else | |
258 | { | |
259 | moves.push(new Move({ | |
260 | appear: [ new PiPo({x:cur[0],y:cur[1],c:color,p:piece}) ], | |
261 | vanish: JSON.parse(JSON.stringify(vanished)), //TODO: required? | |
262 | start: {x:x,y:y}, | |
263 | end: {x:cur[0],y:cur[1]} | |
264 | })); | |
265 | } | |
266 | last = [last[0]+step[0],last[1]+step[1]]; | |
267 | cur = [cur[0]+step[0],cur[1]+step[1]]; | |
268 | } | |
7688bf77 BA |
269 | } |
270 | return moves; | |
2eef6db6 BA |
271 | } |
272 | ||
a3c86ec9 BA |
273 | // Long-leaper |
274 | getPotentialKnightMoves(sq) | |
275 | { | |
276 | return super.getPotentialQueenMoves(sq).concat(this.getKnightCaptures(sq)); | |
277 | } | |
278 | ||
c28265aa | 279 | getPotentialBishopMoves([x,y]) |
2eef6db6 | 280 | { |
c28265aa BA |
281 | let moves = super.getPotentialQueenMoves([x,y]) |
282 | .concat(this.getKnightCaptures([x,y],"asChameleon")); | |
a3c86ec9 BA |
283 | this.addPawnCaptures(moves, "asChameleon"); |
284 | this.addRookCaptures(moves, "asChameleon"); | |
285 | this.addQueenCaptures(moves, "asChameleon"); | |
c28265aa BA |
286 | // Add king capture if it's within range |
287 | const oppKp = this.kingPos[this.getOppCol(this.turn)]; | |
288 | if (Math.abs(x-oppKp[0]) <= 1 && Math.abs(y-oppKp[1]) <= 1) | |
289 | moves.push(this.getBasicMove([x,y],oppKp)); | |
a3c86ec9 BA |
290 | // Post-processing: merge similar moves, concatenating vanish arrays |
291 | let mergedMoves = {}; | |
292 | const [sizeX,sizeY] = VariantRules.size; | |
293 | moves.forEach(m => { | |
294 | const key = m.end.x + sizeX * m.end.y; | |
295 | if (!mergedMoves[key]) | |
296 | mergedMoves[key] = m; | |
297 | else | |
298 | { | |
299 | for (let i=1; i<m.vanish.length; i++) | |
300 | mergedMoves[key].vanish.push(m.vanish[i]); | |
301 | } | |
302 | }); | |
303 | // Finally return an array | |
304 | moves = []; | |
305 | Object.keys(mergedMoves).forEach(k => { moves.push(mergedMoves[k]); }); | |
306 | return moves; | |
2eef6db6 BA |
307 | } |
308 | ||
a3c86ec9 BA |
309 | // Withdrawer |
310 | addQueenCaptures(moves, byChameleon) | |
2eef6db6 | 311 | { |
a3c86ec9 BA |
312 | if (moves.length == 0) |
313 | return; | |
314 | const [x,y] = [moves[0].start.x,moves[0].start.y]; | |
7688bf77 BA |
315 | const V = VariantRules; |
316 | const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]); | |
317 | let capturingDirections = []; | |
a3c86ec9 | 318 | const color = this.turn; |
7688bf77 | 319 | const oppCol = this.getOppCol(color); |
a3c86ec9 | 320 | const [sizeX,sizeY] = V.size; |
7688bf77 BA |
321 | adjacentSteps.forEach(step => { |
322 | const [i,j] = [x+step[0],y+step[1]]; | |
a3c86ec9 BA |
323 | if (i>=0 && i<sizeX && j>=0 && j<sizeY |
324 | && this.board[i][j] != V.EMPTY && this.getColor(i,j) == oppCol | |
325 | && (!byChameleon || this.getPiece(i,j) == V.QUEEN)) | |
326 | { | |
7688bf77 | 327 | capturingDirections.push(step); |
a3c86ec9 | 328 | } |
7688bf77 BA |
329 | }); |
330 | moves.forEach(m => { | |
331 | const step = [ | |
332 | m.end.x!=x ? (m.end.x-x)/Math.abs(m.end.x-x) : 0, | |
333 | m.end.y!=y ? (m.end.y-y)/Math.abs(m.end.y-y) : 0 | |
334 | ]; | |
a3c86ec9 | 335 | // NOTE: includes() and even _.isEqual() functions fail... |
7688bf77 | 336 | // TODO: this test should be done only once per direction |
a3c86ec9 BA |
337 | if (capturingDirections.some(dir => |
338 | { return (dir[0]==-step[0] && dir[1]==-step[1]); })) | |
7688bf77 BA |
339 | { |
340 | const [i,j] = [x-step[0],y-step[1]]; | |
341 | m.vanish.push(new PiPo({ | |
342 | x:i, | |
343 | y:j, | |
344 | p:this.getPiece(i,j), | |
345 | c:oppCol | |
346 | })); | |
347 | } | |
348 | }); | |
2eef6db6 BA |
349 | } |
350 | ||
a3c86ec9 BA |
351 | getPotentialQueenMoves(sq) |
352 | { | |
353 | let moves = super.getPotentialQueenMoves(sq); | |
354 | this.addQueenCaptures(moves); | |
355 | return moves; | |
356 | } | |
357 | ||
45338cdd BA |
358 | getPotentialImmobilizerMoves(sq) |
359 | { | |
a3c86ec9 | 360 | // Immobilizer doesn't capture |
45338cdd BA |
361 | return super.getPotentialQueenMoves(sq); |
362 | } | |
363 | ||
2eef6db6 BA |
364 | getPotentialKingMoves(sq) |
365 | { | |
366 | const V = VariantRules; | |
367 | return this.getSlideNJumpMoves(sq, | |
368 | V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep"); | |
369 | } | |
370 | ||
c28265aa | 371 | underCheck(move) |
2eef6db6 | 372 | { |
c28265aa | 373 | return false; //there is no check |
2eef6db6 BA |
374 | } |
375 | ||
c28265aa | 376 | getCheckSquares(move) |
2eef6db6 | 377 | { |
c28265aa BA |
378 | const c = this.getOppCol(this.turn); //opponent |
379 | const saveKingPos = this.kingPos[c]; //king might be taken | |
380 | this.play(move); | |
381 | // The only way to be "under check" is to have lost the king (thus game over) | |
382 | let res = this.kingPos[c][0] < 0 | |
383 | ? [ JSON.parse(JSON.stringify(saveKingPos)) ] | |
384 | : [ ]; | |
385 | this.undo(move); | |
386 | return res; | |
2eef6db6 BA |
387 | } |
388 | ||
c28265aa | 389 | updateVariables(move) |
2eef6db6 | 390 | { |
c28265aa BA |
391 | // Just update king(s) position(s) |
392 | const piece = this.getPiece(move.start.x,move.start.y); | |
393 | const c = this.getColor(move.start.x,move.start.y); | |
394 | if (piece == VariantRules.KING && move.appear.length > 0) | |
7aea7942 | 395 | { |
c28265aa BA |
396 | this.kingPos[c][0] = move.appear[0].x; |
397 | this.kingPos[c][1] = move.appear[0].y; | |
398 | } | |
399 | // Does this move takes opponent's king? | |
400 | const oppCol = this.getOppCol(c); | |
96f8422e | 401 | for (let i=1; i<move.vanish.length; i++) |
c28265aa | 402 | { |
96f8422e | 403 | if (move.vanish[i].p == VariantRules.KING) |
7aea7942 | 404 | { |
c28265aa BA |
405 | this.kingPos[oppCol] = [-1,-1]; |
406 | break; | |
7aea7942 BA |
407 | } |
408 | } | |
2eef6db6 BA |
409 | } |
410 | ||
c28265aa | 411 | unupdateVariables(move) |
2eef6db6 | 412 | { |
c28265aa BA |
413 | super.unupdateVariables(move); |
414 | const c = this.getColor(move.start.x,move.start.y); | |
415 | const oppCol = this.getOppCol(c); | |
416 | if (this.kingPos[oppCol][0] < 0) | |
7aea7942 | 417 | { |
c28265aa | 418 | // Last move took opponent's king |
96f8422e | 419 | for (let i=1; i<move.vanish.length; i++) |
7aea7942 | 420 | { |
96f8422e | 421 | const psq = move.vanish[i]; |
c28265aa | 422 | if (psq.p == 'k') |
7aea7942 | 423 | { |
c28265aa BA |
424 | this.kingPos[oppCol] = [psq.x, psq.y]; |
425 | break; | |
7aea7942 BA |
426 | } |
427 | } | |
428 | } | |
2eef6db6 BA |
429 | } |
430 | ||
c28265aa | 431 | checkGameOver() |
2eef6db6 | 432 | { |
c28265aa BA |
433 | if (this.checkRepetition()) |
434 | return "1/2"; | |
435 | ||
436 | const color = this.turn; | |
c28265aa BA |
437 | if (this.atLeastOneMove() && this.kingPos[color][0] >= 0) |
438 | return "*"; | |
439 | ||
440 | return this.checkGameEnd(); | |
2eef6db6 BA |
441 | } |
442 | ||
a3c86ec9 BA |
443 | checkGameEnd() |
444 | { | |
0279ac93 | 445 | // Stalemate, or our king disappeared |
a3c86ec9 BA |
446 | return this.turn == "w" ? "0-1" : "1-0"; |
447 | } | |
448 | ||
2eef6db6 BA |
449 | static get VALUES() { //TODO: totally experimental! |
450 | return { | |
451 | 'p': 1, | |
452 | 'r': 2, | |
453 | 'n': 5, | |
454 | 'b': 3, | |
455 | 'q': 3, | |
456 | 'm': 5, | |
457 | 'k': 1000 | |
458 | }; | |
459 | } | |
460 | ||
461 | static get SEARCH_DEPTH() { return 2; } //TODO? | |
462 | ||
c28265aa BA |
463 | static get THRESHOLD_MATE() { |
464 | return 500; //checkmates evals may be slightly below 1000 | |
465 | } | |
466 | ||
2eef6db6 BA |
467 | static GenRandInitFen() |
468 | { | |
469 | let pieces = { "w": new Array(8), "b": new Array(8) }; | |
470 | // Shuffle pieces on first and last rank | |
471 | for (let c of ["w","b"]) | |
472 | { | |
473 | let positions = _.range(8); | |
474 | // Get random squares for every piece, totally freely | |
475 | ||
476 | let randIndex = _.random(7); | |
477 | const bishop1Pos = positions[randIndex]; | |
478 | positions.splice(randIndex, 1); | |
479 | ||
480 | randIndex = _.random(6); | |
481 | const bishop2Pos = positions[randIndex]; | |
482 | positions.splice(randIndex, 1); | |
483 | ||
484 | randIndex = _.random(5); | |
485 | const knight1Pos = positions[randIndex]; | |
486 | positions.splice(randIndex, 1); | |
487 | ||
488 | randIndex = _.random(4); | |
489 | const knight2Pos = positions[randIndex]; | |
490 | positions.splice(randIndex, 1); | |
491 | ||
492 | randIndex = _.random(3); | |
493 | const queenPos = positions[randIndex]; | |
494 | positions.splice(randIndex, 1); | |
495 | ||
496 | randIndex = _.random(2); | |
497 | const kingPos = positions[randIndex]; | |
498 | positions.splice(randIndex, 1); | |
499 | ||
500 | randIndex = _.random(1); | |
501 | const rookPos = positions[randIndex]; | |
502 | positions.splice(randIndex, 1); | |
45338cdd | 503 | const immobilizerPos = positions[0]; |
2eef6db6 BA |
504 | |
505 | pieces[c][bishop1Pos] = 'b'; | |
506 | pieces[c][bishop2Pos] = 'b'; | |
507 | pieces[c][knight1Pos] = 'n'; | |
508 | pieces[c][knight2Pos] = 'n'; | |
509 | pieces[c][queenPos] = 'q'; | |
510 | pieces[c][kingPos] = 'k'; | |
511 | pieces[c][rookPos] = 'r'; | |
512 | pieces[c][immobilizerPos] = 'm'; | |
513 | } | |
514 | return pieces["b"].join("") + | |
515 | "/pppppppp/8/8/8/8/PPPPPPPP/" + | |
516 | pieces["w"].join("").toUpperCase() + | |
517 | " 0000"; //TODO: flags?! | |
518 | } | |
519 | ||
520 | getFlagsFen() | |
521 | { | |
522 | return "0000"; //TODO: or "-" ? | |
523 | } | |
a3c86ec9 BA |
524 | |
525 | getNotation(move) | |
526 | { | |
527 | if (move.appear.length == 0) | |
528 | { | |
529 | const startSquare = | |
530 | String.fromCharCode(97 + move.start.y) + (VariantRules.size[0]-move.start.x); | |
531 | return "^" + startSquare; //suicide | |
532 | } | |
533 | return super.getNotation(move); | |
534 | } | |
32cfcea4 | 535 | } |