X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fevaluate.cpp;h=6e33bb7215d0579e035915d20c40811dac8c8ae9;hp=5621c508f219d7ed7725c68f46b4a28032973fc4;hb=58c181de9a8f505e539b2e7811cf820175c73ebf;hpb=de02768af7b37c903e3227b85ec4d81ec79ba69a diff --git a/src/evaluate.cpp b/src/evaluate.cpp index 5621c508..6e33bb72 100644 --- a/src/evaluate.cpp +++ b/src/evaluate.cpp @@ -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 @@ -222,7 +216,7 @@ namespace { const int KnightCheck = 924; // Threshold for lazy evaluation - const Value LazyEval = Value(1500); + 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. @@ -231,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); + + // Find our pawns on the first two ranks, and those which are blocked + Bitboard b = pos.pieces(Us, PAWN) & (shift(pos.pieces()) | LowRanks); - 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]; + // 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)); - // Init king safety tables only if we are going to use them - if (pos.non_pawn_material(Us) >= QueenValueMg) + // 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; } @@ -255,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 @@ -276,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; @@ -294,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 @@ -318,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 @@ -342,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)); } } @@ -369,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 @@ -400,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]; @@ -422,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); @@ -448,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; @@ -476,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); } @@ -611,7 +616,7 @@ namespace { Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares; Score score = SCORE_ZERO; - b = ei.pi->passed_pawns(Us); + b = ei.pe->passed_pawns(Us); while (b) { @@ -719,10 +724,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); } @@ -784,18 +789,6 @@ namespace { return sf; } - - Value lazy_eval(Value mg, Value eg) { - - if (mg > LazyEval && eg > LazyEval) - return LazyEval + ((mg + eg) / 2 - LazyEval) / 4; - - else if (mg < -LazyEval && eg < -LazyEval) - return -LazyEval + ((mg + eg) / 2 + LazyEval) / 4; - - return VALUE_ZERO; - } - } // namespace @@ -808,6 +801,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 @@ -824,37 +818,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(); - // We have taken into account all cheap evaluation terms. - // If score exceeds a threshold return a lazy evaluation. - Value lazy = lazy_eval(mg_value(score), eg_value(score)); - if (lazy) - return pos.side_to_move() == WHITE ? lazy : -lazy; + // 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 @@ -876,14 +853,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); @@ -892,7 +869,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)