};
// Pawn storm open file bonuses by file
- const int16_t KStormOpenFileBonus[8] = { 31, 31, 18, 0, 0, 0, 0, 0 };
- const int16_t QStormOpenFileBonus[8] = { 0, 0, 0, 0, 0, 26, 42, 26 };
+ const int16_t QStormOpenFileBonus[8] = { 31, 31, 18, 0, 0, 0, 0, 0 };
+ const int16_t KStormOpenFileBonus[8] = { 0, 0, 0, 0, 0, 26, 42, 26 };
// Pawn storm lever bonuses by file
const int StormLeverBonus[8] = { -8, -8, -13, 0, 0, -13, -8, -8 };
/// PawnInfoTable c'tor and d'tor instantiated one each thread
-PawnInfoTable::PawnInfoTable(unsigned numOfEntries) : size(numOfEntries) {
+PawnInfoTable::PawnInfoTable() {
+
+ entries = new PawnInfo[PawnTableSize];
- entries = new PawnInfo[size];
if (!entries)
{
- std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
+ std::cerr << "Failed to allocate " << (PawnTableSize * sizeof(PawnInfo))
<< " bytes for pawn hash table." << std::endl;
Application::exit_with_failure();
}
}
-/// PawnInfo::clear() resets to zero the PawnInfo entry. Note that
-/// kingSquares[] is initialized to SQ_NONE instead.
-
-void PawnInfo::clear() {
-
- memset(this, 0, sizeof(PawnInfo));
- kingSquares[WHITE] = kingSquares[BLACK] = SQ_NONE;
-}
-
-
/// PawnInfoTable::get_pawn_info() takes a position object as input, computes
/// a PawnInfo object, and returns a pointer to it. The result is also stored
/// in a hash table, so we don't have to recompute everything when the same
assert(pos.is_ok());
Key key = pos.get_pawn_key();
- int index = int(key & (size - 1));
+ unsigned index = unsigned(key & (PawnTableSize - 1));
PawnInfo* pi = entries + index;
// If pi->key matches the position's pawn hash key, it means that we
return pi;
// Clear the PawnInfo object, and set the key
- pi->clear();
+ memset(pi, 0, sizeof(PawnInfo));
+ pi->kingSquares[WHITE] = pi->kingSquares[BLACK] = SQ_NONE;
pi->key = key;
// Calculate pawn attacks
Rank r;
int bonus;
bool passed, isolated, doubled, opposed, chain, backward, candidate;
- Score value = make_score(0, 0);
+ Score value = SCORE_ZERO;
const Square* ptr = pos.piece_list_begin(Us, PAWN);
// Initialize pawn storm scores by giving bonuses for open files
pi->qsStormValue[Us] += QStormTable[relative_square(Us, s)] + bonus;
// Our rank plus previous one. Used for chain detection.
- b = rank_bb(r) | rank_bb(r + (Us == WHITE ? -1 : 1));
+ b = rank_bb(r) | rank_bb(Us == WHITE ? r - Rank(1) : r + Rank(1));
// Passed, isolated, doubled or member of a pawn
// chain (but not the backward one) ?
// Test for backward pawn
//
+ backward = false;
+
// If the pawn is passed, isolated, or member of a pawn chain
// it cannot be backward. If can capture an enemy pawn or if
// there are friendly pawns behind on neighboring files it cannot
// be backward either.
- if ( (passed | isolated | chain)
- || (ourPawns & outpost_mask(opposite_color(Us), s))
- || (pos.attacks_from<PAWN>(s, Us) & theirPawns))
- backward = false;
- else
+ if ( !(passed | isolated | chain)
+ && !(ourPawns & attack_span_mask(opposite_color(Us), s))
+ && !(pos.attacks_from<PAWN>(s, Us) & theirPawns))
{
// We now know that there are no friendly pawns beside or behind this
// pawn on neighboring files. We now check whether the pawn is
backward = (b | (Us == WHITE ? b << 8 : b >> 8)) & theirPawns;
}
+ assert(passed | opposed | (attack_span_mask(Us, s) & theirPawns));
+
// Test for candidate passed pawn
- candidate = !passed
- && !opposed
- && ( count_1s_max_15(neighboring_files_bb(f) & (behind_bb(Us, r) | rank_bb(r)) & ourPawns)
- - count_1s_max_15(neighboring_files_bb(f) & in_front_bb(Us, r) & theirPawns)
- >= 0);
+ candidate = !(opposed | passed)
+ && (b = attack_span_mask(opposite_color(Us), s + pawn_push(Us)) & ourPawns) != EmptyBoardBB
+ && count_1s_max_15(b) >= count_1s_max_15(attack_span_mask(Us, s) & theirPawns);
// In order to prevent doubled passed pawns from receiving a too big
// bonus, only the frontmost passed pawn on each file is considered as
// Mark the pawn as passed. Pawn will be properly scored in evaluation
// because we need full attack info to evaluate passed pawns.
if (passed)
- set_bit(&(pi->passedPawns), s);
+ set_bit(&(pi->passedPawns[Us]), s);
// Score this pawn
if (isolated)
{
value -= IsolatedPawnPenalty[f];
- if (!(theirPawns & file_bb(f)))
+ if (!opposed)
value -= IsolatedPawnPenalty[f] / 2;
}
if (doubled)
if (backward)
{
value -= BackwardPawnPenalty[f];
- if (!(theirPawns & file_bb(f)))
+ if (!opposed)
value -= BackwardPawnPenalty[f] / 2;
}
if (chain)
const int K = (Side == KingSide ? 2 : 4);
const File RookFile = (Side == KingSide ? FILE_H : FILE_A);
- Bitboard b = outpost_mask(Us, s) & theirPawns & StormFilesBB;
+ Bitboard b = attack_span_mask(Us, s) & theirPawns & StormFilesBB;
int bonus = 0;
while (b)
/// PawnInfo::updateShelter calculates and caches king shelter. It is called
-/// only when king square changes, about 20% of total get_king_shelter() calls.
-int PawnInfo::updateShelter(const Position& pos, Color c, Square ksq) {
+/// only when king square changes, about 20% of total king_shelter() calls.
+Score PawnInfo::updateShelter(const Position& pos, Color c, Square ksq) {
- Bitboard pawns = pos.pieces(PAWN, c) & this_and_neighboring_files_bb(ksq);
- unsigned shelter = 0;
- unsigned r = ksq & (7 << 3);
+ Bitboard pawns;
+ unsigned r, k, shelter = 0;
- for (int i = 1, k = (c ? -8 : 8); i < 4; i++)
+ if (relative_rank(c, ksq) <= RANK_4)
{
- r += k;
- shelter += BitCount8Bit[(pawns >> r) & 0xFF] * (128 >> i);
+ pawns = pos.pieces(PAWN, c) & this_and_neighboring_files_bb(ksq);
+ r = ksq & (7 << 3);
+ k = (c ? -8 : 8);
+ for (int i = 1; i < 4; i++)
+ {
+ r += k;
+ shelter += BitCount8Bit[(pawns >> r) & 0xFF] * (128 >> i);
+ }
}
kingSquares[c] = ksq;
- kingShelters[c] = shelter;
- return shelter;
+ kingShelters[c] = make_score(shelter, 0);
+ return kingShelters[c];
}
projects / stockfish / blobdiff