#include #include #include #include #include "chess.h" #include "data.h" #if defined(UNIX) # include #endif /* last modified 03/27/01 */ /* ******************************************************************************** * * * Book() is used to determine if the current position is in the book data- * * base. it simply takes the set of moves produced by root_moves() and then * * tries each position's hash key to see if it can be found in the data- * * base. if so, such a move represents a "book move." the set of flags is * * used to decide on a sub-set of moves to be used as the "book move pool" * * from which a move is chosen randomly. * * * * the format of a book position is as follows: * * * * 64 bits: hash key for this position. * * * * 8 bits: flag bits defined as follows: * * * * 0000 0001 ?? flagged move (0001) (0x01) * * 0000 0010 ? flagged move (0002) (0x02) * * 0000 0100 = flagged move (0004) (0x04) * * 0000 1000 ! flagged move (0010) (0x08) * * 0001 0000 !! flagged move (0020) (0x10) * * 0010 0000 black won at least 1 game (0040) (0x20) * * 0100 0000 at least one game was drawn (0100) (0x40) * * 1000 0000 white won at least 1 game (0200) (0x80) * * * * 24 bits: number of games this move was played. * * * * 32 bits: learned value (floating point). * * * * 32 bits: CAP score for this move (integer). * * * * (note: counts are normalized to a max of 255. * * * ******************************************************************************** */ #define BAD_MOVE 002 #define GOOD_MOVE 010 int Book(TREE *tree, int wtm, int root_list_done) { static int book_moves[200]; static BOOK_POSITION start_moves[200]; static int selected[200]; static int selected_order_played[200], selected_value[200]; static int selected_status[200], selected_percent[200], book_development[200]; static int bs_played[200], bs_percent[200]; static int book_status[200], evaluations[200], bs_learn[200], bs_CAP[200]; static float bs_value[200], total_value; int m1_status, forced=0, total_percent; float tempr; int done, i, j, last_move, temp, which, minlv=999999, maxlv=-999999, cap; int mincap=999999, maxcap=-999999, maxp=-999999, minev=999999, maxev=-999999; int nflagged, im, value, np, book_ponder_move; int cluster, scluster, test; BITBOARD temp_hash_key, common; int key, nmoves, num_selected, st; int percent_played, total_played, total_moves, smoves; int distribution; int initial_development; char *whisper_p; /* ---------------------------------------------------------- | | | if we have been out of book for several moves, return | | and start the normal tree search. | | | ---------------------------------------------------------- */ if (moves_out_of_book > 3) return(0); /* ---------------------------------------------------------- | | | position is known, read the start book file and save | | each move found. these will be used later to augment | | the flags in the normal book to offer better control. | | | ---------------------------------------------------------- */ if (!root_list_done) RootMoveList(wtm); test=HashKey>>49; smoves=0; if (books_file) { fseek(books_file,test*sizeof(int),SEEK_SET); fread(&key,sizeof(int),1,books_file); if (key > 0) { fseek(books_file,key,SEEK_SET); fread(&scluster,sizeof(int),1,books_file); fread(books_buffer,sizeof(BOOK_POSITION),scluster,books_file); for (im=0;im>49; if (book_file) { fseek(book_file,test*sizeof(int),SEEK_SET); fread(&key,sizeof(int),1,book_file); if (key > 0) { fseek(book_file,key,SEEK_SET); fread(&cluster,sizeof(int),1,book_file); fread(book_buffer,sizeof(BOOK_POSITION),cluster,book_file); } else cluster=0; if (!cluster) return(0); /* ---------------------------------------------------------- | | | now add any moves from books.bin to the end of the | | cluster so that they will be played even if not in the | | regular database of moves. | | | ---------------------------------------------------------- */ for (i=0;i= cluster) { book_buffer[cluster]=start_moves[i]; book_buffer[cluster].status_played= book_buffer[cluster].status_played&037700000000; cluster++; } } /* ---------------------------------------------------------- | | | first cycle through the root move list, make each | | move, and see if the resulting hash key is in the book | | database. | | | ---------------------------------------------------------- */ initial_development=(wtm) ? EvaluateDevelopmentW(tree,1) : EvaluateDevelopmentB(tree,1); total_moves=0; nmoves=0; for (im=0;im>24; bs_played[nmoves]=book_buffer[i].status_played&077777777; bs_learn[nmoves]=(int) (book_buffer[i].learn*100.0); if (!wtm) bs_learn[nmoves]*=-1; bs_CAP[nmoves]=book_buffer[i].CAP_score; if (puzzling) bs_played[nmoves]+=1; tree->current_move[1]=root_moves[im].move; if (!Captured(root_moves[im].move)) book_development[nmoves]=((wtm) ? EvaluateDevelopmentW(tree,2) : EvaluateDevelopmentB(tree,2))-initial_development; else book_development[nmoves]=0; total_moves+=bs_played[nmoves]; evaluations[nmoves]=Evaluate(tree,2,wtm,-999999,999999); evaluations[nmoves]-=(wtm) ? Material : -Material; bs_percent[nmoves]=0; for (j=0;j>24; bs_percent[nmoves]=start_moves[j].status_played&077777777; break; } } book_moves[nmoves]=root_moves[im].move; if (BookRejectMove(tree,wtm)) book_status[nmoves]|=BAD_MOVE; nmoves++; break; } } UnmakeMove(tree,1,root_moves[im].move,wtm); } if (!nmoves) return(0); /* ---------------------------------------------------------- | | | if any moves have a very bad or a very good learn | | value, set the appropriate ? or ! flag so the move | | be played or avoided as appropriate. | | | ---------------------------------------------------------- */ for (i=0;i= LEARN_COUNTER_GOOD && !(book_status[i] & 003)) book_status[i]|=GOOD_MOVE; if (bs_CAP[i]>=CAP_SCORE_GOOD && !(book_status[i] & 003)) book_status[i]|=GOOD_MOVE; if (bs_CAP[i]<=CAP_SCORE_BAD && bs_CAP[i]!=-2*MATE && !(book_status[i]&003)) book_status[i]|=BAD_MOVE; if (bs_percent[i]) book_status[i]|=GOOD_MOVE; } /* ---------------------------------------------------------- | | | we have the book moves, now it's time to decide how | | they are supposed to be sorted and compute the sort | | index. | | | ---------------------------------------------------------- */ for (i=0;i99) ? 99 : total_percent; for (i=0;ipv[1].path[1]=book_moves[0]; tree->pv[1].pathl=1; tree->pv[1].pathd=0; } return(1); } } /* ---------------------------------------------------------- | | | if puzzling, in tournament mode we try to find the | | best non-book move, because a book move will produce | | a quick move anyway. we therefore would rather search | | for a non-book move, just in case the opponent goes | | out of book here. | | | ---------------------------------------------------------- */ else if (mode==tournament_mode && puzzling && !auto232) { RootMoveList(wtm); for (i=0;i 1) { last_pv.pathd=0; booking=1; (void) Iterate(wtm,booking,1); booking=0; } else { tree->pv[1].path[1]=book_moves[0]; tree->pv[1].pathl=1; tree->pv[1].pathd=0; } return(1); } last_move=nmoves; /* ---------------------------------------------------------- | | | compute a random value and use this to generate a | | book move based on a probability distribution of | | the number of games won by each book move. | | | ---------------------------------------------------------- */ which=Random32(); j=ReadClock(microseconds)/100 % 13; for (i=0;ipv[1].path[1]=book_moves[which]; percent_played=100*bs_played[which]/Max(total_played,1); total_played=bs_played[which]; m1_status=book_status[which]; tree->pv[1].pathl=1; tree->pv[1].pathd=0; if (mode != tournament_mode) { MakeMove(tree,1,book_moves[which],wtm); if ((book_ponder_move=BookPonderMove(tree,ChangeSide(wtm)))) { tree->pv[1].path[2]=book_ponder_move; tree->pv[1].pathl=2; } UnmakeMove(tree,1,book_moves[which],wtm); } Print(128," book 0.0s %3d%% ", percent_played); Print(128," %s",OutputMove(tree,tree->pv[1].path[1],1,wtm)); st=m1_status & book_accept_mask & (~224); if (st) { if (st & 1) Print(128,"??"); else if (st & 2) Print(128,"?"); else if (st & 4) Print(128,"="); else if (st & 8) Print(128,"!"); else if (st & 16) Print(128,"!!"); } MakeMove(tree,1,tree->pv[1].path[1],wtm); if (tree->pv[1].pathl>1) Print(128," %s",OutputMove(tree,tree->pv[1].path[2],2,ChangeSide(wtm))); UnmakeMove(tree,1,tree->pv[1].path[1],wtm); Print(128,"\n"); return(1); } return(0); } /* last modified 09/27/99 */ /* ******************************************************************************** * * * BookPonderMove() is used to find a move to ponder, to avoid the overhead * * of a "puzzling" search early in the game (unless there are no book moves * * found, of course.) the algorithm is much simpler than the normal book * * move code... just find the move with the largest frequency counter and * * assume that will be played. * * * ******************************************************************************** */ int BookPonderMove(TREE *tree, int wtm) { BITBOARD temp_hash_key, common; static int book_moves[200]; int i, key, *lastm, cluster, n_moves, im, played, tplayed; int book_ponder_move=0, test; /* ---------------------------------------------------------- | | | position is known, read in the appropriate cluster. | | note that this cluster will have all possible book | | moves from current position in it (as well as others | | of course.) | | | ---------------------------------------------------------- */ if (book_file) { test=HashKey>>49; fseek(book_file,test*sizeof(int),SEEK_SET); fread(&key,sizeof(int),1,book_file); if (key > 0) { fseek(book_file,key,SEEK_SET); fread(&cluster,sizeof(int),1,book_file); fread(book_buffer,sizeof(BOOK_POSITION),cluster,book_file); } else cluster=0; if (!cluster) return(0); lastm=GenerateCaptures(tree, 2, wtm, book_moves); lastm=GenerateNonCaptures(tree, 2, wtm, lastm); n_moves=lastm-book_moves; /* ---------------------------------------------------------- | | | first cycle through the root move list, make each | | move, and see if the resulting hash key is in the book | | database. | | | ---------------------------------------------------------- */ played=-1; for (im=0;im played) { played=tplayed; book_ponder_move=book_moves[im]; } break; } } UnmakeMove(tree,2,book_moves[im],wtm); } } return(book_ponder_move); } /* last modified 03/19/01 */ /* ******************************************************************************** * * * BookUp() is used to create/add to the opening book file. typing "book * * create" will erase the old book file and start from scratch, typing "book * * add" will simply add more moves to the existing file. * * * * the format of the input data is a left bracket ("[") followed by any title * * information desired, followed by a right bracket ("]") followed by a * * sequence of moves. the sequence of moves is assumed to start at ply=1, * * with white-to-move (normal opening position) and can contain as many moves * * as desired (no limit on the depth of each variation.) the file *must* be * * terminated with a line that begins with "end", since handling the EOF * * condition makes portable code difficult. * * * * book moves can either be typed in by hand, directly into book_add(), by * * using the "book create/add" command. using the command "book add/create * * filename" will cause book_add() to read its opening text moves from * * filename rather than from the key * * * * in addition to the normal text for a move (reduced or full algebraic is * * accepted, ie, e4, ed, exd4, e3d4, etc. are all acceptable) some special * * characters can be appended to a move. * * * * ?? -> never play this move. since the same book is used for both * * black and white, you can enter moves in that white might play, * * but prevent the program from choosing them on its own. * * ? -> avoid this move except for non-important games. these openings * * are historically those that the program doesn't play very well, * * but which aren't outright losing. * * = -> drawish move, only play this move if drawish moves are allowed * * by the operator. this is used to encourage the program to play * * drawish openings (Petrov's comes to mind) when the program needs * * to draw or is facing a formidable opponent (deep thought comes * * to mind.) * * ! -> always play this move, if there isn't a move with the !! flag * * set also. this is a strong move, but not as strong as a !! * * moveing traps. * * !! -> always play this move. this can be used to make the program * * favor particular lines, or to mark a strong move for certain * * opening traps. * * * * {play nn%} is used to force this specific book move to be played a specific * * percentage of the time, and override the frequency of play that * * comes from the large pgn database. * * * ******************************************************************************** */ void BookUp(TREE *tree, char *output_filename, int nargs, char **args) { BB_POSITION *bbuffer; BITBOARD temp_hash_key, common; FILE *book_input; char fname[128], start, *ch; static char schar[2]={"."}; int result=0, played, i, mask_word, total_moves; int move, move_num, wtm, book_positions, major, minor; int cluster, max_cluster, discarded=0, discarded_mp=0, discarded_lose=0; int errors, data_read; int start_cpu_time, start_elapsed_time, ply, max_ply=256; int stat, files=0, buffered=0, min_played=0, games_parsed=0; int wins, losses; BOOK_POSITION current, next; BB_POSITION temp; int last, cluster_seek, next_cluster; int counter, *index, max_search_depth; double wl_percent=0.0; /* ---------------------------------------------------------- | | | open the correct book file for writing/reading | | | ---------------------------------------------------------- */ if (!strcmp(args[0],"create")) { if (nargs < 3) { Print(4095,"usage: book|books create filename "); Print(4095,"maxply [minplay] [win/lose %]\n"); return; } max_ply=atoi(args[2]); if (nargs >= 4) { min_played=atoi(args[3]); } if (nargs > 4) { wl_percent=atof(args[4])/100.0; } } else if (!strcmp(args[0],"off")) { if (book_file) fclose(book_file); if (books_file) fclose(books_file); book_file=0; books_file=0; Print(4095,"book file disabled.\n"); return; } else if (!strcmp(args[0],"on")) { if (!book_file) { #if defined (MACOS) sprintf(fname,":%s:book.bin",book_path); book_file=fopen(fname,"rb+"); sprintf(fname,":%s:books.bin",book_path); books_file=fopen(fname,"rb+"); #else sprintf(fname,"%s/book.bin",book_path); book_file=fopen(fname,"rb+"); sprintf(fname,"%s/books.bin",book_path); books_file=fopen(fname,"rb+"); #endif Print(4095,"book file enabled.\n"); } return; } else if (!strcmp(args[0],"mask")) { if (nargs < 3) { Print(4095,"usage: book mask accept|reject value\n"); return; } else if (!strcmp(args[1],"accept")) { book_accept_mask=BookMask(args[2]); book_reject_mask=book_reject_mask & ~book_accept_mask; return; } else if (!strcmp(args[1],"reject")) { book_reject_mask=BookMask(args[2]); book_accept_mask=book_accept_mask & ~book_reject_mask; return; } } else if (!strcmp(args[0],"random")) { if (nargs < 2) { Print(4095,"usage: book random \n"); return; } book_random=atoi(args[1]); switch (book_random) { case 0: Print(4095,"play best book line after search.\n"); break; case 1: Print(4095,"choose from book moves randomly (using weights.)\n"); break; default: Print(4095,"valid options are 0-1.\n"); break; } return; } else if (!strcmp(args[0],"trigger")) { if (nargs < 2) { Print(4095,"usage: book trigger \n"); return; } book_search_trigger=atoi(args[1]); Print(4095,"search book moves if the most popular was not played\n"); Print(4095,"at least %d times.\n", book_search_trigger); return; } else if (!strcmp(args[0],"width")) { if (nargs < 2) { Print(4095,"usage: book width \n"); return; } book_selection_width=atoi(args[1]); Print(4095,"choose from %d best moves.\n", book_selection_width); return; } else { Print(4095,"usage: book [option] [filename] [maxply] [minplay]\n"); return; } if (!(book_input=fopen(args[1],"r"))) { printf("file %s does not exist.\n",args[1]); return; } ReadPGN(0,0); if (book_file) fclose(book_file); book_file=fopen(output_filename,"wb+"); bbuffer=(BB_POSITION *) malloc(sizeof(BB_POSITION)*SORT_BLOCK); if (!bbuffer) { Print(4095,"Unable to malloc() sort buffer, aborting\n"); exit(1); } fseek(book_file,0,SEEK_SET); /* ---------------------------------------------------------- | | | now, read in a series of moves (terminated by the "[" | | of the next title or by "end" for end of the file) | | and make them. after each MakeMove(), we can grab | | the hash key, and use it to access the book data file | | to add this position. note that we have to check the | | last character of a move for the special flags and | | set the correct bit in the status for this position. | | when we reach the end of a book line, we back up to | | the starting position and start over. | | | ---------------------------------------------------------- */ start=!strstr(output_filename,"book.bin"); printf("parsing pgn move file (100k moves/dot)\n"); start_cpu_time=ReadClock(cpu); start_elapsed_time=ReadClock(elapsed); if (book_file) { total_moves=0; max_search_depth=0; errors=0; do { data_read=ReadPGN(book_input,0); if (data_read == -1) Print(4095,"end-of-file reached\n"); } while (data_read == 0); do { if (data_read < 0) { Print(4095,"end-of-file reached\n"); break; } if (data_read == 1) { if (strstr(buffer,"Site")) { games_parsed++; result=3; } else if (strstr(buffer,"esult")) { if (strstr(buffer,"1-0")) result=2; else if (strstr(buffer,"0-1")) result=1; else if (strstr(buffer,"1/2-1/2")) result=0; else if (strstr(buffer,"*")) result=3; } data_read=ReadPGN(book_input,0); } else do { wtm=1; InitializeChessBoard(&tree->position[1]); move_num=1; tree->position[2]=tree->position[1]; ply=0; data_read=0; while (data_read==0) { mask_word=0; if ((ch=strpbrk(buffer,"?!"))) { mask_word=BookMask(ch); *ch=0; } if (!strchr(buffer,'$') && !strchr(buffer,'*')) { if (ply < max_ply) move=ReadNextMove(tree,buffer,2,wtm); else move=0; if (move) { ply++; max_search_depth=Max(max_search_depth,ply); total_moves++; common=HashKey & mask_16; MakeMove(tree,2,move,wtm); tree->position[2]=tree->position[3]; if (ply <= max_ply) { temp_hash_key=HashKey ^ wtm_random[wtm]; temp_hash_key=(temp_hash_key & ~mask_16) | common; memcpy(bbuffer[buffered].position,(char*)&temp_hash_key,8); if (result == 0) mask_word|=0100; else if (result&2) mask_word|=0200; else if (result&1) mask_word|=040; bbuffer[buffered].status=mask_word; bbuffer[buffered++].percent_play=pgn_suggested_percent+(wtm<<7); if (buffered >= SORT_BLOCK) { BookSort(bbuffer,buffered,++files); buffered=0; strcpy(schar,"S"); } } else { discarded++; } if (!(total_moves % 100000)) { printf(schar); strcpy(schar,"."); if (!(total_moves % 6000000)) printf(" (%dk)\n",total_moves/1000); fflush(stdout); } wtm=ChangeSide(wtm); if (wtm) move_num++; } else if (strspn(buffer,"0123456789/-.*") != strlen(buffer) && ply < max_ply) { errors++; Print(4095,"ERROR! move %d: %s is illegal (line %d)\n", move_num,buffer,ReadPGN(book_input,-2)); ReadPGN(book_input,-1); DisplayChessBoard(stdout,tree->pos); do { data_read=ReadPGN(book_input,0); if (data_read == -1) Print(4095,"end-of-file reached\n"); } while (data_read == 0); break; } } data_read=ReadPGN(book_input,0); } } while(0); } while (strcmp(buffer,"end") && data_read!=-1); if (book_input != stdin) fclose(book_input); if (buffered) BookSort(bbuffer,buffered,++files); free(bbuffer); printf("S \n"); if (total_moves == 0) { Print(4095, "ERROR - empty input PGN file\n"); return; } /* ---------------------------------------------------------- | | | now merge these "chunks" into book.bin, keeping all of | | the "flags" as well as counting the number of times | | that each move was played. | | | ---------------------------------------------------------- */ printf("merging sorted files (%d) (100k/dot)\n",files); counter=0; index=(int *) malloc(32768*sizeof(int)); if (!index) { Print(4095,"Unable to malloc() index block, aborting\n"); exit(1); } for (i=0;i<32768;i++) index[i]=-1; temp=BookUpNextPosition(files,1); memcpy((char*)¤t.position,temp.position,8); current.status_played=temp.status<<24; if (start) current.status_played+=temp.percent_play; current.learn=0.0; played=1; fclose(book_file); book_file=fopen(output_filename,"wb+"); fseek(book_file,sizeof(int)*32768,SEEK_SET); last=current.position>>49; index[last]=ftell(book_file); book_positions=0; cluster=0; cluster_seek=sizeof(int)*32768; fseek(book_file,cluster_seek+sizeof(int),SEEK_SET); max_cluster=0; wins=0; losses=0; if (temp.status&128 && temp.percent_play&128) wins++; if (temp.status&128 && !(temp.percent_play&128)) losses++; if (temp.status&32 && !(temp.percent_play&128)) wins++; if (temp.status&32 && temp.percent_play&128) losses++; while (1) { temp=BookUpNextPosition(files,0); memcpy((char*)&next.position,temp.position,8); next.status_played=temp.status<<24; if (start) next.status_played+=temp.percent_play&127; next.learn=0.0; next.CAP_score=-MATE*2; counter++; if (counter%100000 == 0) { printf("."); if (counter%6000000 == 0) printf(" (%dk)\n",counter/1000); fflush(stdout); } if (current.position == next.position) { current.status_played=current.status_played|next.status_played; played++; if (temp.status&128 && temp.percent_play&128) wins++; if (temp.status&128 && !(temp.percent_play&128)) losses++; if (temp.status&32 && !(temp.percent_play&128)) wins++; if (temp.status&32 && temp.percent_play&128) losses++; } else { if (played>=min_played && wins>=(losses*wl_percent)) { book_positions++; cluster++; max_cluster=Max(max_cluster,cluster); if (!start) current.status_played+=played; current.learn=0.0; current.CAP_score=-MATE*2; stat=fwrite(¤t,sizeof(BOOK_POSITION),1,book_file); if (stat != 1) Print(4095,"ERROR! write failed, disk probably full.\n"); } else if (played < min_played) discarded_mp++; else discarded_lose++; if (last != (int) (next.position>>49)) { next_cluster=ftell(book_file); fseek(book_file,cluster_seek,SEEK_SET); stat=fwrite(&cluster,sizeof(int),1,book_file); if (stat != 1) Print(4095,"ERROR! write failed, disk probably full.\n"); if (next.position == 0) break; fseek(book_file,next_cluster+sizeof(int),SEEK_SET); cluster_seek=next_cluster; last=next.position>>49; index[last]=next_cluster; cluster=0; } wins=0; losses=0; if (temp.status&128 && temp.percent_play&128) wins++; if (temp.status&128 && !(temp.percent_play&128)) losses++; if (temp.status&32 && !(temp.percent_play&128)) wins++; if (temp.status&32 && temp.percent_play&128) losses++; current=next; played=1; if (next.position == 0) break; } } fseek(book_file,0,SEEK_SET); fwrite(index,sizeof(int),32768,book_file); fseek(book_file,0,SEEK_END); major=atoi(version); minor=atoi(strchr(version,'.')+1); major=(major<<16)+minor; fwrite(&major,sizeof(int),1,book_file); /* ---------------------------------------------------------- | | | now clean up, remove the sort.n files, and print the | | statistics for building the book. | | | ---------------------------------------------------------- */ for (i=1;i<=files;i++) { sprintf(fname,"sort.%d",i); remove(fname); } free(index); start_cpu_time=ReadClock(cpu)-start_cpu_time; start_elapsed_time=ReadClock(elapsed)-start_elapsed_time; Print(4095,"\n\nparsed %d moves (%d games).\n",total_moves,games_parsed); Print(4095,"found %d errors during parsing.\n",errors); Print(4095,"discarded %d moves (maxply=%d).\n",discarded,max_ply); Print(4095,"discarded %d moves (minplayed=%d).\n",discarded_mp,min_played); Print(4095,"discarded %d moves (win/lose=%.1f%%).\n",discarded_lose, wl_percent*100); Print(4095,"book contains %d unique positions.\n",book_positions); Print(4095,"deepest book line was %d plies.\n",max_search_depth); Print(4095,"longest cluster of moves was %d.\n",max_cluster); Print(4095,"time used: %s cpu ", DisplayTime(start_cpu_time)); Print(4095," %s elapsed.\n", DisplayTime(start_elapsed_time)); } strcpy(initial_position,""); InitializeChessBoard(&tree->position[1]); } /* last modified 06/18/98 */ /* ******************************************************************************** * * * BookMask() is used to convert the flags for a book move into an 8 bit * * mask that is either kept in the file, or is set by the operator to select * * which opening(s) the program is allowed to play. * * * ******************************************************************************** */ int BookMask(char *flags) { int i, mask; mask=0; for (i=0;i<(int) strlen(flags);i++) { if (flags[i] == '?') { if (flags[i+1] == '?') { mask=mask | 1; i++; } else mask=mask | 2; } else if (flags[i] == '=') { mask=mask | 4; } else if (flags[i] == '!') { if (flags[i+1] == '!') { mask=mask | 16; i++; } else mask=mask | 8; } } return(mask); } /* last modified 01/08/01 */ /* ******************************************************************************** * * * BookRejectMove() is called to test a move to see if it should be excluded * * for some reason. One example is a kingside castling move that castles * * a stonewall attack type formation. * * * ******************************************************************************** */ int BookRejectMove(TREE *tree, int wtm) { /* ---------------------------------------------------------- | | | look for the "stonewall" formation in the pawns and | | reject this move if it castles into the attack. | | | ---------------------------------------------------------- */ if (wtm) { if (PopCnt(BlackPawns&stonewall_black)==2 && (WhitePawns&SetMask(E2) || WhitePawns&SetMask(E3))) return(1); } else { if (PopCnt(WhitePawns&stonewall_white)==2 && (BlackPawns&SetMask(E7) || BlackPawns&SetMask(E6))) return(1); } return(0); } /* last modified 06/19/98 */ /* ******************************************************************************** * * * BookSort() is called to sort a block of moves after they have been parsed * * and converted to hash keys. * * * ******************************************************************************** */ void BookSort(BB_POSITION *buffer, int number, int fileno) { char fname[16]; FILE *output_file; int stat; qsort((char *) buffer,number,sizeof(BB_POSITION),BookUpCompare); sprintf(fname,"sort.%d",fileno); if(!(output_file=fopen(fname,"wb+"))) printf("ERROR. unable to open sort output file\n"); stat=fwrite(buffer,sizeof(BB_POSITION),number,output_file); if (stat != number) Print(4095,"ERROR! write failed, disk probably full.\n"); fclose(output_file); } /* last modified 06/19/98 */ /* ******************************************************************************** * * * BookUpNextPosition() is the heart of the "merge" operation that is done * * after the chunks of the parsed/hashed move file are sorted. this code * * opens the sort.n files, and returns the least (lexically) position key to * * counted/merged into the main book database. * * * ******************************************************************************** */ BB_POSITION BookUpNextPosition(int files, int init) { char fname[20]; static FILE *input_file[100]; static BB_POSITION *buffer[100]; static int data_read[100], next[100]; int i, used; BB_POSITION least; if (init) { for (i=1;i<=files;i++) { sprintf(fname,"sort.%d",i); if (!(input_file[i]=fopen(fname,"rb"))) { printf("unable to open sort.%d file, may be too many files open.\n",i); exit(1); } buffer[i]=(BB_POSITION *) malloc(sizeof(BB_POSITION)*MERGE_BLOCK); if (!buffer[i]) { printf("out of memory. aborting. \n"); exit(1); } fseek(input_file[i],0,SEEK_SET); data_read[i]=fread(buffer[i],sizeof(BB_POSITION),MERGE_BLOCK, input_file[i]); next[i]=0; } } for (i=0;i<8;i++) least.position[i]=0; used=-1; for (i=1;i<=files;i++) if (data_read[i]) { least=buffer[i][next[i]]; used=i; break; } if (i > files) { for (i=1;i<=files;i++) fclose(input_file[i]); return(least); } for (i++;i<=files;i++) { if (data_read[i]) { BITBOARD p1, p2; memcpy((char*)&p1,least.position,8); memcpy((char*)&p2,buffer[i][next[i]].position,8); if (p1 > p2) { least=buffer[i][next[i]]; used=i; } } } if (--data_read[used] == 0) { data_read[used]=fread(buffer[used],sizeof(BB_POSITION), MERGE_BLOCK,input_file[used]); next[used]=0; } else next[used]++; return(least); } #if defined(NT_i386) int _cdecl BookUpCompare(const void *pos1, const void *pos2) { #else int BookUpCompare(const void *pos1, const void *pos2) { #endif static BITBOARD p1, p2; memcpy((char*)&p1,((BB_POSITION *)pos1)->position,8); memcpy((char*)&p2,((BB_POSITION *)pos2)->position,8); if (p1 < p2) return(-1); if (p1 > p2) return(+1); return(0); }