From 9f6bcb38c032a18c8b1aec318d5c7255827f9c7b Mon Sep 17 00:00:00 2001 From: mstembera Date: Wed, 30 Mar 2022 18:14:27 -0700 Subject: [PATCH] Minor cleanups 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 --- src/misc.h | 9 +++---- src/movepick.cpp | 69 ++++++++++-------------------------------------- src/position.h | 18 ++++++++++++- 3 files changed, 34 insertions(+), 62 deletions(-) diff --git a/src/misc.h b/src/misc.h index dcef22a4..2fd2b408 100644 --- a/src/misc.h +++ b/src/misc.h @@ -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 : diff --git a/src/movepick.cpp b/src/movepick.cpp index ce82a59b..b0166c6e 100644 --- a/src/movepick.cpp +++ b/src/movepick.cpp @@ -18,6 +18,7 @@ #include +#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 -Bitboard threatsByPawn (const Position& pos) -{ - return pawn_attacks_bb(pos.pieces(Us, PAWN)); -} - -//squares threatened by minor attacks -template -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(s, pos.pieces()); - else - threats |= attacks_bb(s, pos.pieces()); - } - return threats; -} - -//squares threatened by rook attacks -template -Bitboard threatsByRook (const Position& pos) -{ - Bitboard our = pos.pieces(Us, ROOK); - Bitboard threats = 0; - while (our) - { - Square s = pop_lsb(our); - threats |= attacks_bb(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(pos) : threatsByPawn(pos); + threatenedByPawn = pos.attacks_by(~us); // squares threatened by minors or pawns - threatenedByMinor = pos.side_to_move() == WHITE ? threatsByMinor(pos) : threatsByMinor(pos); - threatenedByMinor |= threatenedByPawn; + threatenedByMinor = pos.attacks_by(~us) | pos.attacks_by(~us) | threatenedByPawn; // squares threatened by rooks, minors or pawns - threatenedByRook = pos.side_to_move() == WHITE ? threatsByRook(pos) : threatsByRook(pos); - threatenedByRook |= threatenedByMinor; + threatenedByRook = pos.attacks_by(~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 { diff --git a/src/position.h b/src/position.h index 7b6165f3..e5585818 100644 --- a/src/position.h +++ b/src/position.h @@ -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 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 +inline Bitboard Position::attacks_by(Color c) const { + + if constexpr (Pt == PAWN) + return c == WHITE ? pawn_attacks_bb(pieces(WHITE, PAWN)) + : pawn_attacks_bb(pieces(BLACK, PAWN)); + else + { + Bitboard threats = 0; + Bitboard attackers = pieces(c, Pt); + while (attackers) + threats |= attacks_bb(pop_lsb(attackers), pieces()); + return threats; + } +} + inline Bitboard Position::checkers() const { return st->checkersBB; } -- 2.39.2