// king is on g8 and there's a white knight on g5, this knight adds
// 2 to kingAdjacentZoneAttacksCount[BLACK].
int kingAdjacentZoneAttacksCount[COLOR_NB];
+
+ Bitboard pinnedPieces[COLOR_NB];
};
// Evaluation grain size, must be a power of 2
const Score RookOpenFile = make_score(43, 21);
const Score RookSemiopenFile = make_score(19, 10);
const Score BishopPawns = make_score( 8, 12);
+ const Score KnightPawns = make_score( 8, 4);
const Score MinorBehindPawn = make_score(16, 0);
const Score UndefendedMinor = make_score(25, 10);
const Score TrappedRook = make_score(90, 0);
const int KingAttackWeights[] = { 0, 0, 2, 2, 3, 5 };
// Bonuses for enemy's safe checks
- const int QueenContactCheck = 12;
- const int RookContactCheck = 8;
- const int QueenCheck = 6;
- const int RookCheck = 4;
- const int BishopCheck = 1;
- const int KnightCheck = 2;
+ const int QueenContactCheck = 24;
+ const int RookContactCheck = 16;
+ const int QueenCheck = 12;
+ const int RookCheck = 8;
+ const int BishopCheck = 2;
+ const int KnightCheck = 3;
// KingExposed[Square] contains penalties based on the position of the
// defending king, indexed by king's square (from white's point of view).
// Function prototypes
template<bool Trace>
- Value do_evaluate(const Position& pos, Value& margin);
+ Value do_evaluate(const Position& pos);
template<Color Us>
void init_eval_info(const Position& pos, EvalInfo& ei);
Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score* mobility);
template<Color Us, bool Trace>
- Score evaluate_king(const Position& pos, const EvalInfo& ei, Value margins[]);
+ Score evaluate_king(const Position& pos, const EvalInfo& ei);
template<Color Us, bool Trace>
Score evaluate_threats(const Position& pos, const EvalInfo& ei);
/// values, an endgame score and a middle game score, and interpolates
/// between them based on the remaining material.
- Value evaluate(const Position& pos, Value& margin) {
- return do_evaluate<false>(pos, margin);
+ Value evaluate(const Position& pos) {
+ return do_evaluate<false>(pos);
}
namespace {
template<bool Trace>
-Value do_evaluate(const Position& pos, Value& margin) {
+Value do_evaluate(const Position& pos) {
assert(!pos.checkers());
EvalInfo ei;
- Value margins[COLOR_NB];
Score score, mobility[2] = { SCORE_ZERO, SCORE_ZERO };
Thread* th = pos.this_thread();
- // margins[] store the uncertainty estimation of position's evaluation
- // that typically is used by the search for pruning decisions.
- margins[WHITE] = margins[BLACK] = VALUE_ZERO;
-
// Initialize score by reading the incrementally updated scores included
// in the position object (material + piece square tables) and adding
// Tempo bonus. Score is computed from the point of view of white.
// If we have a specialized evaluation function for the current material
// configuration, call it and return.
if (ei.mi->specialized_eval_exists())
- {
- margin = VALUE_ZERO;
return ei.mi->evaluate(pos);
- }
// Probe the pawn hash table
ei.pi = Pawns::probe(pos, th->pawnsTable);
// Evaluate kings after all other pieces because we need complete attack
// information when computing the king safety evaluation.
- score += evaluate_king<WHITE, Trace>(pos, ei, margins)
- - evaluate_king<BLACK, Trace>(pos, ei, margins);
+ score += evaluate_king<WHITE, Trace>(pos, ei)
+ - evaluate_king<BLACK, Trace>(pos, ei);
// Evaluate tactical threats, we need full attack information including king
score += evaluate_threats<WHITE, Trace>(pos, ei)
sf = ScaleFactor(50);
}
- margin = margins[pos.side_to_move()];
Value v = interpolate(score, ei.mi->game_phase(), sf);
// In case of tracing add all single evaluation contributions for both white and black
Score b = ei.mi->space_weight() * evaluate_space<BLACK>(pos, ei);
Tracing::add(SPACE, apply_weight(w, Weights[Space]), apply_weight(b, Weights[Space]));
Tracing::add(TOTAL, score);
- Tracing::stream << "\nUncertainty margin: White: " << to_cp(margins[WHITE])
- << ", Black: " << to_cp(margins[BLACK])
- << "\nScaling: " << std::noshowpos
+ Tracing::stream << "\nScaling: " << std::noshowpos
<< std::setw(6) << 100.0 * ei.mi->game_phase() / 128.0 << "% MG, "
<< std::setw(6) << 100.0 * (1.0 - ei.mi->game_phase() / 128.0) << "% * "
<< std::setw(6) << (100.0 * sf) / SCALE_FACTOR_NORMAL << "% EG.\n"
const Color Them = (Us == WHITE ? BLACK : WHITE);
const Square Down = (Us == WHITE ? DELTA_S : DELTA_N);
+ ei.pinnedPieces[Us] = pos.pinned_pieces(Us);
+
Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.king_square(Them));
ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
: Piece == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
: pos.attacks_from<Piece>(s);
+ if (ei.pinnedPieces[Us] & s)
+ b &= LineBB[pos.king_square(Us)][s];
+
ei.attackedBy[Us][Piece] |= b;
if (b & ei.kingRing[Them])
if (Piece == BISHOP)
score -= BishopPawns * ei.pi->pawns_on_same_color_squares(Us, s);
+ // Penalty for knight when there are few enemy pawns
+ if (Piece == KNIGHT)
+ score -= KnightPawns * std::max(5 - pos.count<PAWN>(Them), 0);
+
if (Piece == BISHOP || Piece == KNIGHT)
{
// Bishop and knight outposts squares
// evaluate_king() assigns bonuses and penalties to a king of a given color
template<Color Us, bool Trace>
- Score evaluate_king(const Position& pos, const EvalInfo& ei, Value margins[]) {
+ Score evaluate_king(const Position& pos, const EvalInfo& ei) {
const Color Them = (Us == WHITE ? BLACK : WHITE);
attackUnits = std::min(99, std::max(0, attackUnits));
// Finally, extract the king danger score from the KingDanger[]
- // array and subtract the score from evaluation. Set also margins[]
- // value that will be used for pruning because this value can sometimes
- // be very big, and so capturing a single attacking piece can therefore
- // result in a score change far bigger than the value of the captured piece.
+ // array and subtract the score from evaluation.
score -= KingDanger[Us == Search::RootColor][attackUnits];
- margins[Us] += mg_value(KingDanger[Us == Search::RootColor][attackUnits]);
}
if (Trace)
stream << std::showpoint << std::showpos << std::fixed << std::setprecision(2);
std::memset(scores, 0, 2 * (TOTAL + 1) * sizeof(Score));
- Value margin;
- do_evaluate<true>(pos, margin);
+ do_evaluate<true>(pos);
std::string totals = stream.str();
stream.str("");