Bitboard InFrontBB[2][8];
Bitboard StepAttacksBB[16][64];
Bitboard BetweenBB[64][64];
-Bitboard SquaresInFrontMask[2][64];
+Bitboard ForwardBB[2][64];
Bitboard PassedPawnMask[2][64];
Bitboard AttackSpanMask[2][64];
Bitboard PseudoAttacks[6][64];
for (Color c = WHITE; c <= BLACK; c++)
for (Square s = SQ_A1; s <= SQ_H8; s++)
{
- SquaresInFrontMask[c][s] = in_front_bb(c, s) & file_bb(s);
- PassedPawnMask[c][s] = in_front_bb(c, s) & this_and_adjacent_files_bb(file_of(s));
- AttackSpanMask[c][s] = in_front_bb(c, s) & adjacent_files_bb(file_of(s));
+ ForwardBB[c][s] = in_front_bb(c, s) & file_bb(s);
+ PassedPawnMask[c][s] = in_front_bb(c, s) & this_and_adjacent_files_bb(file_of(s));
+ AttackSpanMask[c][s] = in_front_bb(c, s) & adjacent_files_bb(file_of(s));
}
for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
extern Bitboard InFrontBB[2][8];
extern Bitboard StepAttacksBB[16][64];
extern Bitboard BetweenBB[64][64];
-extern Bitboard SquaresInFrontMask[2][64];
+extern Bitboard ForwardBB[2][64];
extern Bitboard PassedPawnMask[2][64];
extern Bitboard AttackSpanMask[2][64];
extern Bitboard PseudoAttacks[6][64];
}
+/// 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);
+}
+
+
/// 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.
}
-/// 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) {
- Bitboard** const Attacks = Pt == ROOK ? RAttacks : BAttacks;
- return Attacks[s][magic_index<Pt>(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.
+/// 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 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];
}
}
-/// single_bit() returns true if in the 'b' bitboard is set a single bit (or if
-/// b == 0).
+/// 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;
-inline bool single_bit(Bitboard b) {
- return !(b & (b - 1));
+ 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) {
+ Bitboard** const Attacks = Pt == ROOK ? RAttacks : BAttacks;
+ return Attacks[s][magic_index<Pt>(s, occ)];
}
return SCALE_FACTOR_DRAW;
else
{
- Bitboard path = squares_in_front_of(strongerSide, pawnSq);
+ Bitboard path = forward_bb(strongerSide, pawnSq);
if (path & pos.pieces(KING, weakerSide))
return SCALE_FACTOR_DRAW;
assert(b);
- if (single_bit(b) && (b & pos.pieces(Them)))
+ if (!more_than_one(b) && (b & pos.pieces(Them)))
score += ThreatBonus[Piece][type_of(pos.piece_on(first_1(b)))];
}
& ~ei.attackedBy[Them][0];
if (undefendedMinors)
- score += single_bit(undefendedMinors) ? UndefendedMinorPenalty
- : UndefendedMinorPenalty * 2;
+ score += more_than_one(undefendedMinors) ? UndefendedMinorPenalty * 2
+ : UndefendedMinorPenalty;
// Enemy pieces not defended by a pawn and under our attack
weakEnemies = pos.pieces(Them)
// If the pawn is free to advance, increase bonus
if (pos.square_empty(blockSq))
{
- squaresToQueen = squares_in_front_of(Us, s);
+ squaresToQueen = forward_bb(Us, s);
defendedSquares = squaresToQueen & ei.attackedBy[Us][0];
// If there is an enemy rook or queen attacking the pawn from behind,
// add all X-ray attacks by the rook or queen. Otherwise consider only
// the squares in the pawn's path attacked or occupied by the enemy.
- if ( (squares_in_front_of(Them, s) & pos.pieces(ROOK, QUEEN, Them))
- && (squares_in_front_of(Them, s) & pos.pieces(ROOK, QUEEN, Them) & pos.attacks_from<ROOK>(s)))
+ if ( (forward_bb(Them, s) & pos.pieces(ROOK, QUEEN, Them))
+ && (forward_bb(Them, s) & pos.pieces(ROOK, QUEEN, Them) & pos.attacks_from<ROOK>(s)))
unsafeSquares = squaresToQueen;
else
unsafeSquares = squaresToQueen & (ei.attackedBy[Them][0] | pos.pieces(Them));
{
s = pop_1st_bit(&b);
queeningSquare = relative_square(c, make_square(file_of(s), RANK_8));
- queeningPath = squares_in_front_of(c, s);
+ queeningPath = forward_bb(c, s);
// Compute plies to queening and check direct advancement
movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(c, s) == RANK_2);
// Check if (without even considering any obstacles) we're too far away or doubled
if ( pliesToQueen[winnerSide] + 3 <= pliesToGo
- || (squares_in_front_of(loserSide, s) & pos.pieces(PAWN, loserSide)))
+ || (forward_bb(loserSide, s) & pos.pieces(PAWN, loserSide)))
candidates ^= s;
}
// Generate list of blocking pawns and supporters
supporters = adjacent_files_bb(file_of(s)) & candidates;
- opposed = squares_in_front_of(loserSide, s) & pos.pieces(PAWN, winnerSide);
+ opposed = forward_bb(loserSide, s) & pos.pieces(PAWN, winnerSide);
blockers = passed_pawn_mask(loserSide, s) & pos.pieces(PAWN, winnerSide);
assert(blockers);
// If queen and king are far or not on a diagonal line we can safely
// remove all the squares attacked in the other direction becuase are
// not reachable by the king anyway.
- if (squares_between(ksq, checksq) || !(PseudoAttacks[BISHOP][checksq] & ksq))
+ if (between_bb(ksq, checksq) || !(PseudoAttacks[BISHOP][checksq] & ksq))
sliderAttacks |= PseudoAttacks[QUEEN][checksq];
// Otherwise we need to use real rook attacks to check if king is safe
return mlist;
// Blocking evasions or captures of the checking piece
- target = squares_between(checksq, ksq) | checkers;
+ target = between_bb(checksq, ksq) | checkers;
mlist = (us == WHITE ? generate_pawn_moves<WHITE, MV_EVASION>(pos, mlist, target)
: generate_pawn_moves<BLACK, MV_EVASION>(pos, mlist, target));
// chain (but not the backward one).
chain = ourPawns & adjacent_files_bb(f) & b;
isolated = !(ourPawns & adjacent_files_bb(f));
- doubled = ourPawns & squares_in_front_of(Us, s);
- opposed = theirPawns & squares_in_front_of(Us, s);
+ doubled = ourPawns & forward_bb(Us, s);
+ opposed = theirPawns & forward_bb(Us, s);
passed = !(theirPawns & passed_pawn_mask(Us, s));
// Test for backward pawn
while (pinners)
{
- b = squares_between(ksq, pop_1st_bit(&pinners)) & pieces();
+ b = between_bb(ksq, pop_1st_bit(&pinners)) & pieces();
- if (b && single_bit(b) && (b & pieces(sideToMove)))
+ if (b && !more_than_one(b) && (b & pieces(sideToMove)))
result |= b;
}
return result;
return false;
// Our move must be a blocking evasion or a capture of the checking piece
- if (!((squares_between(checksq, king_square(us)) | checkers()) & to))
+ if (!((between_bb(checksq, king_square(us)) | checkers()) & to))
return false;
}
// In case of king moves under check we have to remove king so to catch
// Rule 1. Checks which give opponent's king at most one escape square are dangerous
b = kingAtt & ~pos.pieces(them) & ~newAtt & ~(1ULL << to);
- if (single_bit(b)) // Catches also !b
+ if (!more_than_one(b))
return true;
// Rule 2. Queen contact check is very dangerous
// Case 3: Moving through the vacated square
p2 = pos.piece_on(f2);
- if (piece_is_slider(p2) && (squares_between(f2, t2) & f1))
+ if (piece_is_slider(p2) && (between_bb(f2, t2) & f1))
return true;
// Case 4: The destination square for m2 is defended by the moving piece in m1
// Case 5: Discovered check, checking piece is the piece moved in m1
ksq = pos.king_square(pos.side_to_move());
if ( piece_is_slider(p1)
- && (squares_between(t1, ksq) & f2)
+ && (between_bb(t1, ksq) & f2)
&& (pos.attacks_from(p1, t1, pos.pieces() ^ f2) & ksq))
return true;
// Case 3: If the moving piece in the threatened move is a slider, don't
// prune safe moves which block its ray.
if ( piece_is_slider(pos.piece_on(tfrom))
- && (squares_between(tfrom, tto) & mto)
+ && (between_bb(tfrom, tto) & mto)
&& pos.see_sign(m) >= 0)
return true;
&& spCnt > 0
&& !latest->cutoff
&& latest->slavesMask == latest->allSlavesMask
- && !single_bit(latest->allSlavesMask))
+ && more_than_one(latest->allSlavesMask))
{
lock_grab(latest->lock);
lock_grab(Threads.splitLock);
&& spCnt == th->splitPointsCnt
&& !latest->cutoff
&& latest->slavesMask == latest->allSlavesMask
- && !single_bit(latest->allSlavesMask))
+ && more_than_one(latest->allSlavesMask))
{
latest->slavesMask |= 1ULL << idx; // allSlavesMask is not updated
curSplitPoint = latest;