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