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
 
bGame::~bGame()
{
}
 
void bGame::newGame()
{
  m_result = GR_UNKNOWN;
  m_pgnTags.clear();
  m_pgnTags["Event"] = "Running on " MYOS " " MYPLATFORM;
  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;
  }
}
 
// TODO: check why copy constructor is called, check if we should return
// anything else but positions.back()
bBoard& bGame::getCurrentPosition()
{
  return m_positions.back();
}
 
/** 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()) {
      m_pgnTags["White"] = App().getConfig("enginename", "");
      m_pgnTags["Black"] = App().getConfig("opponent", "");
    } else {
      m_pgnTags["White"] = App().getConfig("opponent", "");
      m_pgnTags["Black"] = App().getConfig("enginename", "");
    }
    std::thread th(&bGame::WaitForSearchEnd, this);
    th.detach();
  }
}
 
void bGame::AbortSearch()
{
  getAlgorithm()->InterruptSearch();
}
 
/**
 * Called in separate thread, sure to terminate normally
 */
void bGame::WaitForSearchEnd()
{
  bBoard& b = getCurrentPosition();
  try {
    bBestMoveInfo result = getAlgorithm()->SearchBestMove(b);
    bMove m(b.getMove(result.moveid));
    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 (...) { throw; // push other exceptions down
  }
}
 
/** do perft search at depth
 */
int64_t bGame::DoPerft(bSearchAlgorithm& search, int const d)
{
  bLevel oldLevel = m_level;
  bBoard& b = getCurrentPosition();
  m_level.setDepthCommand(static_cast<depth_t>(d));
 
  int iSearchVerbose = App().sout.getLevel();
  App().sout.setLevel(-2);
  int iOutputVerbose = App().bout.getLevel();
  App().bout.setLevel(-1);
 
  try {
    search.SearchBestMove(b);
  } catch (const noMoveFoundException&) {
    // ignore error
  } catch (...) { throw; // push other exceptions down
  }
 
  App().bout.setLevel(iOutputVerbose);
  App().sout.setLevel(iSearchVerbose);
 
  m_level = oldLevel;
  return search.getNodes();
}
 
bScore bGame::EvalForPlayer(bBoard const& b)
{
  return getEval()->getEvaluation(b) * b.minimizing();
}
 
gameResult_t bGame::EvalFinalScore(bBoard const& b)
{
  return getEval()->isGameEnded(b);
}
 
/**
 * Following command should return value as expected
 */
void bGame::setExpecting(std::string const& s)
{
  m_expecting = s;
}
 
// TODO: improve by redirecting App().bout
bool bGame::isExpecting(std::string const& s) const
{
  if (m_expecting == "" || m_expecting == s) {
    return true;
  }
  return false;
}
 
std::string const& bGame::getExpecting() const
{
  return m_expecting;
}
 
std::string bGame::getResult(gameResult_t rs) const
{
  if (rs == GR_UNKNOWN) return "*";
  if ((rs >= GR_DRAW_STALEMATE) && (rs <= GR_DRAW_OTHER)) return "1/2-1/2";
  if ((rs >= GR_WHITEMATES) && (rs <= GR_WHITEWINS_FLAG)) return "1-0";
  return "0-1";
}
 
void bGame::setResult(gameResult_t rs)
{
  m_result = rs;
  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)); });
}
 
bool bGame::playGameMove(bCoordMove const& coordmove)
{
  bBoard& b = getCurrentPosition();
  bMoveList ml(b);
  movenum_t n_moves = ml.getNumberOfMoves();
  for (movenum_t moveid = 1; moveid <= n_moves; moveid++) {
    bMove m(ml[moveid]);
    bCoordMove cm(m);
    if (cm == coordmove) {
      m_positions.emplace_back(b, const_cast<bMove&> (m));
      bScore sc = Game()->EvalForPlayer(getCurrentPosition());
      if ((sc & SCORE_POSITIVE) == SCORE_THEORETIC_DRAW) {
        setResult(GR_DRAW_OTHER);
      } else if ((sc & SCORE_POSITIVE) == SCORE_PUNDEFINED) {
        // skip
      } else if (sc <= (-SCORE_MATE + SCORE_CONVERGE_BYDEPTH)) {
        setResult(b.whiteToMove() ? GR_WHITEMATES : GR_BLACKMATES);
      } else if (sc >= (SCORE_MATE - SCORE_CONVERGE_BYDEPTH)) {
        setResult(b.whiteToMove() ? GR_BLACKMATES : GR_WHITEMATES);
      }
      return true;
    }
  }
  return false;
}
 
/**
 * required for Winboard protocol, not supported in UCI (except debug)
 */
void bGame::revertGameMove()
{
  m_positions.pop_back();
  getCurrentPosition().getMoveListRef().emptyMoveList();
  setResult(GR_UNKNOWN);
}
 
/** do actual epd position test
 */
bEpdResult bGame::evalEpdPosition(bFen const& fen,
        bEpdOpCodes& opcodes)
{
  bEpdResult iReturn;
  newGame();
  setFEN(fen);
  int iOldSoutLevel = App().sout.getLevel();
  App().sout.setLevel(-2);
 
  bBoard& currentPosition = getCurrentPosition();
  try {
    bBestMoveInfo result = getAlgorithm()->SearchBestMove(currentPosition);
    bMove m(currentPosition.getMove(result.moveid));
    bPgnMove pgnmove(currentPosition, m);
    iReturn = evalEpdResult(opcodes, pgnmove);
  } catch (const noMoveFoundException&) {
    iReturn = bEpd::tReturn::NO_MOVE_FOUND;
  } catch (...) { throw; // push other exceptions down
  }
 
  App().sout.setLevel(iOldSoutLevel);
  return iReturn;
}
 
/** check move found against epd line opcodes, change level
 * before starting search
 * am avoid-moves
 * bm best-moves
 * acs # set search seconds
 * acn # set search nodes
 * dm # set direct mate depth
 */
bEpdResult bGame::evalEpdResult(bEpdOpCodes& opcodes, bPgnMove const& m)
{
  if (opcodes.find("bm") != opcodes.end()) {
    belofte::stringList const sMoves = belofte::stringSplit(opcodes["bm"], " ");
    if (std::any_of(sMoves.begin(), sMoves.end(),
            [m](std::string const& sm)
            { return m == sm; })) {
      return bEpd::tReturn::BM_OK;
    }
  } else if (opcodes.find("am") != opcodes.end()) {
    // am and bm are exclusive
    belofte::stringList const sMoves = belofte::stringSplit(opcodes["am"], " ");
    if (std::none_of(sMoves.begin(), sMoves.end(),
            [m](std::string const& sm)
            { return m == sm; })) {
      return bEpd::tReturn::AM_OK;
    }
  } // TODO: implement other opcodes such as mate search
 
  App().bout << "found : " << m << " - ";
  return bEpd::tReturn::NOT_RESOLVED;
}
 
/** check perft result for different depths
 * D[1-99] # perft test - nodes
 */
bEpdResult bGame::evalPerftResult(bFen const& fen,
    bEpdOpCodes& opcodes)
{
  bEpdResult result = bEpd::tReturn::PERFT_OK;
  newGame();
  setFEN(fen);
 
  // Parse all D1-D99 opcodes as perft tests
  for (int i = 1; i <= EPD_PERFTMAXDEPTH; i++) {
    std::string sOp = "D" + belofte::to_string(i);
    if (opcodes.find(sOp) != opcodes.end()) {
      std::string sPerftResult = belofte::alltrim(opcodes[sOp]);
      SearchPerft search;
      int64_t nodes = DoPerft(search, i);
      if (sPerftResult != belofte::to_string(nodes)) {
        App().bout << "found nodes : " << belofte::to_string(nodes) << " - ";
        result = bEpd::tReturn::NOT_RESOLVED;
        break;
      }
    }
  }
 
  return result;
}
 
// 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].whiteToMove()) {
      sMovePrefix << m_positions[0].getMoveNumber() << "... ";
    }
 
    for (unsigned int i = 1; i < m_positions.size(); i++) {
      if (m_positions[i].getMovePlayed()) {
        if (m_positions[i - 1].whiteToMove()) {
          sMovePrefix << m_positions[i].getMoveNumber() << ". ";
        } else if (i > 1) {
          sMovePrefix.str("");
        }
        bBoard b(m_positions[i - 1]);
        bPgnMove pm(b, m_positions[i].getMovePlayed());
        sMoves << sMovePrefix.str() << pm << " ";
      }
    }
    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) {
    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