constexpr int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 81, 52, 44, 10 };
// Penalties for enemy's safe checks
- constexpr int QueenSafeCheck = 780;
- constexpr int RookSafeCheck = 1078;
- constexpr int BishopSafeCheck = 635;
- constexpr int KnightSafeCheck = 790;
+ constexpr int QueenSafeCheck = 772;
+ constexpr int RookSafeCheck = 1084;
+ constexpr int BishopSafeCheck = 645;
+ constexpr int KnightSafeCheck = 792;
#define S(mg, eg) make_score(mg, eg)
// Assorted bonuses and penalties
constexpr Score BishopPawns = S( 3, 7);
+ constexpr Score BishopXRayPawns = S( 4, 5);
constexpr Score CorneredBishop = S( 50, 50);
constexpr Score FlankAttacks = S( 8, 0);
constexpr Score Hanging = S( 69, 36);
- constexpr Score KingProtector = S( 7, 8);
+ constexpr Score BishopKingProtector = S( 6, 9);
+ constexpr Score KnightKingProtector = S( 8, 9);
constexpr Score KnightOnQueen = S( 16, 11);
constexpr Score LongDiagonalBishop = S( 45, 0);
constexpr Score MinorBehindPawn = S( 18, 3);
- constexpr Score Outpost = S( 30, 21);
+ constexpr Score KnightOutpost = S( 56, 36);
+ constexpr Score BishopOutpost = S( 30, 23);
+ constexpr Score ReachableOutpost = S( 31, 22);
constexpr Score PassedFile = S( 11, 8);
constexpr Score PawnlessFlank = S( 17, 95);
constexpr Score RestrictedPiece = S( 7, 7);
// Bonus if piece is on an outpost square or can reach one
bb = OutpostRanks & attackedBy[Us][PAWN] & ~pe->pawn_attacks_span(Them);
if (bb & s)
- score += Outpost * (Pt == KNIGHT ? 2 : 1);
-
+ score += (Pt == KNIGHT) ? KnightOutpost : BishopOutpost;
else if (Pt == KNIGHT && bb & b & ~pos.pieces(Us))
- score += Outpost;
+ score += ReachableOutpost;
// Bonus for a knight or bishop shielded by pawn
if (shift<Down>(pos.pieces(PAWN)) & s)
score += MinorBehindPawn;
// Penalty if the piece is far from the king
- score -= KingProtector * distance(pos.square<KING>(Us), s);
+ score -= (Pt == KNIGHT ? KnightKingProtector
+ : BishopKingProtector) * distance(pos.square<KING>(Us), s);
if (Pt == BISHOP)
{
score -= BishopPawns * pos.pawns_on_same_color_squares(Us, s)
* (!(attackedBy[Us][PAWN] & s) + popcount(blocked & CenterFiles));
+ // Penalty for all enemy pawns x-rayed
+ score -= BishopXRayPawns * popcount(PseudoAttacks[BISHOP][s] & pos.pieces(Them, PAWN));
+
// Bonus for bishop on a long diagonal which can "see" both center squares
if (more_than_one(attacks_bb<BISHOP>(s, pos.pieces(PAWN)) & Center))
score += LongDiagonalBishop;
// Enemy rooks checks
rookChecks = b1 & safe & attackedBy[Them][ROOK];
-
if (rookChecks)
- kingDanger += RookSafeCheck;
+ kingDanger += more_than_one(rookChecks) ? RookSafeCheck * 175/100
+ : RookSafeCheck;
else
unsafeChecks |= b1 & attackedBy[Them][ROOK];
& safe
& ~attackedBy[Us][QUEEN]
& ~rookChecks;
-
if (queenChecks)
- kingDanger += QueenSafeCheck;
+ kingDanger += more_than_one(queenChecks) ? QueenSafeCheck * 145/100
+ : QueenSafeCheck;
// Enemy bishops checks: we count them only if they are from squares from
// which we can't give a queen check, because queen checks are more valuable.
& attackedBy[Them][BISHOP]
& safe
& ~queenChecks;
-
if (bishopChecks)
- kingDanger += BishopSafeCheck;
+ kingDanger += more_than_one(bishopChecks) ? BishopSafeCheck * 3/2
+ : BishopSafeCheck;
else
unsafeChecks |= b2 & attackedBy[Them][BISHOP];
// Enemy knights checks
knightChecks = pos.attacks_from<KNIGHT>(ksq) & attackedBy[Them][KNIGHT];
-
if (knightChecks & safe)
- kingDanger += KnightSafeCheck;
+ kingDanger += more_than_one(knightChecks & safe) ? KnightSafeCheck * 162/100
+ : KnightSafeCheck;
else
unsafeChecks |= knightChecks;
+ 24 * infiltration
+ 51 * !pos.non_pawn_material()
- 43 * almostUnwinnable
+ - 2 * pos.rule50_count()
-110 ;
Value mg = mg_value(score);
// Now apply the bonus: note that we find the attacking side by extracting the
// sign of the midgame or endgame values, and that we carefully cap the bonus
// so that the midgame and endgame scores do not change sign after the bonus.
- int u = ((mg > 0) - (mg < 0)) * std::max(std::min(complexity + 50, 0), -abs(mg));
+ int u = ((mg > 0) - (mg < 0)) * Utility::clamp(complexity + 50, -abs(mg), 0);
int v = ((eg > 0) - (eg < 0)) * std::max(complexity, -abs(eg));
if (T)
// If scale is not already specific, scale down the endgame via general heuristics
if (sf == SCALE_FACTOR_NORMAL)
{
- if ( pos.opposite_bishops()
- && pos.non_pawn_material() == 2 * BishopValueMg)
- sf = 22;
+ if (pos.opposite_bishops())
+ {
+ if ( pos.non_pawn_material(WHITE) == BishopValueMg
+ && pos.non_pawn_material(BLACK) == BishopValueMg)
+ sf = 18 + 4 * popcount(pe->passed_pawns(strongSide));
+ else
+ sf = 22 + 3 * pos.count<ALL_PIECES>(strongSide);
+ }
else
- sf = std::min(sf, 36 + (pos.opposite_bishops() ? 2 : 7) * pos.count<PAWN>(strongSide));
-
- sf = std::max(0, sf - (pos.rule50_count() - 12) / 4);
+ sf = std::min(sf, 36 + 7 * pos.count<PAWN>(strongSide));
}
return ScaleFactor(sf);
initialize<WHITE>();
initialize<BLACK>();
- // Pieces should be evaluated first (populate attack tables)
+ // Pieces evaluated first (also populates attackedBy, attackedBy2).
+ // Note that the order of evaluation of the terms is left unspecified
score += pieces<WHITE, KNIGHT>() - pieces<BLACK, KNIGHT>()
+ pieces<WHITE, BISHOP>() - pieces<BLACK, BISHOP>()
+ pieces<WHITE, ROOK >() - pieces<BLACK, ROOK >()
score += mobility[WHITE] - mobility[BLACK];
+ // More complex interactions that require fully populated attack bitboards
score += king< WHITE>() - king< BLACK>()
+ threats<WHITE>() - threats<BLACK>()
+ passed< WHITE>() - passed< BLACK>()
Trace::add(TOTAL, score);
}
- return (pos.side_to_move() == WHITE ? v : -v) + Tempo; // Side to move point of view
+ // Side to move point of view
+ return (pos.side_to_move() == WHITE ? v : -v) + Tempo;
}
} // namespace
projects / stockfish / blobdiff