/*
*******************************************************************************
* *
* SetBoard() is used to set up the board in any position desired. It uses *
* a forsythe-like string of characters to describe the board position. *
* *
* The standard piece codes p,n,b,r,q,k are used to denote the type of piece *
* on a square, upper/lower case are used to indicate the side (program/opp.)*
* of the piece. *
* *
* The pieces are entered with square a8 first, then b8, ... until the full *
* 8th rank is completed. A "/" terminates that rank. This is repeated for *
* each of the 8 ranks, with the last (1st) rank not needing a terminating *
* "/". For empty squares, a number between 1 and 8 can be used to indicate *
* the number of adjacent empty squares. *
* *
* That board description must be followed by a "b" or "w" to indicate which *
* side is on move. *
* *
* Next, up to 4 characters are used to indicate which side can castle and *
* to which side. An uppercase K means white can castle kingside, while a *
* lowercase q means black can castle queenside. *
* *
* Finally, if there is an enpassant capture possible (the last move was a *
* double pawn move and there was an enemy pawn that could capture it. The *
* square is the square the capturing pawn ends up on. *
* *
* K2R/PPP////q/5ppp/7k/ b - - *
* *
* this assumes that k represents a white king and -q represents a black *
* queen. *
* *
* k * * r * * * * *
* p p p * * * * * *
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
* -q * * * * * * * *
* * * * * * -p -p -p *
* * * * * * * * -k *
* *
*******************************************************************************
*/
void SetBoard(TREE * tree, int nargs, char *args[], int special) {
int twtm, i, match, num, pos, square, tboard[64];
int bcastle, ep, wcastle, error = 0;
char input[80];
static const char bdinfo[] =
{ 'k', 'q', 'r', 'b', 'n', 'p', '*', 'P', 'N', 'B',
'R', 'Q', 'K', '*', '1', '2', '3', '4',
'5', '6', '7', '8', '/'
};
static const char status[13] =
{ 'K', 'Q', 'k', 'q', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
'h', ' '
};
int whichsq;
static const int firstsq[8] = { 56, 48, 40, 32, 24, 16, 8, 0 };
if (special)
strcpy(input, initial_position);
else
strcpy(input, args[0]);
for (i = 0; i < 64; i++)
tboard[i] = 0;
/*
************************************************************
* *
* Scan the input string searching for pieces, numbers *
* [empty squares], slashes [end-of-rank] and a blank *
* [end of board, start of castle status]. *
* *
************************************************************
*/
whichsq = 0;
square = firstsq[whichsq];
num = 0;
for (pos = 0; pos < (int) strlen(args[0]); pos++) {
for (match = 0; match < 23 && args[0][pos] != bdinfo[match]; match++);
if (match > 22)
break;
/*
"/" -> end of this rank.
*/
else if (match == 22) {
num = 0;
if (whichsq > 6)
break;
square = firstsq[++whichsq];
}
/*
"1-8" -> empty squares.
*/
else if (match >= 14) {
num += match - 13;
square += match - 13;
if (num > 8) {
printf("more than 8 squares on one rank\n");
error = 1;
break;
}
continue;
}
/*
piece codes.
*/
else {
if (++num > 8) {
printf("more than 8 squares on one rank\n");
error = 1;
break;
}
tboard[square++] = match - 6;
}
}
/*
************************************************************
* *
* Now extract (a) side to move [w/b], (b) castle status *
* [KkQq for white/black king-side ok, white/black queen- *
* side ok], (c) enpassant target square. *
* *
************************************************************
*/
twtm = 0;
ep = 0;
wcastle = 0;
bcastle = 0;
/*
************************************************************
* *
* Side to move. *
* *
************************************************************
*/
if (args[1][0] == 'w')
twtm = 1;
else if (args[1][0] == 'b')
twtm = 0;
else {
printf("side to move is bad\n");
error = 1;
}
/*
************************************************************
* *
* Castling/enpassant status. *
* *
************************************************************
*/
if (nargs > 2 && strlen(args[2])) {
if (strcmp(args[2], "-")) {
for (pos = 0; pos < (int) strlen(args[2]); pos++) {
for (match = 0; (match < 13) && (args[2][pos] != status[match]);
match++);
if (match == 0)
wcastle += 1;
else if (match == 1)
wcastle += 2;
else if (match == 2)
bcastle += 1;
else if (match == 3)
bcastle += 2;
else if (args[2][0] != '-') {
printf("castling status is bad.\n");
error = 1;
}
}
}
}
if (nargs > 3 && strlen(args[3])) {
if (strcmp(args[3], "-")) {
if (args[3][0] >= 'a' && args[3][0] <= 'h' && args[3][1] > '0' &&
args[3][1] < '9') {
ep = (args[3][1] - '1') * 8 + args[3][0] - 'a';
} else if (args[3][0] != '-') {
printf("enpassant status is bad.\n");
error = 1;
}
}
}
for (i = 0; i < 64; i++)
PcOnSq(i) = tboard[i];
Castle(0, white) = wcastle;
Castle(0, black) = bcastle;
EnPassant(0) = 0;
if (ep) {
if (Rank(ep) == RANK6) {
if (PcOnSq(ep - 8) != -pawn)
ep = 0;
} else if (Rank(ep) == RANK3) {
if (PcOnSq(ep + 8) != pawn)
ep = 0;
} else
ep = 0;
if (!ep) {
printf("enpassant status is bad (must be on 3rd/6th rank only.\n");
ep = 0;
error = 1;
}
EnPassant(0) = ep;
}
Rule50Moves(0) = 0;
/*
************************************************************
* *
* Now check the castling status and enpassant status to *
* make sure that the board is in a state that matches *
* these. *
* *
************************************************************
*/
if (((Castle(0, white) & 2) && (PcOnSq(A1) != rook)) ||
((Castle(0, white) & 1) && (PcOnSq(H1) != rook)) ||
((Castle(0, black) & 2) && (PcOnSq(A8) != -rook)) ||
((Castle(0, black) & 1) && (PcOnSq(H8) != -rook))) {
printf("ERROR-- castling status does not match board position\n");
error = 1;
}
/*
************************************************************
* *
* Now set the bitboards so that error tests can be done. *
* *
************************************************************
*/
if ((twtm && EnPassant(0) && (PcOnSq(EnPassant(0) + 8) != -pawn) &&
(PcOnSq(EnPassant(0) - 7) != pawn) &&
(PcOnSq(EnPassant(0) - 9) != pawn)) || (Flip(twtm) && EnPassant(0)
&& (PcOnSq(EnPassant(0) - 8) != pawn) &&
(PcOnSq(EnPassant(0) + 7) != -pawn) &&
(PcOnSq(EnPassant(0) + 9) != -pawn))) {
EnPassant(0) = 0;
}
SetChessBitBoards(tree);
/*
************************************************************
* *
* Now check the position for a sane position, which *
* means no more than 8 pawns, no more than 10 knights, *
* bishops or rooks, no more than 9 queens, no pawns on *
* 1st or 8th rank, etc. *
* *
************************************************************
*/
wtm = twtm;
error += InvalidPosition(tree);
if (!error) {
if (log_file)
DisplayChessBoard(log_file, tree->pos);
tree->rep_index[white] = 0;
tree->rep_index[black] = 0;
Rule50Moves(0) = 0;
if (!special) {
last_mate_score = 0;
InitializeKillers();
last_pv.pathd = 0;
last_pv.pathl = 0;
tree->pv[0].pathd = 0;
tree->pv[0].pathl = 0;
moves_out_of_book = 0;
}
} else {
if (special)
Print(4095, "bad string = \"%s\"\n", initial_position);
else
Print(4095, "bad string = \"%s\"\n", args[0]);
InitializeChessBoard(tree);
Print(4095, "Illegal position, using normal initial chess position\n");
}
}
/*
********************************************************************************
* *
* Search() is the recursive routine used to implement the alpha/beta *
* negamax search (similar to minimax but simpler to code.) Search() is *
* called whenever there is "depth" remaining so that all moves are subject *
* to searching, or when the side to move is in check, to make sure that this *
* side isn't mated. Search() recursively calls itself until depth is ex- *
* hausted, at which time it calls Quiesce() instead. *
* *
********************************************************************************
*/
int Search(int alpha, int beta, int wtm, int depth, int ply, int do_null)
{
register int first_move=1;
register BITBOARD save_hash_key;
register int initial_alpha, value;
register int extensions;
/*
----------------------------------------------------------
| |
| check to see if we have searched enough nodes that it |
| is time to peek at how much time has been used, or if |
| is time to check for operator keyboard input. this is |
| usually enough nodes to force a time/input check about |
| once per second, except when the target time per move |
| is very small, in which case we try to check the time |
| at least 10 times during the search. |
| |
----------------------------------------------------------
*/
if (ply >= MAXPLY-2) return(beta);
nodes_searched++;
if (--next_time_check <= 0) {
next_time_check=nodes_between_time_checks;
if (CheckInput()) Interrupt(ply);
time_abort+=TimeCheck(0);
if (time_abort) {
abort_search=1;
return(0);
}
}
/*
----------------------------------------------------------
| |
| check for draw by repetition. |
| |
----------------------------------------------------------
*/
if (RepetitionCheck(ply,wtm)) {
value=(wtm==root_wtm) ? DrawScore() : -DrawScore();
if (value < beta) SavePV(ply,value,0);
#if !defined(FAST)
if(ply <= trace_level) printf("draw by repetition detected, ply=%d.\n",ply);
#endif
return(value);
}
/*
----------------------------------------------------------
| |
| now call LookUp() to see if this position has been |
| searched before. if so, we may get a real score, |
| produce a cutoff, or get nothing more than a good move |
| to try first. there are four cases to handle: |
| |
| 1. LookUp() returned "EXACT_SCORE" if this score is |
| greater than beta, return beta. otherwise, return the |
| score. In either case, no further searching is needed |
| from this position. note that lookup verified that |
| the table position has sufficient "draft" to meet the |
| requirements of the current search depth remaining. |
| |
| 2. LookUp() returned "LOWER_BOUND" which means that |
| when this position was searched previously, every move |
| was "refuted" by one of its descendents. as a result, |
| when the search was completed, we returned alpha at |
| that point. we simply return alpha here as well. |
| |
| 3. LookUp() returned "UPPER_BOUND" which means that |
| when we encountered this position before, we searched |
| one branch (probably) which promptly refuted the move |
| at the previous ply. |
| |
| 4. LookUp() returned "AVOID_NULL_MOVE" which means |
| the hashed score/bound was no good, but it indicated |
| that trying a null-move in this position will be a |
| waste of time. |
| |
----------------------------------------------------------
*/
switch (LookUp(ply,depth,wtm,&alpha,beta)) {
case EXACT_SCORE:
if(alpha >= beta) return(beta);
else {
SavePV(ply,alpha,1);
return(alpha);
}
case LOWER_BOUND:
return(alpha);
case UPPER_BOUND:
return(beta);
case AVOID_NULL_MOVE:
do_null=0;
}
/*
----------------------------------------------------------
| |
| now it's time to try a probe into the endgame table- |
| base files. this is done if (a) the previous move was |
| a capture or promotion, unless we are at very shallow |
| plies (<4) in the search; (b) there are less than 5 |
| pieces left (currently all interesting 4 piece endings |
| are available.) |
| |
----------------------------------------------------------
*/
#if defined(TABLEBASES)
if (TotalPieces < 5) do {
register int wpawn, bpawn;
int tb_value;
if (TotalWhitePawns && TotalBlackPawns) {
wpawn=FirstOne(WhitePawns);
bpawn=FirstOne(BlackPawns);
if (FileDistance(wpawn,bpawn) == 1) {
if(((Rank(wpawn)==1) && (Rank(bpawn)>2)) ||
((Rank(bpawn)==6) && (Rank(wpawn)<5)) ||
EnPassant(ply)) break;
}
}
tb_probes++;
if (EGTBScore(ply, wtm, &tb_value)) {
tb_probes_successful++;
alpha=tb_value;
if (abs(alpha) > MATE-100) alpha+=(alpha > 0) ? -(ply-1) : +(ply-1);
else if (alpha == 0) alpha=(wtm==root_wtm) ? DrawScore() : -DrawScore();
if(alpha >= beta) return(beta);
else {
SavePV(ply,alpha,2);
return(alpha);
}
}
} while(0);
# endif
/*
----------------------------------------------------------
| |
| initialize. |
| |
----------------------------------------------------------
*/
in_check[ply+1]=0;
extended_reason[ply+1]=no_extension;
initial_alpha=alpha;
last[ply]=last[ply-1];
killer_count1[ply+1]=0;
killer_count2[ply+1]=0;
/*
----------------------------------------------------------
| |
| first, we try a null move to see if we can get a quick |
| cutoff with only a little work. this operates as |
| follows. instead of making a legal move, the side on |
| move 'passes' and does nothing. the resulting position |
| is searched to a shallower depth than normal (usually |
| one ply less but settable by the operator) this should |
| result in a cutoff or at least should set the lower |
| bound better since anything should be better than not |
| doing anything. |
| |
| this is skipped for any of the following reasons: |
| |
| 1. the side on move is in check. the null move |
| results in an illegal position. |
| 2. no more than one null move can appear in succession |
| or else the search will degenerate into nothing. |
| 3. the side on move has little material left making |
| zugzwang positions more likely. |
| |
----------------------------------------------------------
*/
# if defined(NULL_MOVE_DEPTH)
if (do_null && !in_check[ply] &&
((wtm) ? TotalWhitePieces : TotalBlackPieces)>2) {
current_move[ply]=0;
current_phase[ply]=NULL_MOVE;
#if !defined(FAST)
if (ply <= trace_level)
SearchTrace(ply,depth,wtm,alpha,beta,"Search",0);
#endif
position[ply+1]=position[ply];
Rule50Moves(ply+1)++;
save_hash_key=HashKey;
if (EnPassant(ply)) {
HashEP(EnPassant(ply+1),HashKey);
EnPassant(ply+1)=0;
}
if ((depth-NULL_MOVE_DEPTH-INCREMENT_PLY) >= INCREMENT_PLY)
value=-Search(-beta,-alpha,ChangeSide(wtm),depth-NULL_MOVE_DEPTH-INCREMENT_PLY,ply+1,NO_NULL);
else
value=-Quiesce(-beta,-alpha,ChangeSide(wtm),ply+1);
HashKey=save_hash_key;
if (abort_search) return(0);
if (value >= beta) {
StoreRefutation(ply,depth,wtm,beta);
return(beta);
}
}
# endif
/*
----------------------------------------------------------
| |
| if there is no best move from the hash table, and this |
| is a PV node, then we need a good move to search |
| first. while killers and history moves are good, they |
| are not "good enough". the simplest action is to try |
| a shallow search (depth-2) to get a move. note that |
| when we call Search() with depth-2, it, too, will |
| not have a hash move, and will therefore recursively |
| continue this process, hence the name "internal |
| iterative deepening." |
| |
----------------------------------------------------------
*/
next_status[ply].phase=FIRST_PHASE;
if (hash_move[ply]==0 && (depth > 2*INCREMENT_PLY) &&
(((ply & 1) && alpha == root_alpha && beta == root_beta) ||
(!(ply & 1) && alpha == -root_beta && beta == -root_alpha))) {
current_move[ply]=0;
value=Search(alpha,beta,wtm,depth-2*INCREMENT_PLY,ply,DO_NULL);
if (abort_search) return(0);
if (value <= alpha) {
value=Search(-MATE,beta,wtm,depth-2*INCREMENT_PLY,ply,DO_NULL);
if (abort_search) return(0);
}
else if (value < beta) {
if ((int) pv[ply-1].path_length >= ply) hash_move[ply]=pv[ply-1].path[ply];
}
else hash_move[ply]=current_move[ply];
last[ply]=last[ply-1];
next_status[ply].phase=FIRST_PHASE;
}
/*
----------------------------------------------------------
| |
| now iterate through the move list and search the |
| resulting positions. note that Search() culls any |
| move that is not legal by using Check(). the special |
| case is that we must find one legal move to search to |
| confirm that it's not a mate or draw. |
| |
----------------------------------------------------------
*/
while ((current_phase[ply]=(in_check[ply]) ? NextEvasion(ply,wtm) :
NextMove(depth,ply,wtm))) {
extended_reason[ply]&=check_extension;
#if !defined(FAST)
if (ply <= trace_level) SearchTrace(ply,depth,wtm,alpha,beta,"Search",current_phase[ply]);
#endif
/*
----------------------------------------------------------
| |
| if two successive moves are capture / re-capture so |
| that the material score is restored, extend the search |
| by one ply on the re-capture since it is pretty much |
| forced and easy to analyze. |
| |
----------------------------------------------------------
*/
extensions=-INCREMENT_PLY;
if (Captured(current_move[ply]) && Captured(current_move[ply-1]) &&
To(current_move[ply-1]) == To(current_move[ply]) &&
(p_values[Captured(current_move[ply-1])+7] ==
p_values[Captured(current_move[ply])+7] ||
Promote(current_move[ply-1])) &&
!(extended_reason[ply-1]&recapture_extension)) {
extended_reason[ply]|=recapture_extension;
recapture_extensions_done++;
extensions+=RECAPTURE;
}
/*
----------------------------------------------------------
| |
| if we push a passed pawn, we need to look deeper to |
| see if it is a legitimate threat. |
| |
----------------------------------------------------------
*/
if (Piece(current_move[ply])==pawn && !FutileAhead(wtm) &&
((wtm && To(current_move[ply])>H5 && TotalBlackPieces<16 &&
!And(mask_pawn_passed_w[To(current_move[ply])],BlackPawns)) ||
(!wtm && To(current_move[ply])<A4 && TotalWhitePieces<16 &&
!And(mask_pawn_passed_b[To(current_move[ply])],WhitePawns)) ||
push_extensions[To(current_move[ply])]) &&
Swap(From(current_move[ply]),To(current_move[ply]),wtm) >= 0) {
extended_reason[ply]|=passed_pawn_extension;
passed_pawn_extensions_done++;
extensions+=PASSED_PAWN_PUSH;
}
/*
----------------------------------------------------------
| |
| now make the move and search the resulting position. |
| if we are in check, the current move must be legal |
| since NextEvasion ensures this, otherwise we have to |
| make sure the side-on-move is not in check after the |
| move to weed out illegal moves and save time. |
| |
----------------------------------------------------------
*/
MakeMove(ply,current_move[ply],wtm);
if (in_check[ply] || !Check(wtm)) {
/*
----------------------------------------------------------
| |
| if the move to be made checks the opponent, then we |
| need to remember that he's in check and also extend |
| the depth by one ply for him to get out. |
| |
----------------------------------------------------------
*/
if (Check(ChangeSide(wtm))) {
in_check[ply+1]=1;
extended_reason[ply+1]=check_extension;
check_extensions_done++;
extensions+=IN_CHECK;
}
else {
in_check[ply+1]=0;
extended_reason[ply+1]=no_extension;
}
/*
----------------------------------------------------------
| |
| now we toss in the "razoring" trick, which simply says |
| if we are doing fairly badly, we can reduce the depth |
| an additional ply, if there was nothing at the current |
| ply that caused an extension. |
| |
----------------------------------------------------------
*/
if (depth < 3*INCREMENT_PLY && !in_check[ply] &&
extensions == -INCREMENT_PLY) {
register int val=(wtm) ? Material : -Material;
if (val+1500 < alpha) extensions-=INCREMENT_PLY;
}
/*
----------------------------------------------------------
| |
| if there's only one legal move, extend the search one |
| additional ply since this node is very easy to search. |
| |
----------------------------------------------------------
*/
if (first_move) {
if (last[ply]-last[ply-1] == 1) {
extended_reason[ply]|=one_reply_extension;
one_reply_extensions_done++;
extensions+=ONE_REPLY_TO_CHECK;
}
if (depth+MaxExtensions(extensions) >= INCREMENT_PLY)
value=-Search(-beta,-alpha,ChangeSide(wtm),depth+MaxExtensions(extensions),ply+1,DO_NULL);
else {
value=-Quiesce(-beta,-alpha,ChangeSide(wtm),ply+1);
}
if (abort_search) {
UnMakeMove(ply,current_move[ply],wtm);
return(0);
}
first_move=0;
}
else {
if (depth+MaxExtensions(extensions) >= INCREMENT_PLY)
value=-Search(-alpha-1,-alpha,ChangeSide(wtm),depth+MaxExtensions(extensions),ply+1,DO_NULL);
else {
value=-Quiesce(-alpha-1,-alpha,ChangeSide(wtm),ply+1);
}
if (abort_search) {
UnMakeMove(ply,current_move[ply],wtm);
return(0);
}
if (value>alpha && value<beta) {
if (depth+MaxExtensions(extensions) >= INCREMENT_PLY)
value=-Search(-beta,-alpha,ChangeSide(wtm),depth+MaxExtensions(extensions),ply+1,DO_NULL);
else
value=-Quiesce(-beta,-alpha,ChangeSide(wtm),ply+1);
if (abort_search) {
UnMakeMove(ply,current_move[ply],wtm);
return(0);
}
}
}
if (value > alpha) {
if(value >= beta) {
HistoryRefutation(ply,depth,wtm);
UnMakeMove(ply,current_move[ply],wtm);
StoreRefutation(ply,depth,wtm,beta);
return(beta);
}
alpha=value;
}
}
UnMakeMove(ply,current_move[ply],wtm);
}
/*
----------------------------------------------------------
| |
| all moves have been searched. if none were legal, |
| return either MATE or DRAW depending on whether the |
| side to move is in check or not. |
| |
----------------------------------------------------------
*/
if (first_move == 1) {
value=(Check(wtm)) ? -(MATE-ply) :
((wtm==root_wtm) ? DrawScore() : -DrawScore());
if(value > beta) value=beta;
else if (value < alpha) value=alpha;
if (value >=alpha && value <beta) {
SavePV(ply,value,0);
#if !defined(FAST)
if (ply <= trace_level) printf("Search() no moves! ply=%d\n",ply);
#endif
}
return(value);
}
else {
if (alpha != initial_alpha) {
memcpy(&pv[ply-1].path[ply],&pv[ply].path[ply],(pv[ply].path_length-ply+1)*4);
memcpy(&pv[ply-1].path_hashed,&pv[ply].path_hashed,3);
pv[ply-1].path[ply-1]=current_move[ply-1];
HistoryBest(ply,depth,wtm);
}
StoreBest(ply,depth,wtm,alpha,initial_alpha);
/*
----------------------------------------------------------
| |
| if the 50-move rule is drawing close, then adjust the |
| score to reflect the impending draw. |
| |
----------------------------------------------------------
*/
if (Rule50Moves(ply) > 99) {
value=(wtm==root_wtm) ? DrawScore() : -DrawScore();
if (value < beta) SavePV(ply,value,0);
#if !defined(FAST)
if(ply <= trace_level) printf("draw by 50-move rule detected, ply=%d.\n",ply);
#endif
return(value);
}
return(alpha);
}
}
void ValidatePosition(int ply, int move, char *caller)
{
BITBOARD temp, temp1, temp_occ, temp_occ_rl90, temp_occ_rl45;
BITBOARD temp_occ_rr45, temp_occx, cattacks, rattacks;
int i,square,error;
int temp_score;
/*
first, test w_occupied and b_occupied
*/
error=0;
temp_occ=Or(Or(Or(Or(Or(WhitePawns,WhiteKnights),WhiteBishops),
WhiteRooks),WhiteQueens),WhiteKing);
if(Xor(WhitePieces,temp_occ)) {
Print(1,"ERROR white occupied squares is bad!\n");
Display2BitBoards(temp_occ,WhitePieces);
error=1;
}
temp_occ=Or(Or(Or(Or(Or(BlackPawns,BlackKnights),BlackBishops),
BlackRooks),BlackQueens),BlackKing);
if(Xor(BlackPieces,temp_occ)) {
Print(1,"ERROR black occupied squares is bad!\n");
Display2BitBoards(temp_occ,BlackPieces);
error=1;
}
/*
now test rotated occupied bitboards.
*/
temp_occ_rl90=0;
temp_occ_rl45=0;
temp_occ_rr45=0;
for (i=0;i<64;i++) {
if (PieceOnSquare(i)) {
temp_occ_rl90=Or(temp_occ_rl90,set_mask_rl90[i]);
temp_occ_rl45=Or(temp_occ_rl45,set_mask_rl45[i]);
temp_occ_rr45=Or(temp_occ_rr45,set_mask_rr45[i]);
}
}
if(Xor(OccupiedRL90,temp_occ_rl90)) {
Print(1,"ERROR occupied squares (rotated left 90) is bad!\n");
Display2BitBoards(temp_occ_rl90,OccupiedRL90);
error=1;
}
if(Xor(OccupiedRL45,temp_occ_rl45)) {
Print(1,"ERROR occupied squares (rotated left 45) is bad!\n");
Display2BitBoards(temp_occ_rl45,OccupiedRL45);
error=1;
}
if(Xor(OccupiedRR45,temp_occ_rr45)) {
Print(1,"ERROR occupied squares (rotated right 45) is bad!\n");
Display2BitBoards(temp_occ_rr45,OccupiedRR45);
error=1;
}
/*
now test bishops_queens and rooks_queens
*/
temp_occ=Or(Or(Or(WhiteBishops,WhiteQueens),BlackBishops),
BlackQueens);
if(Xor(BishopsQueens,temp_occ)) {
Print(1,"ERROR bishops_queens is bad!\n");
Display2BitBoards(temp_occ,BishopsQueens);
error=1;
}
temp_occ=Or(Or(Or(WhiteRooks,WhiteQueens),BlackRooks),
BlackQueens);
if(Xor(RooksQueens,temp_occ)) {
Print(1,"ERROR rooks_queens is bad!\n");
Display2BitBoards(temp_occ,RooksQueens);
error=1;
}
/*
check individual piece bit-boards to make sure two pieces
don't occupy the same square (bit)
*/
temp_occ=Xor(Xor(Xor(Xor(Xor(Xor(Xor(Xor(Xor(Xor(Xor(
WhitePawns,WhiteKnights),WhiteBishops),WhiteRooks),
WhiteQueens),BlackPawns),BlackKnights),BlackBishops),
BlackRooks),BlackQueens),WhiteKing),BlackKing);
temp_occx=Or(Or(Or(Or(Or(Or(Or(Or(Or(Or(Or(
WhitePawns,WhiteKnights),WhiteBishops),WhiteRooks),
WhiteQueens),BlackPawns),BlackKnights),BlackBishops),
BlackRooks),BlackQueens),WhiteKing),BlackKing);
if(Xor(temp_occ,temp_occx)) {
Print(1,"ERROR two pieces on same square\n");
error=1;
}
/*
test material_evaluation
*/
temp_score=PopCnt(WhitePawns)*PAWN_VALUE;
temp_score-=PopCnt(BlackPawns)*PAWN_VALUE;
temp_score+=PopCnt(WhiteKnights)*KNIGHT_VALUE;
temp_score-=PopCnt(BlackKnights)*KNIGHT_VALUE;
temp_score+=PopCnt(WhiteBishops)*BISHOP_VALUE;
temp_score-=PopCnt(BlackBishops)*BISHOP_VALUE;
temp_score+=PopCnt(WhiteRooks)*ROOK_VALUE;
temp_score-=PopCnt(BlackRooks)*ROOK_VALUE;
temp_score+=PopCnt(WhiteQueens)*QUEEN_VALUE;
temp_score-=PopCnt(BlackQueens)*QUEEN_VALUE;
if(temp_score != Material) {
Print(1,"ERROR material_evaluation is wrong, good=%d, bad=%d\n",
temp_score,Material);
error=1;
}
temp_score=PopCnt(WhiteKnights)*knight_v;
temp_score+=PopCnt(WhiteBishops)*bishop_v;
temp_score+=PopCnt(WhiteRooks)*rook_v;
temp_score+=PopCnt(WhiteQueens)*queen_v;
if(temp_score != TotalWhitePieces) {
Print(1,"ERROR white_pieces is wrong, good=%d, bad=%d\n",
temp_score,TotalWhitePieces);
error=1;
}
temp_score=PopCnt(WhitePawns);
if(temp_score != TotalWhitePawns) {
Print(1,"ERROR white_pawns is wrong, good=%d, bad=%d\n",
temp_score,TotalWhitePawns);
error=1;
}
temp_score=PopCnt(BlackKnights)*knight_v;
temp_score+=PopCnt(BlackBishops)*bishop_v;
temp_score+=PopCnt(BlackRooks)*rook_v;
temp_score+=PopCnt(BlackQueens)*queen_v;
if(temp_score != TotalBlackPieces) {
Print(1,"ERROR black_pieces is wrong, good=%d, bad=%d\n",
temp_score,TotalBlackPieces);
error=1;
}
temp_score=PopCnt(BlackPawns);
if(temp_score != TotalBlackPawns) {
Print(1,"ERROR black_pawns is wrong, good=%d, bad=%d\n",
temp_score,TotalBlackPawns);
error=1;
}
/*
now test the board[...] to make sure piece values are correct.
*/
/*
test pawn locations
*/
temp=WhitePawns;
while(temp) {
square=FirstOne(temp);
if (PieceOnSquare(square) != pawn) {
Print(1,"ERROR! board[%d]=%d, should be 1\n",square,
PieceOnSquare(square));
error=1;
}
Clear(square,temp);
}
temp=BlackPawns;
while(temp) {
square=FirstOne(temp);
if (PieceOnSquare(square) != -pawn) {
Print(1,"ERROR! board[%d]=%d, should be -1\n",square,
PieceOnSquare(square));
error=1;
}
Clear(square,temp);
}
/*
test knight locations
*/
temp=WhiteKnights;
while(temp) {
square=FirstOne(temp);
if (PieceOnSquare(square) != knight) {
Print(1,"ERROR! board[%d]=%d, should be 2\n",square,
PieceOnSquare(square));
error=1;
}
Clear(square,temp);
}
temp=BlackKnights;
while(temp) {
square=FirstOne(temp);
if (PieceOnSquare(square) != -knight) {
Print(1,"ERROR! board[%d]=%d, should be -2\n",square,
PieceOnSquare(square));
error=1;
}
Clear(square,temp);
}
/*
test bishop locations
*/
temp=WhiteBishops;
while(temp) {
square=FirstOne(temp);
if (PieceOnSquare(square) != bishop) {
Print(1,"ERROR! board[%d]=%d, should be 3\n",square,
PieceOnSquare(square));
error=1;
}
rattacks=AttacksBishop(square);
cattacks=ValidateComputeBishopAttacks(square);
if (rattacks != cattacks) {
Print(1,"ERROR! bishop attacks wrong, square=%d\n",square);
Display2BitBoards(rattacks,cattacks);
error=1;
}
Clear(square,temp);
}
temp=BlackBishops;
while(temp) {
square=FirstOne(temp);
if (PieceOnSquare(square) != -bishop) {
Print(1,"ERROR! board[%d]=%d, should be -3\n",square,
PieceOnSquare(square));
error=1;
}
rattacks=AttacksBishop(square);
cattacks=ValidateComputeBishopAttacks(square);
if (rattacks != cattacks) {
Print(1,"ERROR! bishop attacks wrong, square=%d\n",square);
Display2BitBoards(rattacks,cattacks);
error=1;
}
Clear(square,temp);
}
/*
test rook locations
*/
temp=WhiteRooks;
while(temp) {
square=FirstOne(temp);
if (PieceOnSquare(square) != rook) {
Print(1,"ERROR! board[%d]=%d, should be 4\n",square,
PieceOnSquare(square));
error=1;
}
rattacks=AttacksRook(square);
cattacks=ValidateComputeRookAttacks(square);
if (rattacks != cattacks) {
Print(1,"ERROR! Rook attacks wrong, square=%d\n",square);
Display2BitBoards(rattacks,cattacks);
error=1;
}
Clear(square,temp);
}
temp=BlackRooks;
while(temp) {
square=FirstOne(temp);
if (PieceOnSquare(square) != -rook) {
Print(1,"ERROR! board[%d]=%d, should be -4\n",square,
PieceOnSquare(square));
error=1;
}
rattacks=AttacksRook(square);
cattacks=ValidateComputeRookAttacks(square);
if (rattacks != cattacks) {
Print(1,"ERROR! Rook attacks wrong, square=%d\n",square);
Display2BitBoards(rattacks,cattacks);
error=1;
}
Clear(square,temp);
}
/*
test queen locations
*/
temp=WhiteQueens;
while(temp) {
square=FirstOne(temp);
if (PieceOnSquare(square) != queen) {
Print(1,"ERROR! board[%d]=%d, should be 5\n",square,
PieceOnSquare(square));
error=1;
}
rattacks=AttacksQueen(square);
cattacks=Or(ValidateComputeRookAttacks(square),ValidateComputeBishopAttacks(square));
if (rattacks != cattacks) {
Print(1,"ERROR! queen attacks wrong, square=%d\n",square);
Display2BitBoards(rattacks,cattacks);
error=1;
}
Clear(square,temp);
}
temp=BlackQueens;
while(temp) {
square=FirstOne(temp);
if (PieceOnSquare(square) != -queen) {
Print(1,"ERROR! board[%d]=%d, should be -5\n",square,
PieceOnSquare(square));
error=1;
}
rattacks=AttacksQueen(square);
cattacks=Or(ValidateComputeRookAttacks(square),ValidateComputeBishopAttacks(square));
if (rattacks != cattacks) {
Print(1,"ERROR! queen attacks wrong, square=%d\n",square);
Display2BitBoards(rattacks,cattacks);
error=1;
}
Clear(square,temp);
}
/*
test king locations
*/
temp=WhiteKing;
while(temp) {
square=FirstOne(temp);
if (PieceOnSquare(square) != king) {
Print(1,"ERROR! board[%d]=%d, should be 6\n",square,
PieceOnSquare(square));
error=1;
}
if (WhiteKingSQ != square) {
Print(1,"ERROR! white_king is %d, should be %d\n",
WhiteKingSQ,square);
error=1;
}
Clear(square,temp);
}
temp=BlackKing;
while(temp) {
square=FirstOne(temp);
if (PieceOnSquare(square) != -king) {
Print(1,"ERROR! board[%d]=%d, should be -6\n",square,
PieceOnSquare(square));
error=1;
}
if (BlackKingSQ != square) {
Print(1,"ERROR! black_king is %d, should be %d\n",
BlackKingSQ,square);
error=1;
}
Clear(square,temp);
}
/*
test board[i] fully now.
*/
for (i=0;i<64;i++)
switch (PieceOnSquare(i)) {
case -king:
if (!And(BlackKing,set_mask[i])) {
Print(1,"ERROR! b_king/board[%d] don't agree!\n",i);
error=1;
}
break;
case -queen:
if (!And(BlackQueens,set_mask[i])) {
Print(1,"ERROR! b_queen/board[%d] don't agree!\n",i);
error=1;
}
break;
case -rook:
if (!And(BlackRooks,set_mask[i])) {
Print(1,"ERROR! b_rook/board[%d] don't agree!\n",i);
error=1;
}
break;
case -bishop:
if (!And(BlackBishops,set_mask[i])) {
Print(1,"ERROR! b_bishop/board[%d] don't agree!\n",i);
error=1;
}
break;
case -knight:
if (!And(BlackKnights,set_mask[i])) {
Print(1,"ERROR! b_knight/board[%d] don't agree!\n",i);
error=1;
}
break;
case -pawn:
if (!And(BlackPawns,set_mask[i])) {
Print(1,"ERROR! b_pawn/board[%d] don't agree!\n",i);
error=1;
}
break;
case king:
if (!And(WhiteKing,set_mask[i])) {
Print(1,"ERROR! w_king/board[%d] don't agree!\n",i);
error=1;
}
break;
case queen:
if (!And(WhiteQueens,set_mask[i])) {
Print(1,"ERROR! w_queen/board[%d] don't agree!\n",i);
error=1;
}
break;
case rook:
if (!And(WhiteRooks,set_mask[i])) {
Print(1,"ERROR! w_rook/board[%d] don't agree!\n",i);
error=1;
}
break;
case bishop:
if (!And(WhiteBishops,set_mask[i])) {
Print(1,"ERROR! w_bishop/board[%d] don't agree!\n",i);
error=1;
}
break;
case knight:
if (!And(WhiteKnights,set_mask[i])) {
Print(1,"ERROR! w_knight/board[%d] don't agree!\n",i);
error=1;
}
break;
case pawn:
if (!And(WhitePawns,set_mask[i])) {
Print(1,"ERROR! w_pawn/board[%d] don't agree!\n",i);
error=1;
}
break;
}
/*
test empty squares now
*/
temp=Compl(Or(temp_occ,temp_occx));
while(temp) {
square=FirstOne(temp);
if (PieceOnSquare(square)) {
Print(1,"ERROR! board[%d]=%d, should be 0\n",square,
PieceOnSquare(square));
error=1;
}
Clear(square,temp);
}
/*
test total piece count now
*/
temp=PopCnt(Occupied);
if (temp != TotalPieces) {
Print(1,"ERROR! TotalPieces is wrong, correct=%d bad=%d\n",
temp,TotalPieces);
error=1;
}
/*
test hash key
*/
temp=0;
temp1=0;
for (i=0;i<64;i++) {
switch (PieceOnSquare(i)) {
case king:
temp=Xor(temp,w_king_random[i]);
break;
case queen:
temp=Xor(temp,w_queen_random[i]);
break;
case rook:
temp=Xor(temp,w_rook_random[i]);
break;
case bishop:
temp=Xor(temp,w_bishop_random[i]);
break;
case knight:
temp=Xor(temp,w_knight_random[i]);
break;
case pawn:
temp=Xor(temp,w_pawn_random[i]);
temp1=Xor(temp1,w_pawn_random[i]);
break;
case -pawn:
temp=Xor(temp,b_pawn_random[i]);
temp1=Xor(temp1,b_pawn_random[i]);
break;
case -knight:
temp=Xor(temp,b_knight_random[i]);
break;
case -bishop:
temp=Xor(temp,b_bishop_random[i]);
break;
case -rook:
temp=Xor(temp,b_rook_random[i]);
break;
case -queen:
temp=Xor(temp,b_queen_random[i]);
break;
case -king:
temp=Xor(temp,b_king_random[i]);
break;
default:
break;
}
}
if (EnPassant(ply)) HashEP(EnPassant(ply),temp);
if (!(WhiteCastle(ply)&1)) HashCastleW(0,temp);
if (!(WhiteCastle(ply)&2)) HashCastleW(1,temp);
if (!(BlackCastle(ply)&1)) HashCastleB(0,temp);
if (!(BlackCastle(ply)&2)) HashCastleB(1,temp);
if(Xor(temp,HashKey)) {
Print(1,"ERROR! hash_key is bad.\n");
error=1;
}
if(Xor(temp1,PawnHashKey)) {
Print(1,"ERROR! pawn_hash_key is bad.\n");
error=1;
}
if (error) {
/*
Print(0,"active path:\n");
for (i=1;i<=ply;i++)
DisplayChessMove("move=",move);
*/
Print(0,"current move:\n");
DisplayChessMove("move=",move);
DisplayChessBoard(stdout,search);
Print(0,"called from %s, ply=%d\n",caller,ply);
Print(0,"node=%d\n",nodes_searched+q_nodes_searched);
exit(1);
}
}
void UnMakeMove(int ply, int move, int wtm)
{
register int piece, from, to, captured, promote;
/*
----------------------------------------------------------
| |
| first, take care of the hash key if there's a possible |
| enpassant pawn capture. |
| |
----------------------------------------------------------
*/
HashKey=save_hash_key[ply];
PawnHashKey=save_pawn_hash_key[ply];
/*
----------------------------------------------------------
| |
| now do the piece-specific things by calling the |
| appropriate routine. |
| |
----------------------------------------------------------
*/
piece=Piece(move);
from=From(move);
to=To(move);
captured=Captured(move);
promote=Promote(move);
UnMakePieceMove:
SetRL90(from,OccupiedRL90);
SetRL45(from,OccupiedRL45);
SetRR45(from,OccupiedRR45);
ClearRL90(to,OccupiedRL90);
ClearRL45(to,OccupiedRL45);
ClearRR45(to,OccupiedRR45);
bit_move=Or(set_mask[from],set_mask[to]);
PieceOnSquare(to)=0;
switch (piece) {
/*
********************************************************************************
* *
* unmake pawn moves. *
* *
********************************************************************************
*/
case pawn:
if (wtm) {
ClearSet(bit_move,WhitePawns);
ClearSet(bit_move,WhitePieces);
PieceOnSquare(from)=pawn;
if (captured == 1) {
if(EnPassant(ply) == to) {
TotalPieces++;
SetRL90(to-8,OccupiedRL90);
SetRL45(to-8,OccupiedRL45);
SetRR45(to-8,OccupiedRR45);
Set(to-8,BlackPawns);
Set(to-8,BlackPieces);
PieceOnSquare(to-8)=-pawn;
Material-=PAWN_VALUE;
TotalBlackPawns++;
captured=0;
}
}
/*
--------------------------------------------------------------------
| |
| if this is a pawn promotion, remove the pawn from the counts |
| then update the correct piece board to reflect the piece just |
| created. |
| |
--------------------------------------------------------------------
*/
if (promote) {
TotalWhitePawns++;
Material+=PAWN_VALUE;
Clear(to,WhitePawns);
Clear(to,WhitePieces);
switch (promote) {
case knight:
Clear(to,WhiteKnights);
TotalWhitePieces-=knight_v;
Material-=KNIGHT_VALUE;
break;
case bishop:
Clear(to,WhiteBishops);
Clear(to,BishopsQueens);
TotalWhitePieces-=bishop_v;
Material-=BISHOP_VALUE;
break;
case rook:
Clear(to,WhiteRooks);
Clear(to,RooksQueens);
TotalWhitePieces-=rook_v;
Material-=ROOK_VALUE;
break;
case queen:
Clear(to,WhiteQueens);
Clear(to,BishopsQueens);
Clear(to,RooksQueens);
TotalWhitePieces-=queen_v;
Material-=QUEEN_VALUE;
break;
}
}
}
else {
ClearSet(bit_move,BlackPawns);
ClearSet(bit_move,BlackPieces);
PieceOnSquare(from)=-pawn;
if (captured == 1) {
if(EnPassant(ply) == to) {
TotalPieces++;
SetRL90(to+8,OccupiedRL90);
SetRL45(to+8,OccupiedRL45);
SetRR45(to+8,OccupiedRR45);
Set(to+8,WhitePawns);
Set(to+8,WhitePieces);
PieceOnSquare(to+8)=pawn;
Material+=PAWN_VALUE;
TotalWhitePawns++;
captured=0;
}
}
/*
--------------------------------------------------------------------
| |
| if this is a pawn promotion, remove the pawn from the counts |
| then update the correct piece board to reflect the piece just |
| created. |
| |
--------------------------------------------------------------------
*/
if (promote) {
TotalBlackPawns++;
Material-=PAWN_VALUE;
Clear(to,BlackPawns);
Clear(to,BlackPieces);
switch (promote) {
case knight:
Clear(to,BlackKnights);
TotalBlackPieces-=knight_v;
Material+=KNIGHT_VALUE;
break;
case bishop:
Clear(to,BlackBishops);
Clear(to,BishopsQueens);
TotalBlackPieces-=bishop_v;
Material+=BISHOP_VALUE;
break;
case rook:
Clear(to,BlackRooks);
Clear(to,RooksQueens);
TotalBlackPieces-=rook_v;
Material+=ROOK_VALUE;
break;
case queen:
Clear(to,BlackQueens);
Clear(to,BishopsQueens);
Clear(to,RooksQueens);
TotalBlackPieces-=queen_v;
Material+=QUEEN_VALUE;
break;
}
}
}
break;
/*
********************************************************************************
* *
* unmake knight moves. *
* *
********************************************************************************
*/
case knight:
if (wtm) {
ClearSet(bit_move,WhiteKnights);
ClearSet(bit_move,WhitePieces);
PieceOnSquare(from)=knight;
}
else {
ClearSet(bit_move,BlackKnights);
ClearSet(bit_move,BlackPieces);
PieceOnSquare(from)=-knight;
}
break;
/*
********************************************************************************
* *
* unmake bishop moves. *
* *
********************************************************************************
*/
case bishop:
ClearSet(bit_move,BishopsQueens);
if (wtm) {
ClearSet(bit_move,WhiteBishops);
ClearSet(bit_move,WhitePieces);
PieceOnSquare(from)=bishop;
}
else {
ClearSet(bit_move,BlackBishops);
ClearSet(bit_move,BlackPieces);
PieceOnSquare(from)=-bishop;
}
break;
/*
********************************************************************************
* *
* unmake rook moves. *
* *
********************************************************************************
*/
case rook:
ClearSet(bit_move,RooksQueens);
if (wtm) {
ClearSet(bit_move,WhiteRooks);
ClearSet(bit_move,WhitePieces);
PieceOnSquare(from)=rook;
}
else {
ClearSet(bit_move,BlackRooks);
ClearSet(bit_move,BlackPieces);
PieceOnSquare(from)=-rook;
}
break;
/*
********************************************************************************
* *
* unmake queen moves. *
* *
********************************************************************************
*/
case queen:
ClearSet(bit_move,BishopsQueens);
ClearSet(bit_move,RooksQueens);
if (wtm) {
ClearSet(bit_move,WhiteQueens);
ClearSet(bit_move,WhitePieces);
PieceOnSquare(from)=queen;
}
else {
ClearSet(bit_move,BlackQueens);
ClearSet(bit_move,BlackPieces);
PieceOnSquare(from)=-queen;
}
break;
/*
********************************************************************************
* *
* unmake king moves. *
* *
********************************************************************************
*/
case king:
if (wtm) {
ClearSet(bit_move,WhitePieces);
PieceOnSquare(from)=king;
WhiteKingSQ=from;
if (abs(to-from) == 2) {
if (to == 6) {
from=H1;
to=F1;
piece=rook;
goto UnMakePieceMove;
}
else {
from=A1;
to=D1;
piece=rook;
goto UnMakePieceMove;
}
}
}
else {
ClearSet(bit_move,BlackPieces);
PieceOnSquare(from)=-king;
BlackKingSQ=from;
if (abs(to-from) == 2) {
if (to == 62) {
from=H8;
to=F8;
piece=rook;
goto UnMakePieceMove;
}
else {
from=A8;
to=D8;
piece=rook;
goto UnMakePieceMove;
}
}
}
break;
}
/*
********************************************************************************
* *
* now it is time to restore a piece that was captured. *
* *
********************************************************************************
*/
if(captured) {
TotalPieces++;
SetRL90(to,OccupiedRL90);
SetRL45(to,OccupiedRL45);
SetRR45(to,OccupiedRR45);
switch (captured) {
/*
----------------------------------------------------------
| |
| restore a captured pawn. |
| |
----------------------------------------------------------
*/
case pawn:
if (wtm) {
Set(to,BlackPawns);
Set(to,BlackPieces);
PieceOnSquare(to)=-pawn;
Material-=PAWN_VALUE;
TotalBlackPawns++;
}
else {
Set(to,WhitePawns);
Set(to,WhitePieces);
PieceOnSquare(to)=pawn;
Material+=PAWN_VALUE;
TotalWhitePawns++;
}
break;
/*
----------------------------------------------------------
| |
| restore a captured knight. |
| |
----------------------------------------------------------
*/
case knight:
if (wtm) {
Set(to,BlackKnights);
Set(to,BlackPieces);
PieceOnSquare(to)=-knight;
TotalBlackPieces+=knight_v;
Material-=KNIGHT_VALUE;
}
else {
Set(to,WhiteKnights);
Set(to,WhitePieces);
PieceOnSquare(to)=knight;
TotalWhitePieces+=knight_v;
Material+=KNIGHT_VALUE;
}
break;
/*
----------------------------------------------------------
| |
| restore a captured bishop. |
| |
----------------------------------------------------------
*/
case bishop:
Set(to,BishopsQueens);
if (wtm) {
Set(to,BlackBishops);
Set(to,BlackPieces);
PieceOnSquare(to)=-bishop;
TotalBlackPieces+=bishop_v;
Material-=BISHOP_VALUE;
}
else {
Set(to,WhiteBishops);
Set(to,WhitePieces);
PieceOnSquare(to)=bishop;
TotalWhitePieces+=bishop_v;
Material+=BISHOP_VALUE;
}
break;
/*
----------------------------------------------------------
| |
| restore a captured rook. |
| |
----------------------------------------------------------
*/
case rook:
Set(to,RooksQueens);
if (wtm) {
Set(to,BlackRooks);
Set(to,BlackPieces);
PieceOnSquare(to)=-rook;
TotalBlackPieces+=rook_v;
Material-=ROOK_VALUE;
}
else {
Set(to,WhiteRooks);
Set(to,WhitePieces);
PieceOnSquare(to)=rook;
TotalWhitePieces+=rook_v;
Material+=ROOK_VALUE;
}
break;
/*
----------------------------------------------------------
| |
| restore a captured queen. |
| |
----------------------------------------------------------
*/
case queen:
Set(to,BishopsQueens);
Set(to,RooksQueens);
if (wtm) {
Set(to,BlackQueens);
Set(to,BlackPieces);
PieceOnSquare(to)=-queen;
TotalBlackPieces+=queen_v;
Material-=QUEEN_VALUE;
}
else {
Set(to,WhiteQueens);
Set(to,WhitePieces);
PieceOnSquare(to)=queen;
TotalWhitePieces+=queen_v;
Material+=QUEEN_VALUE;
}
break;
/*
----------------------------------------------------------
| |
| restore a captured king. [this is an error condition] |
| |
----------------------------------------------------------
*/
case king:
printf("captured a king\n");
printf("piece=%d,from=%d,to=%d,captured=%d\n",
piece,from,to,captured);
printf("ply=%d\n",ply);
if (log_file) DisplayChessBoard(log_file,search);
}
}
#if defined(DEBUG)
ValidatePosition(ply,move,"UnMakeMove(2)");
#endif
return;
}
