MovePicker.h

Go to the documentation of this file.

#pragma once

 
#include "ISearch.h"
#include <array>
 
// Forward declarations
class Negamax;

class MovePicker {
private:
  const Movelist &allMoves_;   
  
  // === OPTIMIZATION: Fixed-size arrays to avoid dynamic allocations ===
  // Max legal moves in any chess position is 218, but typical positions have <50
  static constexpr int MAX_MOVES = 256; 
  
  std::array<Move, MAX_MOVES> &captures_;      
  std::array<int, MAX_MOVES> &captureScores_;  
  int captureCount_ = 0;                       
  
  std::array<Move, 2> killerMoves_;            
  int killerCount_ = 0;                        
  
  std::array<Move, MAX_MOVES> &quiets_;        
  std::array<int, MAX_MOVES> &quietScores_;    
  int quietCount_ = 0;                         
  
  Move ttMove_;      
  Move countermove_; 
  
  const std::array<std::array<Move, 2>, SearchConstants::MAX_PLY> *killers_; 
  const std::array<std::array<int, 64>, 64> *history_;                       
  const std::array<std::array<int, 64>, 16> *captureHist_;                   
  
  int ply_;          
  int threadId_;     
 
  int nextCapture_ = 0;          
  int nextKiller_ = 0;           
  int nextQuiet_ = 0;            
  
  std::array<Move, MAX_MOVES> &badCaptures_; 
  int badCaptureCount_ = 0;                  
  int nextBadCapture_ = 0;                   
  
  bool capturesGenerated_ = false;           
  bool killersGenerated_ = false;            
  bool quietsGenerated_ = false;             
  
  int nextQueenPromo_ = 0;                   
  int queenPromoCount_ = 0;                  
  
  bool countermoveReturned_ = false;         
  int phase_ = 0;                            
 
public:
  MovePicker(
      const Movelist &moves, Move ttMove,
      const std::array<std::array<Move, 2>, SearchConstants::MAX_PLY> *killers,
      const std::array<std::array<int, 64>, 64> *history,
      const std::array<std::array<int, 64>, 16> *captureHist,
      std::array<Move, MAX_MOVES> &captures,
      std::array<int, MAX_MOVES> &captureScores,
      std::array<Move, MAX_MOVES> &quiets,
      std::array<int, MAX_MOVES> &quietScores,
      std::array<Move, MAX_MOVES> &badCaptures,
      int ply, int threadId = 0, Move countermove = Move(0))
      : allMoves_(moves), captures_(captures), captureScores_(captureScores),
        quiets_(quiets), quietScores_(quietScores),
        badCaptures_(badCaptures), ttMove_(ttMove),
        countermove_(countermove),
        killers_(killers), history_(history), captureHist_(captureHist), 
        ply_(ply), threadId_(threadId) {}

  Move nextMove(const Board &board, const Negamax *search, bool inCheck);
 
private:
  int scoreMove(const Move &move, const Board &board, const Negamax *search,
                bool isCapture);
  void generateAndScoreCaptures(const Board &board, const Negamax *search);
  void generateAndScoreKillers(const Board &board, const Negamax *search);
  void generateAndScoreQuiets(const Board &board, const Negamax *search);
  
  template<size_t N>
  Move selectBestMove(std::array<Move, N> &list, std::array<int, N> &scores,
                      int &nextIdx, int count);
};