#include <cassert>
#include <cstring>
+#include "bitcount.h"
#include "evaluate.h"
#include "material.h"
#include "pawns.h"
namespace {
- const int Sign[2] = {1, -1};
+ const int Sign[2] = { 1, -1 };
- // Evaluation grain size, must be a power of 2.
+ // Evaluation grain size, must be a power of 2
const int GrainSize = 4;
- // Evaluation weights
- int WeightMobilityMidgame = 0x100;
- int WeightMobilityEndgame = 0x100;
- int WeightPawnStructureMidgame = 0x100;
- int WeightPawnStructureEndgame = 0x100;
- int WeightPassedPawnsMidgame = 0x100;
- int WeightPassedPawnsEndgame = 0x100;
- int WeightKingSafety[2] = { 0x100, 0x100 };
+ // Evaluation weights, initialized from UCI options
+ int WeightMobilityMidgame, WeightMobilityEndgame;
+ int WeightPawnStructureMidgame, WeightPawnStructureEndgame;
+ int WeightPassedPawnsMidgame, WeightPassedPawnsEndgame;
+ int WeightKingSafety[2];
int WeightSpace;
- // Internal evaluation weights. These are applied on top of the evaluation
- // weights read from UCI parameters. The purpose is to be able to change
+ // Internal evaluation weights. These are applied on top of the evaluation
+ // weights read from UCI parameters. The purpose is to be able to change
// the evaluation weights while keeping the default values of the UCI
// parameters at 100, which looks prettier.
//
};
// Bishop mobility bonus in middle game and endgame, indexed by the number
- // of attacked squares not occupied by friendly pieces. X-ray attacks through
+ // of attacked squares not occupied by friendly pieces. X-ray attacks through
// queens are also included.
const Value MidgameBishopMobilityBonus[] = {
// 0 1 2 3 4 5 6 7
};
// Rook mobility bonus in middle game and endgame, indexed by the number
- // of attacked squares not occupied by friendly pieces. X-ray attacks through
+ // of attacked squares not occupied by friendly pieces. X-ray attacks through
// queens and rooks are also included.
const Value MidgameRookMobilityBonus[] = {
// 0 1 2 3 4 5 6 7
const Value MidgameQueenOn7thBonus = Value(27);
const Value EndgameQueenOn7thBonus = Value(54);
-
// Rooks on open files
const Value RookOpenFileBonus = Value(43);
const Value RookHalfOpenFileBonus = Value(19);
// Penalty for rooks trapped inside a friendly king which has lost the
- // right to castle:
+ // right to castle.
const Value TrappedRookPenalty = Value(180);
// Penalty for a bishop on a7/h7 (a2/h2 for black) which is trapped by
- // enemy pawns:
+ // enemy pawns.
const Value TrappedBishopA7H7Penalty = Value(300);
- // Bitboard masks for detecting trapped bishops on a7/h7 (a2/h2 for black):
+ // Bitboard masks for detecting trapped bishops on a7/h7 (a2/h2 for black)
const Bitboard MaskA7H7[2] = {
((1ULL << SQ_A7) | (1ULL << SQ_H7)),
((1ULL << SQ_A2) | (1ULL << SQ_H2))
};
// Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
- // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
+ // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
// happen in Chess960 games.
const Value TrappedBishopA1H1Penalty = Value(100);
- // Bitboard masks for detecting trapped bishops on a1/h1 (a8/h8 for black):
+ // Bitboard masks for detecting trapped bishops on a1/h1 (a8/h8 for black)
const Bitboard MaskA1H1[2] = {
((1ULL << SQ_A1) | (1ULL << SQ_H1)),
((1ULL << SQ_A8) | (1ULL << SQ_H8))
};
// The SpaceMask[color] contains area of the board which is consdered by
- // the space evaluation. In the middle game, each side is given a bonus
+ // 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
// friendly minor pieces.
const Bitboard SpaceMask[2] = {
(1ULL<<SQ_C5) | (1ULL<<SQ_D5) | (1ULL<<SQ_E5) | (1ULL<<SQ_F5)
};
- /// King safety constants and variables. The king safety scores are taken
- /// from the array SafetyTable[]. Various little "meta-bonuses" measuring
+ /// King safety constants and variables. The king safety scores are taken
+ /// from the array SafetyTable[]. Various little "meta-bonuses" measuring
/// the strength of the attack are added up into an integer, which is used
/// as an index to SafetyTable[].
- // Attack weights for each piece type.
+ // Attack weights for each piece type
const int QueenAttackWeight = 5;
const int RookAttackWeight = 3;
const int BishopAttackWeight = 2;
const int KnightAttackWeight = 2;
- // Bonuses for safe checks for each piece type.
- int QueenContactCheckBonus = 3;
- int QueenCheckBonus = 2;
- int RookCheckBonus = 1;
- int BishopCheckBonus = 1;
- int KnightCheckBonus = 1;
- int DiscoveredCheckBonus = 3;
+ // Bonuses for safe checks, initialized from UCI options
+ int QueenContactCheckBonus, DiscoveredCheckBonus;
+ int QueenCheckBonus, RookCheckBonus, BishopCheckBonus, KnightCheckBonus;
// Scan for queen contact mates?
const bool QueenContactMates = true;
- // Bonus for having a mate threat.
- int MateThreatBonus = 3;
+ // Bonus for having a mate threat, initialized from UCI options
+ int MateThreatBonus;
// InitKingDanger[] contains bonuses based on the position of the defending
// king.
15, 15, 15, 15, 15, 15, 15, 15
};
- // SafetyTable[] contains the actual king safety scores. It is initialized
+ // SafetyTable[] contains the actual king safety scores. It is initialized
// in init_safety().
Value SafetyTable[100];
// Pawn and material hash tables, indexed by the current thread id
- PawnInfoTable *PawnTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
- MaterialInfoTable *MaterialTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+ PawnInfoTable* PawnTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+ MaterialInfoTable* MaterialTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
// Sizes of pawn and material hash tables
const int PawnTableSize = 16384;
const int MaterialTableSize = 1024;
- // Array which gives the number of nonzero bits in an 8-bit integer:
+ // Array which gives the number of nonzero bits in an 8-bit integer
uint8_t BitCount8Bit[256];
// Function prototypes
inline Value apply_weight(Value v, int w);
Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]);
- int count_1s_8bit(Bitboard b);
-
int compute_weight(int uciWeight, int internalWeight);
int weight_option(const std::string& opt, int weight);
void init_safety();
// Initialize pawn attack bitboards for both sides
ei.attackedBy[WHITE][PAWN] = ((pos.pawns(WHITE) << 9) & ~FileABB) | ((pos.pawns(WHITE) << 7) & ~FileHBB);
ei.attackedBy[BLACK][PAWN] = ((pos.pawns(BLACK) >> 7) & ~FileABB) | ((pos.pawns(BLACK) >> 9) & ~FileHBB);
- ei.kingAttackersCount[WHITE] = count_1s_max_15(ei.attackedBy[WHITE][PAWN] & ei.attackedBy[BLACK][KING])/2;
- ei.kingAttackersCount[BLACK] = count_1s_max_15(ei.attackedBy[BLACK][PAWN] & ei.attackedBy[WHITE][KING])/2;
+ ei.kingAttackersCount[WHITE] = count_1s_max_15<false>(ei.attackedBy[WHITE][PAWN] & ei.attackedBy[BLACK][KING])/2;
+ ei.kingAttackersCount[BLACK] = count_1s_max_15<false>(ei.attackedBy[BLACK][PAWN] & ei.attackedBy[WHITE][KING])/2;
// Evaluate pieces
for (Color c = WHITE; c <= BLACK; c++)
for (Bitboard b = 0ULL; b < 256ULL; b++)
{
- assert(count_1s(b) == int(uint8_t(count_1s(b))));
- BitCount8Bit[b] = (uint8_t)count_1s(b);
+ assert(count_1s<false>(b) == int(uint8_t(count_1s<false>(b))));
+ BitCount8Bit[b] = (uint8_t)count_1s<false>(b);
}
}
ei.kingAttackersWeight[us] += AttackWeight[Piece];
Bitboard bb = (b & ei.attackedBy[them][KING]);
if (bb)
- ei.kingAdjacentZoneAttacksCount[us] += count_1s_max_15(bb);
+ ei.kingAdjacentZoneAttacksCount[us] += count_1s_max_15<false>(bb);
}
// Remove squares protected by enemy pawns
Bitboard bb = (b & ~ei.attackedBy[them][PAWN]);
// Mobility
- int mob = (Piece != QUEEN ? count_1s_max_15(bb & ~p.pieces_of_color(us))
- : count_1s(bb & ~p.pieces_of_color(us)));
+ int mob = (Piece != QUEEN ? count_1s_max_15<false>(bb & ~p.pieces_of_color(us))
+ : count_1s<false>(bb & ~p.pieces_of_color(us)));
ei.mgMobility += Sign[us] * MgBonus[Piece][mob];
ei.egMobility += Sign[us] * EgBonus[Piece][mob];
// King shelter
if (relative_rank(us, s) <= RANK_4)
{
- Bitboard pawns = p.pawns(us) & this_and_neighboring_files_bb(s);
- Rank r = square_rank(s);
- for (int i = 1; i < 4; i++)
- shelter += count_1s_8bit(shiftRowsDown(pawns, r+i*sign)) * (128>>i);
-
+ // Shelter cache lookup
+ shelter = ei.pi->kingShelter(us, s);
+ if (shelter == -1)
+ {
+ shelter = 0;
+ Bitboard pawns = p.pawns(us) & this_and_neighboring_files_bb(s);
+ Rank r = square_rank(s);
+ for (int i = 1; i < 4; i++)
+ shelter += BitCount8Bit[shiftRowsDown(pawns, r+i*sign) & 0xFF] * (128 >> i);
+
+ // Cache shelter value in pawn info
+ ei.pi->setKingShelter(us, s, shelter);
+ }
ei.mgValue += sign * Value(shelter);
}
// quality of the pawn shelter.
int attackUnits =
Min((ei.kingAttackersCount[them] * ei.kingAttackersWeight[them]) / 2, 25)
- + (ei.kingAdjacentZoneAttacksCount[them] + count_1s_max_15(undefended)) * 3
+ + (ei.kingAdjacentZoneAttacksCount[them] + count_1s_max_15<false>(undefended)) * 3
+ InitKingDanger[relative_square(us, s)] - (shelter >> 5);
// Analyse safe queen contact checks
{
// The bitboard b now contains the squares available for safe queen
// contact checks.
- int count = count_1s_max_15(b);
+ int count = count_1s_max_15<false>(b);
attackUnits += QueenContactCheckBonus * count * (sente ? 2 : 1);
// Is there a mate threat?
// Queen checks
b2 = b & ei.attacked_by(them, QUEEN);
if( b2)
- attackUnits += QueenCheckBonus * count_1s_max_15(b2);
+ attackUnits += QueenCheckBonus * count_1s_max_15<false>(b2);
// Rook checks
b2 = b & ei.attacked_by(them, ROOK);
if (b2)
- attackUnits += RookCheckBonus * count_1s_max_15(b2);
+ attackUnits += RookCheckBonus * count_1s_max_15<false>(b2);
}
if (QueenCheckBonus > 0 || BishopCheckBonus > 0)
{
// Queen checks
b2 = b & ei.attacked_by(them, QUEEN);
if (b2)
- attackUnits += QueenCheckBonus * count_1s_max_15(b2);
+ attackUnits += QueenCheckBonus * count_1s_max_15<false>(b2);
// Bishop checks
b2 = b & ei.attacked_by(them, BISHOP);
if (b2)
- attackUnits += BishopCheckBonus * count_1s_max_15(b2);
+ attackUnits += BishopCheckBonus * count_1s_max_15<false>(b2);
}
if (KnightCheckBonus > 0)
{
// Knight checks
b2 = b & ei.attacked_by(them, KNIGHT);
if (b2)
- attackUnits += KnightCheckBonus * count_1s_max_15(b2);
+ attackUnits += KnightCheckBonus * count_1s_max_15<false>(b2);
}
// Analyse discovered checks (only for non-pawns right now, consider
{
b = p.discovered_check_candidates(them) & ~p.pawns();
if (b)
- attackUnits += DiscoveredCheckBonus * count_1s_max_15(b) * (sente? 2 : 1);
+ attackUnits += DiscoveredCheckBonus * count_1s_max_15<false>(b) * (sente? 2 : 1);
}
// Has a mate threat been found? We don't do anything here if the
if (d < 0)
{
int mtg = RANK_8 - relative_rank(us, s);
- int blockerCount = count_1s_max_15(squares_in_front_of(us,s) & pos.occupied_squares());
+ int blockerCount = count_1s_max_15<false>(squares_in_front_of(us,s) & pos.occupied_squares());
mtg += blockerCount;
d += blockerCount;
if (d < 0)
behindFriendlyPawns |= (behindFriendlyPawns << 16);
}
- int space = count_1s_max_15(safeSquares)
- + count_1s_max_15(behindFriendlyPawns & safeSquares);
+ int space = count_1s_max_15<false>(safeSquares)
+ + count_1s_max_15<false>(behindFriendlyPawns & safeSquares);
ei.mgValue += Sign[us] * apply_weight(Value(space * ei.mi->space_weight()), WeightSpace);
}
}
- // count_1s_8bit() counts the number of nonzero bits in the 8 least
- // significant bits of a Bitboard. This function is used by the king
- // shield evaluation.
-
- int count_1s_8bit(Bitboard b) {
- return int(BitCount8Bit[b & 0xFF]);
- }
-
-
// compute_weight() computes the value of an evaluation weight, by combining
// an UCI-configurable weight with an internal weight.
projects / stockfish / blobdiff