game_controller.h

Go to the documentation of this file.

#ifndef GAME_CONTROLLER_H
#define GAME_CONTROLLER_H
 
#include "ccfwd.h"
#include "piece_action_type.h"
#include "game_coordinate.h"
#include "game.h"
#include "lobby_options.h"
#include "side.h"
#include "user_inputs.h"
 
#include <map>
#include <iosfwd>
 
class game_controller
{
public:
  explicit game_controller(
    const game& g = game(),
    const lobby_options& lo = lobby_options()
  );
 
  void add_user_input(const user_input& a);
 
  void apply_user_inputs_to_game();
 
  const game_coordinate& get_cursor_pos(const side player_side) const noexcept;
 
  const game& get_game() const noexcept { return m_game; }
 
  game& get_game() noexcept { return m_game; }
 
  const auto& get_lobby_options() const noexcept { return m_lobby_options; }
 
  const std::optional<piece_id>& get_selected_piece_id(const side s) const noexcept;
 
  const auto& get_user_inputs() const noexcept { return m_user_inputs; }
 
  const physical_controller& get_physical_controller(const side player_side) const noexcept;
 
  void set_cursor_pos(const game_coordinate& pos, const side player_side) noexcept;
 
  void set_selected_piece_id(const side s, const std::optional<piece_id>& selected_piece_id) noexcept;
 
  void tick(const delta_t& dt = delta_t(1.0));
 
private:
 
  std::map<side, game_coordinate> m_cursor_pos;
 
  game m_game;
 
  lobby_options m_lobby_options;
 
  std::map<side, std::optional<piece_id>> m_selected_piece_id;
 
  user_inputs m_user_inputs;
 
  void apply_action_type_to_game(game& g, const piece_action_type t, const side s);
 
  void apply_action_type_attack_to_game(game& g, const side s);
  void apply_action_type_attack_en_passant_to_game(game& g, const side s);
  void apply_action_type_castle_kingside_to_game(game& g, const side s);
  void apply_action_type_castle_queenside_to_game(game& g, const side s);
  void apply_action_type_move_to_game(game& g, const side s);
  void apply_action_type_promote_to_game(game& g, const piece_type promote_to_type, const side s);
  void apply_action_type_select_to_game(game& g, const side s);
  void apply_action_type_unselect_to_game(game& g, const side s);
 
  friend class game_view;
};
 
void add_user_input(game_controller& c, const user_input& input);
 
void add_user_inputs(game_controller& c, const user_inputs& input);
 
 
bool can_attack(
  const game_controller& c,
  const side player_side
) noexcept;
 
bool can_attack_en_passant(
  const game_controller& c,
  const side player_side
) noexcept;
 
bool can_castle_kingside(
  const game_controller& c,
  const side player_side
) noexcept;
 
bool can_castle_queenside(
  const game_controller& c,
  const side player_side
) noexcept;
 
bool can_move(
  const game_controller& c,
  const side player_side
) noexcept;
 
bool can_player_select_piece_at_cursor_pos(
  const game_controller& c,
  const chess_color cursor_color
);
 
bool can_player_select_piece_at_cursor_pos(
  const game_controller& c,
  const side player_side
);
 
bool can_promote(
  const game_controller& c,
  const side player_side
) noexcept;
 
 
bool can_select(
  const game_controller& c,
  const side player_side
) noexcept;
 
bool can_unselect(
  const game_controller& c,
  const side player_side
) noexcept;
 
std::vector<message> collect_messages(const game_controller& g) noexcept;
 
std::vector<piece_id> collect_selected_piece_ids(const game_controller& c);
 
user_inputs convert_move_to_user_inputs(
  const game_controller& c,
  const chess_move& move,
  const physical_controller_type t
);
 
int count_piece_actions(const game_controller& g);
 
int count_piece_actions(
  const game_controller& g,
  const chess_color player
);
 
int count_selected_units(
  const game_controller& c,
  const chess_color player_color
);
 
int count_user_inputs(const game_controller& c) noexcept;
 
chess_color get_color(
  const game_controller& c,
  const side s
);
 
const game_coordinate& get_cursor_pos(
  const game_controller& c,
  const side player_side
) noexcept;
 
const game_coordinate& get_cursor_pos(
  const game_controller& c,
  const chess_color cursor_color
);
 
square get_cursor_square(
  const game_controller& c,
  const side player_side
);
 
const in_game_time& get_in_game_time(
  const game_controller& c
) noexcept;
 
std::vector<piece_action_type> get_piece_actions(
  const game_controller& c,
  const side player_side
) noexcept;
 
piece& get_piece_at(game_controller& c, const std::string& square_str);
piece& get_piece_at(game_controller& c, const square& s);
 
std::vector<square> get_possible_moves(
  const game_controller& c,
  const side player
);
 
std::vector<piece> get_selected_pieces(
  const game_controller& c,
  const chess_color player
);
 
std::vector<piece> get_selected_pieces(
  const game_controller& c,
  const side player
);
 
 
const user_inputs& get_user_inputs(const game_controller& c) noexcept;
 
user_inputs get_user_inputs_to_move_cursor_from_to(
  const game_controller& c,
  const square& from,
  const square& to,
  const side player_side,
  const physical_controller_type t
);
 
user_inputs get_user_inputs_to_move_cursor_to(
  const game_controller& c,
  const square& to,
  const side player_side,
  const physical_controller_type t
);
 
const std::optional<chess_color>& get_winner(const game_controller& c) noexcept;
 
bool has_selected_pieces(
  const game_controller& c,
  const chess_color player_color
);
 
bool has_selected_pieces(
  const game_controller& c,
  const side player_side
);
 
bool has_winner(const game_controller& c) noexcept;
 
bool is_cursor_on_selected_piece(
  const game_controller& c,
  const side player_side
) noexcept;
 
bool is_draw(const game_controller& c);
 
bool is_piece_at(
  const game_controller& g,
  const square& coordinat
);
 
bool is_piece_at(
  const game_controller& g,
  const std::string& square_str
);
 
bool is_selected(
  const piece& p,
  const game_controller& c
);
 
bool is_square_attacked(
  const game_controller& c,
  const square& s,
  const chess_color attacker_color
);
 
void move_cursor_to(
  game_controller& c,
  const std::string& square_str,
  const side player_side
);
 
void move_cursor_to(
  game_controller& c,
  const square& s,
  const side player_side
);
 
game play_random_game(const int n_turns = 2, const int seed = 42);
 
void set_cursor_pos(
  game_controller& c,
  const game_coordinate& pos,
  const side player_side
) noexcept;
 
void test_game_controller();
 
std::string to_board_str(
  const game_controller& c,
  const board_to_text_options& options = board_to_text_options()
) noexcept;
 
std::ostream& operator<<(std::ostream& os, const game_controller& g) noexcept;
 
#endif // GAME_CONTROLLER_H