// Penalties for enemy's safe checks
constexpr int QueenSafeCheck = 780;
- constexpr int RookSafeCheck = 880;
- constexpr int BishopSafeCheck = 435;
+ constexpr int RookSafeCheck = 1080;
+ constexpr int BishopSafeCheck = 635;
constexpr int KnightSafeCheck = 790;
#define S(mg, eg) make_score(mg, eg)
// Assorted bonuses and penalties
constexpr Score BishopPawns = S( 3, 7);
- constexpr Score CloseEnemies = S( 8, 0);
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 KnightOnQueen = S( 16, 12);
constexpr Score ThreatByPawnPush = S( 48, 39);
constexpr Score ThreatByRank = S( 13, 0);
constexpr Score ThreatBySafePawn = S(173, 94);
- constexpr Score TrappedRook = S( 96, 4);
+ constexpr Score TrappedRook = S( 47, 4);
constexpr Score WeakQueen = S( 49, 15);
constexpr Score WeakUnopposedPawn = S( 12, 23);
constexpr Direction Down = (Us == WHITE ? SOUTH : NORTH);
constexpr Bitboard LowRanks = (Us == WHITE ? Rank2BB | Rank3BB: Rank7BB | Rank6BB);
+ const Square ksq = pos.square<KING>(Us);
+
// Find our pawns that are blocked or on the first two ranks
Bitboard b = pos.pieces(Us, PAWN) & (shift<Down>(pos.pieces()) | LowRanks);
- // Squares occupied by those pawns, by our king or queen, or controlled by enemy pawns
- // are excluded from the mobility area.
+ // Squares occupied by those pawns, by our king or queen or controlled by
+ // enemy pawns are excluded from the mobility area.
mobilityArea[Us] = ~(b | pos.pieces(Us, KING, QUEEN) | pe->pawn_attacks(Them));
- // Initialise attackedBy bitboards for kings and pawns
- attackedBy[Us][KING] = pos.attacks_from<KING>(pos.square<KING>(Us));
+ // Initialize attackedBy[] for king and pawns
+ attackedBy[Us][KING] = pos.attacks_from<KING>(ksq);
attackedBy[Us][PAWN] = pe->pawn_attacks(Us);
attackedBy[Us][ALL_PIECES] = attackedBy[Us][KING] | attackedBy[Us][PAWN];
attackedBy2[Us] = attackedBy[Us][KING] & attackedBy[Us][PAWN];
// Init our king safety tables
kingRing[Us] = attackedBy[Us][KING];
- if (relative_rank(Us, pos.square<KING>(Us)) == RANK_1)
+ if (relative_rank(Us, ksq) == RANK_1)
kingRing[Us] |= shift<Up>(kingRing[Us]);
- if (file_of(pos.square<KING>(Us)) == FILE_H)
+ if (file_of(ksq) == FILE_H)
kingRing[Us] |= shift<WEST>(kingRing[Us]);
- else if (file_of(pos.square<KING>(Us)) == FILE_A)
+ else if (file_of(ksq) == FILE_A)
kingRing[Us] |= shift<EAST>(kingRing[Us]);
kingAttackersCount[Them] = popcount(kingRing[Us] & pe->pawn_attacks(Them));
- kingRing[Us] &= ~double_pawn_attacks_bb<Us>(pos.pieces(Us, PAWN));
kingAttacksCount[Them] = kingAttackersWeight[Them] = 0;
+
+ // Remove from kingRing[] the squares defended by two pawns
+ kingRing[Us] &= ~pawn_double_attacks_bb<Us>(pos.pieces(Us, PAWN));
}
const Square* pl = pos.squares<Pt>(Us);
Bitboard b, bb;
- Square s;
Score score = SCORE_ZERO;
attackedBy[Us][Pt] = 0;
- while ((s = *pl++) != SQ_NONE)
+ for (Square s = *pl; s != SQ_NONE; s = *++pl)
{
// Find attacked squares, including x-ray attacks for bishops and rooks
b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(QUEEN))
{
File kf = file_of(pos.square<KING>(Us));
if ((kf < FILE_E) == (file_of(s) < kf))
- score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.castling_rights(Us));
+ score -= TrappedRook * (1 + !pos.castling_rights(Us));
}
}
constexpr Bitboard Camp = (Us == WHITE ? AllSquares ^ Rank6BB ^ Rank7BB ^ Rank8BB
: AllSquares ^ Rank1BB ^ Rank2BB ^ Rank3BB);
+ Bitboard weak, b, b1, b2, safe, unsafeChecks = 0;
+ int kingDanger = 0;
const Square ksq = pos.square<KING>(Us);
- Bitboard kingFlank, weak, b, b1, b2, safe, unsafeChecks;
- // King shelter and enemy pawns storm
+ // Init the score with king shelter and enemy pawns storm
Score score = pe->king_safety<Us>(pos);
- // Find the squares that opponent attacks in our king flank, and the squares
- // which are attacked twice in that flank.
- kingFlank = KingFlank[file_of(ksq)];
- b1 = attackedBy[Them][ALL_PIECES] & kingFlank & Camp;
- b2 = b1 & attackedBy2[Them];
-
- int tropism = popcount(b1) + popcount(b2);
-
- // Main king safety evaluation
- int kingDanger = 0;
- unsafeChecks = 0;
-
// Attacked squares defended at most once by our queen or king
weak = attackedBy[Them][ALL_PIECES]
& ~attackedBy2[Us]
b1 = attacks_bb<ROOK >(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
b2 = attacks_bb<BISHOP>(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
- // Enemy queen safe checks
- if ((b1 | b2) & attackedBy[Them][QUEEN] & safe & ~attackedBy[Us][QUEEN])
- kingDanger += QueenSafeCheck;
-
- b1 &= attackedBy[Them][ROOK];
- b2 &= attackedBy[Them][BISHOP];
-
// Enemy rooks checks
- if (b1 & safe)
+ Bitboard RookCheck = b1
+ & safe
+ & attackedBy[Them][ROOK];
+
+ if (RookCheck)
kingDanger += RookSafeCheck;
else
- unsafeChecks |= b1;
+ unsafeChecks |= b1 & attackedBy[Them][ROOK];
+
+ // Enemy queen safe checks: we count them only if they are from squares from
+ // which we can't give a rook check, because rook checks are more valuable.
+ Bitboard QueenCheck = (b1 | b2)
+ & attackedBy[Them][QUEEN]
+ & safe
+ & ~attackedBy[Us][QUEEN]
+ & ~RookCheck;
+
+ if (QueenCheck)
+ kingDanger += 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.
+ Bitboard BishopCheck = b2
+ & attackedBy[Them][BISHOP]
+ & safe
+ & ~QueenCheck;
- // Enemy bishops checks
- if (b2 & safe)
+ if (BishopCheck)
kingDanger += BishopSafeCheck;
else
- unsafeChecks |= b2;
+ unsafeChecks |= b2 & attackedBy[Them][BISHOP];
// Enemy knights checks
b = pos.attacks_from<KNIGHT>(ksq) & attackedBy[Them][KNIGHT];
+
if (b & safe)
kingDanger += KnightSafeCheck;
else
// the square is in the attacker's mobility area.
unsafeChecks &= mobilityArea[Them];
+ // Find the squares that opponent attacks in our king flank, and the squares
+ // which are attacked twice in that flank.
+ b1 = attackedBy[Them][ALL_PIECES] & KingFlank[file_of(ksq)] & Camp;
+ b2 = b1 & attackedBy2[Them];
+
+ int kingFlankAttacks = popcount(b1) + popcount(b2);
+
kingDanger += kingAttackersCount[Them] * kingAttackersWeight[Them]
+ 69 * kingAttacksCount[Them]
+ 185 * popcount(kingRing[Us] & weak)
+ - 100 * bool(attackedBy[Us][KNIGHT] & attackedBy[Us][KING])
+ 150 * popcount(pos.blockers_for_king(Us) | unsafeChecks)
- + tropism * tropism / 4
- 873 * !pos.count<QUEEN>(Them)
- 6 * mg_value(score) / 8
+ mg_value(mobility[Them] - mobility[Us])
- - 30;
+ + 5 * kingFlankAttacks * kingFlankAttacks / 16
+ - 25;
// Transform the kingDanger units into a Score, and subtract it from the evaluation
if (kingDanger > 0)
score -= make_score(kingDanger * kingDanger / 4096, kingDanger / 16);
// Penalty when our king is on a pawnless flank
- if (!(pos.pieces(PAWN) & kingFlank))
+ if (!(pos.pieces(PAWN) & KingFlank[file_of(ksq)]))
score -= PawnlessFlank;
- // King tropism bonus, to anticipate slow motion attacks on our king
- score -= CloseEnemies * tropism;
+ // Penalty if king flank is under attack, potentially moving toward the king
+ score -= FlankAttacks * kingFlankAttacks;
if (T)
Trace::add(KING, Us, score);
v = mg_value(score) * int(me->game_phase())
+ eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
- v /= int(PHASE_MIDGAME);
+ v /= PHASE_MIDGAME;
// In case of tracing add all remaining individual evaluation terms
if (T)
projects / stockfish / blobdiff