#include "types.h"
+namespace Bitboards {
+
+extern void init();
+extern void print(Bitboard b);
+
+}
+
CACHE_LINE_ALIGNMENT
extern Bitboard RMasks[64];
extern Bitboard InFrontBB[2][8];
extern Bitboard StepAttacksBB[16][64];
extern Bitboard BetweenBB[64][64];
-extern Bitboard SquaresInFrontMask[2][64];
+extern Bitboard DistanceRingsBB[64][8];
+extern Bitboard ForwardBB[2][64];
extern Bitboard PassedPawnMask[2][64];
extern Bitboard AttackSpanMask[2][64];
extern Bitboard PseudoAttacks[6][64];
}
inline Bitboard& operator|=(Bitboard& b, Square s) {
- return b |= SquareBB[s], b;
+ return b |= SquareBB[s];
}
inline Bitboard& operator^=(Bitboard& b, Square s) {
- return b ^= SquareBB[s], b;
+ return b ^= SquareBB[s];
+}
+
+inline Bitboard operator|(Bitboard b, Square s) {
+ return b | SquareBB[s];
+}
+
+inline Bitboard operator^(Bitboard b, Square s) {
+ return b ^ SquareBB[s];
+}
+
+
+/// more_than_one() returns true if in 'b' there is more than one bit set
+
+inline bool more_than_one(Bitboard b) {
+ return b & (b - 1);
}
}
-/// Functions for computing sliding attack bitboards. rook_attacks_bb(),
-/// bishop_attacks_bb() and queen_attacks_bb() all take a square and a
-/// bitboard of occupied squares as input, and return a bitboard representing
-/// all squares attacked by a rook, bishop or queen on the given square.
-
-#if defined(IS_64BIT)
-
-FORCE_INLINE unsigned r_index(Square s, Bitboard occ) {
- return unsigned(((occ & RMasks[s]) * RMagics[s]) >> RShifts[s]);
-}
-
-FORCE_INLINE unsigned b_index(Square s, Bitboard occ) {
- return unsigned(((occ & BMasks[s]) * BMagics[s]) >> BShifts[s]);
-}
-
-#else // if !defined(IS_64BIT)
-
-FORCE_INLINE unsigned r_index(Square s, Bitboard occ) {
- unsigned lo = unsigned(occ) & unsigned(RMasks[s]);
- unsigned hi = unsigned(occ >> 32) & unsigned(RMasks[s] >> 32);
- return (lo * unsigned(RMagics[s]) ^ hi * unsigned(RMagics[s] >> 32)) >> RShifts[s];
-}
-
-FORCE_INLINE unsigned b_index(Square s, Bitboard occ) {
- unsigned lo = unsigned(occ) & unsigned(BMasks[s]);
- unsigned hi = unsigned(occ >> 32) & unsigned(BMasks[s] >> 32);
- return (lo * unsigned(BMagics[s]) ^ hi * unsigned(BMagics[s] >> 32)) >> BShifts[s];
-}
-
-#endif
+/// between_bb returns a bitboard representing all squares between two squares.
+/// For instance, between_bb(SQ_C4, SQ_F7) returns a bitboard with the bits for
+/// square d5 and e6 set. If s1 and s2 are not on the same line, file or diagonal,
+/// 0 is returned.
-inline Bitboard rook_attacks_bb(Square s, Bitboard occ) {
- return RAttacks[s][r_index(s, occ)];
-}
-
-inline Bitboard bishop_attacks_bb(Square s, Bitboard occ) {
- return BAttacks[s][b_index(s, occ)];
-}
-
-
-/// squares_between returns a bitboard representing all squares between
-/// two squares. For instance, squares_between(SQ_C4, SQ_F7) returns a
-/// bitboard with the bits for square d5 and e6 set. If s1 and s2 are not
-/// on the same line, file or diagonal, EmptyBoardBB is returned.
-
-inline Bitboard squares_between(Square s1, Square s2) {
+inline Bitboard between_bb(Square s1, Square s2) {
return BetweenBB[s1][s2];
}
-/// 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. Definition of the table is:
-/// SquaresInFrontOf[c][s] = in_front_bb(c, s) & file_bb(s)
+/// forward_bb 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. Definition of the table is:
+/// ForwardBB[c][s] = in_front_bb(c, s) & file_bb(s)
-inline Bitboard squares_in_front_of(Color c, Square s) {
- return SquaresInFrontMask[c][s];
+inline Bitboard forward_bb(Color c, Square s) {
+ return ForwardBB[c][s];
}
}
-/// first_1() finds the least significant nonzero bit in a nonzero bitboard.
-/// pop_1st_bit() finds and clears the least significant nonzero bit in a
-/// nonzero bitboard.
+/// Functions for computing sliding attack bitboards. Function attacks_bb() takes
+/// a square and a bitboard of occupied squares as input, and returns a bitboard
+/// representing all squares attacked by Pt (bishop or rook) on the given square.
+template<PieceType Pt>
+FORCE_INLINE unsigned magic_index(Square s, Bitboard occ) {
+
+ Bitboard* const Masks = Pt == ROOK ? RMasks : BMasks;
+ Bitboard* const Magics = Pt == ROOK ? RMagics : BMagics;
+ unsigned* const Shifts = Pt == ROOK ? RShifts : BShifts;
+
+ if (Is64Bit)
+ return unsigned(((occ & Masks[s]) * Magics[s]) >> Shifts[s]);
+
+ unsigned lo = unsigned(occ) & unsigned(Masks[s]);
+ unsigned hi = unsigned(occ >> 32) & unsigned(Masks[s] >> 32);
+ return (lo * unsigned(Magics[s]) ^ hi * unsigned(Magics[s] >> 32)) >> Shifts[s];
+}
+
+template<PieceType Pt>
+inline Bitboard attacks_bb(Square s, Bitboard occ) {
+ return (Pt == ROOK ? RAttacks : BAttacks)[s][magic_index<Pt>(s, occ)];
+}
+
+
+/// lsb()/msb() finds the least/most significant bit in a nonzero bitboard.
+/// pop_lsb() finds and clears the least significant bit in a nonzero bitboard.
#if defined(USE_BSFQ)
-#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+# if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
-FORCE_INLINE Square first_1(Bitboard b) {
- unsigned long index;
- _BitScanForward64(&index, b);
- return (Square) index;
+FORCE_INLINE Square lsb(Bitboard b) {
+ unsigned long index;
+ _BitScanForward64(&index, b);
+ return (Square) index;
}
-#else
-FORCE_INLINE Square first_1(Bitboard b) { // Assembly code by Heinz van Saanen
- Bitboard dummy;
- __asm__("bsfq %1, %0": "=r"(dummy): "rm"(b) );
- return (Square) dummy;
+FORCE_INLINE Square msb(Bitboard b) {
+ unsigned long index;
+ _BitScanReverse64(&index, b);
+ return (Square) index;
+}
+
+# else
+
+FORCE_INLINE Square lsb(Bitboard b) { // Assembly code by Heinz van Saanen
+ Bitboard index;
+ __asm__("bsfq %1, %0": "=r"(index): "rm"(b) );
+ return (Square) index;
}
-#endif
-FORCE_INLINE Square pop_1st_bit(Bitboard* b) {
- const Square s = first_1(*b);
- *b &= ~(1ULL<<s);
+FORCE_INLINE Square msb(Bitboard b) {
+ Bitboard index;
+ __asm__("bsrq %1, %0": "=r"(index): "rm"(b) );
+ return (Square) index;
+}
+
+# endif
+
+FORCE_INLINE Square pop_lsb(Bitboard* b) {
+ const Square s = lsb(*b);
+ *b &= ~(1ULL << s);
return s;
}
#else // if !defined(USE_BSFQ)
-extern Square first_1(Bitboard b);
-extern Square pop_1st_bit(Bitboard* b);
+extern Square msb(Bitboard b);
+extern Square lsb(Bitboard b);
+extern Square pop_lsb(Bitboard* b);
#endif
-
-extern void print_bitboard(Bitboard b);
-extern void bitboards_init();
-
#endif // !defined(BITBOARD_H_INCLUDED)