kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-30 16:53:09 +00:00
Code Issues Releases Wiki Activity

Don't calculate pawnsOnSquares twice

Browse source 
And reformat some code while there.

No functional change.
This commit is contained in:
Marco Costalba 2013-06-16 10:51:17 +02:00
parent 1fd020a8ba
commit 5ea984ac35
1 changed files with 19 additions and 26 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

45
src/pawns.cpp
View file

@ -80,11 +80,12 @@ namespace {
#undef V #undef V
template<Color Us> template<Color Us>
Score evaluate_pawns(const Position& pos, Bitboard ourPawns, Score evaluate(const Position& pos, Pawns::Entry* e) {
Bitboard theirPawns, Pawns::Entry* e) {
const Color Them = (Us == WHITE ? BLACK : WHITE); const Color Them = (Us == WHITE ? BLACK : WHITE);
const Square Up = (Us == WHITE ? DELTA_N : DELTA_S); const Square Up = (Us == WHITE ? DELTA_N : DELTA_S);
const Square Right = (Us == WHITE ? DELTA_NE : DELTA_SW);
const Square Left = (Us == WHITE ? DELTA_NW : DELTA_SE);
Bitboard b; Bitboard b;
Square s; Square s;
@ -94,6 +95,16 @@ namespace {
Score value = SCORE_ZERO; Score value = SCORE_ZERO;
const Square* pl = pos.piece_list(Us, PAWN); const Square* pl = pos.piece_list(Us, PAWN);
Bitboard ourPawns = pos.pieces(Us, PAWN);
Bitboard theirPawns = pos.pieces(Them, PAWN);
e->passedPawns[Us] = 0;
e->kingSquares[Us] = SQ_NONE;
e->semiopenFiles[Us] = 0xFF;
e->pawnAttacks[Us] = shift_bb<Right>(ourPawns) | shift_bb<Left>(ourPawns);
e->pawnsOnSquares[Us][BLACK] = popcount<Max15>(ourPawns & BlackSquares);
e->pawnsOnSquares[Us][WHITE] = pos.piece_count(Us, PAWN) - e->pawnsOnSquares[Us][BLACK];
// 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 ((s = *pl++) != SQ_NONE) while ((s = *pl++) != SQ_NONE)
{ {
@ -135,7 +146,7 @@ namespace {
// Note that we are sure to find something because pawn is not passed // Note that we are sure to find something because pawn is not passed
// nor isolated, so loop is potentially infinite, but it isn't. // nor isolated, so loop is potentially infinite, but it isn't.
while (!(b & (ourPawns | theirPawns))) while (!(b & (ourPawns | theirPawns)))
Us == WHITE ? b <<= 8 : b >>= 8; b = shift_bb<Up>(b);
// The friendly pawn needs to be at least two ranks closer than the // The friendly pawn needs to be at least two ranks closer than the
// enemy pawn in order to help the potentially backward pawn advance. // enemy pawn in order to help the potentially backward pawn advance.
@ -175,15 +186,10 @@ namespace {
value += CandidatePassed[relative_rank(Us, s)]; value += CandidatePassed[relative_rank(Us, s)];
} }
e->pawnsOnSquares[Us][BLACK] = popcount<Max15>(ourPawns & BlackSquares);
e->pawnsOnSquares[Us][WHITE] = pos.piece_count(Us, PAWN) - e->pawnsOnSquares[Us][BLACK];
e->pawnsOnSquares[Them][BLACK] = popcount<Max15>(theirPawns & BlackSquares);
e->pawnsOnSquares[Them][WHITE] = pos.piece_count(Them, PAWN) - e->pawnsOnSquares[Them][BLACK];
return value; return value;
} }
}
} // namespace
namespace Pawns { namespace Pawns {
@ -196,24 +202,11 @@ Entry* probe(const Position& pos, Table& entries) {
Key key = pos.pawn_key(); Key key = pos.pawn_key();
Entry* e = entries[key]; Entry* e = entries[key];
// If e->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 (e->key == key) if (e->key == key)
return e; return e;
e->key = key; e->key = key;
e->passedPawns[WHITE] = e->passedPawns[BLACK] = 0; e->value = evaluate<WHITE>(pos, e) - evaluate<BLACK>(pos, e);
e->kingSquares[WHITE] = e->kingSquares[BLACK] = SQ_NONE;
e->semiopenFiles[WHITE] = e->semiopenFiles[BLACK] = 0xFF;
Bitboard wPawns = pos.pieces(WHITE, PAWN);
Bitboard bPawns = pos.pieces(BLACK, PAWN);
e->pawnAttacks[WHITE] = shift_bb<DELTA_NE>(wPawns) | shift_bb<DELTA_NW>(wPawns);
e->pawnAttacks[BLACK] = shift_bb<DELTA_SE>(bPawns) | shift_bb<DELTA_SW>(bPawns);
e->value = evaluate_pawns<WHITE>(pos, wPawns, bPawns, e)
- evaluate_pawns<BLACK>(pos, bPawns, wPawns, e);
return e; return e;
} }