Negamax.h

Go to the documentation of this file.

#pragma once

 
#include "../eval/IEvaluator.h"
#include "../eval/SimpleEvalContext.h"
#include "../tablebases/Tablebase.h"
#include "ISearch.h"
#include "TT.h"
#include "TimeManager.h"
#include <array>
#include <chrono>
 
#include "MovePicker.h"
#include "SearchHeuristics.h"

class Negamax : public ISearch {
  // Grant MovePicker access to heap-allocated heuristics
  friend class MovePicker;
 
private:
  IEvaluator &evalCtx_;              
  TranspositionTable &tt_;           
 
  // LAZY SMP: Shared State
  std::shared_ptr<SearchSharedData> shared_; 
  bool isMainThread_;                
  int threadId_;                     
 
  // Thread-local statistics
  uint64_t localNodes_ = 0;          
  uint64_t localTbHits_ = 0;         
  uint64_t localTtHits_ = 0;         
  int localSelDepth_ = 0;            
  static constexpr uint64_t NODE_FLUSH_INTERVAL = 1024; 
 
  // Time management
  TimeManager timeManager_;                  
  TimeManager::TimeAllocation timeAlloc_{};  
  float lastEvalCp_ = 0.0f;                  
 
  // Iteration state tracking
  Move lastBestMove_;                
  int lastScore_ = 0;                
  int bestMoveChanges_ = 0;          
  int scoreDrops_ = 0;               
  std::array<uint64_t, 4096> rootNodeCounts_{}; 
  uint64_t searchNodes_ = 0;         
 
  std::unique_ptr<SearchHeuristics> h_; 

  uint64_t getPawnKey(const Board& board) const;

  uint64_t getNonPawnKey(const Board& board, Color c) const;
 
  // Search context tracking arrays
  std::array<Move, SearchConstants::MAX_PLY> prevMove_;  
  std::array<Piece, SearchConstants::MAX_PLY> prevPiece_{}; 
  std::array<int, SearchConstants::MAX_PLY> pvLength_;   
  std::array<int, SearchConstants::MAX_PLY> evalHistory_{}; 
  
  int currentIter_ = 0; 
 
  std::vector<Move> searchMoves_; 
 
  InfoCallback infoCallback_; 
 
  SimpleEvalContext simpleEval_; 
 
public:
  Negamax(IEvaluator &eval, TranspositionTable &table,
          std::shared_ptr<SearchSharedData> shared, bool isMainThread,
          int threadId = 0);
 
  Move startSearch(Board &root, const SearchParams &params) override;
  
  void stop() override {
    if (shared_)
      shared_->stop = true;
  }
  
  bool isSearching() const override { return shared_ && !shared_->stop; }
  
  void setInfoCallback(InfoCallback callback) override {
    infoCallback_ = callback;
  }
  
  uint64_t getNodes() const override {
    return shared_ ? shared_->totalNodes.load(std::memory_order_relaxed) : 0;
  }
 
private:
  int alphaBeta(Board &board, int depth, int alpha, int beta, int ply,
                bool allowNull, int extensions, bool prevWasCapture = false, bool cutnode = false, Move excludedMove = Move(0));

  int quiescence(Board &board, int alpha, int beta, int ply);

  bool canLazySkip(const Board &board, int depth, int alpha, int beta, int ply,
                   int fastScore, Bound &outBound, bool prevWasCapture,
                   bool pvNode);

  int scoreMoveFast(const Move &move, const Board &board, Move ttMove, int ply,
                    bool isCapture);

  void updateKillers(Move move, int ply);

  void updateHistory(const Board& board, Move move, int bonus, int ply);
 
  friend class MovePicker; 

  int see(const Board &board, Move move) const;

  int pieceValue(PieceType pt) const;

  int applyCorrHist(int rawEval, const Board &board, int ply) const;
 
  // Extension condition checkers
  bool isPassedPawn(const Board &board, Square sq, Color side) const;
  bool isPawnPush7th(const Board &board, Move move) const;
 
  // Time management helpers
  void syncTimeToShared();
  bool shouldStop() const;
  int64_t elapsedMs() const;
  bool shouldStopIteration(int depth, int score, Move bestMove) const;
 
  // General utilities
  bool isCapture(const Board &board, Move move) const;
  bool isDraw(const Board &board) const;
  int mateScore(int ply) const;
  bool isMateScore(int score) const {
    return std::abs(score) >= SearchConstants::MATE_IN_MAX - SearchConstants::MAX_PLY;
  }

  void clearState();

  void flushLocalSearchStats();
};