Use score and value consistently
[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
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 to squares
65     // directly adjacent to the king of the given color. Pieces which attack
66     // more than one square are counted multiple times. For instance, if black's
67     // king is on g8 and there's a white knight on g5, this knight adds
68     // 2 to kingAdjacentZoneAttacksCount[BLACK].
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}, {318, 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
166   // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
167   // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
168   // happen in Chess960 games.
169   const Score TrappedBishopA1H1 = S(50, 50);
170
171   #undef S
172   #undef V
173
174   // SpaceMask[Color] contains the area of the board which is considered
175   // by the space evaluation. In the middlegame, each side is given a bonus
176   // based on how many squares inside this area are safe and available for
177   // friendly minor pieces.
178   const Bitboard SpaceMask[] = {
179     (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank2BB | Rank3BB | Rank4BB),
180     (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank7BB | Rank6BB | Rank5BB)
181   };
182
183   // King danger constants and variables. The king danger scores are looked-up
184   // in KingDanger[]. Various little "meta-bonuses" measuring the strength
185   // of the enemy attack are added up into an integer, which is used as an
186   // index to KingDanger[].
187   //
188   // KingAttackWeights[PieceType] contains king attack weights by piece type
189   const int KingAttackWeights[] = { 0, 0, 2, 2, 3, 5 };
190
191   // Bonuses for enemy's safe checks
192   const int QueenContactCheck = 24;
193   const int RookContactCheck  = 16;
194   const int QueenCheck        = 12;
195   const int RookCheck         = 8;
196   const int BishopCheck       = 2;
197   const int KnightCheck       = 3;
198
199   // KingDanger[attackUnits] contains the actual king danger weighted
200   // scores, indexed by a calculated integer number.
201   Score KingDanger[128];
202
203   // apply_weight() weighs score 's' by weight 'w' trying to prevent overflow
204   Score apply_weight(Score s, const Weight& w) {
205     return make_score(mg_value(s) * w.mg / 256, eg_value(s) * 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.non_pawn_material(Us) >= QueenValueMg)
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             // Bonus for outpost square
317             if (!(pos.pieces(Them, PAWN) & pawn_attack_span(Us, s)))
318                 score += evaluate_outpost<Pt, Us>(pos, ei, s);
319
320             // Bonus when behind a pawn
321             if (    relative_rank(Us, s) < RANK_5
322                 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
323                 score += MinorBehindPawn;
324
325             // Penalty for pawns on same color square of bishop
326             if (Pt == BISHOP)
327                 score -= BishopPawns * ei.pi->pawns_on_same_color_squares(Us, s);
328
329             // An important Chess960 pattern: A cornered bishop blocked by a friendly
330             // pawn diagonally in front of it is a very serious problem, especially
331             // when that pawn is also blocked.
332             if (   Pt == BISHOP
333                 && pos.is_chess960()
334                 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
335             {
336                 Square d = pawn_push(Us) + (file_of(s) == FILE_A ? DELTA_E : DELTA_W);
337                 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
338                     score -= !pos.empty(s + d + pawn_push(Us))                ? TrappedBishopA1H1 * 4
339                             : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
340                                                                               : TrappedBishopA1H1;
341             }
342         }
343
344         if (Pt == ROOK)
345         {
346             // Bonus for aligning with enemy pawns on the same rank/file
347             if (relative_rank(Us, s) >= RANK_5)
348             {
349                 Bitboard alignedPawns = pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s];
350                 if (alignedPawns)
351                     score += popcount<Max15>(alignedPawns) * RookOnPawn;
352             }
353
354             // Bonus when on an open or semi-open file
355             if (ei.pi->semiopen_file(Us, file_of(s)))
356                 score += ei.pi->semiopen_file(Them, file_of(s)) ? RookOnOpenFile : RookOnSemiOpenFile;
357
358             // Penalize when trapped by the king, even more if king cannot castle
359             if (mob <= 3 && !ei.pi->semiopen_file(Us, file_of(s)))
360             {
361                 Square ksq = pos.king_square(Us);
362
363                 if (   ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
364                     && (rank_of(ksq) == rank_of(s) || relative_rank(Us, ksq) == RANK_1)
365                     && !ei.pi->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq)))
366                     score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));
367             }
368         }
369     }
370
371     if (Trace)
372         Tracing::write(Pt, Us, score);
373
374     // Recursively call evaluate_pieces() of next piece type until KING excluded
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 into 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                      - !pos.count<QUEEN>(Them) * 15;
419
420         // Analyse the enemy's safe queen contact checks. Firstly, find the
421         // undefended squares around the king reachable by the enemy 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 reachable by the enemy rooks...
435         b = undefended & ei.attackedBy[Them][ROOK] & ~pos.pieces(Them);
436
437         // Consider only squares where the enemy's rook gives check
438         b &= PseudoAttacks[ROOK][ksq];
439
440         if (b)
441         {
442             // ...and then remove squares not supported by another enemy piece
443             b &= (  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
444                   | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][QUEEN]);
445
446             if (b)
447                 attackUnits += RookContactCheck * popcount<Max15>(b);
448         }
449
450         // Analyse the enemy's safe distance checks for sliders and knights
451         safe = ~(ei.attackedBy[Us][ALL_PIECES] | pos.pieces(Them));
452
453         b1 = pos.attacks_from<ROOK  >(ksq) & safe;
454         b2 = pos.attacks_from<BISHOP>(ksq) & safe;
455
456         // Enemy queen safe checks
457         b = (b1 | b2) & ei.attackedBy[Them][QUEEN];
458         if (b)
459             attackUnits += QueenCheck * popcount<Max15>(b);
460
461         // Enemy rooks safe checks
462         b = b1 & ei.attackedBy[Them][ROOK];
463         if (b)
464             attackUnits += RookCheck * popcount<Max15>(b);
465
466         // Enemy bishops safe checks
467         b = b2 & ei.attackedBy[Them][BISHOP];
468         if (b)
469             attackUnits += BishopCheck * popcount<Max15>(b);
470
471         // Enemy knights safe checks
472         b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT] & safe;
473         if (b)
474             attackUnits += KnightCheck * popcount<Max15>(b);
475
476         // Finally, extract the king danger score from the KingDanger[]
477         // array and subtract the score from evaluation.
478         score -= KingDanger[std::max(std::min(attackUnits, 99), 0)];
479     }
480
481     if (Trace)
482         Tracing::write(KING, Us, score);
483
484     return score;
485   }
486
487
488   // evaluate_threats() assigns bonuses according to the type of attacking piece
489   // and the type of attacked one.
490
491   template<Color Us, bool Trace>
492   Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
493
494     const Color Them = (Us == WHITE ? BLACK : WHITE);
495
496     enum { Defended, Weak };
497     enum { Minor, Major };
498
499     Bitboard b, weak, defended;
500     Score score = SCORE_ZERO;
501
502     // Non-pawn enemies defended by a pawn
503     defended =  (pos.pieces(Them) ^ pos.pieces(Them, PAWN))
504               &  ei.attackedBy[Them][PAWN];
505
506     // Add a bonus according to the kind of attacking pieces
507     if (defended)
508     {
509         b = defended & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
510         while (b)
511             score += Threat[Defended][Minor][type_of(pos.piece_on(pop_lsb(&b)))];
512
513         b = defended & (ei.attackedBy[Us][ROOK]);
514         while (b)
515             score += Threat[Defended][Major][type_of(pos.piece_on(pop_lsb(&b)))];
516     }
517
518     // Enemies not defended by a pawn and under our attack
519     weak =   pos.pieces(Them)
520           & ~ei.attackedBy[Them][PAWN]
521           &  ei.attackedBy[Us][ALL_PIECES];
522
523     // Add a bonus according to the kind of attacking pieces
524     if (weak)
525     {
526         b = weak & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
527         while (b)
528             score += Threat[Weak][Minor][type_of(pos.piece_on(pop_lsb(&b)))];
529
530         b = weak & (ei.attackedBy[Us][ROOK] | ei.attackedBy[Us][QUEEN]);
531         while (b)
532             score += Threat[Weak][Major][type_of(pos.piece_on(pop_lsb(&b)))];
533
534         b = weak & ~ei.attackedBy[Them][ALL_PIECES];
535         if (b)
536             score += more_than_one(b) ? Hanging * popcount<Max15>(b) : Hanging;
537
538         b = weak & ei.attackedBy[Us][KING];
539         if (b)
540             score += more_than_one(b) ? KingOnMany : KingOnOne;
541     }
542
543     if (Trace)
544         Tracing::write(Tracing::THREAT, Us, score);
545
546     return score;
547   }
548
549
550   // evaluate_passed_pawns() evaluates the passed pawns of the given color
551
552   template<Color Us, bool Trace>
553   Score evaluate_passed_pawns(const Position& pos, const EvalInfo& ei) {
554
555     const Color Them = (Us == WHITE ? BLACK : WHITE);
556
557     Bitboard b, squaresToQueen, defendedSquares, unsafeSquares;
558     Score score = SCORE_ZERO;
559
560     b = ei.pi->passed_pawns(Us);
561
562     while (b)
563     {
564         Square s = pop_lsb(&b);
565
566         assert(pos.pawn_passed(Us, s));
567
568         int r = relative_rank(Us, s) - RANK_2;
569         int rr = r * (r - 1);
570
571         // Base bonus based on rank
572         Value mbonus = Value(17 * rr), ebonus = Value(7 * (rr + r + 1));
573
574         if (rr)
575         {
576             Square blockSq = s + pawn_push(Us);
577
578             // Adjust bonus based on the king's proximity
579             ebonus +=  distance(pos.king_square(Them), blockSq) * 5 * rr
580                      - distance(pos.king_square(Us  ), blockSq) * 2 * rr;
581
582             // If blockSq is not the queening square then consider also a second push
583             if (relative_rank(Us, blockSq) != RANK_8)
584                 ebonus -= distance(pos.king_square(Us), blockSq + pawn_push(Us)) * rr;
585
586             // If the pawn is free to advance, then increase the bonus
587             if (pos.empty(blockSq))
588             {
589                 // If there is a rook or queen attacking/defending the pawn from behind,
590                 // consider all the squaresToQueen. Otherwise consider only the squares
591                 // in the pawn's path attacked or occupied by the enemy.
592                 defendedSquares = unsafeSquares = squaresToQueen = forward_bb(Us, s);
593
594                 Bitboard bb = forward_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
595
596                 if (!(pos.pieces(Us) & bb))
597                     defendedSquares &= ei.attackedBy[Us][ALL_PIECES];
598
599                 if (!(pos.pieces(Them) & bb))
600                     unsafeSquares &= ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
601
602                 // If there aren't any enemy attacks, assign a big bonus. Otherwise
603                 // assign a smaller bonus if the block square isn't attacked.
604                 int k = !unsafeSquares ? 15 : !(unsafeSquares & blockSq) ? 9 : 0;
605
606                 // If the path to queen is fully defended, assign a big bonus.
607                 // Otherwise assign a smaller bonus if the block square is defended.
608                 if (defendedSquares == squaresToQueen)
609                     k += 6;
610
611                 else if (defendedSquares & blockSq)
612                     k += 4;
613
614                 mbonus += k * rr, ebonus += k * rr;
615             }
616             else if (pos.pieces(Us) & blockSq)
617                 mbonus += rr * 3 + r * 2 + 3, ebonus += rr + r * 2;
618         } // rr != 0
619
620         if (pos.count<PAWN>(Us) < pos.count<PAWN>(Them))
621             ebonus += ebonus / 4;
622
623         score += make_score(mbonus, ebonus);
624     }
625
626     if (Trace)
627         Tracing::write(Tracing::PASSED, Us, apply_weight(score, Weights[PassedPawns]));
628
629     // Add the scores to the middlegame and endgame eval
630     return apply_weight(score, Weights[PassedPawns]);
631   }
632
633
634   // evaluate_space() computes the space evaluation for a given side. The
635   // space evaluation is a simple bonus based on the number of safe squares
636   // available for minor pieces on the central four files on ranks 2--4. Safe
637   // squares one, two or three squares behind a friendly pawn are counted
638   // twice. Finally, the space bonus is scaled by a weight taken from the
639   // material hash table. The aim is to improve play on game opening.
640   template<Color Us>
641   Score evaluate_space(const Position& pos, const EvalInfo& ei, Score weight) {
642
643     const Color Them = (Us == WHITE ? BLACK : WHITE);
644
645     // Find the safe squares for our pieces inside the area defined by
646     // SpaceMask[]. A square is unsafe if it is attacked by an enemy
647     // pawn, or if it is undefended and attacked by an enemy piece.
648     Bitboard safe =   SpaceMask[Us]
649                    & ~pos.pieces(Us, PAWN)
650                    & ~ei.attackedBy[Them][PAWN]
651                    & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
652
653     // Find all squares which are at most three squares behind some friendly pawn
654     Bitboard behind = pos.pieces(Us, PAWN);
655     behind |= (Us == WHITE ? behind >>  8 : behind <<  8);
656     behind |= (Us == WHITE ? behind >> 16 : behind << 16);
657
658     // Since SpaceMask[Us] is fully on our half of the board
659     assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
660
661     // Count safe + (behind & safe) with a single popcount
662     return popcount<Full>((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe)) * weight;
663   }
664
665
666   // do_evaluate() is the evaluation entry point, called directly from evaluate()
667
668   template<bool Trace>
669   Value do_evaluate(const Position& pos) {
670
671     assert(!pos.checkers());
672
673     EvalInfo ei;
674     Score score, mobility[2] = { SCORE_ZERO, SCORE_ZERO };
675     Thread* thisThread = pos.this_thread();
676
677     // Initialize score by reading the incrementally updated scores included
678     // in the position object (material + piece square tables).
679     // Score is computed from the point of view of white.
680     score = pos.psq_score();
681
682     // Probe the material hash table
683     ei.mi = Material::probe(pos, thisThread->materialTable, thisThread->endgames);
684     score += ei.mi->imbalance();
685
686     // If we have a specialized evaluation function for the current material
687     // configuration, call it and return.
688     if (ei.mi->specialized_eval_exists())
689         return ei.mi->evaluate(pos);
690
691     // Probe the pawn hash table
692     ei.pi = Pawns::probe(pos, thisThread->pawnsTable);
693     score += apply_weight(ei.pi->pawns_score(), Weights[PawnStructure]);
694
695     // Initialize attack and king safety bitboards
696     init_eval_info<WHITE>(pos, ei);
697     init_eval_info<BLACK>(pos, ei);
698
699     ei.attackedBy[WHITE][ALL_PIECES] |= ei.attackedBy[WHITE][KING];
700     ei.attackedBy[BLACK][ALL_PIECES] |= ei.attackedBy[BLACK][KING];
701
702     // Do not include in mobility squares protected by enemy pawns or occupied by our pawns or king
703     Bitboard mobilityArea[] = { ~(ei.attackedBy[BLACK][PAWN] | pos.pieces(WHITE, PAWN, KING)),
704                                 ~(ei.attackedBy[WHITE][PAWN] | pos.pieces(BLACK, PAWN, KING)) };
705
706     // Evaluate pieces and mobility
707     score += evaluate_pieces<KNIGHT, WHITE, Trace>(pos, ei, mobility, mobilityArea);
708     score += apply_weight(mobility[WHITE] - mobility[BLACK], Weights[Mobility]);
709
710     // Evaluate kings after all other pieces because we need complete attack
711     // information when computing the king safety evaluation.
712     score +=  evaluate_king<WHITE, Trace>(pos, ei)
713             - evaluate_king<BLACK, Trace>(pos, ei);
714
715     // Evaluate tactical threats, we need full attack information including king
716     score +=  evaluate_threats<WHITE, Trace>(pos, ei)
717             - evaluate_threats<BLACK, Trace>(pos, ei);
718
719     // Evaluate passed pawns, we need full attack information including king
720     score +=  evaluate_passed_pawns<WHITE, Trace>(pos, ei)
721             - evaluate_passed_pawns<BLACK, Trace>(pos, ei);
722
723     // If both sides have only pawns, score for potential unstoppable pawns
724     if (!pos.non_pawn_material(WHITE) && !pos.non_pawn_material(BLACK))
725     {
726         Bitboard b;
727         if ((b = ei.pi->passed_pawns(WHITE)) != 0)
728             score += int(relative_rank(WHITE, frontmost_sq(WHITE, b))) * Unstoppable;
729
730         if ((b = ei.pi->passed_pawns(BLACK)) != 0)
731             score -= int(relative_rank(BLACK, frontmost_sq(BLACK, b))) * Unstoppable;
732     }
733
734     // Evaluate space for both sides, only in middlegame
735     if (ei.mi->space_weight())
736     {
737         Score s =  evaluate_space<WHITE>(pos, ei, ei.mi->space_weight())
738                  - evaluate_space<BLACK>(pos, ei, ei.mi->space_weight());
739
740         score += apply_weight(s, Weights[Space]);
741     }
742
743     // Scale winning side if position is more drawish than it appears
744     Color strongSide = eg_value(score) > VALUE_DRAW ? WHITE : BLACK;
745     ScaleFactor sf = ei.mi->scale_factor(pos, strongSide);
746
747     // If we don't already have an unusual scale factor, check for certain
748     // types of endgames, and use a lower scale for those.
749     if (    ei.mi->game_phase() < PHASE_MIDGAME
750         && (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN))
751     {
752         if (pos.opposite_bishops())
753         {
754             // Endgame with opposite-colored bishops and no other pieces (ignoring pawns)
755             // is almost a draw, in case of KBP vs KB is even more a draw.
756             if (   pos.non_pawn_material(WHITE) == BishopValueMg
757                 && pos.non_pawn_material(BLACK) == BishopValueMg)
758                 sf = more_than_one(pos.pieces(PAWN)) ? ScaleFactor(32) : ScaleFactor(8);
759
760             // Endgame with opposite-colored bishops, but also other pieces. Still
761             // a bit drawish, but not as drawish as with only the two bishops.
762             else
763                  sf = ScaleFactor(50 * sf / SCALE_FACTOR_NORMAL);
764         }
765         // Endings where weaker side can place his king in front of the opponent's
766         // pawns are drawish.
767         else if (    abs(eg_value(score)) <= BishopValueEg
768                  &&  ei.pi->pawn_span(strongSide) <= 1
769                  && !pos.pawn_passed(~strongSide, pos.king_square(~strongSide)))
770                  sf = ei.pi->pawn_span(strongSide) ? ScaleFactor(56) : ScaleFactor(38);
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::write(Tracing::MATERIAL, pos.psq_score());
783         Tracing::write(Tracing::IMBALANCE, ei.mi->imbalance());
784         Tracing::write(PAWN, ei.pi->pawns_score());
785         Tracing::write(Tracing::MOBILITY, apply_weight(mobility[WHITE], Weights[Mobility])
786                                         , apply_weight(mobility[BLACK], Weights[Mobility]));
787         Score w = evaluate_space<WHITE>(pos, ei, ei.mi->space_weight());
788         Score b = evaluate_space<BLACK>(pos, ei, ei.mi->space_weight());
789         Tracing::write(Tracing::SPACE, apply_weight(w, Weights[Space]), apply_weight(b, Weights[Space]));
790         Tracing::write(Tracing::TOTAL, score);
791         Tracing::ei = ei;
792         Tracing::sf = sf;
793     }
794
795     return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo;
796   }
797
798
799   // Tracing function definitions
800
801   double Tracing::to_cp(Value v) { return double(v) / PawnValueEg; }
802
803   void Tracing::write(int idx, Color c, Score s) { scores[c][idx] = s; }
804
805   void Tracing::write(int idx, Score w, Score b) {
806
807     write(idx, WHITE, w);
808     write(idx, BLACK, b);
809   }
810
811   void Tracing::print(std::stringstream& ss, const char* name, int idx) {
812
813     Score wScore = scores[WHITE][idx];
814     Score bScore = scores[BLACK][idx];
815
816     switch (idx) {
817     case MATERIAL: case IMBALANCE: case PAWN: case TOTAL:
818         ss << std::setw(15) << name << " |   ---   --- |   ---   --- | "
819            << std::setw(5)  << to_cp(mg_value(wScore - bScore)) << " "
820            << std::setw(5)  << to_cp(eg_value(wScore - bScore)) << " \n";
821         break;
822     default:
823         ss << std::setw(15) << name << " | " << std::noshowpos
824            << std::setw(5)  << to_cp(mg_value(wScore)) << " "
825            << std::setw(5)  << to_cp(eg_value(wScore)) << " | "
826            << std::setw(5)  << to_cp(mg_value(bScore)) << " "
827            << std::setw(5)  << to_cp(eg_value(bScore)) << " | "
828            << std::setw(5)  << to_cp(mg_value(wScore - bScore)) << " "
829            << std::setw(5)  << to_cp(eg_value(wScore - bScore)) << " \n";
830     }
831   }
832
833   std::string Tracing::do_trace(const Position& pos) {
834
835     std::memset(scores, 0, sizeof(scores));
836
837     Value v = do_evaluate<true>(pos);
838     v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
839
840     std::stringstream ss;
841     ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
842        << "      Eval term |    White    |    Black    |    Total    \n"
843        << "                |   MG    EG  |   MG    EG  |   MG    EG  \n"
844        << "----------------+-------------+-------------+-------------\n";
845
846     print(ss, "Material", MATERIAL);
847     print(ss, "Imbalance", IMBALANCE);
848     print(ss, "Pawns", PAWN);
849     print(ss, "Knights", KNIGHT);
850     print(ss, "Bishops", BISHOP);
851     print(ss, "Rooks", ROOK);
852     print(ss, "Queens", QUEEN);
853     print(ss, "Mobility", MOBILITY);
854     print(ss, "King safety", KING);
855     print(ss, "Threats", THREAT);
856     print(ss, "Passed pawns", PASSED);
857     print(ss, "Space", SPACE);
858
859     ss << "----------------+-------------+-------------+-------------\n";
860     print(ss, "Total", TOTAL);
861
862     ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";
863
864     return ss.str();
865   }
866
867 } // namespace
868
869
870 namespace Eval {
871
872   /// evaluate() is the main evaluation function. It returns a static evaluation
873   /// of the position always from the point of view of the side to move.
874
875   Value evaluate(const Position& pos) {
876     return do_evaluate<false>(pos);
877   }
878
879
880   /// trace() is like evaluate(), but instead of returning a value, it returns
881   /// a string (suitable for outputting to stdout) that contains the detailed
882   /// descriptions and values of each evaluation term. It's mainly used for
883   /// debugging.
884   std::string trace(const Position& pos) {
885     return Tracing::do_trace(pos);
886   }
887
888
889   /// init() computes evaluation weights, usually at startup
890
891   void init() {
892
893     const double MaxSlope = 30;
894     const double Peak = 1280;
895
896     for (int t = 0, i = 1; i < 100; ++i)
897     {
898         t = int(std::min(Peak, std::min(0.4 * i * i, t + MaxSlope)));
899         KingDanger[i] = apply_weight(make_score(t, 0), Weights[KingSafety]);
900     }
901   }
902
903 } // namespace Eval