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