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