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