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();
  ~bGame() override
    {}
 
  bGame(bGame const&) = delete;
  bGame(bGame&&) = delete;
  bGame& operator=(bGame const&) = delete;
  bGame& operator=(bGame&&) = delete;
 
  void newGame();
  void setFEN(std::string const& fenstr);
  void setFENInitialPos();
 
  bool playGameMoveSeries(std::string const& coordmoves);
  bool playPGNMoves(std::string const& sPGNMoveList);
  void revertGameMove(std::string const& reason);
 
  static std::string getResult(gameResult_t gr);
  void setResult(gameResult_t gr);
  gameResult_t getResult() const
    { return m_result; }
 
  bool isExpecting(std::string const& s) const
    { /// @todo improve by redirecting App().bout
      return (m_expecting == "" || m_expecting == s); }
  void setExpecting(std::string const& s)
    { m_expecting = s; }
  std::string const& getExpecting() const
    { return m_expecting; }
 
  /// @todo check why copy constructor is called, check if we should return
  /// anything else but positions.back()
  bBoard& getCurrentPosition()
    { return m_positions.back(); }
 
  void setLevel(bLevel const& l)
    { m_level = l; }
  bLevel& getLevel()
    { return m_level; }
  positions_t& getPositions()
    { return m_positions; }
  void setPlayerName(std::string const& n);
 
  void DoSearch();
  void AbortSearch();
  void WaitForSearchEnd();
 
  bScore EvalForPlayer(bBoard const& b, gameResult_t gr);
 
  // test related elements
  int64_t DoPerftCommand(depth_t const d);
  int64_t DoPerft(bSearchAlgorithm& sa, depth_t const d);
  bMove getEpdMoveInPosition(bFen const& fen);
 
  inline void setStandardPgn(bool const l)
    { standardPGN = l; }
  constexpr bool isStandardPgn() const
    { return standardPGN; }
  inline void setSearching(bool const l)
    { isInSearch = l; }
  constexpr bool isSearching() const
    { return isInSearch; }
 
  operator std::string() const;
 
private:
  bool playGameMove(bCoordMove const& coordmove);
  std::string movesinpgnformat() const;
 
  bool standardPGN = true;
  bool isInSearch = false;
  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;
  std::string m_expecting; // next command should return according to expectation
};
 
#endif // defined GAME_H
 
// eof