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"
 
// --------------------------------------------------------------------
 
void bLevel::setInfinite()
{
  m_oType = LevelType::Infinite;
 
  setSearchDepth(1);
  setQSDepth(INFINITE_DEPTH);
  setMaxDepth(INFINITE_DEPTH);
 
  recalibrateTime();
}
 
void bLevel::setGameTime(int const msPerGame)
{
  m_oType = LevelType::SuddenDeath;
  if (hasLevelChanged()) {
    m_timeForGame = msPerGame;
    clearLevelChanged();
  }
 
  m_movesPerPeriod = 0;
  m_incrementPerMove = 0;
  m_nTimeLeftForGame = msPerGame;
 
  setSearchDepth(DEFAULT_DEPTH);
  setMaxDepth(INFINITE_DEPTH);
 
  recalibrateTime();
}
 
void bLevel::setGameTime(int const msPerGame, int const msIncrementPerMove)
{
  m_oType = LevelType::FicherTimeControl;
  if (hasLevelChanged()) {
    m_timeForGame = msPerGame;
    clearLevelChanged();
  }
  m_movesPerPeriod = 0;
  m_incrementPerMove = msIncrementPerMove;
 
  m_nTimeLeftForGame = msPerGame;
 
  setSearchDepth(DEFAULT_DEPTH);
  setMaxDepth(INFINITE_DEPTH);
 
  recalibrateTime();
}
 
void bLevel::setMoveTime(int const msPerMove)
{
  m_oType = LevelType::SecondsPerMove;
  if (hasLevelChanged()) {
    clearLevelChanged();
  }
  m_movesPerPeriod = 0;
 
  m_nTimeForMove = msPerMove;
 
  setSearchDepth(DEFAULT_DEPTH);
  setMaxDepth(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 (hasLevelChanged()) {
    m_timeForGame = msPerGame;
    m_movesPerPeriod = nMoves;
    clearLevelChanged();
  }
 
  m_incrementPerMove = 0;
  m_nRemainingMovesForPeriod = nMoves;
  m_nTimeLeftForGame = msPerGame;
 
  setSearchDepth(DEFAULT_DEPTH);
  setMaxDepth(INFINITE_DEPTH);
 
  recalibrateTime();
}
 
void bLevel::setMoveTime(int const msPerGame,
        int const nMoves, int const msIncrementPerMove)
{
  m_oType = LevelType::FicherTimeControl;
  if (hasLevelChanged()) {
    m_movesPerPeriod = nMoves;
    m_timeForGame = msPerGame;
    clearLevelChanged();
  }
  m_incrementPerMove = msIncrementPerMove;
 
  m_nRemainingMovesForPeriod = nMoves;
  m_nTimeLeftForGame = msPerGame;
 
  setSearchDepth(DEFAULT_DEPTH);
  setMaxDepth(INFINITE_DEPTH);
 
  recalibrateTime();
}
 
void bLevel::setMateSearch(depth_t const d)
{
  m_oType = LevelType::MateSearch;
 
  setSearchDepth(d);
  setQSDepth(d);
  setMaxDepth(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 / 24;
    m_nMaxTimeForMove = m_nTimeLeftForGame / 12;
  } else if (m_oType == LevelType::FicherTimeControl) {
    if (m_movesPerPeriod) {
      // FC control with moves per period, meaning it can repeat after this
      if (!m_nRemainingMovesForPeriod) {
        // avoid divide by zero
        m_nRemainingMovesForPeriod = 1;
      }
      m_nTimeForMove = (m_nTimeLeftForGame / (m_nRemainingMovesForPeriod + 1)) + m_incrementPerMove;
      if (m_nRemainingMovesForPeriod > 3) {
        m_nMaxTimeForMove = (m_nTimeLeftForGame / (m_nRemainingMovesForPeriod/3)) + m_incrementPerMove / 2;
      } else {
        m_nMaxTimeForMove = m_nTimeForMove;
      }
    } else {
      // FC without period cut-off, so we need to be less generous at giving time
      m_nTimeForMove = (m_nTimeLeftForGame / 20) + m_incrementPerMove;
      m_nMaxTimeForMove = (m_nTimeLeftForGame / 10) + m_incrementPerMove;
    }
  } else if ((m_oType == LevelType::TimeControl) && m_movesPerPeriod) {
      if (!m_nRemainingMovesForPeriod) {
        // avoid divide by zero
        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;
 
  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_nAbsoluteAbortTime < m_nMaxTimeForMove) m_nAbsoluteAbortTime = m_nMaxTimeForMove;
 
  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)
{
  setSearchDepth(d);
  setMaxDepth(d);
}
 
void bLevel::setSearchDepth(depth_t const d)
{
  m_nSearchDepth = d;
  adjustQSDepth();
}
 
void bLevel::adjustQSDepth()
{
  setQSDepth(getSearchDepth() + QS_DEPTHEXTENSION);
}
 
// --------------------------------------------------------------------
 
bool bLevel::searchDepthReached(depth_t const d) const
{
  return d >= getSearchDepth();
}
 
bool bLevel::qsDepthReached(depth_t const d) const
{
  return d >= getQSDepth();
}
 
/**
 * 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_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;
}
 
/**
 * increase gradually the allowed time for move, first
 * move to max time for move, then move to abort time
 */
void bLevel::setMoreTimeRequired()
{
  if (m_nTimeForMove == m_nMaxTimeForMove) {
    // second increase, also move next iteration
    m_nTimeForMove = m_nAbsoluteAbortTime - TIME_LOSTINENGINE;
    m_nEstAllowNextIterationTime = m_nAbsoluteAbortTime - TIME_LASTMOVEMARGIN;
  } else {
    m_nTimeForMove = m_nMaxTimeForMove;
  }
}
 
// --------------------------------------------------------------------
 
std::string bLevel::prettyDepth(depth_t const d) const
{
  if (d == INFINITE_DEPTH) return "∞";
  if (d) return belofte::to_string(static_cast<int16_t>(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/abt "
            + belofte::prettyTime(m_nTimeForMove)
            + "/" + belofte::prettyTime(m_nMaxTimeForMove)
            + "/" + 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/abt "
            + belofte::prettyTime(m_nTimeForMove)
            + "/" + belofte::prettyTime(m_nMaxTimeForMove)
            + "/" + 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/abt "
            + belofte::prettyTime(m_nTimeForMove)
            + "/" + belofte::prettyTime(m_nMaxTimeForMove)
            + "/" + 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/abt "
            + belofte::prettyTime(m_nTimeForMove)
            + "/" + belofte::prettyTime(m_nMaxTimeForMove)
            + "/" + 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<int16_t>(getSearchDepth()));
  } 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 (getMaxDepth() != INFINITE_DEPTH) {
      s += ", depth limited to " + belofte::to_string(static_cast<int16_t>(getMaxDepth()));
    }
  }
 
  return s;
}
 
// eof