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 auto INFINITE_DEPTH = 50;
constexpr auto DEFAULT_DEPTH = 1;
constexpr auto QSDEPTH_MULTIPLYER = 2;
constexpr auto QS_DEPTHEXTENSION = 5;
constexpr auto MINIMAL_DEPTH_COMPLETED = 1;
constexpr auto TIME_OVERFLOWMULTIPLYER = 3;
 
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 = 5;
 
/// 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;
 
constexpr auto DEFAULT_MOVETIME = 3000 + TIME_LOSTINENGINE;
 
/** 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   - setDepth(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& operator=(bLevel const&) = default;
 
  // no copy or move ctor nor assignment defined
  bLevel(bLevel const&) = delete;
  bLevel(bLevel&&) = delete;
  bLevel& operator=(bLevel&&) = delete;
 
  operator std::string() const;
 
  void flagLevelChange(); /// 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 const n);
  void initDepths(depth_t const d);
  void setPondering();
  void clearPondering();
  bool isPondering() const;
 
  // level info
  LevelType getType() const;
  depth_t getDepth() const;
 
  // level search decisions
  void setDepth(depth_t const d);
  bool depthReached(depth_t const d) const;
  bool qsDepthReached(depth_t const d) const;
  bool stoppingSearch(int64_t const nodes, 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();
  void setEstimatedMovesLeft(int const n) { m_movesleftingame = n; }
 
private:
  void recalibrateTime();
  std::string prettyDepth(depth_t const d) const;
  std::string prettyMoves(int const d) const;
 
  LevelType m_oType;
  depth_t m_nDepth = DEFAULT_DEPTH;
  depth_t m_nQSDepth = DEFAULT_DEPTH * QSDEPTH_MULTIPLYER + QS_DEPTHEXTENSION;
 
  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
  int m_movesleftingame = 32; /// estimated number of moves left in game (for some time controls)
 
  // 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