kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-30 08:43:09 +00:00
Code Issues Releases Wiki Activity

Document PolyGlotRandoms[] offsets

Browse source 
Should be more clear from where the 'magic' numbers
come from.

Also bit of reformat while there.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2012-08-25 18:48:08 +01:00
parent cbd7ce468c
commit 16f380e5c1
2 changed files with 25 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

65
src/book.cpp
View file

@ -301,10 +301,10 @@ namespace {
};
// 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;
const Key* ZobPiece = PolyGlotRandoms;
const Key* ZobCastle = ZobPiece + 12 * 64; // Pieces * squares
const Key* ZobEnPassant = ZobCastle + 4; // Castle flags
const Key* ZobTurn = ZobEnPassant + 8; // Number of files
// book_key() returns the PolyGlot hash key of the given position
uint64_t book_key(const Position& pos) {
@ -314,12 +314,12 @@ namespace {
while (b)
{
// Piece offset is at 64 * polyPiece where polyPiece is defined as:
// In PolyGlotRandoms[] pieces are stored in the following sequence:
// BP = 0, WP = 1, BN = 2, WN = 3, ... BK = 10, WK = 11
Square s = pop_lsb(&b);
Piece p = pos.piece_on(s);
int polyPiece = 2 * (type_of(p) - 1) + (color_of(p) == WHITE);
key ^= ZobPiece[64 * polyPiece + s];
int pieceOfs = 2 * (type_of(p) - 1) + (color_of(p) == WHITE);
key ^= ZobPiece[64 * pieceOfs + s];
}
b = pos.can_castle(ALL_CASTLES);
@ -338,7 +338,7 @@ namespace {
} // namespace
Book::Book() : size(0) {
Book::Book() {
for (int i = Time::current_time().msec() % 10000; i > 0; i--)
RKiss.rand<unsigned>(); // Make random number generation less deterministic
@ -370,30 +370,14 @@ template<> Book& Book::operator>>(BookEntry& e) {
bool Book::open(const char* fName) {
fileName = "";
if (is_open()) // Cannot close an already closed file
close();
ifstream::open(fName, ifstream::in | ifstream::binary | ios::ate);
ifstream::open(fName, ifstream::in | ifstream::binary);
if (!is_open())
{
clear();
return false; // Silently fail if the file is not found
}
// Get the book size in number of entries, we are already at the end of file
size = (size_t)tellg() / sizeof(BookEntry);
if (!good())
{
cerr << "Failed to open book file " << fName << endl;
exit(EXIT_FAILURE);
}
fileName = fName; // Set only if successful
return true;
fileName = is_open() ? fName : "";
ifstream::clear(); // Reset any error flag to allow retry ifstream::open()
return !fileName.empty();
}
@ -403,16 +387,16 @@ bool Book::open(const char* fName) {
Move Book::probe(const Position& pos, const string& fName, bool pickBest) {
if (fileName != fName && !open(fName.c_str()))
return MOVE_NONE;
BookEntry e;
uint16_t best = 0;
unsigned sum = 0;
Move move = MOVE_NONE;
uint64_t key = book_key(pos);
if (fileName != fName && !open(fName.c_str()))
return MOVE_NONE;
binary_search(key);
seekg(find_first(key) * sizeof(BookEntry), ios_base::beg);
while (*this >> e, e.key == key && good())
{
@ -453,18 +437,17 @@ Move Book::probe(const Position& pos, const string& fName, bool pickBest) {
}
/// Book::binary_search() takes a book key as input, and does a binary search
/// through the book file for the given key. File stream current position is set
/// to the leftmost book entry with the same key as the input.
/// Book::find_first() takes a book key as input, and does a binary search
/// through the book file for the given key. Returns the index of the leftmost
/// book entry with the same key as the input.
void Book::binary_search(uint64_t key) {
size_t Book::find_first(uint64_t key) {
size_t low, high, mid;
seekg(0, ios::end); // Move pointer to end, so tellg() gets file's size
size_t low = 0, mid, high = (size_t)tellg() / sizeof(BookEntry) - 1;
BookEntry e;
low = 0;
high = size - 1;
assert(low <= high);
while (low < high && good())
@ -484,5 +467,5 @@ void Book::binary_search(uint64_t key) {
assert(low == high);
seekg(low * sizeof(BookEntry), ios_base::beg);
return low;
}

3
src/book.h
View file

@ -48,11 +48,10 @@ private:
template<typename T> Book& operator>>(T& n);
bool open(const char* fName);
void binary_search(uint64_t key);
size_t find_first(uint64_t key);
RKISS RKiss;
std::string fileName;
size_t size;
};
#endif // !defined(BOOK_H_INCLUDED)