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

Pawn clean up

Browse source 
Non functional simplification when we find the passed pawns in pawn.cpp
and some code clean up. It also better follows the pattern "flag the pawn"
and "score the pawn".

-------------------------

The idea behind the third condition for candidate passed pawn is a little
bit difficult to visualize. Just for the record, the idea is the following:

Consider White e5 d4 against black e6. d4 can (in some endgames) push
to d5 and lever e6. Thanks to this sacrifice, or after d5xe6, we consider
e5 as "passed".

However:
- if White e5/d4 against black e6/c6: d4 cannot safely push to d5 since d5 is double attacked;
- if White e5/d4 against black e6/d5: d4 cannot safely push to d5 since it is occupied.

This is exactly what the following expression does:

```
   && (shift<Up>(support) & ~(theirPawns | dblAttackThem)))
```

--------------------------

http://tests.stockfishchess.org/tests/view/5d3325bb0ebc5925cf0e6e91
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 124666 W: 27586 L: 27669 D: 69411

Closes https://github.com/official-stockfish/Stockfish/pull/2255

No functional change
This commit is contained in:
Alain SAVARD 2019-07-25 09:02:26 +02:00 • committed by Stéphane Nicolet
parent dc243a3c88
commit 33c3a04653
2 changed files with 23 additions and 22 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

41
src/pawns.cpp
View file

@ -35,8 +35,8 @@ namespace {
constexpr Score Backward = S( 9, 24);
constexpr Score Doubled = S(11, 56);
constexpr Score Isolated = S( 5, 15);
constexpr Score WeakLever = S( 0, 56);
constexpr Score WeakUnopposed = S(13, 27);
constexpr Score Attacked2Unsupported = S(0, 56);
// Connected pawn bonus
constexpr int Connected[RANK_NB] = { 0, 7, 8, 12, 29, 48, 86 };
@ -73,13 +73,15 @@ namespace {
Bitboard b, neighbours, stoppers, doubled, support, phalanx;
Bitboard lever, leverPush;
Square s;
bool opposed, backward;
bool opposed, backward, passed;
Score score = SCORE_ZERO;
const Square* pl = pos.squares<PAWN>(Us);
Bitboard ourPawns = pos.pieces( Us, PAWN);
Bitboard theirPawns = pos.pieces(Them, PAWN);
Bitboard doubleAttackThem = pawn_double_attacks_bb<Them>(theirPawns);
e->passedPawns[Us] = e->pawnAttacksSpan[Us] = 0;
e->kingSquares[Us] = SQ_NONE;
e->pawnAttacks[Us] = pawn_attacks_bb<Us>(ourPawns);
@ -109,21 +111,20 @@ namespace {
backward = !(neighbours & forward_ranks_bb(Them, s))
&& (stoppers & (leverPush | (s + Up)));
// Passed pawns will be properly scored in evaluation because we need
// full attack info to evaluate them. Include also not passed pawns
// which could become passed after one or two pawn pushes when they
// are not attacked more times than defended.
if ( !(stoppers ^ lever) ||
(!(stoppers ^ leverPush) && popcount(phalanx) >= popcount(leverPush)))
e->passedPawns[Us] |= s;
// A pawn is passed if one of the three following conditions is true:
// (a) there is no stoppers except some levers
// (b) the only stoppers are the leverPush, but we outnumber them
// (c) there is only one front stopper which can be levered.
passed = !(stoppers ^ lever)
|| ( !(stoppers ^ leverPush)
&& popcount(phalanx) >= popcount(leverPush))
|| ( stoppers == square_bb(s + Up) && r >= RANK_5
&& (shift<Up>(support) & ~(theirPawns | doubleAttackThem)));
else if (stoppers == square_bb(s + Up) && r >= RANK_5)
{
b = shift<Up>(support) & ~theirPawns;
while (b)
if (!more_than_one(theirPawns & PawnAttacks[Us][pop_lsb(&b)]))
// Passed pawns will be properly scored later in evaluation when we have
// full attack info.
if (passed)
e->passedPawns[Us] |= s;
}
// Score this pawn
if (support | phalanx)
@ -144,11 +145,11 @@ namespace {
score -= Doubled;
}
// Unsupported friendly pawns attacked twice by the enemy
score -= Attacked2Unsupported * popcount( ourPawns
& pawn_double_attacks_bb<Them>(theirPawns)
& ~pawn_attacks_bb<Us>(ourPawns)
& ~e->passedPawns[Us]);
// Penalize the unsupported and non passed pawns attacked twice by the enemy
b = ourPawns
& doubleAttackThem
& ~(e->pawnAttacks[Us] | e->passedPawns[Us]);
score -= WeakLever * popcount(b);
return score;
}