The Battle for Wesnoth  1.19.15+dev
game_launcher.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2003 - 2025
3  by David White <dave@whitevine.net>
4  Part of the Battle for Wesnoth Project https://www.wesnoth.org/
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 2 of the License, or
9  (at your option) any later version.
10  This program is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY.
12 
13  See the COPYING file for more details.
14 */
15 
16 #include "game_launcher.hpp"
17 #include "game_errors.hpp"
18 
19 #include "ai/manager.hpp" // for manager
20 #include "commandline_options.hpp" // for commandline_options
21 #include "config.hpp" // for config, etc
22 #include "cursor.hpp" // for set, CURSOR_TYPE::NORMAL
23 #include "exceptions.hpp" // for error
24 #include "filesystem.hpp" // for get_user_data_dir, etc
25 #include "game_classification.hpp" // for game_classification, etc
26 #include "game_config.hpp" // for path, etc
27 #include "game_config_manager.hpp" // for game_config_manager
28 #include "game_initialization/multiplayer.hpp" // for start_client, etc
29 #include "game_initialization/playcampaign.hpp" // for play_game, etc
30 #include "game_initialization/singleplayer.hpp" // for sp_create_mode
31 #include "generators/map_generator.hpp" // for mapgen_exception
32 #include "gettext.hpp" // for _
33 #include "gui/dialogs/language_selection.hpp" // for language_selection
35 #include "gui/dialogs/message.hpp" // for show error message
37 #include "gui/dialogs/title_screen.hpp" // for show_debug_clock_button
38 #include "gui/dialogs/transient_message.hpp" // for show_transient_message
39 #include "gui/widgets/settings.hpp" // for new_widgets
40 #include "language.hpp" // for language_def, etc
41 #include "log.hpp" // for LOG_STREAM, logger, general, etc
42 #include "map/exception.hpp"
44 #include "save_index.hpp"
46 #include "sdl/surface.hpp" // for surface
47 #include "serialization/compression.hpp" // for format::NONE
48 #include "tstring.hpp" // for operator==, operator!=
49 #include "video.hpp"
51 #include "wml_exception.hpp" // for wml_exception
52 
53 #ifdef __APPLE__
54 
55 //
56 // HACK: MacCompileStuff is currently on 1.86, so it could use the v2 API,
57 // but we need to update the libs manually to link against boost::process.
58 //
59 // -- vultraz, 2025-05-12
60 //
61 #if BOOST_VERSION > 108600
62 #error MacCompileStuff has been updated. Remove this block and the accompanying __APPLE__ checks below.
63 #endif
64 #include <boost/process/v1/child.hpp>
65 
66 #elif BOOST_VERSION >= 108600
67 
68 // boost::asio (via boost::process) complains about winsock.h otherwise
69 #ifdef _WIN32
70 #define WIN32_LEAN_AND_MEAN
71 #endif
72 #include <boost/process/v2/process.hpp>
73 
74 #else
75 
76 // process::v1 only. The v1 folders do not exist until 1.86
77 #ifdef _WIN32
78 #include <boost/process/windows.hpp>
79 #endif
80 #include <boost/process/child.hpp>
81 
82 #endif
83 
84 #include <algorithm> // for copy, max, min, stable_sort
85 #include <cstdlib> // for system
86 #include <new>
87 #include <thread>
88 #include <utility> // for pair
89 
90 #ifdef DEBUG_WINDOW_LAYOUT_GRAPHS
91 #include "gui/widgets/debug.hpp"
92 #endif
93 
94 static lg::log_domain log_config("config");
95 #define ERR_CONFIG LOG_STREAM(err, log_config)
96 #define WRN_CONFIG LOG_STREAM(warn, log_config)
97 #define LOG_CONFIG LOG_STREAM(info, log_config)
98 
99 #define ERR_GENERAL LOG_STREAM(err, lg::general())
100 #define LOG_GENERAL LOG_STREAM(info, lg::general())
101 #define WRN_GENERAL LOG_STREAM(warn, lg::general())
102 #define DBG_GENERAL LOG_STREAM(debug, lg::general())
103 
104 #define LOG_TEST FORCE_LOG_TO(lg::general(), log_config)
105 
106 static lg::log_domain log_mp_create("mp/create");
107 #define DBG_MP LOG_STREAM(debug, log_mp_create)
108 
109 static lg::log_domain log_network("network");
110 #define ERR_NET LOG_STREAM(err, log_network)
111 
112 static lg::log_domain log_enginerefac("enginerefac");
113 #define LOG_RG LOG_STREAM(info, log_enginerefac)
114 
116  : cmdline_opts_(cmdline_opts)
117  , font_manager_()
118  , image_manager_()
119  , main_event_context_()
120  , hotkey_manager_()
121  , music_thinker_()
122  , music_muter_()
123  , test_scenarios_{"test"}
124  , screenshot_map_()
125  , screenshot_filename_()
126  , state_()
127  , play_replay_(false)
128  , multiplayer_server_()
129  , jump_to_multiplayer_(false)
130  , jump_to_campaign_{}
131  , jump_to_editor_()
132  , load_data_()
133 {
134  bool no_music = false;
135  bool no_sound = false;
136 
137  if(cmdline_opts_.core_id) {
138  prefs::get().set_core(*cmdline_opts_.core_id);
139  }
140  if(cmdline_opts_.campaign) {
141  jump_to_campaign_.jump = true;
143  PLAIN_LOG << "selected campaign id: [" << jump_to_campaign_.campaign_id << "]";
144 
147  PLAIN_LOG << "selected difficulty: [" << jump_to_campaign_.difficulty << "]";
148  } else {
149  jump_to_campaign_.difficulty = -1; // let the user choose the difficulty
150  }
151 
154  PLAIN_LOG << "selected scenario id: [" << jump_to_campaign_.scenario_id << "]";
155  }
156 
159  }
160  }
161  if(cmdline_opts_.clock)
163  if(cmdline_opts_.debug) {
165  game_config::mp_debug = true;
166  }
167 #ifdef DEBUG_WINDOW_LAYOUT_GRAPHS
168  if(cmdline_opts_.debug_dot_domain)
169  gui2::debug_layout_graph::set_domain(*cmdline_opts_.debug_dot_domain);
170  if(cmdline_opts_.debug_dot_level)
171  gui2::debug_layout_graph::set_level(*cmdline_opts_.debug_dot_level);
172 #endif
175  if(cmdline_opts_.fps)
176  prefs::get().set_show_fps(true);
178  prefs::get().set_fullscreen(true);
179  if(cmdline_opts_.load) {
180 #ifdef __cpp_aggregate_paren_init
181  load_data_.emplace(
183 #else
186 #endif
187  try {
188  load_data_->read_file();
189  } catch(const game::load_game_failed&) {
190  load_data_.reset();
191  }
192  }
193  if(cmdline_opts_.max_fps) {
194  prefs::get().set_refresh_rate(std::clamp(*cmdline_opts_.max_fps, 1, 1000));
195  }
197  no_sound = true;
199  }
201  gui2::new_widgets = true;
203  no_music = true;
205  no_sound = true;
207  const int xres = std::get<0>(*cmdline_opts_.resolution);
208  const int yres = std::get<1>(*cmdline_opts_.resolution);
209  if(xres > 0 && yres > 0) {
210  prefs::get().set_resolution(point(xres, yres));
211  prefs::get().set_maximized(false);
212  }
213  }
215  // TODO it could be simplified to use cmdline_opts_ directly if there is no other way to enter screenshot mode
218  no_sound = true;
220  }
221  if (cmdline_opts_.server){
222  jump_to_multiplayer_ = true;
223  // Do we have any server specified ?
224  if(!cmdline_opts_.server->empty()) {
226  } else {
227  // Pick the first server in config
228  if(game_config::server_list.size() > 0) {
230  } else {
231  multiplayer_server_ = "";
232  }
233  }
234  if(cmdline_opts_.username) {
237  if(cmdline_opts_.password) {
239  prefs::get().set_password(*cmdline_opts.server, *cmdline_opts.username, *cmdline_opts_.password);
240  }
241  }
242  }
243  if(cmdline_opts_.test) {
244  if(!cmdline_opts_.test->empty()) {
246  }
247  }
248  if(!cmdline_opts_.unit_test.empty()) {
250  }
252  prefs::get().set_fullscreen(false);
254  load_data_->show_replay = true;
257 
258  if(!cmdline_opts.nobanner) {
259  PLAIN_LOG
260  << "\nGame data: " << game_config::path
261  << "\nUser data: " << filesystem::get_user_data_dir()
262  << "\nCache: " << filesystem::get_cache_dir()
263  << "\n";
264  }
265 
266  // disable sound in nosound mode, or when sound engine failed to initialize
267  if(no_sound || ((prefs::get().sound() || prefs::get().music_on() ||
269  !sound::init_sound())) {
270  prefs::get().set_sound(false);
271  prefs::get().set_music(false);
272  prefs::get().set_turn_bell(false);
273  prefs::get().set_ui_sound(false);
274  } else if(no_music) { // else disable the music in nomusic mode
275  prefs::get().set_music(false);
276  }
277 }
278 
280 {
281  if(!::load_language_list()) {
282  return false;
283  }
284 
285  language_def locale;
286  if(cmdline_opts_.language) {
287  std::vector<language_def> langs = get_languages(true);
288  for(const language_def& def : langs) {
289  if(def.localename == *cmdline_opts_.language) {
290  locale = def;
291  break;
292  }
293  }
294  if(locale.localename.empty()) {
295  PLAIN_LOG << "Language symbol '" << *cmdline_opts_.language << "' not found.";
296  return false;
297  }
298  } else {
299  locale = get_locale();
300  }
301  ::set_language(locale);
302 
303  return true;
304 }
305 
307 {
308  // Handle special commandline launch flags
313  {
319  {
320  PLAIN_LOG << "--nogui flag is only valid with --multiplayer or --screenshot or --plugin flags";
321  return false;
322  }
324  // Screenshots require a rendering context, and thus a window,
325  // so we create one but hidden.
327  } else {
328  // Other functions don't require a window at all.
330  }
331  return true;
332  }
333 
334  // Initialize video subsystem, and create a new window.
335  video::init();
336 
337  // Set window title and icon
339 
340 #if !(defined(__APPLE__))
341  surface icon(image::get_surface(image::locator{"icons/icon-game.png"}, image::UNSCALED));
342  if(icon != nullptr) {
344  }
345 #endif
346  return true;
347 }
348 
350 {
351  bool error = false;
352 
353  if(!cmdline_opts_.nobanner) {
354  STREAMING_LOG << "Checking lua scripts... ";
355  }
356 
358  // load the "package" package, so that scripts can get what packages they want
360  }
361 
363  std::string filename = *cmdline_opts_.plugin_file;
364 
365  PLAIN_LOG << "Loading a plugin file'" << filename << "'...";
366 
368 
369  try {
370  if(sf->fail()) {
371  throw std::runtime_error("failed to open plugin file");
372  }
373 
374  /* Cancel all "jumps" to editor / campaign / multiplayer */
375  jump_to_multiplayer_ = false;
376  jump_to_editor_ = utils::nullopt;
377  jump_to_campaign_.jump = false;
378 
379  std::string full_plugin((std::istreambuf_iterator<char>(*sf)), std::istreambuf_iterator<char>());
380 
382 
383  std::size_t i = pm.add_plugin(filename, full_plugin);
384 
385  for(std::size_t j = 0; j < pm.size(); ++j) {
386  PLAIN_LOG << j << ": " << pm.get_name(j) << " -- " << pm.get_detailed_status(j);
387  }
388 
389  PLAIN_LOG << "Starting a plugin...";
390  pm.start_plugin(i);
391 
392  for(std::size_t j = 0; j < pm.size(); ++j) {
393  PLAIN_LOG << j << ": " << pm.get_name(j) << " -- " << pm.get_detailed_status(j);
394  }
395 
396  plugins_context pc("init");
397 
398  for(std::size_t repeat = 0; repeat < 5; ++repeat) {
399  PLAIN_LOG << "Playing a slice...";
400  pc.play_slice();
401 
402  for(std::size_t j = 0; j < pm.size(); ++j) {
403  PLAIN_LOG << j << ": " << pm.get_name(j) << " -- " << pm.get_detailed_status(j);
404  }
405  }
406 
407  return true;
408  } catch(const std::exception& e) {
409  gui2::show_error_message(std::string("When loading a plugin, error:\n") + e.what());
410  error = true;
411  }
412  }
413 
414  if(!error && !cmdline_opts_.nobanner) {
415  PLAIN_LOG << "ok";
416  }
417 
418  return !error;
419 }
420 
421 void game_launcher::set_test(const std::string& id)
422 {
423  state_.clear();
424  state_.classification().type = campaign_type::type::test;
426  state_.classification().era_id = "era_default";
427 
428  state_.set_carryover_sides_start(config{"next_scenario", id});
429 }
430 
432 {
433  // This first_time variable was added in 70f3c80a3e2 so that using the GUI
434  // menu to load a game works. That seems to have edge-cases, for example if
435  // you try to load a game a second time then Wesnoth exits.
436  static bool first_time = true;
437 
438  if(!cmdline_opts_.test) {
439  return true;
440  }
441 
442  if(!first_time) {
443  return false;
444  }
445 
446  first_time = false;
447 
448  if(test_scenarios_.size() == 0) {
449  // shouldn't happen, as test_scenarios_ is initialised to {"test"}
450  PLAIN_LOG << "Error in the test handling code";
451  return false;
452  }
453 
454  if(test_scenarios_.size() > 1) {
455  PLAIN_LOG << "You can't run more than one unit test in interactive mode";
456  }
457 
458  set_test(test_scenarios_.at(0));
459 
461 
462  try {
463  campaign_controller ccontroller(state_);
464  ccontroller.play_game();
465  } catch(savegame::load_game_exception& e) {
466  load_data_ = std::move(e.data_);
467  return true;
468  }
469 
470  return false;
471 }
472 
473 /**
474  * Runs unit tests specified on the command line.
475  *
476  * If multiple unit tests were specified, then this will stop at the first test
477  * which returns a non-zero status.
478  */
479 // Same as play_test except that we return the results of play_game.
480 // \todo "same ... except" ... and many other changes, such as testing the replay
482 {
483  // There's no copy of play_test's first_time variable. That seems to be for handling
484  // the player loading a game via the GUI, which makes no sense in a non-interactive test.
485  if(cmdline_opts_.unit_test.empty()) {
487  }
488 
489  auto ret = unit_test_result::TEST_FAIL; // will only be returned if no test is run
490  for(const auto& scenario : test_scenarios_) {
491  set_test(scenario);
492  ret = single_unit_test();
493  const char* describe_result;
494  switch(ret) {
496  describe_result = "PASS TEST";
497  break;
499  describe_result = "FAIL TEST (INVALID REPLAY)";
500  break;
502  describe_result = "FAIL TEST (ERRORED REPLAY)";
503  break;
505  describe_result = "FAIL TEST (WML EXCEPTION)";
506  break;
508  describe_result = "FAIL TEST (DEFEAT)";
509  break;
511  describe_result = "PASS TEST (VICTORY)";
512  break;
514  describe_result = "BROKE STRICT (PASS)";
515  break;
517  describe_result = "BROKE STRICT (FAIL)";
518  break;
520  describe_result = "BROKE STRICT (DEFEAT)";
521  break;
523  describe_result = "BROKE STRICT (VICTORY)";
524  break;
525  default:
526  describe_result = "FAIL TEST (UNKNOWN)";
527  break;
528  }
529 
530  PLAIN_LOG << describe_result << " (" << int(ret) << "): " << scenario;
531  if(ret != unit_test_result::TEST_PASS) {
532  break;
533  }
534  }
535 
536  return ret;
537 }
538 
540 {
542 
543  level_result::type game_res = level_result::type::fail;
544  try {
545  campaign_controller ccontroller(state_, true);
546  game_res = ccontroller.play_game();
547  if(game_res == level_result::type::fail) {
548  if(lg::broke_strict()) {
550  } else {
552  }
553  }
554  } catch(const wml_exception& e) {
555  PLAIN_LOG << "Caught WML Exception:" << e.dev_message;
557  }
558 
560 
562  return pass_victory_or_defeat(game_res);
563  }
564 
566  save.save_game_automatic(false, "unit_test_replay");
567 
568 #ifdef __cpp_aggregate_paren_init
569  load_data_.emplace(
570  savegame::save_index_class::default_saves_dir(), save.filename(), "", true, true, false);
571 #else
573  savegame::save_index_class::default_saves_dir(), save.filename(), "", true, true, false};
574 #endif
575  load_data_->read_file();
576 
577  if(!load_prepared_game()) {
578  PLAIN_LOG << "Failed to load the replay!";
579  return unit_test_result::TEST_FAIL_LOADING_REPLAY; // failed to load replay
580  }
581 
582  try {
583  const bool was_strict_broken = lg::broke_strict();
584  campaign_controller ccontroller(state_, true);
585  ccontroller.play_replay();
586  if(!was_strict_broken && lg::broke_strict()) {
587  PLAIN_LOG << "Observed failure on replay";
589  }
590  } catch(const wml_exception& e) {
591  PLAIN_LOG << "WML Exception while playing replay: " << e.dev_message;
593  }
594 
595  return pass_victory_or_defeat(game_res);
596 }
597 
599 {
600  if(res == level_result::type::defeat) {
601  if(lg::broke_strict()) {
603  } else {
605  }
606  } else if(res == level_result::type::victory) {
607  if(lg::broke_strict()) {
609  } else {
611  }
612  }
613 
614  if(lg::broke_strict()) {
616  } else {
618  }
619 }
620 
622 {
624  return true;
625  }
626 
628 
630 
632  return false;
633 }
634 
636 {
638  return true;
639  }
640 
641  state_.classification().type = campaign_type::type::multiplayer;
642  DBG_GENERAL << "Current campaign type: " << campaign_type::get_string(state_.classification().type);
643 
644  try {
646  } catch(const config::error& e) {
647  PLAIN_LOG << "Error loading game config: " << e.what();
648  return false;
649  }
650 
651  // A default output filename
652  std::string outfile = "wesnoth_image.png";
653 
654  // If a output path was given as an argument, use that instead
656  outfile = *cmdline_opts_.render_image_dst;
657  }
658 
660  exit(1);
661  }
662 
663  return false;
664 }
665 
667 {
668  return load_data_.has_value();
669 }
670 
672 {
673  return std::exchange(load_data_, utils::nullopt).value();
674 }
675 
677 {
678  DBG_GENERAL << "Current campaign type: " << campaign_type::get_string(state_.classification().type);
679  assert(!load_data_);
680 
681  // FIXME: evaluate which of these damn catch blocks are still necessary
682  try {
684 
685  } catch(const config::error& e) {
686  if(e.message.empty()) {
687  gui2::show_error_message(_("The file you have tried to load is corrupt"));
688  } else {
689  gui2::show_error_message(_("The file you have tried to load is corrupt: '") + e.message + '\'');
690  }
691 
692  return false;
693  } catch(const wml_exception& e) {
694  e.show();
695  return false;
696  } catch(const filesystem::io_exception& e) {
697  if(e.message.empty()) {
698  gui2::show_error_message(_("File I/O Error while reading the game"));
699  } else {
700  gui2::show_error_message(_("File I/O Error while reading the game: '") + e.message + '\'');
701  }
702 
703  return false;
704  } catch(const game::error& e) {
705  if(e.message.empty()) {
706  gui2::show_error_message(_("The file you have tried to load is corrupt"));
707  } else {
708  gui2::show_error_message(_("The file you have tried to load is corrupt: '") + e.message + '\'');
709  }
710 
711  return false;
712  }
713 
714  // If the player canceled loading, we won't have any load data at this point
715  return has_load_data();
716 }
717 
719 {
720  auto load_data = extract_load_data();
722 
723  play_replay_ = load_data.show_replay;
724 
725  // in case show_replay && is_start_of_scenario
726  // there won't be any turns to replay, but the
727  // user gets to watch the intro sequence again ...
728  if(load_data.show_replay && !state_.is_start_of_scenario()) {
730  }
731 
732  if(load_data.cancel_orders) {
734  }
735 
736  try {
738  } catch(const config::error&) {
739  return false;
740  }
741 
742  return true;
743 }
744 
746 {
747  state_.clear();
748  state_.classification().type = campaign_type::type::scenario;
749  play_replay_ = false;
750 
752 }
753 
755 {
757 }
758 
760  jump_to_campaign_.jump = false;
761  if(new_campaign()) {
764  return true;
765  }
766  return false;
767 }
768 
770 {
771  if(jump_to_campaign_.jump) {
772  return play_campaign();
773  }
774 
775  return true;
776 }
777 
779 {
780  if(!jump_to_multiplayer_) {
781  return true;
782  }
783 
784  jump_to_multiplayer_ = false;
786 }
787 
789 {
790  if(jump_to_editor_) {
791  // If no filename was specified, this will be an empty string.
792  const std::string to_open = std::exchange(jump_to_editor_, utils::nullopt).value();
793 
795  return false;
796  }
797  }
798 
799  return true;
800 }
801 
803 {
804  std::string wesnothd_program = "";
805  if(!prefs::get().get_mp_server_program_name().empty()) {
806  wesnothd_program = prefs::get().get_mp_server_program_name();
807  } else {
808  wesnothd_program = filesystem::get_wesnothd_name();
809  }
810 
811  std::string config = filesystem::get_user_data_dir() + "/lan_server.cfg";
813  // copy file if it isn't created yet
815  }
816 
817  LOG_GENERAL << "Starting wesnothd";
818  try
819  {
820 #if !defined(__APPLE__) && BOOST_VERSION >= 108600
821  boost::asio::io_context io_context;
822  auto c = boost::process::v2::process{io_context, wesnothd_program, { "-c", config }};
823 #else
824 #ifndef _WIN32
825  boost::process::child c(wesnothd_program, "-c", config);
826 #else
827  boost::process::child c(wesnothd_program, "-c", config, boost::process::windows::create_no_window);
828 #endif
829 #endif
830  c.detach();
831  // Give server a moment to start up
832  using namespace std::chrono_literals;
833  std::this_thread::sleep_for(50ms);
834  return;
835  }
836 #if defined(__APPLE__) || BOOST_VERSION < 108600
837  catch(const boost::process::process_error& e)
838 #else
839  catch(const std::exception& e)
840 #endif
841  {
843 
844  // Couldn't start server so throw error
845  WRN_GENERAL << "Failed to start server " << wesnothd_program << ":\n" << e.what();
846  throw game::mp_server_error("Starting MP server failed!");
847  }
848 }
849 
851 {
853  try {
854  if(mode == mp_mode::HOST) {
855  try {
856  start_wesnothd();
857  } catch(const game::mp_server_error&) {
859 
860  try {
861  start_wesnothd();
862  } catch(const game::mp_server_error&) {
863  return false;
864  }
865  }
866  }
867 
868  // If a server address wasn't specified, prompt for it now.
869  if(mode != mp_mode::LOCAL && multiplayer_server_.empty()) {
870  if(!gui2::dialogs::mp_connect::execute()) {
871  return false;
872  }
873 
874  // The prompt saves its input to preferences.
876 
877  if(multiplayer_server_ != prefs::get().builtin_servers_list().front().address) {
879  }
880  }
881 
882  // create_engine already calls game_config_manager::get()->load_config but maybe its better to have MULTIPLAYER
883  // defined while we are in the lobby.
885 
886  events::discard_input(); // prevent the "keylogger" effect
888 
889  if(mode == mp_mode::LOCAL) {
891  } else {
893  multiplayer_server_.clear();
894  }
895 
896  } catch(const wesnothd_rejected_client_error& e) {
897  gui2::show_error_message(e.message);
898  } catch(const game::mp_server_error& e) {
899  gui2::show_error_message(_("Error while starting server: ") + e.message);
900  } catch(const game::load_game_failed& e) {
901  gui2::show_error_message(_("The game could not be loaded: ") + e.message);
902  } catch(const game::game_error& e) {
903  gui2::show_error_message(_("Error while playing the game: ") + e.message);
904  } catch(const mapgen_exception& e) {
905  gui2::show_error_message(_("Map generator error: ") + e.message);
906  } catch(const wesnothd_error& e) {
907  if(!e.message.empty()) {
908  ERR_NET << "caught network error: " << e.message;
909 
910  std::string user_msg;
911  auto conn_err = dynamic_cast<const wesnothd_connection_error*>(&e);
912 
913  if(conn_err) {
914  // The wesnothd_connection_error subclass is only thrown with messages
915  // from boost::system::error_code which we can't translate ourselves.
916  // It's also the originator of the infamous EOF error that happens when
917  // the server dies. <https://github.com/wesnoth/wesnoth/issues/3005>. It
918  // will provide a translated string instead of that when it happens.
919  user_msg = !conn_err->user_message.empty()
920  ? conn_err->user_message
921  : _("Connection failed: ") + e.message;
922  } else {
923  // This will be a message from the server itself, which we can
924  // probably translate.
925  user_msg = translation::gettext(e.message.c_str());
926  }
927 
928  gui2::show_error_message(user_msg);
929  } else {
930  ERR_NET << "caught network error";
931  }
932  } catch(const config::error& e) {
933  if(!e.message.empty()) {
934  ERR_CONFIG << "caught config::error: " << e.message;
935  gui2::show_transient_message("", e.message);
936  } else {
937  ERR_CONFIG << "caught config::error";
938  }
939  } catch(const incorrect_map_format_error& e) {
940  gui2::show_error_message(_("The game map could not be loaded: ") + e.message);
941  } catch(savegame::load_game_exception& e) {
942  load_data_ = std::move(e.data_);
943  // this will make it so next time through the title screen loop, this game is loaded
944  } catch(const wml_exception& e) {
945  e.show();
946  } catch(const game::error& e) {
947  PLAIN_LOG << "caught game::error...";
948  gui2::show_error_message(_("Error: ") + e.message);
949  }
950 
951  return true;
952 }
953 
955 {
957  return true;
958  }
959 
960  DBG_MP << "starting multiplayer game from the commandline";
961 
963 
964  events::discard_input(); // prevent the "keylogger" effect
966 
967  try {
969  } catch(savegame::load_game_exception& e) {
970  load_data_ = std::move(e.data_);
971  return true;
972  }
973 
974  return false;
975 }
976 
978 {
979  if(!gui2::dialogs::language_selection::execute()) {
980  return false;
981  }
982 
985  }
986 
991 
992  return true;
993 }
994 
996 {
997  assert(!load_data_);
998  if(play_replay_) {
999  play_replay();
1000  return;
1001  }
1002 
1003  gui2::dialogs::loading_screen::display([this, reload]() {
1005 
1006  if(reload == reload_mode::RELOAD_DATA) {
1007  try {
1010  } catch(const config::error&) {
1011  return;
1012  }
1013  }
1014  });
1015 
1016  try {
1017  campaign_controller ccontroller(state_);
1018  ccontroller.play_game();
1019  ai::manager::singleton_ = nullptr;
1020  } catch(savegame::load_game_exception& e) {
1021  load_data_ = std::move(e.data_);
1022  // this will make it so next time through the title screen loop, this game is loaded
1023  } catch(const wml_exception& e) {
1024  e.show();
1025  } catch(const mapgen_exception& e) {
1026  gui2::show_error_message(_("Map generator error: ") + e.message);
1027  }
1028 }
1029 
1031 {
1032  assert(!load_data_);
1033  try {
1034  campaign_controller ccontroller(state_);
1035  ccontroller.play_replay();
1036  } catch(savegame::load_game_exception& e) {
1037  load_data_ = std::move(e.data_);
1038  // this will make it so next time through the title screen loop, this game is loaded
1039  } catch(const wml_exception& e) {
1040  e.show();
1041  }
1042 }
1043 
1045 {
1047  while(true) {
1049 
1051 
1053 
1054  if(res != editor::EXIT_RELOAD_DATA) {
1055  return res;
1056  }
1057 
1059  }
1060 
1061  return editor::EXIT_ERROR; // not supposed to happen
1062 }
1063 
1065 {
1066  load_data_.reset();
1067 }
1068 
1070 {
1071  try {
1073  video::deinit();
1074  } catch(std::exception& e) {
1075  ERR_GENERAL << "Suppressing exception thrown during ~game_launcher: " << e.what();
1076  } catch(...) {
1077  ERR_GENERAL << "Suppressing exception " << utils::get_unknown_exception_type() << " thrown during ~game_launcher";
1078  }
1079 }
Managing the AIs lifecycle - headers TODO: Refactor history handling and internal commands.
static manager * singleton_
Definition: manager.hpp:422
level_result::type play_game()
level_result::type play_replay()
bool nogui
True if –nogui was given on the command line.
utils::optional< std::pair< int, int > > resolution
Pair of AxB values specified after –resolution.
bool headless_unit_test
True if –unit is used and –showgui is not present.
utils::optional< std::string > screenshot_map_file
Map file to make a screenshot of.
utils::optional< std::string > test
Non-empty if –test was given on the command line.
bool windowed
True if –windowed was given on the command line.
utils::optional< std::string > language
Non-empty if –language was given on the command line.
bool noreplaycheck
True if –noreplaycheck was given on the command line.
utils::optional< std::string > screenshot_output_file
Output file to put screenshot in.
utils::optional< int > max_fps
Max FPS specified by –max-fps option.
utils::optional< std::string > core_id
Non-empty if –core was given on the command line.
utils::optional< int > campaign_difficulty
Non-empty if –campaign-difficulty was given on the command line.
bool debug
True if –debug was given on the command line.
bool nosound
True if –nosound was given on the command line.
bool multiplayer
True if –multiplayer was given on the command line.
utils::optional< std::string > server
Non-empty if –server was given on the command line.
bool script_unsafe_mode
Whether to load the "package" package for the scripting environment.
utils::optional< unsigned int > translation_percent
Non-empty if –all-translations or –translations-over is given on the command line.
utils::optional< std::string > plugin_file
File to load a lua plugin script from.
bool nobanner
True if –nobanner was given on the command line.
bool nomusic
True if –nomusic was given on the command line.
bool clock
True if –clock was given on the command line.
utils::optional< std::string > render_image_dst
Output file to put rendered image path in.
utils::optional< std::string > render_image
Image path to render.
utils::optional< std::string > campaign
Non-empty if –campaign was given on the command line.
bool new_widgets
True if –new-widgets was given on the command line.
bool fps
True if –fps was given on the command line.
utils::optional< std::string > username
Non-empty if –username was given on the command line.
bool campaign_skip_story
True if –skip-story was given on the command line.
bool with_replay
True if –with-replay was given on the command line.
bool screenshot
True if –screenshot was given on the command line.
std::vector< std::string > unit_test
Non-empty if –unit was given on the command line.
utils::optional< std::string > editor
Non-empty if –editor was given on the command line.
utils::optional< std::string > password
Non-empty if –password was given on the command line.
bool fullscreen
True if –fullscreen was given on the command line.
utils::optional< std::string > campaign_scenario
Non-empty if –campaign-scenario was given on the command line.
utils::optional< std::string > load
Non-empty if –load was given on the command line.
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:158
campaign_type::type type
std::string label
Name of the game (e.g.
std::string campaign_define
If there is a define the campaign uses to customize data.
static game_config_manager * get()
void load_game_config_for_game(const game_classification &classification, const std::string &scenario_id)
void load_game_config_for_create(bool is_mp, bool is_test=false)
game_launcher(const commandline_options &cmdline_opts)
bool load_prepared_game()
utils::optional< std::string > jump_to_editor_
unit_test_result single_unit_test()
Internal to the implementation of unit_test().
std::string multiplayer_server_
std::string jump_to_campaign_id() const
Return the ID of the campaign to jump to (skipping the main menu).
bool play_screenshot_mode()
jump_to_campaign_info jump_to_campaign_
std::string screenshot_filename_
void launch_game(reload_mode reload=reload_mode::RELOAD_DATA)
bool goto_multiplayer()
bool change_language()
saved_game state_
savegame::load_game_metadata extract_load_data()
Returns the load_game_metadata object stored in load_data_.
bool load_game_prompt()
unit_test_result pass_victory_or_defeat(level_result::type res)
bool has_load_data() const
bool play_render_image_mode()
void clear_loaded_game()
bool init_lua_script()
std::vector< std::string > test_scenarios_
unit_test_result
Status code after running a unit test, should match the run_wml_tests script and the documentation fo...
std::string screenshot_map_
const commandline_options & cmdline_opts_
utils::optional< savegame::load_game_metadata > load_data_
void set_test(const std::string &id)
bool play_multiplayer_commandline()
unit_test_result unit_test()
Runs unit tests specified on the command line.
bool play_multiplayer(mp_mode mode)
editor::EXIT_STATUS start_editor()
static void progress(loading_stage stage=loading_stage::none)
Report what is being loaded to the loading screen.
static void display(const std::function< void()> &f)
Generic locator abstracting the location of an image.
Definition: picture.hpp:59
void load_package()
Loads the package library into lua environment.
void play_slice()
Definition: context.cpp:103
std::size_t size()
Definition: manager.cpp:68
std::string get_name(std::size_t idx)
Definition: manager.cpp:94
static plugins_manager * get()
Definition: manager.cpp:58
void start_plugin(std::size_t idx)
Definition: manager.cpp:101
std::string get_detailed_status(std::size_t idx)
Definition: manager.cpp:83
lua_kernel_base * get_kernel_base()
Definition: manager.cpp:63
std::size_t add_plugin(const std::string &name, const std::string &prog)
Definition: manager.cpp:118
void set_network_host(const std::string &host)
bool set_music(bool ison)
std::string network_host()
bool set_ui_sound(bool ison)
void set_login(const std::string &login)
static prefs & get()
void show_wesnothd_server_search()
void set_password(const std::string &server, const std::string &login, const std::string &key)
bool set_turn_bell(bool ison)
void set_show_fps(bool value)
bool set_sound(bool ison)
void set_resolution(const point &res)
static void disable_preferences_save()
std::string get_mp_server_program_name()
void set_mp_server_program_name(const std::string &)
game_classification & classification()
Definition: saved_game.hpp:55
void set_skip_story(bool skip_story)
Definition: saved_game.hpp:146
bool is_start_of_scenario() const
Definition: saved_game.hpp:109
void set_carryover_sides_start(config carryover_sides_start)
Definition: saved_game.cpp:165
std::string get_scenario_id() const
Definition: saved_game.cpp:698
void clear()
Definition: saved_game.cpp:832
statistics_record::campaign_stats_t & statistics()
Definition: saved_game.hpp:142
void cancel_orders()
Definition: saved_game.cpp:735
Exception used to signal that the user has decided to abort a game, and to load another game instead.
Definition: savegame.hpp:88
Class for replay saves (either manually or automatically).
Definition: savegame.hpp:244
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:202
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:295
const std::string & filename() const
Definition: savegame.hpp:154
static void reset_translations()
Definition: tstring.cpp:665
Definitions for the interface to Wesnoth Markup Language (WML).
Declarations for File-IO.
std::size_t i
Definition: function.cpp:1032
#define ERR_GENERAL
#define DBG_GENERAL
static lg::log_domain log_enginerefac("enginerefac")
#define DBG_MP
static lg::log_domain log_network("network")
static lg::log_domain log_mp_create("mp/create")
#define ERR_CONFIG
#define WRN_GENERAL
#define ERR_NET
#define LOG_GENERAL
static lg::log_domain log_config("config")
static std::string _(const char *str)
Definition: gettext.hpp:97
const language_def & get_locale()
Definition: language.cpp:329
std::vector< language_def > get_languages(bool all)
Return a list of available translations.
Definition: language.cpp:130
void init_textdomains(const game_config_view &cfg)
Initializes the list of textdomains from a configuration object.
Definition: language.cpp:367
bool load_language_list()
Definition: language.cpp:111
void set_min_translation_percent(int percent)
Definition: language.cpp:152
Standard logging facilities (interface).
#define STREAMING_LOG
Definition: log.hpp:297
#define PLAIN_LOG
Definition: log.hpp:296
@ NORMAL
Definition: cursor.hpp:28
void set(CURSOR_TYPE type)
Use the default parameter to reset cursors.
Definition: cursor.cpp:178
void point(int x, int y)
Draw a single point.
Definition: draw.cpp:214
@ EXIT_ERROR
Definition: editor_main.hpp:27
@ EXIT_NORMAL
Definition: editor_main.hpp:24
@ EXIT_QUIT_TO_DESKTOP
Definition: editor_main.hpp:25
@ EXIT_RELOAD_DATA
Definition: editor_main.hpp:26
EXIT_STATUS start(bool clear_id, const std::string &filename, bool take_screenshot, const std::string &screenshot_filename)
Main interface for launching the editor from the title screen.
void discard_input()
Discards all input events.
Definition: events.cpp:763
std::string get_cache_dir()
Definition: filesystem.cpp:882
filesystem::scoped_istream istream_file(const std::string &fname, bool treat_failure_as_error)
std::string get_user_data_dir()
Definition: filesystem.cpp:872
static bool file_exists(const bfs::path &fpath)
Definition: filesystem.cpp:341
utils::optional< std::string > get_wml_location(const std::string &path, const utils::optional< std::string > &current_dir)
Returns a translated path to the actual file or directory, if it exists.
std::string read_file(const std::string &fname)
Basic disk I/O - read file.
std::unique_ptr< std::istream > scoped_istream
Definition: filesystem.hpp:53
void write_file(const std::string &fname, const std::string &data, std::ios_base::openmode mode)
Throws io_exception if an error occurs.
std::string get_wesnothd_name()
std::string normalize_path(const std::string &fpath, bool normalize_separators, bool resolve_dot_entries)
Returns the absolute path of a file.
bool load_font_config()
Definition: font_config.cpp:78
std::string turn_bell
Game configuration data as global variables.
Definition: build_info.cpp:61
std::string path
Definition: filesystem.cpp:106
std::string get_default_title_string()
std::vector< server_info > server_list
Definition: game_config.cpp:76
void set_debug(bool new_debug)
Definition: game_config.cpp:97
bool show_debug_clock_button
Do we wish to show the button for the debug clock.
static bool sound()
static bool ui_sound_on()
static bool music_on()
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.
bool new_widgets
Do we wish to use the new library or not.
Definition: settings.cpp:23
void show_error_message(const std::string &msg, bool message_use_markup)
Shows an error message to the user.
Definition: message.cpp:201
void flush_cache()
Purges all image caches.
Definition: picture.cpp:210
surface get_surface(const image::locator &i_locator, TYPE type, bool skip_cache)
Returns an image surface suitable for software manipulation.
Definition: picture.cpp:679
save_result save_image(const locator &i_locator, const std::string &filename)
Definition: picture.cpp:906
@ UNSCALED
Unmodified original-size image.
Definition: picture.hpp:173
bool broke_strict()
Definition: log.cpp:430
void start_local_game()
Starts a multiplayer game in single-user mode.
void start_local_game_commandline(const commandline_options &cmdline_opts)
Starts a multiplayer game in single-user mode using command line settings.
void start_client(const std::string &host)
Pubic entry points for the MP workflow.
void clean_saves(const std::string &label)
Delete all autosaves of a certain scenario from the default save directory.
Definition: savegame.cpp:64
void set_gamestate(saved_game &gamestate, load_game_metadata &load_data)
Definition: savegame.cpp:278
utils::optional< load_game_metadata > load_interactive()
Definition: savegame.cpp:153
bool init_sound()
Definition: sound.cpp:440
void close_sound()
Definition: sound.cpp:492
void flush_cache()
Definition: sound.cpp:192
bool select_campaign(saved_game &state, jump_to_campaign_info jump_to_campaign)
void process(int mousex, int mousey)
Definition: tooltips.cpp:334
void set_language(const std::string &language, const std::vector< std::string > *)
Definition: gettext.cpp:494
static std::string gettext(const char *str)
Definition: gettext.hpp:62
std::size_t size(std::string_view str)
Length in characters of a UTF-8 string.
Definition: unicode.cpp:85
std::string get_unknown_exception_type()
Utility function for finding the type of thing caught with catch(...).
Definition: general.cpp:23
void set_window_title(const std::string &title)
Sets the title of the main window.
Definition: video.cpp:671
void set_window_icon(surface &icon)
Sets the icon of the main window.
Definition: video.cpp:677
void init(fake type)
Initialize the video subsystem.
Definition: video.cpp:90
void deinit()
Deinitialize the video subsystem.
Definition: video.cpp:119
This file contains the settings handling of the widget library.
std::string filename
Filename.
An exception object used when an IO error occurs.
Definition: filesystem.hpp:67
Base class for all the errors encountered by the engine.
Definition: exceptions.hpp:29
Error used for any general game error, e.g.
Definition: game_errors.hpp:47
Error used when game loading fails.
Definition: game_errors.hpp:31
std::string campaign_id
The ID of the campaign to launch.
bool jump
Whether the game should immediately start a campaign.
std::string scenario_id
The ID of the scenario within the campaign to jump to.
bool skip_story
Whether the story screen should be skipped.
int difficulty
The difficulty at which to launch the campaign.
std::string localename
Definition: language.hpp:32
void clear_current_scenario()
Delete the current scenario from the stats.
static std::string get_string(enum_type key)
Converts a enum to its string equivalent.
Definition: enum_base.hpp:46
An error occurred inside the underlying network communication code (boost asio) TODO: find a short na...
std::string user_message
User-friendly and potentially translated message for use in the UI.
An error occurred during when trying to communicate with the wesnothd server.
Error used when the client is rejected by the MP server.
Helper class, don't construct this directly.
mock_char c
Add a special kind of assert to validate whether the input from WML doesn't contain any problems that...
#define e