game.h

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: game.h
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#if !defined(GAME_H)
#define GAME_H
 
//-----------------------------------------------------------------------
// helpers for bGame class
 
typedef std::map<std::string, std::string> gameAttributes_t;
typedef std::vector<bBoard> positions_t;
 
//-----------------------------------------------------------------------
 
/** game representation, singleton */
class bGame : public bConfigurableGame {
public:
  bGame();
  virtual ~bGame() override;
 
  bGame(bGame const&) = delete;
  bGame(bGame&&) = delete;
  bGame& operator=(bGame const&) = delete;
  bGame& operator=(bGame&&) = delete;
 
  operator std::string() const;
 
  void newGame();
  void setFEN(std::string const& fenstr);
  void setFENInitialPos();
 
  bool playUIsuppliedMove(std::string const& coordmove);
  bool playGameMove(bCoordMove const& coordmove);
  bool playGameMoveSeries(std::string const& coordmoves);
  void revertGameMove();
 
  std::string getResult(gameResult_t rs) const;
  void setResult(gameResult_t rs);
  gameResult_t getResult() const { return m_result; }
 
  bBoard& getCurrentPosition();
 
  void setLevel(bLevel const& l) { m_level = l; }
  bLevel& getLevel() { return m_level; }
  positions_t& getPositions() { return m_positions; }
  bool getRandom() const { return m_random; }
  void setRandom(bool const r) { m_random = r; }
  void setPlayerName(std::string const& n);
 
  void DoSearch();
  void AbortSearch();
  void WaitForSearchEnd();
 
  bScore EvalForPlayer(bBoard& b);
  bScore MaterialEvalForPlayer(bBoard& b);
  gameResult_t EvalFinalScore(bBoard& b);
 
private:
  std::string movesinpgnformat() const;
 
  gameResult_t m_result = gameResult::GR_UNKNOWN; // TODO: move to last position
  gameAttributes_t m_pgnTags;
  gameAttributes_t m_optTags;
  positions_t m_positions; // TODO: convert to class bPositions
  bLevel m_level;
  bool m_random =
#if defined(BELOFTE_NORANDOM) || defined(_DEBUG)
  false;
#else
  true;
#endif
};
 
//-----------------------------------------------------------------------
 
class bGameWithTest final : public bGame {
public:
  bGameWithTest();
  virtual ~bGameWithTest() final;
 
  int64_t DoPerft(depth_t const d, bSearchAlgorithm& sa);
 
  bEpdResult evalEpdPosition(bFen const& fen, bEpdOpCodes& opcodes,
          epdTest_t const typeOfTest);
  bEpdResult evalPerftResult(bFen const& fen, bEpdOpCodes& opcodes);
 
private:
  bEpdResult evalEpdPosResult(bEpdOpCodes& opcodes, bPgnMove const& m,
          epdTest_t const typeOfTest);
};
 
#endif // defined GAME_H
 
// eof