"Fossies" - the Fresh Open Source Software Archive

Member "stockfish-11-linux/src/evaluate.cpp" (18 Jan 2020, 33584 Bytes) of package /linux/privat/stockfish-11-linux.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. See also the last Fossies "Diffs" side-by-side code changes report for "evaluate.cpp": 9-linux_vs_10-linux.

    1 /*
    2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
    3   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
    4   Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
    5   Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
    6 
    7   Stockfish is free software: you can redistribute it and/or modify
    8   it under the terms of the GNU General Public License as published by
    9   the Free Software Foundation, either version 3 of the License, or
   10   (at your option) any later version.
   11 
   12   Stockfish is distributed in the hope that it will be useful,
   13   but WITHOUT ANY WARRANTY; without even the implied warranty of
   14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   15   GNU General Public License for more details.
   16 
   17   You should have received a copy of the GNU General Public License
   18   along with this program.  If not, see <http://www.gnu.org/licenses/>.
   19 */
   20 
   21 #include <algorithm>
   22 #include <cassert>
   23 #include <cstring>   // For std::memset
   24 #include <iomanip>
   25 #include <sstream>
   26 
   27 #include "bitboard.h"
   28 #include "evaluate.h"
   29 #include "material.h"
   30 #include "pawns.h"
   31 #include "thread.h"
   32 
   33 namespace Trace {
   34 
   35   enum Tracing { NO_TRACE, TRACE };
   36 
   37   enum Term { // The first 8 entries are reserved for PieceType
   38     MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, INITIATIVE, TOTAL, TERM_NB
   39   };
   40 
   41   Score scores[TERM_NB][COLOR_NB];
   42 
   43   double to_cp(Value v) { return double(v) / PawnValueEg; }
   44 
   45   void add(int idx, Color c, Score s) {
   46     scores[idx][c] = s;
   47   }
   48 
   49   void add(int idx, Score w, Score b = SCORE_ZERO) {
   50     scores[idx][WHITE] = w;
   51     scores[idx][BLACK] = b;
   52   }
   53 
   54   std::ostream& operator<<(std::ostream& os, Score s) {
   55     os << std::setw(5) << to_cp(mg_value(s)) << " "
   56        << std::setw(5) << to_cp(eg_value(s));
   57     return os;
   58   }
   59 
   60   std::ostream& operator<<(std::ostream& os, Term t) {
   61 
   62     if (t == MATERIAL || t == IMBALANCE || t == INITIATIVE || t == TOTAL)
   63         os << " ----  ----"    << " | " << " ----  ----";
   64     else
   65         os << scores[t][WHITE] << " | " << scores[t][BLACK];
   66 
   67     os << " | " << scores[t][WHITE] - scores[t][BLACK] << "\n";
   68     return os;
   69   }
   70 }
   71 
   72 using namespace Trace;
   73 
   74 namespace {
   75 
   76   // Threshold for lazy and space evaluation
   77   constexpr Value LazyThreshold  = Value(1400);
   78   constexpr Value SpaceThreshold = Value(12222);
   79 
   80   // KingAttackWeights[PieceType] contains king attack weights by piece type
   81   constexpr int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 81, 52, 44, 10 };
   82 
   83   // Penalties for enemy's safe checks
   84   constexpr int QueenSafeCheck  = 780;
   85   constexpr int RookSafeCheck   = 1080;
   86   constexpr int BishopSafeCheck = 635;
   87   constexpr int KnightSafeCheck = 790;
   88 
   89 #define S(mg, eg) make_score(mg, eg)
   90 
   91   // MobilityBonus[PieceType-2][attacked] contains bonuses for middle and end game,
   92   // indexed by piece type and number of attacked squares in the mobility area.
   93   constexpr Score MobilityBonus[][32] = {
   94     { S(-62,-81), S(-53,-56), S(-12,-30), S( -4,-14), S(  3,  8), S( 13, 15), // Knights
   95       S( 22, 23), S( 28, 27), S( 33, 33) },
   96     { S(-48,-59), S(-20,-23), S( 16, -3), S( 26, 13), S( 38, 24), S( 51, 42), // Bishops
   97       S( 55, 54), S( 63, 57), S( 63, 65), S( 68, 73), S( 81, 78), S( 81, 86),
   98       S( 91, 88), S( 98, 97) },
   99     { S(-58,-76), S(-27,-18), S(-15, 28), S(-10, 55), S( -5, 69), S( -2, 82), // Rooks
  100       S(  9,112), S( 16,118), S( 30,132), S( 29,142), S( 32,155), S( 38,165),
  101       S( 46,166), S( 48,169), S( 58,171) },
  102     { S(-39,-36), S(-21,-15), S(  3,  8), S(  3, 18), S( 14, 34), S( 22, 54), // Queens
  103       S( 28, 61), S( 41, 73), S( 43, 79), S( 48, 92), S( 56, 94), S( 60,104),
  104       S( 60,113), S( 66,120), S( 67,123), S( 70,126), S( 71,133), S( 73,136),
  105       S( 79,140), S( 88,143), S( 88,148), S( 99,166), S(102,170), S(102,175),
  106       S(106,184), S(109,191), S(113,206), S(116,212) }
  107   };
  108 
  109   // RookOnFile[semiopen/open] contains bonuses for each rook when there is
  110   // no (friendly) pawn on the rook file.
  111   constexpr Score RookOnFile[] = { S(21, 4), S(47, 25) };
  112 
  113   // ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to
  114   // which piece type attacks which one. Attacks on lesser pieces which are
  115   // pawn-defended are not considered.
  116   constexpr Score ThreatByMinor[PIECE_TYPE_NB] = {
  117     S(0, 0), S(6, 32), S(59, 41), S(79, 56), S(90, 119), S(79, 161)
  118   };
  119 
  120   constexpr Score ThreatByRook[PIECE_TYPE_NB] = {
  121     S(0, 0), S(3, 44), S(38, 71), S(38, 61), S(0, 38), S(51, 38)
  122   };
  123 
  124   // PassedRank[Rank] contains a bonus according to the rank of a passed pawn
  125   constexpr Score PassedRank[RANK_NB] = {
  126     S(0, 0), S(10, 28), S(17, 33), S(15, 41), S(62, 72), S(168, 177), S(276, 260)
  127   };
  128 
  129   // Assorted bonuses and penalties
  130   constexpr Score BishopPawns        = S(  3,  7);
  131   constexpr Score CorneredBishop     = S( 50, 50);
  132   constexpr Score FlankAttacks       = S(  8,  0);
  133   constexpr Score Hanging            = S( 69, 36);
  134   constexpr Score KingProtector      = S(  7,  8);
  135   constexpr Score KnightOnQueen      = S( 16, 12);
  136   constexpr Score LongDiagonalBishop = S( 45,  0);
  137   constexpr Score MinorBehindPawn    = S( 18,  3);
  138   constexpr Score Outpost            = S( 30, 21);
  139   constexpr Score PassedFile         = S( 11,  8);
  140   constexpr Score PawnlessFlank      = S( 17, 95);
  141   constexpr Score RestrictedPiece    = S(  7,  7);
  142   constexpr Score ReachableOutpost   = S( 32, 10);
  143   constexpr Score RookOnQueenFile    = S(  7,  6);
  144   constexpr Score SliderOnQueen      = S( 59, 18);
  145   constexpr Score ThreatByKing       = S( 24, 89);
  146   constexpr Score ThreatByPawnPush   = S( 48, 39);
  147   constexpr Score ThreatBySafePawn   = S(173, 94);
  148   constexpr Score TrappedRook        = S( 52, 10);
  149   constexpr Score WeakQueen          = S( 49, 15);
  150 
  151 #undef S
  152 
  153   // Evaluation class computes and stores attacks tables and other working data
  154   template<Tracing T>
  155   class Evaluation {
  156 
  157   public:
  158     Evaluation() = delete;
  159     explicit Evaluation(const Position& p) : pos(p) {}
  160     Evaluation& operator=(const Evaluation&) = delete;
  161     Value value();
  162 
  163   private:
  164     template<Color Us> void initialize();
  165     template<Color Us, PieceType Pt> Score pieces();
  166     template<Color Us> Score king() const;
  167     template<Color Us> Score threats() const;
  168     template<Color Us> Score passed() const;
  169     template<Color Us> Score space() const;
  170     ScaleFactor scale_factor(Value eg) const;
  171     Score initiative(Score score) const;
  172 
  173     const Position& pos;
  174     Material::Entry* me;
  175     Pawns::Entry* pe;
  176     Bitboard mobilityArea[COLOR_NB];
  177     Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
  178 
  179     // attackedBy[color][piece type] is a bitboard representing all squares
  180     // attacked by a given color and piece type. Special "piece types" which
  181     // is also calculated is ALL_PIECES.
  182     Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
  183 
  184     // attackedBy2[color] are the squares attacked by at least 2 units of a given
  185     // color, including x-rays. But diagonal x-rays through pawns are not computed.
  186     Bitboard attackedBy2[COLOR_NB];
  187 
  188     // kingRing[color] are the squares adjacent to the king plus some other
  189     // very near squares, depending on king position.
  190     Bitboard kingRing[COLOR_NB];
  191 
  192     // kingAttackersCount[color] is the number of pieces of the given color
  193     // which attack a square in the kingRing of the enemy king.
  194     int kingAttackersCount[COLOR_NB];
  195 
  196     // kingAttackersWeight[color] is the sum of the "weights" of the pieces of
  197     // the given color which attack a square in the kingRing of the enemy king.
  198     // The weights of the individual piece types are given by the elements in
  199     // the KingAttackWeights array.
  200     int kingAttackersWeight[COLOR_NB];
  201 
  202     // kingAttacksCount[color] is the number of attacks by the given color to
  203     // squares directly adjacent to the enemy king. Pieces which attack more
  204     // than one square are counted multiple times. For instance, if there is
  205     // a white knight on g5 and black's king is on g8, this white knight adds 2
  206     // to kingAttacksCount[WHITE].
  207     int kingAttacksCount[COLOR_NB];
  208   };
  209 
  210 
  211   // Evaluation::initialize() computes king and pawn attacks, and the king ring
  212   // bitboard for a given color. This is done at the beginning of the evaluation.
  213   template<Tracing T> template<Color Us>
  214   void Evaluation<T>::initialize() {
  215 
  216     constexpr Color     Them = (Us == WHITE ? BLACK : WHITE);
  217     constexpr Direction Up   = pawn_push(Us);
  218     constexpr Direction Down = -Up;
  219     constexpr Bitboard LowRanks = (Us == WHITE ? Rank2BB | Rank3BB : Rank7BB | Rank6BB);
  220 
  221     const Square ksq = pos.square<KING>(Us);
  222 
  223     Bitboard dblAttackByPawn = pawn_double_attacks_bb<Us>(pos.pieces(Us, PAWN));
  224 
  225     // Find our pawns that are blocked or on the first two ranks
  226     Bitboard b = pos.pieces(Us, PAWN) & (shift<Down>(pos.pieces()) | LowRanks);
  227 
  228     // Squares occupied by those pawns, by our king or queen, by blockers to attacks on our king
  229     // or controlled by enemy pawns are excluded from the mobility area.
  230     mobilityArea[Us] = ~(b | pos.pieces(Us, KING, QUEEN) | pos.blockers_for_king(Us) | pe->pawn_attacks(Them));
  231 
  232     // Initialize attackedBy[] for king and pawns
  233     attackedBy[Us][KING] = pos.attacks_from<KING>(ksq);
  234     attackedBy[Us][PAWN] = pe->pawn_attacks(Us);
  235     attackedBy[Us][ALL_PIECES] = attackedBy[Us][KING] | attackedBy[Us][PAWN];
  236     attackedBy2[Us] = dblAttackByPawn | (attackedBy[Us][KING] & attackedBy[Us][PAWN]);
  237 
  238     // Init our king safety tables
  239     Square s = make_square(clamp(file_of(ksq), FILE_B, FILE_G),
  240                            clamp(rank_of(ksq), RANK_2, RANK_7));
  241     kingRing[Us] = PseudoAttacks[KING][s] | s;
  242 
  243     kingAttackersCount[Them] = popcount(kingRing[Us] & pe->pawn_attacks(Them));
  244     kingAttacksCount[Them] = kingAttackersWeight[Them] = 0;
  245 
  246     // Remove from kingRing[] the squares defended by two pawns
  247     kingRing[Us] &= ~dblAttackByPawn;
  248   }
  249 
  250 
  251   // Evaluation::pieces() scores pieces of a given color and type
  252   template<Tracing T> template<Color Us, PieceType Pt>
  253   Score Evaluation<T>::pieces() {
  254 
  255     constexpr Color     Them = (Us == WHITE ? BLACK : WHITE);
  256     constexpr Direction Down = -pawn_push(Us);
  257     constexpr Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
  258                                                    : Rank5BB | Rank4BB | Rank3BB);
  259     const Square* pl = pos.squares<Pt>(Us);
  260 
  261     Bitboard b, bb;
  262     Score score = SCORE_ZERO;
  263 
  264     attackedBy[Us][Pt] = 0;
  265 
  266     for (Square s = *pl; s != SQ_NONE; s = *++pl)
  267     {
  268         // Find attacked squares, including x-ray attacks for bishops and rooks
  269         b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(QUEEN))
  270           : Pt ==   ROOK ? attacks_bb<  ROOK>(s, pos.pieces() ^ pos.pieces(QUEEN) ^ pos.pieces(Us, ROOK))
  271                          : pos.attacks_from<Pt>(s);
  272 
  273         if (pos.blockers_for_king(Us) & s)
  274             b &= LineBB[pos.square<KING>(Us)][s];
  275 
  276         attackedBy2[Us] |= attackedBy[Us][ALL_PIECES] & b;
  277         attackedBy[Us][Pt] |= b;
  278         attackedBy[Us][ALL_PIECES] |= b;
  279 
  280         if (b & kingRing[Them])
  281         {
  282             kingAttackersCount[Us]++;
  283             kingAttackersWeight[Us] += KingAttackWeights[Pt];
  284             kingAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
  285         }
  286 
  287         int mob = popcount(b & mobilityArea[Us]);
  288 
  289         mobility[Us] += MobilityBonus[Pt - 2][mob];
  290 
  291         if (Pt == BISHOP || Pt == KNIGHT)
  292         {
  293             // Bonus if piece is on an outpost square or can reach one
  294             bb = OutpostRanks & attackedBy[Us][PAWN] & ~pe->pawn_attacks_span(Them);
  295             if (bb & s)
  296                 score += Outpost * (Pt == KNIGHT ? 2 : 1);
  297 
  298             else if (Pt == KNIGHT && bb & b & ~pos.pieces(Us))
  299                 score += ReachableOutpost;
  300 
  301             // Knight and Bishop bonus for being right behind a pawn
  302             if (shift<Down>(pos.pieces(PAWN)) & s)
  303                 score += MinorBehindPawn;
  304 
  305             // Penalty if the piece is far from the king
  306             score -= KingProtector * distance(s, pos.square<KING>(Us));
  307 
  308             if (Pt == BISHOP)
  309             {
  310                 // Penalty according to number of pawns on the same color square as the
  311                 // bishop, bigger when the center files are blocked with pawns.
  312                 Bitboard blocked = pos.pieces(Us, PAWN) & shift<Down>(pos.pieces());
  313 
  314                 score -= BishopPawns * pos.pawns_on_same_color_squares(Us, s)
  315                                      * (1 + popcount(blocked & CenterFiles));
  316 
  317                 // Bonus for bishop on a long diagonal which can "see" both center squares
  318                 if (more_than_one(attacks_bb<BISHOP>(s, pos.pieces(PAWN)) & Center))
  319                     score += LongDiagonalBishop;
  320 
  321                 // An important Chess960 pattern: a cornered bishop blocked by a friendly
  322                 // pawn diagonally in front of it is a very serious problem, especially
  323                 // when that pawn is also blocked.
  324                 if (   pos.is_chess960()
  325                     && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
  326                 {
  327                     Direction d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
  328                     if (pos.piece_on(s + d) == make_piece(Us, PAWN))
  329                         score -= !pos.empty(s + d + pawn_push(Us))                ? CorneredBishop * 4
  330                                 : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? CorneredBishop * 2
  331                                                                                   : CorneredBishop;
  332                 }
  333             }
  334         }
  335 
  336         if (Pt == ROOK)
  337         {
  338             // Bonus for rook on the same file as a queen
  339             if (file_bb(s) & pos.pieces(QUEEN))
  340                 score += RookOnQueenFile;
  341 
  342             // Bonus for rook on an open or semi-open file
  343             if (pos.is_on_semiopen_file(Us, s))
  344                 score += RookOnFile[pos.is_on_semiopen_file(Them, s)];
  345 
  346             // Penalty when trapped by the king, even more if the king cannot castle
  347             else if (mob <= 3)
  348             {
  349                 File kf = file_of(pos.square<KING>(Us));
  350                 if ((kf < FILE_E) == (file_of(s) < kf))
  351                     score -= TrappedRook * (1 + !pos.castling_rights(Us));
  352             }
  353         }
  354 
  355         if (Pt == QUEEN)
  356         {
  357             // Penalty if any relative pin or discovered attack against the queen
  358             Bitboard queenPinners;
  359             if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, queenPinners))
  360                 score -= WeakQueen;
  361         }
  362     }
  363     if (T)
  364         Trace::add(Pt, Us, score);
  365 
  366     return score;
  367   }
  368 
  369 
  370   // Evaluation::king() assigns bonuses and penalties to a king of a given color
  371   template<Tracing T> template<Color Us>
  372   Score Evaluation<T>::king() const {
  373 
  374     constexpr Color    Them = (Us == WHITE ? BLACK : WHITE);
  375     constexpr Bitboard Camp = (Us == WHITE ? AllSquares ^ Rank6BB ^ Rank7BB ^ Rank8BB
  376                                            : AllSquares ^ Rank1BB ^ Rank2BB ^ Rank3BB);
  377 
  378     Bitboard weak, b1, b2, b3, safe, unsafeChecks = 0;
  379     Bitboard rookChecks, queenChecks, bishopChecks, knightChecks;
  380     int kingDanger = 0;
  381     const Square ksq = pos.square<KING>(Us);
  382 
  383     // Init the score with king shelter and enemy pawns storm
  384     Score score = pe->king_safety<Us>(pos);
  385 
  386     // Attacked squares defended at most once by our queen or king
  387     weak =  attackedBy[Them][ALL_PIECES]
  388           & ~attackedBy2[Us]
  389           & (~attackedBy[Us][ALL_PIECES] | attackedBy[Us][KING] | attackedBy[Us][QUEEN]);
  390 
  391     // Analyse the safe enemy's checks which are possible on next move
  392     safe  = ~pos.pieces(Them);
  393     safe &= ~attackedBy[Us][ALL_PIECES] | (weak & attackedBy2[Them]);
  394 
  395     b1 = attacks_bb<ROOK  >(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
  396     b2 = attacks_bb<BISHOP>(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
  397 
  398     // Enemy rooks checks
  399     rookChecks = b1 & safe & attackedBy[Them][ROOK];
  400 
  401     if (rookChecks)
  402         kingDanger += RookSafeCheck;
  403     else
  404         unsafeChecks |= b1 & attackedBy[Them][ROOK];
  405 
  406     // Enemy queen safe checks: we count them only if they are from squares from
  407     // which we can't give a rook check, because rook checks are more valuable.
  408     queenChecks =  (b1 | b2)
  409                  & attackedBy[Them][QUEEN]
  410                  & safe
  411                  & ~attackedBy[Us][QUEEN]
  412                  & ~rookChecks;
  413 
  414     if (queenChecks)
  415         kingDanger += QueenSafeCheck;
  416 
  417     // Enemy bishops checks: we count them only if they are from squares from
  418     // which we can't give a queen check, because queen checks are more valuable.
  419     bishopChecks =  b2
  420                   & attackedBy[Them][BISHOP]
  421                   & safe
  422                   & ~queenChecks;
  423 
  424     if (bishopChecks)
  425         kingDanger += BishopSafeCheck;
  426     else
  427         unsafeChecks |= b2 & attackedBy[Them][BISHOP];
  428 
  429     // Enemy knights checks
  430     knightChecks = pos.attacks_from<KNIGHT>(ksq) & attackedBy[Them][KNIGHT];
  431 
  432     if (knightChecks & safe)
  433         kingDanger += KnightSafeCheck;
  434     else
  435         unsafeChecks |= knightChecks;
  436 
  437     // Find the squares that opponent attacks in our king flank, the squares
  438     // which they attack twice in that flank, and the squares that we defend.
  439     b1 = attackedBy[Them][ALL_PIECES] & KingFlank[file_of(ksq)] & Camp;
  440     b2 = b1 & attackedBy2[Them];
  441     b3 = attackedBy[Us][ALL_PIECES] & KingFlank[file_of(ksq)] & Camp;
  442 
  443     int kingFlankAttack = popcount(b1) + popcount(b2);
  444     int kingFlankDefense = popcount(b3);
  445 
  446     kingDanger +=        kingAttackersCount[Them] * kingAttackersWeight[Them]
  447                  + 185 * popcount(kingRing[Us] & weak)
  448                  + 148 * popcount(unsafeChecks)
  449                  +  98 * popcount(pos.blockers_for_king(Us))
  450                  +  69 * kingAttacksCount[Them]
  451                  +   3 * kingFlankAttack * kingFlankAttack / 8
  452                  +       mg_value(mobility[Them] - mobility[Us])
  453                  - 873 * !pos.count<QUEEN>(Them)
  454                  - 100 * bool(attackedBy[Us][KNIGHT] & attackedBy[Us][KING])
  455                  -   6 * mg_value(score) / 8
  456                  -   4 * kingFlankDefense
  457                  +  37;
  458 
  459     // Transform the kingDanger units into a Score, and subtract it from the evaluation
  460     if (kingDanger > 100)
  461         score -= make_score(kingDanger * kingDanger / 4096, kingDanger / 16);
  462 
  463     // Penalty when our king is on a pawnless flank
  464     if (!(pos.pieces(PAWN) & KingFlank[file_of(ksq)]))
  465         score -= PawnlessFlank;
  466 
  467     // Penalty if king flank is under attack, potentially moving toward the king
  468     score -= FlankAttacks * kingFlankAttack;
  469 
  470     if (T)
  471         Trace::add(KING, Us, score);
  472 
  473     return score;
  474   }
  475 
  476 
  477   // Evaluation::threats() assigns bonuses according to the types of the
  478   // attacking and the attacked pieces.
  479   template<Tracing T> template<Color Us>
  480   Score Evaluation<T>::threats() const {
  481 
  482     constexpr Color     Them     = (Us == WHITE ? BLACK   : WHITE);
  483     constexpr Direction Up       = pawn_push(Us);
  484     constexpr Bitboard  TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
  485 
  486     Bitboard b, weak, defended, nonPawnEnemies, stronglyProtected, safe;
  487     Score score = SCORE_ZERO;
  488 
  489     // Non-pawn enemies
  490     nonPawnEnemies = pos.pieces(Them) & ~pos.pieces(PAWN);
  491 
  492     // Squares strongly protected by the enemy, either because they defend the
  493     // square with a pawn, or because they defend the square twice and we don't.
  494     stronglyProtected =  attackedBy[Them][PAWN]
  495                        | (attackedBy2[Them] & ~attackedBy2[Us]);
  496 
  497     // Non-pawn enemies, strongly protected
  498     defended = nonPawnEnemies & stronglyProtected;
  499 
  500     // Enemies not strongly protected and under our attack
  501     weak = pos.pieces(Them) & ~stronglyProtected & attackedBy[Us][ALL_PIECES];
  502 
  503     // Bonus according to the kind of attacking pieces
  504     if (defended | weak)
  505     {
  506         b = (defended | weak) & (attackedBy[Us][KNIGHT] | attackedBy[Us][BISHOP]);
  507         while (b)
  508             score += ThreatByMinor[type_of(pos.piece_on(pop_lsb(&b)))];
  509 
  510         b = weak & attackedBy[Us][ROOK];
  511         while (b)
  512             score += ThreatByRook[type_of(pos.piece_on(pop_lsb(&b)))];
  513 
  514         if (weak & attackedBy[Us][KING])
  515             score += ThreatByKing;
  516 
  517         b =  ~attackedBy[Them][ALL_PIECES]
  518            | (nonPawnEnemies & attackedBy2[Us]);
  519         score += Hanging * popcount(weak & b);
  520     }
  521 
  522     // Bonus for restricting their piece moves
  523     b =   attackedBy[Them][ALL_PIECES]
  524        & ~stronglyProtected
  525        &  attackedBy[Us][ALL_PIECES];
  526 
  527     score += RestrictedPiece * popcount(b);
  528 
  529     // Protected or unattacked squares
  530     safe = ~attackedBy[Them][ALL_PIECES] | attackedBy[Us][ALL_PIECES];
  531 
  532     // Bonus for attacking enemy pieces with our relatively safe pawns
  533     b = pos.pieces(Us, PAWN) & safe;
  534     b = pawn_attacks_bb<Us>(b) & nonPawnEnemies;
  535     score += ThreatBySafePawn * popcount(b);
  536 
  537     // Find squares where our pawns can push on the next move
  538     b  = shift<Up>(pos.pieces(Us, PAWN)) & ~pos.pieces();
  539     b |= shift<Up>(b & TRank3BB) & ~pos.pieces();
  540 
  541     // Keep only the squares which are relatively safe
  542     b &= ~attackedBy[Them][PAWN] & safe;
  543 
  544     // Bonus for safe pawn threats on the next move
  545     b = pawn_attacks_bb<Us>(b) & nonPawnEnemies;
  546     score += ThreatByPawnPush * popcount(b);
  547 
  548     // Bonus for threats on the next moves against enemy queen
  549     if (pos.count<QUEEN>(Them) == 1)
  550     {
  551         Square s = pos.square<QUEEN>(Them);
  552         safe = mobilityArea[Us] & ~stronglyProtected;
  553 
  554         b = attackedBy[Us][KNIGHT] & pos.attacks_from<KNIGHT>(s);
  555 
  556         score += KnightOnQueen * popcount(b & safe);
  557 
  558         b =  (attackedBy[Us][BISHOP] & pos.attacks_from<BISHOP>(s))
  559            | (attackedBy[Us][ROOK  ] & pos.attacks_from<ROOK  >(s));
  560 
  561         score += SliderOnQueen * popcount(b & safe & attackedBy2[Us]);
  562     }
  563 
  564     if (T)
  565         Trace::add(THREAT, Us, score);
  566 
  567     return score;
  568   }
  569 
  570   // Evaluation::passed() evaluates the passed pawns and candidate passed
  571   // pawns of the given color.
  572 
  573   template<Tracing T> template<Color Us>
  574   Score Evaluation<T>::passed() const {
  575 
  576     constexpr Color     Them = (Us == WHITE ? BLACK : WHITE);
  577     constexpr Direction Up   = pawn_push(Us);
  578 
  579     auto king_proximity = [&](Color c, Square s) {
  580       return std::min(distance(pos.square<KING>(c), s), 5);
  581     };
  582 
  583     Bitboard b, bb, squaresToQueen, unsafeSquares;
  584     Score score = SCORE_ZERO;
  585 
  586     b = pe->passed_pawns(Us);
  587 
  588     while (b)
  589     {
  590         Square s = pop_lsb(&b);
  591 
  592         assert(!(pos.pieces(Them, PAWN) & forward_file_bb(Us, s + Up)));
  593 
  594         int r = relative_rank(Us, s);
  595 
  596         Score bonus = PassedRank[r];
  597 
  598         if (r > RANK_3)
  599         {
  600             int w = 5 * r - 13;
  601             Square blockSq = s + Up;
  602 
  603             // Adjust bonus based on the king's proximity
  604             bonus += make_score(0, (  (king_proximity(Them, blockSq) * 19) / 4
  605                                      - king_proximity(Us,   blockSq) *  2) * w);
  606 
  607             // If blockSq is not the queening square then consider also a second push
  608             if (r != RANK_7)
  609                 bonus -= make_score(0, king_proximity(Us, blockSq + Up) * w);
  610 
  611             // If the pawn is free to advance, then increase the bonus
  612             if (pos.empty(blockSq))
  613             {
  614                 squaresToQueen = forward_file_bb(Us, s);
  615                 unsafeSquares = passed_pawn_span(Us, s);
  616 
  617                 bb = forward_file_bb(Them, s) & pos.pieces(ROOK, QUEEN);
  618 
  619                 if (!(pos.pieces(Them) & bb))
  620                     unsafeSquares &= attackedBy[Them][ALL_PIECES];
  621 
  622                 // If there are no enemy attacks on passed pawn span, assign a big bonus.
  623                 // Otherwise assign a smaller bonus if the path to queen is not attacked
  624                 // and even smaller bonus if it is attacked but block square is not.
  625                 int k = !unsafeSquares                    ? 35 :
  626                         !(unsafeSquares & squaresToQueen) ? 20 :
  627                         !(unsafeSquares & blockSq)        ?  9 :
  628                                                              0 ;
  629 
  630                 // Assign a larger bonus if the block square is defended
  631                 if ((pos.pieces(Us) & bb) || (attackedBy[Us][ALL_PIECES] & blockSq))
  632                     k += 5;
  633 
  634                 bonus += make_score(k * w, k * w);
  635             }
  636         } // r > RANK_3
  637 
  638         // Scale down bonus for candidate passers which need more than one
  639         // pawn push to become passed, or have a pawn in front of them.
  640         if (   !pos.pawn_passed(Us, s + Up)
  641             || (pos.pieces(PAWN) & (s + Up)))
  642             bonus = bonus / 2;
  643 
  644         score += bonus - PassedFile * map_to_queenside(file_of(s));
  645     }
  646 
  647     if (T)
  648         Trace::add(PASSED, Us, score);
  649 
  650     return score;
  651   }
  652 
  653 
  654   // Evaluation::space() computes the space evaluation for a given side. The
  655   // space evaluation is a simple bonus based on the number of safe squares
  656   // available for minor pieces on the central four files on ranks 2--4. Safe
  657   // squares one, two or three squares behind a friendly pawn are counted
  658   // twice. Finally, the space bonus is multiplied by a weight. The aim is to
  659   // improve play on game opening.
  660 
  661   template<Tracing T> template<Color Us>
  662   Score Evaluation<T>::space() const {
  663 
  664     if (pos.non_pawn_material() < SpaceThreshold)
  665         return SCORE_ZERO;
  666 
  667     constexpr Color Them     = (Us == WHITE ? BLACK : WHITE);
  668     constexpr Direction Down = -pawn_push(Us);
  669     constexpr Bitboard SpaceMask =
  670       Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
  671                   : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
  672 
  673     // Find the available squares for our pieces inside the area defined by SpaceMask
  674     Bitboard safe =   SpaceMask
  675                    & ~pos.pieces(Us, PAWN)
  676                    & ~attackedBy[Them][PAWN];
  677 
  678     // Find all squares which are at most three squares behind some friendly pawn
  679     Bitboard behind = pos.pieces(Us, PAWN);
  680     behind |= shift<Down>(behind);
  681     behind |= shift<Down+Down>(behind);
  682 
  683     int bonus = popcount(safe) + popcount(behind & safe & ~attackedBy[Them][ALL_PIECES]);
  684     int weight = pos.count<ALL_PIECES>(Us) - 1;
  685     Score score = make_score(bonus * weight * weight / 16, 0);
  686 
  687     if (T)
  688         Trace::add(SPACE, Us, score);
  689 
  690     return score;
  691   }
  692 
  693 
  694   // Evaluation::initiative() computes the initiative correction value
  695   // for the position. It is a second order bonus/malus based on the
  696   // known attacking/defending status of the players.
  697 
  698   template<Tracing T>
  699   Score Evaluation<T>::initiative(Score score) const {
  700 
  701     Value mg = mg_value(score);
  702     Value eg = eg_value(score);
  703 
  704     int outflanking =  distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
  705                      - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
  706 
  707     bool infiltration =   rank_of(pos.square<KING>(WHITE)) > RANK_4
  708                        || rank_of(pos.square<KING>(BLACK)) < RANK_5;
  709 
  710     bool pawnsOnBothFlanks =   (pos.pieces(PAWN) & QueenSide)
  711                             && (pos.pieces(PAWN) & KingSide);
  712 
  713     bool almostUnwinnable =   !pe->passed_count()
  714                            &&  outflanking < 0
  715                            && !pawnsOnBothFlanks;
  716 
  717     // Compute the initiative bonus for the attacking side
  718     int complexity =   9 * pe->passed_count()
  719                     + 11 * pos.count<PAWN>()
  720                     +  9 * outflanking
  721                     + 12 * infiltration
  722                     + 21 * pawnsOnBothFlanks
  723                     + 51 * !pos.non_pawn_material()
  724                     - 43 * almostUnwinnable
  725                     - 100 ;
  726 
  727     // Now apply the bonus: note that we find the attacking side by extracting the
  728     // sign of the midgame or endgame values, and that we carefully cap the bonus
  729     // so that the midgame and endgame scores do not change sign after the bonus.
  730     int u = ((mg > 0) - (mg < 0)) * std::max(std::min(complexity + 50, 0), -abs(mg));
  731     int v = ((eg > 0) - (eg < 0)) * std::max(complexity, -abs(eg));
  732 
  733     if (T)
  734         Trace::add(INITIATIVE, make_score(u, v));
  735 
  736     return make_score(u, v);
  737   }
  738 
  739 
  740   // Evaluation::scale_factor() computes the scale factor for the winning side
  741 
  742   template<Tracing T>
  743   ScaleFactor Evaluation<T>::scale_factor(Value eg) const {
  744 
  745     Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
  746     int sf = me->scale_factor(pos, strongSide);
  747 
  748     // If scale is not already specific, scale down the endgame via general heuristics
  749     if (sf == SCALE_FACTOR_NORMAL)
  750     {
  751         if (   pos.opposite_bishops()
  752             && pos.non_pawn_material() == 2 * BishopValueMg)
  753             sf = 22 ;
  754         else
  755             sf = std::min(sf, 36 + (pos.opposite_bishops() ? 2 : 7) * pos.count<PAWN>(strongSide));
  756 
  757         sf = std::max(0, sf - (pos.rule50_count() - 12) / 4);
  758     }
  759 
  760     return ScaleFactor(sf);
  761   }
  762 
  763 
  764   // Evaluation::value() is the main function of the class. It computes the various
  765   // parts of the evaluation and returns the value of the position from the point
  766   // of view of the side to move.
  767 
  768   template<Tracing T>
  769   Value Evaluation<T>::value() {
  770 
  771     assert(!pos.checkers());
  772 
  773     // Probe the material hash table
  774     me = Material::probe(pos);
  775 
  776     // If we have a specialized evaluation function for the current material
  777     // configuration, call it and return.
  778     if (me->specialized_eval_exists())
  779         return me->evaluate(pos);
  780 
  781     // Initialize score by reading the incrementally updated scores included in
  782     // the position object (material + piece square tables) and the material
  783     // imbalance. Score is computed internally from the white point of view.
  784     Score score = pos.psq_score() + me->imbalance() + pos.this_thread()->contempt;
  785 
  786     // Probe the pawn hash table
  787     pe = Pawns::probe(pos);
  788     score += pe->pawn_score(WHITE) - pe->pawn_score(BLACK);
  789 
  790     // Early exit if score is high
  791     Value v = (mg_value(score) + eg_value(score)) / 2;
  792     if (abs(v) > LazyThreshold + pos.non_pawn_material() / 64)
  793        return pos.side_to_move() == WHITE ? v : -v;
  794 
  795     // Main evaluation begins here
  796 
  797     initialize<WHITE>();
  798     initialize<BLACK>();
  799 
  800     // Pieces should be evaluated first (populate attack tables)
  801     score +=  pieces<WHITE, KNIGHT>() - pieces<BLACK, KNIGHT>()
  802             + pieces<WHITE, BISHOP>() - pieces<BLACK, BISHOP>()
  803             + pieces<WHITE, ROOK  >() - pieces<BLACK, ROOK  >()
  804             + pieces<WHITE, QUEEN >() - pieces<BLACK, QUEEN >();
  805 
  806     score += mobility[WHITE] - mobility[BLACK];
  807 
  808     score +=  king<   WHITE>() - king<   BLACK>()
  809             + threats<WHITE>() - threats<BLACK>()
  810             + passed< WHITE>() - passed< BLACK>()
  811             + space<  WHITE>() - space<  BLACK>();
  812 
  813     score += initiative(score);
  814 
  815     // Interpolate between a middlegame and a (scaled by 'sf') endgame score
  816     ScaleFactor sf = scale_factor(eg_value(score));
  817     v =  mg_value(score) * int(me->game_phase())
  818        + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
  819 
  820     v /= PHASE_MIDGAME;
  821 
  822     // In case of tracing add all remaining individual evaluation terms
  823     if (T)
  824     {
  825         Trace::add(MATERIAL, pos.psq_score());
  826         Trace::add(IMBALANCE, me->imbalance());
  827         Trace::add(PAWN, pe->pawn_score(WHITE), pe->pawn_score(BLACK));
  828         Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
  829         Trace::add(TOTAL, score);
  830     }
  831 
  832     return  (pos.side_to_move() == WHITE ? v : -v) // Side to move point of view
  833            + Eval::Tempo;
  834   }
  835 
  836 } // namespace
  837 
  838 
  839 /// evaluate() is the evaluator for the outer world. It returns a static
  840 /// evaluation of the position from the point of view of the side to move.
  841 
  842 Value Eval::evaluate(const Position& pos) {
  843   return Evaluation<NO_TRACE>(pos).value();
  844 }
  845 
  846 
  847 /// trace() is like evaluate(), but instead of returning a value, it returns
  848 /// a string (suitable for outputting to stdout) that contains the detailed
  849 /// descriptions and values of each evaluation term. Useful for debugging.
  850 
  851 std::string Eval::trace(const Position& pos) {
  852 
  853   if (pos.checkers())
  854       return "Total evaluation: none (in check)";
  855 
  856   std::memset(scores, 0, sizeof(scores));
  857 
  858   pos.this_thread()->contempt = SCORE_ZERO; // Reset any dynamic contempt
  859 
  860   Value v = Evaluation<TRACE>(pos).value();
  861 
  862   v = pos.side_to_move() == WHITE ? v : -v; // Trace scores are from white's point of view
  863 
  864   std::stringstream ss;
  865   ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
  866      << "     Term    |    White    |    Black    |    Total   \n"
  867      << "             |   MG    EG  |   MG    EG  |   MG    EG \n"
  868      << " ------------+-------------+-------------+------------\n"
  869      << "    Material | " << Term(MATERIAL)
  870      << "   Imbalance | " << Term(IMBALANCE)
  871      << "       Pawns | " << Term(PAWN)
  872      << "     Knights | " << Term(KNIGHT)
  873      << "     Bishops | " << Term(BISHOP)
  874      << "       Rooks | " << Term(ROOK)
  875      << "      Queens | " << Term(QUEEN)
  876      << "    Mobility | " << Term(MOBILITY)
  877      << " King safety | " << Term(KING)
  878      << "     Threats | " << Term(THREAT)
  879      << "      Passed | " << Term(PASSED)
  880      << "       Space | " << Term(SPACE)
  881      << "  Initiative | " << Term(INITIATIVE)
  882      << " ------------+-------------+-------------+------------\n"
  883      << "       Total | " << Term(TOTAL);
  884 
  885   ss << "\nTotal evaluation: " << to_cp(v) << " (white side)\n";
  886 
  887   return ss.str();
  888 }