level.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: level.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#include "belofte.h"
 
// --------------------------------------------------------------------
 
bLevel::bLevel()
  : m_oType{LevelType::Unset}
  , m_nSearchDepth{DEFAULT_DEPTH}
  , m_nQSDepth{DEFAULT_DEPTH * MAXDEPTH_MULTIPLYER + QS_DEPTHEXTENSION}
  , m_nMaxDepth{INFINITE_DEPTH}
{
  flagLevelChanged();
}
 
bLevel::~bLevel()
{
}
 
// --------------------------------------------------------------------
 
void bLevel::flagLevelChanged()
{
  m_levelchanged = true;
}
 
void bLevel::setInfinite()
{
  m_oType = LevelType::Infinite;
 
  m_nSearchDepth = 1;
  m_nQSDepth = INFINITE_DEPTH;
  m_nMaxDepth = INFINITE_DEPTH;
 
  recalibrateTime();
}
 
void bLevel::setGameTime(int const msPerGame)
{
  m_oType = LevelType::SuddenDeath;
  if (m_levelchanged) {
    m_timeForGame = msPerGame;
    m_levelchanged = false;
  }
 
  m_movesPerPeriod = 0;
  m_incrementPerMove = 0;
  m_nTimeLeftForGame = msPerGame;
 
  m_nSearchDepth = DEFAULT_DEPTH;
  m_nQSDepth = DEFAULT_DEPTH * MAXDEPTH_MULTIPLYER + QS_DEPTHEXTENSION;
  m_nMaxDepth = INFINITE_DEPTH;
 
  recalibrateTime();
}
 
void bLevel::setGameTime(int const msPerGame, int const msIncrementPerMove)
{
  m_oType = LevelType::FicherTimeControl;
  if (m_levelchanged) {
    m_timeForGame = msPerGame;
    m_levelchanged = false;
  }
  m_movesPerPeriod = 0;
  m_incrementPerMove = msIncrementPerMove;
 
  m_nTimeLeftForGame = msPerGame;
 
  m_nSearchDepth = DEFAULT_DEPTH;
  m_nQSDepth = DEFAULT_DEPTH * MAXDEPTH_MULTIPLYER + QS_DEPTHEXTENSION;
  m_nMaxDepth = INFINITE_DEPTH;
 
  recalibrateTime();
}
 
void bLevel::setMoveTime(int const msPerMove)
{
  m_oType = LevelType::SecondsPerMove;
  //if (m_levelchanged) {
    m_levelchanged = false;
  //}
  m_movesPerPeriod = 0;
 
  m_nTimeForMove = msPerMove;
 
  m_nSearchDepth = DEFAULT_DEPTH;
  m_nQSDepth = DEFAULT_DEPTH * MAXDEPTH_MULTIPLYER + QS_DEPTHEXTENSION;
  m_nMaxDepth = INFINITE_DEPTH;
 
  // pre-calibration
  m_nTimeForMove -= TIME_LOSTINENGINE;
  m_nMaxTimeForMove = m_nTimeForMove;
  m_nTimeLeftForGame = m_nMaxTimeForMove + TIME_LOSTINENGINE;
 
  recalibrateTime();
}
 
void bLevel::setMoveTime(int const msPerGame, int const nMoves)
{
  m_oType = LevelType::TimeControl;
  if (m_levelchanged) {
    m_timeForGame = msPerGame;
    m_movesPerPeriod = nMoves;
    m_levelchanged = false;
  }
 
  m_incrementPerMove = 0;
  m_nRemainingMovesForPeriod = nMoves;
  m_nTimeLeftForGame = msPerGame;
 
  m_nSearchDepth = DEFAULT_DEPTH;
  m_nQSDepth = DEFAULT_DEPTH * MAXDEPTH_MULTIPLYER + QS_DEPTHEXTENSION;
  m_nMaxDepth = INFINITE_DEPTH;
 
  recalibrateTime();
}
 
void bLevel::setMoveTime(int const msPerGame,
        int const nMoves, int const msIncrementPerMove)
{
  m_oType = LevelType::FicherTimeControl;
  if (m_levelchanged) {
    m_movesPerPeriod = nMoves;
    m_timeForGame = msPerGame;
    m_levelchanged = false;
  }
  m_incrementPerMove = msIncrementPerMove;
 
  m_nRemainingMovesForPeriod = nMoves;
  m_nTimeLeftForGame = msPerGame;
 
  m_nSearchDepth = DEFAULT_DEPTH;
  m_nQSDepth = DEFAULT_DEPTH * MAXDEPTH_MULTIPLYER + QS_DEPTHEXTENSION;
  m_nMaxDepth = INFINITE_DEPTH;
 
  recalibrateTime();
}
 
void bLevel::setMateSearch(depth_t const d)
{
  m_oType = LevelType::MateSearch;
 
  m_nSearchDepth = d;
  m_nQSDepth = d;
  m_nMaxDepth = d;
 
  recalibrateTime();
}
 
/** xboard issues time command to update available time
 */
void bLevel::setRemainingTime(const int msPerGame)
{
  m_nTimeLeftForGame = msPerGame;
 
  int nInc = m_incrementPerMove;
  m_incrementPerMove = 0; // UCI adds time per move before move, so put to 0
  recalibrateTime();
  m_incrementPerMove = nInc;
}
 
void bLevel::setMovePlayed()
{
  m_nRemainingMovesForPeriod--;
  if (m_nRemainingMovesForPeriod < 1)
    m_nRemainingMovesForPeriod = m_movesPerPeriod;
 
  recalibrateTime();
}
 
/** used for recalibrating time in case for undo move in
 *  xboard moves per period
 */
void bLevel::undoMovePlayed()
{
  m_nRemainingMovesForPeriod++;
 
  recalibrateTime();
}
 
void bLevel::recalibrateTime()
{
  // TODO: more intelligent number of moves left
  // 35 at game start with 32 pieces on board, 20 in endgame
  if (m_oType == LevelType::SuddenDeath) {
    m_nTimeForMove = m_nTimeLeftForGame / 20;
    m_nMaxTimeForMove = m_nTimeLeftForGame / 15;
  } else if ((m_oType == LevelType::FicherTimeControl) && m_movesPerPeriod) {
    // avoid divide by zero (TODO consider catching error)
    // TOCHECK code should be avoidable
    if (!m_nRemainingMovesForPeriod) m_nRemainingMovesForPeriod = 1;
    if (m_nRemainingMovesForPeriod <= 4) {
      m_nTimeForMove = m_nTimeLeftForGame / m_nRemainingMovesForPeriod;
      m_nMaxTimeForMove = m_nTimeForMove;
    } else {
      m_nTimeForMove = (m_nTimeLeftForGame / m_nRemainingMovesForPeriod) + m_incrementPerMove;
      m_nMaxTimeForMove = (m_nTimeLeftForGame / (m_nRemainingMovesForPeriod - 3)) + m_incrementPerMove;
    }
  } else if ((m_oType == LevelType::FicherTimeControl) && !m_movesPerPeriod) {
    if (m_nTimeLeftForGame > m_incrementPerMove * 5) {
      m_nTimeForMove = (m_nTimeLeftForGame / 20) + m_incrementPerMove;
      m_nMaxTimeForMove = (m_nTimeLeftForGame / 10) + m_incrementPerMove;
    } else {
      m_nTimeForMove = m_nTimeLeftForGame / 20;
      m_nMaxTimeForMove = m_nTimeLeftForGame / 10;
    }
  } else if ((m_oType == LevelType::TimeControl) && m_movesPerPeriod) {
    // avoid divide by zero (TODO consider catching error)
    // TOCHECK code should be avoidable
    if (!m_nRemainingMovesForPeriod) m_nRemainingMovesForPeriod = 1;
    if (m_nRemainingMovesForPeriod > 10) {
      m_nTimeForMove = m_nTimeLeftForGame / m_nRemainingMovesForPeriod;
      m_nMaxTimeForMove = m_nTimeLeftForGame / (m_nRemainingMovesForPeriod - 5);
    } else {
      m_nTimeForMove = m_nTimeLeftForGame / m_nRemainingMovesForPeriod;
      m_nMaxTimeForMove = m_nTimeForMove;
    }
  }
 
  // make sure that position is not lost because of overhead outside search
  if (m_nMaxTimeForMove > m_nTimeLeftForGame - TIME_LOSTINENGINE)
    m_nMaxTimeForMove = m_nTimeLeftForGame - TIME_LOSTINENGINE;
 
  // temporarily adjust
  m_nTimeForMove = (m_nTimeForMove + m_nMaxTimeForMove) / 2;
 
  if (m_nTimeForMove > m_nMaxTimeForMove)
    m_nTimeForMove = m_nMaxTimeForMove;
 
  m_nEstAllowNextIterationTime = TIME_UNDERFLOWMULTIPLYER
            * m_nTimeForMove / TIME_UNDERFLOWDEVIDER;
 
  m_nAbsoluteAbortTime = m_nTimeForMove * TIME_OVERFLOWMULTIPLYER;
  if (m_nRemainingMovesForPeriod < 1) {
    if (m_nAbsoluteAbortTime > m_nTimeLeftForGame - TIME_LOSTINENGINE - TIME_LASTMOVEMARGIN)
      m_nAbsoluteAbortTime = m_nTimeLeftForGame - TIME_LOSTINENGINE - TIME_LASTMOVEMARGIN;
  } else {
    if (m_nAbsoluteAbortTime > m_nTimeLeftForGame - TIME_LOSTINENGINE)
      m_nAbsoluteAbortTime = m_nTimeLeftForGame - TIME_LOSTINENGINE;
  }
}
 
// --------------------------------------------------------------------
 
void bLevel::setDepthCommand(depth_t const d)
{
  m_nSearchDepth = d;
  m_nQSDepth = d * MAXDEPTH_MULTIPLYER + QS_DEPTHEXTENSION;
  if (m_nQSDepth < DEFAULT_DEPTH * MAXDEPTH_MULTIPLYER + QS_DEPTHEXTENSION)
    m_nQSDepth = DEFAULT_DEPTH * MAXDEPTH_MULTIPLYER + QS_DEPTHEXTENSION;
  m_nMaxDepth = d;
}
 
void bLevel::setSearchDepth(depth_t const d)
{
  m_nSearchDepth = d;
}
 
void bLevel::setMaxDepth(depth_t const d)
{
  m_nMaxDepth = d;
}
 
void bLevel::setNodes(int64_t d)
{
  m_nNodes = d;
}
 
LevelType bLevel::getType() const
{
  return m_oType;
}
 
depth_t bLevel::getSearchDepth() const
{
  return m_nSearchDepth;
}
 
depth_t bLevel::getMaxDepth() const
{
  return m_nMaxDepth;
}
 
void bLevel::setPondering()
{
  m_pondering = true;
}
 
void bLevel::clearPondering()
{
  m_pondering = false;
}
 
bool bLevel::isPondering() const
{
  return m_pondering;
}
 
// --------------------------------------------------------------------
 
bool bLevel::searchDepthReached(depth_t const d) const
{
  return d >= m_nSearchDepth;
}
 
bool bLevel::qsDepthReached(depth_t const d) const
{
  return d >= m_nQSDepth;
}
 
/**
 * Stop search required ?
 * @param nTimeElapsed time elapsed until now
 * @return true if need to stop search
 */
bool bLevel::stoppingSearch(long const nTimeElapsed)
        const
{
  if ((m_oType == LevelType::TimeControl)
          || (m_oType == LevelType::FicherTimeControl)
          || (m_oType == LevelType::SecondsPerMove)
          || (m_oType == LevelType::SuddenDeath)) {
    if (nTimeElapsed > m_nTimeForMove) return true; /// stopping
    if (nTimeElapsed > m_nMaxTimeForMove) return true; /// aborting
    if (nTimeElapsed > m_nAbsoluteAbortTime) return true; /// avoid getting flagged
  }
 
  return false;
}
 
/**
 * Do we still have time to do another iteration ?
 * @param d current depth searched
 * @param nTimeElapsed time elapsed until now
 * @return true if another iteration could be started
 */
bool bLevel::stillTimeLeft(depth_t const d, long const nTimeElapsed) const
{
  if (d < MINIMAL_DEPTH_COMPLETED) return true;
 
  if ((m_oType == LevelType::TimeControl)
          || (m_oType == LevelType::FicherTimeControl)
          || (m_oType == LevelType::SuddenDeath)) {
    if (nTimeElapsed > m_nEstAllowNextIterationTime) return false;
  }
 
  return true;
}
 
// --------------------------------------------------------------------
 
std::string bLevel::prettyDepth(depth_t const d) const
{
  if (d == INFINITE_DEPTH) return "∞";
  if (d) return belofte::to_string(static_cast<int>(d));
  return "-";
}
 
std::string bLevel::prettyMoves(int const d) const
{
  if (d) return belofte::to_string(d);
  return "∞";
}
 
// --------------------------------------------------------------------
 
bLevel::operator std::string() const
{
  std::string s;
  if (m_oType == LevelType::SuddenDeath) {
    s = "SD " + belofte::prettyTime(m_timeForGame)
            + " Left for game = " + belofte::prettyTime(m_nTimeLeftForGame)
            + " for move est/max "
            + belofte::prettyTime(m_nTimeForMove)
            + "/" + belofte::prettyTime(m_nAbsoluteAbortTime);
  } else if ((m_oType == LevelType::FicherTimeControl) && m_movesPerPeriod) {
    s = "FC " + belofte::prettyTime(m_timeForGame)
            + "/" + prettyMoves(m_movesPerPeriod)
            + "+" + belofte::prettyTime(m_incrementPerMove)
            + " Left for #" + prettyMoves(m_nRemainingMovesForPeriod)
            + " moves = " + belofte::prettyTime(m_nTimeLeftForGame)
            + " for move est/max "
            + belofte::prettyTime(m_nTimeForMove)
            + "/" + belofte::prettyTime(m_nAbsoluteAbortTime);
  } else if ((m_oType == LevelType::FicherTimeControl) && !m_movesPerPeriod) {
    s = "FC " + belofte::prettyTime(m_timeForGame)
            + "+" + belofte::prettyTime(m_incrementPerMove)
            + " Left for game = " + belofte::prettyTime(m_nTimeLeftForGame)
            + " for move est/max "
            + belofte::prettyTime(m_nTimeForMove)
            + "/" + belofte::prettyTime(m_nAbsoluteAbortTime);
  } else if (m_oType == LevelType::TimeControl) {
    s = "TC " + belofte::prettyTime(m_timeForGame)
            + "/" + prettyMoves(m_movesPerPeriod)
            + " Left for #" + prettyMoves(m_nRemainingMovesForPeriod)
            + " moves = " + belofte::prettyTime(m_nTimeLeftForGame)
            + " for move est/max "
            + belofte::prettyTime(m_nTimeForMove)
            + "/" + belofte::prettyTime(m_nAbsoluteAbortTime);
  } else if (m_oType == LevelType::SecondsPerMove) {
    s = "ST " + belofte::prettyTime(m_nTimeLeftForGame)
            + " Time left for move = " + belofte::prettyTime(m_nTimeForMove);
  } else if (m_oType == LevelType::MateSearch) {
    s = "Search mate in " + belofte::to_string(static_cast<int>(m_nSearchDepth));
  } else if (m_oType == LevelType::Infinite) {
    s = "∞ search";
  } else if (m_oType == LevelType::Unset) {
    s = "No level set";
  } else {
    s = "To be implemented";
  }
 
  if (m_oType != LevelType::MateSearch) {
    if (m_nMaxDepth != INFINITE_DEPTH) {
      s += ", depth limited to " + belofte::to_string(static_cast<int>(m_nMaxDepth));
    }
  }
 
  return s;
}
 
// eof