7f9531eb82ef281a9f5a899161f8e34c7d05b46e
[vchess.git] / public / javascripts / variants / Ultima.js
1 class UltimaRules extends ChessRules
2 {
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 }
9
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 {
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: [],
75 vanish: [new PiPo({x:x,y:y,p:piece,c:color})],
76 start: {x:x,y:y},
77 end: {x:i,y:j}
78 }) ];
79 }
80 }
81 }
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 }
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
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
160 // "Pincher"
161 getPotentialPawnMoves([x,y])
162 {
163 let moves = super.getPotentialRookMoves([x,y]);
164 this.addPawnCaptures(moves);
165 return moves;
166 }
167
168 addRookCaptures(moves, byChameleon)
169 {
170 const color = this.turn;
171 const oppCol = this.getOppCol(color);
172 const kp = this.kingPos[color];
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 {
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 }
193 }
194 }
195 });
196 }
197
198 // Coordinator
199 getPotentialRookMoves(sq)
200 {
201 let moves = super.getPotentialQueenMoves(sq);
202 this.addRookCaptures(moves);
203 return moves;
204 }
205
206 // Long-leaper
207 getKnightCaptures(startSquare, byChameleon)
208 {
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;
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:
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 }
227 if (i<0 || i>=sizeX || j<0 || j>=sizeY || this.getColor(i,j)==color
228 || (!!byChameleon && this.getPiece(i,j)!=V.KNIGHT))
229 {
230 continue;
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 }
269 }
270 return moves;
271 }
272
273 // Long-leaper
274 getPotentialKnightMoves(sq)
275 {
276 return super.getPotentialQueenMoves(sq).concat(this.getKnightCaptures(sq));
277 }
278
279 getPotentialBishopMoves([x,y])
280 {
281 let moves = super.getPotentialQueenMoves([x,y])
282 .concat(this.getKnightCaptures([x,y],"asChameleon"));
283 this.addPawnCaptures(moves, "asChameleon");
284 this.addRookCaptures(moves, "asChameleon");
285 this.addQueenCaptures(moves, "asChameleon");
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));
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;
307 }
308
309 // Withdrawer
310 addQueenCaptures(moves, byChameleon)
311 {
312 if (moves.length == 0)
313 return;
314 const [x,y] = [moves[0].start.x,moves[0].start.y];
315 const V = VariantRules;
316 const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
317 let capturingDirections = [];
318 const color = this.turn;
319 const oppCol = this.getOppCol(color);
320 const [sizeX,sizeY] = V.size;
321 adjacentSteps.forEach(step => {
322 const [i,j] = [x+step[0],y+step[1]];
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 {
327 capturingDirections.push(step);
328 }
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 ];
335 // NOTE: includes() and even _.isEqual() functions fail...
336 // TODO: this test should be done only once per direction
337 if (capturingDirections.some(dir =>
338 { return (dir[0]==-step[0] && dir[1]==-step[1]); }))
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 });
349 }
350
351 getPotentialQueenMoves(sq)
352 {
353 let moves = super.getPotentialQueenMoves(sq);
354 this.addQueenCaptures(moves);
355 return moves;
356 }
357
358 getPotentialImmobilizerMoves(sq)
359 {
360 // Immobilizer doesn't capture
361 return super.getPotentialQueenMoves(sq);
362 }
363
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
371 underCheck(move)
372 {
373 return false; //there is no check
374 }
375
376 getCheckSquares(move)
377 {
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;
387 }
388
389 updateVariables(move)
390 {
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)
395 {
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);
401 for (let i=1; i<move.vanish.length; i++)
402 {
403 if (move.vanish[i].p == VariantRules.KING)
404 {
405 this.kingPos[oppCol] = [-1,-1];
406 break;
407 }
408 }
409 }
410
411 unupdateVariables(move)
412 {
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)
417 {
418 // Last move took opponent's king
419 for (let i=1; i<move.vanish.length; i++)
420 {
421 const psq = move.vanish[i];
422 if (psq.p == 'k')
423 {
424 this.kingPos[oppCol] = [psq.x, psq.y];
425 break;
426 }
427 }
428 }
429 }
430
431 checkGameOver()
432 {
433 if (this.checkRepetition())
434 return "1/2";
435
436 const color = this.turn;
437 if (this.atLeastOneMove() && this.kingPos[color][0] >= 0)
438 return "*";
439
440 return this.checkGameEnd();
441 }
442
443 checkGameEnd()
444 {
445 // Stalemate, or our king disappeared
446 return this.turn == "w" ? "0-1" : "1-0";
447 }
448
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
463 static get THRESHOLD_MATE() {
464 return 500; //checkmates evals may be slightly below 1000
465 }
466
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);
503 const immobilizerPos = positions[0];
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 }
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 }
535 }