X-Git-Url: http://winboard.nl/cgi-bin?p=xboard.git;a=blobdiff_plain;f=book.c;h=9828dd24e3d09decce7d4e5e45b1914489de2b94;hp=124344f551c3dce6f32c7fdbfa370e56928f2067;hb=HEAD;hpb=570f0d333ffba03730d5bc5a69ef5a509247104f diff --git a/book.c b/book.c index 124344f..9828dd2 100644 --- a/book.c +++ b/book.c @@ -2,7 +2,7 @@ * book.c -- code for probing Polyglot opening books * * This code was first released in the public domain by Michel Van den Bergh. - * The array Random64 is taken from the Polyglot source code. + * The array Random64 is taken from the Polyglot source code. * I am pretty sure that a table of random numbers is never protected * by copyright. * @@ -28,13 +28,27 @@ * ------------------------------------------------------------------------ */ +#include "config.h" + #include #include #include #include +#include #include "common.h" +#include "frontend.h" #include "backend.h" +#include "moves.h" +#include "gettext.h" + +#ifdef ENABLE_NLS +# define _(s) gettext (s) +# define N_(s) gettext_noop (s) +#else +# define _(s) (s) +# define N_(s) s +#endif #ifdef _MSC_VER typedef unsigned __int64 uint64; @@ -42,7 +56,6 @@ typedef unsigned long long int uint64; #endif - #ifdef _MSC_VER # define U64(u) (u##ui64) #else @@ -54,19 +67,18 @@ typedef unsigned short uint16; typedef unsigned int uint32; typedef struct { - uint64 key; + uint64 key; uint16 move; uint16 weight; - uint32 learn; + uint16 learnPoints; + uint16 learnCount; } entry_t; entry_t entry_none = { 0, 0, 0, 0 }; -char *promote_pieces=" nbrqac="; -extern char castlingRights[][BOARD_SIZE]; -extern char epStatus[]; +char *promote_pieces=" nbrqac=+"; uint64 Random64[781] = { U64(0x9D39247E33776D41), U64(0x2AF7398005AAA5C7), U64(0x44DB015024623547), U64(0x9C15F73E62A76AE2), @@ -273,20 +285,43 @@ uint64 *RandomEnPassant =Random64+772; uint64 *RandomTurn =Random64+780; -uint64 hash(int moveNr) +uint64 +hash (int moveNr) { int r, f, p_enc, squareNr, pieceGroup; - uint64 key=0, Zobrist; + uint64 key=0, holdingsKey=0, Zobrist; + VariantClass v = gameInfo.variant; + + switch(v) { + case VariantNormal: + case VariantFischeRandom: // compatible with normal + case VariantNoCastle: + case VariantXiangqi: // for historic reasons; does never collide anyway because of other King type + break; + case VariantGiveaway: // in opening same as suicide + key += VariantSuicide; + break; + case VariantGothic: // these are special cases of CRC, and can share book + case VariantCapablanca: + v = VariantCapaRandom; + default: + key += v; // variant type incorporated in key to allow mixed books without collisions + } - for(f=BOARD_LEFT; f= (int)BlackPawn) ? (int)BlackPawn :(int)WhitePawn; + if(j >= WhitePBishop && j != WhiteKing) promoted++, j -= WhiteTokin; if(j > (int)WhiteQueen) j++; // make space for King if(j > (int) WhiteKing) j = (int)WhiteQueen + 1; p_enc = 2*j + ((int)p < (int)BlackPawn); + // holdings squares get nmbers immediately after board; first left, then right holdings + if(f == BOARD_LEFT-2) squareNr = (BOARD_RGHT - BOARD_LEFT)*BOARD_HEIGHT + r; else + if(f == BOARD_RGHT+1) squareNr = (BOARD_RGHT - BOARD_LEFT + 1)*BOARD_HEIGHT + r; else squareNr = (BOARD_RGHT - BOARD_LEFT)*r + (f - BOARD_LEFT); // note that in normal Chess squareNr < 64 and p_enc < 12. The following code // maps other pieces and squares in this range, and then modify the corresponding @@ -294,7 +329,8 @@ uint64 hash(int moveNr) pieceGroup = p_enc / 12; p_enc = p_enc % 12; Zobrist = RandomPiece[64*p_enc + (squareNr & 63)]; - switch(pieceGroup) { + if(pieceGroup & 4) Zobrist *= 987654321; + switch(pieceGroup & 3) { case 1: // pieces 5-10 (FEACWM) Zobrist = (Zobrist << 16) ^ (Zobrist >> 48); break; @@ -305,26 +341,30 @@ uint64 hash(int moveNr) Zobrist = (Zobrist << 48) ^ (Zobrist >> 16); break; } - if(squareNr >= 64) Zobrist = (Zobrist << 8) ^ (Zobrist >> 56); + if(promoted) Zobrist ^= 123456789*RandomPiece[squareNr & 63]; + if(squareNr & 64) Zobrist = (Zobrist << 8) ^ (Zobrist >> 56); + if(squareNr & 128) Zobrist = (Zobrist << 4) ^ (Zobrist >> 60); + // holdings have separate (additive) key, to encode presence of multiple pieces on same square + if(f == BOARD_LEFT-2) holdingsKey += Zobrist * boards[moveNr][r][f+1]; else + if(f == BOARD_RGHT+1) holdingsKey += Zobrist * boards[moveNr][r][f-1]; else key ^= Zobrist; } } } - // Holdings not implemented yet! - if(castlingRights[moveNr][2] >= 0) { - if(castlingRights[moveNr][0] >= 0) key^=RandomCastle[0]; - if(castlingRights[moveNr][1] >= 0) key^=RandomCastle[1]; + if(boards[moveNr][CASTLING][2] != NoRights) { + if(boards[moveNr][CASTLING][0] != NoRights) key^=RandomCastle[0]; + if(boards[moveNr][CASTLING][1] != NoRights) key^=RandomCastle[1]; } - if(castlingRights[moveNr][5] >= 0) { - if(castlingRights[moveNr][3] >= 0) key^=RandomCastle[2]; - if(castlingRights[moveNr][4] >= 0) key^=RandomCastle[3]; + if(boards[moveNr][CASTLING][5] != NoRights) { + if(boards[moveNr][CASTLING][3] != NoRights) key^=RandomCastle[2]; + if(boards[moveNr][CASTLING][4] != NoRights) key^=RandomCastle[3]; } - f = epStatus[moveNr]; + f = boards[moveNr][EP_STATUS]; if(f >= 0 && f < 8){ if(!WhiteOnMove(moveNr)){ - // the test for neighboring Pawns might not be needed, + // the test for neighboring Pawns might not be needed, // as epStatus already kept track of it, but better safe than sorry. if((f>0 && boards[moveNr][3][f-1]==BlackPawn)|| (f<7 && boards[moveNr][3][f+1]==BlackPawn)){ @@ -341,16 +381,47 @@ uint64 hash(int moveNr) if(WhiteOnMove(moveNr)){ key^=RandomTurn[0]; } - return key; + return key + holdingsKey; } #define MOVE_BUF 100 -int int_from_file(FILE *f, int l, uint64 *r) +// fs routines read from memory buffer if no file specified + +static unsigned char *memBuf, *memPtr; +static int bufSize; +Boolean mcMode; + +int +fsseek (FILE *f, int n, int mode) +{ + if(f) return fseek(f, n, mode); + if(mode == SEEK_SET) memPtr = memBuf + n; else + if(mode == SEEK_END) memPtr = memBuf + 16*bufSize + n; + return memPtr < memBuf || memPtr > memBuf + 16*bufSize; +} + +int +fstell (FILE *f) +{ + if(f) return ftell(f); + return memPtr - memBuf; +} + +int +fsgetc (FILE *f) +{ + if(f) return fgetc(f); + if(memPtr >= memBuf + 16*bufSize) return EOF; + return *memPtr++ ; +} + +int +int_from_file (FILE *f, int l, uint64 *r) { int i,c; for(i=0;ikey=r; @@ -372,23 +445,27 @@ int entry_from_file(FILE *f, entry_t *entry) ret=int_from_file(f,2,&r); if(ret) return 1; entry->weight=r; - ret=int_from_file(f,4,&r); + ret=int_from_file(f,2,&r); if(ret) return 1; - entry->learn=r; + entry->learnCount=r; + ret=int_from_file(f,2,&r); + if(ret) return 1; + entry->learnPoints=r; return 0; } -int find_key(FILE *f, uint64 key, entry_t *entry) +int +find_key (FILE *f, uint64 key, entry_t *entry) { int first, last, middle; - entry_t first_entry=entry_none, last_entry,middle_entry; + entry_t last_entry,middle_entry; first=-1; - if(fseek(f,-16,SEEK_END)){ + if(fsseek(f,-16,SEEK_END)){ *entry=entry_none; entry->key=key+1; //hack return -1; } - last=ftell(f)/16; + last=fstell(f)/16; entry_from_file(f,&last_entry); while(1){ if(last-first==1){ @@ -396,95 +473,98 @@ int find_key(FILE *f, uint64 key, entry_t *entry) return last; } middle=(first+last)/2; - fseek(f,16*middle,SEEK_SET); + fsseek(f,16*middle,SEEK_SET); entry_from_file(f,&middle_entry); if(key<=middle_entry.key){ last=middle; last_entry=middle_entry; }else{ first=middle; - first_entry=middle_entry; } } } -void move_to_string(char move_s[6], uint16 move) +static int xStep[] = { 0, 1, 1, 1, 0,-1,-1,-1 }; +static int yStep[] = { 1, 1, 0,-1,-1,-1, 0, 1 }; + +void +move_to_string (char move_s[20], uint16 move) { int f,fr,ff,t,tr,tf,p; int width = BOARD_RGHT - BOARD_LEFT, size; // allow for alternative board formats size = width * BOARD_HEIGHT; + p = move / (size*size); + move = move % (size*size); f = move / size; fr = f / width; ff = f % width; t = move % size; tr = t / width; tf = t % width; - p = move / (size*size); - move_s[0] = ff + 'a'; - move_s[1] = fr + '1' - (BOARD_HEIGHT > 9); - move_s[2] = tf + 'a'; - move_s[3] = tr + '1' - (BOARD_HEIGHT > 9); + snprintf(move_s, 9, "%c%d%c%d", ff + 'a', fr + 1 - (BOARD_HEIGHT == 10), tf + 'a', tr + 1 - (BOARD_HEIGHT == 10)); + + if(IS_SHOGI(gameInfo.variant) && p) { + if(p == 2) p = 10; // Lion moves, for boards so big that 10 is out of range + else if(p != 7) p = 8; // use '+' for all others that do not explicitly defer + } // kludge: encode drops as special promotion code - if(gameInfo.holdingsSize && p == 8) { + if(gameInfo.holdingsSize && p == 9) { move_s[0] = f + '@'; // from square encodes piece type move_s[1] = '@'; // drop symbol p = 0; + } else if(p == 10) { // decode Lion move + int i = t & 7, j = t >> 3 & 7; + tf = ff + xStep[i] + xStep[j]; tr = fr + yStep[i] + yStep[j]; // calculate true to-square + snprintf(move_s, 20, "%c%d%c%d,%c%d%c%d", ff + 'a', fr + 1 - (BOARD_HEIGHT == 10), + ff + xStep[i] + 'a', fr + yStep[i] + 1 - (BOARD_HEIGHT == 10), + ff + xStep[i] + 'a', fr + yStep[i] + 1 - (BOARD_HEIGHT == 10), + tf + 'a', tr + 1 - (BOARD_HEIGHT == 10) ); + p = 0; } // add promotion piece, if any if(p){ - move_s[4] = promote_pieces[p]; - move_s[5] = '\0'; - }else{ - move_s[4] = '\0'; + int len = strlen(move_s); + move_s[len] = promote_pieces[p]; + move_s[len+1] = '\0'; } if(gameInfo.variant != VariantNormal) return; - // correct FRC-style castlings in variant normal. + // correct FRC-style castlings in variant normal. // [HGM] This is buggy code! e1h1 could very well be a normal R or Q move. if(!strcmp(move_s,"e1h1")){ - strcpy(move_s,"e1g1"); + safeStrCpy(move_s,"e1g1", 6); }else if(!strcmp(move_s,"e1a1")){ - strcpy(move_s,"e1c1"); + safeStrCpy(move_s,"e1c1", 6); }else if(!strcmp(move_s,"e8h8")){ - strcpy(move_s,"e8g8"); + safeStrCpy(move_s,"e8g8", 6); }else if(!strcmp(move_s,"e8a8")){ - strcpy(move_s,"e8c8"); + safeStrCpy(move_s,"e8c8", 6); } } -char *ProbeBook(int moveNr, char *book) -{ - FILE *f; +int +GetBookMoves (FILE *f, int moveNr, entry_t entries[], int max) +{ // retrieve all entries for given position from book in 'entries', return number. entry_t entry; int offset; uint64 key; - entry_t entries[MOVE_BUF]; - int count=0; - int ret, i, j; - static char move_s[6]; - int total_weight; - - if(book == NULL) return NULL; -// if(gameInfo.variant != VariantNormal) return NULL; // Zobrist scheme only works for normal Chess, so far - f=fopen(book,"rb"); - if(!f){ - DisplayError("Polyglot book not valid", 0); - appData.usePolyglotBook = FALSE; - return NULL; - } + int count; + int ret; key = hash(moveNr); if(appData.debugMode) fprintf(debugFP, "book key = %08x%08x\n", (unsigned int)(key>>32), (unsigned int)key); offset=find_key(f, key, &entry); - if(entry.key != key) return NULL; + if(entry.key != key) { + return FALSE; + } entries[0] = entry; count=1; - fseek(f, 16*(offset+1), SEEK_SET); + fsseek(f, 16*(offset+1), SEEK_SET); while(1){ ret=entry_from_file(f, &entry); if(ret){ @@ -493,23 +573,483 @@ char *ProbeBook(int moveNr, char *book) if(entry.key != key){ break; } - if(count == MOVE_BUF) break; + if(count == max) break; entries[count++] = entry; } + return count; +} + +static int dirty; + +int +ReadFromBookFile (int moveNr, char *book, entry_t entries[]) +{ // retrieve all entries for given position from book in 'entries', return number. + static FILE *f = NULL; + static char curBook[MSG_SIZ]; + + if(book == NULL) return -1; + if(dirty) { if(f) fclose(f); dirty = 0; f = NULL; } + if(!f || strcmp(book, curBook)){ // keep book file open until book changed + strncpy(curBook, book, MSG_SIZ); + if(f) fclose(f); + f = fopen(book,"rb"); + } + if(!f){ + DisplayError(_("Polyglot book not valid"), 0); + appData.usePolyglotBook = FALSE; + return -1; + } + + return GetBookMoves(f, moveNr, entries, MOVE_BUF); +} + +// next three made into subroutines to facilitate future changes in storage scheme (e.g. 2 x 3 bytes) + +static int +wins(entry_t *e) +{ + return e->learnPoints; +} + +static int +losses(entry_t *e) +{ + return e->learnCount; +} + +static void +CountMove (entry_t *e, int result) +{ + switch(result) { + case 0: e->learnCount ++; break; + case 1: e->learnCount ++; // count draw as win + loss + case 2: e->learnPoints ++; break; + } +} + +#define MERGESIZE 2048 +#define HASHSIZE 1024*1024*4 + +entry_t *memBook, *hashTab, *mergeBuf; +int bookSize=1, mergeSize=1, mask = HASHSIZE-1; + +void +InitMemBook () +{ + static int initDone = FALSE; + if(initDone) return; + memBook = (entry_t *) calloc(1024*1024, sizeof(entry_t)); + hashTab = (entry_t *) calloc(HASHSIZE, sizeof(entry_t)); + mergeBuf = (entry_t *) calloc(MERGESIZE+5, sizeof(entry_t)); + memBook[0].key = -1LL; + mergeBuf[0].key = -1LL; + initDone = TRUE; +} + +char * +MCprobe (int moveNr) +{ + int count, count2, games, i, choice=0; + entry_t entries[MOVE_BUF]; + float nominal[MOVE_BUF], tot, deficit, max, min; + static char move_s[6]; + + InitMemBook(); + memBuf = (unsigned char*) memBook; bufSize = bookSize; // in MC mode book resides in memory + count = GetBookMoves(NULL, moveNr, entries, MOVE_BUF); + if(count < 0) count = 0; // don't care about miss yet + memBuf = (unsigned char*) mergeBuf; bufSize = mergeSize; // there could be moves still waiting to be merged + count2 = count + GetBookMoves(NULL, moveNr, entries+count, MOVE_BUF - count); + if(appData.debugMode) fprintf(debugFP, "MC probe: %d/%d (%d+%d)\n", count, count2,bookSize,mergeSize); + if(!count2) return NULL; + tot = games = 0; + for(i=0; i max) max = deficit, choice = i; + if(deficit < min) min = deficit; + } // note that a single move will never be underplayed + if(max - min > 0.5*sqrt(nominal[choice])) { // if one of the listed moves is significantly under-played, play it now. + move_to_string(move_s, entries[choice].move); + if(appData.debugMode) fprintf(debugFP, "book move field = %d\n", entries[choice].move); + return move_s; + } + return NULL; // otherwise fake book miss to force engine think, hoping for hitherto unplayed move. +} + +char +*ProbeBook (int moveNr, char *book) +{ // + entry_t entries[MOVE_BUF]; + int count; + int i, j; + static char move_s[6]; + int total_weight; + + if(moveNr >= 2*appData.bookDepth) return NULL; + if(mcMode) return MCprobe(moveNr); + + if((count = ReadFromBookFile(moveNr, book, entries)) <= 0) return NULL; // no book, or no hit + + if(appData.bookStrength != 50) { // transform weights + double power = 0, maxWeight = 0.0; + if(appData.bookStrength) power = (100.-appData.bookStrength)/appData.bookStrength; + for(i=0; i maxWeight) maxWeight = entries[i].weight; + for(i=0; i 0) + entries[i].weight = appData.bookStrength || weight == 1.0 ? 1e4*exp(power * log(weight)) + 0.5 : 0.0; + } + } total_weight = 0; for(i=0; i> 15; // create random < total_weight + if(total_weight == 0) return NULL; // force book miss rather than playing moves with weight 0. + j = (random() & 0xFFF) * total_weight >> 12; // create random < total_weight total_weight = 0; for(i=0; i j) break; } - if(i >= count) DisplayFatalError("Book Fault", 0, 1); // safety catch, cannot happen + if(i >= count) DisplayFatalError(_("Book Fault"), 0, 1); // safety catch, cannot happen move_to_string(move_s, entries[i].move); if(appData.debugMode) fprintf(debugFP, "book move field = %d\n", entries[i].move); return move_s; } + +extern char yy_textstr[]; +entry_t lastEntries[MOVE_BUF]; + +char * +MovesToText(int count, entry_t *entries) +{ + int i, totalWeight = 0; + char algMove[12]; + char *p = (char*) malloc(40*count+1); + for(i=0; i= 4) { + CoordsToAlgebraic(boards[currentMove], PosFlags(currentMove), i1-ONE+'0', c1-AAA, i2-ONE+'0', c2-AAA, c3, algMove); + } + buf[0] = NULLCHAR; + if(entries[i].learnCount || entries[i].learnPoints) + snprintf(buf, MSG_SIZ, " {%d/%d}", entries[i].learnPoints, entries[i].learnCount); + snprintf(p+strlen(p), 40, "%5.1f%% %5d %s%s\n", 100*entries[i].weight/(totalWeight+0.001), + entries[i].weight, algMove, buf); +//lastEntries[i] = entries[i]; + } + return p; +} + +static int +CoordsToMove (int fromX, int fromY, int toX, int toY, char promoChar) +{ + int i, width = BOARD_RGHT - BOARD_LEFT; + int to = toX - BOARD_LEFT + toY * width; + int from = fromX - BOARD_LEFT + fromY * width; + for(i=0; promote_pieces[i]; i++) if(promote_pieces[i] == promoChar) break; + if(!promote_pieces[i]) i = 0; + else if(i == 9 && gameInfo.variant == VariantChu) i = 1; // on 12x12 only 3 promotion codes available, so use 1 to indicate promotion + if(fromY == DROP_RANK) i = 9, from = ToUpper(PieceToChar(fromX)) - '@'; + if(killX >= 0) { // multi-leg move + int dx = killX - fromX, dy = killY - fromY; + for(i=0; i<8; i++) if(dx == xStep[i] && dy == yStep[i]) { + int j; + dx = toX - killX; dy = toY - killY; + for(j=0; j<8; j++) if(dx == xStep[j] && dy == yStep[j]) { + // special encoding in to-square, with promoType = 2. Assumes board >= 64 squares! + return i + 8*j + (2 * width * BOARD_HEIGHT + from) * width * BOARD_HEIGHT; + } + } + i = 0; // if not a valid Lion move, ignore kill-square and promoChar + } + return to + (i * width * BOARD_HEIGHT + from) * width * BOARD_HEIGHT; +} + +int +TextToMoves (char *text, int moveNum, entry_t *entries) +{ + int i, w, count=0; + uint64 hashKey = hash(moveNum); + int fromX, fromY, toX, toY; + ChessMove moveType; + char promoChar, valid; + float dummy; + + entries[0].key = hashKey; // make sure key is returned even if no moves + while((i=sscanf(text, "%f%%%d", &dummy, &w))==2 || (i=sscanf(text, "%d", &w))==1) { + if(i == 2) text = strchr(text, '%') + 1; // skip percentage + if(w == 1) text = strstr(text, "1 ") + 2; // skip weight that could be recognized as move number one + valid = ParseOneMove(text, moveNum, &moveType, &fromX, &fromY, &toX, &toY, &promoChar); + text = strstr(text, yy_textstr) + strlen(yy_textstr); // skip what we parsed + if(!valid || moveType != NormalMove && moveType != WhiteDrop && moveType != BlackDrop + && moveType != FirstLeg + && moveType != WhitePromotion && moveType != BlackPromotion + && moveType != WhiteCapturesEnPassant && moveType != BlackCapturesEnPassant + && moveType != WhiteKingSideCastle && moveType != BlackKingSideCastle + && moveType != WhiteQueenSideCastle && moveType != BlackQueenSideCastle + && moveType != WhiteNonPromotion && moveType != BlackNonPromotion) continue; + if(*text == ' ' && sscanf(text+1, "{%hd/%hd}", &entries[count].learnPoints, &entries[count].learnCount) == 2) { + text = strchr(text+1, '}') + 1; + } else { + entries[count].learnPoints = 0; + entries[count].learnCount = 0; + } + entries[count].move = CoordsToMove(fromX, fromY, toX, toY, promoChar); killX = killY = -1; + entries[count].key = hashKey; + entries[count].weight = w; + count++; + } + return count; +} + +Boolean bookUp; +int currentCount; + +Boolean +DisplayBook (int moveNr) +{ + entry_t entries[MOVE_BUF]; + int count; + char *p; + if(!bookUp) return FALSE; + count = currentCount = ReadFromBookFile(moveNr, appData.polyglotBook, entries); + if(count < 0) return FALSE; + p = MovesToText(count, entries); + EditTagsPopUp(p, NULL); + free(p); + addToBookFlag = FALSE; + return TRUE; +} + +void +EditBookEvent() +{ + bookUp = TRUE; + bookUp = DisplayBook(currentMove); +} + +void +int_to_file (FILE *f, int l, uint64 r) +{ + int i; + for(i=l-1;i>=0;i--) fputc(r>>8*i & 255, f); +} + +void +entry_to_file (FILE *f, entry_t *entry) +{ + int_to_file(f,8,entry->key); + int_to_file(f,2,entry->move); + int_to_file(f,2,entry->weight); + int_to_file(f,2,entry->learnCount); + int_to_file(f,2,entry->learnPoints); +} + +char buf1[4096], buf2[4096]; + +void +SaveToBook (char *text) +{ + entry_t entries[MOVE_BUF], entry; + int count = TextToMoves(text, currentMove, entries); + int offset, i, len1=0, len2, readpos=0, writepos=0; + FILE *f; + if(!count && !currentCount) return; + f=fopen(appData.polyglotBook, "rb+"); + if(!f){ DisplayError(_("Polyglot book not valid"), 0); return; } + offset=find_key(f, entries[0].key, &entry); + if(entries[0].key != entry.key && currentCount) { + DisplayError(_("Hash keys are different"), 0); + fclose(f); + return; + } + if(count != currentCount) { + readpos = 16*(offset + currentCount); + writepos = 16*(offset + count); + fsseek(f, readpos, SEEK_SET); + readpos += len1 = fread(buf1, 1, 4096 - 16*currentCount, f); // salvage some entries immediately behind change + } + fsseek(f, 16*(offset), SEEK_SET); + for(i=0; i writepos) { + fsseek(f, readpos, SEEK_SET); + readpos += len1 = fread(buf1, 1, 4096, f); + } else len1 = 0; // wrote already past old EOF + fsseek(f, writepos, SEEK_SET); + fwrite(buf2, 1, len2, f); + writepos += len2; + } while(len1); + } + dirty = 1; + fclose(f); +} + +void +NewEntry (entry_t *e, uint64 key, int move, int result) +{ + e->key = key; + e->move = move; + e->learnPoints = 0; + e->learnCount = 0; + CountMove(e, result); +} + +void +Merge () +{ + int i; + + if(appData.debugMode) fprintf(debugFP, "book merge %d moves (old size %d)\n", mergeSize, bookSize); + + bookSize += --mergeSize; + for(i=bookSize-1; mergeSize; i--) { + while(mergeSize && (i < mergeSize || mergeBuf[mergeSize-1].key >= memBook[i-mergeSize].key)) + memBook[i--] = mergeBuf[--mergeSize]; + if(i < 0) break; + memBook[i] = memBook[i-mergeSize]; + } + if(mergeSize) DisplayFatalError("merge error", 0, 0); // impossible + mergeSize = 1; + mergeBuf[0].key = -1LL; +} + +void +AddToBook (int moveNr, int result) +{ + entry_t entry; + int offset, start, move; + uint64 key; + int i, j, fromY, toY; + char fromX, toX, promo; +extern char moveList[][MOVE_LEN]; + + if(!moveList[moveNr][0] || moveList[moveNr][0] == '\n') return; // could be terminal position + + if(appData.debugMode) fprintf(debugFP, "add move %d to book %s", moveNr, moveList[moveNr]); + + // calculate key and book representation of move + key = hash(moveNr); + if(moveList[moveNr][1] == '@') { + sscanf(moveList[moveNr], "%c@%c%d", &promo, &toX, &toY); + fromX = CharToPiece(WhiteOnMove(moveNr) ? ToUpper(promo) : ToLower(promo)); + fromY = DROP_RANK; promo = NULLCHAR; + } else sscanf(moveList[moveNr], "%c%d%c%d%c", &fromX, &fromY, &toX, &toY, &promo), fromX -= AAA, fromY -= ONE - '0'; + move = CoordsToMove(fromX, fromY, toX-AAA, toY-ONE+'0', promo); + + // if move already in book, just add count + memBuf = (unsigned char*) memBook; bufSize = bookSize; // in MC mode book resides in memory + offset = find_key(NULL, key, &entry); + while(memBook[offset].key == key) { + if(memBook[offset].move == move) { + CountMove(memBook+offset, result); return; + } else offset++; + } + // move did not occur in the main book + memBuf = (unsigned char*) mergeBuf; bufSize = mergeSize; // it could be amongst moves still waiting to be merged + start = offset = find_key(NULL, key, &entry); + while(mergeBuf[offset].key == key) { + if(mergeBuf[offset].move == move) { + if(appData.debugMode) fprintf(debugFP, "found in book merge buf @ %d\n", offset); + CountMove(mergeBuf+offset, result); return; + } else offset++; + } + if(start != offset) { // position was in mergeBuf, but move is new + if(appData.debugMode) fprintf(debugFP, "add in book merge buf @ %d\n", offset); + for(i=mergeSize++; i>offset; i--) mergeBuf[i] = mergeBuf[i-1]; // make room + NewEntry(mergeBuf+offset, key, move, result); + return; + } + // position was not in mergeBuf; look in hash table + i = (key & mask); offset = -1; + while(hashTab[i].key) { // search in hash table (necessary because sought item could be re-hashed) + if(hashTab[i].key == 1 && offset < 0) offset = i; // remember first invalidated entry we pass + if(!((hashTab[i].key - key) & ~1)) { // hit + if(hashTab[i].move == move) { + CountMove(hashTab+i, result); + for(j=mergeSize++; j>start; j--) mergeBuf[j] = mergeBuf[j-1]; + } else { + // position already in hash now occurs with different move; move both moves to mergeBuf + for(j=mergeSize+1; j>start+1; j--) mergeBuf[j] = mergeBuf[j-2]; + NewEntry(mergeBuf+start+1, key, move, result); mergeSize += 2; + } + hashTab[i].key = 1; // kludge to invalidate hash entry + mergeBuf[start] = hashTab[i]; mergeBuf[start].key = key; + if(mergeSize >= MERGESIZE) Merge(); + return; + } + i = i+1 & mask; // wrap! + } + // position did not yet occur in hash table. Put it there + if(offset < 0) offset = i; + NewEntry(hashTab+offset, key, move, result); + if(appData.debugMode) + fprintf(debugFP, "book hash @ %d (%d-%d)\n", offset, hashTab[offset].learnPoints, hashTab[offset].learnCount); +} + +void +AddGameToBook (int always) +{ + int i, result; + + if(!mcMode && !always) return; + + InitMemBook(); + switch(gameInfo.result) { + case GameIsDrawn: result = 1; break; + case WhiteWins: result = 2; break; + case BlackWins: result = 0; break; + default: return; // don't treat games with unknown result + } + + if(appData.debugMode) fprintf(debugFP, "add game to book (%d-%d)\n", backwardMostMove, forwardMostMove); + for(i=backwardMostMove; i text && start[-1] != ' ' && start[-1] != '\t') start--; + while(*end && *++end != ' ' && *end != '\n') + ; *end = NULLCHAR; // find clicked word + if(start != end) TypeInDoneEvent(start); // fake it was typed in move type-in +} + +void +FlushBook () +{ + FILE *f; + int i; + + InitMemBook(); + Merge(); // flush merge buffer to memBook + + if(f = fopen(appData.polyglotBook, "wb")) { + for(i=0; i