The Battle for Wesnoth  1.19.0-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 <optional>
29 
30 #include <set>
31 
32 class team;
33 class replay;
34 class replay_controller;
35 class saved_game;
36 struct mp_game_settings;
39 
40 namespace actions {
41  class undo_list;
42 }
43 
44 namespace font {
45  struct floating_label_context;
46 }
47 
48 namespace game_events {
49  class wml_event_pump;
50 } // namespace game_events
51 
52 class statistics_t;
53 
54 namespace wb {
55  class manager; // whiteboard manager
56 } // namespace wb
57 
58 // Holds gamestate related objects
59 
61 {
62 public:
64  saved_game& state_of_game,
65  bool skip_replay,
66  bool start_faded = false);
67  virtual ~play_controller();
68 
69  //event handler, overridden from observer
70  //there is nothing to handle in this class actually but that might change in the future
71  virtual void handle_generic_event(const std::string& /*name*/) override {}
72 
73  bool can_undo() const;
74  bool can_redo() const;
75 
76  void undo();
77  void redo();
78 
79  void load_game();
80 
81  void save_game();
82  void save_game_auto(const std::string& filename);
83  void save_replay();
84  void save_replay_auto(const std::string& filename);
85  void save_map();
86  replay& get_replay();
87 
88  void init_side_begin();
89 
90  /**
91  * Called by turn_info::process_network_data() or init_side() to call do_init_side() if necessary.
92  */
93  void maybe_do_init_side();
94 
95  /**
96  * Called by replay handler or init_side() to do actual work for turn change.
97  */
98  void do_init_side();
99 
100  void init_side_end();
101 
102  virtual void force_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 
115  {
117  }
118 
120  {
121  gamestate().end_level_data_.reset();
122  }
123 
124  bool is_regular_game_end() const
125  {
126  return gamestate().end_level_data_.has_value();
127  }
128 
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  void toggle_skipping_replay();
214  void do_autosave();
215 
216  bool is_skipping_story() const { return skip_story_; }
217 
218  void do_consolesave(const std::string& filename);
219 
222 
223  std::shared_ptr<wb::manager> get_whiteboard() const;
228 
230 
231  int get_ticks() const;
232 
233  virtual soundsource::manager* get_soundsource_man() override;
234  virtual plugins_context* get_plugins_context() override;
236 
238 
239  bool is_browsing() const override;
240 
241  class hotkey_handler;
242 
243  virtual replay_controller * get_replay_controller() const { return nullptr; }
244  bool is_replay() const { return get_replay_controller() != nullptr; }
245 
247  {
248  return level_["name"].t_str();
249  }
250 
251  bool get_disallow_recall() const
252  {
253  return level_["disallow_recall"].to_bool();
254  }
255 
256  std::string get_loaded_resources() const
257  {
258  return level_["loaded_resources"].str();
259  }
260 
261  std::string theme() const
262  {
263  return gamestate_->get_game_data()->get_theme();
264  }
265 
266  virtual bool should_return_to_play_side() const
267  {
268  return is_regular_game_end();
269  }
270 
271  void maybe_throw_return_to_play_side() const;
272 
273  virtual void play_side_impl() {}
274 
275  void play_side();
276 
277  team& current_team();
278  const team& current_team() const;
279 
280  bool can_use_synced_wml_menu() const;
281  std::set<std::string> all_players() const;
282  int ticks() const { return ticks_; }
283  game_display& get_display() override;
284 
285  void update_savegame_snapshot() const;
286  /**
287  * Changes the UI for this client to the passed side index.
288  */
289  void update_gui_to_player(const int team_index, const bool observe = false);
290 
291  virtual bool is_networked_mp() const { return false; }
292  virtual void send_to_wesnothd(const config&, const std::string& = "unknown") const { }
293  virtual bool receive_from_wesnothd(config&) const { return false; }
294  /** Reevaluate [show_if] conditions and build a new objectives string. */
295  void refresh_objectives() const;
296  void show_objectives() const;
297 
299  {
303  };
304 
306 
308  bool is_during_turn() const;
309  bool is_linger_mode() const;
310 
311 protected:
313  void play_slice_catch();
314  bool have_keyboard_focus() override;
315  void process_focus_keydown_event(const SDL_Event& event) override;
316  void process_keydown_event(const SDL_Event& event) override;
317  void process_keyup_event(const SDL_Event& event) override;
318 
319  void init_managers();
320  /** preload events cannot be synced */
321  void fire_preload();
322  void fire_prestart();
323  void fire_start();
324  void start_game();
325  virtual void init_gui();
327  void finish_turn(); //this should not throw an end turn or end level exception
328  bool enemies_visible() const;
329 
330  void enter_textbox();
331  void textbox_move_vertically(bool up);
332  void tab();
333 
334 
335  bool is_team_visible(int team_num, bool observer) const;
336 public:
337  /** returns 0 if no such team was found. */
338  int find_viewing_side() const;
339 
340 private:
341  const int ticks_;
342 
343 protected:
344  //gamestate
345  std::unique_ptr<game_state> gamestate_;
348 
349  //managers
351 
352  //whiteboard manager
353  std::shared_ptr<wb::manager> whiteboard_manager_;
354 
355  //plugins context
356  std::unique_ptr<plugins_context> plugins_context_;
357 
358  //more managers
359  std::unique_ptr<font::floating_label_context> labels_manager_;
363  std::unique_ptr<hotkey_handler> hotkey_handler_;
364  std::unique_ptr<soundsource::manager> soundsources_manager_;
366 
367  //other objects
368  std::unique_ptr<game_display> gui_;
369  const std::unique_ptr<unit_experience_accelerator> xp_mod_;
370  const std::unique_ptr<statistics_t> statistics_context_;
372  const actions::undo_list& undo_stack() const { return *gamestate().undo_stack_; }
373  std::unique_ptr<replay> replay_;
374 
377  /**
378  * Whether we did init sides in this session
379  * (false = we did init sides before we reloaded the game).
380  */
383  //the displayed location when we load a game.
385  // Whether to start with the display faded to black
387 
388  const std::string& select_music(bool victory) const;
389 
390  void reset_gamestate(const config& level, int replay_pos);
391 
392 private:
393 
394  void init(const config& level);
395 
396  /**
397  * This shows a warning dialog if either [scenario]next_scenario or any [endlevel]next_scenario would lead to an "Unknown Scenario" dialog.
398  */
400 
401  std::vector<std::string> victory_music_;
402  std::vector<std::string> defeat_music_;
403 
405 
406 protected:
407  mutable bool ignore_replay_errors_;
408  /// true when the controller of the currently playing side has changed.
409  /// this can mean for example:
410  /// - The currently active side was reassigned from/to another player in a mp game
411  /// - The replay controller was disabled ('continue play' button)
412  /// - The currently active side was droided / undroided.
413  /// - A side was set to idle.
415  virtual void sync_end_turn() {}
416  virtual void check_time_over();
417  virtual void update_viewing_player() = 0;
418 };
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:159
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:79
virtual const unit_map & units() const override
Definition: game_board.hpp:106
virtual const gamemap & map() const override
Definition: game_board.hpp:96
int server_request_number_
Definition: game_state.hpp:66
std::optional< end_level_data > end_level_data_
Definition: game_state.hpp:64
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_
int find_viewing_side() const
returns 0 if no such team was found.
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
bool is_team_visible(int team_num, bool observer) 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...
actions::undo_list & get_undo_stack()
const unit_map & get_units() const
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
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_during_turn() const
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()
play_controller(const config &level, saved_game &state_of_game, bool skip_replay, bool start_faded=false)
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()
bool check_regular_game_end()
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
virtual void play_side_impl()
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_
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
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).
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()
std::string get_loaded_resources() const
help::help_manager help_manager_
const game_state & gamestate() const
persist_manager persist_
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:74
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.
Collection of helper functions relating to Pango formatting.
std::string observer
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:194
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:38
scoped_savegame_snapshot(const play_controller &controller)