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

Minor cleanups

Browse source 
simplify and relocate to position.cpp some of the recent threat calculations used in the movepicker.

passed STC:
https://tests.stockfishchess.org/tests/view/62468c301f682ea45ce3b3b9
LLR: 2.96 (-2.94,2.94) <-2.25,0.25>
Total: 76544 W: 20247 L: 20152 D: 36145
Ptnml(0-2): 327, 8113, 21317, 8168, 347

closes https://github.com/official-stockfish/Stockfish/pull/3972

No functional change
This commit is contained in:
mstembera 2022-03-30 18:14:27 -07:00 • committed by Joost VandeVondele
parent 471d93063a
commit 9f6bcb38c0
3 changed files with 34 additions and 62 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
src/misc.h
View file

@ -90,9 +90,6 @@ static inline const bool IsLittleEndian = (Le.c[0] == 4);
class RunningAverage {
public:
// Constructor
RunningAverage() {}
// Reset the running average to rational value p / q
void set(int64_t p, int64_t q)
{ average = p * PERIOD * RESOLUTION / q; }
@ -102,10 +99,10 @@ class RunningAverage {
{ average = RESOLUTION * v + (PERIOD - 1) * average / PERIOD; }
// Test if average is strictly greater than rational a / b
bool is_greater(int64_t a, int64_t b)
{ return b * average > a * PERIOD * RESOLUTION ; }
bool is_greater(int64_t a, int64_t b) const
{ return b * average > a * (PERIOD * RESOLUTION); }
int64_t value()
int64_t value() const
{ return average / (PERIOD * RESOLUTION); }
private :

69
src/movepick.cpp
View file

@ -18,6 +18,7 @@
#include <cassert>
#include "bitboard.h"
#include "movepick.h"
namespace Stockfish {
@ -97,44 +98,6 @@ MovePicker::MovePicker(const Position& p, Move ttm, Value th, Depth d, const Cap
&& pos.see_ge(ttm, threshold));
}
//squares threatened by pawn attacks
template <Color Us>
Bitboard threatsByPawn (const Position& pos)
{
return pawn_attacks_bb<Us>(pos.pieces(Us, PAWN));
}
//squares threatened by minor attacks
template <Color Us>
Bitboard threatsByMinor (const Position& pos)
{
Bitboard our = pos.pieces(Us, KNIGHT, BISHOP);
Bitboard threats = 0;
while (our)
{
Square s = pop_lsb(our);
if (type_of(pos.piece_on(s)) == KNIGHT)
threats |= attacks_bb<KNIGHT>(s, pos.pieces());
else
threats |= attacks_bb<BISHOP>(s, pos.pieces());
}
return threats;
}
//squares threatened by rook attacks
template <Color Us>
Bitboard threatsByRook (const Position& pos)
{
Bitboard our = pos.pieces(Us, ROOK);
Bitboard threats = 0;
while (our)
{
Square s = pop_lsb(our);
threats |= attacks_bb<ROOK>(s, pos.pieces());
}
return threats;
}
/// MovePicker::score() assigns a numerical value to each move in a list, used
/// for sorting. Captures are ordered by Most Valuable Victim (MVV), preferring
/// captures with a good history. Quiets moves are ordered using the histories.
@ -146,26 +109,22 @@ void MovePicker::score() {
Bitboard threatened, threatenedByPawn, threatenedByMinor, threatenedByRook;
if constexpr (Type == QUIETS)
{
Color us = pos.side_to_move();
// squares threatened by pawns
threatenedByPawn = pos.side_to_move() == WHITE ? threatsByPawn<BLACK>(pos) : threatsByPawn<WHITE>(pos);
threatenedByPawn = pos.attacks_by<PAWN>(~us);
// squares threatened by minors or pawns
threatenedByMinor = pos.side_to_move() == WHITE ? threatsByMinor<BLACK>(pos) : threatsByMinor<WHITE>(pos);
threatenedByMinor |= threatenedByPawn;
threatenedByMinor = pos.attacks_by<KNIGHT>(~us) | pos.attacks_by<BISHOP>(~us) | threatenedByPawn;
// squares threatened by rooks, minors or pawns
threatenedByRook = pos.side_to_move() == WHITE ? threatsByRook<BLACK>(pos) : threatsByRook<WHITE>(pos);
threatenedByRook |= threatenedByMinor;
threatenedByRook = pos.attacks_by<ROOK>(~us) | threatenedByMinor;
// pieces threatened by pieces of lesser material value
threatened = pos.side_to_move() == WHITE ? ((pos.pieces(WHITE, QUEEN) & threatenedByRook) |
(pos.pieces(WHITE, ROOK) & threatenedByMinor) |
(pos.pieces(WHITE, KNIGHT, BISHOP) & threatenedByPawn))
: ((pos.pieces(BLACK, QUEEN) & threatenedByRook) |
(pos.pieces(BLACK, ROOK) & threatenedByMinor) |
(pos.pieces(BLACK, KNIGHT, BISHOP) & threatenedByPawn));
threatened = (pos.pieces(us, QUEEN) & threatenedByRook)
| (pos.pieces(us, ROOK) & threatenedByMinor)
| (pos.pieces(us, KNIGHT, BISHOP) & threatenedByPawn);
}
else
{
// Silence unused variable warning
// Silence unused variable warnings
(void) threatened;
(void) threatenedByPawn;
(void) threatenedByMinor;
@ -184,11 +143,11 @@ void MovePicker::score() {
+ (*continuationHistory[3])[pos.moved_piece(m)][to_sq(m)]
+ (*continuationHistory[5])[pos.moved_piece(m)][to_sq(m)]
+ (threatened & from_sq(m) ?
(type_of(pos.piece_on(from_sq(m))) == QUEEN && !(to_sq(m) & threatenedByRook) ? 50000
: type_of(pos.piece_on(from_sq(m))) == ROOK && !(to_sq(m) & threatenedByMinor) ? 25000
: !(to_sq(m) & threatenedByPawn) ? 15000
: 0)
: 0);
(type_of(pos.moved_piece(m)) == QUEEN && !(to_sq(m) & threatenedByRook) ? 50000
: type_of(pos.moved_piece(m)) == ROOK && !(to_sq(m) & threatenedByMinor) ? 25000
: !(to_sq(m) & threatenedByPawn) ? 15000
: 0)
: 0);
else // Type == EVASIONS
{

18
src/position.h
View file

@ -120,12 +120,12 @@ public:
Bitboard attackers_to(Square s) const;
Bitboard attackers_to(Square s, Bitboard occupied) const;
Bitboard slider_blockers(Bitboard sliders, Square s, Bitboard& pinners) const;
template<PieceType Pt> Bitboard attacks_by(Color c) const;
// Properties of moves
bool legal(Move m) const;
bool pseudo_legal(const Move m) const;
bool capture(Move m) const;
bool capture_or_promotion(Move m) const;
bool gives_check(Move m) const;
Piece moved_piece(Move m) const;
Piece captured_piece() const;
@ -285,6 +285,22 @@ inline Bitboard Position::attackers_to(Square s) const {
return attackers_to(s, pieces());
}
template<PieceType Pt>
inline Bitboard Position::attacks_by(Color c) const {
if constexpr (Pt == PAWN)
return c == WHITE ? pawn_attacks_bb<WHITE>(pieces(WHITE, PAWN))
: pawn_attacks_bb<BLACK>(pieces(BLACK, PAWN));
else
{
Bitboard threats = 0;
Bitboard attackers = pieces(c, Pt);
while (attackers)
threats |= attacks_bb<Pt>(pop_lsb(attackers), pieces());
return threats;
}
}
inline Bitboard Position::checkers() const {
return st->checkersBB;
}