kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-30 00:33: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

416
src/pawns.cpp
View file

@ -86,14 +86,14 @@ namespace {
// Candidate passed pawn bonus by rank, middle game.
const Value CandidateMidgameBonus[8] = {
Value(0), Value(12), Value(12), Value(20),
Value(40), Value(90), Value(0), Value(0)
Value( 0), Value(12), Value(12), Value(20),
Value(40), Value(90), Value( 0), Value( 0)
};
// Candidate passed pawn bonus by rank, endgame.
const Value CandidateEndgameBonus[8] = {
Value(0), Value(24), Value(24), Value(40),
Value(80), Value(180), Value(0), Value(0)
Value( 0), Value(24), Value(24), Value(40),
Value(80), Value(180), Value(0), Value( 0)
};
// Evaluate pawn storms?
@ -101,25 +101,25 @@ namespace {
// Pawn storm tables for positions with opposite castling:
const int QStormTable[64] = {
0, 0, 0, 0, 0, 0, 0, 0,
-22, -22, -22, -13, -4, 0, 0, 0,
-4, -9, -9, -9, -4, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
-22,-22,-22,-13,-4, 0, 0, 0,
-4, -9, -9, -9,-4, 0, 0, 0,
9, 18, 22, 18, 9, 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,
0, 0, 0, 0, 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,
0, 0, 0, 0, 0, 0, 0, 0
};
const int KStormTable[64] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, -4, -13, -22, -27, -27,
0, 0, 0, -4, -9, -13, -18, -18,
0, 0, 0, 0, 9, 9, 9, 9,
0, 0, 0, 0, 9, 18, 27, 27,
0, 0, 0, 0, 9, 27, 40, 36,
0, 0, 0, 0, 0, 31, 40, 31,
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, -9,-13,-18,-18,
0, 0, 0, 0, 9, 9, 9, 9,
0, 0, 0, 0, 9, 18, 27, 27,
0, 0, 0, 0, 9, 27, 40, 36,
0, 0, 0, 0, 0, 31, 40, 31,
0, 0, 0, 0, 0, 0, 0, 0
};
// Pawn storm open file bonuses by file:
@ -141,14 +141,16 @@ namespace {
/// Constructor
PawnInfoTable::PawnInfoTable(unsigned numOfEntries) {
size = numOfEntries;
entries = new PawnInfo[size];
if(entries == NULL) {
std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
<< " bytes for pawn hash table." << std::endl;
exit(EXIT_FAILURE);
if (entries == NULL)
{
std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
<< " 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.
PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
assert(pos.is_ok());
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
// have analysed this pawn structure before, and we can simply return the
// information we found the last time instead of recomputing it:
if(pi->key == key)
return pi;
// information we found the last time instead of recomputing it
if (pi->key == key)
return pi;
// Clear the PawnInfo object, and set the key:
// Clear the PawnInfo object, and set the key
pi->clear();
pi->key = key;
Value mgValue[2] = {Value(0), Value(0)};
Value egValue[2] = {Value(0), Value(0)};
// Loop through the pawns for both colors:
for(Color us = WHITE; us <= BLACK; us++) {
// Loop through the pawns for both colors
for (Color us = WHITE; us <= BLACK; us++)
{
Color them = opposite_color(us);
Bitboard ourPawns = pos.pawns(us);
Bitboard theirPawns = pos.pawns(them);
Bitboard pawns = ourPawns;
// Initialize pawn storm scores by giving bonuses for open files:
if(EvaluatePawnStorms)
for(File f = FILE_A; f <= FILE_H; f++)
if(pos.file_is_half_open(us, f)) {
pi->ksStormValue[us] += KStormOpenFileBonus[f];
pi->qsStormValue[us] += QStormOpenFileBonus[f];
// Initialize pawn storm scores by giving bonuses for open files
if (EvaluatePawnStorms)
for(File f = FILE_A; f <= FILE_H; f++)
if(pos.file_is_half_open(us, 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:
while(pawns) {
Square s = pop_1st_bit(&pawns);
File f = square_file(s);
Rank r = square_rank(s);
bool passed, doubled, isolated, backward, chain, candidate;
int bonus;
// Member of a pawn chain (but not the backward one)? We could speed up
// the test a little by introducing an array of masks indexed by color
// and square for doing the test, but because everything is hashed,
// it probably won't make any noticable difference.
chain = ourPawns
& neighboring_files_bb(f)
& (rank_bb(r) | rank_bb(r - (us == WHITE ? 1 : -1)));
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.
// Test for backward pawn
//
// 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).
// 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
|| (pos.pawn_attacks(us, s) & theirPawns)
|| (ourPawns & in_front_bb(them, r) & neighboring_files_bb(f)))
backward = false;
else
{
// 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 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
{
for (b = pos.pawn_attacks(us, s); !(b & (ourPawns | theirPawns)); b >>= 8);
backward = (b | (b >> 8)) & theirPawns;
}
}
// Test for candidate passed pawn
candidate = !passed
&& pos.file_is_half_open(them, 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);
// 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 (doubled)
{
mv -= DoubledPawnMidgamePenalty[f];
ev -= DoubledPawnEndgamePenalty[f];
}
if (backward)
{
mv -= BackwardPawnMidgamePenalty[f];
ev -= BackwardPawnEndgamePenalty[f];
if (pos.file_is_half_open(them, f))
{
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;
egValue[us] += ev;
// Kingside pawn storms:
bonus = KStormTable[relative_square(us, s)];
if(bonus > 0 && outpost_mask(us, s) & theirPawns) {
switch(f) {
case FILE_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:
bonus += bonus / 2;
break;
case FILE_B:
bonus += bonus / 2 + bonus / 4;
break;
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
// introducing an array of masks indexed by color and square for doing
// the test, but because everything is hashed, it probably won't make
// any noticable difference.
chain = (us == WHITE)?
(ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r-1))) :
(ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r+1)));
// Test for backward pawn.
// 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 {
for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b>>=8);
backward = (b | (b >> 8)) & theirPawns;
}
}
// Test for candidate passed pawn.
candidate =
(!passed && pos.file_is_half_open(them, 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);
// 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(doubled) {
mv -= DoubledPawnMidgamePenalty[f];
ev -= DoubledPawnEndgamePenalty[f];
}
if(backward) {
mv -= BackwardPawnMidgamePenalty[f];
ev -= BackwardPawnEndgamePenalty[f];
if(pos.file_is_half_open(them, f)) {
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;
egValue[us] += ev;
// If the pawn is passed, set the square of the pawn in the passedPawns
// bitboard:
if(passed)
set_bit(&(pi->passedPawns), s);
}
}
// If the pawn is passed, set the square of the pawn in the passedPawns
// bitboard
if (passed)
set_bit(&(pi->passedPawns), s);
} // while(pawns)
} // for(colors)
pi->mgValue = int16_t(mgValue[WHITE] - mgValue[BLACK]);
pi->egValue = int16_t(egValue[WHITE] - egValue[BLACK]);
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() {
mgValue = egValue = 0;
passedPawns = EmptyBoardBB;
ksStormValue[WHITE] = ksStormValue[BLACK] = 0;
qsStormValue[WHITE] = qsStormValue[BLACK] = 0;
Key k = key;
memset(this, 0, sizeof(PawnInfo));
key = k;
halfOpenFiles[WHITE] = halfOpenFiles[BLACK] = 0xFF;
}