-/*\r
- * book.c -- code for probing P0lyglot opening books\r
- *\r
+/*
+ * 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
- *\r
- * The following terms apply to the enhanced version of XBoard distributed\r
- * by the Free Software Foundation:\r
- * ------------------------------------------------------------------------\r
- * This program is free software; you can redistribute it and/or modify\r
- * it under the terms of the GNU General Public License as published by\r
- * the Free Software Foundation; either version 2 of the License, or\r
- * (at your option) any later version.\r
- *\r
- * This program is distributed in the hope that it will be useful,\r
- * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
- * GNU General Public License for more details.\r
- *\r
- * You should have received a copy of the GNU General Public License\r
- * along with this program; if not, write to the Free Software\r
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\r
- * ------------------------------------------------------------------------\r
- */\r
-\r
+ *
+ * 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 <stdio.h>
#include <string.h>
+#include <time.h>
+#include <stdlib.h>
+#include <math.h>
#include "common.h"
#include "backend.h"
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),
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, Zobrist;
for(f=BOARD_LEFT; f<BOARD_RGHT; f++){
for(r=0; r<BOARD_HEIGHT;r++){
ChessSquare p = boards[moveNr][r][f];
if(p != EmptySquare){
- int j = (int)p;
- j -= (j >= (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);
+ 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);
+ key ^= Zobrist;
}
}
}
- if(castlingRights[moveNr][2] >= 0) {
- if(castlingRights[moveNr][0] >= 0) key^=RandomCastle[0];
- if(castlingRights[moveNr][1] >= 0) key^=RandomCastle[1];
+ // Holdings not implemented yet!
+
+ 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,
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);
}
}
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
+ if(book == NULL || moveNr >= 2*appData.bookDepth) 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);
}
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 NULL;
+ }
entries[0] = entry;
count=1;
fseek(f, 16*(offset+1), SEEK_SET);
if(count == MOVE_BUF) break;
entries[count++] = entry;
}
+ 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;
}
- 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;
}
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);
+ fclose(f);
return move_s;
}