Remove queen threat evaluation
[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
6   Stockfish is free software: you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation, either version 3 of the License, or
9   (at your option) any later version.
10
11   Stockfish is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <algorithm>
21 #include <cassert>
22 #include <cstring>   // For std::memset
23 #include <iomanip>
24 #include <sstream>
25
26 #include "bitcount.h"
27 #include "evaluate.h"
28 #include "material.h"
29 #include "pawns.h"
30
31 namespace {
32
33   namespace Trace {
34
35     enum Term { // First 8 entries are for PieceType
36       MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, TOTAL, TERM_NB
37     };
38
39     double scores[TERM_NB][COLOR_NB][PHASE_NB];
40
41     double to_cp(Value v) { return double(v) / PawnValueEg; }
42
43     void add(int idx, Color c, Score s) {
44       scores[idx][c][MG] = to_cp(mg_value(s));
45       scores[idx][c][EG] = to_cp(eg_value(s));
46     }
47
48     void add(int idx, Score w, Score b = SCORE_ZERO) {
49       add(idx, WHITE, w); add(idx, BLACK, b);
50     }
51
52     std::ostream& operator<<(std::ostream& os, Term t) {
53
54       if (t == MATERIAL || t == IMBALANCE || t == Term(PAWN) || t == TOTAL)
55           os << "  ---   --- |   ---   --- | ";
56       else
57           os << std::setw(5) << scores[t][WHITE][MG] << " "
58              << std::setw(5) << scores[t][WHITE][EG] << " | "
59              << std::setw(5) << scores[t][BLACK][MG] << " "
60              << std::setw(5) << scores[t][BLACK][EG] << " | ";
61
62       os << std::setw(5) << scores[t][WHITE][MG] - scores[t][BLACK][MG] << " "
63          << std::setw(5) << scores[t][WHITE][EG] - scores[t][BLACK][EG] << " \n";
64
65       return os;
66     }
67   }
68
69   using namespace Trace;
70
71   // Struct EvalInfo contains various information computed and collected
72   // by the evaluation functions.
73   struct EvalInfo {
74
75     // attackedBy[color][piece type] is a bitboard representing all squares
76     // attacked by a given color and piece type (can be also ALL_PIECES).
77     Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
78
79     // kingRing[color] is the zone around the king which is considered
80     // by the king safety evaluation. This consists of the squares directly
81     // adjacent to the king, and the three (or two, for a king on an edge file)
82     // squares two ranks in front of the king. For instance, if black's king
83     // is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,
84     // f7, g7, h7, f6, g6 and h6.
85     Bitboard kingRing[COLOR_NB];
86
87     // kingAttackersCount[color] is the number of pieces of the given color
88     // which attack a square in the kingRing of the enemy king.
89     int kingAttackersCount[COLOR_NB];
90
91     // kingAttackersWeight[color] is the sum of the "weight" of the pieces of the
92     // given color which attack a square in the kingRing of the enemy king. The
93     // weights of the individual piece types are given by the elements in the
94     // KingAttackWeights array.
95     int kingAttackersWeight[COLOR_NB];
96
97     // kingAdjacentZoneAttacksCount[color] is the number of attacks by the given
98     // color to squares directly adjacent to the enemy king. Pieces which attack
99     // more than one square are counted multiple times. For instance, if there is
100     // a white knight on g5 and black's king is on g8, this white knight adds 2
101     // to kingAdjacentZoneAttacksCount[WHITE].
102     int kingAdjacentZoneAttacksCount[COLOR_NB];
103
104     Bitboard pinnedPieces[COLOR_NB];
105     Pawns::Entry* pi;
106   };
107
108
109   // Evaluation weights, indexed by the corresponding evaluation term
110   enum { Mobility, PawnStructure, PassedPawns, Space, KingSafety };
111
112   const struct Weight { int mg, eg; } Weights[] = {
113     {289, 344}, {233, 201}, {221, 273}, {46, 0}, {322, 0}
114   };
115
116   Score operator*(Score s, const Weight& w) {
117     return make_score(mg_value(s) * w.mg / 256, eg_value(s) * w.eg / 256);
118   }
119
120
121   #define V(v) Value(v)
122   #define S(mg, eg) make_score(mg, eg)
123
124   // MobilityBonus[PieceType][attacked] contains bonuses for middle and end
125   // game, indexed by piece type and number of attacked squares not occupied by
126   // friendly pieces.
127   const Score MobilityBonus[][32] = {
128     {}, {},
129     { S(-68,-49), S(-46,-33), S(-3,-12), S( 5, -4), S( 9, 11), S(15, 16), // Knights
130       S( 23, 27), S( 33, 28), S(37, 29) },
131     { S(-49,-44), S(-23,-16), S(16,  1), S(29, 16), S(40, 25), S(51, 34), // Bishops
132       S( 55, 43), S( 61, 49), S(64, 51), S(68, 52), S(73, 55), S(75, 60),
133       S( 80, 65), S( 86, 66) },
134     { S(-50,-57), S(-28,-22), S(-11, 7), S(-1, 29), S( 0, 39), S( 1, 46), // Rooks
135       S( 10, 66), S( 16, 79), S(22, 86), S(23,103), S(30,109), S(33,111),
136       S( 37,115), S( 38,119), S(48,124) },
137     { S(-43,-30), S(-27,-15), S( 1, -5), S( 2, -3), S(14, 10), S(18, 24), // Queens
138       S( 20, 27), S( 33, 37), S(33, 38), S(34, 43), S(40, 46), S(43, 56),
139       S( 46, 61), S( 52, 63), S(52, 63), S(57, 65), S(60, 70), S(61, 74),
140       S( 67, 80), S( 76, 82), S(77, 88), S(82, 94), S(86, 95), S(90, 96),
141       S( 94, 99), S( 96,100), S(99,111), S(99,112) }
142   };
143
144   // Outpost[knight/bishop][supported by pawn] contains bonuses for knights and
145   // bishops outposts, bigger if outpost piece is supported by a pawn.
146   const Score Outpost[][2] = {
147     { S(42,11), S(63,17) }, // Knights
148     { S(18, 5), S(27, 8) }  // Bishops
149   };
150
151   // Threat[defended/weak][minor/rook attacking][attacked PieceType] contains
152   // bonuses according to which piece type attacks which one.
153   const Score Threat[][2][PIECE_TYPE_NB] = {
154   { { S(0, 0), S( 0, 0), S(19, 37), S(24, 37), S(44, 97), S(35,106) },   // Minor on Defended
155     { S(0, 0), S( 0, 0), S( 9, 14), S( 9, 14), S( 7, 14), S(24, 48) } }, // Rook on Defended
156   { { S(0, 0), S( 0,32), S(33, 41), S(31, 50), S(41,100), S(35,104) },   // Minor on Weak
157     { S(0, 0), S( 0,27), S(26, 57), S(26, 57), S(0 , 43), S(23, 51) } }  // Rook on Weak
158   };
159
160   // ThreatenedByPawn[PieceType] contains a penalty according to which piece
161   // type is attacked by an enemy pawn.
162   const Score ThreatenedByPawn[PIECE_TYPE_NB] = {
163     S(0, 0), S(0, 0), S(107, 138), S(84, 122), S(114, 203), S(121, 217)
164   };
165
166   // Passed[mg/eg][rank] contains midgame and endgame bonuses for passed pawns.
167   // We don't use a Score because we process the two components independently.
168   const Value Passed[][RANK_NB] = {
169     { V(0), V( 1), V(34), V(90), V(214), V(328) },
170     { V(7), V(14), V(37), V(63), V(134), V(189) }
171   };
172
173   // PassedFile[File] contains a bonus according to the file of a passed pawn.
174   const Score PassedFile[] = {
175     S( 14,  13), S( 2,  5), S(-3, -4), S(-19, -14),
176     S(-19, -14), S(-3, -4), S( 2,  5), S( 14,  13)
177   };
178
179   const Score ThreatenedByHangingPawn = S(40, 60);
180
181   // Assorted bonuses and penalties used by evaluation
182   const Score KingOnOne          = S( 2, 58);
183   const Score KingOnMany         = S( 6,125);
184   const Score RookOnPawn         = S( 7, 27);
185   const Score RookOnOpenFile     = S(43, 21);
186   const Score RookOnSemiOpenFile = S(19, 10);
187   const Score BishopPawns        = S( 8, 12);
188   const Score MinorBehindPawn    = S(16,  0);
189   const Score TrappedRook        = S(92,  0);
190   const Score Unstoppable        = S( 0, 20);
191   const Score Hanging            = S(31, 26);
192   const Score PawnAttackThreat   = S(20, 20);
193   const Score Checked            = S(20, 20);
194
195   // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
196   // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
197   // happen in Chess960 games.
198   const Score TrappedBishopA1H1 = S(50, 50);
199
200   #undef S
201   #undef V
202
203   // SpaceMask[Color] contains the area of the board which is considered
204   // by the space evaluation. In the middlegame, each side is given a bonus
205   // based on how many squares inside this area are safe and available for
206   // friendly minor pieces.
207   const Bitboard SpaceMask[COLOR_NB] = {
208     (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank2BB | Rank3BB | Rank4BB),
209     (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank7BB | Rank6BB | Rank5BB)
210   };
211
212   // King danger constants and variables. The king danger scores are looked-up
213   // in KingDanger[]. Various little "meta-bonuses" measuring the strength
214   // of the enemy attack are added up into an integer, which is used as an
215   // index to KingDanger[].
216   Score KingDanger[512];
217
218   // KingAttackWeights[PieceType] contains king attack weights by piece type
219   const int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 7, 5, 4, 1 };
220
221   // Penalties for enemy's safe checks
222   const int QueenContactCheck = 89;
223   const int RookContactCheck  = 71;
224   const int QueenCheck        = 50;
225   const int RookCheck         = 37;
226   const int BishopCheck       = 6;
227   const int KnightCheck       = 14;
228
229
230   // init_eval_info() initializes king bitboards for given color adding
231   // pawn attacks. To be done at the beginning of the evaluation.
232
233   template<Color Us>
234   void init_eval_info(const Position& pos, EvalInfo& ei) {
235
236     const Color  Them = (Us == WHITE ? BLACK   : WHITE);
237     const Square Down = (Us == WHITE ? DELTA_S : DELTA_N);
238
239     ei.pinnedPieces[Us] = pos.pinned_pieces(Us);
240     Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.square<KING>(Them));
241     ei.attackedBy[Them][ALL_PIECES] |= b;
242     ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
243
244     // Init king safety tables only if we are going to use them
245     if (pos.non_pawn_material(Us) >= QueenValueMg)
246     {
247         ei.kingRing[Them] = b | shift_bb<Down>(b);
248         b &= ei.attackedBy[Us][PAWN];
249         ei.kingAttackersCount[Us] = b ? popcount<Max15>(b) : 0;
250         ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = 0;
251     }
252     else
253         ei.kingRing[Them] = ei.kingAttackersCount[Us] = 0;
254   }
255
256
257   // evaluate_pieces() assigns bonuses and penalties to the pieces of a given color
258
259   template<PieceType Pt, Color Us, bool DoTrace>
260   Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility, const Bitboard* mobilityArea) {
261
262     Bitboard b;
263     Square s;
264     Score score = SCORE_ZERO;
265
266     const PieceType NextPt = (Us == WHITE ? Pt : PieceType(Pt + 1));
267     const Color Them = (Us == WHITE ? BLACK : WHITE);
268     const Square* pl = pos.squares<Pt>(Us);
269
270     ei.attackedBy[Us][Pt] = 0;
271
272     while ((s = *pl++) != SQ_NONE)
273     {
274         // Find attacked squares, including x-ray attacks for bishops and rooks
275         b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))
276           : Pt ==   ROOK ? attacks_bb<  ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
277                          : pos.attacks_from<Pt>(s);
278
279         if (ei.pinnedPieces[Us] & s)
280             b &= LineBB[pos.square<KING>(Us)][s];
281
282         ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][Pt] |= b;
283
284         if (b & ei.kingRing[Them])
285         {
286             ei.kingAttackersCount[Us]++;
287             ei.kingAttackersWeight[Us] += KingAttackWeights[Pt];
288             Bitboard bb = b & ei.attackedBy[Them][KING];
289             if (bb)
290                 ei.kingAdjacentZoneAttacksCount[Us] += popcount<Max15>(bb);
291         }
292
293         if (Pt == QUEEN)
294             b &= ~(  ei.attackedBy[Them][KNIGHT]
295                    | ei.attackedBy[Them][BISHOP]
296                    | ei.attackedBy[Them][ROOK]);
297
298         int mob = popcount<Pt == QUEEN ? Full : Max15>(b & mobilityArea[Us]);
299
300         mobility[Us] += MobilityBonus[Pt][mob];
301
302         if (Pt == BISHOP || Pt == KNIGHT)
303         {
304             // Bonus for outpost square
305             if (   relative_rank(Us, s) >= RANK_4
306                 && relative_rank(Us, s) <= RANK_6
307                 && !(pos.pieces(Them, PAWN) & pawn_attack_span(Us, s)))
308                 score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & s)];
309
310             // Bonus when behind a pawn
311             if (    relative_rank(Us, s) < RANK_5
312                 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
313                 score += MinorBehindPawn;
314
315             // Penalty for pawns on same color square of bishop
316             if (Pt == BISHOP)
317                 score -= BishopPawns * ei.pi->pawns_on_same_color_squares(Us, s);
318
319             // An important Chess960 pattern: A cornered bishop blocked by a friendly
320             // pawn diagonally in front of it is a very serious problem, especially
321             // when that pawn is also blocked.
322             if (   Pt == BISHOP
323                 && pos.is_chess960()
324                 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
325             {
326                 Square d = pawn_push(Us) + (file_of(s) == FILE_A ? DELTA_E : DELTA_W);
327                 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
328                     score -= !pos.empty(s + d + pawn_push(Us))                ? TrappedBishopA1H1 * 4
329                             : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
330                                                                               : TrappedBishopA1H1;
331             }
332         }
333
334         if (Pt == ROOK)
335         {
336             // Bonus for aligning with enemy pawns on the same rank/file
337             if (relative_rank(Us, s) >= RANK_5)
338             {
339                 Bitboard alignedPawns = pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s];
340                 if (alignedPawns)
341                     score += popcount<Max15>(alignedPawns) * RookOnPawn;
342             }
343
344             // Bonus when on an open or semi-open file
345             if (ei.pi->semiopen_file(Us, file_of(s)))
346                 score += ei.pi->semiopen_file(Them, file_of(s)) ? RookOnOpenFile : RookOnSemiOpenFile;
347
348             // Penalize when trapped by the king, even more if king cannot castle
349             if (mob <= 3 && !ei.pi->semiopen_file(Us, file_of(s)))
350             {
351                 Square ksq = pos.square<KING>(Us);
352
353                 if (   ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
354                     && (rank_of(ksq) == rank_of(s) || relative_rank(Us, ksq) == RANK_1)
355                     && !ei.pi->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq)))
356                     score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));
357             }
358         }
359     }
360
361     if (DoTrace)
362         Trace::add(Pt, Us, score);
363
364     // Recursively call evaluate_pieces() of next piece type until KING excluded
365     return score - evaluate_pieces<NextPt, Them, DoTrace>(pos, ei, mobility, mobilityArea);
366   }
367
368   template<>
369   Score evaluate_pieces<KING, WHITE, false>(const Position&, EvalInfo&, Score*, const Bitboard*) { return SCORE_ZERO; }
370   template<>
371   Score evaluate_pieces<KING, WHITE,  true>(const Position&, EvalInfo&, Score*, const Bitboard*) { return SCORE_ZERO; }
372
373
374   // evaluate_king() assigns bonuses and penalties to a king of a given color
375
376   template<Color Us, bool DoTrace>
377   Score evaluate_king(const Position& pos, const EvalInfo& ei) {
378
379     const Color Them = (Us == WHITE ? BLACK : WHITE);
380
381     Bitboard undefended, b, b1, b2, safe;
382     int attackUnits;
383     const Square ksq = pos.square<KING>(Us);
384
385     // King shelter and enemy pawns storm
386     Score score = ei.pi->king_safety<Us>(pos, ksq);
387
388     // Main king safety evaluation
389     if (ei.kingAttackersCount[Them])
390     {
391         // Find the attacked squares around the king which have no defenders
392         // apart from the king itself
393         undefended =  ei.attackedBy[Them][ALL_PIECES]
394                     & ei.attackedBy[Us][KING]
395                     & ~(  ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
396                         | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
397                         | ei.attackedBy[Us][QUEEN]);
398
399         // Initialize the 'attackUnits' variable, which is used later on as an
400         // index into the KingDanger[] array. The initial value is based on the
401         // number and types of the enemy's attacking pieces, the number of
402         // attacked and undefended squares around our king and the quality of
403         // the pawn shelter (current 'score' value).
404         attackUnits =  std::min(74, ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them])
405                      +  8 * ei.kingAdjacentZoneAttacksCount[Them]
406                      + 25 * popcount<Max15>(undefended)
407                      + 11 * !!ei.pinnedPieces[Us]
408                      - 60 * !pos.count<QUEEN>(Them)
409                      - mg_value(score) / 8;
410
411         // Analyse the enemy's safe queen contact checks. Firstly, find the
412         // undefended squares around the king reachable by the enemy queen...
413         b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces(Them);
414         if (b)
415         {
416             // ...and then remove squares not supported by another enemy piece
417             b &=  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
418                 | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK];
419
420             if (b)
421                 attackUnits += QueenContactCheck * popcount<Max15>(b);
422         }
423
424         // Analyse the enemy's safe rook contact checks. Firstly, find the
425         // undefended squares around the king reachable by the enemy rooks...
426         b = undefended & ei.attackedBy[Them][ROOK] & ~pos.pieces(Them);
427
428         // Consider only squares where the enemy's rook gives check
429         b &= PseudoAttacks[ROOK][ksq];
430
431         if (b)
432         {
433             // ...and then remove squares not supported by another enemy piece
434             b &= (  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
435                   | ei.attackedBy[Them][BISHOP]);
436
437             if (b)
438                 attackUnits += RookContactCheck * popcount<Max15>(b);
439         }
440
441         // Analyse the enemy's safe distance checks for sliders and knights
442         safe = ~(ei.attackedBy[Us][ALL_PIECES] | pos.pieces(Them));
443
444         b1 = pos.attacks_from<ROOK  >(ksq) & safe;
445         b2 = pos.attacks_from<BISHOP>(ksq) & safe;
446
447         // Enemy queen safe checks
448         b = (b1 | b2) & ei.attackedBy[Them][QUEEN];
449         if (b)
450         {
451             attackUnits += QueenCheck * popcount<Max15>(b);
452             score -= Checked;
453         }
454
455         // Enemy rooks safe checks
456         b = b1 & ei.attackedBy[Them][ROOK];
457         if (b)
458         {
459             attackUnits += RookCheck * popcount<Max15>(b);
460             score -= Checked;
461         }
462
463         // Enemy bishops safe checks
464         b = b2 & ei.attackedBy[Them][BISHOP];
465         if (b)
466         {
467             attackUnits += BishopCheck * popcount<Max15>(b);
468             score -= Checked;
469         }
470
471         // Enemy knights safe checks
472         b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT] & safe;
473         if (b)
474         {
475             attackUnits += KnightCheck * popcount<Max15>(b);
476             score -= Checked;
477         }
478
479         // Finally, extract the king danger score from the KingDanger[]
480         // array and subtract the score from evaluation.
481         score -= KingDanger[std::max(std::min(attackUnits, 399), 0)];
482     }
483
484     if (DoTrace)
485         Trace::add(KING, Us, score);
486
487     return score;
488   }
489
490
491   // evaluate_threats() assigns bonuses according to the type of attacking piece
492   // and the type of attacked one.
493
494   template<Color Us, bool DoTrace>
495   Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
496
497     const Color Them        = (Us == WHITE ? BLACK    : WHITE);
498     const Square Up         = (Us == WHITE ? DELTA_N  : DELTA_S);
499     const Square Left       = (Us == WHITE ? DELTA_NW : DELTA_SE);
500     const Square Right      = (Us == WHITE ? DELTA_NE : DELTA_SW);
501     const Bitboard TRank2BB = (Us == WHITE ? Rank2BB  : Rank7BB);
502     const Bitboard TRank7BB = (Us == WHITE ? Rank7BB  : Rank2BB);
503
504     enum { Defended, Weak };
505     enum { Minor, Rook };
506
507     Bitboard b, weak, defended, safeThreats;
508     Score score = SCORE_ZERO;
509
510     // Non-pawn enemies attacked by a pawn
511     weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Us][PAWN];
512
513     if (weak)
514     {
515         b = pos.pieces(Us, PAWN) & ( ~ei.attackedBy[Them][ALL_PIECES]
516                                     | ei.attackedBy[Us][ALL_PIECES]);
517
518         safeThreats = (shift_bb<Right>(b) | shift_bb<Left>(b)) & weak;
519
520         if (weak ^ safeThreats)
521             score += ThreatenedByHangingPawn;
522
523         while (safeThreats)
524             score += ThreatenedByPawn[type_of(pos.piece_on(pop_lsb(&safeThreats)))];
525     }
526
527     // Non-pawn enemies defended by a pawn
528     defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Them][PAWN];
529
530     // Add a bonus according to the kind of attacking pieces
531     if (defended)
532     {
533         b = defended & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
534         while (b)
535             score += Threat[Defended][Minor][type_of(pos.piece_on(pop_lsb(&b)))];
536
537         b = defended & ei.attackedBy[Us][ROOK];
538         while (b)
539             score += Threat[Defended][Rook][type_of(pos.piece_on(pop_lsb(&b)))];
540     }
541
542     // Enemies not defended by a pawn and under our attack
543     weak =   pos.pieces(Them)
544           & ~ei.attackedBy[Them][PAWN]
545           &  ei.attackedBy[Us][ALL_PIECES];
546
547     // Add a bonus according to the kind of attacking pieces
548     if (weak)
549     {
550         b = weak & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
551         while (b)
552             score += Threat[Weak][Minor][type_of(pos.piece_on(pop_lsb(&b)))];
553
554         b = weak & ei.attackedBy[Us][ROOK];
555         while (b)
556             score += Threat[Weak][Rook][type_of(pos.piece_on(pop_lsb(&b)))];
557
558         b = weak & ~ei.attackedBy[Them][ALL_PIECES];
559         if (b)
560             score += Hanging * popcount<Max15>(b);
561
562         b = weak & ei.attackedBy[Us][KING];
563         if (b)
564             score += more_than_one(b) ? KingOnMany : KingOnOne;
565     }
566
567     // Bonus if some pawns can safely push and attack an enemy piece
568     b = pos.pieces(Us, PAWN) & ~TRank7BB;
569     b = shift_bb<Up>(b | (shift_bb<Up>(b & TRank2BB) & ~pos.pieces()));
570
571     b &=  ~pos.pieces()
572         & ~ei.attackedBy[Them][PAWN]
573         & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
574
575     b =  (shift_bb<Left>(b) | shift_bb<Right>(b))
576        &  pos.pieces(Them)
577        & ~ei.attackedBy[Us][PAWN];
578
579     if (b)
580         score += popcount<Max15>(b) * PawnAttackThreat;
581
582     if (DoTrace)
583         Trace::add(THREAT, Us, score);
584
585     return score;
586   }
587
588
589   // evaluate_passed_pawns() evaluates the passed pawns of the given color
590
591   template<Color Us, bool DoTrace>
592   Score evaluate_passed_pawns(const Position& pos, const EvalInfo& ei) {
593
594     const Color Them = (Us == WHITE ? BLACK : WHITE);
595
596     Bitboard b, squaresToQueen, defendedSquares, unsafeSquares;
597     Score score = SCORE_ZERO;
598
599     b = ei.pi->passed_pawns(Us);
600
601     while (b)
602     {
603         Square s = pop_lsb(&b);
604
605         assert(pos.pawn_passed(Us, s));
606
607         int r = relative_rank(Us, s) - RANK_2;
608         int rr = r * (r - 1);
609
610         Value mbonus = Passed[MG][r], ebonus = Passed[EG][r];
611
612         if (rr)
613         {
614             Square blockSq = s + pawn_push(Us);
615
616             // Adjust bonus based on the king's proximity
617             ebonus +=  distance(pos.square<KING>(Them), blockSq) * 5 * rr
618                      - distance(pos.square<KING>(Us  ), blockSq) * 2 * rr;
619
620             // If blockSq is not the queening square then consider also a second push
621             if (relative_rank(Us, blockSq) != RANK_8)
622                 ebonus -= distance(pos.square<KING>(Us), blockSq + pawn_push(Us)) * rr;
623
624             // If the pawn is free to advance, then increase the bonus
625             if (pos.empty(blockSq))
626             {
627                 // If there is a rook or queen attacking/defending the pawn from behind,
628                 // consider all the squaresToQueen. Otherwise consider only the squares
629                 // in the pawn's path attacked or occupied by the enemy.
630                 defendedSquares = unsafeSquares = squaresToQueen = forward_bb(Us, s);
631
632                 Bitboard bb = forward_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
633
634                 if (!(pos.pieces(Us) & bb))
635                     defendedSquares &= ei.attackedBy[Us][ALL_PIECES];
636
637                 if (!(pos.pieces(Them) & bb))
638                     unsafeSquares &= ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
639
640                 // If there aren't any enemy attacks, assign a big bonus. Otherwise
641                 // assign a smaller bonus if the block square isn't attacked.
642                 int k = !unsafeSquares ? 15 : !(unsafeSquares & blockSq) ? 9 : 0;
643
644                 // If the path to queen is fully defended, assign a big bonus.
645                 // Otherwise assign a smaller bonus if the block square is defended.
646                 if (defendedSquares == squaresToQueen)
647                     k += 6;
648
649                 else if (defendedSquares & blockSq)
650                     k += 4;
651
652                 mbonus += k * rr, ebonus += k * rr;
653             }
654             else if (pos.pieces(Us) & blockSq)
655                 mbonus += rr * 3 + r * 2 + 3, ebonus += rr + r * 2;
656         } // rr != 0
657
658         if (pos.count<PAWN>(Us) < pos.count<PAWN>(Them))
659             ebonus += ebonus / 4;
660
661         score += make_score(mbonus, ebonus) + PassedFile[file_of(s)];
662     }
663
664     if (DoTrace)
665         Trace::add(PASSED, Us, score * Weights[PassedPawns]);
666
667     // Add the scores to the middlegame and endgame eval
668     return score * Weights[PassedPawns];
669   }
670
671
672   // evaluate_space() computes the space evaluation for a given side. The
673   // space evaluation is a simple bonus based on the number of safe squares
674   // available for minor pieces on the central four files on ranks 2--4. Safe
675   // squares one, two or three squares behind a friendly pawn are counted
676   // twice. Finally, the space bonus is multiplied by a weight. The aim is to
677   // improve play on game opening.
678   template<Color Us>
679   Score evaluate_space(const Position& pos, const EvalInfo& ei) {
680
681     const Color Them = (Us == WHITE ? BLACK : WHITE);
682
683     // Find the safe squares for our pieces inside the area defined by
684     // SpaceMask[]. A square is unsafe if it is attacked by an enemy
685     // pawn, or if it is undefended and attacked by an enemy piece.
686     Bitboard safe =   SpaceMask[Us]
687                    & ~pos.pieces(Us, PAWN)
688                    & ~ei.attackedBy[Them][PAWN]
689                    & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
690
691     // Find all squares which are at most three squares behind some friendly pawn
692     Bitboard behind = pos.pieces(Us, PAWN);
693     behind |= (Us == WHITE ? behind >>  8 : behind <<  8);
694     behind |= (Us == WHITE ? behind >> 16 : behind << 16);
695
696     // Since SpaceMask[Us] is fully on our half of the board...
697     assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
698
699     // ...count safe + (behind & safe) with a single popcount
700     int bonus = popcount<Full>((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
701     int weight =  pos.count<KNIGHT>(Us) + pos.count<BISHOP>(Us)
702                 + pos.count<KNIGHT>(Them) + pos.count<BISHOP>(Them);
703
704     return make_score(bonus * weight * weight, 0);
705   }
706
707 } // namespace
708
709
710 /// evaluate() is the main evaluation function. It returns a static evaluation
711 /// of the position always from the point of view of the side to move.
712
713 template<bool DoTrace>
714 Value Eval::evaluate(const Position& pos) {
715
716   assert(!pos.checkers());
717
718   EvalInfo ei;
719   Score score, mobility[2] = { SCORE_ZERO, SCORE_ZERO };
720
721   // Initialize score by reading the incrementally updated scores included
722   // in the position object (material + piece square tables).
723   // Score is computed from the point of view of white.
724   score = pos.psq_score();
725
726   // Probe the material hash table
727   Material::Entry* me = Material::probe(pos);
728   score += me->imbalance();
729
730   // If we have a specialized evaluation function for the current material
731   // configuration, call it and return.
732   if (me->specialized_eval_exists())
733       return me->evaluate(pos);
734
735   // Probe the pawn hash table
736   ei.pi = Pawns::probe(pos);
737   score += ei.pi->pawns_score() * Weights[PawnStructure];
738
739   // Initialize attack and king safety bitboards
740   ei.attackedBy[WHITE][ALL_PIECES] = ei.attackedBy[BLACK][ALL_PIECES] = 0;
741   init_eval_info<WHITE>(pos, ei);
742   init_eval_info<BLACK>(pos, ei);
743
744   // Pawns blocked or on ranks 2 and 3. Will be excluded from the mobility area
745   Bitboard blockedPawns[] = {
746     pos.pieces(WHITE, PAWN) & (shift_bb<DELTA_S>(pos.pieces()) | Rank2BB | Rank3BB),
747     pos.pieces(BLACK, PAWN) & (shift_bb<DELTA_N>(pos.pieces()) | Rank7BB | Rank6BB)
748   };
749
750   // Do not include in mobility squares protected by enemy pawns, or occupied
751   // by our blocked pawns or king.
752   Bitboard mobilityArea[] = {
753     ~(ei.attackedBy[BLACK][PAWN] | blockedPawns[WHITE] | pos.square<KING>(WHITE)),
754     ~(ei.attackedBy[WHITE][PAWN] | blockedPawns[BLACK] | pos.square<KING>(BLACK))
755   };
756
757   // Evaluate pieces and mobility
758   score += evaluate_pieces<KNIGHT, WHITE, DoTrace>(pos, ei, mobility, mobilityArea);
759   score += (mobility[WHITE] - mobility[BLACK]) * Weights[Mobility];
760
761   // Evaluate kings after all other pieces because we need complete attack
762   // information when computing the king safety evaluation.
763   score +=  evaluate_king<WHITE, DoTrace>(pos, ei)
764           - evaluate_king<BLACK, DoTrace>(pos, ei);
765
766   // Evaluate tactical threats, we need full attack information including king
767   score +=  evaluate_threats<WHITE, DoTrace>(pos, ei)
768           - evaluate_threats<BLACK, DoTrace>(pos, ei);
769
770   // Evaluate passed pawns, we need full attack information including king
771   score +=  evaluate_passed_pawns<WHITE, DoTrace>(pos, ei)
772           - evaluate_passed_pawns<BLACK, DoTrace>(pos, ei);
773
774   // If both sides have only pawns, score for potential unstoppable pawns
775   if (!pos.non_pawn_material(WHITE) && !pos.non_pawn_material(BLACK))
776   {
777       Bitboard b;
778       if ((b = ei.pi->passed_pawns(WHITE)) != 0)
779           score += int(relative_rank(WHITE, frontmost_sq(WHITE, b))) * Unstoppable;
780
781       if ((b = ei.pi->passed_pawns(BLACK)) != 0)
782           score -= int(relative_rank(BLACK, frontmost_sq(BLACK, b))) * Unstoppable;
783   }
784
785   // Evaluate space for both sides, only during opening
786   if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 11756)
787       score += (evaluate_space<WHITE>(pos, ei) - evaluate_space<BLACK>(pos, ei)) * Weights[Space];
788
789   // Scale winning side if position is more drawish than it appears
790   Color strongSide = eg_value(score) > VALUE_DRAW ? WHITE : BLACK;
791   ScaleFactor sf = me->scale_factor(pos, strongSide);
792
793   // If we don't already have an unusual scale factor, check for certain
794   // types of endgames, and use a lower scale for those.
795   if (    me->game_phase() < PHASE_MIDGAME
796       && (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN))
797   {
798       if (pos.opposite_bishops())
799       {
800           // Endgame with opposite-colored bishops and no other pieces (ignoring pawns)
801           // is almost a draw, in case of KBP vs KB is even more a draw.
802           if (   pos.non_pawn_material(WHITE) == BishopValueMg
803               && pos.non_pawn_material(BLACK) == BishopValueMg)
804               sf = more_than_one(pos.pieces(PAWN)) ? ScaleFactor(32) : ScaleFactor(8);
805
806           // Endgame with opposite-colored bishops, but also other pieces. Still
807           // a bit drawish, but not as drawish as with only the two bishops.
808           else
809               sf = ScaleFactor(50 * sf / SCALE_FACTOR_NORMAL);
810       }
811       // Endings where weaker side can place his king in front of the opponent's
812       // pawns are drawish.
813       else if (    abs(eg_value(score)) <= BishopValueEg
814                &&  ei.pi->pawn_span(strongSide) <= 1
815                && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
816           sf = ei.pi->pawn_span(strongSide) ? ScaleFactor(56) : ScaleFactor(38);
817   }
818
819   // Scale endgame by number of pawns
820   int p = pos.count<PAWN>(WHITE) + pos.count<PAWN>(BLACK);
821   int v_eg = 1 + abs(int(eg_value(score)));
822   sf = ScaleFactor(std::max(sf / 2, sf - 7 * SCALE_FACTOR_NORMAL * (14 - p) / v_eg));
823
824   // Interpolate between a middlegame and a (scaled by 'sf') endgame score
825   Value v =  mg_value(score) * int(me->game_phase())
826            + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
827
828   v /= int(PHASE_MIDGAME);
829
830   // In case of tracing add all single evaluation terms
831   if (DoTrace)
832   {
833       Trace::add(MATERIAL, pos.psq_score());
834       Trace::add(IMBALANCE, me->imbalance());
835       Trace::add(PAWN, ei.pi->pawns_score());
836       Trace::add(MOBILITY, mobility[WHITE] * Weights[Mobility]
837                          , mobility[BLACK] * Weights[Mobility]);
838       Trace::add(SPACE, evaluate_space<WHITE>(pos, ei) * Weights[Space]
839                       , evaluate_space<BLACK>(pos, ei) * Weights[Space]);
840       Trace::add(TOTAL, score);
841   }
842
843   return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view
844 }
845
846 // Explicit template instantiations
847 template Value Eval::evaluate<true >(const Position&);
848 template Value Eval::evaluate<false>(const Position&);
849
850
851 /// trace() is like evaluate(), but instead of returning a value, it returns
852 /// a string (suitable for outputting to stdout) that contains the detailed
853 /// descriptions and values of each evaluation term. Useful for debugging.
854
855 std::string Eval::trace(const Position& pos) {
856
857   std::memset(scores, 0, sizeof(scores));
858
859   Value v = evaluate<true>(pos);
860   v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
861
862   std::stringstream ss;
863   ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
864      << "      Eval term |    White    |    Black    |    Total    \n"
865      << "                |   MG    EG  |   MG    EG  |   MG    EG  \n"
866      << "----------------+-------------+-------------+-------------\n"
867      << "       Material | " << Term(MATERIAL)
868      << "      Imbalance | " << Term(IMBALANCE)
869      << "          Pawns | " << Term(PAWN)
870      << "        Knights | " << Term(KNIGHT)
871      << "         Bishop | " << Term(BISHOP)
872      << "          Rooks | " << Term(ROOK)
873      << "         Queens | " << Term(QUEEN)
874      << "       Mobility | " << Term(MOBILITY)
875      << "    King safety | " << Term(KING)
876      << "        Threats | " << Term(THREAT)
877      << "   Passed pawns | " << Term(PASSED)
878      << "          Space | " << Term(SPACE)
879      << "----------------+-------------+-------------+-------------\n"
880      << "          Total | " << Term(TOTAL);
881
882   ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";
883
884   return ss.str();
885 }
886
887
888 /// init() computes evaluation weights, usually at startup
889
890 void Eval::init() {
891
892   const int MaxSlope = 8700;
893   const int Peak = 1280000;
894   int t = 0;
895
896   for (int i = 0; i < 400; ++i)
897   {
898       t = std::min(Peak, std::min(i * i * 27, t + MaxSlope));
899       KingDanger[i] = make_score(t / 1000, 0) * Weights[KingSafety];
900   }
901 }