X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fevaluate.cpp;h=d9aae3d32bd3667a2b7daa415afeaf7c38b9380e;hp=af7a9d34edde97fc2911433ef1f57ca5eee815df;hb=471f7a1b5c4da03a712da2ce079034de45b4c35b;hpb=e3a8b8bcff893d078e219637b3d0dcaeaa04beb2 diff --git a/src/evaluate.cpp b/src/evaluate.cpp index af7a9d34..d9aae3d3 100644 --- a/src/evaluate.cpp +++ b/src/evaluate.cpp @@ -2,7 +2,7 @@ Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad - Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad + Copyright (C) 2015-2017 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -73,6 +73,10 @@ namespace { // by the evaluation functions. struct EvalInfo { + Material::Entry* me; + Pawns::Entry* pe; + Bitboard mobilityArea[COLOR_NB]; + // attackedBy[color][piece type] is a bitboard representing all squares // attacked by a given color and piece type (can be also ALL_PIECES). Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB]; @@ -106,17 +110,13 @@ namespace { // a white knight on g5 and black's king is on g8, this white knight adds 2 // to kingAdjacentZoneAttacksCount[WHITE]. int kingAdjacentZoneAttacksCount[COLOR_NB]; - - Bitboard pinnedPieces[COLOR_NB]; - Material::Entry* me; - Pawns::Entry* pi; }; #define V(v) Value(v) #define S(mg, eg) make_score(mg, eg) - // MobilityBonus[PieceType][attacked] contains bonuses for middle and end - // game, indexed by piece type and number of attacked squares in the MobilityArea. + // MobilityBonus[PieceType][attacked] contains bonuses for middle and end game, + // indexed by piece type and number of attacked squares in the mobility area. const Score MobilityBonus[][32] = { {}, {}, { S(-75,-76), S(-56,-54), S( -9,-26), S( -2,-10), S( 6, 5), S( 15, 11), // Knights @@ -134,19 +134,13 @@ namespace { S(118,174), S(119,177), S(123,191), S(128,199) } }; - // Outpost[knight/bishop][supported by pawn] contains bonuses for knights and - // bishops outposts, bigger if outpost piece is supported by a pawn. + // Outpost[knight/bishop][supported by pawn] contains bonuses for minor + // pieces if they can reach an outpost square, bigger if that square is + // supported by a pawn. If the minor piece occupies an outpost square + // then score is doubled. const Score Outpost[][2] = { - { S(43,11), S(65,20) }, // Knights - { S(20, 3), S(29, 8) } // Bishops - }; - - // ReachableOutpost[knight/bishop][supported by pawn] contains bonuses for - // knights and bishops which can reach an outpost square in one move, bigger - // if outpost square is supported by a pawn. - const Score ReachableOutpost[][2] = { - { S(21, 5), S(35, 8) }, // Knights - { S( 8, 0), S(14, 4) } // Bishops + { S(22, 6), S(33, 9) }, // Knight + { S( 9, 2), S(14, 4) } // Bishop }; // RookOnFile[semiopen/open] contains bonuses for each rook when there is no @@ -221,6 +215,8 @@ namespace { const int BishopCheck = 588; const int KnightCheck = 924; + // Threshold for lazy evaluation + const Value LazyThreshold = Value(1500); // eval_init() initializes king and attack bitboards for a given color // adding pawn attacks. To be done at the beginning of the evaluation. @@ -229,23 +225,33 @@ namespace { void eval_init(const Position& pos, EvalInfo& ei) { const Color Them = (Us == WHITE ? BLACK : WHITE); + const Square Up = (Us == WHITE ? NORTH : SOUTH); const Square Down = (Us == WHITE ? SOUTH : NORTH); + const Bitboard LowRanks = (Us == WHITE ? Rank2BB | Rank3BB: Rank7BB | Rank6BB); - ei.pinnedPieces[Us] = pos.pinned_pieces(Us); - Bitboard b = ei.attackedBy[Them][KING]; - ei.attackedBy[Them][ALL_PIECES] |= b; - ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us); - ei.attackedBy2[Us] = ei.attackedBy[Us][PAWN] & ei.attackedBy[Us][KING]; + // Find our pawns on the first two ranks, and those which are blocked + Bitboard b = pos.pieces(Us, PAWN) & (shift(pos.pieces()) | LowRanks); - // Init king safety tables only if we are going to use them - if (pos.non_pawn_material(Us) >= QueenValueMg) + // Squares occupied by those pawns, by our king, or controlled by enemy pawns + // are excluded from the mobility area. + ei.mobilityArea[Us] = ~(b | pos.square(Us) | ei.pe->pawn_attacks(Them)); + + // Initialise the attack bitboards with the king and pawn information + b = ei.attackedBy[Us][KING] = pos.attacks_from(pos.square(Us)); + ei.attackedBy[Us][PAWN] = ei.pe->pawn_attacks(Us); + + ei.attackedBy2[Us] = b & ei.attackedBy[Us][PAWN]; + ei.attackedBy[Us][ALL_PIECES] = b | ei.attackedBy[Us][PAWN]; + + // Init our king safety tables only if we are going to use them + if (pos.non_pawn_material(Them) >= QueenValueMg) { - ei.kingRing[Them] = b | shift(b); - ei.kingAttackersCount[Us] = popcount(b & ei.attackedBy[Us][PAWN]); - ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = 0; + ei.kingRing[Us] = b | shift(b); + ei.kingAttackersCount[Them] = popcount(b & ei.pe->pawn_attacks(Them)); + ei.kingAdjacentZoneAttacksCount[Them] = ei.kingAttackersWeight[Them] = 0; } else - ei.kingRing[Them] = ei.kingAttackersCount[Us] = 0; + ei.kingRing[Us] = ei.kingAttackersCount[Them] = 0; } @@ -253,8 +259,8 @@ namespace { // color and type. template - Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility, - const Bitboard* mobilityArea) { + Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility) { + const PieceType NextPt = (Us == WHITE ? Pt : PieceType(Pt + 1)); const Color Them = (Us == WHITE ? BLACK : WHITE); const Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB @@ -274,7 +280,7 @@ namespace { : Pt == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN)) : pos.attacks_from(s); - if (ei.pinnedPieces[Us] & s) + if (pos.pinned_pieces(Us) & s) b &= LineBB[pos.square(Us)][s]; ei.attackedBy2[Us] |= ei.attackedBy[Us][ALL_PIECES] & b; @@ -292,21 +298,21 @@ namespace { | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]); - int mob = popcount(b & mobilityArea[Us]); + int mob = popcount(b & ei.mobilityArea[Us]); mobility[Us] += MobilityBonus[Pt][mob]; if (Pt == BISHOP || Pt == KNIGHT) { // Bonus for outpost squares - bb = OutpostRanks & ~ei.pi->pawn_attacks_span(Them); + bb = OutpostRanks & ~ei.pe->pawn_attacks_span(Them); if (bb & s) - score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & s)]; + score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & s)] * 2; else { bb &= b & ~pos.pieces(Us); if (bb) - score += ReachableOutpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & bb)]; + score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & bb)]; } // Bonus when behind a pawn @@ -316,7 +322,7 @@ namespace { // Penalty for pawns on the same color square as the bishop if (Pt == BISHOP) - score -= BishopPawns * ei.pi->pawns_on_same_color_squares(Us, s); + score -= BishopPawns * ei.pe->pawns_on_same_color_squares(Us, s); // An important Chess960 pattern: A cornered bishop blocked by a friendly // pawn diagonally in front of it is a very serious problem, especially @@ -340,16 +346,16 @@ namespace { score += RookOnPawn * popcount(pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s]); // Bonus when on an open or semi-open file - if (ei.pi->semiopen_file(Us, file_of(s))) - score += RookOnFile[!!ei.pi->semiopen_file(Them, file_of(s))]; + if (ei.pe->semiopen_file(Us, file_of(s))) + score += RookOnFile[!!ei.pe->semiopen_file(Them, file_of(s))]; - // Penalize when trapped by the king, even more if the king cannot castle + // Penalty when trapped by the king, even more if the king cannot castle else if (mob <= 3) { Square ksq = pos.square(Us); if ( ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq))) - && !ei.pi->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq))) + && !ei.pe->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq))) score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us)); } } @@ -367,13 +373,13 @@ namespace { Trace::add(Pt, Us, score); // Recursively call evaluate_pieces() of next piece type until KING is excluded - return score - evaluate_pieces(pos, ei, mobility, mobilityArea); + return score - evaluate_pieces(pos, ei, mobility); } template<> - Score evaluate_pieces(const Position&, EvalInfo&, Score*, const Bitboard*) { return SCORE_ZERO; } + Score evaluate_pieces(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; } template<> - Score evaluate_pieces< true, WHITE, KING>(const Position&, EvalInfo&, Score*, const Bitboard*) { return SCORE_ZERO; } + Score evaluate_pieces< true, WHITE, KING>(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; } // evaluate_king() assigns bonuses and penalties to a king of a given color @@ -398,12 +404,12 @@ namespace { int kingDanger; // King shelter and enemy pawns storm - Score score = ei.pi->king_safety(pos, ksq); + Score score = ei.pe->king_safety(pos, ksq); // Main king safety evaluation if (ei.kingAttackersCount[Them]) { - // Find the attacked squares which are defended only by the king... + // Find the attacked squares which are defended only by our king... undefended = ei.attackedBy[Them][ALL_PIECES] & ei.attackedBy[Us][KING] & ~ei.attackedBy2[Us]; @@ -420,25 +426,20 @@ namespace { kingDanger = std::min(807, ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) + 101 * ei.kingAdjacentZoneAttacksCount[Them] + 235 * popcount(undefended) - + 134 * (popcount(b) + !!ei.pinnedPieces[Us]) + + 134 * (popcount(b) + !!pos.pinned_pieces(Us)) - 717 * !pos.count(Them) - 7 * mg_value(score) / 5 - 5; // Analyse the enemy's safe queen contact checks. Firstly, find the - // undefended squares around the king reachable by the enemy queen... + // undefended squares around our king reachable by the enemy queen... b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces(Them); - // ...and keep squares supported by another enemy piece + // ...and keep squares supported by another enemy piece. kingDanger += QueenContactCheck * popcount(b & ei.attackedBy2[Them]); - // Analyse the safe enemy's checks which are possible on next move... + // Analyse the safe enemy's checks which are possible on next move safe = ~(ei.attackedBy[Us][ALL_PIECES] | pos.pieces(Them)); - // ... and some other potential checks, only requiring the square to be - // safe from pawn-attacks, and not being occupied by a blocked pawn. - other = ~( ei.attackedBy[Us][PAWN] - | (pos.pieces(Them, PAWN) & shift(pos.pieces(PAWN)))); - b1 = pos.attacks_from(ksq); b2 = pos.attacks_from(ksq); @@ -446,12 +447,18 @@ namespace { if ((b1 | b2) & ei.attackedBy[Them][QUEEN] & safe) kingDanger += QueenCheck; - // For other pieces, also consider the square safe if attacked twice, - // and only defended by a queen. + // For minors and rooks, also consider the square safe if attacked twice, + // and only defended by our queen. safe |= ei.attackedBy2[Them] & ~(ei.attackedBy2[Us] | pos.pieces(Them)) & ei.attackedBy[Us][QUEEN]; + // Some other potential checks are also analysed, even from squares + // currently occupied by the opponent own pieces, as long as the square + // is not attacked by our pawns, and is not occupied by a blocked pawn. + other = ~( ei.attackedBy[Us][PAWN] + | (pos.pieces(Them, PAWN) & shift(pos.pieces(PAWN)))); + // Enemy rooks safe and other checks if (b1 & ei.attackedBy[Them][ROOK] & safe) kingDanger += RookCheck; @@ -474,7 +481,7 @@ namespace { else if (b & other) score -= OtherCheck; - // Compute the king danger score and subtract it from the evaluation + // Transform the kingDanger units into a Score, and substract it from the evaluation if (kingDanger > 0) score -= make_score(std::min(kingDanger * kingDanger / 4096, 2 * int(BishopValueMg)), 0); } @@ -599,23 +606,23 @@ namespace { } - // evaluate_passed_pawns() evaluates the passed pawns of the given color + // evaluate_passer_pawns() evaluates the passed pawns and candidate passed + // pawns of the given color. template - Score evaluate_passed_pawns(const Position& pos, const EvalInfo& ei) { + Score evaluate_passer_pawns(const Position& pos, const EvalInfo& ei) { const Color Them = (Us == WHITE ? BLACK : WHITE); Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares; Score score = SCORE_ZERO; - b = ei.pi->passed_pawns(Us); + b = ei.pe->passed_pawns(Us); while (b) { Square s = pop_lsb(&b); - assert(pos.pawn_passed(Us, s)); assert(!(pos.pieces(PAWN) & forward_bb(Us, s))); bb = forward_bb(Us, s) & (ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them)); @@ -676,6 +683,11 @@ namespace { if (!pos.non_pawn_material(Them)) ebonus += 20; + // Scale down bonus for candidate passers which need more than one pawn + // push to become passed. + if (!pos.pawn_passed(Us, s + pawn_push(Us))) + mbonus /= 2, ebonus /= 2; + score += make_score(mbonus, ebonus) + PassedFile[file_of(s)]; } @@ -717,10 +729,10 @@ namespace { // Since SpaceMask[Us] is fully on our half of the board... assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0); - // ...count safe + (behind & safe) with a single popcount + // ...count safe + (behind & safe) with a single popcount. int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe)); bonus = std::min(16, bonus); - int weight = pos.count(Us) - 2 * ei.pi->open_files(); + int weight = pos.count(Us) - 2 * ei.pe->open_files(); return make_score(bonus * weight * weight / 18, 0); } @@ -794,6 +806,7 @@ Value Eval::evaluate(const Position& pos) { assert(!pos.checkers()); Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO }; + Value v; EvalInfo ei; // Probe the material hash table @@ -810,31 +823,20 @@ Value Eval::evaluate(const Position& pos) { Score score = pos.psq_score() + ei.me->imbalance(); // Probe the pawn hash table - ei.pi = Pawns::probe(pos); - score += ei.pi->pawns_score(); + ei.pe = Pawns::probe(pos); + score += ei.pe->pawns_score(); + + // Early exit if score is high + v = (mg_value(score) + eg_value(score)) / 2; + if (abs(v) > LazyThreshold) + return pos.side_to_move() == WHITE ? v : -v; // Initialize attack and king safety bitboards - ei.attackedBy[WHITE][ALL_PIECES] = ei.attackedBy[BLACK][ALL_PIECES] = 0; - ei.attackedBy[WHITE][KING] = pos.attacks_from(pos.square(WHITE)); - ei.attackedBy[BLACK][KING] = pos.attacks_from(pos.square(BLACK)); eval_init(pos, ei); eval_init(pos, ei); - // Pawns blocked or on ranks 2 and 3 will be excluded from the mobility area - Bitboard blockedPawns[] = { - pos.pieces(WHITE, PAWN) & (shift(pos.pieces()) | Rank2BB | Rank3BB), - pos.pieces(BLACK, PAWN) & (shift(pos.pieces()) | Rank7BB | Rank6BB) - }; - - // Do not include in mobility area squares protected by enemy pawns, or occupied - // by our blocked pawns or king. - Bitboard mobilityArea[] = { - ~(ei.attackedBy[BLACK][PAWN] | blockedPawns[WHITE] | pos.square(WHITE)), - ~(ei.attackedBy[WHITE][PAWN] | blockedPawns[BLACK] | pos.square(BLACK)) - }; - // Evaluate all pieces but king and pawns - score += evaluate_pieces(pos, ei, mobility, mobilityArea); + score += evaluate_pieces(pos, ei, mobility); score += mobility[WHITE] - mobility[BLACK]; // Evaluate kings after all other pieces because we need full attack @@ -847,8 +849,8 @@ Value Eval::evaluate(const Position& pos) { - evaluate_threats(pos, ei); // Evaluate passed pawns, we need full attack information including king - score += evaluate_passed_pawns(pos, ei) - - evaluate_passed_pawns(pos, ei); + score += evaluate_passer_pawns(pos, ei) + - evaluate_passer_pawns(pos, ei); // Evaluate space for both sides, only during opening if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222) @@ -856,14 +858,14 @@ Value Eval::evaluate(const Position& pos) { - evaluate_space(pos, ei); // Evaluate position potential for the winning side - score += evaluate_initiative(pos, ei.pi->pawn_asymmetry(), eg_value(score)); + score += evaluate_initiative(pos, ei.pe->pawn_asymmetry(), eg_value(score)); // Evaluate scale factor for the winning side ScaleFactor sf = evaluate_scale_factor(pos, ei, eg_value(score)); // Interpolate between a middlegame and a (scaled by 'sf') endgame score - Value v = mg_value(score) * int(ei.me->game_phase()) - + eg_value(score) * int(PHASE_MIDGAME - ei.me->game_phase()) * sf / SCALE_FACTOR_NORMAL; + v = mg_value(score) * int(ei.me->game_phase()) + + eg_value(score) * int(PHASE_MIDGAME - ei.me->game_phase()) * sf / SCALE_FACTOR_NORMAL; v /= int(PHASE_MIDGAME); @@ -872,7 +874,7 @@ Value Eval::evaluate(const Position& pos) { { Trace::add(MATERIAL, pos.psq_score()); Trace::add(IMBALANCE, ei.me->imbalance()); - Trace::add(PAWN, ei.pi->pawns_score()); + Trace::add(PAWN, ei.pe->pawns_score()); Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]); if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222) Trace::add(SPACE, evaluate_space(pos, ei)