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