- // Has a mate threat been found? We don't do anything here if the
- // side with the mating move is the side to move, because in that
- // case the mating side will get a huge bonus at the end of the main
- // evaluation function instead.
- if(ei.mateThreat[them] != MOVE_NONE)
- attackUnits += MateThreatBonus;
-
- // Ensure that attackUnits is between 0 and 99, in order to avoid array
- // out of bounds errors:
- if(attackUnits < 0) attackUnits = 0;
- if(attackUnits >= 100) attackUnits = 99;
-
- // Finally, extract the king safety score from the SafetyTable[] array.
- // Add the score to the evaluation, and also to ei.futilityMargin. The
- // reason for adding the king safety score to the futility margin is
- // that the king safety scores can sometimes be very big, and that
- // capturing a single attacking piece can therefore result in a score
- // change far bigger than the value of the captured piece.
- Value v = apply_weight(SafetyTable[attackUnits], WeightKingSafety[us]);
- ei.mgValue -= sign * v;
- if(us == p.side_to_move())
- ei.futilityMargin += v;
+ // King shelter
+ if (relative_rank(Us, ksq) <= RANK_4)
+ {
+ shelter = ei.pi->get_king_shelter(pos, Us, ksq);
+ ei.value += Sign[Us] * make_score(shelter, 0);
+ }
+
+ // King safety. This is quite complicated, and is almost certainly far
+ // from optimally tuned.
+ if ( pos.piece_count(Them, QUEEN) >= 1
+ && ei.kingAttackersCount[Them] >= 2
+ && pos.non_pawn_material(Them) >= QueenValueMidgame + RookValueMidgame
+ && ei.kingAdjacentZoneAttacksCount[Them])
+ {
+ // Is it the attackers turn to move?
+ sente = (Them == pos.side_to_move());
+
+ // Find the attacked squares around the king which has no defenders
+ // apart from the king itself
+ undefended = ei.attacked_by(Them) & ei.attacked_by(Us, KING);
+ undefended &= ~( ei.attacked_by(Us, PAWN) | ei.attacked_by(Us, KNIGHT)
+ | ei.attacked_by(Us, BISHOP) | ei.attacked_by(Us, ROOK)
+ | ei.attacked_by(Us, QUEEN));
+
+ // Initialize the 'attackUnits' variable, which is used later on as an
+ // index to the KingDangerTable[] array. The initial value is based on
+ // the number and types of the enemy's attacking pieces, the number of
+ // attacked and undefended squares around our king, the square of the
+ // king, and the quality of the pawn shelter.
+ attackUnits = Min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
+ + 3 * (ei.kingAdjacentZoneAttacksCount[Them] + count_1s_max_15<HasPopCnt>(undefended))
+ + InitKingDanger[relative_square(Us, ksq)]
+ - shelter / 32;
+
+ // Analyse enemy's safe queen contact checks. First find undefended
+ // squares around the king attacked by enemy queen...
+ b = undefended & ei.attacked_by(Them, QUEEN) & ~pos.pieces_of_color(Them);
+ if (b)
+ {
+ // ...then remove squares not supported by another enemy piece
+ b &= ( ei.attacked_by(Them, PAWN) | ei.attacked_by(Them, KNIGHT)
+ | ei.attacked_by(Them, BISHOP) | ei.attacked_by(Them, ROOK));
+ if (b)
+ attackUnits += QueenContactCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente ? 2 : 1);
+ }
+
+ // Analyse enemy's safe distance checks for sliders and knights
+ safe = ~(pos.pieces_of_color(Them) | ei.attacked_by(Us));
+
+ b1 = pos.attacks_from<ROOK>(ksq) & safe;
+ b2 = pos.attacks_from<BISHOP>(ksq) & safe;
+
+ // Enemy queen safe checks
+ b = (b1 | b2) & ei.attacked_by(Them, QUEEN);
+ if (b)
+ attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b);
+
+ // Enemy rooks safe checks
+ b = b1 & ei.attacked_by(Them, ROOK);
+ if (b)
+ attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b);
+
+ // Enemy bishops safe checks
+ b = b2 & ei.attacked_by(Them, BISHOP);
+ if (b)
+ attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b);
+
+ // Enemy knights safe checks
+ b = pos.attacks_from<KNIGHT>(ksq) & ei.attacked_by(Them, KNIGHT) & safe;
+ if (b)
+ attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b);
+
+ // To index KingDangerTable[] attackUnits must be in [0, 99] range
+ attackUnits = Min(99, Max(0, attackUnits));
+
+ // Finally, extract the king danger score from the KingDangerTable[]
+ // array and subtract the score from evaluation. Set also ei.kingDanger[]
+ // value that will be used for pruning because this value can sometimes
+ // be very big, and so capturing a single attacking piece can therefore
+ // result in a score change far bigger than the value of the captured piece.
+ ei.value -= Sign[Us] * KingDangerTable[Us][attackUnits];
+ ei.kingDanger[Us] = mg_value(KingDangerTable[Us][attackUnits]);