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 = 3;
constexpr depth_t MAXDEPTH_MULTIPLYER = 2;
constexpr depth_t QS_DEPTHEXTENSION = 5;
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 = 3;
 
/// 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 final {
public:
  bLevel();
  ~bLevel();
 
  bLevel(bLevel const&) = default;
  bLevel& operator=(bLevel const&) = default;
 
  // no move ctor or assignment defined
  bLevel(bLevel&&) = delete;
  bLevel& operator=(bLevel&&) = delete;
 
  operator std::string() const;
 
  void flagLevelChanged(); /// new level or new game
 
  // 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);
 
  // level modifiers, before start of search
  void setMoves(std::string movelist);
  void setNodes(int64_t n);
  void setPondering();
  void clearPondering();
  bool isPondering() const;
 
  // level info
  LevelType getType() const;
  void setSearchDepth(depth_t const d);
  depth_t getSearchDepth() const;
  void setQSDepth(depth_t const d) { m_nQSDepth = d; }
  depth_t getQSDepth() const { return m_nQSDepth; }
  void setMaxDepth(depth_t const d);
  depth_t getMaxDepth() const;
 
  // 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();
 
private:
  void recalibrateTime();
  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