Simplify slider_blocker calculation

[stockfish] / src / position.cpp

diff --git a/src/position.cpp b/src/position.cpp
index 31cdbc06b670afa2148f69bf4677987347551c3e..120677432b6480f3e35baba5d683768c0e51f123 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -16,22 +16,29 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include "position.h"
+
 #include <algorithm>
+#include <atomic>
 #include <cassert>
-#include <cstddef> // For offsetof()
-#include <cstring> // For std::memset, std::memcmp
+#include <cctype>
+#include <cstddef>
+#include <cstring>
+#include <initializer_list>
 #include <iomanip>
+#include <iostream>
 #include <sstream>
 #include <string_view>
+#include <utility>
 
 #include "bitboard.h"
 #include "misc.h"
 #include "movegen.h"
-#include "position.h"
+#include "nnue/nnue_common.h"
+#include "syzygy/tbprobe.h"
 #include "thread.h"
 #include "tt.h"
 #include "uci.h"
-#include "syzygy/tbprobe.h"
 
 using std::string;
 
@@ -42,7 +49,7 @@ namespace Zobrist {
   Key psq[PIECE_NB][SQUARE_NB];
   Key enpassant[FILE_NB];
   Key castling[CASTLING_RIGHT_NB];
-  Key side, noPawns;
+  Key side;
 }
 
 namespace {
@@ -125,7 +132,6 @@ void Position::init() {
       Zobrist::castling[cr] = rng.rand<Key>();
 
   Zobrist::side = rng.rand<Key>();
-  Zobrist::noPawns = rng.rand<Key>();
 
   // Prepare the cuckoo tables
   std::memset(cuckoo, 0, sizeof(cuckoo));
@@ -315,8 +321,8 @@ void Position::set_castling_right(Color c, Square rfrom) {
 
 void Position::set_check_info() const {
 
-  st->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square<KING>(WHITE), st->pinners[BLACK]);
-  st->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square<KING>(BLACK), st->pinners[WHITE]);
+  update_slider_blockers(WHITE);
+  update_slider_blockers(BLACK);
 
   Square ksq = square<KING>(~sideToMove);
 
@@ -348,7 +354,7 @@ void Position::set_state() const {
       st->key ^= Zobrist::psq[pc][s];
 
       if (type_of(pc) != KING && type_of(pc) != PAWN)
-          st->nonPawnMaterial[color_of(pc)] += PieceValue[MG][pc];
+          st->nonPawnMaterial[color_of(pc)] += PieceValue[pc];
   }
 
   if (st->epSquare != SQ_NONE)
@@ -437,37 +443,33 @@ string Position::fen() const {
   return ss.str();
 }
 
+/// update_slider_blockers() calculates st->blockersForKing[c] and st->pinners[~c],
+/// which store respectively the pieces preventing king of color c from being in check
+/// and the slider pieces of color ~c pinning pieces of color c to the king.
+void Position::update_slider_blockers(Color c) const {
 
-/// Position::slider_blockers() returns a bitboard of all the pieces (both colors)
-/// that are blocking attacks on the square 's' from 'sliders'. A piece blocks a
-/// slider if removing that piece from the board would result in a position where
-/// square 's' is attacked. For example, a king-attack blocking piece can be either
-/// a pinned or a discovered check piece, according if its color is the opposite
-/// or the same of the color of the slider.
-
-Bitboard Position::slider_blockers(Bitboard sliders, Square s, Bitboard& pinners) const {
+  Square ksq =  square<KING>(c);
 
-  Bitboard blockers = 0;
-  pinners = 0;
+  st->blockersForKing[c] = 0;
+  st->pinners[~c] = 0;
 
   // Snipers are sliders that attack 's' when a piece and other snipers are removed
-  Bitboard snipers = (  (attacks_bb<  ROOK>(s) & pieces(QUEEN, ROOK))
-                      | (attacks_bb<BISHOP>(s) & pieces(QUEEN, BISHOP))) & sliders;
+  Bitboard snipers = (  (attacks_bb<  ROOK>(ksq) & pieces(QUEEN, ROOK))
+                      | (attacks_bb<BISHOP>(ksq) & pieces(QUEEN, BISHOP))) & pieces(~c);
   Bitboard occupancy = pieces() ^ snipers;
 
   while (snipers)
   {
     Square sniperSq = pop_lsb(snipers);
-    Bitboard b = between_bb(s, sniperSq) & occupancy;
+    Bitboard b = between_bb(ksq, sniperSq) & occupancy;
 
     if (b && !more_than_one(b))
     {
-        blockers |= b;
-        if (b & pieces(color_of(piece_on(s))))
-            pinners |= sniperSq;
+        st->blockersForKing[c] |= b;
+        if (b & pieces(c))
+            st->pinners[~c] |= sniperSq;
     }
   }
-  return blockers;
 }
 
 
@@ -743,7 +745,7 @@ void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) {
           }
       }
       else
-          st->nonPawnMaterial[them] -= PieceValue[MG][captured];
+          st->nonPawnMaterial[them] -= PieceValue[captured];
 
       dp.dirty_num = 2;  // 1 piece moved, 1 piece captured
       dp.piece[1] = captured;
@@ -823,7 +825,7 @@ void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) {
                             ^ Zobrist::psq[pc][pieceCount[pc]];
 
           // Update material
-          st->nonPawnMaterial[us] += PieceValue[MG][promotion];
+          st->nonPawnMaterial[us] += PieceValue[promotion];
       }
 
       // Reset rule 50 draw counter
@@ -1049,11 +1051,11 @@ bool Position::see_ge(Move m, Bitboard& occupied, Value threshold) const {
 
   Square from = from_sq(m), to = to_sq(m);
 
-  int swap = PieceValue[MG][piece_on(to)] - threshold;
+  int swap = PieceValue[piece_on(to)] - threshold;
   if (swap < 0)
       return false;
 
-  swap = PieceValue[MG][piece_on(from)] - swap;
+  swap = PieceValue[piece_on(from)] - swap;
   if (swap <= 0)
       return true;
 
@@ -1090,7 +1092,7 @@ bool Position::see_ge(Move m, Bitboard& occupied, Value threshold) const {
       if ((bb = stmAttackers & pieces(PAWN)))
       {
           occupied ^= least_significant_square_bb(bb);
-          if ((swap = PawnValueMg - swap) < res)
+          if ((swap = PawnValue - swap) < res)
               break;
 
           attackers |= attacks_bb<BISHOP>(to, occupied) & pieces(BISHOP, QUEEN);
@@ -1099,14 +1101,14 @@ bool Position::see_ge(Move m, Bitboard& occupied, Value threshold) const {
       else if ((bb = stmAttackers & pieces(KNIGHT)))
       {
           occupied ^= least_significant_square_bb(bb);
-          if ((swap = KnightValueMg - swap) < res)
+          if ((swap = KnightValue - swap) < res)
               break;
       }
 
       else if ((bb = stmAttackers & pieces(BISHOP)))
       {
           occupied ^= least_significant_square_bb(bb);
-          if ((swap = BishopValueMg - swap) < res)
+          if ((swap = BishopValue - swap) < res)
               break;
 
           attackers |= attacks_bb<BISHOP>(to, occupied) & pieces(BISHOP, QUEEN);
@@ -1115,7 +1117,7 @@ bool Position::see_ge(Move m, Bitboard& occupied, Value threshold) const {
       else if ((bb = stmAttackers & pieces(ROOK)))
       {
           occupied ^= least_significant_square_bb(bb);
-          if ((swap = RookValueMg - swap) < res)
+          if ((swap = RookValue - swap) < res)
               break;
 
           attackers |= attacks_bb<ROOK>(to, occupied) & pieces(ROOK, QUEEN);
@@ -1124,7 +1126,7 @@ bool Position::see_ge(Move m, Bitboard& occupied, Value threshold) const {
       else if ((bb = stmAttackers & pieces(QUEEN)))
       {
           occupied ^= least_significant_square_bb(bb);
-          if ((swap = QueenValueMg - swap) < res)
+          if ((swap = QueenValue - swap) < res)
               break;
 
           attackers |=  (attacks_bb<BISHOP>(to, occupied) & pieces(BISHOP, QUEEN))