game.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: game.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#include "belofte.h"
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif
 
bGame::bGame()
{
  newGame();
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
void bGame::newGame()
{
  m_result = GR_UNKNOWN;
  m_pgnTags.clear();
#if defined(_DEBUG)
  m_pgnTags["Event"] = "Debugging on " MYOS " " MYPLATFORM;
#else
  m_pgnTags["Event"] = "Running on " MYOS " " MYPLATFORM;
#endif
  m_pgnTags["Site"] = "";
  m_pgnTags["Date"] = belofte::currentDate();
  m_pgnTags["Round"] = "";
  m_pgnTags["White"] = MYNAME " " MYVERSION " build " MYRELEASEDATE;
  m_pgnTags["Black"] = MYNAME " " MYVERSION " build " MYRELEASEDATE;
  m_pgnTags["Result"] = getResult(m_result);
  m_optTags.clear();
  m_optTags["eloWhite"] = "";
  m_optTags["eloBlack"] = "";
  m_positions.clear();
  getLevel().flagLevelChanged();
}
 
void bGame::setFENInitialPos()
{
  m_positions.clear();
  m_positions.emplace_back(bFen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"));
  m_optTags.erase("SetUp");
  m_optTags.erase("FEN");
}
 
void bGame::setFEN(std::string const& fenstr)
{
  m_positions.clear();
  m_positions.emplace_back(bFen(fenstr));
  m_optTags["SetUp"] = "1";
  m_optTags["FEN"] = fenstr;
}
 
void bGame::setPlayerName(std::string const& n)
{
  if (getCurrentPosition().whiteToMove()) {
    m_pgnTags["White"] = n;
  } else {
    m_pgnTags["Black"] = n;
  }
}
 
/**
 * Start search thread and exit
 * in case of batch mode, will wait until end of search
 */
void bGame::DoSearch()
{
  if (App().m_reader.isBatchMode()) {
    /// in case of batch mode, do not start separate thread for searching
    /// @todo allow for cancel search with ? / stop command
    WaitForSearchEnd();
  } else {
    if (getCurrentPosition().whiteToMove()) {
      std::string player = App().getConfig("enginename", "");
      if (!player.empty()) m_pgnTags["White"] = player;
      std::string opponent = App().getConfig("opponent", "");
      if (!opponent.empty()) m_pgnTags["Black"] = opponent;
    } else {
      std::string player = App().getConfig("enginename", "");
      if (!player.empty()) m_pgnTags["Black"] = player;
      std::string opponent = App().getConfig("opponent", "");
      if (!opponent.empty()) m_pgnTags["White"] = opponent;
    }
    std::thread th(&bGame::WaitForSearchEnd, std::ref(*this));
    th.detach();
  }
}
 
void bGame::AbortSearch()
{
  getAlgorithm()->InterruptSearch();
}
 
/**
 * Called in separate thread, sure to terminate normally
 */
void bGame::WaitForSearchEnd()
{
  bBoard& b = getCurrentPosition();
  try {
    bMoveList ml;
    getAlgorithm()->SearchBestMove(b, ml);
    bMove m(ml[ml.getBestMoveId()]);
    AppEI()->sendMove(b, m);
    playGameMove(bCoordMove(m));
    AppEI()->sendResult(b, getResult());
  } catch (const noMoveFoundException&) {
    // ignore error
    AppEI()->sendError("no move found", "Wait for search");
  } catch (const gameEndException&) {
    // we already sent result earlier
    /// @todo handle sending result here
  } catch (...) { throw; // push other exceptions down
  }
}
 
/**
 * do perft search using SearchPerft algorithm at depth
 */
int64_t bGame::DoPerftCommand(depth_t const d)
{
  SearchPerft search;
  return DoPerft(search, d);
}
 
/**
 * do perft search at depth
 * in case of Perft algorithm, temporarily set evaltype to None
 */
int64_t bGame::DoPerft(bSearchAlgorithm& sa, depth_t const d)
{
  bLevel oldLevel(m_level);
  bBoard& b = getCurrentPosition();
  m_level.setDepthCommand(d);
 
  std::string sAlgName = getAlgorithm()->operator std::string();
  std::string sEval = getEval()->operator std::string();
 
  if (sAlgName == "Perft") setEval("None");
 
  int iSearchVerbose = App().sout.getLevel();
  App().sout.setLevel(-2);
  int iOutputVerbose = App().bout.getLevel();
  App().bout.setLevel(-1);
 
  try {
    bMoveList ml;
    sa.setBench();
    sa.SearchBestMove(b, ml);
    sa.clearBench();
  } catch (const noMoveFoundException&) {
    // ignore error
  } catch (...) { throw; // push other exceptions down
  }
 
  App().bout.setLevel(iOutputVerbose);
  App().sout.setLevel(iSearchVerbose);
 
  if (sAlgName == "Perft") setEval(sEval);
 
  m_level = oldLevel;
  return sa.getNodes();
}
 
bScore bGame::EvalForPlayer(bBoard const& b, gameResult_t gr)
{
  return getEval()->getEvaluation(b, gr) * b.minimizing();
}
 
std::string bGame::getResult(gameResult_t gr)
{
  if (gr == GR_UNKNOWN) return "*";
  if (bPositionEvaluation::isDrawResult(gr)) return "1/2-1/2";
  if ((gr >= GR_WHITEMATES) && (gr <= GR_WHITEWINS_FLAG)) return "1-0";
  return "0-1";
}
 
void bGame::setResult(gameResult_t gr)
{
  m_result = gr;
  m_pgnTags["Result"] = getResult(m_result);
}
 
/**
 * all moves in a single string
 * @return false if one move cannot be played
 */
bool bGame::playGameMoveSeries(std::string const& coordmoves)
{
  std::vector<std::string> vstrings = belofte::stringSplit(coordmoves, " ");
 
  return std::all_of(vstrings.begin(), vstrings.end(),
    [this](std::string const& s)
            { return this->playGameMove(bCoordMove(s)) || this->playPGNMoves(s); });
}
 
/**
 * apply move, it will change the current board by updating the move played
 * it will also add the new board to the game positions list
 */
bool bGame::playGameMove(bCoordMove const& coordmove)
{
  bBoard const& b = getCurrentPosition();
  bMoveList ml;
  ml.clearNeedSorted();
  ml.clearKeepScores();
  ml.generateMoves(b);
  movenum_t n_moves = ml.getNumberOfMoves();
  for (ml.curmoveid = 1; ml.curmoveid <= n_moves; ++ml.curmoveid) {
    bMove const& m(ml[ml.curmoveid]);
    bCoordMove cm(m);
    if (cm == coordmove) {
      bBoard newboard(b);
      newboard.applyMove(m);
      newboard.setMove(m.getFromTo());
      newboard.calcGameStage();
      m_positions.push_back(newboard);
      bScore sc = Game()->EvalForPlayer(newboard, GR_UNSET);
      if (bSearchScore::isDrawScore(sc)) {
        setResult(GR_DRAW_OTHER);
      } else if (bSearchScore::isUndefinedScore(sc)) {
        // skip
      } else if (sc == -SCORE_MATE) {
        setResult(b.whiteToMove() ? GR_WHITEMATES : GR_BLACKMATES);
      } else if (sc == SCORE_MATE) {
        setResult(b.whiteToMove() ? GR_BLACKMATES : GR_WHITEMATES);
      }
      return true;
    }
  }
  return false;
}
 
/**
 * apply move, it will change the current board by updating the move played
 * it will also add the new board to the game positions list
 * @return true if at least a single move has been applied to position
 */
bool bGame::playPGNMoves(std::string const& sPGNMoveList)
{
  auto filterMoveNum = [](const std::string& str) -> std::string {
    // filter out move-number, score (*,1-0,1/2-1/2) and newlines
    size_t n = str.find_first_not_of("0123456789. */-\r\n\t");
    return (n == std::string::npos) ? "" : str.substr(n);
  };
 
  bool hasPlayedMove = false;
 
  std::regex commentsPatern("\\{[^}]*\\}");
  std::string sMoveList = std::regex_replace(sPGNMoveList, commentsPatern, "");
  std::regex alternativesPatern("\\([^)]*\\)");
  sMoveList = std::regex_replace(sPGNMoveList, alternativesPatern, "");
  belofte::stringList sMoves = belofte::stringSplit(sMoveList, " ");
  if (sMoves.size() > 0) {
    for (auto it = sMoves.begin(); it != sMoves.end(); ++it) {
      bBoard const& b = getCurrentPosition();
      bMoveList ml;
      movenum_t n_moves = ml.generateMoves(b);
      std::string sMove = filterMoveNum(*it);
      for (ml.curmoveid = 1; ml.curmoveid <= n_moves; ++ml.curmoveid) {
        bMove const& m(ml[ml.curmoveid]);
        bPgnMove pm(b, m.getBMoveT());
        if (pm == sMove) {
          bCoordMove cm(m);
          if (playGameMove(cm)) hasPlayedMove = true;
        }
      }
    }
  }
 
  return hasPlayedMove;
}
 
/**
 * required for Winboard protocol, not supported in UCI (except debug)
 */
void bGame::revertGameMove(std::string const& reason)
{
  if (m_positions.size() > 1) {
    m_positions.pop_back();
    setResult(GR_UNKNOWN);
    getCurrentPosition().clearMove();
  } else {
    AppEI()->sendError("cannot undo move", reason);
  }
}
 
/**
 * do actual epd position test
 */
bMove bGame::getEpdMoveInPosition(bFen const& fen)
{
  bMove m;
 
  int iOldSoutLevel = App().sout.getLevel();
  App().sout.setLevel(-2);
 
  newGame();
  setFEN(fen);
  bBoard& b = getCurrentPosition();
  try {
    bMoveList ml;
    getAlgorithm()->SearchBestMove(b, ml);
    m = ml[ml.getBestMoveId()];
  } catch (const noMoveFoundException&) {
    // not returning no move found
  } catch (...) { throw; // push other exceptions down
  }
 
  App().sout.setLevel(iOldSoutLevel);
  return m;
}
 
/// @todo Look at using stream and << operator instead of string
std::string bGame::movesinpgnformat() const
{
  std::stringstream sMoves;
  std::stringstream sMovePrefix;
 
  if (m_positions.size() > 1) {
    if (m_positions[0].blackToMove()) {
      sMovePrefix << m_positions[0].getMoveNumber() << "... ";
    }
 
    for (unsigned int i = 1; i < m_positions.size(); ++i) {
      bBoard newboard(m_positions[i]);
      bBoard ob(m_positions[i - 1]);
      if (newboard.getMove()) {
        if (ob.whiteToMove()) {
          sMovePrefix << newboard.getMoveNumber() << ". ";
        }
        bPgnMove pm(ob, newboard.getMove());
        sMoves << sMovePrefix.str() << pm << " ";
        sMovePrefix.str("");
      }
    }
  }
 
  sMoves << getResult(getResult());
  return sMoves.str();
}
 
/// @todo Look at using stream and << operator instead of std::string
bGame::operator std::string() const
{
  std::string sGameHeader;
 
  // Export tags (7-tag roster)
  for (auto const& x : m_pgnTags) {
    if (isStandardPgn() || x.second.size()) {
      sGameHeader += "[" + x.first + " \"" + x.second + "\"]" + "\n";
    }
  }
 
  // only in extended PGN format, for values that are present
  for (auto const& x : m_optTags) {
    if (x.second.size()) {
      sGameHeader += "[" + x.first + " \"" + x.second + "\"]" + "\n";
    }
  }
  return sGameHeader + "\n" + movesinpgnformat();
}
 
// eof