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 = 6;
- const int RookContactCheck = 4;
- const int QueenCheck = 3;
- const int RookCheck = 2;
- const int BishopCheck = 1;
- const int KnightCheck = 1;
+ 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);
template<Color Us, bool Trace>
- Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility);
+ 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, mobilityWhite, mobilityBlack;
+ 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);
init_eval_info<BLACK>(pos, ei);
// Evaluate pieces and mobility
- score += evaluate_pieces_of_color<WHITE, Trace>(pos, ei, mobilityWhite)
- - evaluate_pieces_of_color<BLACK, Trace>(pos, ei, mobilityBlack);
+ score += evaluate_pieces_of_color<WHITE, Trace>(pos, ei, mobility)
+ - evaluate_pieces_of_color<BLACK, Trace>(pos, ei, mobility);
- score += apply_weight(mobilityWhite - mobilityBlack, Weights[Mobility]);
+ score += apply_weight(mobility[WHITE] - mobility[BLACK], Weights[Mobility]);
// 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"
b &= ei.attackedBy[Us][PAWN];
ei.kingAttackersCount[Us] = b ? popcount<Max15>(b) / 2 : 0;
ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = 0;
- } else
+ }
+ else
ei.kingRing[Them] = ei.kingAttackersCount[Us] = 0;
}
else
bonus += bonus / 2;
}
+
return make_score(bonus, bonus);
}
- // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given color
+ // evaluate_pieces() assigns bonuses and penalties to the pieces of a given color
template<PieceType Piece, Color Us, bool Trace>
- Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score& mobility, Bitboard mobilityArea) {
+ Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility, Bitboard mobilityArea) {
Bitboard b;
Square s;
{
ei.kingAttackersCount[Us]++;
ei.kingAttackersWeight[Us] += KingAttackWeights[Piece];
- Bitboard bb = (b & ei.attackedBy[Them][KING]);
+ Bitboard bb = b & ei.attackedBy[Them][KING];
if (bb)
ei.kingAdjacentZoneAttacksCount[Us] += popcount<Max15>(bb);
}
int mob = Piece != QUEEN ? popcount<Max15>(b & mobilityArea)
: popcount<Full >(b & mobilityArea);
- mobility += MobilityBonus[Piece][mob];
+ mobility[Us] += MobilityBonus[Piece][mob];
// Decrease score if we are attacked by an enemy pawn. Remaining part
// of threat evaluation must be done later when we have full attack info.
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
const enum Piece P = make_piece(Us, PAWN);
Square d = pawn_push(Us) + (file_of(s) == FILE_A ? DELTA_E : DELTA_W);
if (pos.piece_on(s + d) == P)
- score -= !pos.is_empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1 * 4
- : pos.piece_on(s + d + d) == P ? TrappedBishopA1H1 * 2
- : TrappedBishopA1H1;
+ score -= !pos.empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1 * 4
+ : pos.piece_on(s + d + d) == P ? TrappedBishopA1H1 * 2
+ : TrappedBishopA1H1;
}
}
}
- // evaluate_threats<>() assigns bonuses according to the type of attacking piece
- // and the type of attacked one.
-
- template<Color Us, bool Trace>
- Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
-
- const Color Them = (Us == WHITE ? BLACK : WHITE);
-
- Bitboard b, undefendedMinors, weakEnemies;
- Score score = SCORE_ZERO;
-
- // Undefended minors get penalized even if not under attack
- undefendedMinors = pos.pieces(Them, BISHOP, KNIGHT)
- & ~ei.attackedBy[Them][ALL_PIECES];
-
- if (undefendedMinors)
- score += UndefendedMinor;
-
- // Enemy pieces not defended by a pawn and under our attack
- weakEnemies = pos.pieces(Them)
- & ~ei.attackedBy[Them][PAWN]
- & ei.attackedBy[Us][ALL_PIECES];
-
- // Add bonus according to type of attacked enemy piece and to the
- // type of attacking piece, from knights to queens. Kings are not
- // considered because are already handled in king evaluation.
- if (weakEnemies)
- for (PieceType pt1 = KNIGHT; pt1 < KING; ++pt1)
- {
- b = ei.attackedBy[Us][pt1] & weakEnemies;
- if (b)
- for (PieceType pt2 = PAWN; pt2 < KING; ++pt2)
- if (b & pos.pieces(pt2))
- score += Threat[pt1][pt2];
- }
-
- if (Trace)
- Tracing::scores[Us][THREAT] = score;
-
- return score;
- }
-
-
- // evaluate_pieces_of_color<>() assigns bonuses and penalties to all the
+ // evaluate_pieces_of_color() assigns bonuses and penalties to all the
// pieces of a given color.
template<Color Us, bool Trace>
- Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility) {
+ Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score* mobility) {
const Color Them = (Us == WHITE ? BLACK : WHITE);
- Score score = mobility = SCORE_ZERO;
-
// Do not include in mobility squares protected by enemy pawns or occupied by our pieces
const Bitboard mobilityArea = ~(ei.attackedBy[Them][PAWN] | pos.pieces(Us, PAWN, KING));
- score += evaluate_pieces<KNIGHT, Us, Trace>(pos, ei, mobility, mobilityArea);
- score += evaluate_pieces<BISHOP, Us, Trace>(pos, ei, mobility, mobilityArea);
- score += evaluate_pieces<ROOK, Us, Trace>(pos, ei, mobility, mobilityArea);
- score += evaluate_pieces<QUEEN, Us, Trace>(pos, ei, mobility, mobilityArea);
+ Score score = evaluate_pieces<KNIGHT, Us, Trace>(pos, ei, mobility, mobilityArea)
+ + evaluate_pieces<BISHOP, Us, Trace>(pos, ei, mobility, mobilityArea)
+ + evaluate_pieces<ROOK, Us, Trace>(pos, ei, mobility, mobilityArea)
+ + evaluate_pieces<QUEEN, Us, Trace>(pos, ei, mobility, mobilityArea);
- // Sum up all attacked squares
- ei.attackedBy[Us][ALL_PIECES] = ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
- | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
- | ei.attackedBy[Us][QUEEN] | ei.attackedBy[Us][KING];
+ // Sum up all attacked squares (updated in evaluate_pieces)
+ ei.attackedBy[Us][ALL_PIECES] = ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
+ | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
+ | ei.attackedBy[Us][QUEEN] | ei.attackedBy[Us][KING];
if (Trace)
- Tracing::scores[Us][MOBILITY] = apply_weight(mobility, Weights[Mobility]);
+ Tracing::scores[Us][MOBILITY] = apply_weight(mobility[Us], Weights[Mobility]);
return score;
}
- // 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<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);
// King shelter and enemy pawns storm
Score score = ei.pi->king_safety<Us>(pos, ksq);
- // King safety. This is quite complicated, and is almost certainly far
- // from optimally tuned.
+ // Main king safety evaluation
if ( ei.kingAttackersCount[Them] >= 2
&& ei.kingAdjacentZoneAttacksCount[Them])
{
// Find the attacked squares around the king which has no defenders
// apart from the king itself
- undefended = ei.attackedBy[Them][ALL_PIECES] & ei.attackedBy[Us][KING];
- undefended &= ~( ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
+ undefended = ei.attackedBy[Them][ALL_PIECES]
+ & ei.attackedBy[Us][KING]
+ & ~( ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
| ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
| ei.attackedBy[Us][QUEEN]);
// number and types of the enemy's attacking pieces, the number of
// attacked and undefended squares around our king, the square of the
// king, and the quality of the pawn shelter.
- attackUnits = std::min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
+ attackUnits = std::min(20, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
+ 3 * (ei.kingAdjacentZoneAttacksCount[Them] + popcount<Max15>(undefended))
+ KingExposed[relative_square(Us, ksq)]
- mg_value(score) / 32;
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)
}
- // evaluate_passed_pawns<>() evaluates the passed pawns of the given color
+ // evaluate_threats() assigns bonuses according to the type of attacking piece
+ // and the type of attacked one.
+
+ template<Color Us, bool Trace>
+ Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
+
+ const Color Them = (Us == WHITE ? BLACK : WHITE);
+
+ Bitboard b, undefendedMinors, weakEnemies;
+ Score score = SCORE_ZERO;
+
+ // Undefended minors get penalized even if not under attack
+ undefendedMinors = pos.pieces(Them, BISHOP, KNIGHT)
+ & ~ei.attackedBy[Them][ALL_PIECES];
+
+ if (undefendedMinors)
+ score += UndefendedMinor;
+
+ // Enemy pieces not defended by a pawn and under our attack
+ weakEnemies = pos.pieces(Them)
+ & ~ei.attackedBy[Them][PAWN]
+ & ei.attackedBy[Us][ALL_PIECES];
+
+ // Add bonus according to type of attacked enemy piece and to the
+ // type of attacking piece, from knights to queens. Kings are not
+ // considered because are already handled in king evaluation.
+ if (weakEnemies)
+ for (PieceType pt1 = KNIGHT; pt1 < KING; ++pt1)
+ {
+ b = ei.attackedBy[Us][pt1] & weakEnemies;
+ if (b)
+ for (PieceType pt2 = PAWN; pt2 < KING; ++pt2)
+ if (b & pos.pieces(pt2))
+ score += Threat[pt1][pt2];
+ }
+
+ if (Trace)
+ Tracing::scores[Us][THREAT] = score;
+
+ return score;
+ }
+
+
+ // evaluate_passed_pawns() evaluates the passed pawns of the given color
template<Color Us, bool Trace>
Score evaluate_passed_pawns(const Position& pos, const EvalInfo& ei) {
{
Square s = pop_lsb(&b);
- assert(pos.pawn_is_passed(Us, s));
+ assert(pos.pawn_passed(Us, s));
int r = int(relative_rank(Us, s) - RANK_2);
int rr = r * (r - 1);
ebonus -= Value(square_distance(pos.king_square(Us), blockSq + pawn_push(Us)) * rr);
// If the pawn is free to advance, increase bonus
- if (pos.is_empty(blockSq))
+ if (pos.empty(blockSq))
{
squaresToQueen = forward_bb(Us, s);
ebonus -= ebonus / 4;
}
- // Increase the bonus if we have more non-pawn pieces
- if (pos.count<ALL_PIECES>( Us) - pos.count<PAWN>( Us) >
- pos.count<ALL_PIECES>(Them) - pos.count<PAWN>(Them))
+ if (pos.count<PAWN>(Us) < pos.count<PAWN>(Them))
ebonus += ebonus / 4;
score += make_score(mbonus, ebonus);
if (!b || pos.non_pawn_material(~us))
return SCORE_ZERO;
- return Unstoppable * int(relative_rank(WHITE, frontmost_sq(us, b)));
+ return Unstoppable * int(relative_rank(us, frontmost_sq(us, b)));
}
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("");
projects / stockfish / blobdiff