1 class PiPo
//Piece+Position
3 // o: {piece[p], color[c], posX[x], posY[y]}
15 // o: {appear, vanish, [start,] [end,]}
16 // appear,vanish = arrays of PiPo
17 // start,end = coordinates to apply to trigger move visually (think castle)
20 this.appear
= o
.appear
;
21 this.vanish
= o
.vanish
;
22 this.start
= !!o
.start
? o
.start : {x:o
.vanish
[0].x
, y:o
.vanish
[0].y
};
23 this.end
= !!o
.end
? o
.end : {x:o
.appear
[0].x
, y:o
.appear
[0].y
};
27 // NOTE: x coords = top to bottom; y = left to right (from white player perspective)
33 return b
; //usual pieces in pieces/ folder
35 // Turn "wb" into "B" (for FEN)
38 return b
[0]=='w' ? b
[1].toUpperCase() : b
[1];
40 // Turn "p" into "bp" (for board)
43 return f
.charCodeAt()<=90 ? "w"+f
.toLowerCase() : "b"+f
;
49 // fen == "position flags"
50 constructor(fen
, moves
)
53 // Use fen string to initialize variables, flags and board
54 this.board
= VariantRules
.GetBoard(fen
);
56 this.initVariables(fen
);
61 this.INIT_COL_KING
= {'w':-1, 'b':-1};
62 this.INIT_COL_ROOK
= {'w':[-1,-1], 'b':[-1,-1]};
63 this.kingPos
= {'w':[-1,-1], 'b':[-1,-1]}; //respective squares of white and black king
64 const fenParts
= fen
.split(" ");
65 const position
= fenParts
[0].split("/");
66 for (let i
=0; i
<position
.length
; i
++)
68 let k
= 0; //column index on board
69 for (let j
=0; j
<position
[i
].length
; j
++)
71 switch (position
[i
].charAt(j
))
74 this.kingPos
['b'] = [i
,k
];
75 this.INIT_COL_KING
['b'] = k
;
78 this.kingPos
['w'] = [i
,k
];
79 this.INIT_COL_KING
['w'] = k
;
82 if (this.INIT_COL_ROOK
['b'][0] < 0)
83 this.INIT_COL_ROOK
['b'][0] = k
;
85 this.INIT_COL_ROOK
['b'][1] = k
;
88 if (this.INIT_COL_ROOK
['w'][0] < 0)
89 this.INIT_COL_ROOK
['w'][0] = k
;
91 this.INIT_COL_ROOK
['w'][1] = k
;
94 let num
= parseInt(position
[i
].charAt(j
));
101 const epSq
= this.moves
.length
> 0 ? this.getEpSquare(this.lastMove
) : undefined;
102 this.epSquares
= [ epSq
];
105 // Turn diagram fen into double array ["wb","wp","bk",...]
108 let rows
= fen
.split(" ")[0].split("/");
109 const [sizeX
,sizeY
] = VariantRules
.size
;
110 let board
= doubleArray(sizeX
, sizeY
, "");
111 for (let i
=0; i
<rows
.length
; i
++)
114 for (let indexInRow
= 0; indexInRow
< rows
[i
].length
; indexInRow
++)
116 let character
= rows
[i
][indexInRow
];
117 let num
= parseInt(character
);
119 j
+= num
; //just shift j
120 else //something at position i,j
121 board
[i
][j
++] = VariantRules
.fen2board(character
);
127 // Overridable: flags can change a lot
130 // white a-castle, h-castle, black a-castle, h-castle
131 this.castleFlags
= {'w': new Array(2), 'b': new Array(2)};
132 let flags
= fen
.split(" ")[1]; //flags right after position
133 for (let i
=0; i
<4; i
++)
134 this.castleFlags
[i
< 2 ? 'w' : 'b'][i
%2] = (flags
.charAt(i
) == '1');
140 // Simple useful getters
141 static get size() { return [8,8]; }
142 // Two next functions return 'undefined' if called on empty square
143 getColor(i
,j
) { return this.board
[i
][j
].charAt(0); }
144 getPiece(i
,j
) { return this.board
[i
][j
].charAt(1); }
147 getOppCol(color
) { return color
=="w" ? "b" : "w"; }
150 const L
= this.moves
.length
;
151 return L
>0 ? this.moves
[L
-1] : null;
154 return this.moves
.length
%2==0 ? 'w' : 'b';
158 static get PAWN() { return 'p'; }
159 static get ROOK() { return 'r'; }
160 static get KNIGHT() { return 'n'; }
161 static get BISHOP() { return 'b'; }
162 static get QUEEN() { return 'q'; }
163 static get KING() { return 'k'; }
166 static get EMPTY() { return ''; }
168 // Some pieces movements
171 'r': [ [-1,0],[1,0],[0,-1],[0,1] ],
172 'n': [ [-1,-2],[-1,2],[1,-2],[1,2],[-2,-1],[-2,1],[2,-1],[2,1] ],
173 'b': [ [-1,-1],[-1,1],[1,-1],[1,1] ],
177 // Aggregates flags into one object
179 return this.castleFlags
;
185 this.castleFlags
= flags
;
188 // En-passant square, if any
191 const [sx
,sy
,ex
] = [move.start
.x
,move.start
.y
,move.end
.x
];
192 if (this.getPiece(sx
,sy
) == VariantRules
.PAWN
&& Math
.abs(sx
- ex
) == 2)
199 return undefined; //default
202 // can thing on square1 take thing on square2
203 canTake([x1
,y1
], [x2
,y2
])
205 return this.getColor(x1
,y1
) != this.getColor(x2
,y2
);
211 // All possible moves from selected square (assumption: color is OK)
212 getPotentialMovesFrom([x
,y
])
214 switch (this.getPiece(x
,y
))
216 case VariantRules
.PAWN:
217 return this.getPotentialPawnMoves([x
,y
]);
218 case VariantRules
.ROOK:
219 return this.getPotentialRookMoves([x
,y
]);
220 case VariantRules
.KNIGHT:
221 return this.getPotentialKnightMoves([x
,y
]);
222 case VariantRules
.BISHOP:
223 return this.getPotentialBishopMoves([x
,y
]);
224 case VariantRules
.QUEEN:
225 return this.getPotentialQueenMoves([x
,y
]);
226 case VariantRules
.KING:
227 return this.getPotentialKingMoves([x
,y
]);
231 // Build a regular move from its initial and destination squares; tr: transformation
232 getBasicMove([sx
,sy
], [ex
,ey
], tr
)
239 c: !!tr
? tr
.c : this.getColor(sx
,sy
),
240 p: !!tr
? tr
.p : this.getPiece(sx
,sy
)
247 c: this.getColor(sx
,sy
),
248 p: this.getPiece(sx
,sy
)
253 // The opponent piece disappears if we take it
254 if (this.board
[ex
][ey
] != VariantRules
.EMPTY
)
260 c: this.getColor(ex
,ey
),
261 p: this.getPiece(ex
,ey
)
268 // Generic method to find possible moves of non-pawn pieces ("sliding or jumping")
269 getSlideNJumpMoves([x
,y
], steps
, oneStep
)
271 const color
= this.getColor(x
,y
);
273 const [sizeX
,sizeY
] = VariantRules
.size
;
275 for (let step
of steps
)
279 while (i
>=0 && i
<sizeX
&& j
>=0 && j
<sizeY
&& this.board
[i
][j
] == VariantRules
.EMPTY
)
281 moves
.push(this.getBasicMove([x
,y
], [i
,j
]));
282 if (oneStep
!== undefined)
287 if (i
>=0 && i
<8 && j
>=0 && j
<8 && this.canTake([x
,y
], [i
,j
]))
288 moves
.push(this.getBasicMove([x
,y
], [i
,j
]));
293 // What are the pawn moves from square x,y considering color "color" ?
294 getPotentialPawnMoves([x
,y
])
296 const color
= this.turn
;
298 const V
= VariantRules
;
299 const [sizeX
,sizeY
] = VariantRules
.size
;
300 const shift
= (color
== "w" ? -1 : 1);
301 const firstRank
= (color
== 'w' ? sizeY
-1 : 0);
302 const startRank
= (color
== "w" ? sizeY
-2 : 1);
303 const lastRank
= (color
== "w" ? 0 : sizeY
-1);
305 if (x
+shift
>= 0 && x
+shift
< sizeX
&& x
+shift
!= lastRank
)
308 if (this.board
[x
+shift
][y
] == V
.EMPTY
)
310 moves
.push(this.getBasicMove([x
,y
], [x
+shift
,y
]));
311 // Next condition because variants with pawns on 1st rank generally allow them to jump
312 if ([startRank
,firstRank
].includes(x
) && this.board
[x
+2*shift
][y
] == V
.EMPTY
)
315 moves
.push(this.getBasicMove([x
,y
], [x
+2*shift
,y
]));
319 if (y
>0 && this.canTake([x
,y
], [x
+shift
,y
-1]) && this.board
[x
+shift
][y
-1] != V
.EMPTY
)
320 moves
.push(this.getBasicMove([x
,y
], [x
+shift
,y
-1]));
321 if (y
<sizeY
-1 && this.canTake([x
,y
], [x
+shift
,y
+1]) && this.board
[x
+shift
][y
+1] != V
.EMPTY
)
322 moves
.push(this.getBasicMove([x
,y
], [x
+shift
,y
+1]));
325 if (x
+shift
== lastRank
)
328 let promotionPieces
= [V
.ROOK
,V
.KNIGHT
,V
.BISHOP
,V
.QUEEN
];
329 promotionPieces
.forEach(p
=> {
331 if (this.board
[x
+shift
][y
] == V
.EMPTY
)
332 moves
.push(this.getBasicMove([x
,y
], [x
+shift
,y
], {c:color
,p:p
}));
334 if (y
>0 && this.canTake([x
,y
], [x
+shift
,y
-1]) && this.board
[x
+shift
][y
-1] != V
.EMPTY
)
335 moves
.push(this.getBasicMove([x
,y
], [x
+shift
,y
-1], {c:color
,p:p
}));
336 if (y
<sizeY
-1 && this.canTake([x
,y
], [x
+shift
,y
+1]) && this.board
[x
+shift
][y
+1] != V
.EMPTY
)
337 moves
.push(this.getBasicMove([x
,y
], [x
+shift
,y
+1], {c:color
,p:p
}));
342 const Lep
= this.epSquares
.length
;
343 const epSquare
= Lep
>0 ? this.epSquares
[Lep
-1] : undefined;
344 if (!!epSquare
&& epSquare
.x
== x
+shift
&& Math
.abs(epSquare
.y
- y
) == 1)
346 let epStep
= epSquare
.y
- y
;
347 var enpassantMove
= this.getBasicMove([x
,y
], [x
+shift
,y
+epStep
]);
348 enpassantMove
.vanish
.push({
352 c: this.getColor(x
,y
+epStep
)
354 moves
.push(enpassantMove
);
360 // What are the rook moves from square x,y ?
361 getPotentialRookMoves(sq
)
363 return this.getSlideNJumpMoves(sq
, VariantRules
.steps
[VariantRules
.ROOK
]);
366 // What are the knight moves from square x,y ?
367 getPotentialKnightMoves(sq
)
369 return this.getSlideNJumpMoves(sq
, VariantRules
.steps
[VariantRules
.KNIGHT
], "oneStep");
372 // What are the bishop moves from square x,y ?
373 getPotentialBishopMoves(sq
)
375 return this.getSlideNJumpMoves(sq
, VariantRules
.steps
[VariantRules
.BISHOP
]);
378 // What are the queen moves from square x,y ?
379 getPotentialQueenMoves(sq
)
381 const V
= VariantRules
;
382 return this.getSlideNJumpMoves(sq
, V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
]));
385 // What are the king moves from square x,y ?
386 getPotentialKingMoves(sq
)
388 const V
= VariantRules
;
389 // Initialize with normal moves
390 let moves
= this.getSlideNJumpMoves(sq
,
391 V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
]), "oneStep");
392 return moves
.concat(this.getCastleMoves(sq
));
395 getCastleMoves([x
,y
])
397 const c
= this.getColor(x
,y
);
398 if (x
!= (c
=="w" ? 7 : 0) || y
!= this.INIT_COL_KING
[c
])
399 return []; //x isn't first rank, or king has moved (shortcut)
401 const V
= VariantRules
;
404 const oppCol
= this.getOppCol(c
);
407 const finalSquares
= [ [2,3], [6,5] ]; //king, then rook
409 for (let castleSide
=0; castleSide
< 2; castleSide
++) //large, then small
411 if (!this.castleFlags
[c
][castleSide
])
413 // If this code is reached, rooks and king are on initial position
415 // Nothing on the path of the king (and no checks; OK also if y==finalSquare)?
416 let step
= finalSquares
[castleSide
][0] < y
? -1 : 1;
417 for (i
=y
; i
!=finalSquares
[castleSide
][0]; i
+=step
)
419 if (this.isAttacked([x
,i
], oppCol
) || (this.board
[x
][i
] != V
.EMPTY
&&
420 // NOTE: next check is enough, because of chessboard constraints
421 (this.getColor(x
,i
) != c
|| ![V
.KING
,V
.ROOK
].includes(this.getPiece(x
,i
)))))
423 continue castlingCheck
;
427 // Nothing on the path to the rook?
428 step
= castleSide
== 0 ? -1 : 1;
429 for (i
= y
+ step
; i
!= this.INIT_COL_ROOK
[c
][castleSide
]; i
+= step
)
431 if (this.board
[x
][i
] != V
.EMPTY
)
432 continue castlingCheck
;
434 const rookPos
= this.INIT_COL_ROOK
[c
][castleSide
];
436 // Nothing on final squares, except maybe king and castling rook?
439 if (this.board
[x
][finalSquares
[castleSide
][i
]] != V
.EMPTY
&&
440 this.getPiece(x
,finalSquares
[castleSide
][i
]) != V
.KING
&&
441 finalSquares
[castleSide
][i
] != rookPos
)
443 continue castlingCheck
;
447 // If this code is reached, castle is valid
448 moves
.push( new Move({
450 new PiPo({x:x
,y:finalSquares
[castleSide
][0],p:V
.KING
,c:c
}),
451 new PiPo({x:x
,y:finalSquares
[castleSide
][1],p:V
.ROOK
,c:c
})],
453 new PiPo({x:x
,y:y
,p:V
.KING
,c:c
}),
454 new PiPo({x:x
,y:rookPos
,p:V
.ROOK
,c:c
})],
455 end: Math
.abs(y
- rookPos
) <= 2
457 : {x:x
, y:y
+ 2 * (castleSide
==0 ? -1 : 1)}
467 canIplay(side
, [x
,y
])
469 return ((side
=='w' && this.moves
.length
%2==0) || (side
=='b' && this.moves
.length
%2==1))
470 && this.getColor(x
,y
) == side
;
473 getPossibleMovesFrom(sq
)
475 // Assuming color is right (already checked)
476 return this.filterValid( this.getPotentialMovesFrom(sq
) );
479 // TODO: once a promotion is filtered, the others results are same: useless computations
482 if (moves
.length
== 0)
484 return moves
.filter(m
=> { return !this.underCheck(m
); });
487 // Search for all valid moves considering current turn (for engine and game end)
490 const color
= this.turn
;
491 const oppCol
= this.getOppCol(color
);
492 var potentialMoves
= [];
493 let [sizeX
,sizeY
] = VariantRules
.size
;
494 for (var i
=0; i
<sizeX
; i
++)
496 for (var j
=0; j
<sizeY
; j
++)
498 // Next condition ... != oppCol is a little HACK to work with checkered variant
499 if (this.board
[i
][j
] != VariantRules
.EMPTY
&& this.getColor(i
,j
) != oppCol
)
500 Array
.prototype.push
.apply(potentialMoves
, this.getPotentialMovesFrom([i
,j
]));
503 // NOTE: prefer lazy undercheck tests, letting the king being taken?
504 // No: if happen on last 1/2 move, could lead to forbidden moves, wrong evals
505 return this.filterValid(potentialMoves
);
508 // Stop at the first move found
511 const color
= this.turn
;
512 const oppCol
= this.getOppCol(color
);
513 let [sizeX
,sizeY
] = VariantRules
.size
;
514 for (let i
=0; i
<sizeX
; i
++)
516 for (let j
=0; j
<sizeY
; j
++)
518 if (this.board
[i
][j
] != VariantRules
.EMPTY
&& this.getColor(i
,j
) != oppCol
)
520 const moves
= this.getPotentialMovesFrom([i
,j
]);
521 if (moves
.length
> 0)
523 for (let k
=0; k
<moves
.length
; k
++)
525 if (this.filterValid([moves
[k
]]).length
> 0)
535 // Check if pieces of color 'colors' are attacking square x,y
536 isAttacked(sq
, colors
)
538 return (this.isAttackedByPawn(sq
, colors
)
539 || this.isAttackedByRook(sq
, colors
)
540 || this.isAttackedByKnight(sq
, colors
)
541 || this.isAttackedByBishop(sq
, colors
)
542 || this.isAttackedByQueen(sq
, colors
)
543 || this.isAttackedByKing(sq
, colors
));
546 // Is square x,y attacked by pawns of color c ?
547 isAttackedByPawn([x
,y
], colors
)
549 for (let c
of colors
)
551 let pawnShift
= (c
=="w" ? 1 : -1);
552 if (x
+pawnShift
>=0 && x
+pawnShift
<8)
554 for (let i
of [-1,1])
556 if (y
+i
>=0 && y
+i
<8 && this.getPiece(x
+pawnShift
,y
+i
)==VariantRules
.PAWN
557 && this.getColor(x
+pawnShift
,y
+i
)==c
)
567 // Is square x,y attacked by rooks of color c ?
568 isAttackedByRook(sq
, colors
)
570 return this.isAttackedBySlideNJump(sq
, colors
,
571 VariantRules
.ROOK
, VariantRules
.steps
[VariantRules
.ROOK
]);
574 // Is square x,y attacked by knights of color c ?
575 isAttackedByKnight(sq
, colors
)
577 return this.isAttackedBySlideNJump(sq
, colors
,
578 VariantRules
.KNIGHT
, VariantRules
.steps
[VariantRules
.KNIGHT
], "oneStep");
581 // Is square x,y attacked by bishops of color c ?
582 isAttackedByBishop(sq
, colors
)
584 return this.isAttackedBySlideNJump(sq
, colors
,
585 VariantRules
.BISHOP
, VariantRules
.steps
[VariantRules
.BISHOP
]);
588 // Is square x,y attacked by queens of color c ?
589 isAttackedByQueen(sq
, colors
)
591 const V
= VariantRules
;
592 return this.isAttackedBySlideNJump(sq
, colors
, V
.QUEEN
,
593 V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
]));
596 // Is square x,y attacked by king of color c ?
597 isAttackedByKing(sq
, colors
)
599 const V
= VariantRules
;
600 return this.isAttackedBySlideNJump(sq
, colors
, V
.KING
,
601 V
.steps
[V
.ROOK
].concat(V
.steps
[V
.BISHOP
]), "oneStep");
604 // Generic method for non-pawn pieces ("sliding or jumping"): is x,y attacked by piece != color ?
605 isAttackedBySlideNJump([x
,y
], colors
, piece
, steps
, oneStep
)
607 for (let step
of steps
)
609 let rx
= x
+step
[0], ry
= y
+step
[1];
610 while (rx
>=0 && rx
<8 && ry
>=0 && ry
<8 && this.board
[rx
][ry
] == VariantRules
.EMPTY
616 if (rx
>=0 && rx
<8 && ry
>=0 && ry
<8 && this.board
[rx
][ry
] != VariantRules
.EMPTY
617 && this.getPiece(rx
,ry
) == piece
&& colors
.includes(this.getColor(rx
,ry
)))
625 // Is color c under check after move ?
628 const color
= this.turn
;
630 let res
= this.isAttacked(this.kingPos
[color
], this.getOppCol(color
));
635 // On which squares is color c under check (after move) ?
636 getCheckSquares(move)
639 const color
= this.turn
; //opponent
640 let res
= this.isAttacked(this.kingPos
[color
], this.getOppCol(color
))
641 ? [ JSON
.parse(JSON
.stringify(this.kingPos
[color
])) ] //need to duplicate!
647 // Apply a move on board
648 static PlayOnBoard(board
, move)
650 for (let psq
of move.vanish
)
651 board
[psq
.x
][psq
.y
] = VariantRules
.EMPTY
;
652 for (let psq
of move.appear
)
653 board
[psq
.x
][psq
.y
] = psq
.c
+ psq
.p
;
655 // Un-apply the played move
656 static UndoOnBoard(board
, move)
658 for (let psq
of move.appear
)
659 board
[psq
.x
][psq
.y
] = VariantRules
.EMPTY
;
660 for (let psq
of move.vanish
)
661 board
[psq
.x
][psq
.y
] = psq
.c
+ psq
.p
;
664 // Before move is played, update variables + flags
665 updateVariables(move)
667 const piece
= this.getPiece(move.start
.x
,move.start
.y
);
668 const c
= this.getColor(move.start
.x
,move.start
.y
);
669 const firstRank
= (c
== "w" ? 7 : 0);
671 // Update king position + flags
672 if (piece
== VariantRules
.KING
&& move.appear
.length
> 0)
674 this.kingPos
[c
][0] = move.appear
[0].x
;
675 this.kingPos
[c
][1] = move.appear
[0].y
;
676 this.castleFlags
[c
] = [false,false];
679 const oppCol
= this.getOppCol(c
);
680 const oppFirstRank
= 7 - firstRank
;
681 if (move.start
.x
== firstRank
//our rook moves?
682 && this.INIT_COL_ROOK
[c
].includes(move.start
.y
))
684 const flagIdx
= (move.start
.y
== this.INIT_COL_ROOK
[c
][0] ? 0 : 1);
685 this.castleFlags
[c
][flagIdx
] = false;
687 else if (move.end
.x
== oppFirstRank
//we took opponent rook?
688 && this.INIT_COL_ROOK
[oppCol
].includes(move.end
.y
))
690 const flagIdx
= (move.end
.y
== this.INIT_COL_ROOK
[oppCol
][0] ? 0 : 1);
691 this.castleFlags
[oppCol
][flagIdx
] = false;
695 unupdateVariables(move)
697 // (Potentially) Reset king position
698 const c
= this.getColor(move.start
.x
,move.start
.y
);
699 if (this.getPiece(move.start
.x
,move.start
.y
) == VariantRules
.KING
)
700 this.kingPos
[c
] = [move.start
.x
, move.start
.y
];
706 // if (!this.states) this.states = [];
707 // if (!ingame) this.states.push(JSON.stringify(this.board));
710 move.notation
= this.getNotation(move);
712 move.flags
= JSON
.stringify(this.flags
); //save flags (for undo)
713 this.updateVariables(move);
714 this.moves
.push(move);
715 this.epSquares
.push( this.getEpSquare(move) );
716 VariantRules
.PlayOnBoard(this.board
, move);
721 VariantRules
.UndoOnBoard(this.board
, move);
722 this.epSquares
.pop();
724 this.unupdateVariables(move);
725 this.parseFlags(JSON
.parse(move.flags
));
728 // let state = this.states.pop();
729 // if (JSON.stringify(this.board) != state)
738 // Check for 3 repetitions
739 if (this.moves
.length
>= 8)
741 // NOTE: crude detection, only moves repetition
742 const L
= this.moves
.length
;
743 if (_
.isEqual(this.moves
[L
-1], this.moves
[L
-5]) &&
744 _
.isEqual(this.moves
[L
-2], this.moves
[L
-6]) &&
745 _
.isEqual(this.moves
[L
-3], this.moves
[L
-7]) &&
746 _
.isEqual(this.moves
[L
-4], this.moves
[L
-8]))
756 if (this.checkRepetition())
759 if (this.atLeastOneMove()) // game not over
763 return this.checkGameEnd();
766 // No moves are possible: compute score
769 const color
= this.turn
;
770 // No valid move: stalemate or checkmate?
771 if (!this.isAttacked(this.kingPos
[color
], this.getOppCol(color
)))
774 return color
== "w" ? "0-1" : "1-0";
781 static get VALUES() {
792 static get INFINITY() {
793 return 9999; //"checkmate" (unreachable eval)
796 static get THRESHOLD_MATE() {
797 // At this value or above, the game is over
798 return VariantRules
.INFINITY
;
801 // Assumption: at least one legal move
802 getComputerMove(moves1
) //moves1 might be precomputed (Magnetic chess)
804 const maxeval
= VariantRules
.INFINITY
;
805 const color
= this.turn
;
807 moves1
= this.getAllValidMoves();
809 // Rank moves using a min-max at depth 2
810 for (let i
=0; i
<moves1
.length
; i
++)
812 moves1
[i
].eval
= (color
=="w" ? -1 : 1) * maxeval
; //very low, I'm checkmated
813 let eval2
= (color
=="w" ? 1 : -1) * maxeval
; //initialized with checkmate value
814 this.play(moves1
[i
]);
816 let moves2
= this.getAllValidMoves();
817 // If no possible moves AND underCheck, eval2 is correct.
818 // If !underCheck, eval2 is 0 (stalemate).
819 if (moves2
.length
== 0 && this.checkGameEnd() == "1/2")
821 for (let j
=0; j
<moves2
.length
; j
++)
823 this.play(moves2
[j
]);
824 let evalPos
= this.evalPosition();
825 if ((color
== "w" && evalPos
< eval2
) || (color
=="b" && evalPos
> eval2
))
827 this.undo(moves2
[j
]);
829 if ((color
=="w" && eval2
> moves1
[i
].eval
) || (color
=="b" && eval2
< moves1
[i
].eval
))
830 moves1
[i
].eval
= eval2
;
831 this.undo(moves1
[i
]);
833 moves1
.sort( (a
,b
) => { return (color
=="w" ? 1 : -1) * (b
.eval
- a
.eval
); });
835 // Skip depth 3 if we found a checkmate (or if we are checkmated in 1...)
836 if (Math
.abs(moves1
[0].eval
) < VariantRules
.THRESHOLD_MATE
)
838 // TODO: show current analyzed move for depth 3, allow stopping eval (return moves1[0])
839 for (let i
=0; i
<moves1
.length
; i
++)
841 this.play(moves1
[i
]);
842 // 0.1 * oldEval : heuristic to avoid some bad moves (not all...)
843 moves1
[i
].eval
= 0.1*moves1
[i
].eval
+ this.alphabeta(2, -maxeval
, maxeval
);
844 this.undo(moves1
[i
]);
846 moves1
.sort( (a
,b
) => { return (color
=="w" ? 1 : -1) * (b
.eval
- a
.eval
); });
849 let candidates
= [0]; //indices of candidates moves
850 for (let j
=1; j
<moves1
.length
&& moves1
[j
].eval
== moves1
[0].eval
; j
++)
852 // console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; }));
853 return moves1
[_
.sample(candidates
, 1)];
856 alphabeta(depth
, alpha
, beta
)
858 const maxeval
= VariantRules
.INFINITY
;
859 const color
= this.turn
;
860 if (!this.atLeastOneMove())
862 switch (this.checkGameEnd())
864 case "1/2": return 0;
865 default: return color
=="w" ? -maxeval : maxeval
;
869 return this.evalPosition();
870 const moves
= this.getAllValidMoves();
871 let v
= color
=="w" ? -maxeval : maxeval
;
874 for (let i
=0; i
<moves
.length
; i
++)
877 v
= Math
.max(v
, this.alphabeta(depth
-1, alpha
, beta
));
879 alpha
= Math
.max(alpha
, v
);
886 for (let i
=0; i
<moves
.length
; i
++)
889 v
= Math
.min(v
, this.alphabeta(depth
-1, alpha
, beta
));
891 beta
= Math
.min(beta
, v
);
893 break; //alpha cutoff
901 const [sizeX
,sizeY
] = VariantRules
.size
;
903 //Just count material for now
904 for (let i
=0; i
<sizeX
; i
++)
906 for (let j
=0; j
<sizeY
; j
++)
908 if (this.board
[i
][j
] != VariantRules
.EMPTY
)
910 const sign
= this.getColor(i
,j
) == "w" ? 1 : -1;
911 evaluation
+= sign
* VariantRules
.VALUES
[this.getPiece(i
,j
)];
922 static GenRandInitFen()
924 let pieces
= [new Array(8), new Array(8)];
925 // Shuffle pieces on first and last rank
926 for (let c
= 0; c
<= 1; c
++)
928 let positions
= _
.range(8);
930 // Get random squares for bishops
931 let randIndex
= 2 * _
.random(3);
932 let bishop1Pos
= positions
[randIndex
];
933 // The second bishop must be on a square of different color
934 let randIndex_tmp
= 2 * _
.random(3) + 1;
935 let bishop2Pos
= positions
[randIndex_tmp
];
936 // Remove chosen squares
937 positions
.splice(Math
.max(randIndex
,randIndex_tmp
), 1);
938 positions
.splice(Math
.min(randIndex
,randIndex_tmp
), 1);
940 // Get random squares for knights
941 randIndex
= _
.random(5);
942 let knight1Pos
= positions
[randIndex
];
943 positions
.splice(randIndex
, 1);
944 randIndex
= _
.random(4);
945 let knight2Pos
= positions
[randIndex
];
946 positions
.splice(randIndex
, 1);
948 // Get random square for queen
949 randIndex
= _
.random(3);
950 let queenPos
= positions
[randIndex
];
951 positions
.splice(randIndex
, 1);
953 // Rooks and king positions are now fixed, because of the ordering rook-king-rook
954 let rook1Pos
= positions
[0];
955 let kingPos
= positions
[1];
956 let rook2Pos
= positions
[2];
958 // Finally put the shuffled pieces in the board array
959 pieces
[c
][rook1Pos
] = 'r';
960 pieces
[c
][knight1Pos
] = 'n';
961 pieces
[c
][bishop1Pos
] = 'b';
962 pieces
[c
][queenPos
] = 'q';
963 pieces
[c
][kingPos
] = 'k';
964 pieces
[c
][bishop2Pos
] = 'b';
965 pieces
[c
][knight2Pos
] = 'n';
966 pieces
[c
][rook2Pos
] = 'r';
968 let fen
= pieces
[0].join("") +
969 "/pppppppp/8/8/8/8/PPPPPPPP/" +
970 pieces
[1].join("").toUpperCase() +
975 // Return current fen according to pieces+colors state
978 return this.getBaseFen() + " " + this.getFlagsFen();
984 let [sizeX
,sizeY
] = VariantRules
.size
;
985 for (let i
=0; i
<sizeX
; i
++)
988 for (let j
=0; j
<sizeY
; j
++)
990 if (this.board
[i
][j
] == VariantRules
.EMPTY
)
996 // Add empty squares in-between
1000 fen
+= VariantRules
.board2fen(this.board
[i
][j
]);
1005 // "Flush remainder"
1009 fen
+= "/"; //separate rows
1018 // Add castling flags
1019 for (let i
of ['w','b'])
1021 for (let j
=0; j
<2; j
++)
1022 fen
+= this.castleFlags
[i
][j
] ? '1' : '0';
1027 // Context: just before move is played, turn hasn't changed
1030 if (move.appear
.length
== 2 && move.appear
[0].p
== VariantRules
.KING
)
1033 if (move.end
.y
< move.start
.y
)
1039 // Translate final square
1041 String
.fromCharCode(97 + move.end
.y
) + (VariantRules
.size
[0]-move.end
.x
);
1043 const piece
= this.getPiece(move.start
.x
, move.start
.y
);
1044 if (piece
== VariantRules
.PAWN
)
1048 if (move.vanish
.length
> move.appear
.length
)
1051 const startColumn
= String
.fromCharCode(97 + move.start
.y
);
1052 notation
= startColumn
+ "x" + finalSquare
;
1055 notation
= finalSquare
;
1056 if (move.appear
.length
> 0 && piece
!= move.appear
[0].p
) //promotion
1057 notation
+= "=" + move.appear
[0].p
.toUpperCase();
1064 return piece
.toUpperCase() +
1065 (move.vanish
.length
> move.appear
.length
? "x" : "") + finalSquare
;
1069 // The score is already computed when calling this function
1070 getPGN(mycolor
, score
, fenStart
, mode
)
1073 pgn
+= '[Site "vchess.club"]<br>';
1074 const d
= new Date();
1075 const opponent
= mode
=="human" ? "Anonymous" : "Computer";
1076 pgn
+= '[Variant "' + variant
+ '"]<br>';
1077 pgn
+= '[Date "' + d
.getFullYear() + '-' + (d
.getMonth()+1) + '-' + d
.getDate() + '"]<br>';
1078 pgn
+= '[White "' + (mycolor
=='w'?'Myself':opponent
) + '"]<br>';
1079 pgn
+= '[Black "' + (mycolor
=='b'?'Myself':opponent
) + '"]<br>';
1080 pgn
+= '[Fen "' + fenStart
+ '"]<br>';
1081 pgn
+= '[Result "' + score
+ '"]<br><br>';
1083 for (let i
=0; i
<this.moves
.length
; i
++)
1086 pgn
+= ((i
/2)+1) + ".";
1087 pgn
+= this.moves
[i
].notation
+ " ";