kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-05-01 09:13:08 +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

214
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?
@ -102,8 +102,8 @@ 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,
@ -113,8 +113,8 @@ namespace {
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,
@ -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)) std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
<< " bytes for pawn hash table." << std::endl; << " bytes for pawn hash table." << std::endl;
exit(EXIT_FAILURE); 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,43 +184,45 @@ 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->ksStormValue[us] += KStormOpenFileBonus[f];
pi->qsStormValue[us] += QStormOpenFileBonus[f]; pi->qsStormValue[us] += QStormOpenFileBonus[f];
} }
// Loop through all pawns of the current color and score each pawn: // Loop through all pawns of the current color and score each pawn
while(pawns) { while (pawns)
{
bool passed, doubled, isolated, backward, chain, candidate;
Square s = pop_1st_bit(&pawns); Square s = pop_1st_bit(&pawns);
File f = square_file(s); File f = square_file(s);
Rank r = square_rank(s); Rank r = square_rank(s);
bool passed, doubled, isolated, backward, chain, candidate;
int bonus;
assert(pos.piece_on(s) == pawn_of_color(us)); assert(pos.piece_on(s) == pawn_of_color(us));
// The file containing the pawn is not half open: // The file containing the pawn is not half open
pi->halfOpenFiles[us] &= ~(1 << f); pi->halfOpenFiles[us] &= ~(1 << f);
// Passed, isolated or doubled pawn? // Passed, isolated or doubled pawn?
@ -225,10 +230,11 @@ PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
isolated = pos.pawn_is_isolated(us, s); isolated = pos.pawn_is_isolated(us, s);
doubled = pos.pawn_is_doubled(us, s); doubled = pos.pawn_is_doubled(us, s);
if(EvaluatePawnStorms) { if (EvaluatePawnStorms)
// We calculate kingside and queenside pawn storm {
// scores for both colors. These are used when evaluating // We calculate kingside and queenside pawn storm scores
// middle game positions with opposite side castling. // 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 // Each pawn is given a base score given by a piece square table
// (KStormTable[] or QStormTable[]). This score is increased if // (KStormTable[] or QStormTable[]). This score is increased if
@ -237,135 +243,134 @@ PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
// enemy king, and to avoid blocking the pawn structure (e.g. white // enemy king, and to avoid blocking the pawn structure (e.g. white
// pawns on h6, g5, black pawns on h7, g6, f7). // pawns on h6, g5, black pawns on h7, g6, f7).
// Kingside pawn storms: // Kingside and queenside pawn storms
bonus = KStormTable[relative_square(us, s)]; bool outPost = (outpost_mask(us, s) & theirPawns);
if(bonus > 0 && outpost_mask(us, s) & theirPawns) { bool passed = (passed_pawn_mask(us, s) & theirPawns);
switch(f) { int KBonus = KStormTable[relative_square(us, s)];
int QBonus = QStormTable[relative_square(us, s)];
case FILE_F: switch (f) {
bonus += bonus / 4;
break;
case FILE_G:
bonus += bonus / 2 + bonus / 4;
break;
case FILE_H:
bonus += bonus / 2;
break;
default:
break;
}
}
pi->ksStormValue[us] += bonus;
// Queenside pawn storms:
bonus = QStormTable[relative_square(us, s)];
if(bonus > 0 && passed_pawn_mask(us, s) & theirPawns) {
switch(f) {
case FILE_A: case FILE_A:
bonus += bonus / 2; QBonus += passed * QBonus / 4;
break; break;
case FILE_B: case FILE_B:
bonus += bonus / 2 + bonus / 4; QBonus += passed * (QBonus / 2 + QBonus / 4);
break; break;
case FILE_C: case FILE_C:
bonus += bonus / 2; 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; break;
default: default:
break; break;
} }
} pi->ksStormValue[us] += KBonus;
pi->qsStormValue[us] += bonus; pi->qsStormValue[us] += QBonus;
} }
// Member of a pawn chain? We could speed up the test a little by // Member of a pawn chain (but not the backward one)? We could speed up
// introducing an array of masks indexed by color and square for doing // the test a little by introducing an array of masks indexed by color
// the test, but because everything is hashed, it probably won't make // and square for doing the test, but because everything is hashed,
// any noticable difference. // it probably won't make any noticable difference.
chain = (us == WHITE)? chain = ourPawns
(ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r-1))) : & neighboring_files_bb(f)
(ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r+1))); & (rank_bb(r) | rank_bb(r - (us == WHITE ? 1 : -1)));
// Test for backward pawn
// Test for backward pawn. //
// If the pawn is passed, isolated, or member of a pawn chain
// If the pawn is isolated, passed, or member of a pawn chain, it cannot // it cannot be backward. If can capture an enemy pawn or if
// be backward: // there are friendly pawns behind on neighboring files it cannot
if(passed || isolated || chain) // be backward either.
if ( passed
|| isolated
|| chain
|| (pos.pawn_attacks(us, s) & theirPawns)
|| (ourPawns & in_front_bb(them, r) & neighboring_files_bb(f)))
backward = false; backward = false;
// If the pawn can capture an enemy pawn, it's not backward: else
else if(pos.pawn_attacks(us, s) & theirPawns) {
backward = false; // We now know that there are no friendly pawns beside or behind this
// 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 // pawn on neighboring files. We now check whether the pawn is
// backward by looking in the forward direction on the neighboring // backward by looking in the forward direction on the neighboring
// files, and seeing whether we meet a friendly or an enemy pawn first. // files, and seeing whether we meet a friendly or an enemy pawn first.
Bitboard b; Bitboard b;
if(us == WHITE) { if (us == WHITE)
for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b<<=8); {
for (b = pos.pawn_attacks(us, s); !(b & (ourPawns | theirPawns)); b <<= 8);
backward = (b | (b << 8)) & theirPawns; backward = (b | (b << 8)) & theirPawns;
} }
else { else
for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b>>=8); {
for (b = pos.pawn_attacks(us, s); !(b & (ourPawns | theirPawns)); b >>= 8);
backward = (b | (b >> 8)) & theirPawns; backward = (b | (b >> 8)) & theirPawns;
} }
} }
// Test for candidate passed pawn. // Test for candidate passed pawn
candidate = candidate = !passed
(!passed && pos.file_is_half_open(them, f) && && pos.file_is_half_open(them, f)
count_1s_max_15(neighboring_files_bb(f) && ( count_1s_max_15(neighboring_files_bb(f) & (in_front_bb(them, r) | rank_bb(r)) & ourPawns)
& (in_front_bb(them, r) | rank_bb(r)) - count_1s_max_15(neighboring_files_bb(f) & in_front_bb(us, r) & theirPawns)
& ourPawns)
- count_1s_max_15(neighboring_files_bb(f) & in_front_bb(us, r)
& theirPawns)
>= 0); >= 0);
// In order to prevent doubled passed pawns from receiving a too big // In order to prevent doubled passed pawns from receiving a too big
// bonus, only the frontmost passed pawn on each file is considered as // bonus, only the frontmost passed pawn on each file is considered as
// a true passed pawn. // a true passed pawn.
if(passed && (ourPawns & squares_in_front_of(us, s))) { if (passed && (ourPawns & squares_in_front_of(us, s)))
{
// candidate = true; // candidate = true;
passed = false; passed = false;
} }
// Score this pawn: // Score this pawn
Value mv = Value(0), ev = Value(0); Value mv = Value(0), ev = Value(0);
if(isolated) { if (isolated)
{
mv -= IsolatedPawnMidgamePenalty[f]; mv -= IsolatedPawnMidgamePenalty[f];
ev -= IsolatedPawnEndgamePenalty[f]; ev -= IsolatedPawnEndgamePenalty[f];
if(pos.file_is_half_open(them, f)) { if (pos.file_is_half_open(them, f))
{
mv -= IsolatedPawnMidgamePenalty[f] / 2; mv -= IsolatedPawnMidgamePenalty[f] / 2;
ev -= IsolatedPawnEndgamePenalty[f] / 2; ev -= IsolatedPawnEndgamePenalty[f] / 2;
} }
} }
if(doubled) { if (doubled)
{
mv -= DoubledPawnMidgamePenalty[f]; mv -= DoubledPawnMidgamePenalty[f];
ev -= DoubledPawnEndgamePenalty[f]; ev -= DoubledPawnEndgamePenalty[f];
} }
if(backward) { if (backward)
{
mv -= BackwardPawnMidgamePenalty[f]; mv -= BackwardPawnMidgamePenalty[f];
ev -= BackwardPawnEndgamePenalty[f]; ev -= BackwardPawnEndgamePenalty[f];
if(pos.file_is_half_open(them, f)) { if (pos.file_is_half_open(them, f))
{
mv -= BackwardPawnMidgamePenalty[f] / 2; mv -= BackwardPawnMidgamePenalty[f] / 2;
ev -= BackwardPawnEndgamePenalty[f] / 2; ev -= BackwardPawnEndgamePenalty[f] / 2;
} }
} }
if(chain) { if (chain)
{
mv += ChainMidgameBonus[f]; mv += ChainMidgameBonus[f];
ev += ChainEndgameBonus[f]; ev += ChainEndgameBonus[f];
} }
if(candidate) { if (candidate)
{
mv += CandidateMidgameBonus[relative_rank(us, s)]; mv += CandidateMidgameBonus[relative_rank(us, s)];
ev += CandidateEndgameBonus[relative_rank(us, s)]; ev += CandidateEndgameBonus[relative_rank(us, s)];
} }
@ -374,14 +379,13 @@ PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
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;
} }