// attacked by a given color and piece type (can be also ALL_PIECES).
Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
+ // attackedBy2[color] are the squares attacked by 2 pieces of a given color,
+ // possibly via x-ray or by one pawn and one piece. Diagonal x-ray through
+ // pawn or squares attacked by 2 pawns are not explicitly added.
+ Bitboard attackedBy2[COLOR_NB];
+
// kingRing[color] is the zone around the king which is considered
// by the king safety evaluation. This consists of the squares directly
// adjacent to the king, and the three (or two, for a king on an edge file)
const Square Down = (Us == WHITE ? DELTA_S : DELTA_N);
ei.pinnedPieces[Us] = pos.pinned_pieces(Us);
- Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.square<KING>(Them));
+ 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];
// Init king safety tables only if we are going to use them
if (pos.non_pawn_material(Us) >= QueenValueMg)
if (ei.pinnedPieces[Us] & s)
b &= LineBB[pos.square<KING>(Us)][s];
+ ei.attackedBy2[Us] |= ei.attackedBy[Us][ALL_PIECES] & b;
ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][Pt] |= b;
if (b & ei.kingRing[Them])
if (ei.kingAttackersCount[Them])
{
// Find the attacked squares which are defended only by the king...
- undefended = ei.attackedBy[Them][ALL_PIECES]
- & ei.attackedBy[Us][KING]
- & ~( ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
- | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
- | ei.attackedBy[Us][QUEEN]);
+ undefended = ei.attackedBy[Them][ALL_PIECES]
+ & ei.attackedBy[Us][KING]
+ & ~ei.attackedBy2[Us];
// ... and those which are not defended at all in the larger king ring
b = ei.attackedBy[Them][ALL_PIECES] & ~ei.attackedBy[Us][ALL_PIECES]
// Analyse the enemy's safe queen contact checks. Firstly, find the
// undefended squares around the king reachable by the enemy queen...
b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces(Them);
- if (b)
- {
- // ...and then remove squares not supported by another enemy piece
- b &= ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT]
- | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]
- | ei.attackedBy[Them][KING];
- attackUnits += QueenContactCheck * popcount(b);
- }
+ // ...and keep squares supported by another enemy piece
+ attackUnits += QueenContactCheck * popcount(b & ei.attackedBy2[Them]);
// Analyse the safe enemy's checks which are possible on next move...
safe = ~(ei.attackedBy[Us][ALL_PIECES] | pos.pieces(Them));
if ((b1 | b2) & ei.attackedBy[Them][QUEEN] & safe)
attackUnits += QueenCheck, score -= SafeCheck;
+ // For other pieces, also consider the square safe if attacked twice,
+ // and only defended by a queen.
+ safe |= ei.attackedBy2[Them]
+ & ~(ei.attackedBy2[Us] | pos.pieces(Them))
+ & ei.attackedBy[Us][QUEEN];
+
// Enemy rooks safe and other checks
if (b1 & ei.attackedBy[Them][ROOK] & safe)
attackUnits += RookCheck, score -= SafeCheck;
// evaluate_threats() assigns bonuses according to the types of the attacking
// and the attacked pieces.
+ const Bitboard WhiteCamp = Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB;
+ const Bitboard BlackCamp = Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB;
+ const Bitboard QueenSide = FileABB | FileBBB | FileCBB | FileDBB;
+ const Bitboard CenterFiles = FileCBB | FileDBB | FileEBB | FileFBB;
+ const Bitboard KingSide = FileEBB | FileFBB | FileGBB | FileHBB;
+
+ const Bitboard KingFlank[COLOR_NB][FILE_NB] = {
+ { QueenSide & WhiteCamp, QueenSide & WhiteCamp, QueenSide & WhiteCamp, CenterFiles & WhiteCamp,
+ CenterFiles & WhiteCamp, KingSide & WhiteCamp, KingSide & WhiteCamp, KingSide & WhiteCamp },
+ { QueenSide & BlackCamp, QueenSide & BlackCamp, QueenSide & BlackCamp, CenterFiles & BlackCamp,
+ CenterFiles & BlackCamp, KingSide & BlackCamp, KingSide & BlackCamp, KingSide & BlackCamp },
+ };
+
template<Color Us, bool DoTrace>
Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
score += ThreatByPawnPush * popcount(b);
+ // King tropism: firstly, find squares that we attack in the enemy king flank
+ b = ei.attackedBy[Us][ALL_PIECES] & KingFlank[Us][file_of(pos.square<KING>(Them))];
+
+ // Secondly, add to the bitboard the squares which we attack twice in that flank
+ // but which are not protected by a enemy pawn. Note the trick to shift away the
+ // previous attack bits to the empty part of the bitboard.
+ b = (b & ei.attackedBy2[Us] & ~ei.attackedBy[Them][PAWN])
+ | (Us == WHITE ? b >> 4 : b << 4);
+
+ // Count all these squares with a single popcount
+ score += make_score(7 * popcount(b), 0);
+
if (DoTrace)
Trace::add(THREAT, Us, score);
Square s = pop_lsb(&b);
assert(pos.pawn_passed(Us, s));
+ assert(!(pos.pieces(PAWN) & forward_bb(Us, s)));
int r = relative_rank(Us, s) - RANK_2;
int rr = r * (r - 1);
// ...count safe + (behind & safe) with a single popcount
int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
- int weight = pos.count<KNIGHT>(Us) + pos.count<BISHOP>(Us)
- + pos.count<KNIGHT>(Them) + pos.count<BISHOP>(Them);
+ bonus = std::min(16, bonus);
+ int weight = pos.count<ALL_PIECES>(Us);
- return make_score(bonus * weight * weight * 2 / 11, 0);
+ return make_score(bonus * weight * weight / 22, 0);
}
// Endgame with opposite-colored bishops, but also other pieces. Still
// a bit drawish, but not as drawish as with only the two bishops.
else
- sf = ScaleFactor(46 * sf / SCALE_FACTOR_NORMAL);
+ sf = ScaleFactor(46);
}
// Endings where weaker side can place his king in front of the opponent's
// pawns are drawish.
// Initialize attack and king safety bitboards
ei.attackedBy[WHITE][ALL_PIECES] = ei.attackedBy[BLACK][ALL_PIECES] = 0;
+ ei.attackedBy[WHITE][KING] = pos.attacks_from<KING>(pos.square<KING>(WHITE));
+ ei.attackedBy[BLACK][KING] = pos.attacks_from<KING>(pos.square<KING>(BLACK));
eval_init<WHITE>(pos, ei);
eval_init<BLACK>(pos, ei);
projects / stockfish / blobdiff