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