level.h

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: level.h
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#if !defined(LEVEL_H)
#define LEVEL_H
 
constexpr depth_t INFINITE_DEPTH = 50;
constexpr depth_t DEFAULT_DEPTH = 5;
constexpr depth_t QS_DEPTHEXTENSION = 4;
constexpr auto MINIMAL_DEPTH_COMPLETED = 1;
constexpr auto TIME_OVERFLOWMULTIPLYER = 2;
 
constexpr auto TIME_UNDERFLOWMULTIPLYER = 2;
// formula time-elapsed > multiplier * movetime / divider
// 1,3 equals 33% 1,2 equals 50%, 2,3 equals 66%
constexpr auto TIME_UNDERFLOWDEVIDER = 2;
 
/// time lost in between UI go command and bestmove return
/// @todo replace based on actual measurements
constexpr auto TIME_LOSTINENGINE = 50;
constexpr auto TIME_LASTMOVEMARGIN = 100;
 
/** Implements clock
 * n seconds per game    - setGameTime(seconds * 1000)
 * n seconds per game, increment inc seconds per move
 *                       - setGameTime(seconds * 1000,  inc * 1000)
 * n seconds per move    - setMoveTime(seconds * 1000)
 * n seconds per x moves - setMoveTime(seconds * 1000, x)
 * n seconds per x moves, increment inc seconds per move
 *                       - setMoveTime(seconds * 1000, x, inc * 1000)
 * infinite              - setInfinite()
 * mate search           - setMateSearch(depth)
 *
 * restrict to depth x   - setDepthCommand(depth)
 * @todo restrict to n nodes   - setNodes(nodes)
 * @todo restrict to moves     - setMoves(moves)
 *
 * start pondering       - setPondering()
 */
 
enum class LevelType {Unset, SecondsPerMove,
        SuddenDeath, TimeControl, FicherTimeControl, Infinite, MateSearch};
 
class bLevel {
public:
  bLevel()
    : m_oType{LevelType::Unset}
    , m_nSearchDepth{DEFAULT_DEPTH}
    , m_nQSDepth{DEFAULT_DEPTH + QS_DEPTHEXTENSION}
    , m_nMaxDepth{INFINITE_DEPTH}
    { flagLevelChanged(); }
  ~bLevel()
    {}
 
  bLevel(bLevel const&) = default;
  bLevel& operator=(bLevel const&) = default;
 
  // no move ctor or assignment defined
  bLevel(bLevel&&) = delete;
  bLevel& operator=(bLevel&&) = delete;
 
  constexpr bool hasLevelChanged() const
    { return m_levelchanged; }
  inline void flagLevelChanged()
    { m_levelchanged = true; } /// new level or new game
  inline void clearLevelChanged()
    { m_levelchanged = false; }
 
  // specific levels
  void setGameTime(int const msPerGame);
  void setGameTime(int const msPerGame, int const msIncrementPerMove);
  void setMoveTime(int const msPerMove);
  void setMoveTime(int const msPerGame, int const nMoves);
  void setMoveTime(int const msPerGame, int const nMoves, int const msIncrementPerMove);
  void setInfinite();
  void setMateSearch(depth_t const d);
  void setMoreTimeRequired();
 
  // level modifiers, before start of search
  void setMoves(std::string movelist);
  inline void setNodes(int64_t const n)
    { m_nNodes = n; }
  inline void setPondering()
    { m_pondering = true; }
  inline void clearPondering()
    { m_pondering = false; }
  constexpr bool isPondering() const
    { return m_pondering; }
 
  // level info
  constexpr LevelType getType() const
    { return m_oType; }
  void setSearchDepth(depth_t const d); // also adjusts QS depth
  constexpr depth_t getSearchDepth() const
    { return m_nSearchDepth; }
  inline void setQSDepth(depth_t const d)
    { m_nQSDepth = d; }
  constexpr depth_t getQSDepth() const
    { return m_nQSDepth; }
  inline void setMaxDepth(depth_t const d)
    { m_nMaxDepth = d; }
  constexpr depth_t getMaxDepth() const
    { return m_nMaxDepth; }
 
  // level search decisions
  void setDepthCommand(depth_t const d);
  bool searchDepthReached(depth_t const d) const;
  bool qsDepthReached(depth_t const d) const;
  bool stoppingSearch(long const nTimeElapsed) const;
  bool stillTimeLeft(depth_t const d, long const nTimeElapsed) const;
 
  // level update
  void setRemainingTime(int const msPerGame);
  void setMovePlayed();
  void undoMovePlayed();
 
  operator std::string() const;
 
private:
  void recalibrateTime();
  void adjustQSDepth();
  std::string prettyDepth(depth_t const d) const;
  std::string prettyMoves(int const d) const;
 
  LevelType m_oType;
  depth_t m_nSearchDepth;
  depth_t m_nQSDepth;
  depth_t m_nMaxDepth;
 
  int m_nTimeForMove = 0; /// indicative time for searching
  int m_nTimeLeftForGame = 0; /// total time left for n moves or game
  int m_nRemainingMovesForPeriod = 0; /// total time left for next time control
 
  // aborting time control
  int m_nMaxTimeForMove = 0; /// time when to abort search
  int m_nEstAllowNextIterationTime = 0; /// indicative time for next iteration
  int m_nAbsoluteAbortTime = 0; /// time after which an abort if forced
 
  // level as set initially
  bool m_levelchanged = true;
  bool m_pondering = false;
  int64_t m_nNodes = 0; /// maximum number of nodes allowed
  int m_timeForGame = 0; /// total time per game set
  int m_movesPerPeriod = 0; /// number of moves per period
  int m_incrementPerMove = 0; /// number of milliseconds added each move
};
 
#endif // defined LEVEL_H
 
// eof