kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-05-01 01:03:09 +00:00
Code Issues Releases Wiki Activity

Space inflate pawns.cpp

Browse source 
Hopefully no functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2008-12-09 16:46:10 +01:00
parent aaad48464b
commit 67aac4889e
2 changed files with 214 additions and 210 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

396
src/pawns.cpp
View file

@ -86,14 +86,14 @@ namespace {
// Candidate passed pawn bonus by rank, middle game. // Candidate passed pawn bonus by rank, middle game.
const Value CandidateMidgameBonus[8] = { const Value CandidateMidgameBonus[8] = {
Value(0), Value(12), Value(12), Value(20), Value( 0), Value(12), Value(12), Value(20),
Value(40), Value(90), Value(0), Value(0) Value(40), Value(90), Value( 0), Value( 0)
}; };
// Candidate passed pawn bonus by rank, endgame. // Candidate passed pawn bonus by rank, endgame.
const Value CandidateEndgameBonus[8] = { const Value CandidateEndgameBonus[8] = {
Value(0), Value(24), Value(24), Value(40), Value( 0), Value(24), Value(24), Value(40),
Value(80), Value(180), Value(0), Value(0) Value(80), Value(180), Value(0), Value( 0)
}; };
// Evaluate pawn storms? // Evaluate pawn storms?
@ -101,25 +101,25 @@ namespace {
// Pawn storm tables for positions with opposite castling: // Pawn storm tables for positions with opposite castling:
const int QStormTable[64] = { const int QStormTable[64] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-22, -22, -22, -13, -4, 0, 0, 0, -22,-22,-22,-13,-4, 0, 0, 0,
-4, -9, -9, -9, -4, 0, 0, 0, -4, -9, -9, -9,-4, 0, 0, 0,
9, 18, 22, 18, 9, 0, 0, 0, 9, 18, 22, 18, 9, 0, 0, 0,
22, 31, 31, 22, 0, 0, 0, 0, 22, 31, 31, 22, 0, 0, 0, 0,
31, 40, 40, 31, 0, 0, 0, 0, 31, 40, 40, 31, 0, 0, 0, 0,
31, 40, 40, 31, 0, 0, 0, 0, 31, 40, 40, 31, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0 0, 0, 0, 0, 0, 0, 0, 0
}; };
const int KStormTable[64] = { const int KStormTable[64] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, -4, -13, -22, -27, -27, 0, 0, 0,-4,-13,-22,-27,-27,
0, 0, 0, -4, -9, -13, -18, -18, 0, 0, 0,-4, -9,-13,-18,-18,
0, 0, 0, 0, 9, 9, 9, 9, 0, 0, 0, 0, 9, 9, 9, 9,
0, 0, 0, 0, 9, 18, 27, 27, 0, 0, 0, 0, 9, 18, 27, 27,
0, 0, 0, 0, 9, 27, 40, 36, 0, 0, 0, 0, 9, 27, 40, 36,
0, 0, 0, 0, 0, 31, 40, 31, 0, 0, 0, 0, 0, 31, 40, 31,
0, 0, 0, 0, 0, 0, 0, 0 0, 0, 0, 0, 0, 0, 0, 0
}; };
// Pawn storm open file bonuses by file: // Pawn storm open file bonuses by file:
@ -141,14 +141,16 @@ namespace {
/// Constructor /// Constructor
PawnInfoTable::PawnInfoTable(unsigned numOfEntries) { PawnInfoTable::PawnInfoTable(unsigned numOfEntries) {
size = numOfEntries; size = numOfEntries;
entries = new PawnInfo[size]; entries = new PawnInfo[size];
if(entries == NULL) { if (entries == NULL)
std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo)) {
<< " bytes for pawn hash table." << std::endl; std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
exit(EXIT_FAILURE); << " bytes for pawn hash table." << std::endl;
exit(EXIT_FAILURE);
} }
this->clear(); clear();
} }
@ -173,6 +175,7 @@ void PawnInfoTable::clear() {
/// the same pawn structure occurs again. /// the same pawn structure occurs again.
PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) { PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
assert(pos.is_ok()); assert(pos.is_ok());
Key key = pos.get_pawn_key(); Key key = pos.get_pawn_key();
@ -181,207 +184,208 @@ PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
// If pi->key matches the position's pawn hash key, it means that we // If pi->key matches the position's pawn hash key, it means that we
// have analysed this pawn structure before, and we can simply return the // have analysed this pawn structure before, and we can simply return the
// information we found the last time instead of recomputing it: // information we found the last time instead of recomputing it
if(pi->key == key) if (pi->key == key)
return pi; return pi;
// Clear the PawnInfo object, and set the key: // Clear the PawnInfo object, and set the key
pi->clear(); pi->clear();
pi->key = key; pi->key = key;
Value mgValue[2] = {Value(0), Value(0)}; Value mgValue[2] = {Value(0), Value(0)};
Value egValue[2] = {Value(0), Value(0)}; Value egValue[2] = {Value(0), Value(0)};
// Loop through the pawns for both colors: // Loop through the pawns for both colors
for(Color us = WHITE; us <= BLACK; us++) { for (Color us = WHITE; us <= BLACK; us++)
{
Color them = opposite_color(us); Color them = opposite_color(us);
Bitboard ourPawns = pos.pawns(us); Bitboard ourPawns = pos.pawns(us);
Bitboard theirPawns = pos.pawns(them); Bitboard theirPawns = pos.pawns(them);
Bitboard pawns = ourPawns; Bitboard pawns = ourPawns;
// Initialize pawn storm scores by giving bonuses for open files: // Initialize pawn storm scores by giving bonuses for open files
if(EvaluatePawnStorms) if (EvaluatePawnStorms)
for(File f = FILE_A; f <= FILE_H; f++) for(File f = FILE_A; f <= FILE_H; f++)
if(pos.file_is_half_open(us, f)) { if(pos.file_is_half_open(us, f))
pi->ksStormValue[us] += KStormOpenFileBonus[f]; {
pi->qsStormValue[us] += QStormOpenFileBonus[f]; pi->ksStormValue[us] += KStormOpenFileBonus[f];
pi->qsStormValue[us] += QStormOpenFileBonus[f];
}
// Loop through all pawns of the current color and score each pawn
while (pawns)
{
bool passed, doubled, isolated, backward, chain, candidate;
Square s = pop_1st_bit(&pawns);
File f = square_file(s);
Rank r = square_rank(s);
assert(pos.piece_on(s) == pawn_of_color(us));
// The file containing the pawn is not half open
pi->halfOpenFiles[us] &= ~(1 << f);
// Passed, isolated or doubled pawn?
passed = pos.pawn_is_passed(us, s);
isolated = pos.pawn_is_isolated(us, s);
doubled = pos.pawn_is_doubled(us, s);
if (EvaluatePawnStorms)
{
// We calculate kingside and queenside pawn storm scores
// for both colors. These are used when evaluating middle
// game positions with opposite side castling.
//
// Each pawn is given a base score given by a piece square table
// (KStormTable[] or QStormTable[]). This score is increased if
// there are enemy pawns on adjacent files in front of the pawn.
// This is because we want to be able to open files against the
// enemy king, and to avoid blocking the pawn structure (e.g. white
// pawns on h6, g5, black pawns on h7, g6, f7).
// Kingside and queenside pawn storms
bool outPost = (outpost_mask(us, s) & theirPawns);
bool passed = (passed_pawn_mask(us, s) & theirPawns);
int KBonus = KStormTable[relative_square(us, s)];
int QBonus = QStormTable[relative_square(us, s)];
switch (f) {
case FILE_A:
QBonus += passed * QBonus / 4;
break;
case FILE_B:
QBonus += passed * (QBonus / 2 + QBonus / 4);
break;
case FILE_C:
QBonus += passed * QBonus / 2;
break;
case FILE_F:
KBonus += outPost * KBonus / 4;
break;
case FILE_G:
KBonus += outPost * (KBonus / 2 + KBonus / 4);
break;
case FILE_H:
KBonus += outPost * KBonus / 2;
break;
default:
break;
}
pi->ksStormValue[us] += KBonus;
pi->qsStormValue[us] += QBonus;
} }
// Loop through all pawns of the current color and score each pawn: // Member of a pawn chain (but not the backward one)? We could speed up
while(pawns) { // the test a little by introducing an array of masks indexed by color
Square s = pop_1st_bit(&pawns); // and square for doing the test, but because everything is hashed,
File f = square_file(s); // it probably won't make any noticable difference.
Rank r = square_rank(s); chain = ourPawns
bool passed, doubled, isolated, backward, chain, candidate; & neighboring_files_bb(f)
int bonus; & (rank_bb(r) | rank_bb(r - (us == WHITE ? 1 : -1)));
assert(pos.piece_on(s) == pawn_of_color(us)); // Test for backward pawn
// The file containing the pawn is not half open:
pi->halfOpenFiles[us] &= ~(1 << f);
// Passed, isolated or doubled pawn?
passed = pos.pawn_is_passed(us, s);
isolated = pos.pawn_is_isolated(us, s);
doubled = pos.pawn_is_doubled(us, s);
if(EvaluatePawnStorms) {
// We calculate kingside and queenside pawn storm
// scores for both colors. These are used when evaluating
// middle game positions with opposite side castling.
// //
// Each pawn is given a base score given by a piece square table // If the pawn is passed, isolated, or member of a pawn chain
// (KStormTable[] or QStormTable[]). This score is increased if // it cannot be backward. If can capture an enemy pawn or if
// there are enemy pawns on adjacent files in front of the pawn. // there are friendly pawns behind on neighboring files it cannot
// This is because we want to be able to open files against the // be backward either.
// enemy king, and to avoid blocking the pawn structure (e.g. white if ( passed
// pawns on h6, g5, black pawns on h7, g6, f7). || isolated
|| chain
// Kingside pawn storms: || (pos.pawn_attacks(us, s) & theirPawns)
bonus = KStormTable[relative_square(us, s)]; || (ourPawns & in_front_bb(them, r) & neighboring_files_bb(f)))
if(bonus > 0 && outpost_mask(us, s) & theirPawns) { backward = false;
switch(f) { else
{
case FILE_F: // We now know that there are no friendly pawns beside or behind this
bonus += bonus / 4; // pawn on neighboring files. We now check whether the pawn is
break; // backward by looking in the forward direction on the neighboring
// files, and seeing whether we meet a friendly or an enemy pawn first.
case FILE_G: Bitboard b;
bonus += bonus / 2 + bonus / 4; if (us == WHITE)
break; {
for (b = pos.pawn_attacks(us, s); !(b & (ourPawns | theirPawns)); b <<= 8);
case FILE_H: backward = (b | (b << 8)) & theirPawns;
bonus += bonus / 2; }
break; else
{
default: for (b = pos.pawn_attacks(us, s); !(b & (ourPawns | theirPawns)); b >>= 8);
break; backward = (b | (b >> 8)) & theirPawns;
} }
} }
pi->ksStormValue[us] += bonus;
// Queenside pawn storms: // Test for candidate passed pawn
bonus = QStormTable[relative_square(us, s)]; candidate = !passed
if(bonus > 0 && passed_pawn_mask(us, s) & theirPawns) { && pos.file_is_half_open(them, f)
switch(f) { && ( count_1s_max_15(neighboring_files_bb(f) & (in_front_bb(them, r) | rank_bb(r)) & ourPawns)
- count_1s_max_15(neighboring_files_bb(f) & in_front_bb(us, r) & theirPawns)
>= 0);
case FILE_A: // In order to prevent doubled passed pawns from receiving a too big
bonus += bonus / 2; // bonus, only the frontmost passed pawn on each file is considered as
break; // a true passed pawn.
if (passed && (ourPawns & squares_in_front_of(us, s)))
case FILE_B: {
bonus += bonus / 2 + bonus / 4; // candidate = true;
break; passed = false;
case FILE_C:
bonus += bonus / 2;
break;
default:
break;
}
} }
pi->qsStormValue[us] += bonus;
}
// Member of a pawn chain? We could speed up the test a little by // Score this pawn
// introducing an array of masks indexed by color and square for doing Value mv = Value(0), ev = Value(0);
// the test, but because everything is hashed, it probably won't make if (isolated)
// any noticable difference. {
chain = (us == WHITE)? mv -= IsolatedPawnMidgamePenalty[f];
(ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r-1))) : ev -= IsolatedPawnEndgamePenalty[f];
(ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r+1))); if (pos.file_is_half_open(them, f))
{
mv -= IsolatedPawnMidgamePenalty[f] / 2;
// Test for backward pawn. ev -= IsolatedPawnEndgamePenalty[f] / 2;
}
// If the pawn is isolated, passed, or member of a pawn chain, it cannot
// be backward:
if(passed || isolated || chain)
backward = false;
// If the pawn can capture an enemy pawn, it's not backward:
else if(pos.pawn_attacks(us, s) & theirPawns)
backward = false;
// Check for friendly pawns behind on neighboring files:
else if(ourPawns & in_front_bb(them, r) & neighboring_files_bb(f))
backward = false;
else {
// We now know that there is no friendly pawns beside or behind this
// pawn on neighboring files. We now check whether the pawn is
// backward by looking in the forward direction on the neighboring
// files, and seeing whether we meet a friendly or an enemy pawn first.
Bitboard b;
if(us == WHITE) {
for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b<<=8);
backward = (b | (b << 8)) & theirPawns;
} }
else { if (doubled)
for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b>>=8); {
backward = (b | (b >> 8)) & theirPawns; mv -= DoubledPawnMidgamePenalty[f];
ev -= DoubledPawnEndgamePenalty[f];
} }
} if (backward)
{
// Test for candidate passed pawn. mv -= BackwardPawnMidgamePenalty[f];
candidate = ev -= BackwardPawnEndgamePenalty[f];
(!passed && pos.file_is_half_open(them, f) && if (pos.file_is_half_open(them, f))
count_1s_max_15(neighboring_files_bb(f) {
& (in_front_bb(them, r) | rank_bb(r)) mv -= BackwardPawnMidgamePenalty[f] / 2;
& ourPawns) ev -= BackwardPawnEndgamePenalty[f] / 2;
- count_1s_max_15(neighboring_files_bb(f) & in_front_bb(us, r) }
& theirPawns)
>= 0);
// In order to prevent doubled passed pawns from receiving a too big
// bonus, only the frontmost passed pawn on each file is considered as
// a true passed pawn.
if(passed && (ourPawns & squares_in_front_of(us, s))) {
// candidate = true;
passed = false;
}
// Score this pawn:
Value mv = Value(0), ev = Value(0);
if(isolated) {
mv -= IsolatedPawnMidgamePenalty[f];
ev -= IsolatedPawnEndgamePenalty[f];
if(pos.file_is_half_open(them, f)) {
mv -= IsolatedPawnMidgamePenalty[f] / 2;
ev -= IsolatedPawnEndgamePenalty[f] / 2;
} }
} if (chain)
if(doubled) { {
mv -= DoubledPawnMidgamePenalty[f]; mv += ChainMidgameBonus[f];
ev -= DoubledPawnEndgamePenalty[f]; ev += ChainEndgameBonus[f];
} }
if(backward) { if (candidate)
mv -= BackwardPawnMidgamePenalty[f]; {
ev -= BackwardPawnEndgamePenalty[f]; mv += CandidateMidgameBonus[relative_rank(us, s)];
if(pos.file_is_half_open(them, f)) { ev += CandidateEndgameBonus[relative_rank(us, s)];
mv -= BackwardPawnMidgamePenalty[f] / 2;
ev -= BackwardPawnEndgamePenalty[f] / 2;
} }
}
if(chain) {
mv += ChainMidgameBonus[f];
ev += ChainEndgameBonus[f];
}
if(candidate) {
mv += CandidateMidgameBonus[relative_rank(us, s)];
ev += CandidateEndgameBonus[relative_rank(us, s)];
}
mgValue[us] += mv; mgValue[us] += mv;
egValue[us] += ev; egValue[us] += ev;
// If the pawn is passed, set the square of the pawn in the passedPawns // If the pawn is passed, set the square of the pawn in the passedPawns
// bitboard: // bitboard
if(passed) if (passed)
set_bit(&(pi->passedPawns), s); set_bit(&(pi->passedPawns), s);
} } // while(pawns)
} } // for(colors)
pi->mgValue = int16_t(mgValue[WHITE] - mgValue[BLACK]); pi->mgValue = int16_t(mgValue[WHITE] - mgValue[BLACK]);
pi->egValue = int16_t(egValue[WHITE] - egValue[BLACK]); pi->egValue = int16_t(egValue[WHITE] - egValue[BLACK]);
return pi; return pi;
} }

8
src/pawns.h
View file

@ -120,10 +120,10 @@ inline bool PawnInfo::has_open_file_to_right(Color c, File f) const {
} }
inline void PawnInfo::clear() { inline void PawnInfo::clear() {
mgValue = egValue = 0;
passedPawns = EmptyBoardBB; Key k = key;
ksStormValue[WHITE] = ksStormValue[BLACK] = 0; memset(this, 0, sizeof(PawnInfo));
qsStormValue[WHITE] = qsStormValue[BLACK] = 0; key = k;
halfOpenFiles[WHITE] = halfOpenFiles[BLACK] = 0xFF; halfOpenFiles[WHITE] = halfOpenFiles[BLACK] = 0xFF;
} }