game_view.h

Go to the documentation of this file.

#ifndef GAME_VIEW_H
#define GAME_VIEW_H
 
#ifndef LOGIC_ONLY
 
#include "ccfwd.h"
#include "controls_bar.h"
#include "physical_controller.h"
//#include "game.h"
#include "game_log.h"
#include "game_controller.h"
#include "game_view_layout.h"
#include "game_statistics_output_file.h"
#include "game_statistics_in_time.h"
#include "view.h"
 
#include <SFML/Graphics.hpp>
 
//#include <optional>
 
class game_view : public view
{
public:
  explicit game_view();
 
  void draw_impl() override;
 
  void tick_impl(delta_t dt) override;
 
  double get_elapsed_time_secs() const noexcept;
 
  const auto& get_game() const noexcept { return m_game_controller.get_game(); }
 
  const auto& get_game_controller() const noexcept { return m_game_controller; }
 
  const auto& get_game_options() const noexcept { return m_game_options; }
 
  const auto& get_layout() const noexcept { return m_layout; }
 
  const auto& get_log() const noexcept { return m_log; }
 
  const auto& get_physical_controllers() const noexcept { return m_pc; }
 
  [[nodiscard]] replay get_replay() const;
 
  bool process_event_impl(sf::Event& event) override;
 
  void process_resize_event_impl(sf::Event& event) override;
 
  void set_game_options(const game_options& go) noexcept { m_game_options = go; }
 
  void set_lobby_options(const lobby_options& lo) noexcept;
 
  void start_impl() override;
 
  void stop_impl() override;
 
private:
 
  sf::Clock m_clock;
 
  controls_bar m_controls_bar;
 
  game_options m_game_options;
 
  game_controller m_game_controller;
 
  game_view_layout m_layout;
 
  lobby_options m_lobby_options;
 
  game_log m_log;
 
  physical_controllers m_pc;
 
  game_statistics_output_file m_statistics_output_file;
 
  game_statistics_in_time m_statistics_in_time;
 
 
  void play_pieces_sound_effects();
 
  void process_piece_messages();
 
  void show_mouse_cursor();
};
 
sf::RectangleShape create_black_square(game_view& view);
 
sf::RectangleShape create_white_square(game_view& view);
 
const physical_controller& get_physical_controller(const game_view& view, const side player);
 
physical_controller_type get_physical_controller_type(const game_view& view, const side player);
 
std::vector<std::string> get_controls_texts(
  const game_controller& c,
  const side player_side
);
 
std::string get_last_log_messages(
  const game_view& v,
  const side player
) noexcept;
 
const game_view_layout& get_layout(const game_view& v) noexcept;
 
const std::vector<piece>& get_pieces(const game_view& v) noexcept;
 
const game_coordinate& get_cursor_pos(
  const game_view& view,
  const side player
) noexcept;
 
const in_game_time& get_time(const game_view& v) noexcept;
 
void process_event(
  game_controller& c,
  const physical_controllers& pc,
  const sf::Event& event,
  const game_view_layout& layout
);
 
 
void draw_background(game_view& view);
 
void draw_board(
  game_view& view,
  const bool show_occupied
);
 
void draw_controls(
  game_view& view,
  const side player
);
 
void draw_game_statistics_widget(game_view& view);
 
void draw_navigation_controls(game_view& view);
 
void show_debug(game_view& view, const side player_side);
 
void draw_log(game_view& view, const side player);
 
 
void show_occupied_squares(game_view& view);
 
void draw_pieces(game_view& view);
 
void draw_possible_moves(game_view& view);
 
void show_sidebar(game_view& view, const side player_side);
 
void draw_squares(game_view& view);
 
void draw_cursor(
  game_view& view,
  const side player
);
 
void draw_unit_health_bars(game_view& view);
 
void draw_unit_paths(game_view& view);
 
void draw_unit_info(game_view& view, const side player_side);
 
void test_game_view();
 
bool would_be_valid(
  const game_view& view,
  chess_color player_color
);
 
#endif // LOGIC_ONLY
 
#endif // GAME_VIEW_H