The Battle for Wesnoth  1.19.12+dev
play_controller.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2006 - 2025
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 /**
18  * @file
19  * Handle input via mouse & keyboard, events, schedule commands.
20  */
21 
22 #include "play_controller.hpp"
23 
24 #include "actions/heal.hpp"
25 #include "actions/undo.hpp"
26 #include "actions/vision.hpp"
27 #include "ai/manager.hpp"
28 #include "ai/testing.hpp"
29 #include "display_chat_manager.hpp"
30 #include "floating_label.hpp"
31 #include "formula/string_utils.hpp"
32 #include "game_errors.hpp"
34 #include "game_events/pump.hpp"
35 #include "game_state.hpp"
36 #include "gettext.hpp"
38 #include "gui/dialogs/message.hpp" // for show_error_message
42 #include "log.hpp"
43 #include "map/label.hpp"
44 #include "pathfind/teleport.hpp"
46 #include "random.hpp"
47 #include "replay.hpp"
48 #include "resources.hpp"
49 #include "save_index.hpp"
50 #include "saved_game.hpp"
51 #include "savegame.hpp"
55 #include "sound.hpp"
56 #include "soundsource.hpp"
57 #include "statistics.hpp"
58 #include "synced_context.hpp"
59 #include "units/types.hpp"
60 #include "units/unit.hpp"
61 #include "utils/general.hpp"
62 #include "video.hpp"
63 #include "whiteboard/manager.hpp"
64 
65 #include <functional>
66 
67 static lg::log_domain log_aitesting("ai/testing");
68 #define LOG_AIT LOG_STREAM(info, log_aitesting)
69 // If necessary, this define can be replaced with `#define LOG_AIT std::cout` to restore previous behavior
70 
71 static lg::log_domain log_engine("engine");
72 #define LOG_NG LOG_STREAM(info, log_engine)
73 #define DBG_NG LOG_STREAM(debug, log_engine)
74 #define ERR_NG LOG_STREAM(err, log_engine)
75 
76 static lg::log_domain log_display("display");
77 #define ERR_DP LOG_STREAM(err, log_display)
78 
79 static lg::log_domain log_enginerefac("enginerefac");
80 #define LOG_RG LOG_STREAM(info, log_enginerefac)
81 
82 static lg::log_domain log_engine_enemies("engine/enemies");
83 #define DBG_EE LOG_STREAM(debug, log_engine_enemies)
84 
85 /**
86  * Copies [scenario] attributes/tags that are not otherwise stored in C++ structs/clases.
87  */
88 static void copy_persistent(const config& src, config& dst)
89 {
90  static const std::set<std::string> attrs {
91  "description",
92  "name",
93  "disallow_recall",
94  "experience_modifier",
95  "require_scenario",
96  "loaded_resources"
97  };
98 
99  static const std::set<std::string> tags {
100  "terrain_graphics",
101  "modify_unit_type",
102  "lua"
103  };
104 
105  for(const std::string& attr : attrs) {
106  dst[attr] = src[attr];
107  }
108 
109  for(const std::string& tag : tags) {
110  dst.append_children(src, tag);
111  }
112 }
113 
114 static void clear_resources()
115 {
116  resources::controller = nullptr;
117  resources::filter_con = nullptr;
118  resources::gameboard = nullptr;
119  resources::gamedata = nullptr;
120  resources::lua_kernel = nullptr;
121  resources::game_events = nullptr;
122  resources::persist = nullptr;
123  resources::soundsources = nullptr;
124  resources::tod_manager = nullptr;
125  resources::tunnels = nullptr;
126  resources::undo_stack = nullptr;
127  resources::recorder = nullptr;
128  resources::whiteboard.reset();
129  resources::classification = nullptr;
130 }
131 
133  : controller_base()
134  , observer()
136  , timer_()
137  , gamestate_()
138  , level_()
139  , saved_game_(state_of_game)
140  , tooltips_manager_()
141  , whiteboard_manager_()
142  , plugins_context_()
143  , labels_manager_(new font::floating_label_context())
144  , help_manager_(&game_config_)
145  , mouse_handler_(*this)
146  , menu_handler_(*this)
147  , hotkey_handler_(new hotkey_handler(*this, saved_game_))
148  , soundsources_manager_()
149  , persist_()
150  , gui_()
151  , xp_mod_(new unit_experience_accelerator(level["experience_modifier"].to_int(100)))
152  , statistics_context_(new statistics_t(state_of_game.statistics()))
153  , replay_(new replay(state_of_game.get_replay()))
154  , skip_replay_(false)
155  , skip_story_(state_of_game.skip_story())
156  , did_autosave_this_turn_(true)
157  , did_tod_sound_this_turn_(false)
158  , map_start_()
159  , start_faded_(true)
160  , victory_music_()
161  , defeat_music_()
162  , scope_(hotkey::scope_game)
163  , ignore_replay_errors_(false)
164  , player_type_changed_(false)
165 {
167 
168  for(const config& modify_unit_type : level_.child_range("modify_unit_type")) {
169  unit_types.apply_scenario_fix(modify_unit_type);
170  }
171  resources::controller = this;
174 
176 
178 
180 
181  try {
182  init(level);
183  } catch(...) {
184  DBG_NG << "Caught exception initializing level: " << utils::get_unknown_exception_type();
185  clear_resources();
186  throw;
187  }
188 }
189 
191 {
193  clear_resources();
194 }
195 
197 {
198  /*
199  * Initilisation currently happens on the following order:
200  * 1) This code, which is executed with the loadingscreen
201  * From inside the constructor.
202  * 2) The Music is changed.
203  * 3) The Storyscreen is shown.
204  * 4) The Labels are added
205  * 5) The preload event is fired
206  * 6) The prestart event is fired
207  * 7) The gui is activated
208  * 8) The start event is fired
209  */
212 
213  LOG_NG << "initializing game_state..." << timer();
214  gamestate_.reset(new game_state(level, *this));
215 
223 
224  gamestate_->ai_manager_.add_observer(this);
225  gamestate_->init(level, *this);
227 
228  LOG_NG << "initializing whiteboard..." << timer();
230  whiteboard_manager_.reset(new wb::manager());
232 
233  LOG_NG << "loading units..." << timer();
236 
237  LOG_NG << "initializing display (includes theme init and building terrain rules)... " << timer();
239  gui_.reset(new game_display(gamestate().board_, whiteboard_manager_, *gamestate().reports_, theme(), level));
240  map_start_ = map_location(level.child_or_empty("display").child_or_empty("location"));
241  if(start_faded_) {
242  gui_->set_fade({0,0,0,255});
243  gui_->set_prevent_draw(true);
244  }
245 
246  // Ensure the loading screen doesn't end up underneath the game display
248 
249  if(!video::headless()) {
251  gui_->get_theme().modify_label("time-icon", _("time left for current turn"));
252  } else {
253  gui_->get_theme().modify_label("time-icon", _("current local time"));
254  }
255  }
256 
257  mouse_handler_.set_gui(gui_.get());
258  menu_handler_.set_gui(gui_.get());
259 
260  LOG_NG << "done initializing display... " << timer();
261 
262  LOG_NG << "building gamestate to gui and whiteboard... " << timer();
263  // This *needs* to be created before the show_intro and show_map_scene
264  // as that functions use the manager state_of_game
265  // Has to be done before registering any events!
268 
269  init_managers();
271  // loadscreen_manager->reset();
273  gamestate().lua_kernel_->load_game(level);
274 
275  plugins_context_.reset(new plugins_context("Game"));
276  plugins_context_->set_callback("save_game", [this](const config& cfg) { save_game_auto(cfg["filename"]); }, true);
277  plugins_context_->set_callback("save_replay", [this](const config& cfg) { save_replay_auto(cfg["filename"]); }, true);
278  plugins_context_->set_callback("quit", [](const config&) { throw_quit_game_exception(); }, false);
279  plugins_context_->set_callback_execute(*resources::lua_kernel);
280  plugins_context_->set_accessor_string("scenario_name", [this](const config&) { return get_scenario_name(); });
281  plugins_context_->set_accessor_int("current_side", [this](const config&) { return current_side(); });
282  plugins_context_->set_accessor_int("current_turn", [this](const config&) { return turn(); });
283  plugins_context_->set_accessor_bool("can_move", [this](const config&) { return !events::commands_disabled && gamestate().gamedata_.phase() == game_data::TURN_PLAYING; });
284  plugins_context_->set_callback("end_turn", [this](const config&) { require_end_turn(); }, false);
285  plugins_context_->set_callback("synced_command", [this](const config& cmd) {
286  auto& pm = *plugins_manager::get();
287  if(resources::whiteboard->has_planned_unit_map())
288  {
289  ERR_NG << "plugin called synced command while whiteboard is applied, ignoring";
290  pm.notify_event("synced_command_error", config{"error", "whiteboard"});
291  return;
292  }
293 
294  auto& gamedata = gamestate().gamedata_;
295  const bool is_too_early = gamedata.phase() == game_data::INITIAL || resources::gamedata->phase() == game_data::PRELOAD;
296  const bool is_during_turn = gamedata.phase() == game_data::TURN_PLAYING;
297  const bool is_unsynced = synced_context::get_synced_state() == synced_context::UNSYNCED;
298  if(is_too_early) {
299  ERR_NG << "synced command called too early, only allowed at START or later";
300  pm.notify_event("synced_command_error", config{"error", "too-early"});
301  return;
302  }
303  if(is_unsynced && !is_during_turn) {
304  ERR_NG << "synced command can only be used during a turn when a user would also be able to invoke commands";
305  pm.notify_event("synced_command_error", config{"error", "not-your-turn"});
306  return;
307  }
308  if(is_unsynced && events::commands_disabled) {
309  ERR_NG << "synced command cannot be invoked while commands are blocked";
310  pm.notify_event("synced_command_error", config{"error", "disabled"});
311  return;
312  }
313  if(is_unsynced && !resources::controller->current_team().is_local()) {
314  ERR_NG << "synced command can only be used from clients that control the currently playing side";
315  pm.notify_event("synced_command_error", config{"error", "not-your-turn"});
316  return;
317  }
318  action_spectator spectator([&pm](const std::string& message) {
319  ERR_NG << "synced command from plugin raised an error: " << message;
320  pm.notify_event("synced_command_error", config{"error", "error", "message", message});
321  });
322  for(const auto [key, child] : cmd.all_children_range()) {
325  }
326  }, false);
327  });
328 }
329 
330 void play_controller::reset_gamestate(const config& level, int replay_pos)
331 {
332  // TODO: should we update we update this->level_ with level ?
333 
334  resources::gameboard = nullptr;
335  resources::gamedata = nullptr;
336  resources::tod_manager = nullptr;
337  resources::filter_con = nullptr;
338  resources::lua_kernel = nullptr;
339  resources::game_events = nullptr;
340  resources::tunnels = nullptr;
341  resources::undo_stack = nullptr;
342 
343  gui_->labels().set_team(nullptr);
344 
345  /* First destroy the old game state, then create the new one.
346  This is necessary to ensure that while the old AI manager is being destroyed,
347  all its member objects access the old manager instead of the new. */
348  gamestate_.reset();
349  gamestate_.reset(new game_state(level, *this));
350 
358 
359  gamestate_->ai_manager_.add_observer(this);
360  gamestate_->init(level, *this);
363 
364  gui_->reset_reports(*gamestate().reports_);
365  gui_->change_display_context(&gamestate().board_);
366  saved_game_.get_replay().set_pos(replay_pos);
367 
369  gamestate().lua_kernel_->load_game(level);
370 }
371 
373 {
374  LOG_NG << "initializing managers... " << timer();
376 
378  LOG_NG << "done initializing managers... " << timer();
379 }
380 
382 {
383  // Run initialization scripts, even if loading from a snapshot.
384  gamestate().gamedata_.get_variable("turn_number") = static_cast<int>(turn());
385  pump().fire("preload");
386  gamestate().lua_kernel_->preload_finished();
387 }
388 
390 {
391  // pre-start events must be executed before any GUI operation,
392  // as those may cause the display to be refreshed.
394 
395  // Fire these right before prestart events, to catch only the units sides
396  // have started with.
397  for(const unit& u : get_units()) {
398  pump().fire("unit_placed", map_location(u.get_location()));
399  }
400 
401  pump().fire("prestart");
402 
403  // prestart event may modify start turn with WML, reflect any changes.
404  gamestate().gamedata_.get_variable("turn_number") = static_cast<int>(turn());
405 }
406 
408 {
409  if(!get_teams().empty()) {
410  const config cfg("side", gui_->viewing_team().side());
411  gamestate().lua_kernel_->run_wml_action("show_objectives", vconfig(cfg),
412  game_events::queued_event("_from_interface", "", map_location(), map_location(), config()));
413  }
414 }
415 
417 {
419  pump().fire("start");
420 
421  skip_story_ = false; // Show [message]s from now on even with --campaign-skip-story
422 
423  // start event may modify start turn with WML, reflect any changes.
424  gamestate().gamedata_.get_variable("turn_number") = static_cast<int>(turn());
425 
428 
429  // prestart and start events may modify the initial gold amount,
430  // reflect any changes.
431  for(team& tm : get_teams()) {
432  tm.set_start_gold(tm.gold());
433  }
434 
436 }
437 
439 {
440  gui_->begin_game();
441  gui_->update_tod();
442 }
443 
445 {
447  gui_->set_playing_team_index(std::size_t(current_side() - 1));
448 
450 
452 }
453 
455 {
456  //
457  // We do side init only if not done yet for a local side when we are not replaying.
458  // For all other sides it is recorded in replay and replay handler has to handle
459  // calling do_init_side() functions.
460  //
461  if(is_during_turn()) {
462  // We already executed do_init_side this can for example happe if we reload a game,
463  // but also if we changed control of a side during it's turn
464  return;
465  }
466 
467  if(!current_team().is_local()) {
468  // We are in a mp game and execute do_init_side as soon as we receive [init_side] from the current player
469  // (see replay.cpp)
470  return;
471  }
472 
473  if(is_replay()) {
474  // We are in a replay and execute do_init_side as soon as we reach the next [init_side] in the replay data
475  // (see replay.cpp)
476  return;
477  }
478 
479  if(current_team().is_idle()) {
480  // In this case it can happen that we just gave control of this side to another player so doing init_side
481  // could lead to errors since we no longer own this side from the servers perspective.
482  // (see playturn.cpp)
483  return;
484  }
485 
487  do_init_side();
488 }
489 
491 {
492  { // Block for set_scontext_synced
493  set_scontext_synced sync;
494 
496 
497  log_scope("player turn");
498  // In case we might end up calling sync:network during the side turn events,
499  // and we don't want do_init_side to be called when a player drops.
501  gamestate_->next_player_number_ = gamestate_->player_number_ + 1;
502 
503  const std::string turn_num = std::to_string(turn());
504  const std::string side_num = std::to_string(current_side());
505 
506  gamestate().gamedata_.get_variable("side_number") = current_side();
507 
508  // We might have skipped some sides because they were empty so it is not enough to check for side_num==1
509  if(!gamestate().tod_manager_.has_turn_event_fired()) {
510  pump().fire("turn_" + turn_num);
511  pump().fire("new_turn");
513  }
514 
515  pump().fire("side_turn");
516  pump().fire("side_" + side_num + "_turn");
517  pump().fire("side_turn_" + turn_num);
518  pump().fire("side_" + side_num + "_turn_" + turn_num);
519 
520  // We want to work out if units for this player should get healed,
521  // and the player should get income now.
522  // Healing/income happen if it's not the first turn of processing,
523  // or if we are loading a game.
524  if(turn() > 1) {
527 
528  // If the expense is less than the number of villages owned
529  // times the village support capacity,
530  // then we don't have to pay anything at all
531  int expense = gamestate().board_.side_upkeep(current_side()) - current_team().support();
532  if(expense > 0) {
533  current_team().spend_gold(expense);
534  }
535  }
536 
537  if(do_healing()) {
539  }
540 
541  // Do healing on every side turn except the very first side turn.
542  // (1.14 and earlier did healing whenever turn >= 2.)
543  set_do_healing(true);
544 
545  // Set resting now after the healing has been done.
546  for(unit& patient : resources::gameboard->units()) {
547  if(patient.side() == current_side()) {
548  patient.set_resting(true);
549  }
550  }
551 
552  // Prepare the undo stack.
554 
555  pump().fire("turn_refresh");
556  pump().fire("side_" + side_num + "_turn_refresh");
557  pump().fire("turn_" + turn_num + "_refresh");
558  pump().fire("side_" + side_num + "_turn_" + turn_num + "_refresh");
559 
560  // Make sure vision is accurate.
562 
563  check_victory();
564  sync.do_final_checkup();
566  }
567 
568  statistics().reset_turn_stats(gamestate().board_.get_team(current_side()).save_id_or_number());
569 
570  init_side_end();
571 
572  if(!is_skipping_replay() && current_team().get_scroll_to_leader()) {
573  gui_->scroll_to_leader(current_side(), game_display::ONSCREEN, false);
574  }
575 }
576 
578 {
583  }
584  whiteboard_manager_->on_init_side();
585 }
586 
588 {
589  config cfg = level_;
590 
591  cfg["replay_pos"] = saved_game_.get_replay().get_pos();
592  gamestate().write(cfg);
593 
594  gui_->write(cfg.add_child("display"));
595 
596  // Write the soundsources.
597  soundsources_manager_->write_sourcespecs(cfg);
598 
599  gui_->labels().write(cfg);
601 
602  if(cfg["replay_pos"].to_int(0) > 0 && cfg["playing_team"].empty()) {
603  gui2::show_error_message(_("Trying to create a corrupt file, please report this bug"));
604  }
605 
606  return cfg;
607 }
608 
610 {
611 
612  { // Block for set_scontext_synced
613  set_scontext_synced sync(1);
614  // Also clears the undo stack.
616 
618  const std::string turn_num = std::to_string(turn());
619  const std::string side_num = std::to_string(current_side());
620 
621  // Clear shroud, in case units had been slowed for the turn.
623 
624  pump().fire("side_turn_end");
625  pump().fire("side_" + side_num + "_turn_end");
626  pump().fire("side_turn_" + turn_num + "_end");
627  pump().fire("side_" + side_num + "_turn_" + turn_num + "_end");
628  // This is where we refog, after all of a side's events are done.
630  check_victory();
631  sync.do_final_checkup();
632  }
634 }
635 
637 {
638  set_scontext_synced sync(2);
639  const std::string turn_num = std::to_string(turn());
640  pump().fire("turn_end");
641  pump().fire("turn_" + turn_num + "_end");
642  sync.do_final_checkup();
643 }
644 
646 {
647  // If we aren't using fog/shroud, this is easy :)
648  if(current_team().uses_fog() == false && current_team().uses_shroud() == false) {
649  return true;
650  }
651 
652  // See if any enemies are visible
653  for(const unit& u : get_units()) {
654  if(current_team().is_enemy(u.side()) && !gui_->fogged(u.get_location())) {
655  return true;
656  }
657  }
658 
659  return false;
660 }
661 
663 {
664  if(menu_handler_.get_textbox().active() == false) {
665  return;
666  }
667 
668  const std::string str = menu_handler_.get_textbox().box()->text();
669  const unsigned int team_num = current_side();
670  events::mouse_handler& mousehandler = mouse_handler_;
671 
672  switch(menu_handler_.get_textbox().mode()) {
673  case gui::TEXTBOX_SEARCH:
677  break;
679  if (menu_handler_.do_speak()) {
682  }
683  break;
688  break;
689  case gui::TEXTBOX_AI:
692  menu_handler_.do_ai_formula(str, team_num, mousehandler);
693  break;
694  default:
696  ERR_DP << "unknown textbox mode";
697  }
698 }
699 
701 {
702  if(menu_handler_.get_textbox().active() == false) {
703  return;
704  }
705 
706  const std::string str = menu_handler_.get_textbox().box()->text();
707  const std::vector<std::string>& command_history = menu_handler_.get_textbox().command_history();
708 
709  auto prev = std::find(command_history.begin(), command_history.end(), str);
710 
711  if (prev != command_history.end())
712  {
713  if(up) {
714  if(prev != command_history.begin()) {
715  menu_handler_.get_textbox().box()->set_text(*--prev);
716  }
717  } else {
718  if(++prev != command_history.end()) {
719  menu_handler_.get_textbox().box()->set_text(*prev);
720  } else {
721  menu_handler_.get_textbox().box()->set_text("");
722  }
723  }
724  } else if (up) {
725  if(command_history.size() > 0) {
726  menu_handler_.get_textbox().box()->set_text(*--prev);
727  }
728  if(!str.empty()) {
730  }
731  }
732 }
733 
735 {
737 
738  std::set<std::string> dictionary;
739  switch(mode) {
740  case gui::TEXTBOX_SEARCH: {
741  for(const unit& u : get_units()) {
742  const map_location& loc = u.get_location();
743  if(!gui_->fogged(loc) && !(gui_->viewing_team().is_enemy(u.side()) && u.invisible(loc)))
744  dictionary.insert(u.name());
745  }
746  // TODO List map labels
747  break;
748  }
749  case gui::TEXTBOX_COMMAND: {
750  std::vector<std::string> commands = menu_handler_.get_commands_list();
751  dictionary.insert(commands.begin(), commands.end());
752  [[fallthrough]]; // we also want player names from the next case
753  }
754  case gui::TEXTBOX_MESSAGE: {
755  for(const team& t : get_teams()) {
756  if(!t.is_empty())
757  dictionary.insert(t.current_player());
758  }
759 
760  // Add observers
761  for(const std::string& o : gui_->observers()) {
762  dictionary.insert(o);
763  }
764 
765  // Add nicks who whispered you
766  for(const std::string& w : gui_->get_chat_manager().whisperers()) {
767  dictionary.insert(w);
768  }
769 
770  // Add nicks from friendlist
771  const std::map<std::string, std::string> friends = prefs::get().get_acquaintances_nice("friend");
772 
773  for(std::map<std::string, std::string>::const_iterator iter = friends.begin(); iter != friends.end(); ++iter) {
774  dictionary.insert((*iter).first);
775  }
776 
777  // Exclude own nick from tab-completion.
778  // NOTE why ?
779  dictionary.erase(prefs::get().login());
780  break;
781  }
782 
783  default:
784  ERR_DP << "unknown textbox mode";
785  } // switch(mode)
786 
787  menu_handler_.get_textbox().tab(dictionary);
788 }
789 
791 {
792  if(get_teams().size() == 0) {
793  throw game::game_error("The scenario has no sides defined");
794  }
795 
796  assert(gamestate().board_.has_team(current_side()));
798 }
799 
801 {
802  if(get_teams().size() == 0) {
803  throw game::game_error("The scenario has no sides defined");
804  }
805 
806  assert(gamestate().board_.has_team(current_side()));
808 }
809 
810 
812 {
813  return mouse_handler_;
814 }
815 
816 std::shared_ptr<wb::manager> play_controller::get_whiteboard() const
817 {
818  return whiteboard_manager_;
819 }
820 
822 {
823  return saved_game_.mp_settings();
824 }
825 
827 {
828  return saved_game_.classification();
829 }
830 
832 {
833  return *gui_;
834 }
835 
837 {
838  return !menu_handler_.get_textbox().active();
839 }
840 
842 {
843  if(event.key.keysym.sym == SDLK_ESCAPE) {
845  } else if(event.key.keysym.sym == SDLK_TAB) {
846  tab();
847  } else if(event.key.keysym.sym == SDLK_UP) {
849  } else if(event.key.keysym.sym == SDLK_DOWN) {
851  } else if(event.key.keysym.sym == SDLK_RETURN || event.key.keysym.sym == SDLK_KP_ENTER) {
852  enter_textbox();
853  }
854 }
855 
856 void play_controller::process_keydown_event(const SDL_Event& event)
857 {
858  if(event.key.keysym.sym == SDLK_TAB) {
859  whiteboard_manager_->set_invert_behavior(true);
860  }
861 }
862 
863 void play_controller::process_keyup_event(const SDL_Event& event)
864 {
865  // If the user has pressed 1 through 9, we want to show
866  // how far the unit can move in that many turns
867  if(event.key.keysym.sym >= '1' && event.key.keysym.sym <= '9') {
868  const int new_path_turns = (event.type == SDL_KEYDOWN) ? event.key.keysym.sym - '1' : 0;
869 
870  if(new_path_turns != mouse_handler_.get_path_turns()) {
871  mouse_handler_.set_path_turns(new_path_turns);
872 
874 
875  if(u.valid()) {
876  // if it's not the unit's turn, we reset its moves
877  unit_movement_resetter move_reset(*u, u->side() != current_side());
878 
880  *u, false, true, gui_->viewing_team(), mouse_handler_.get_path_turns()));
881 
882  gui_->highlight_reach(mouse_handler_.current_paths());
883  } else {
885  }
886  }
887  } else if(event.key.keysym.sym == SDLK_TAB) {
888  CKey keys;
889  if(!keys[SDLK_TAB]) {
890  whiteboard_manager_->set_invert_behavior(false);
891  }
892  }
893 }
894 
896 {
897  assert(replay_);
898  return *replay_.get();
899 }
900 
902 {
903  // Saving while an event is running isn't supported
904  // because it may lead to expired event handlers being saved.
905  assert(!gamestate().events_manager_->is_event_running());
906 
907  scoped_savegame_snapshot snapshot(*this);
908  savegame::ingame_savegame save(saved_game_, prefs::get().save_compression_format());
910 }
911 
913 {
914  scoped_savegame_snapshot snapshot(*this);
915  savegame::ingame_savegame save(saved_game_, prefs::get().save_compression_format());
916  save.save_game_automatic(false, filename);
917 }
918 
920 {
921  savegame::replay_savegame save(saved_game_, prefs::get().save_compression_format());
923 }
924 
926 {
927  savegame::replay_savegame save(saved_game_, prefs::get().save_compression_format());
928  save.save_game_automatic(false, filename);
929 }
930 
932 {
934 }
935 
937 {
939  load.load_game_ingame();
940 }
941 
943 {
945  undo_stack().undo();
946 }
947 
949 {
951  undo_stack().redo();
952 }
953 
955 {
957 }
958 
960 {
962 }
963 
964 const std::string& play_controller::select_music(bool victory) const
965 {
966  const std::vector<std::string>& music_list = victory
967  ? (gamestate_->get_game_data()->get_victory_music().empty()
969  : gamestate_->get_game_data()->get_victory_music())
970  : (gamestate_->get_game_data()->get_defeat_music().empty()
972  : gamestate_->get_game_data()->get_defeat_music());
973 
974  if(music_list.empty()) {
975  // Since this function returns a reference, we can't return a temporary empty string.
976  static const std::string empty_str = "";
977  return empty_str;
978  }
979 
980  return music_list[randomness::rng::default_instance().get_random_int(0, music_list.size() - 1)];
981 }
982 
984 {
985  if(is_linger_mode()) {
986  return;
987  }
988 
989  if(is_regular_game_end()) {
990  return;
991  }
992 
993  bool continue_level, found_player, found_network_player, invalidate_all;
994  std::set<unsigned> not_defeated;
995 
997  continue_level,
998  found_player,
999  found_network_player,
1001  not_defeated,
1002  gamestate().remove_from_carryover_on_defeat_
1003  );
1004 
1005  if(invalidate_all) {
1006  gui_->invalidate_all();
1007  }
1008 
1009  if(continue_level) {
1010  return;
1011  }
1012 
1013  if(found_player || found_network_player) {
1014  pump().fire("enemies_defeated");
1015  if(is_regular_game_end()) {
1016  return;
1017  }
1018  }
1019 
1020  DBG_EE << "victory_when_enemies_defeated: " << gamestate().victory_when_enemies_defeated_;
1021  DBG_EE << "found_player: " << found_player;
1022  DBG_EE << "found_network_player: " << found_network_player;
1023 
1024  if(!gamestate().victory_when_enemies_defeated_ && (found_player || found_network_player)) {
1025  // This level has asked not to be ended by this condition.
1026  return;
1027  }
1028 
1029  if(video::headless()) {
1030  LOG_AIT << "winner: ";
1031  for(unsigned l : not_defeated) {
1033  if(ai.empty())
1034  ai = "default ai";
1035  LOG_AIT << l << " (using " << ai << ") ";
1036  }
1037 
1038  LOG_AIT;
1039  ai_testing::log_victory(not_defeated);
1040  }
1041 
1042  DBG_EE << "throwing end level exception...";
1043  // Also proceed to the next scenario when another player survived.
1044  end_level_data el_data;
1046  el_data.proceed_to_next_level = found_player || found_network_player;
1047  el_data.is_victory = found_player;
1048  set_end_level_data(el_data);
1049 }
1050 
1051 void play_controller::process_oos(const std::string& msg) const
1052 {
1053  if(video::headless()) {
1054  throw game::game_error(msg);
1055  }
1056 
1058  return;
1059  }
1060 
1061  std::stringstream message;
1062  message << _("The game is out of sync. It might not make much sense to continue. Do you want to save your game?");
1063  message << "\n\n" << _("Error details:") << "\n\n" << msg;
1064 
1065  scoped_savegame_snapshot snapshot(*this);
1067  save.save_game_interactive(message.str(), savegame::savegame::YES_NO); // can throw quit_game_exception
1068 }
1069 
1071 {
1072  return saved_game_.classification().get_tagname() == "multiplayer";
1073 }
1074 
1075 void play_controller::update_gui_to_player(const int team_index, const bool observe)
1076 {
1077  gui_->set_viewing_team_index(team_index, observe);
1078  gui_->recalculate_minimap();
1079  gui_->invalidate_all();
1080 }
1081 
1083 {
1084  scoped_savegame_snapshot snapshot(*this);
1085  savegame::autosave_savegame save(saved_game_, prefs::get().save_compression_format());
1086  save.autosave(false, prefs::get().auto_save_max(), pref_constants::INFINITE_AUTO_SAVES);
1087 }
1088 
1090 {
1091  scoped_savegame_snapshot snapshot(*this);
1092  savegame::ingame_savegame save(saved_game_, prefs::get().save_compression_format());
1093  save.save_game_automatic(true, filename);
1094 }
1095 
1097 {
1098  // note: this writes to level_ if this is not a replay.
1100 }
1101 
1103 {
1104  return gamestate().events_manager_->pump();
1105 }
1106 
1108 {
1109  return soundsources_manager_.get();
1110 }
1111 
1113 {
1114  return plugins_context_.get();
1115 }
1116 
1118 {
1119  return hotkey_handler_.get();
1120 }
1121 
1123 {
1124  if(!gamestate().in_phase(game_data::TURN_PLAYING)) {
1125  return true;
1126  }
1127 
1128  const team& t = current_team();
1129  return !t.is_local_human() || !t.is_proxy_human();
1130 }
1131 
1133 {
1135  return;
1136  }
1137 
1138  try {
1139  play_slice();
1140  } catch(const return_to_play_side_exception&) {
1141  assert(should_return_to_play_side());
1142  }
1143 }
1144 
1146 {
1147  if(gamestate().in_phase(game_data::PRELOAD)) {
1150 
1151  set_scontext_synced sync;
1152 
1153  // So that the code knows it can send choices immidiateley
1154  // todo: im not sure whetrh this is actually needed.
1156  fire_prestart();
1157  if(is_regular_game_end()) {
1158  return;
1159  }
1160 
1161  for(const team& t : get_teams()) {
1162  actions::clear_shroud(t.side(), false, false);
1163  }
1164 
1165  init_gui();
1166  LOG_NG << "first_time..." << (is_skipping_replay() ? "skipping" : "no skip");
1167 
1168  fire_start();
1169  if(is_regular_game_end()) {
1170  return;
1171  }
1172 
1173  sync.do_final_checkup();
1174  gui_->recalculate_minimap();
1175 
1176  // Initialize countdown clock.
1177  for(const team& t : get_teams()) {
1179  t.set_countdown_time(saved_game_.mp_settings().mp_countdown_init_time);
1180  }
1181  }
1182  did_autosave_this_turn_ = false;
1183  } else {
1184  init_gui();
1185  gui_->recalculate_minimap();
1186  }
1187 
1189 }
1190 
1191 /**
1192  * Find all [endlevel]next_scenario= attributes, and add them to @a result.
1193  */
1194 static void find_next_scenarios(const config& parent, std::set<std::string>& result) {
1195  for(const auto& endlevel : parent.child_range("endlevel")) {
1196  if(endlevel.has_attribute("next_scenario")) {
1197  result.insert(endlevel["next_scenario"]);
1198  }
1199  }
1200  for(const auto [key, cfg] : parent.all_children_view()) {
1201  find_next_scenarios(cfg, result);
1202  }
1203 };
1204 
1206  // Which scenarios are reachable from the current one?
1207  std::set<std::string> possible_next_scenarios;
1208  possible_next_scenarios.insert(gamestate().gamedata_.next_scenario());
1209 
1210  // Find all "endlevel" tags that could be triggered in events
1211  config events;
1212  gamestate().events_manager_->write_events(events);
1213  find_next_scenarios(events, possible_next_scenarios);
1214 
1215  // Are we looking for [scenario]id=, [multiplayer]id= or [test]id=?
1216  const auto tagname = saved_game_.classification().get_tagname();
1217 
1218  // Of the possible routes, work out which exist.
1219  bool possible_this_is_the_last_scenario = false;
1220  std::vector<std::string> known;
1221  std::vector<std::string> unknown;
1222  for(const auto& x : possible_next_scenarios) {
1223  if(x.empty() || x == "null") {
1224  possible_this_is_the_last_scenario = true;
1225  LOG_NG << "This can be the last scenario";
1226  } else if(utils::contains(x, '$')) {
1227  // Assume a WML variable will be set to a correct value before the end of the scenario
1228  known.push_back(x);
1229  LOG_NG << "Variable value for next scenario '" << x << "'";
1230  } else if(game_config_.find_child(tagname, "id", x)) {
1231  known.push_back(x);
1232  LOG_NG << "Known next scenario '" << x << "'";
1233  } else {
1234  unknown.push_back(x);
1235  ERR_NG << "Unknown next scenario '" << x << "'";
1236  }
1237  }
1238 
1239  if(unknown.empty()) {
1240  // everything's good
1241  return;
1242  }
1243 
1244  std::string title = _("Warning: broken campaign branches");
1245  std::stringstream message;
1246 
1247  message << _n(
1248  // TRANSLATORS: This is an error that will hopefully only be seen by UMC authors and by players who have already
1249  // said "okay" to a "loading saves from an old version might not work" dialog.
1250  "The next scenario is missing, you will not be able to finish this campaign.",
1251  // TRANSLATORS: This is an error that will hopefully only be seen by UMC authors and by players who have already
1252  // said "okay" to a "loading saves from an old version might not work" dialog.
1253  "Some of the possible next scenarios are missing, you might not be able to finish this campaign.",
1254  unknown.size() + known.size() + (possible_this_is_the_last_scenario ? 1 : 0));
1255  message << "\n\n";
1256  message << _n(
1257  "Please report the following missing scenario to the campaign’s author:\n$unknown_list|",
1258  "Please report the following missing scenarios to the campaign’s author:\n$unknown_list|",
1259  unknown.size());
1260  message << "\n";
1261  message << _("Once this is fixed, you will need to restart this scenario.");
1262 
1263  std::stringstream unknown_list;
1264  for(const auto& x : unknown) {
1265  unknown_list << font::unicode_bullet << " " << x << "\n";
1266  }
1267  utils::string_map symbols;
1268  symbols["unknown_list"] = unknown_list.str();
1269  auto message_str = utils::interpolate_variables_into_string(message.str(), &symbols);
1270  ERR_NG << message_str;
1272 }
1273 
1275 {
1276  const team& viewing_team = gui_->viewing_team();
1277  return gui_->viewing_team_is_playing() && !events::commands_disabled && viewing_team.is_local_human()
1278  && !is_browsing();
1279 }
1280 
1281 std::set<std::string> play_controller::all_players() const
1282 {
1283  std::set<std::string> res = gui_->observers();
1284  for(const team& t : get_teams()) {
1285  if(t.is_human()) {
1286  res.insert(t.current_player());
1287  }
1288  }
1289 
1290  return res;
1291 }
1292 
1294 {
1295  const bool time_left = gamestate().tod_manager_.next_turn(&gamestate().gamedata_);
1296 
1297  if(!time_left) {
1298  LOG_NG << "firing time over event...";
1300  pump().fire("time_over");
1301  LOG_NG << "done firing time over event...";
1302 
1303  // If turns are added while handling 'time over' event.
1304  if(gamestate().tod_manager_.is_time_left()) {
1305  return;
1306  }
1307 
1308  if(video::headless()) {
1309  LOG_AIT << "time over (draw)";
1311  }
1312 
1313  check_victory();
1314  if(is_regular_game_end()) {
1315  return;
1316  }
1317 
1318  end_level_data e;
1319  e.transient.reveal_map = reveal_map_default();
1320  e.proceed_to_next_level = false;
1321  e.is_victory = false;
1323  }
1324 }
1325 
1327  : controller_(controller)
1328 {
1330 }
1331 
1333 {
1334  controller_.saved_game_.remove_snapshot();
1335 }
1336 
1338 {
1339  const team& t = gui_->viewing_team();
1340  static const std::string no_objectives(_("No objectives available"));
1341  std::string objectives = utils::interpolate_variables_into_string(t.objectives(), *gamestate_->get_game_data());
1342  gui2::show_transient_message(get_scenario_name(), (objectives.empty() ? no_objectives : objectives), "", true);
1343  t.reset_objectives_changed();
1344 }
1345 
1347 {
1349  const std::shared_ptr<gui::button> skip_animation_button = get_display().find_action_button("skip-animation");
1350  if(skip_animation_button) {
1351  skip_animation_button->set_check(skip_replay_);
1352  }
1353 }
1354 
1356 {
1357  return is_skipping_replay() || (prefs::get().skip_ai_moves() && current_team().is_ai() && !is_replay());
1358 }
1359 
1361 {
1363 }
1364 
1366 {
1368 }
1369 
1371 {
1374  }
1375 }
map_location loc
Definition: move.cpp:172
Managing the AIs lifecycle - headers TODO: Refactor history handling and internal commands.
double t
Definition: astarsearch.cpp:63
map_location prev
Definition: astarsearch.cpp:64
Class that keeps track of all the keys on the keyboard.
Definition: key.hpp:29
void new_side_turn(int side)
Performs some initializations and error checks when starting a new side-turn.
Definition: undo.cpp:173
bool can_undo() const
True if there are actions that can be undone.
Definition: undo.hpp:95
void redo()
Redoes the top action on the redo stack.
Definition: undo.cpp:313
bool can_redo() const
True if there are actions that can be redone.
Definition: undo.hpp:97
void undo()
Undoes the top action on the undo stack.
Definition: undo.cpp:280
std::string get_active_ai_identifier_for_side(side_number side)
Gets AI algorithm identifier for active AI of the given side.
Definition: manager.cpp:692
void raise_gamestate_changed()
Notifies all observers of 'ai_gamestate_changed' event.
Definition: manager.cpp:448
static manager & get_singleton()
Definition: manager.hpp:140
static void log_victory(const std::set< unsigned int > &teams)
Definition: testing.cpp:81
static void log_draw()
Definition: testing.cpp:75
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:158
auto all_children_view() const
In-order iteration over all children.
Definition: config.hpp:796
const_all_children_itors all_children_range() const
In-order iteration over all children.
Definition: config.cpp:880
child_itors child_range(config_key_type key)
Definition: config.cpp:268
config & add_child(config_key_type key)
Definition: config.cpp:436
const game_config_view & game_config_
virtual void play_slice()
int side_upkeep(int side_num) const
@ ONSCREEN
Definition: display.hpp:496
std::shared_ptr< gui::button > find_action_button(const std::string &id)
Retrieves a pointer to a theme UI button.
Definition: display.cpp:763
void do_ai_formula(const std::string &str, int side_num, mouse_handler &mousehandler)
gui::floating_textbox & get_textbox()
void do_command(const std::string &str)
void do_search(const std::string &new_search)
void set_gui(game_display *gui)
Definition: menu_events.hpp:57
std::vector< std::string > get_commands_list()
void set_gui(game_display *gui)
const pathfind::paths & current_paths() const
void set_current_paths(const pathfind::paths &new_paths)
unit_map::iterator selected_unit()
map_location get_selected_hex() const
void select_hex(const map_location &hex, const bool browse, const bool highlight=true, const bool fire_event=true, const bool force_unhighlight=false)
int get_path_turns() const
void set_side(int side_number)
void set_path_turns(const int path_turns)
void check_victory(bool &, bool &, bool &, bool &, std::set< unsigned > &, bool)
Definition: game_board.cpp:114
team & get_team(int i)
Definition: game_board.hpp:92
void end_turn(int pnum)
Definition: game_board.cpp:79
void new_turn(int pnum)
Definition: game_board.cpp:70
std::string get_tagname() const
optional_const_config find_child(config_key_type key, const std::string &name, const std::string &value) const
static game_config_view wrap(const config &cfg)
void set_phase(PHASE phase)
Definition: game_data.hpp:106
@ PRELOAD
the preload [event] is fired next phase: PRESTART (normal game), TURN_STARTING_WAITING (reloaded game...
Definition: game_data.hpp:76
@ INITIAL
creating intitial [unit]s, executing toplevel [lua] etc.
Definition: game_data.hpp:73
@ GAME_ENDED
The game has ended and the user is observing the final state "lingering" The game can be saved here.
Definition: game_data.hpp:102
@ PRESTART
the prestart [event] is fired next phase: START (default), GAME_ENDING
Definition: game_data.hpp:79
@ TURN_PLAYING
The User is controlling the game and invoking actions The game can be saved here.
Definition: game_data.hpp:93
@ TURN_STARTING_WAITING
we are waiting for the turn to start.
Definition: game_data.hpp:86
@ START
the start [event] is fired next phase: TURN_STARTING_WAITING (default), GAME_ENDING
Definition: game_data.hpp:82
@ TURN_STARTING
the turn, side turn etc.
Definition: game_data.hpp:89
PHASE phase() const
Definition: game_data.hpp:105
map_location last_selected
the last location where a select event fired.
Definition: game_data.hpp:126
config::attribute_value & get_variable(const std::string &varname)
throws invalid_variablename_exception if varname is no valid variable name.
Definition: game_data.cpp:66
pump_result_t fire(const std::string &event, const entity_location &loc1=entity_location::null_entity, const entity_location &loc2=entity_location::null_entity, const config &data=config())
Function to fire an event.
Definition: pump.cpp:399
void write(config &cfg) const
Definition: game_state.cpp:216
bool in_phase(game_data::PHASE phase) const
Definition: game_state.hpp:109
void set_game_display(game_display *)
Definition: game_state.cpp:211
std::unique_ptr< game_lua_kernel > lua_kernel_
Definition: game_state.hpp:48
std::unique_ptr< pathfind::manager > pathfind_manager_
Definition: game_state.hpp:46
game_board board_
Definition: game_state.hpp:44
const std::unique_ptr< game_events::manager > events_manager_
Definition: game_state.hpp:50
bool victory_when_enemies_defeated_
Definition: game_state.hpp:61
tod_manager tod_manager_
Definition: game_state.hpp:45
game_data gamedata_
Definition: game_state.hpp:43
static void progress(loading_stage stage=loading_stage::none)
Report what is being loaded to the loading screen.
static void raise()
Raise the loading screen to the top of the draw stack.
static void display(const std::function< void()> &f)
@ close_button
Shows a close button.
Definition: message.hpp:75
void memorize_command(const std::string &command)
const std::unique_ptr< gui::textbox > & box() const
TEXTBOX_MODE mode() const
void tab(const std::set< std::string > &dictionary)
const std::vector< std::string > & command_history() const
game_classification & get_classification()
const std::string & select_music(bool victory) const
void process_keydown_event(const SDL_Event &event) override
Process keydown (always).
void maybe_throw_return_to_play_side() const
config to_config() const
Builds the snapshot config from members and their respective configs.
void init(const config &level)
std::vector< team > & get_teams()
std::unique_ptr< hotkey_handler > hotkey_handler_
virtual void init_gui()
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
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
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
void set_do_healing(bool do_healing)
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)
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
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 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
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
std::unique_ptr< soundsource::manager > soundsources_manager_
void do_init_side()
Called by replay handler or init_side() to do actual work for turn change.
std::string theme() const
int current_side() const
Returns the number of the side whose turn it is.
bool is_skipping_replay() const
std::shared_ptr< wb::manager > get_whiteboard() 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
std::size_t turn() const
map_location map_start_
virtual bool should_return_to_play_side() const
std::set< std::string > all_players() const
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
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()
persist_manager persist_
std::shared_ptr< wb::manager > whiteboard_manager_
virtual void check_time_over()
t_string get_scenario_name() const
static plugins_manager * get()
Definition: manager.cpp:58
static prefs & get()
void encounter_all_content(const game_board &gb)
std::map< std::string, std::string > get_acquaintances_nice(const std::string &filter)
Implements a quit confirmation dialog.
static rng & default_instance()
Definition: random.cpp:73
int get_random_int(int min, int max)
Definition: random.hpp:51
bool add_start_if_not_there_yet()
Definition: replay.cpp:660
void init_side()
Definition: replay.cpp:204
config * get_next_action()
Definition: replay.cpp:606
Exception used to escape form the ai or ui code to playsingle_controller::play_side.
game_classification & classification()
Definition: saved_game.hpp:56
mp_game_settings & mp_settings()
Multiplayer parameters for this game.
Definition: saved_game.hpp:60
replay_recorder_base & get_replay()
Definition: saved_game.hpp:140
config & set_snapshot(config snapshot)
Definition: saved_game.cpp:607
Class for autosaves.
Definition: savegame.hpp:281
void autosave(const bool disable_autosave, const int autosave_max, const int infinite_autosaves)
Definition: savegame.cpp:599
Class for "normal" midgame saves.
Definition: savegame.hpp:254
The class for loading a savefile.
Definition: savegame.hpp:101
Class for replay saves (either manually or automatically).
Definition: savegame.hpp:268
static std::shared_ptr< save_index_class > default_saves_dir()
Returns an instance for managing saves in filesystem::get_saves_dir()
Definition: save_index.cpp:210
bool save_game_automatic(bool ask_for_overwrite=false, const std::string &filename="")
Saves a game without user interaction, unless the file exists and it should be asked to overwrite it.
Definition: savegame.cpp:362
bool save_game_interactive(const std::string &message, DIALOG_TYPE dialog_type)
Save a game interactively through the savegame dialog.
Definition: savegame.cpp:379
A RAII object to enter the synced context, cannot be called if we are already in a synced context.
void do_final_checkup(bool dont_throw=false)
void reset_turn_stats(const std::string &save_id)
Definition: statistics.cpp:207
static bool run_in_synced_context_if_not_already(const std::string &commandname, const config &data, action_spectator &spectator=get_default_spectator())
Checks whether we are currently running in a synced context, and if not we enters it.
static synced_state get_synced_state()
static void block_undo(bool do_block=true, bool clear_undo=true)
set this to false to prevent clearing the undo stack, this is important when we cannot change the gam...
This class stores all the data for a single 'side' (in game nomenclature).
Definition: team.hpp:75
bool is_ai() const
Definition: team.hpp:256
int support() const
Calculate total support capacity, based on support_per_village.
Definition: team.hpp:195
bool is_local_human() const
Definition: team.hpp:258
void spend_gold(const int amount)
Definition: team.hpp:200
void new_turn()
Definition: team.hpp:196
void turn_event_fired()
const time_of_day & get_time_of_day(int for_turn=0) const
Returns global time of day for the passed turn.
Definition: tod_manager.hpp:56
bool next_turn(game_data *vars)
Function to move to the next turn.
void remove_scenario_fixes()
Definition: types.cpp:1467
void apply_scenario_fix(const config &cfg)
Definition: types.cpp:1432
This class represents a single unit of a specific type.
Definition: unit.hpp:133
A variable-expanding proxy for the config class.
Definition: variable.hpp:45
This class is the frontend of the whiteboard framework for the rest of the Wesnoth code.
Definition: manager.hpp:44
int w
void throw_quit_game_exception()
static std::string _n(const char *str1, const char *str2, int n)
Definition: gettext.hpp:101
static std::string _(const char *str)
Definition: gettext.hpp:97
void calculate_healing(int side, bool update_display)
Calculates healing for all units for the given side.
Definition: heal.cpp:290
Various functions that implement healing of units (when a side turn starts).
This file implements all the hotkey handling and menu details for play controller.
Standard logging facilities (interface).
#define log_scope(description)
Definition: log.hpp:275
Declarations for a class that implements WML-defined (right-click) menu items.
bool clear_shroud(int side, bool reset_fog, bool fire_events)
Function that will clear shroud (and fog) based on current unit positions.
Definition: vision.cpp:746
void recalculate_fog(int side)
Function that recalculates the fog of war.
Definition: vision.cpp:697
A small explanation about what's going on here: Each action has access to two game_info objects First...
Definition: actions.cpp:59
void invalidate_all()
Mark the entire screen as requiring redraw.
Handling of system events.
Graphical text output.
const std::string unicode_bullet
Definition: constants.cpp:47
std::string observer
std::vector< std::string > default_defeat_music
bool ignore_replay_errors
Definition: game_config.cpp:89
static void add_color_info(const game_config_view &v, bool build_defaults)
std::vector< std::string > default_victory_music
std::vector< game_tip > load(const config &cfg)
Loads the tips from a config.
Definition: tips.cpp:37
void show_transient_message(const std::string &title, const std::string &message, const std::string &image, const bool message_use_markup, const bool title_use_markup)
Shows a transient message to the user.
void show_error_message(const std::string &msg, bool message_use_markup)
Shows an error message to the user.
Definition: message.cpp:201
void show_message(const std::string &title, const std::string &msg, const std::string &button_caption, const bool auto_close, const bool message_use_markup, const bool title_use_markup)
Shows a message to the user.
Definition: message.cpp:148
@ TEXTBOX_MESSAGE
@ TEXTBOX_SEARCH
@ TEXTBOX_COMMAND
Keyboard shortcuts for game actions.
constexpr uint32_t scope_game
std::string tag(std::string_view tag, Args &&... data)
Wraps the given data in the specified tag.
Definition: markup.hpp:45
const int INFINITE_AUTO_SAVES
Definition: preferences.hpp:59
::tod_manager * tod_manager
Definition: resources.cpp:29
game_board * gameboard
Definition: resources.cpp:20
persist_manager * persist
Definition: resources.cpp:26
game_data * gamedata
Definition: resources.cpp:22
game_events::manager * game_events
Definition: resources.cpp:24
replay * recorder
Definition: resources.cpp:28
actions::undo_list * undo_stack
Definition: resources.cpp:32
soundsource::manager * soundsources
Definition: resources.cpp:27
game_lua_kernel * lua_kernel
Definition: resources.cpp:25
game_classification * classification
Definition: resources.cpp:34
pathfind::manager * tunnels
Definition: resources.cpp:31
play_controller * controller
Definition: resources.cpp:21
filter_context * filter_con
Definition: resources.cpp:23
std::shared_ptr< wb::manager > whiteboard
Definition: resources.cpp:33
void write_music_play_list(config &snapshot)
Definition: sound.cpp:868
void play_sound(const std::string &files, channel_group group, unsigned int repeats)
Definition: sound.cpp:1043
@ SOUND_SOURCES
Definition: sound.hpp:30
std::size_t size(std::string_view str)
Length in characters of a UTF-8 string.
Definition: unicode.cpp:85
constexpr auto keys
Definition: ranges.hpp:39
std::string interpolate_variables_into_string(const std::string &str, const string_map *const symbols)
Function which will interpolate variables, starting with '$' in the string 'str' with the equivalent ...
bool contains(const Container &container, const Value &value)
Returns true iff value is found in container.
Definition: general.hpp:86
std::string get_unknown_exception_type()
Utility function for finding the type of thing caught with catch(...).
Definition: general.cpp:23
std::map< std::string, t_string > string_map
auto * find(Container &container, const Value &value)
Convenience wrapper for using find on a container without needing to comare to end()
Definition: general.hpp:140
bool headless()
The game is running headless.
Definition: video.cpp:139
static void msg(const char *act, debug_info &i, const char *to="", const char *result="")
Definition: debugger.cpp:109
static void clear_resources()
static lg::log_domain log_engine("engine")
#define ERR_NG
static lg::log_domain log_aitesting("ai/testing")
static void find_next_scenarios(const config &parent, std::set< std::string > &result)
Find all [endlevel]next_scenario= attributes, and add them to result.
static void copy_persistent(const config &src, config &dst)
Copies [scenario] attributes/tags that are not otherwise stored in C++ structs/clases.
static lg::log_domain log_enginerefac("enginerefac")
#define LOG_AIT
static lg::log_domain log_display("display")
static lg::log_domain log_engine_enemies("engine/enemies")
#define DBG_NG
#define ERR_DP
#define DBG_EE
#define LOG_NG
Define the game's event mechanism.
Replay control code.
rect dst
Location on the final composed sheet.
rect src
Non-transparent portion of the surface to compose.
std::string filename
Filename.
Additional information on the game outcome which can be provided by WML.
bool proceed_to_next_level
whether to proceed to the next scenario, equals is_victory in sp.
transient_end_level transient
Error used for any general game error, e.g.
Definition: game_errors.hpp:47
Encapsulates the map of the game.
Definition: location.hpp:45
static const map_location & null_location()
Definition: location.hpp:102
std::chrono::seconds mp_countdown_init_time
Object which contains all the possible locations a unit can move to, with associated best routes to t...
Definition: pathfind.hpp:73
scoped_savegame_snapshot(const play_controller &controller)
Object which defines a time of day with associated bonuses, image, sounds etc.
Definition: time_of_day.hpp:57
std::string sounds
List of "ambient" sounds associated with this time_of_day, Played at the beginning of turn.
bool reveal_map
Should we reveal map when game is ended? (Multiplayer only)
bool valid() const
Definition: map.hpp:273
Object which temporarily resets a unit's movement.
Definition: unit.hpp:2172
const std::string & gamedata
Gather statistics important for AI testing and output them.
unit_type_data unit_types
Definition: types.cpp:1504
Various functions that implement the undoing (and redoing) of in-game commands.
Various functions implementing vision (through fog of war and shroud).
#define e