namespace {
enum ExtendedPieceType { // Used for tracing
- PST = 8, IMBALANCE, MOBILITY, THREAT, PASSED, UNSTOPPABLE, SPACE, TOTAL
+ PST = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, TOTAL
};
namespace Tracing {
// 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
S( 25, 41), S( 25, 41), S(25, 41), S(25, 41) }
};
- // Outpost[PieceType][Square] contains bonuses of knights and bishops, indexed
- // by piece type and square (from white's point of view).
+ // Outpost[PieceType][Square] contains bonuses for knights and bishops outposts,
+ // indexed by piece type and square (from white's point of view).
const Value Outpost[][SQUARE_NB] = {
{
// A B C D E F G H
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 Score Unstoppable = make_score( 0, 20);
// Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
// a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
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);
template<Color Us>
int evaluate_space(const Position& pos, const EvalInfo& ei);
- Score evaluate_unstoppable_pawns(const Position& pos, const EvalInfo& ei);
+ Score evaluate_unstoppable_pawns(const Position& pos, Color us, const EvalInfo& ei);
Value interpolate(const Score& v, Phase ph, ScaleFactor sf);
Score apply_weight(Score v, Score w);
/// 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);
}
- /// trace() is like evaluate() but instead of a value returns a string suitable
- /// to be print on stdout with the detailed descriptions and values of each
- /// evaluation term. Used mainly for debugging.
+ /// trace() is like evaluate(), but instead of returning a value, it returns
+ /// a string (suitable for outputting to stdout) that contains the detailed
+ /// descriptions and values of each evaluation term. It's mainly used for
+ /// debugging.
std::string trace(const Position& pos) {
return Tracing::do_trace(pos);
}
const int MaxSlope = 30;
const int Peak = 1280;
- for (int t = 0, i = 1; i < 100; i++)
+ for (int t = 0, i = 1; i < 100; ++i)
{
t = std::min(Peak, std::min(int(0.4 * i * i), t + MaxSlope));
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
+ // in the position object (material + piece square tables) and adding a
// Tempo bonus. Score is computed from the point of view of white.
score = pos.psq_score() + (pos.side_to_move() == WHITE ? Tempo : -Tempo);
// 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)
score += evaluate_passed_pawns<WHITE, Trace>(pos, ei)
- evaluate_passed_pawns<BLACK, Trace>(pos, ei);
- // If one side has only a king, check whether exists any unstoppable passed pawn
+ // If one side has only a king, score for potential unstoppable pawns
if (!pos.non_pawn_material(WHITE) || !pos.non_pawn_material(BLACK))
- score += evaluate_unstoppable_pawns(pos, ei);
+ score += evaluate_unstoppable_pawns(pos, WHITE, ei)
+ - evaluate_unstoppable_pawns(pos, BLACK, ei);
// Evaluate space for both sides, only in middle-game.
if (ei.mi->space_weight())
&& pos.opposite_bishops()
&& sf == SCALE_FACTOR_NORMAL)
{
- // Only the two bishops ?
+ // Ignoring any pawns, do both sides only have a single bishop and no
+ // other pieces ?
if ( pos.non_pawn_material(WHITE) == BishopValueMg
&& pos.non_pawn_material(BLACK) == BishopValueMg)
{
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
Tracing::add(PST, pos.psq_score());
Tracing::add(IMBALANCE, ei.mi->material_value());
Tracing::add(PAWN, ei.pi->pawns_value());
- Tracing::add(UNSTOPPABLE, evaluate_unstoppable_pawns(pos, ei));
Score w = ei.mi->space_weight() * evaluate_space<WHITE>(pos, ei);
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);
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;
}
- // evaluate_outposts() evaluates bishop and knight outposts squares
+ // evaluate_outposts() evaluates bishop and knight outpost squares
template<PieceType Piece, Color Us>
Score evaluate_outposts(const Position& pos, EvalInfo& ei, Square s) {
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;
: 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])
{
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
+ // Decrease score if we are attacked by an enemy pawn. The remaining part
// of threat evaluation must be done later when we have full attack info.
if (ei.attackedBy[Them][PAWN] & s)
score -= ThreatenedByPawn[Piece];
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
Square ksq = pos.king_square(Us);
- // Penalize rooks which are trapped inside a king. Penalize more if
- // king has lost right to castle.
+ // Penalize rooks which are trapped by a king. Penalize more if the
+ // king has lost its castling capability.
if ( ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
&& (rank_of(ksq) == rank_of(s) || relative_rank(Us, ksq) == RANK_1)
&& !ei.pi->semiopen_on_side(Us, file_of(ksq), file_of(ksq) < FILE_E))
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
+ // Find the attacked squares around the king which have 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;
- // Analyse enemy's safe queen contact checks. First find undefended
- // squares around the king attacked by enemy queen...
+ // Analyse the enemy's safe queen contact checks. Firstly, find the
+ // undefended squares around the king that are attacked by the enemy's
+ // queen...
b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces(Them);
if (b)
{
- // ...then remove squares not supported by another enemy piece
+ // ...and then remove squares not supported by another enemy piece
b &= ( ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT]
| ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]);
if (b)
* (Them == pos.side_to_move() ? 2 : 1);
}
- // Analyse enemy's safe rook contact checks. First find undefended
- // squares around the king attacked by enemy rooks...
+ // Analyse the enemy's safe rook contact checks. Firstly, find the
+ // undefended squares around the king that are attacked by the enemy's
+ // rooks...
b = undefended & ei.attackedBy[Them][ROOK] & ~pos.pieces(Them);
- // Consider only squares where the enemy rook gives check
+ // Consider only squares where the enemy's rook gives check
b &= PseudoAttacks[ROOK][ksq];
if (b)
{
- // ...then remove squares not supported by another enemy piece
+ // ...and then remove squares not supported by another enemy piece
b &= ( ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT]
| ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][QUEEN]);
if (b)
* (Them == pos.side_to_move() ? 2 : 1);
}
- // Analyse enemy's safe distance checks for sliders and knights
+ // Analyse the enemy's safe distance checks for sliders and knights
safe = ~(pos.pieces(Them) | ei.attackedBy[Us][ALL_PIECES]);
b1 = pos.attacks_from<ROOK>(ksq) & safe;
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 they are 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 they 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);
{
Square blockSq = s + pawn_push(Us);
- // Adjust bonus based on kings proximity
- ebonus += Value(square_distance(pos.king_square(Them), blockSq) * 5 * rr);
- ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 2 * rr);
+ // Adjust bonus based on the king's proximity
+ ebonus += Value(square_distance(pos.king_square(Them), blockSq) * 5 * rr)
+ - Value(square_distance(pos.king_square(Us ), blockSq) * 2 * rr);
// If blockSq is not the queening square then consider also a second push
if (relative_rank(Us, blockSq) != RANK_8)
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 the pawn is free to advance, then increase the bonus
+ if (pos.empty(blockSq))
{
squaresToQueen = forward_bb(Us, s);
else
defendedSquares = squaresToQueen & ei.attackedBy[Us][ALL_PIECES];
- // If there aren't enemy attacks huge bonus, a bit smaller if at
- // least block square is not attacked, otherwise smallest bonus.
+ // If there aren't any enemy attacks, then assign a huge bonus.
+ // The bonus will be a bit smaller if at least the block square
+ // isn't attacked, otherwise assign the smallest possible bonus.
int k = !unsafeSquares ? 15 : !(unsafeSquares & blockSq) ? 9 : 3;
- // Big bonus if the path to queen is fully defended, a bit less
- // if at least block square is defended.
+ // Assign a big bonus if the path to the queen is fully defended,
+ // otherwise assign a bit less of a bonus if at least the block
+ // square is defended.
if (defendedSquares == squaresToQueen)
k += 6;
{
if (pos.non_pawn_material(Them) <= KnightValueMg)
ebonus += ebonus / 4;
+
else if (pos.pieces(Them, ROOK, QUEEN))
ebonus -= ebonus / 4;
}
+
+ if (pos.count<PAWN>(Us) < pos.count<PAWN>(Them))
+ ebonus += ebonus / 4;
+
score += make_score(mbonus, ebonus);
}
}
- // evaluate_unstoppable_pawns() evaluates the unstoppable passed pawns for both sides, this is quite
- // conservative and returns a winning score only when we are very sure that the pawn is winning.
-
- Score evaluate_unstoppable_pawns(const Position& pos, const EvalInfo& ei) {
-
- Bitboard b, b2, blockers, supporters, queeningPath, candidates;
- Square s, blockSq, queeningSquare;
- Color c, winnerSide, loserSide;
- bool pathDefended, opposed;
- int pliesToGo, movesToGo, oppMovesToGo, sacptg, blockersCount, minKingDist, kingptg, d;
- int pliesToQueen[] = { 256, 256 };
-
- // Step 1. Hunt for unstoppable passed pawns. If we find at least one,
- // record how many plies are required for promotion.
- for (c = WHITE; c <= BLACK; c++)
- {
- // Skip if other side has non-pawn pieces
- if (pos.non_pawn_material(~c))
- continue;
+ // evaluate_unstoppable_pawns() scores the most advanced among the passed and
+ // candidate pawns. In case opponent has no pieces but pawns, this is somewhat
+ // related to the possibility that pawns are unstoppable.
- b = ei.pi->passed_pawns(c);
+ Score evaluate_unstoppable_pawns(const Position& pos, Color us, const EvalInfo& ei) {
- while (b)
- {
- s = pop_lsb(&b);
- queeningSquare = relative_square(c, file_of(s) | RANK_8);
- 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);
- oppMovesToGo = square_distance(pos.king_square(~c), queeningSquare) - int(c != pos.side_to_move());
- pathDefended = ((ei.attackedBy[c][ALL_PIECES] & queeningPath) == queeningPath);
-
- if (movesToGo >= oppMovesToGo && !pathDefended)
- continue;
+ Bitboard b = ei.pi->passed_pawns(us) | ei.pi->candidate_pawns(us);
- // Opponent king cannot block because path is defended and position
- // is not in check. So only friendly pieces can be blockers.
- assert(!pos.checkers());
- assert((queeningPath & pos.pieces()) == (queeningPath & pos.pieces(c)));
-
- // Add moves needed to free the path from friendly pieces and retest condition
- movesToGo += popcount<Max15>(queeningPath & pos.pieces(c));
-
- if (movesToGo >= oppMovesToGo && !pathDefended)
- continue;
-
- pliesToGo = 2 * movesToGo - int(c == pos.side_to_move());
- pliesToQueen[c] = std::min(pliesToQueen[c], pliesToGo);
- }
- }
-
- // Step 2. If either side cannot promote at least three plies before the other side then situation
- // becomes too complex and we give up. Otherwise we determine the possibly "winning side"
- if (abs(pliesToQueen[WHITE] - pliesToQueen[BLACK]) < 3)
+ if (!b || pos.non_pawn_material(~us))
return SCORE_ZERO;
- winnerSide = (pliesToQueen[WHITE] < pliesToQueen[BLACK] ? WHITE : BLACK);
- loserSide = ~winnerSide;
-
- // Step 3. Can the losing side possibly create a new passed pawn and thus prevent the loss?
- b = candidates = pos.pieces(loserSide, PAWN);
-
- while (b)
- {
- s = pop_lsb(&b);
-
- // Compute plies from queening
- queeningSquare = relative_square(loserSide, file_of(s) | RANK_8);
- movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(loserSide, s) == RANK_2);
- pliesToGo = 2 * movesToGo - int(loserSide == pos.side_to_move());
-
- // Check if (without even considering any obstacles) we're too far away or doubled
- if ( pliesToQueen[winnerSide] + 3 <= pliesToGo
- || (forward_bb(loserSide, s) & pos.pieces(loserSide, PAWN)))
- candidates ^= s;
- }
-
- // If any candidate is already a passed pawn it _may_ promote in time. We give up.
- if (candidates & ei.pi->passed_pawns(loserSide))
- return SCORE_ZERO;
-
- // Step 4. Check new passed pawn creation through king capturing and pawn sacrifices
- b = candidates;
-
- while (b)
- {
- s = pop_lsb(&b);
- sacptg = blockersCount = 0;
- minKingDist = kingptg = 256;
-
- // Compute plies from queening
- queeningSquare = relative_square(loserSide, file_of(s) | RANK_8);
- movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(loserSide, s) == RANK_2);
- pliesToGo = 2 * movesToGo - int(loserSide == pos.side_to_move());
-
- // Generate list of blocking pawns and supporters
- supporters = adjacent_files_bb(file_of(s)) & candidates;
- opposed = forward_bb(loserSide, s) & pos.pieces(winnerSide, PAWN);
- blockers = passed_pawn_mask(loserSide, s) & pos.pieces(winnerSide, PAWN);
-
- assert(blockers);
-
- // How many plies does it take to remove all the blocking pawns?
- while (blockers)
- {
- blockSq = pop_lsb(&blockers);
- movesToGo = 256;
-
- // Check pawns that can give support to overcome obstacle, for instance
- // black pawns: a4, b4 white: b2 then pawn in b4 is giving support.
- if (!opposed)
- {
- b2 = supporters & in_front_bb(winnerSide, rank_of(blockSq + pawn_push(winnerSide)));
-
- while (b2) // This while-loop could be replaced with LSB/MSB (depending on color)
- {
- d = square_distance(blockSq, pop_lsb(&b2)) - 2;
- movesToGo = std::min(movesToGo, d);
- }
- }
-
- // Check pawns that can be sacrificed against the blocking pawn
- b2 = pawn_attack_span(winnerSide, blockSq) & candidates & ~(1ULL << s);
-
- while (b2) // This while-loop could be replaced with LSB/MSB (depending on color)
- {
- d = square_distance(blockSq, pop_lsb(&b2)) - 2;
- movesToGo = std::min(movesToGo, d);
- }
-
- // If obstacle can be destroyed with an immediate pawn exchange / sacrifice,
- // it's not a real obstacle and we have nothing to add to pliesToGo.
- if (movesToGo <= 0)
- continue;
-
- // Plies needed to sacrifice against all the blocking pawns
- sacptg += movesToGo * 2;
- blockersCount++;
-
- // Plies needed for the king to capture all the blocking pawns
- d = square_distance(pos.king_square(loserSide), blockSq);
- minKingDist = std::min(minKingDist, d);
- kingptg = (minKingDist + blockersCount) * 2;
- }
-
- // Check if pawn sacrifice plan _may_ save the day
- if (pliesToQueen[winnerSide] + 3 > pliesToGo + sacptg)
- return SCORE_ZERO;
-
- // Check if king capture plan _may_ save the day (contains some false positives)
- if (pliesToQueen[winnerSide] + 3 > pliesToGo + kingptg)
- return SCORE_ZERO;
- }
-
- // Winning pawn is unstoppable and will promote as first, return big score
- Score score = make_score(0, (Value) 1280 - 32 * pliesToQueen[winnerSide]);
- return winnerSide == WHITE ? score : -score;
+ return Unstoppable * int(relative_rank(us, frontmost_sq(us, b)));
}
Score bScore = scores[BLACK][idx];
switch (idx) {
- case PST: case IMBALANCE: case PAWN: case UNSTOPPABLE: case TOTAL:
+ case PST: case IMBALANCE: case PAWN: case TOTAL:
stream << std::setw(20) << name << " | --- --- | --- --- | "
<< std::setw(6) << to_cp(mg_value(wScore)) << " "
<< std::setw(6) << to_cp(eg_value(wScore)) << " \n";
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("");
row("King safety", KING);
row("Threats", THREAT);
row("Passed pawns", PASSED);
- row("Unstoppable pawns", UNSTOPPABLE);
row("Space", SPACE);
stream << "---------------------+-------------+-------------+---------------\n";