/*
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
const Bitboard WhiteSquaresBB = 0x55AA55AA55AA55AAULL;
const Bitboard BlackSquaresBB = 0xAA55AA55AA55AA55ULL;
-const Bitboard SquaresByColorBB[2] = { BlackSquaresBB, WhiteSquaresBB };
const Bitboard FileABB = 0x0101010101010101ULL;
const Bitboard FileBBB = 0x0202020202020202ULL;
const Bitboard FileGBB = 0x4040404040404040ULL;
const Bitboard FileHBB = 0x8080808080808080ULL;
-const Bitboard FileBB[8] = {
- FileABB, FileBBB, FileCBB, FileDBB, FileEBB, FileFBB, FileGBB, FileHBB
-};
-
-const Bitboard NeighboringFilesBB[8] = {
- FileBBB, FileABB|FileCBB, FileBBB|FileDBB, FileCBB|FileEBB,
- FileDBB|FileFBB, FileEBB|FileGBB, FileFBB|FileHBB, FileGBB
-};
-
-const Bitboard ThisAndNeighboringFilesBB[8] = {
- FileABB|FileBBB, FileABB|FileBBB|FileCBB,
- FileBBB|FileCBB|FileDBB, FileCBB|FileDBB|FileEBB,
- FileDBB|FileEBB|FileFBB, FileEBB|FileFBB|FileGBB,
- FileFBB|FileGBB|FileHBB, FileGBB|FileHBB
-};
-
const Bitboard Rank1BB = 0xFFULL;
const Bitboard Rank2BB = 0xFF00ULL;
const Bitboard Rank3BB = 0xFF0000ULL;
const Bitboard Rank7BB = 0xFF000000000000ULL;
const Bitboard Rank8BB = 0xFF00000000000000ULL;
-const Bitboard RankBB[8] = {
- Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
-};
-
-const Bitboard RelativeRankBB[2][8] = {
- { Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB },
- { Rank8BB, Rank7BB, Rank6BB, Rank5BB, Rank4BB, Rank3BB, Rank2BB, Rank1BB }
-};
-
-const Bitboard InFrontBB[2][8] = {
- { Rank2BB | Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
- Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
- Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
- Rank5BB | Rank6BB | Rank7BB | Rank8BB,
- Rank6BB | Rank7BB | Rank8BB,
- Rank7BB | Rank8BB,
- Rank8BB,
- EmptyBoardBB
- },
- { EmptyBoardBB,
- Rank1BB,
- Rank2BB | Rank1BB,
- Rank3BB | Rank2BB | Rank1BB,
- Rank4BB | Rank3BB | Rank2BB | Rank1BB,
- Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
- Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
- Rank7BB | Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB
- }
-};
+extern const Bitboard SquaresByColorBB[2];
+extern const Bitboard FileBB[8];
+extern const Bitboard NeighboringFilesBB[8];
+extern const Bitboard ThisAndNeighboringFilesBB[8];
+extern const Bitboard RankBB[8];
+extern const Bitboard RelativeRankBB[2][8];
+extern const Bitboard InFrontBB[2][8];
extern Bitboard SetMaskBB[65];
extern Bitboard ClearMaskBB[65];
extern Bitboard RayBB[64][8];
extern Bitboard BetweenBB[64][64];
+extern Bitboard SquaresInFrontMask[2][64];
extern Bitboard PassedPawnMask[2][64];
-extern Bitboard OutpostMask[2][64];
+extern Bitboard AttackSpanMask[2][64];
extern const uint64_t RMult[64];
extern const int RShift[64];
extern Bitboard RookPseudoAttacks[64];
extern Bitboard QueenPseudoAttacks[64];
+extern uint8_t BitCount8Bit[256];
+
////
//// Inline functions
*b ^= move_bb;
}
-/// rank_bb() and file_bb() gives a bitboard containing all squares on a given
-/// file or rank. It is also possible to pass a square as input to these
-/// functions.
+/// rank_bb() and file_bb() take a file or a square as input, and return
+/// a bitboard representing all squares on the given file or rank.
inline Bitboard rank_bb(Rank r) {
return RankBB[r];
}
inline Bitboard neighboring_files_bb(Square s) {
- return neighboring_files_bb(square_file(s));
+ return NeighboringFilesBB[square_file(s)];
}
}
inline Bitboard this_and_neighboring_files_bb(Square s) {
- return this_and_neighboring_files_bb(square_file(s));
+ return ThisAndNeighboringFilesBB[square_file(s)];
}
}
inline Bitboard in_front_bb(Color c, Square s) {
- return in_front_bb(c, square_rank(s));
+ return InFrontBB[c][square_rank(s)];
}
}
inline Bitboard behind_bb(Color c, Square s) {
- return in_front_bb(opposite_color(c), square_rank(s));
+ return InFrontBB[opposite_color(c)][square_rank(s)];
}
/// squares_in_front_of takes a color and a square as input, and returns a
/// bitboard representing all squares along the line in front of the square,
-/// from the point of view of the given color. For instance,
-/// squares_in_front_of(BLACK, SQ_E4) returns a bitboard with the squares
-/// e3, e2 and e1 set.
+/// from the point of view of the given color. Definition of the table is:
+/// SquaresInFrontOf[c][s] = in_front_bb(c, s) & file_bb(s)
inline Bitboard squares_in_front_of(Color c, Square s) {
- return in_front_bb(c, s) & file_bb(s);
+ return SquaresInFrontMask[c][s];
}
/// behind the square instead of in front of the square.
inline Bitboard squares_behind(Color c, Square s) {
- return in_front_bb(opposite_color(c), s) & file_bb(s);
+ return SquaresInFrontMask[opposite_color(c)][s];
}
/// passed_pawn_mask takes a color and a square as input, and returns a
/// bitboard mask which can be used to test if a pawn of the given color on
-/// the given square is a passed pawn.
+/// the given square is a passed pawn. Definition of the table is:
+/// PassedPawnMask[c][s] = in_front_bb(c, s) & this_and_neighboring_files_bb(s)
inline Bitboard passed_pawn_mask(Color c, Square s) {
return PassedPawnMask[c][s];
}
-/// outpost_mask takes a color and a square as input, and returns a bitboard
-/// mask which can be used to test whether a piece on the square can possibly
-/// be driven away by an enemy pawn.
-
-inline Bitboard outpost_mask(Color c, Square s) {
- return OutpostMask[c][s];
-}
-
-
-/// isolated_pawn_mask takes a square as input, and returns a bitboard mask
-/// which can be used to test whether a pawn on the given square is isolated.
+/// attack_span_mask takes a color and a square as input, and returns a bitboard
+/// representing all squares that can be attacked by a pawn of the given color
+/// when it moves along its file starting from the given square. Definition is:
+/// AttackSpanMask[c][s] = in_front_bb(c, s) & neighboring_files_bb(s);
-inline Bitboard isolated_pawn_mask(Square s) {
- return neighboring_files_bb(s);
+inline Bitboard attack_span_mask(Color c, Square s) {
+ return AttackSpanMask[c][s];
}
#if defined(USE_BSFQ) // Assembly code by Heinz van Saanen
-inline Square __attribute__((always_inline)) first_1(Bitboard b) {
+inline Square first_1(Bitboard b) {
Bitboard dummy;
__asm__("bsfq %1, %0": "=r"(dummy): "rm"(b) );
return (Square)(dummy);
}
-inline Square __attribute__((always_inline)) pop_1st_bit(Bitboard* b) {
+inline Square pop_1st_bit(Bitboard* b) {
const Square s = first_1(*b);
*b &= ~(1ULL<<s);
return s;