X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=book.c;h=c40cd925895c6bf42541188e68da96a62aec5c10;hb=7e0222e64da6706bf0dc2468f459b98e4346206b;hp=7e59a7fda2a8ee7fda261ede546a378aa17acc86;hpb=762e18baef5f815cc46019ba3e082bd5ec1980f6;p=xboard.git diff --git a/book.c b/book.c index 7e59a7f..c40cd92 100644 --- a/book.c +++ b/book.c @@ -1,37 +1,52 @@ -/* - * book.c -- code for probing P0lyglot opening books - * +/* + * 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. * I am pretty sure that a table of random numbers is never protected * by copyright. * * It s adapted by H.G. Muller for working with xboard / Winboard - * - * The following terms apply to the enhanced version of XBoard distributed - * by the Free Software Foundation: - * ------------------------------------------------------------------------ - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * ------------------------------------------------------------------------ - */ - + * + * The following terms apply to the enhanced version of XBoard distributed + * by the Free Software Foundation: + * ------------------------------------------------------------------------ + * + * GNU XBoard is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or (at + * your option) any later version. + * + * GNU XBoard is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://www.gnu.org/licenses/. * + * + * ------------------------------------------------------------------------ + */ + #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; @@ -39,7 +54,6 @@ typedef unsigned long long int uint64; #endif - #ifdef _MSC_VER # define U64(u) (u##ui64) #else @@ -54,16 +68,15 @@ typedef struct { 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=" nbrq"; -extern char castlingRights[][BOARD_SIZE]; -extern char epStatus[]; +char *promote_pieces=" nbrqac="; uint64 Random64[781] = { U64(0x9D39247E33776D41), U64(0x2AF7398005AAA5C7), U64(0x44DB015024623547), U64(0x9C15F73E62A76AE2), @@ -270,35 +283,79 @@ uint64 *RandomEnPassant =Random64+772; uint64 *RandomTurn =Random64+780; -uint64 hash(int moveNr) +uint64 +hash (int moveNr) { - char c; - int p, r, f, i, p_enc; - uint64 key=0; + int r, f, p_enc, squareNr, pieceGroup; + uint64 key=0, holdingsKey=0, Zobrist; + VariantClass v = gameInfo.variant; - for(f=BOARD_LEFT; f= (int)BlackPawn) ? (int)BlackPawn :(int)WhitePawn; - p_enc = 2*j + ((int)p < (int)BlackPawn); - if(p_enc >= 2*(int)WhiteKing) // king code is not contiguous! - p_enc += 2*((int)WhiteQueen - (int)WhiteKing + 1); - key ^= RandomPiece[64*p_enc+8*r+f]; + int j = (int)p; + j -= (j >= (int)BlackPawn) ? (int)BlackPawn :(int)WhitePawn; + 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 + // Zobrist random by rotating its bitpattern according to what the piece really was. + pieceGroup = p_enc / 12; + p_enc = p_enc % 12; + Zobrist = RandomPiece[64*p_enc + (squareNr & 63)]; + switch(pieceGroup) { + case 1: // pieces 5-10 (FEACWM) + Zobrist = (Zobrist << 16) ^ (Zobrist >> 48); + break; + case 2: // pieces 11-16 (OHIJGD) + Zobrist = (Zobrist << 32) ^ (Zobrist >> 32); + break; + case 3: // pieces 17-20 (VLSU) + Zobrist = (Zobrist << 48) ^ (Zobrist >> 16); + break; + } + if(squareNr >= 64) Zobrist = (Zobrist << 8) ^ (Zobrist >> 56); + // 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; } } } - 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, @@ -318,12 +375,13 @@ 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) +int +int_from_file (FILE *f, int l, uint64 *r) { int i,c; for(i=0;iweight=r; - ret=int_from_file(f,4,&r); + ret=int_from_file(f,2,&r); + if(ret) return 1; + entry->learnCount=r; + ret=int_from_file(f,2,&r); if(ret) return 1; - entry->learn=r; + 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)){ *entry=entry_none; @@ -380,67 +443,90 @@ int find_key(FILE *f, uint64 key, entry_t *entry) last_entry=middle_entry; }else{ first=middle; - first_entry=middle_entry; } } } -void move_to_string(char move_s[6], uint16 move) +void +move_to_string (char move_s[6], uint16 move) { int f,fr,ff,t,tr,tf,p; - f=(move>>6)&077; - fr=(f>>3)&0x7; - ff=f&0x7; - t=move&077; - tr=(t>>3)&0x7; - tf=t&0x7; - p=(move>>12)&0x7; - move_s[0]=ff+'a'; - move_s[1]=fr+'1'; - move_s[2]=tf+'a'; - move_s[3]=tr+'1'; + int width = BOARD_RGHT - BOARD_LEFT, size; // allow for alternative board formats + + size = width * BOARD_HEIGHT; + 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); + + // kludge: encode drops as special promotion code + if(gameInfo.holdingsSize && p == 8) { + move_s[0] = f + '@'; // from square encodes piece type + move_s[1] = '@'; // drop symbol + p = 0; + } + + // add promotion piece, if any if(p){ - move_s[4]=promote_pieces[p]; - move_s[5]='\0'; + move_s[4] = promote_pieces[p]; + move_s[5] = '\0'; }else{ - move_s[4]='\0'; + move_s[4] = '\0'; } + + if(gameInfo.variant != VariantNormal) return; + + // 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 (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]; 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; + int count; + int ret; - 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(book == NULL || moveNr >= 2*appData.bookDepth) return -1; +// if(gameInfo.variant != VariantNormal) return -1; // Zobrist scheme only works for normal Chess, so far + 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); + DisplayError(_("Polyglot book not valid"), 0); appData.usePolyglotBook = FALSE; - return NULL; + return -1; } 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); @@ -455,18 +541,189 @@ char *ProbeBook(int moveNr, char *book) if(count == MOVE_BUF) break; entries[count++] = entry; } + return count; +} + +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((count = GetBookMoves(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[6]; + char *p = (char*) malloc(30*count+1); + for(i=0; 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); + fseek(f, readpos, SEEK_SET); + readpos += len1 = fread(buf1, 1, 4096 - 16*currentCount, f); // salvage some entries immediately behind change + } + fseek(f, 16*(offset), SEEK_SET); + for(i=0; i writepos) { + fseek(f, readpos, SEEK_SET); + readpos += len1 = fread(buf1, 1, 4096, f); + } else len1 = 0; // wrote already past old EOF + fseek(f, writepos, SEEK_SET); + fwrite(buf2, 1, len2, f); + writepos += len2; + } while(len1); + } + fclose(f); +} +