/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
- Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+ Copyright (C) 2008-2012 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
Bitboard SetMaskBB[65];
Bitboard ClearMaskBB[65];
-Bitboard SquaresByColorBB[2];
Bitboard FileBB[8];
Bitboard RankBB[8];
Bitboard NeighboringFilesBB[8];
void bitboards_init() {
for (Bitboard b = 0; b < 256; b++)
- BitCount8Bit[b] = (uint8_t)count_1s<CNT32_MAX15>(b);
-
- SquaresByColorBB[DARK] = 0xAA55AA55AA55AA55ULL;
- SquaresByColorBB[LIGHT] = ~SquaresByColorBB[DARK];
+ BitCount8Bit[b] = (uint8_t)popcount<Max15>(b);
for (Square s = SQ_A1; s <= SQ_H8; s++)
{
ClearMaskBB[s] = ~SetMaskBB[s];
}
- ClearMaskBB[SQ_NONE] = ~EmptyBoardBB;
+ ClearMaskBB[SQ_NONE] = ~0ULL;
FileBB[FILE_A] = FileABB;
RankBB[RANK_1] = Rank1BB;
SquareDistance[s1][s2] = std::max(file_distance(s1, s2), rank_distance(s1, s2));
for (int i = 0; i < 64; i++)
- if (!CpuIs64Bit) // Matt Taylor's folding trick for 32 bit systems
+ if (!Is64Bit) // Matt Taylor's folding trick for 32 bit systems
{
Bitboard b = 1ULL << i;
b ^= b - 1;
for (Square s = SQ_A1; s <= SQ_H8; s++)
{
- BishopPseudoAttacks[s] = bishop_attacks_bb(s, EmptyBoardBB);
- RookPseudoAttacks[s] = rook_attacks_bb(s, EmptyBoardBB);
- QueenPseudoAttacks[s] = queen_attacks_bb(s, EmptyBoardBB);
+ BishopPseudoAttacks[s] = bishop_attacks_bb(s, 0);
+ RookPseudoAttacks[s] = rook_attacks_bb(s, 0);
+ QueenPseudoAttacks[s] = queen_attacks_bb(s, 0);
}
for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
// all the attacks for each possible subset of the mask and so is 2 power
// the number of 1s of the mask. Hence we deduce the size of the shift to
// apply to the 64 or 32 bits word to get the index.
- masks[s] = sliding_attacks(pt, s, EmptyBoardBB) & ~edges;
- shifts[s] = (CpuIs64Bit ? 64 : 32) - count_1s<CNT32_MAX15>(masks[s]);
+ masks[s] = sliding_attacks(pt, s, 0) & ~edges;
+ shifts[s] = (Is64Bit ? 64 : 32) - popcount<Max15>(masks[s]);
// Use Carry-Rippler trick to enumerate all subsets of masks[s] and
// store the corresponding sliding attacks bitboard in reference[].
if (s < SQ_H8)
attacks[s + 1] = attacks[s] + size;
- booster = MagicBoosters[CpuIs64Bit][rank_of(s)];
+ booster = MagicBoosters[Is64Bit][rank_of(s)];
// Find a magic for square 's' picking up an (almost) random number
// until we find the one that passes the verification test.