/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
- Copyright (C) 2008-2009 Marco Costalba
+ Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
////
#include <cassert>
+#include <iostream>
#include "book.h"
-#include "mersenne.h"
#include "movegen.h"
using namespace std;
-////
-//// Global variables
-////
-
-Book OpeningBook;
-
-
////
//// Local definitions
////
namespace {
- /// Book entry size in bytes
+ // Book entry size in bytes
const int EntrySize = 16;
-
- /// Random numbers from PolyGlot, used to compute book hash keys
-
+ // Random numbers from PolyGlot, used to compute book hash keys
const uint64_t Random64[781] = {
0x9D39247E33776D41ULL, 0x2AF7398005AAA5C7ULL, 0x44DB015024623547ULL,
0x9C15F73E62A76AE2ULL, 0x75834465489C0C89ULL, 0x3290AC3A203001BFULL,
0xF8D626AAAF278509ULL
};
+ // Indices to the Random64[] array
+ const int PieceIdx = 0;
+ const int CastleIdx = 768;
+ const int EnPassantIdx = 772;
+ const int TurnIdx = 780;
- /// Indices to the Random64[] array
-
- const int RandomPiece = 0;
- const int RandomCastle = 768;
- const int RandomEnPassant = 772;
- const int RandomTurn = 780;
-
-
- /// Prototypes
-
+ // Local functions
uint64_t book_key(const Position& pos);
uint64_t book_piece_key(Piece p, Square s);
uint64_t book_castle_key(const Position& pos);
//// Functions
////
+// C'tor. Make random number generation less deterministic, for book moves
+Book::Book() {
+
+ for (int i = abs(get_system_time() % 10000); i > 0; i--)
+ RKiss.rand<unsigned>();
+}
+
/// Destructor. Be sure file is closed before we leave.
}
+/// Book::close() closes the file only if it is open, otherwise
+/// we can end up in a little mess due to how std::ifstream works.
+
+void Book::close() {
+
+ if (is_open())
+ ifstream::close();
+}
+
+
/// Book::open() opens a book file with a given file name
void Book::open(const string& fName) {
fileName = fName;
ifstream::open(fileName.c_str(), ifstream::in | ifstream::binary);
+
+ // Silently return when asked to open a non-exsistent file
if (!is_open())
return;
// Get the book size in number of entries
seekg(0, ios::end);
- bookSize = tellg() / EntrySize;
+ bookSize = long(tellg()) / EntrySize;
seekg(0, ios::beg);
if (!good())
{
cerr << "Failed to open book file " << fileName << endl;
- Application::exit_with_failure();
+ exit(EXIT_FAILURE);
}
}
-/// Book::close() closes the file only if it is open, otherwise
-/// we can end up in a little mess due to how std::ifstream works.
-
-void Book::close() {
-
- if (is_open())
- ifstream::close();
-}
-
-
/// Book::file_name() returns the file name of the currently active book,
/// or the empty string if no book is open.
/// Book::get_move() gets a book move for a given position. Returns
/// MOVE_NONE if no book move is found.
-Move Book::get_move(const Position& pos) {
+Move Book::get_move(const Position& pos, bool findBestMove) {
if (!is_open() || bookSize == 0)
return MOVE_NONE;
- int bookMove = 0, scoresSum = 0;
- uint64_t key = book_key(pos);
BookEntry entry;
+ int bookMove = MOVE_NONE;
+ unsigned scoresSum = 0, bestScore = 0;
+ uint64_t key = book_key(pos);
// Choose a book move among the possible moves for the given position
for (int idx = find_key(key); idx < bookSize; idx++)
if (entry.key != key)
break;
- int score = entry.count;
+ unsigned score = entry.count;
- assert(score > 0);
+ // If findBestMove is true choose highest rated book move
+ if (findBestMove)
+ {
+ if (score > bestScore)
+ {
+ bestScore = score;
+ bookMove = entry.move;
+ }
+ continue;
+ }
// Choose book move according to its score. If a move has a very
// high score it has more probability to be choosen then a one with
// lower score. Note that first entry is always chosen.
scoresSum += score;
- if (int(genrand_int32() % scoresSum) < score)
+ if (RKiss.rand<unsigned>() % scoresSum < score)
bookMove = entry.move;
}
if (!bookMove)
return MOVE_NONE;
- MoveStack mlist[256];
- MoveStack* last = generate_moves(pos, mlist);
+ // A PolyGlot book move is encoded as follows:
+ //
+ // bit 0- 5: destination square (from 0 to 63)
+ // bit 6-11: origin square (from 0 to 63)
+ // bit 12-13-14: promotion piece (from KNIGHT == 1 to QUEEN == 4)
+ //
+ // Castling moves follow "king captures rook" representation. So in case
+ // book move is a promotion we have to convert to our representation, in
+ // all other cases we can directly compare with a Move after having
+ // masked out special Move's flags that are not supported by PolyGlot.
+ int p = (bookMove >> 12) & 7;
+
+ if (p)
+ bookMove = int(make_promotion_move(move_from(Move(bookMove)),
+ move_to(Move(bookMove)), PieceType(p + 1)));
+
+ // Verify the book move is legal
+ MoveStack mlist[MOVES_MAX];
+ MoveStack* last = generate<MV_LEGAL>(pos, mlist);
for (MoveStack* cur = mlist; cur != last; cur++)
- if ((int(cur->move) & 07777) == bookMove)
+ if ((int(cur->move) & ~(3 << 14)) == bookMove) // Mask out special flags
return cur->move;
return MOVE_NONE;
assert(mid >= left && mid < right);
read_entry(entry, mid);
+
if (key <= entry.key)
right = mid;
else
assert(left == right);
read_entry(entry, left);
- return (entry.key == key)? left : bookSize;
+ return entry.key == key ? left : bookSize;
}
assert(is_open());
seekg(idx * EntrySize, ios_base::beg);
+
*this >> entry;
+
if (!good())
{
cerr << "Failed to read book entry at index " << idx << endl;
- Application::exit_with_failure();
+ exit(EXIT_FAILURE);
}
}
uint64_t Book::read_integer(int size) {
char buf[8];
+ uint64_t n = 0;
+
read(buf, size);
// Numbers are stored on disk as a binary byte stream
- uint64_t n = 0ULL;
for (int i = 0; i < size; i++)
n = (n << 8) + (unsigned char)buf[i];
uint64_t book_key(const Position& pos) {
- uint64_t result = 0ULL;
+ uint64_t result = 0;
+ Bitboard b = pos.occupied_squares();
- for (Color c = WHITE; c <= BLACK; c++)
+ while (b)
{
- Bitboard b = pos.pieces_of_color(c);
-
- while (b)
- {
- Square s = pop_1st_bit(&b);
- Piece p = pos.piece_on(s);
-
- assert(piece_is_ok(p));
- assert(color_of_piece(p) == c);
-
- result ^= book_piece_key(p, s);
- }
+ Square s = pop_1st_bit(&b);
+ result ^= book_piece_key(pos.piece_on(s), s);
}
+
result ^= book_castle_key(pos);
result ^= book_ep_key(pos);
result ^= book_color_key(pos);
uint64_t book_piece_key(Piece p, Square s) {
- /// Convert pieces to the range 0..11
+ // Convert pieces to the range 0..11
static const int PieceTo12[] = { 0, 0, 2, 4, 6, 8, 10, 0, 0, 1, 3, 5, 7, 9, 11 };
- return Random64[RandomPiece + (PieceTo12[int(p)]^1) * 64 + int(s)];
+ return Random64[PieceIdx + (PieceTo12[int(p)]^1) * 64 + int(s)];
}
uint64_t book_castle_key(const Position& pos) {
- uint64_t result = 0ULL;
+ uint64_t result = 0;
if (pos.can_castle_kingside(WHITE))
- result ^= Random64[RandomCastle+0];
+ result ^= Random64[CastleIdx + 0];
if (pos.can_castle_queenside(WHITE))
- result ^= Random64[RandomCastle+1];
+ result ^= Random64[CastleIdx + 1];
if (pos.can_castle_kingside(BLACK))
- result ^= Random64[RandomCastle+2];
+ result ^= Random64[CastleIdx + 2];
if (pos.can_castle_queenside(BLACK))
- result ^= Random64[RandomCastle+3];
+ result ^= Random64[CastleIdx + 3];
return result;
}
uint64_t book_ep_key(const Position& pos) {
- return (pos.ep_square() == SQ_NONE ? 0ULL : Random64[RandomEnPassant + square_file(pos.ep_square())]);
+
+ return pos.ep_square() == SQ_NONE ? 0 : Random64[EnPassantIdx + square_file(pos.ep_square())];
}
uint64_t book_color_key(const Position& pos) {
- return (pos.side_to_move() == WHITE ? Random64[RandomTurn] : 0ULL);
+
+ return pos.side_to_move() == WHITE ? Random64[TurnIdx] : 0;
}
}
projects / stockfish / blobdiff