movelist.h

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: movelist.h
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#if !defined(MOVELIST_H)
#define MOVELIST_H
 
typedef std::vector<bMove> movelist_t;
 
//-----------------------------------------------------------------------
 
class bMoveList {
public:
  explicit bMoveList()
    : m_lmoves{}
    {}
  bMoveList(bMoveList& ml)
    : curmoveid{ml.curmoveid}
    , m_lmoves{ml.m_lmoves}
    , flags{ml.flags}
    , m_nQSMoves{ml.m_nQSMoves}
    , m_bestmoveid{ml.m_bestmoveid}
    {}
  ~bMoveList()
    {}
 
  bMoveList& operator=(bMoveList const& ml)
    { curmoveid = ml.curmoveid;
      m_lmoves = ml.m_lmoves;
      flags = ml.flags;
      m_nQSMoves = ml.m_nQSMoves;
      m_bestmoveid = ml.m_bestmoveid;
      return *this;
    }
 
  // no copy or move ctor nor assignment defined
  bMoveList(bMoveList const& ml) = delete;
  bMoveList(bMoveList&& ml) = delete;
  bMoveList& operator=(bMoveList&& ml) = delete;
 
  movenum_t adjustQSMoves();
  bool atLeastOneMovePossible(bBasicBoard& b);
  movenum_t generateMoves(bBasicBoard const& b);
  void emptyMoveList();
 
  constexpr movenum_t getNumberOfMoves() const
    { return static_cast<movenum_t>(m_lmoves.size()); }
  constexpr movenum_t getNumberOfQSMoves() const // return number of non silent moves
    { return m_nQSMoves; }
 
  inline bMove const& operator[](movenum_t const moveid) const
    { return m_lmoves[moveid - 1]; }
  constexpr fromto_t getFromTo(movenum_t const moveid) const
    { return m_lmoves[moveid - 1].getFromTo(); }
  constexpr bmove_t getBMoveT(movenum_t const moveid) const
    { return m_lmoves[moveid - 1].getBMoveT(); }
 
  movenum_t addWhiteMoveIfValid(bBasicBoard const& b, bMove& m);
  movenum_t addBlackMoveIfValid(bBasicBoard const& b, bMove& m);
  movenum_t addWhitePromotionIfValid(bBasicBoard const& b, bMove& m);
  movenum_t addBlackPromotionIfValid(bBasicBoard const& b, bMove& m);
 
  void sortMoves(bool const bFastSort);
  void clearScores()
    { for (bMove& m: m_lmoves) m.clearScore(); }
  void clearScores(bScore const sc)
    { for (bMove& m: m_lmoves) m.clearScore(sc); }
 
  // manage best score and best move
  bool setScoreOfMove(movenum_t const moveid, bScore const score);
  bool setMinScoreOfMove(movenum_t const moveid, bScore const score);
  void setScoreOfMoveUnsorted(movenum_t const moveid, bScore const score);
  void setMinScoreOfMoveUnsorted(movenum_t const moveid, bScore const score);
 
  constexpr bScore getBestMoveScore() const
    { return m_lmoves[m_bestmoveid - 1].getScore(); }
  inline void setBestMoveScore(bScore const score)
    { m_lmoves[m_bestmoveid - 1].setScore(score); }
  inline void setBestMoveScore(movenum_t const moveid, bScore const score)
    { m_bestmoveid = moveid; setMoveScore(moveid, score); }
  inline void setMoveScore(movenum_t const moveid, bScore const score)
    { m_lmoves[moveid - 1].setScore(score); }
 
  constexpr movenum_t getBestMoveId() const
    { return m_bestmoveid; }
  inline void setBestMoveId(movenum_t const n)
    { m_bestmoveid = n; }
  inline void clearBestMoveId()
    { m_bestmoveid = 0; }
 
  inline void setNeedSorted()
    { flags &= ~(0x10); }
  inline void clearNeedSorted()
    { flags |= 0x10; }
  inline void setKeepScores()
    { flags &= ~(0x20); }
  inline void clearKeepScores()
    { flags |= 0x20; }
 
  // current move in iterator
  movenum_t curmoveid = 0;
 
protected:
  constexpr bool isGenerated() const
    { return flags & 0x01; }
  inline void setIsGenerated()
    { flags |= 0x01; }
  inline void clearIsGenerated()
    { flags &= ~(0x01); }
  constexpr bool isSorted() const
    { return flags & 0x02; }
  constexpr bool isNotSorted() const
    { return !(flags & 0x02); }
  inline void setIsSorted()
    { flags |= 0x02; }
  inline void clearIsSorted()
    { flags &= ~(0x02); }
 
  // the best move is much better than the second best move
  constexpr bool isOnlyMove() const
    { return flags & 0x04; }
  inline void setIsOnlyMove()
    { flags |= 0x04; }
  inline void clearIsOnlyMove()
    { flags &= ~(0x04); }
 
  // a move was found previously on this board
  constexpr bool isPossibleMove() const
    { return getBestMoveId() || (flags & 0x08); }
  inline void setIsPossibleMove()
    { flags |= 0x08; }
  inline void clearIsPossibleMove()
    { flags &= ~(0x08); }
 
  constexpr bool isNeedSorted() const
    { return !(flags & 0x10); }
  constexpr bool isNoNeedSorted() const
    { return flags & 0x10; }
  constexpr bool isKeepScores() const
    { return !(flags & 0x20); }
  constexpr bool isNoKeepScores() const
    { return flags & 0x20; }
 
private:
  friend std::ostream& operator<<(std::ostream& os, bMoveList const& ml);
 
  inline bool bestMoveHasImproved(bScore const score) const
    { return bSearchScore::realScore(score) > bSearchScore::realScore(getBestMoveScore()); }
  inline bool minMoveHasImproved(bScore const score) const
    { return bSearchScore::realScore(score) < bSearchScore::realScore(getBestMoveScore()); }
 
  bool bestMoveHasImprovedNS(bScore const score) const;
  void addMoveToList(bBasicBoard const& b, bMove& m, bool const isCheckMove);
 
  movelist_t m_lmoves; // = decltype(bMoveList::ml_moves){};
  uint8_t flags = 0; // 0x01 generated
                     // 0x02 sorted
                     // 0x04 large gap in between best and second best move
                     // 0x08 there is at least a possible move
                     // 0x10 no need to sort (random/perft/bf)
                     // 0x20 no need to keep scores (random/perft)
  movenum_t m_nQSMoves = 0;
  movenum_t m_bestmoveid = 0;
};
 
#endif // defined MOVELIST_H
 
// eof