The Battle for Wesnoth  1.19.8+dev
play_controller.hpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2006 - 2024
3  by Joerg Hinrichs <joerg.hinrichs@alice-dsl.de>
4  Copyright (C) 2003 by David White <dave@whitevine.net>
5  Part of the Battle for Wesnoth Project https://www.wesnoth.org/
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 2 of the License, or
10  (at your option) any later version.
11  This program is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY.
13 
14  See the COPYING file for more details.
15 */
16 
17 #pragma once
18 
19 #include "controller_base.hpp"
20 #include "game_end_exceptions.hpp"
21 #include "help/help.hpp"
23 #include "menu_events.hpp"
24 #include "mouse_events.hpp"
25 #include "persist_manager.hpp"
26 #include "tod_manager.hpp"
27 #include "game_state.hpp"
28 #include "utils/optimer.hpp"
29 #include "utils/optional_fwd.hpp"
30 
31 #include <set>
32 
33 class team;
34 class replay;
35 class replay_controller;
36 class saved_game;
37 struct mp_game_settings;
40 
41 namespace actions {
42  class undo_list;
43 }
44 
45 namespace font {
46  struct floating_label_context;
47 }
48 
49 namespace game_events {
50  class wml_event_pump;
51 } // namespace game_events
52 
53 class statistics_t;
54 
55 namespace wb {
56  class manager; // whiteboard manager
57 } // namespace wb
58 
59 // Holds gamestate related objects
60 
62 {
63 public:
65  saved_game& state_of_game);
66  virtual ~play_controller();
67 
68  //event handler, overridden from observer
69  //there is nothing to handle in this class actually but that might change in the future
70  virtual void handle_generic_event(const std::string& /*name*/) override {}
71 
72  bool can_undo() const;
73  bool can_redo() const;
74 
75  void undo();
76  void redo();
77 
78  void load_game();
79 
80  void save_game();
81  void save_game_auto(const std::string& filename);
82  void save_replay();
83  void save_replay_auto(const std::string& filename);
84  void save_map();
85  replay& get_replay();
86 
87  void init_side_begin();
88 
89  /**
90  * Called by turn_info::process_network_data() or init_side() to call do_init_side() if necessary.
91  */
92  void maybe_do_init_side();
93 
94  /**
95  * Called by replay handler or init_side() to do actual work for turn change.
96  */
97  void do_init_side();
98 
99  void init_side_end();
100 
101  virtual void force_end_turn() = 0;
102  virtual void require_end_turn() = 0;
103  virtual void check_objectives() = 0;
104 
105  virtual void on_not_observer() = 0;
106 
107  /**
108  * Asks the user whether to continue on an OOS error.
109  *
110  * @throw quit_game_exception If the user wants to abort.
111  */
112  virtual void process_oos(const std::string& msg) const;
113 
114  bool reveal_map_default() const;
115 
117  {
119  }
120 
122  {
123  gamestate().end_level_data_.reset();
124  }
125 
126  bool is_regular_game_end() const
127  {
128  return gamestate().end_level_data_.has_value();
129  }
130 
132  {
133  return *gamestate().end_level_data_;
134  }
135 
136  std::vector<team>& get_teams()
137  {
138  return gamestate().board_.teams();
139  }
140 
141  const std::vector<team>& get_teams() const
142  {
143  return gamestate().board_.teams();
144  }
145 
146  const unit_map& get_units() const
147  {
148  return gamestate().board_.units();
149  }
150 
152  {
153  return gamestate().board_.units();
154  }
155 
156  const gamemap& get_map() const
157  {
158  return gamestate().board_.map();
159  }
160 
162  {
163  return gamestate().tod_manager_;
164  }
165 
166  bool is_observer() const
167  {
168  return gamestate().board_.is_observer();
169  }
170 
171  bool do_healing() const
172  {
173  return gamestate().do_healing_;
174  }
175 
177  {
179  }
180 
182  {
183  return *gamestate_;
184  }
185 
186  const game_state& gamestate() const
187  {
188  return *gamestate_;
189  }
190 
191  /**
192  * Checks to see if a side has won.
193  *
194  * This will also remove control of villages from sides with dead leaders.
195  */
196  void check_victory();
197 
198  std::size_t turn() const {return gamestate().tod_manager_.turn();}
199 
200  /**
201  * Returns the number of the side whose turn it is.
202  *
203  * Numbering starts at one.
204  */
205  int current_side() const { return gamestate_->player_number_; }
206 
207  /**
208  * Builds the snapshot config from members and their respective configs.
209  */
210  config to_config() const;
211 
212  bool is_skipping_replay() const { return skip_replay_; }
213  bool is_skipping_actions() const;
214  void toggle_skipping_replay();
215  void do_autosave();
216 
217  bool is_skipping_story() const { return skip_story_; }
218 
219  void do_consolesave(const std::string& filename);
220 
223 
224  std::shared_ptr<wb::manager> get_whiteboard() const;
229 
231 
232  virtual soundsource::manager* get_soundsource_man() override;
233  virtual plugins_context* get_plugins_context() override;
235 
237 
238  bool is_browsing() const override;
239 
240  class hotkey_handler;
241 
242  virtual replay_controller * get_replay_controller() const { return nullptr; }
243  bool is_replay() const { return get_replay_controller() != nullptr; }
244 
245  replay& recorder() const { return *replay_; }
246 
248  {
249  return level_["name"].t_str();
250  }
251 
252  bool get_disallow_recall() const
253  {
254  return level_["disallow_recall"].to_bool();
255  }
256 
257  std::string get_loaded_resources() const
258  {
259  return level_["loaded_resources"].str();
260  }
261 
262  std::string theme() const
263  {
264  return gamestate_->get_game_data()->get_theme();
265  }
266 
267  virtual bool should_return_to_play_side() const
268  {
269  return is_regular_game_end();
270  }
271 
272  void maybe_throw_return_to_play_side() const;
273 
274  team& current_team();
275  const team& current_team() const;
276 
277  bool can_use_synced_wml_menu() const;
278  std::set<std::string> all_players() const;
279  const auto& timer() const { return timer_; }
280  game_display& get_display() override;
281 
282  void update_savegame_snapshot() const;
283  /**
284  * Changes the UI for this client to the passed side index.
285  */
286  void update_gui_to_player(const int team_index, const bool observe = false);
287 
288  /// Sends replay [command]s to the server
289  virtual void send_actions() { }
290  /// Reads and executes replay [command]s from the server
291  virtual void receive_actions() { }
292 
293  virtual bool is_networked_mp() const { return false; }
294  virtual void send_to_wesnothd(const config&, const std::string& = "unknown") const { }
295  virtual bool receive_from_wesnothd(config&) const { return false; }
296  /** Reevaluate [show_if] conditions and build a new objectives string. */
297  void refresh_objectives() const;
298  void show_objectives() const;
299 
301  {
305  };
306 
308 
310  bool is_during_turn() const;
311  bool is_linger_mode() const;
312 
313 protected:
315  void play_slice_catch();
316  bool have_keyboard_focus() override;
317  void process_focus_keydown_event(const SDL_Event& event) override;
318  void process_keydown_event(const SDL_Event& event) override;
319  void process_keyup_event(const SDL_Event& event) override;
320 
321  void init_managers();
322  /** preload events cannot be synced */
323  void fire_preload();
324  void fire_prestart();
325  void fire_start();
326  void start_game();
327  virtual void init_gui();
329  void finish_turn(); //this should not throw an end turn or end level exception
330  bool enemies_visible() const;
331 
332  void enter_textbox();
333  void textbox_move_vertically(bool up);
334  void tab();
335 
336 public:
337  /** returns 0 if no such team was found. */
338  virtual int find_viewing_side() const = 0;
339 private:
341 
342 protected:
343  //gamestate
344  std::unique_ptr<game_state> gamestate_;
347 
348  //managers
350 
351  //whiteboard manager
352  std::shared_ptr<wb::manager> whiteboard_manager_;
353 
354  //plugins context
355  std::unique_ptr<plugins_context> plugins_context_;
356 
357  //more managers
358  std::unique_ptr<font::floating_label_context> labels_manager_;
362  std::unique_ptr<hotkey_handler> hotkey_handler_;
363  std::unique_ptr<soundsource::manager> soundsources_manager_;
365 
366  //other objects
367  std::unique_ptr<game_display> gui_;
368  const std::unique_ptr<unit_experience_accelerator> xp_mod_;
369  const std::unique_ptr<statistics_t> statistics_context_;
371  const actions::undo_list& undo_stack() const { return *gamestate().undo_stack_; }
372  std::unique_ptr<replay> replay_;
373 
376  /**
377  * Whether we did init sides in this session
378  * (false = we did init sides before we reloaded the game).
379  */
382  //the displayed location when we load a game.
384  // Whether to start with the display faded to black
386 
387  const std::string& select_music(bool victory) const;
388 
389  void reset_gamestate(const config& level, int replay_pos);
390 
391 private:
392 
393  void init(const config& level);
394 
395  /**
396  * This shows a warning dialog if either [scenario]next_scenario or any [endlevel]next_scenario would lead to an "Unknown Scenario" dialog.
397  */
399 
400  std::vector<std::string> victory_music_;
401  std::vector<std::string> defeat_music_;
402 
404 
405 protected:
406  mutable bool ignore_replay_errors_;
407  /// true when the controller of the currently playing side has changed.
408  /// this can mean for example:
409  /// - The currently active side was reassigned from/to another player in a mp game
410  /// - The replay controller was disabled ('continue play' button)
411  /// - The currently active side was droided / undroided.
412  /// - A side was set to idle.
414  virtual void sync_end_turn() {}
415  virtual void check_time_over();
416  virtual void update_viewing_player() = 0;
417 };
Class to store the actions that a player can undo and redo.
Definition: undo.hpp:34
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:158
bool is_observer() const
Check if we are an observer in this game.
virtual const std::vector< team > & teams() const override
Definition: game_board.hpp:80
virtual const unit_map & units() const override
Definition: game_board.hpp:107
virtual const gamemap & map() const override
Definition: game_board.hpp:97
utils::optional< end_level_data > end_level_data_
Definition: game_state.hpp:64
int server_request_number_
Definition: game_state.hpp:66
const std::unique_ptr< actions::undo_list > undo_stack_
undo_stack_ is never nullptr.
Definition: game_state.hpp:56
bool do_healing_
True if healing should be done at the beginning of the next side turn.
Definition: game_state.hpp:60
game_board board_
Definition: game_state.hpp:44
tod_manager tod_manager_
Definition: game_state.hpp:45
Encapsulates the map of the game.
Definition: map.hpp:172
unit_map & get_units()
game_classification & get_classification()
const std::string & select_music(bool victory) const
virtual void handle_generic_event(const std::string &) override
void process_keydown_event(const SDL_Event &event) override
Process keydown (always).
events::menu_handler & get_menu_handler()
void maybe_throw_return_to_play_side() const
config to_config() const
Builds the snapshot config from members and their respective configs.
virtual void on_not_observer()=0
void init(const config &level)
const std::vector< team > & get_teams() const
virtual bool receive_from_wesnothd(config &) const
int get_server_request_number() const
std::vector< team > & get_teams()
std::unique_ptr< hotkey_handler > hotkey_handler_
virtual void init_gui()
virtual replay_controller * get_replay_controller() const
bool have_keyboard_focus() override
Derived classes should override this to return false when arrow keys should not scroll the map,...
std::unique_ptr< game_state > gamestate_
void show_objectives() const
events::menu_handler menu_handler_
void fire_preload()
preload events cannot be synced
std::vector< std::string > victory_music_
void check_victory()
Checks to see if a side has won.
bool is_linger_mode() const
actions::undo_list & undo_stack()
statistics_t & statistics()
virtual soundsource::manager * get_soundsource_man() override
Get (optionally) a soundsources manager a derived class uses.
void check_next_scenario_is_known()
This shows a warning dialog if either [scenario]next_scenario or any [endlevel]next_scenario would le...
bool reveal_map_default() const
actions::undo_list & get_undo_stack()
const unit_map & get_units() const
play_controller(const config &level, saved_game &state_of_game)
bool do_healing() const
void set_end_level_data(const end_level_data &data)
events::mouse_handler & get_mouse_handler_base() override
Get a reference to a mouse handler member a derived class uses.
void update_savegame_snapshot() const
virtual int find_viewing_side() const =0
returns 0 if no such team was found.
void increase_server_request_number()
bool is_observer() const
void set_do_healing(bool do_healing)
const actions::undo_list & undo_stack() const
bool is_skipping_actions() const
bool is_during_turn() const
virtual void require_end_turn()=0
bool can_use_synced_wml_menu() const
void reset_gamestate(const config &level, int replay_pos)
bool is_skipping_story() const
void do_consolesave(const std::string &filename)
void save_game_auto(const std::string &filename)
void textbox_move_vertically(bool up)
bool is_regular_game_end() const
saved_game & get_saved_game()
tooltips::manager tooltips_manager_
virtual void check_objectives()=0
void save_replay_auto(const std::string &filename)
saved_game & saved_game_
game_state & gamestate()
hotkey::command_executor * get_hotkey_command_executor() override
Optionally get a command executor to handle context menu events.
bool enemies_visible() const
std::unique_ptr< replay > replay_
const std::unique_ptr< statistics_t > statistics_context_
const mp_game_settings & get_mp_settings()
game_display & get_display() override
Get a reference to a display member a derived class uses.
virtual void update_viewing_player()=0
virtual void sync_end_turn()
std::unique_ptr< game_display > gui_
void maybe_do_init_side()
Called by turn_info::process_network_data() or init_side() to call do_init_side() if necessary.
virtual void process_oos(const std::string &msg) const
Asks the user whether to continue on an OOS error.
bool is_browsing() const override
virtual void send_to_wesnothd(const config &, const std::string &="unknown") const
std::unique_ptr< soundsource::manager > soundsources_manager_
const end_level_data & get_end_level_data() const
void do_init_side()
Called by replay handler or init_side() to do actual work for turn change.
std::string theme() const
const tod_manager & get_tod_manager() const
int current_side() const
Returns the number of the side whose turn it is.
virtual bool is_networked_mp() const
bool is_skipping_replay() const
bool get_disallow_recall() const
const hotkey::scope_changer scope_
std::unique_ptr< font::floating_label_context > labels_manager_
std::shared_ptr< wb::manager > get_whiteboard() const
std::vector< std::string > defeat_music_
const gamemap & get_map() const
bool did_autosave_this_turn_
Whether we did init sides in this session (false = we did init sides before we reloaded the game).
bool is_replay() const
bool player_type_changed_
true when the controller of the currently playing side has changed.
std::size_t turn() const
map_location map_start_
virtual bool should_return_to_play_side() const
std::set< std::string > all_players() const
virtual void force_end_turn()=0
void update_gui_to_player(const int team_index, const bool observe=false)
Changes the UI for this client to the passed side index.
events::mouse_handler mouse_handler_
const auto & timer() const
std::unique_ptr< plugins_context > plugins_context_
virtual plugins_context * get_plugins_context() override
Get (optionally) a plugins context a derived class uses.
virtual ~play_controller()
bool can_undo() const
utils::ms_optimer timer_
const std::unique_ptr< unit_experience_accelerator > xp_mod_
void process_focus_keydown_event(const SDL_Event &event) override
Process keydown (only when the general map display does not have focus).
virtual void send_actions()
Sends replay [command]s to the server.
void refresh_objectives() const
Reevaluate [show_if] conditions and build a new objectives string.
bool can_redo() const
game_events::wml_event_pump & pump()
void process_keyup_event(const SDL_Event &event) override
Process keyup (always).
void finish_side_turn_events()
replay & recorder() const
std::string get_loaded_resources() const
help::help_manager help_manager_
const game_state & gamestate() const
persist_manager persist_
virtual void receive_actions()
Reads and executes replay [command]s from the server.
std::shared_ptr< wb::manager > whiteboard_manager_
virtual void check_time_over()
t_string get_scenario_name() const
Implements a quit confirmation dialog.
This class stores all the data for a single 'side' (in game nomenclature).
Definition: team.hpp:75
int turn() const
Container associating units to locations.
Definition: map.hpp:98
controller_base framework: controller_base is roughly analogous to a "dialog" class in a GUI toolkit ...
Contains the exception interfaces used to signal completion of a scenario, campaign or turn.
Graphical text output.
Domain specific events.
Definition: display.hpp:45
static void msg(const char *act, debug_info &i, const char *to="", const char *result="")
Definition: debugger.cpp:109
std::string_view data
Definition: picture.cpp:178
std::string filename
Filename.
Additional information on the game outcome which can be provided by WML.
The help implementation caches data parsed from the game_config.
Definition: help.hpp:39
Encapsulates the map of the game.
Definition: location.hpp:45
scoped_savegame_snapshot(const play_controller &controller)
Reports time elapsed at the end of an object scope.
Definition: optimer.hpp:37