namespace {
// Random numbers from PolyGlot, used to compute book hash keys
- const uint64_t Random64[781] = {
+ const Key PolyGlotRandoms[781] = {
0x9D39247E33776D41ULL, 0x2AF7398005AAA5C7ULL, 0x44DB015024623547ULL,
0x9C15F73E62A76AE2ULL, 0x75834465489C0C89ULL, 0x3290AC3A203001BFULL,
0x0FBBAD1F61042279ULL, 0xE83A908FF2FB60CAULL, 0x0D7E765D58755C10ULL,
0xF8D626AAAF278509ULL
};
- // Indices to the Random64[] array
- const int PieceIdx = 0;
- const int CastleIdx = 768;
- const int EnPassantIdx = 772;
- const int TurnIdx = 780;
+ // Offsets to the PolyGlotRandoms[] array of zobrist keys
+ const Key* ZobPiece = PolyGlotRandoms + 0;
+ const Key* ZobCastle = PolyGlotRandoms + 768;
+ const Key* ZobEnPassant = PolyGlotRandoms + 772;
+ const Key* ZobTurn = PolyGlotRandoms + 780;
+
+ // Piece offset is calculated as 64 * (PolyPiece ^ 1) where
+ // PolyPiece is: BP = 0, WP = 1, BN = 2, WN = 3 ... BK = 10, WK = 11
+ const int PieceOfs[] = { 0, 64, 192, 320, 448, 576, 704, 0,
+ 0, 0, 128, 256, 384, 512, 640 };
// book_key() builds up a PolyGlot hash key out of a position
uint64_t book_key(const Position& pos) {
- // Piece offset is calculated as (64 * PolyPieceType + square), where
- // PolyPieceType is: BP = 0, WP = 1, BN = 2, WN = 3 .... BK = 10, WK = 11
- static const int PieceToPoly[] = { 0, 1, 3, 5, 7, 9, 11, 0, 0, 0, 2, 4, 6, 8, 10 };
-
uint64_t result = 0;
Bitboard b = pos.occupied_squares();
while (b)
{
Square s = pop_1st_bit(&b);
- int p = PieceToPoly[int(pos.piece_on(s))];
- result ^= Random64[PieceIdx + 64 * p + int(s)];
+ result ^= ZobPiece[PieceOfs[pos.piece_on(s)] + s];
}
- if (pos.can_castle_kingside(WHITE))
- result ^= Random64[CastleIdx + 0];
+ if (pos.can_castle(WHITE_OO))
+ result ^= ZobCastle[0];
- if (pos.can_castle_queenside(WHITE))
- result ^= Random64[CastleIdx + 1];
+ if (pos.can_castle(WHITE_OOO))
+ result ^= ZobCastle[1];
- if (pos.can_castle_kingside(BLACK))
- result ^= Random64[CastleIdx + 2];
+ if (pos.can_castle(BLACK_OO))
+ result ^= ZobCastle[2];
- if (pos.can_castle_queenside(BLACK))
- result ^= Random64[CastleIdx + 3];
+ if (pos.can_castle(BLACK_OOO))
+ result ^= ZobCastle[3];
if (pos.ep_square() != SQ_NONE)
- result ^= Random64[EnPassantIdx + square_file(pos.ep_square())];
+ result ^= ZobEnPassant[square_file(pos.ep_square())];
if (pos.side_to_move() == WHITE)
- result ^= Random64[TurnIdx];
+ result ^= ZobTurn[0];
return result;
}
-
}
/// Book c'tor. Make random number generation less deterministic, for book moves
-Book::Book() {
+Book::Book() : bookSize(0) {
for (int i = abs(get_system_time() % 10000); i > 0; i--)
RKiss.rand<unsigned>();
void Book::close() {
- if (is_open())
- ifstream::close();
+ if (bookFile.is_open())
+ bookFile.close();
bookName = "";
+ bookSize = 0;
}
// Close old file before opening the new
close();
- ifstream::open(fileName.c_str(), ifstream::in | ifstream::binary);
+ bookFile.open(fileName.c_str(), ifstream::in | ifstream::binary);
// Silently return when asked to open a non-exsistent file
- if (!is_open())
+ if (!bookFile.is_open())
return;
// Get the book size in number of entries
- seekg(0, ios::end);
- bookSize = long(tellg()) / sizeof(BookEntry);
+ bookFile.seekg(0, ios::end);
+ bookSize = long(bookFile.tellg()) / sizeof(BookEntry);
- if (!good())
+ if (!bookFile.good())
{
cerr << "Failed to open book file " << fileName << endl;
exit(EXIT_FAILURE);
Move Book::get_move(const Position& pos, bool findBestMove) {
- if (!is_open() || bookSize == 0)
+ if (!bookSize || !bookFile.is_open())
return MOVE_NONE;
BookEntry entry;
uint64_t key = book_key(pos);
// Choose a book move among the possible moves for the given position
- for (int idx = find_entry(key); idx < bookSize; idx++)
+ for (int idx = first_entry(key); idx < bookSize; idx++)
{
entry = read_entry(idx);
if (!findBestMove)
{
// 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.
+ // high score it has higher probability to be choosen than a move
+ // with lower score. Note that first entry is always chosen.
scoresSum += score;
if (RKiss.rand<unsigned>() % scoresSum < score)
bookMove = entry.move;
}
}
+ if (!bookMove)
+ return MOVE_NONE;
+
// A PolyGlot book move is encoded as follows:
//
// bit 0- 5: destination square (from 0 to 63)
// 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;
+ int promotion = (bookMove >> 12) & 7;
- if (p)
+ if (promotion)
bookMove = int(make_promotion_move(move_from(Move(bookMove)),
- move_to(Move(bookMove)), PieceType(p + 1)));
-
- // Verify the book move (if any) is legal
- MoveStack mlist[MOVES_MAX];
- MoveStack* last = generate<MV_LEGAL>(pos, mlist);
- for (MoveStack* cur = mlist; cur != last; cur++)
- if ((int(cur->move) & ~(3 << 14)) == bookMove) // Mask out special flags
- return cur->move;
+ move_to(Move(bookMove)),
+ PieceType(promotion + 1)));
+ // Verify the book move is legal
+ for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
+ if ((ml.move() & ~(3 << 14)) == bookMove) // Mask out special flags
+ return ml.move();
return MOVE_NONE;
}
-/// Book::find_entry() takes a book key as input, and does a binary search
-/// through the book file for the given key. The index to the first book
-/// entry with the same key as the input is returned. When the key is not
+/// Book::first_entry() takes a book key as input, and does a binary search
+/// through the book file for the given key. The index to the first (leftmost)
+/// book entry with the same key as the input is returned. When the key is not
/// found in the book file, bookSize is returned.
-int Book::find_entry(uint64_t key) {
+int Book::first_entry(uint64_t key) {
int left, right, mid;
- // Binary search (finds the leftmost entry)
+ // Binary search (finds the leftmost entry with given key)
left = 0;
right = bookSize - 1;
}
+/// Book::operator>>() reads sizeof(T) chars from the file's binary byte
+/// stream and converts them in a number of type T.
+template<typename T>
+Book& Book::operator>>(T& n) {
+
+ n = 0;
+
+ for (size_t i = 0; i < sizeof(T); i++)
+ n = T((n << 8) + bookFile.get());
+
+ return *this;
+}
+
+
/// Book::read_entry() takes an integer index, and returns the BookEntry
/// at the given index in the book file.
BookEntry Book::read_entry(int idx) {
assert(idx >= 0 && idx < bookSize);
- assert(is_open());
+ assert(bookFile.is_open());
BookEntry e;
- seekg(idx * sizeof(BookEntry), ios_base::beg);
+ bookFile.seekg(idx * sizeof(BookEntry), ios_base::beg);
*this >> e.key >> e.move >> e.count >> e.learn;
- if (!good())
+ if (!bookFile.good())
{
cerr << "Failed to read book entry at index " << idx << endl;
exit(EXIT_FAILURE);
projects / stockfish / blobdiff