mirror of
https://github.com/sockspls/badfish
synced 2025-04-30 00:33:09 +00:00
Unroll color loops in evaluate
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
parent
60e23693f0
commit
d56345c9ae
1 changed files with 127 additions and 118 deletions
245
src/evaluate.cpp
245
src/evaluate.cpp
|
|
@ -270,11 +270,11 @@ namespace {
|
|||
template<bool HasPopCnt>
|
||||
Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID);
|
||||
|
||||
template<PieceType Piece, bool HasPopCnt>
|
||||
void evaluate_pieces(const Position& p, Color us, EvalInfo& ei);
|
||||
template<Color Us, bool HasPopCnt>
|
||||
void evaluate_pieces_of_color(const Position& pos, EvalInfo& ei);
|
||||
|
||||
template<bool HasPopCnt>
|
||||
void evaluate_king(const Position& p, Color us, EvalInfo &ei);
|
||||
template<Color Us, bool HasPopCnt>
|
||||
void evaluate_king(const Position& p, EvalInfo &ei);
|
||||
|
||||
void evaluate_passed_pawns(const Position &pos, EvalInfo &ei);
|
||||
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;
|
||||
|
||||
// Evaluate pieces
|
||||
for (Color c = WHITE; c <= BLACK; c++)
|
||||
{
|
||||
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];
|
||||
}
|
||||
evaluate_pieces_of_color<WHITE, HasPopCnt>(pos, ei);
|
||||
evaluate_pieces_of_color<BLACK, HasPopCnt>(pos, ei);
|
||||
|
||||
// Kings. Kings are evaluated after all other pieces for both sides,
|
||||
// because we need complete attack information for all pieces when computing
|
||||
// the king safety evaluation.
|
||||
for (Color c = WHITE; c <= BLACK; c++)
|
||||
evaluate_king<HasPopCnt>(pos, c, ei);
|
||||
evaluate_king<WHITE, HasPopCnt>(pos, ei);
|
||||
evaluate_king<BLACK, HasPopCnt>(pos, ei);
|
||||
|
||||
// Evaluate passed pawns. We evaluate passed pawns for both sides at once,
|
||||
// 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
|
||||
|
||||
template<PieceType Piece, bool HasPopCnt>
|
||||
int evaluate_mobility(const Position& p, const Bitboard& b, Color us, Color them, EvalInfo& ei) {
|
||||
template<PieceType Piece, Color Us, bool HasPopCnt>
|
||||
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 Value* MgBonus[] = { 0, 0, MidgameKnightMobilityBonus, MidgameBishopMobilityBonus, MidgameRookMobilityBonus, MidgameQueenMobilityBonus };
|
||||
static const Value* EgBonus[] = { 0, 0, EndgameKnightMobilityBonus, EndgameBishopMobilityBonus, EndgameRookMobilityBonus, EndgameQueenMobilityBonus };
|
||||
|
||||
// Update attack info
|
||||
ei.attackedBy[us][Piece] |= b;
|
||||
ei.attackedBy[Us][Piece] |= b;
|
||||
|
||||
// King attacks
|
||||
if (b & ei.kingZone[us])
|
||||
if (b & ei.kingZone[Us])
|
||||
{
|
||||
ei.kingAttackersCount[us]++;
|
||||
ei.kingAttackersWeight[us] += AttackWeight[Piece];
|
||||
Bitboard bb = (b & ei.attackedBy[them][KING]);
|
||||
ei.kingAttackersCount[Us]++;
|
||||
ei.kingAttackersWeight[Us] += AttackWeight[Piece];
|
||||
Bitboard bb = (b & ei.attackedBy[Them][KING]);
|
||||
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
|
||||
Bitboard bb = (b & ~ei.attackedBy[them][PAWN]);
|
||||
Bitboard bb = (b & ~ei.attackedBy[Them][PAWN]);
|
||||
|
||||
// Mobility
|
||||
int mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(bb & ~p.pieces_of_color(us))
|
||||
: count_1s<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)));
|
||||
|
||||
ei.mgMobility += Sign[us] * MgBonus[Piece][mob];
|
||||
ei.egMobility += Sign[us] * EgBonus[Piece][mob];
|
||||
ei.mgMobility += Sign[Us] * MgBonus[Piece][mob];
|
||||
ei.egMobility += Sign[Us] * EgBonus[Piece][mob];
|
||||
return mob;
|
||||
}
|
||||
|
||||
|
||||
// evaluate_outposts() evaluates bishop and knight outposts squares
|
||||
|
||||
template<PieceType Piece>
|
||||
void evaluate_outposts(const Position& p, Color us, Color them, EvalInfo& ei, Square s) {
|
||||
template<PieceType Piece, Color Us>
|
||||
void evaluate_outposts(const Position& p, EvalInfo& ei, Square s) {
|
||||
|
||||
const Color Them = (Us == WHITE ? BLACK : WHITE);
|
||||
|
||||
// Initial bonus based on square
|
||||
Value bonus = (Piece == BISHOP ? BishopOutpostBonus[relative_square(us, s)]
|
||||
: KnightOutpostBonus[relative_square(us, s)]);
|
||||
Value bonus = (Piece == BISHOP ? BishopOutpostBonus[relative_square(Us, s)]
|
||||
: KnightOutpostBonus[relative_square(Us, s)]);
|
||||
|
||||
// Increase bonus if supported by pawn, especially if the opponent has
|
||||
// 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
|
||||
&& (SquaresByColorBB[square_color(s)] & p.pieces(BISHOP, them)) == EmptyBoardBB)
|
||||
if ( p.pieces(KNIGHT, Them) == EmptyBoardBB
|
||||
&& (SquaresByColorBB[square_color(s)] & p.pieces(BISHOP, Them)) == EmptyBoardBB)
|
||||
bonus += bonus + bonus / 2;
|
||||
else
|
||||
bonus += bonus / 2;
|
||||
}
|
||||
ei.mgValue += Sign[us] * bonus;
|
||||
ei.egValue += Sign[us] * bonus;
|
||||
ei.mgValue += Sign[Us] * bonus;
|
||||
ei.egValue += Sign[Us] * bonus;
|
||||
}
|
||||
|
||||
|
||||
// evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given
|
||||
// color.
|
||||
|
||||
template<PieceType Piece, bool HasPopCnt>
|
||||
void evaluate_pieces(const Position& pos, Color us, EvalInfo& ei) {
|
||||
template<PieceType Piece, Color Us, bool HasPopCnt>
|
||||
void evaluate_pieces(const Position& pos, EvalInfo& ei) {
|
||||
|
||||
Bitboard b;
|
||||
Square s, ksq;
|
||||
int mob;
|
||||
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)
|
||||
{
|
||||
if (Piece == KNIGHT || Piece == QUEEN)
|
||||
b = pos.attacks_from<Piece>(s);
|
||||
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)
|
||||
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
|
||||
assert(false);
|
||||
|
||||
// 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
|
||||
if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, them))
|
||||
evaluate_outposts<Piece>(pos, us, them, ei, s);
|
||||
if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, Them))
|
||||
evaluate_outposts<Piece, Us>(pos, ei, s);
|
||||
|
||||
// Special patterns: trapped bishops on a7/h7/a2/h2
|
||||
// and trapped bishops on a1/h1/a8/h8 in Chess960.
|
||||
if (Piece == BISHOP)
|
||||
{
|
||||
if (bit_is_set(MaskA7H7[us], s))
|
||||
evaluate_trapped_bishop_a7h7(pos, s, us, ei);
|
||||
if (bit_is_set(MaskA7H7[Us], s))
|
||||
evaluate_trapped_bishop_a7h7(pos, s, Us, ei);
|
||||
|
||||
if (Chess960 && bit_is_set(MaskA1H1[us], s))
|
||||
evaluate_trapped_bishop_a1h1(pos, s, us, ei);
|
||||
if (Chess960 && bit_is_set(MaskA1H1[Us], s))
|
||||
evaluate_trapped_bishop_a1h1(pos, s, Us, ei);
|
||||
}
|
||||
|
||||
if (Piece == ROOK || Piece == QUEEN)
|
||||
{
|
||||
// Queen or rook on 7th rank
|
||||
if ( relative_rank(us, s) == RANK_7
|
||||
&& relative_rank(us, pos.king_square(them)) == RANK_8)
|
||||
if ( relative_rank(Us, s) == RANK_7
|
||||
&& relative_rank(Us, pos.king_square(Them)) == RANK_8)
|
||||
{
|
||||
ei.mgValue += Sign[us] * (Piece == ROOK ? MidgameRookOn7thBonus : MidgameQueenOn7thBonus);
|
||||
ei.egValue += Sign[us] * (Piece == ROOK ? EndgameRookOn7thBonus : EndgameQueenOn7thBonus);
|
||||
ei.mgValue += Sign[Us] * (Piece == ROOK ? MidgameRookOn7thBonus : MidgameQueenOn7thBonus);
|
||||
ei.egValue += Sign[Us] * (Piece == ROOK ? EndgameRookOn7thBonus : EndgameQueenOn7thBonus);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -661,84 +655,99 @@ namespace {
|
|||
{
|
||||
// Open and half-open files
|
||||
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.egValue += Sign[us] * RookOpenFileBonus;
|
||||
ei.mgValue += Sign[Us] * RookOpenFileBonus;
|
||||
ei.egValue += Sign[Us] * RookOpenFileBonus;
|
||||
}
|
||||
else
|
||||
{
|
||||
ei.mgValue += Sign[us] * RookHalfOpenFileBonus;
|
||||
ei.egValue += Sign[us] * RookHalfOpenFileBonus;
|
||||
ei.mgValue += Sign[Us] * RookHalfOpenFileBonus;
|
||||
ei.egValue += Sign[Us] * RookHalfOpenFileBonus;
|
||||
}
|
||||
}
|
||||
|
||||
// Penalize rooks which are trapped inside a king. Penalize more if
|
||||
// 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;
|
||||
|
||||
ksq = pos.king_square(us);
|
||||
ksq = pos.king_square(Us);
|
||||
|
||||
if ( square_file(ksq) >= FILE_E
|
||||
&& 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?
|
||||
if (!ei.pi->has_open_file_to_right(us, square_file(ksq)))
|
||||
ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
|
||||
: Sign[us] * (TrappedRookPenalty - mob * 16);
|
||||
if (!ei.pi->has_open_file_to_right(Us, square_file(ksq)))
|
||||
ei.mgValue -= pos.can_castle(Us)? Sign[Us] * ((TrappedRookPenalty - mob * 16) / 2)
|
||||
: Sign[Us] * (TrappedRookPenalty - mob * 16);
|
||||
}
|
||||
else if ( square_file(ksq) <= FILE_D
|
||||
&& 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?
|
||||
if (!ei.pi->has_open_file_to_left(us, square_file(ksq)))
|
||||
ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
|
||||
: Sign[us] * (TrappedRookPenalty - mob * 16);
|
||||
if (!ei.pi->has_open_file_to_left(Us, square_file(ksq)))
|
||||
ei.mgValue -= pos.can_castle(Us)? Sign[Us] * ((TrappedRookPenalty - mob * 16) / 2)
|
||||
: 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.
|
||||
|
||||
template<bool HasPopCnt>
|
||||
void evaluate_king(const Position& p, Color us, EvalInfo& ei) {
|
||||
template<Color Us, bool HasPopCnt>
|
||||
void evaluate_king(const Position& p, EvalInfo& ei) {
|
||||
|
||||
int shelter = 0, sign = Sign[us];
|
||||
Square s = p.king_square(us);
|
||||
const Color Them = (Us == WHITE ? BLACK : WHITE);
|
||||
const Square s = p.king_square(Us);
|
||||
int shelter = 0;
|
||||
|
||||
// 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);
|
||||
ei.mgValue += sign * Value(shelter);
|
||||
shelter = ei.pi->get_king_shelter(p, Us, s);
|
||||
ei.mgValue += Sign[Us] * Value(shelter);
|
||||
}
|
||||
|
||||
// King safety. This is quite complicated, and is almost certainly far
|
||||
// from optimally tuned.
|
||||
Color them = opposite_color(us);
|
||||
|
||||
if ( p.piece_count(them, QUEEN) >= 1
|
||||
&& ei.kingAttackersCount[them] >= 2
|
||||
&& p.non_pawn_material(them) >= QueenValueMidgame + RookValueMidgame
|
||||
&& ei.kingAdjacentZoneAttacksCount[them])
|
||||
if ( p.piece_count(Them, QUEEN) >= 1
|
||||
&& ei.kingAttackersCount[Them] >= 2
|
||||
&& p.non_pawn_material(Them) >= QueenValueMidgame + RookValueMidgame
|
||||
&& ei.kingAdjacentZoneAttacksCount[Them])
|
||||
{
|
||||
// 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
|
||||
// apart from the king itself
|
||||
Bitboard undefended =
|
||||
ei.attacked_by(them) & ~ei.attacked_by(us, PAWN)
|
||||
& ~ei.attacked_by(us, KNIGHT) & ~ei.attacked_by(us, BISHOP)
|
||||
& ~ei.attacked_by(us, ROOK) & ~ei.attacked_by(us, QUEEN)
|
||||
& ei.attacked_by(us, KING);
|
||||
ei.attacked_by(Them) & ~ei.attacked_by(Us, PAWN)
|
||||
& ~ei.attacked_by(Us, KNIGHT) & ~ei.attacked_by(Us, BISHOP)
|
||||
& ~ei.attacked_by(Us, ROOK) & ~ei.attacked_by(Us, QUEEN)
|
||||
& ei.attacked_by(Us, KING);
|
||||
|
||||
Bitboard occ = p.occupied_squares(), b, b2;
|
||||
|
||||
|
|
@ -748,17 +757,17 @@ namespace {
|
|||
// undefended squares around the king, the square of the king, and the
|
||||
// quality of the pawn shelter.
|
||||
int attackUnits =
|
||||
Min((ei.kingAttackersCount[them] * ei.kingAttackersWeight[them]) / 2, 25)
|
||||
+ (ei.kingAdjacentZoneAttacksCount[them] + count_1s_max_15<HasPopCnt>(undefended)) * 3
|
||||
+ InitKingDanger[relative_square(us, s)] - (shelter >> 5);
|
||||
Min((ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2, 25)
|
||||
+ (ei.kingAdjacentZoneAttacksCount[Them] + count_1s_max_15<HasPopCnt>(undefended)) * 3
|
||||
+ InitKingDanger[relative_square(Us, s)] - (shelter >> 5);
|
||||
|
||||
// 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)
|
||||
{
|
||||
Bitboard attackedByOthers =
|
||||
ei.attacked_by(them, PAWN) | ei.attacked_by(them, KNIGHT)
|
||||
| ei.attacked_by(them, BISHOP) | ei.attacked_by(them, ROOK);
|
||||
ei.attacked_by(Them, PAWN) | ei.attacked_by(Them, KNIGHT)
|
||||
| ei.attacked_by(Them, BISHOP) | ei.attacked_by(Them, ROOK);
|
||||
|
||||
b &= attackedByOthers;
|
||||
if (b)
|
||||
|
|
@ -772,7 +781,7 @@ namespace {
|
|||
if (QueenContactMates && !p.is_check())
|
||||
{
|
||||
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)
|
||||
{
|
||||
|
|
@ -781,15 +790,15 @@ namespace {
|
|||
{
|
||||
// We have a mate, unless the queen is pinned or there
|
||||
// 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)
|
||||
&& !bit_is_set(p.pinned_pieces(them), from)
|
||||
&& !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.pieces(ROOK, QUEEN, us))
|
||||
&& !(bishop_attacks_bb(to, occ & ClearMaskBB[from]) & p.pieces(BISHOP, QUEEN, us)))
|
||||
&& !bit_is_set(p.pinned_pieces(Them), from)
|
||||
&& !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.pieces(ROOK, 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
|
||||
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
|
||||
b2 = b & ei.attacked_by(them, QUEEN);
|
||||
b2 = b & ei.attacked_by(Them, QUEEN);
|
||||
if( b2)
|
||||
attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b2);
|
||||
|
||||
// Rook checks
|
||||
b2 = b & ei.attacked_by(them, ROOK);
|
||||
b2 = b & ei.attacked_by(Them, ROOK);
|
||||
if (b2)
|
||||
attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b2);
|
||||
}
|
||||
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
|
||||
b2 = b & ei.attacked_by(them, QUEEN);
|
||||
b2 = b & ei.attacked_by(Them, QUEEN);
|
||||
if (b2)
|
||||
attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b2);
|
||||
|
||||
// Bishop checks
|
||||
b2 = b & ei.attacked_by(them, BISHOP);
|
||||
b2 = b & ei.attacked_by(Them, BISHOP);
|
||||
if (b2)
|
||||
attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b2);
|
||||
}
|
||||
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
|
||||
b2 = b & ei.attacked_by(them, KNIGHT);
|
||||
b2 = b & ei.attacked_by(Them, KNIGHT);
|
||||
if (b2)
|
||||
attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b2);
|
||||
}
|
||||
|
|
@ -840,16 +849,16 @@ namespace {
|
|||
// adding pawns later).
|
||||
if (DiscoveredCheckBonus)
|
||||
{
|
||||
b = p.discovered_check_candidates(them) & ~p.pieces(PAWN);
|
||||
b = p.discovered_check_candidates(Them) & ~p.pieces(PAWN);
|
||||
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
|
||||
// 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
|
||||
// evaluation function instead.
|
||||
if (ei.mateThreat[them] != MOVE_NONE)
|
||||
if (ei.mateThreat[Them] != MOVE_NONE)
|
||||
attackUnits += MateThreatBonus;
|
||||
|
||||
// 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
|
||||
// capturing a single attacking piece can therefore result in a score
|
||||
// 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;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue