X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=book.c;h=aecb30df8c9dfa85c1b938cfe76a4543a048bbb6;hb=9141d53c4e3fe5f14a4940e2afb76f530f5a7a60;hp=124344f551c3dce6f32c7fdbfa370e56928f2067;hpb=570f0d333ffba03730d5bc5a69ef5a509247104f;p=xboard.git

diff --git a/book.c b/book.c
index 124344f..aecb30d 100644
--- a/book.c
+++ b/book.c
@@ -32,6 +32,7 @@
 #include <string.h>
 #include <time.h>
 #include <stdlib.h>
+#include <math.h>
 
 #include "common.h"
 #include "backend.h"
@@ -65,8 +66,6 @@ entry_t entry_none = {
 };
 
 char *promote_pieces=" nbrqac=";
-extern char castlingRights[][BOARD_SIZE];
-extern char epStatus[];
 
 uint64 Random64[781] = {
    U64(0x9D39247E33776D41), U64(0x2AF7398005AAA5C7), U64(0x44DB015024623547), U64(0x9C15F73E62A76AE2),
@@ -312,16 +311,16 @@ uint64 hash(int moveNr)
     }
     // 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, 
@@ -446,42 +445,42 @@ void move_to_string(char move_s[6], uint16 move)
     // 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)
-{
+int GetBookMoves(int moveNr, char *book, entry_t entries[])
+{   // retrieve all entries for given position from book in 'entries', return number.
     FILE *f;
     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
+    if(book == NULL || moveNr >= 2*appData.bookDepth) return -1; 
+//    if(gameInfo.variant != VariantNormal) return -1; // Zobrist scheme only works for normal Chess, so far
     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) {
+	  fclose(f);
+	  return FALSE;
+    }
     entries[0] = entry;
     count=1;
     fseek(f, 16*(offset+1), SEEK_SET);
@@ -496,12 +495,35 @@ char *ProbeBook(int moveNr, char *book)
         if(count == MOVE_BUF) break;
         entries[count++] = entry;
     }
+    fclose(f);
+    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<count; i++) if(entries[i].weight > maxWeight) maxWeight = entries[i].weight;
+        for(i=0; i<count; i++){
+            double weight = entries[i].weight / maxWeight;
+	      if(weight > 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<count; i++){
         total_weight += entries[i].weight;
     }
-    srandom( time(0) );
-    j = (random() & 0x7FFF) * total_weight >> 15; // create random < total_weight
+    j = (random() & 0xFFF) * total_weight >> 12; // create random < total_weight
     total_weight = 0;
     for(i=0; i<count; i++){
         total_weight += entries[i].weight;
@@ -513,3 +535,124 @@ char *ProbeBook(int moveNr, char *book)
 
     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<count; i++) totalWeight += entries[i].weight;
+	*p = 0;
+	for(i=0; i<count; i++) {
+	    move_to_string(algMove, entries[i].move);
+	    snprintf(p+strlen(p), 30, "%5.1f%% %5d %s\n", 100*entries[i].weight/(totalWeight+0.001), entries[i].weight, algMove);
+//lastEntries[i] = entries[i];
+	}
+	return p;
+}
+
+int TextToMoves(char *text, int moveNum, entry_t *entries)
+{
+	int i, w, count=0;
+      uint64 hashKey = hash(moveNum);
+	int  fromX, fromY, toX, toY, to, from;
+	ChessMove  moveType;
+	char promoChar, valid;
+	float dummy;
+	int width = BOARD_RGHT - BOARD_LEFT;
+
+	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) continue;
+	    to = toX + toY * width;
+	    from = fromX + fromY * width;
+	    // TODO: promotions, drops
+	    entries[count].move = to + from * width * BOARD_HEIGHT;
+	    entries[count].key  = hashKey;
+	    entries[count].weight = w;
+	    entries[count].learn  = 0; //TODO: learn value?
+	    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 = GetBookMoves(moveNr, appData.polyglotBook, entries);
+    if(count < 0) return FALSE;
+    p = MovesToText(count, entries);
+    EditTagsPopUp(p, NULL);
+    free(p);
+    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,4,entry->learn);
+}
+
+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) 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) {
+	  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<count; i++) entry_to_file(f, entries + i); // save the change
+    if(count != currentCount) {
+	do {
+	    for(i=0; i<len1; i++) buf2[i] = buf1[i]; len2 = len1;
+	    fseek(f, readpos, SEEK_SET);
+	    readpos += len1 = fread(buf1, 1, 4096, f);
+	    fseek(f, writepos, SEEK_SET);
+	    fwrite(buf2, 1, len2, f);
+	    writepos += len2;
+	} while(len1);
+    }
+    fclose(f);
+}