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

Unroll color loops in evaluate

Browse source 
Use templates to manually unroll the loops so that
many values could be calculated at compile time or at
runtime but with a fast direct memory access instead of
an indirect one.

This change gives a speed up of 3.5 % on pgo build !!!  :-)

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2009-09-28 10:46:55 +01:00
parent 60e23693f0
commit d56345c9ae
1 changed files with 127 additions and 118 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

245
src/evaluate.cpp
View file

@ -270,11 +270,11 @@ namespace {
template<bool HasPopCnt> template<bool HasPopCnt>
Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID); Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID);
template<PieceType Piece, bool HasPopCnt> template<Color Us, bool HasPopCnt>
void evaluate_pieces(const Position& p, Color us, EvalInfo& ei); void evaluate_pieces_of_color(const Position& pos, EvalInfo& ei);
template<bool HasPopCnt> template<Color Us, bool HasPopCnt>
void evaluate_king(const Position& p, Color us, EvalInfo &ei); void evaluate_king(const Position& p, EvalInfo &ei);
void evaluate_passed_pawns(const Position &pos, EvalInfo &ei); void evaluate_passed_pawns(const Position &pos, EvalInfo &ei);
void evaluate_trapped_bishop_a7h7(const Position &pos, Square s, Color us, void evaluate_trapped_bishop_a7h7(const Position &pos, Square s, Color us,
@ -359,24 +359,14 @@ Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
ei.kingAttackersCount[BLACK] = count_1s_max_15<HasPopCnt>(b2)/2; ei.kingAttackersCount[BLACK] = count_1s_max_15<HasPopCnt>(b2)/2;
// Evaluate pieces // Evaluate pieces
for (Color c = WHITE; c <= BLACK; c++) evaluate_pieces_of_color<WHITE, HasPopCnt>(pos, ei);
{ evaluate_pieces_of_color<BLACK, HasPopCnt>(pos, ei);
evaluate_pieces<KNIGHT, HasPopCnt>(pos, c, ei);
evaluate_pieces<BISHOP, HasPopCnt>(pos, c, ei);
evaluate_pieces<ROOK, HasPopCnt>(pos, c, ei);
evaluate_pieces<QUEEN, HasPopCnt>(pos, c, ei);
// Sum up all attacked squares
ei.attackedBy[c][0] = ei.attackedBy[c][PAWN] | ei.attackedBy[c][KNIGHT]
| ei.attackedBy[c][BISHOP] | ei.attackedBy[c][ROOK]
| ei.attackedBy[c][QUEEN] | ei.attackedBy[c][KING];
}
// Kings. Kings are evaluated after all other pieces for both sides, // Kings. Kings are evaluated after all other pieces for both sides,
// because we need complete attack information for all pieces when computing // because we need complete attack information for all pieces when computing
// the king safety evaluation. // the king safety evaluation.
for (Color c = WHITE; c <= BLACK; c++) evaluate_king<WHITE, HasPopCnt>(pos, ei);
evaluate_king<HasPopCnt>(pos, c, ei); evaluate_king<BLACK, HasPopCnt>(pos, ei);
// Evaluate passed pawns. We evaluate passed pawns for both sides at once, // Evaluate passed pawns. We evaluate passed pawns for both sides at once,
// because we need to know which side promotes first in positions where // because we need to know which side promotes first in positions where
@ -546,113 +536,117 @@ namespace {
// evaluate_mobility() computes mobility and attacks for every piece // evaluate_mobility() computes mobility and attacks for every piece
template<PieceType Piece, bool HasPopCnt> template<PieceType Piece, Color Us, bool HasPopCnt>
int evaluate_mobility(const Position& p, const Bitboard& b, Color us, Color them, EvalInfo& ei) { int evaluate_mobility(const Position& p, const Bitboard& b, EvalInfo& ei) {
const Color Them = (Us == WHITE ? BLACK : WHITE);
static const int AttackWeight[] = { 0, 0, KnightAttackWeight, BishopAttackWeight, RookAttackWeight, QueenAttackWeight }; static const int AttackWeight[] = { 0, 0, KnightAttackWeight, BishopAttackWeight, RookAttackWeight, QueenAttackWeight };
static const Value* MgBonus[] = { 0, 0, MidgameKnightMobilityBonus, MidgameBishopMobilityBonus, MidgameRookMobilityBonus, MidgameQueenMobilityBonus }; static const Value* MgBonus[] = { 0, 0, MidgameKnightMobilityBonus, MidgameBishopMobilityBonus, MidgameRookMobilityBonus, MidgameQueenMobilityBonus };
static const Value* EgBonus[] = { 0, 0, EndgameKnightMobilityBonus, EndgameBishopMobilityBonus, EndgameRookMobilityBonus, EndgameQueenMobilityBonus }; static const Value* EgBonus[] = { 0, 0, EndgameKnightMobilityBonus, EndgameBishopMobilityBonus, EndgameRookMobilityBonus, EndgameQueenMobilityBonus };
// Update attack info // Update attack info
ei.attackedBy[us][Piece] |= b; ei.attackedBy[Us][Piece] |= b;
// King attacks // King attacks
if (b & ei.kingZone[us]) if (b & ei.kingZone[Us])
{ {
ei.kingAttackersCount[us]++; ei.kingAttackersCount[Us]++;
ei.kingAttackersWeight[us] += AttackWeight[Piece]; ei.kingAttackersWeight[Us] += AttackWeight[Piece];
Bitboard bb = (b & ei.attackedBy[them][KING]); Bitboard bb = (b & ei.attackedBy[Them][KING]);
if (bb) if (bb)
ei.kingAdjacentZoneAttacksCount[us] += count_1s_max_15<HasPopCnt>(bb); ei.kingAdjacentZoneAttacksCount[Us] += count_1s_max_15<HasPopCnt>(bb);
} }
// Remove squares protected by enemy pawns // Remove squares protected by enemy pawns
Bitboard bb = (b & ~ei.attackedBy[them][PAWN]); Bitboard bb = (b & ~ei.attackedBy[Them][PAWN]);
// Mobility // Mobility
int mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(bb & ~p.pieces_of_color(us)) int mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(bb & ~p.pieces_of_color(Us))
: count_1s<HasPopCnt>(bb & ~p.pieces_of_color(us))); : count_1s<HasPopCnt>(bb & ~p.pieces_of_color(Us)));
ei.mgMobility += Sign[us] * MgBonus[Piece][mob]; ei.mgMobility += Sign[Us] * MgBonus[Piece][mob];
ei.egMobility += Sign[us] * EgBonus[Piece][mob]; ei.egMobility += Sign[Us] * EgBonus[Piece][mob];
return mob; return mob;
} }
// evaluate_outposts() evaluates bishop and knight outposts squares // evaluate_outposts() evaluates bishop and knight outposts squares
template<PieceType Piece> template<PieceType Piece, Color Us>
void evaluate_outposts(const Position& p, Color us, Color them, EvalInfo& ei, Square s) { void evaluate_outposts(const Position& p, EvalInfo& ei, Square s) {
const Color Them = (Us == WHITE ? BLACK : WHITE);
// Initial bonus based on square // Initial bonus based on square
Value bonus = (Piece == BISHOP ? BishopOutpostBonus[relative_square(us, s)] Value bonus = (Piece == BISHOP ? BishopOutpostBonus[relative_square(Us, s)]
: KnightOutpostBonus[relative_square(us, s)]); : KnightOutpostBonus[relative_square(Us, s)]);
// Increase bonus if supported by pawn, especially if the opponent has // Increase bonus if supported by pawn, especially if the opponent has
// no minor piece which can exchange the outpost piece // no minor piece which can exchange the outpost piece
if (bonus && (p.attacks_from<PAWN>(s, them) & p.pieces(PAWN, us))) if (bonus && (p.attacks_from<PAWN>(s, Them) & p.pieces(PAWN, Us)))
{ {
if ( p.pieces(KNIGHT, them) == EmptyBoardBB if ( p.pieces(KNIGHT, Them) == EmptyBoardBB
&& (SquaresByColorBB[square_color(s)] & p.pieces(BISHOP, them)) == EmptyBoardBB) && (SquaresByColorBB[square_color(s)] & p.pieces(BISHOP, Them)) == EmptyBoardBB)
bonus += bonus + bonus / 2; bonus += bonus + bonus / 2;
else else
bonus += bonus / 2; bonus += bonus / 2;
} }
ei.mgValue += Sign[us] * bonus; ei.mgValue += Sign[Us] * bonus;
ei.egValue += Sign[us] * bonus; ei.egValue += Sign[Us] * bonus;
} }
// evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given
// color. // color.
template<PieceType Piece, bool HasPopCnt> template<PieceType Piece, Color Us, bool HasPopCnt>
void evaluate_pieces(const Position& pos, Color us, EvalInfo& ei) { void evaluate_pieces(const Position& pos, EvalInfo& ei) {
Bitboard b; Bitboard b;
Square s, ksq; Square s, ksq;
int mob; int mob;
File f; File f;
Color them = opposite_color(us);
const Square* ptr = pos.piece_list_begin(us, Piece); const Color Them = (Us == WHITE ? BLACK : WHITE);
const Square* ptr = pos.piece_list_begin(Us, Piece);
while ((s = *ptr++) != SQ_NONE) while ((s = *ptr++) != SQ_NONE)
{ {
if (Piece == KNIGHT || Piece == QUEEN) if (Piece == KNIGHT || Piece == QUEEN)
b = pos.attacks_from<Piece>(s); b = pos.attacks_from<Piece>(s);
else if (Piece == BISHOP) else if (Piece == BISHOP)
b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(QUEEN, us)); b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(QUEEN, Us));
else if (Piece == ROOK) else if (Piece == ROOK)
b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(ROOK, QUEEN, us)); b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(ROOK, QUEEN, Us));
else else
assert(false); assert(false);
// Attacks and mobility // Attacks and mobility
mob = evaluate_mobility<Piece, HasPopCnt>(pos, b, us, them, ei); mob = evaluate_mobility<Piece, Us, HasPopCnt>(pos, b, ei);
// Bishop and knight outposts squares // Bishop and knight outposts squares
if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, them)) if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, Them))
evaluate_outposts<Piece>(pos, us, them, ei, s); evaluate_outposts<Piece, Us>(pos, ei, s);
// Special patterns: trapped bishops on a7/h7/a2/h2 // Special patterns: trapped bishops on a7/h7/a2/h2
// and trapped bishops on a1/h1/a8/h8 in Chess960. // and trapped bishops on a1/h1/a8/h8 in Chess960.
if (Piece == BISHOP) if (Piece == BISHOP)
{ {
if (bit_is_set(MaskA7H7[us], s)) if (bit_is_set(MaskA7H7[Us], s))
evaluate_trapped_bishop_a7h7(pos, s, us, ei); evaluate_trapped_bishop_a7h7(pos, s, Us, ei);
if (Chess960 && bit_is_set(MaskA1H1[us], s)) if (Chess960 && bit_is_set(MaskA1H1[Us], s))
evaluate_trapped_bishop_a1h1(pos, s, us, ei); evaluate_trapped_bishop_a1h1(pos, s, Us, ei);
} }
if (Piece == ROOK || Piece == QUEEN) if (Piece == ROOK || Piece == QUEEN)
{ {
// Queen or rook on 7th rank // Queen or rook on 7th rank
if ( relative_rank(us, s) == RANK_7 if ( relative_rank(Us, s) == RANK_7
&& relative_rank(us, pos.king_square(them)) == RANK_8) && relative_rank(Us, pos.king_square(Them)) == RANK_8)
{ {
ei.mgValue += Sign[us] * (Piece == ROOK ? MidgameRookOn7thBonus : MidgameQueenOn7thBonus); ei.mgValue += Sign[Us] * (Piece == ROOK ? MidgameRookOn7thBonus : MidgameQueenOn7thBonus);
ei.egValue += Sign[us] * (Piece == ROOK ? EndgameRookOn7thBonus : EndgameQueenOn7thBonus); ei.egValue += Sign[Us] * (Piece == ROOK ? EndgameRookOn7thBonus : EndgameQueenOn7thBonus);
} }
} }
@ -661,84 +655,99 @@ namespace {
{ {
// Open and half-open files // Open and half-open files
f = square_file(s); f = square_file(s);
if (ei.pi->file_is_half_open(us, f)) if (ei.pi->file_is_half_open(Us, f))
{ {
if (ei.pi->file_is_half_open(them, f)) if (ei.pi->file_is_half_open(Them, f))
{ {
ei.mgValue += Sign[us] * RookOpenFileBonus; ei.mgValue += Sign[Us] * RookOpenFileBonus;
ei.egValue += Sign[us] * RookOpenFileBonus; ei.egValue += Sign[Us] * RookOpenFileBonus;
} }
else else
{ {
ei.mgValue += Sign[us] * RookHalfOpenFileBonus; ei.mgValue += Sign[Us] * RookHalfOpenFileBonus;
ei.egValue += Sign[us] * RookHalfOpenFileBonus; ei.egValue += Sign[Us] * RookHalfOpenFileBonus;
} }
} }
// Penalize rooks which are trapped inside a king. Penalize more if // Penalize rooks which are trapped inside a king. Penalize more if
// king has lost right to castle. // king has lost right to castle.
if (mob > 6 || ei.pi->file_is_half_open(us, f)) if (mob > 6 || ei.pi->file_is_half_open(Us, f))
continue; continue;
ksq = pos.king_square(us); ksq = pos.king_square(Us);
if ( square_file(ksq) >= FILE_E if ( square_file(ksq) >= FILE_E
&& square_file(s) > square_file(ksq) && square_file(s) > square_file(ksq)
&& (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s))) && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
{ {
// Is there a half-open file between the king and the edge of the board? // Is there a half-open file between the king and the edge of the board?
if (!ei.pi->has_open_file_to_right(us, square_file(ksq))) if (!ei.pi->has_open_file_to_right(Us, square_file(ksq)))
ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2) ei.mgValue -= pos.can_castle(Us)? Sign[Us] * ((TrappedRookPenalty - mob * 16) / 2)
: Sign[us] * (TrappedRookPenalty - mob * 16); : Sign[Us] * (TrappedRookPenalty - mob * 16);
} }
else if ( square_file(ksq) <= FILE_D else if ( square_file(ksq) <= FILE_D
&& square_file(s) < square_file(ksq) && square_file(s) < square_file(ksq)
&& (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s))) && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
{ {
// Is there a half-open file between the king and the edge of the board? // Is there a half-open file between the king and the edge of the board?
if (!ei.pi->has_open_file_to_left(us, square_file(ksq))) if (!ei.pi->has_open_file_to_left(Us, square_file(ksq)))
ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2) ei.mgValue -= pos.can_castle(Us)? Sign[Us] * ((TrappedRookPenalty - mob * 16) / 2)
: Sign[us] * (TrappedRookPenalty - mob * 16); : Sign[Us] * (TrappedRookPenalty - mob * 16);
} }
} }
} }
} }
// evaluate_pieces_of_color<>() assigns bonuses and penalties to all the pieces of a given
// color.
template<Color Us, bool HasPopCnt>
void evaluate_pieces_of_color(const Position& pos, EvalInfo& ei) {
evaluate_pieces<KNIGHT, Us, HasPopCnt>(pos, ei);
evaluate_pieces<BISHOP, Us, HasPopCnt>(pos, ei);
evaluate_pieces<ROOK, Us, HasPopCnt>(pos, ei);
evaluate_pieces<QUEEN, Us, HasPopCnt>(pos, ei);
// Sum up all attacked squares
ei.attackedBy[Us][0] = ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
| ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
| ei.attackedBy[Us][QUEEN] | ei.attackedBy[Us][KING];
}
// evaluate_king<>() assigns bonuses and penalties to a king of a given color. // evaluate_king<>() assigns bonuses and penalties to a king of a given color.
template<bool HasPopCnt> template<Color Us, bool HasPopCnt>
void evaluate_king(const Position& p, Color us, EvalInfo& ei) { void evaluate_king(const Position& p, EvalInfo& ei) {
int shelter = 0, sign = Sign[us]; const Color Them = (Us == WHITE ? BLACK : WHITE);
Square s = p.king_square(us); const Square s = p.king_square(Us);
int shelter = 0;
// King shelter // King shelter
if (relative_rank(us, s) <= RANK_4) if (relative_rank(Us, s) <= RANK_4)
{ {
shelter = ei.pi->get_king_shelter(p, us, s); shelter = ei.pi->get_king_shelter(p, Us, s);
ei.mgValue += sign * Value(shelter); ei.mgValue += Sign[Us] * Value(shelter);
} }
// King safety. This is quite complicated, and is almost certainly far // King safety. This is quite complicated, and is almost certainly far
// from optimally tuned. // from optimally tuned.
Color them = opposite_color(us); if ( p.piece_count(Them, QUEEN) >= 1
&& ei.kingAttackersCount[Them] >= 2
if ( p.piece_count(them, QUEEN) >= 1 && p.non_pawn_material(Them) >= QueenValueMidgame + RookValueMidgame
&& ei.kingAttackersCount[them] >= 2 && ei.kingAdjacentZoneAttacksCount[Them])
&& p.non_pawn_material(them) >= QueenValueMidgame + RookValueMidgame
&& ei.kingAdjacentZoneAttacksCount[them])
{ {
// Is it the attackers turn to move? // Is it the attackers turn to move?
bool sente = (them == p.side_to_move()); bool sente = (Them == p.side_to_move());
// Find the attacked squares around the king which has no defenders // Find the attacked squares around the king which has no defenders
// apart from the king itself // apart from the king itself
Bitboard undefended = Bitboard undefended =
ei.attacked_by(them) & ~ei.attacked_by(us, PAWN) ei.attacked_by(Them) & ~ei.attacked_by(Us, PAWN)
& ~ei.attacked_by(us, KNIGHT) & ~ei.attacked_by(us, BISHOP) & ~ei.attacked_by(Us, KNIGHT) & ~ei.attacked_by(Us, BISHOP)
& ~ei.attacked_by(us, ROOK) & ~ei.attacked_by(us, QUEEN) & ~ei.attacked_by(Us, ROOK) & ~ei.attacked_by(Us, QUEEN)
& ei.attacked_by(us, KING); & ei.attacked_by(Us, KING);
Bitboard occ = p.occupied_squares(), b, b2; Bitboard occ = p.occupied_squares(), b, b2;
@ -748,17 +757,17 @@ namespace {
// undefended squares around the king, the square of the king, and the // undefended squares around the king, the square of the king, and the
// quality of the pawn shelter. // quality of the pawn shelter.
int attackUnits = int attackUnits =
Min((ei.kingAttackersCount[them] * ei.kingAttackersWeight[them]) / 2, 25) Min((ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2, 25)
+ (ei.kingAdjacentZoneAttacksCount[them] + count_1s_max_15<HasPopCnt>(undefended)) * 3 + (ei.kingAdjacentZoneAttacksCount[Them] + count_1s_max_15<HasPopCnt>(undefended)) * 3
+ InitKingDanger[relative_square(us, s)] - (shelter >> 5); + InitKingDanger[relative_square(Us, s)] - (shelter >> 5);
// Analyse safe queen contact checks // Analyse safe queen contact checks
b = undefended & ei.attacked_by(them, QUEEN) & ~p.pieces_of_color(them); b = undefended & ei.attacked_by(Them, QUEEN) & ~p.pieces_of_color(Them);
if (b) if (b)
{ {
Bitboard attackedByOthers = Bitboard attackedByOthers =
ei.attacked_by(them, PAWN) | ei.attacked_by(them, KNIGHT) ei.attacked_by(Them, PAWN) | ei.attacked_by(Them, KNIGHT)
| ei.attacked_by(them, BISHOP) | ei.attacked_by(them, ROOK); | ei.attacked_by(Them, BISHOP) | ei.attacked_by(Them, ROOK);
b &= attackedByOthers; b &= attackedByOthers;
if (b) if (b)
@ -772,7 +781,7 @@ namespace {
if (QueenContactMates && !p.is_check()) if (QueenContactMates && !p.is_check())
{ {
Bitboard escapeSquares = Bitboard escapeSquares =
p.attacks_from<KING>(s) & ~p.pieces_of_color(us) & ~attackedByOthers; p.attacks_from<KING>(s) & ~p.pieces_of_color(Us) & ~attackedByOthers;
while (b) while (b)
{ {
@ -781,15 +790,15 @@ namespace {
{ {
// We have a mate, unless the queen is pinned or there // We have a mate, unless the queen is pinned or there
// is an X-ray attack through the queen. // is an X-ray attack through the queen.
for (int i = 0; i < p.piece_count(them, QUEEN); i++) for (int i = 0; i < p.piece_count(Them, QUEEN); i++)
{ {
from = p.piece_list(them, QUEEN, i); from = p.piece_list(Them, QUEEN, i);
if ( bit_is_set(p.attacks_from<QUEEN>(from), to) if ( bit_is_set(p.attacks_from<QUEEN>(from), to)
&& !bit_is_set(p.pinned_pieces(them), from) && !bit_is_set(p.pinned_pieces(Them), from)
&& !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.pieces(ROOK, QUEEN, us)) && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.pieces(ROOK, QUEEN, Us))
&& !(bishop_attacks_bb(to, occ & ClearMaskBB[from]) & p.pieces(BISHOP, QUEEN, us))) && !(bishop_attacks_bb(to, occ & ClearMaskBB[from]) & p.pieces(BISHOP, QUEEN, Us)))
ei.mateThreat[them] = make_move(from, to); ei.mateThreat[Them] = make_move(from, to);
} }
} }
} }
@ -800,38 +809,38 @@ namespace {
// Analyse safe distance checks // Analyse safe distance checks
if (QueenCheckBonus > 0 || RookCheckBonus > 0) if (QueenCheckBonus > 0 || RookCheckBonus > 0)
{ {
b = p.attacks_from<ROOK>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us); b = p.attacks_from<ROOK>(s) & ~p.pieces_of_color(Them) & ~ei.attacked_by(Us);
// Queen checks // Queen checks
b2 = b & ei.attacked_by(them, QUEEN); b2 = b & ei.attacked_by(Them, QUEEN);
if( b2) if( b2)
attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b2); attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b2);
// Rook checks // Rook checks
b2 = b & ei.attacked_by(them, ROOK); b2 = b & ei.attacked_by(Them, ROOK);
if (b2) if (b2)
attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b2); attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b2);
} }
if (QueenCheckBonus > 0 || BishopCheckBonus > 0) if (QueenCheckBonus > 0 || BishopCheckBonus > 0)
{ {
b = p.attacks_from<BISHOP>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us); b = p.attacks_from<BISHOP>(s) & ~p.pieces_of_color(Them) & ~ei.attacked_by(Us);
// Queen checks // Queen checks
b2 = b & ei.attacked_by(them, QUEEN); b2 = b & ei.attacked_by(Them, QUEEN);
if (b2) if (b2)
attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b2); attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b2);
// Bishop checks // Bishop checks
b2 = b & ei.attacked_by(them, BISHOP); b2 = b & ei.attacked_by(Them, BISHOP);
if (b2) if (b2)
attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b2); attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b2);
} }
if (KnightCheckBonus > 0) if (KnightCheckBonus > 0)
{ {
b = p.attacks_from<KNIGHT>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us); b = p.attacks_from<KNIGHT>(s) & ~p.pieces_of_color(Them) & ~ei.attacked_by(Us);
// Knight checks // Knight checks
b2 = b & ei.attacked_by(them, KNIGHT); b2 = b & ei.attacked_by(Them, KNIGHT);
if (b2) if (b2)
attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b2); attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b2);
} }
@ -840,16 +849,16 @@ namespace {
// adding pawns later). // adding pawns later).
if (DiscoveredCheckBonus) if (DiscoveredCheckBonus)
{ {
b = p.discovered_check_candidates(them) & ~p.pieces(PAWN); b = p.discovered_check_candidates(Them) & ~p.pieces(PAWN);
if (b) if (b)
attackUnits += DiscoveredCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente? 2 : 1); attackUnits += DiscoveredCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente ? 2 : 1);
} }
// Has a mate threat been found? We don't do anything here if the // Has a mate threat been found? We don't do anything here if the
// side with the mating move is the side to move, because in that // side with the mating move is the side to move, because in that
// case the mating side will get a huge bonus at the end of the main // case the mating side will get a huge bonus at the end of the main
// evaluation function instead. // evaluation function instead.
if (ei.mateThreat[them] != MOVE_NONE) if (ei.mateThreat[Them] != MOVE_NONE)
attackUnits += MateThreatBonus; attackUnits += MateThreatBonus;
// Ensure that attackUnits is between 0 and 99, in order to avoid array // Ensure that attackUnits is between 0 and 99, in order to avoid array
@ -866,11 +875,11 @@ namespace {
// that the king safety scores can sometimes be very big, and that // that the king safety scores can sometimes be very big, and that
// capturing a single attacking piece can therefore result in a score // capturing a single attacking piece can therefore result in a score
// change far bigger than the value of the captured piece. // change far bigger than the value of the captured piece.
Value v = apply_weight(SafetyTable[attackUnits], WeightKingSafety[us]); Value v = apply_weight(SafetyTable[attackUnits], WeightKingSafety[Us]);
ei.mgValue -= sign * v; ei.mgValue -= Sign[Us] * v;
if (us == p.side_to_move()) if (Us == p.side_to_move())
ei.futilityMargin += v; ei.futilityMargin += v;
} }
} }