game.h

Go to the documentation of this file.

#ifndef GAME_H
#define GAME_H
 
 
#include "ccfwd.h"
#include "message.h"
#include "piece.h"
#include "pieces.h"
#include "action_history.h"
#include "starting_position_type.h"
#include "fen_string.h"
 
#include <iosfwd>
#include <vector>
#include <optional>
 
class game
{
public:
  explicit game(const std::vector<piece>& pieces = get_standard_starting_pieces());
 
  auto& get_pieces() noexcept { return m_pieces; }
 
  const auto& get_pieces() const noexcept { return m_pieces; }
 
  const auto& get_in_game_time() const noexcept { return m_in_game_time; }
 
  const auto& get_winner() const noexcept { return m_winner; }
 
  void tick(const delta_t& dt);
 
private:
 
  std::vector<piece> m_pieces;
 
  in_game_time m_in_game_time;
 
  std::optional<chess_color> m_winner;
 
  void check_all_occupied_squares_are_unique() const;
 
 
  void check_game_and_pieces_agree_on_the_time() const;
 
  void check_if_there_is_a_winner();
 
  void tick_impl(const delta_t& dt);
 
  friend game create_game_with_starting_position(starting_position_type t) noexcept;
};
 
bool can_castle_kingside(const piece& p, const game& g) noexcept;
 
bool can_castle_queenside(const piece& p, const game& g) noexcept;
 
bool can_do_attack(
  const game& g,
  const piece& selected_piece,
  const square& cursor_square,
  const chess_color player_color
);
 
bool can_do_castle_kingside(
  const game& g,
  const piece& selected_piece,
  const chess_color player_color
);
 
bool can_do_castle_queenside(
  const game& g,
  const piece& selected_piece,
  const chess_color player_color
);
 
bool can_do_en_passant(
  const game& g,
  const piece& selected_piece,
  const square& cursor_square,
  const chess_color player_color
);
 
bool can_do_move(
  const game& g,
  const piece& selected_piece,
  const square& cursor_square,
  const chess_color player_color
);
 
bool can_do_promote(
  const piece& selected_piece,
  const chess_color player_color
);
 
void clear_piece_messages(game& g) noexcept;
 
action_history collect_action_history(const game& g);
 
std::vector<piece_action> collect_all_piece_actions(const game& g);
 
std::vector<piece_action> collect_all_piece_actions(
  const game& g,
  const chess_color player_color
);
 
std::vector<piece_action> collect_all_piece_actions(
  const game& g,
  const piece& p
);
 
std::vector<piece_action> collect_all_bishop_actions(
  const game& g,
  const piece& p
);
 
std::vector<piece_action> collect_all_king_actions(
  const game& g,
  const piece& p
);
 
std::vector<piece_action> collect_all_knight_actions(
  const game& g,
  const piece& p
);
 
std::vector<piece_action> collect_all_pawn_actions(
  const game& g,
  const piece& p
);
 
std::vector<piece_action> collect_all_pawn_attack_actions(
  const game& g,
  const piece& p
);
 
std::vector<piece_action> collect_all_pawn_en_passant_actions(
  const game& g,
  const piece& p
);
 
std::vector<piece_action> collect_all_pawn_move_actions(
  const game& g,
  const piece& p
);
 
std::vector<piece_action> collect_all_queen_actions(
  const game& g,
  const piece& p
);
 
std::vector<piece_action> collect_all_rook_actions(
  const game& g,
  const piece& p
);
 
std::vector<message> collect_messages(const game& g) noexcept;
 
std::vector<message_type> collect_message_types(const game& g) noexcept;
 
int count_piece_actions(const game& g);
 
int count_piece_actions(
  const game& g,
  const chess_color player
);
 
game create_game_from_fen_string(const fen_string& s) noexcept;
 
game create_game_with_standard_starting_position() noexcept;
 
game create_game_with_starting_position(
  starting_position_type t,
  const race lhs_race = race::classic,
  const race rhs_race = race::classic
) noexcept;
 
std::vector<piece> find_pieces(
  const game& g,
  const piece_type type,
  const chess_color color
);
 
const piece& get_closest_piece_to(const game& g, const game_coordinate& coordinat);
 
piece& get_closest_piece_to(game& g, const game_coordinate& coordinat);
 
 
 
int get_index_of_closest_piece_to(
  const game& g,
  const game_coordinate& coordinat
);
 
/*
game get_kings_only_game() noexcept;
*/
std::vector<square> get_unique_occupied_squares(const game& g) noexcept;
 
 
std::vector<square> get_occupied_squares(const game& g) noexcept;
 
const piece& get_piece_at(const game& g, const square& coordinat);
 
const piece& get_piece_at(const game& g, const std::string& square_str);
 
piece& get_piece_at(game& g, const square& coordinat);
 
piece& get_piece_at(game& g, const std::string& square_str);
 
const piece& get_piece_with_id(const game& g, const piece_id& id);
 
piece& get_piece_with_id(game& g, const piece_id& id);
 
std::vector<piece>& get_pieces(game& g) noexcept;
 
const std::vector<piece>& get_pieces(const game& g) noexcept;
 
const in_game_time& get_time(const game& g) noexcept;
 
bool has_piece_with_id(
  const game& g,
  const piece_id& id
);
 
bool is_draw(const game& g);
 
bool is_empty(const game& g, const square& s) noexcept;
 
bool is_empty_between(
  const game& g,
  const square& from,
  const square& to
);
 
bool is_empty_between(
  const game& g,
  const std::string& from_square_str,
  const std::string& to_square_str
);
 
bool is_idle(const game& g) noexcept;
 
bool is_piece_at(
  const game& g,
  const game_coordinate& coordinat,
  const double distance = 0.5
);
 
bool is_piece_at(
  const game& g,
  const square& coordinat
);
 
bool is_piece_at(
  const game& g,
  const std::string& square_str
);
 
bool is_square_attacked(
  const game& g,
  const square& s,
  const chess_color attacker_color
);
 
void tick(game& g, const delta_t dt);
 
void tick_until_idle(game& g);
 
std::string to_board_str(
  const game& g,
  const board_to_text_options& options = board_to_text_options()
) noexcept;
 
fen_string to_fen_string(const game& g);
 
std::string to_pgn(const game& g);
 
std::ostream& operator<<(std::ostream& os, const game& g) noexcept;
 
#endif // GAME_H