// happen in Chess960 games.
const Score TrappedBishopA1H1Penalty = make_score(100, 100);
+ // Penalty for BNR that is not defended by anything
+ const Score UndefendedPiecePenalty = make_score(25, 10);
+
// The SpaceMask[Color] contains the area of the board which is considered
// by the space evaluation. In the middle game, each side is given a bonus
// based on how many squares inside this area are safe and available for
template<bool Trace>
Value do_evaluate(const Position& pos, Value& margin) {
+ assert(!pos.in_check());
+
EvalInfo ei;
Value margins[2];
Score score, mobilityWhite, mobilityBlack;
- assert(pos.thread() >= 0 && pos.thread() < MAX_THREADS);
- assert(!pos.in_check());
-
// Initialize score by reading the incrementally updated scores included
// in the position object (material + piece square tables).
score = pos.value();
if (Piece == KNIGHT || Piece == QUEEN)
b = pos.attacks_from<Piece>(s);
else if (Piece == BISHOP)
- b = attacks_bb<BISHOP>(s, pos.occupied_squares() & ~pos.pieces(QUEEN, Us));
+ b = attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(QUEEN, Us));
else if (Piece == ROOK)
- b = attacks_bb<ROOK>(s, pos.occupied_squares() & ~pos.pieces(ROOK, QUEEN, Us));
+ b = attacks_bb<ROOK>(s, pos.pieces() ^ pos.pieces(ROOK, QUEEN, Us));
else
assert(false);
if ( (Piece == BISHOP || Piece == ROOK || Piece == QUEEN)
&& (PseudoAttacks[Piece][pos.king_square(Them)] & s))
{
- b = BetweenBB[s][pos.king_square(Them)] & pos.occupied_squares();
+ b = BetweenBB[s][pos.king_square(Them)] & pos.pieces();
assert(b);
const Color Them = (Us == WHITE ? BLACK : WHITE);
- Bitboard b;
+ Bitboard b, undefended, undefendedMinors, weakEnemies;
Score score = SCORE_ZERO;
+ // Undefended pieces get penalized even if not under attack
+ undefended = pos.pieces(Them) & ~ei.attackedBy[Them][0];
+ undefendedMinors = undefended & (pos.pieces(BISHOP) | pos.pieces(KNIGHT));
+
+ if (undefendedMinors)
+ score += single_bit(undefendedMinors) ? UndefendedPiecePenalty
+ : UndefendedPiecePenalty * 2;
+ if (undefended & pos.pieces(ROOK))
+ score += UndefendedPiecePenalty;
+
// Enemy pieces not defended by a pawn and under our attack
- Bitboard weakEnemies = pos.pieces(Them)
- & ~ei.attackedBy[Them][PAWN]
- & ei.attackedBy[Us][0];
+ weakEnemies = pos.pieces(Them)
+ & ~ei.attackedBy[Them][PAWN]
+ & ei.attackedBy[Us][0];
+
if (!weakEnemies)
- return SCORE_ZERO;
+ return score;
// Add bonus according to type of attacked enemy piece and to the
// type of attacking piece, from knights to queens. Kings are not
int attackUnits;
const Square ksq = pos.king_square(Us);
- // King shelter
- Score score = ei.pi->king_shelter<Us>(pos, ksq);
+ // King shelter and enemy pawns storm
+ Score score = ei.pi->king_safety<Us>(pos, ksq);
// King safety. This is quite complicated, and is almost certainly far
// from optimally tuned.
attackUnits = std::min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
+ 3 * (ei.kingAdjacentZoneAttacksCount[Them] + popcount<Max15>(undefended))
+ InitKingDanger[relative_square(Us, ksq)]
- - mg_value(ei.pi->king_shelter<Us>(pos, ksq)) / 32;
+ - mg_value(ei.pi->king_safety<Us>(pos, ksq)) / 32;
// Analyse enemy's safe queen contact checks. First find undefended
// squares around the king attacked by enemy queen...
// Opponent king cannot block because path is defended and position
// is not in check. So only friendly pieces can be blockers.
assert(!pos.in_check());
- assert((queeningPath & pos.occupied_squares()) == (queeningPath & pos.pieces(c)));
+ assert((queeningPath & pos.pieces()) == (queeningPath & pos.pieces(c)));
// Add moves needed to free the path from friendly pieces and retest condition
movesToGo += popcount<Max15>(queeningPath & pos.pieces(c));