The Battle for Wesnoth  1.19.14+dev
wesnoth.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 "addon/manager.hpp"
17 #include "build_info.hpp"
18 #include "commandline_argv.hpp"
19 #include "commandline_options.hpp" // for commandline_options, etc
20 #include "config.hpp" // for config, config::error, etc
21 #include "cursor.hpp" // for set, CURSOR_TYPE::NORMAL, etc
22 #include "events.hpp"
23 #include "filesystem.hpp" // for filesystem::file_exists, filesystem::io_exception, etc
24 #include "floating_label.hpp"
25 #include "font/error.hpp" // for error
26 #include "font/font_config.hpp" // for load_font_config, etc
27 #include "formula/formula.hpp" // for formula_error
28 #include "game_config.hpp" // for path, debug, debug_lua, etc
29 #include "game_config_manager.hpp" // for game_config_manager, etc
30 #include "game_end_exceptions.hpp"
31 #include "game_launcher.hpp" // for game_launcher, etc
32 #include "gettext.hpp"
33 #include "gui/core/event/handler.hpp" // for tmanager
35 #include "gui/dialogs/message.hpp" // for show_error_message
37 #include "gui/dialogs/title_screen.hpp" // for title_screen, etc
38 #include "gui/gui.hpp" // for init
39 #include "log.hpp" // for LOG_STREAM, general, logger, etc
44 #include "sdl/exception.hpp" // for exception
45 #include "serialization/binary_or_text.hpp" // for config_writer
46 #include "serialization/chrono.hpp"
47 #include "serialization/parser.hpp" // for read
48 #include "serialization/preprocessor.hpp" // for preproc_define, etc
49 #include "serialization/schema_validator.hpp" // for strict_validation_enabled and schema_validator
50 #include "sound.hpp" // for commit_music_changes, etc
51 #include "utils/optimer.hpp"
52 #include "formula/string_utils.hpp" // VGETTEXT
53 #include <functional>
54 #include "game_version.hpp" // for version_info
55 #include "video.hpp" // for video::error and video::quit
56 #include "wesconfig.h" // for PACKAGE
57 #include "wml_exception.hpp" // for wml_exception
58 
60 #ifdef _WIN32
61 #include "log_windows.hpp"
62 
63 #include <float.h>
64 #endif // _WIN32
65 
66 #ifndef _MSC_VER
67 #include <fenv.h>
68 #endif // _MSC_VER
69 
70 #include <SDL2/SDL.h> // for SDL_Init, SDL_INIT_TIMER
71 
72 #include <boost/program_options/errors.hpp> // for error
73 #include <boost/algorithm/string/predicate.hpp> // for checking cmdline options
74 #include "utils/optional_fwd.hpp"
75 
76 #include <cerrno> // for ENOMEM
77 #include <clocale> // for setlocale, LC_ALL, etc
78 #include <cstdio> // for remove, fprintf, stderr
79 #include <cstdlib> // for srand, exit
80 #include <exception> // for exception
81 #include <vector>
82 #include <iostream>
83 
84 //#define NO_CATCH_AT_GAME_END
85 
86 #ifdef _WIN32
87 
88 #ifdef INADDR_ANY
89 #undef INADDR_ANY
90 #endif
91 
92 #ifdef INADDR_BROADCAST
93 #undef INADDR_BROADCAST
94 #endif
95 
96 #ifdef INADDR_NONE
97 #undef INADDR_NONE
98 #endif
99 
100 #include <windows.h>
101 
102 #endif // _WIN32
103 
104 #ifdef __ANDROID__
105 #define main SDL_main
106 #endif
107 
108 #ifdef DEBUG_WINDOW_LAYOUT_GRAPHS
109 #include "gui/widgets/debug.hpp"
110 #endif
111 
112 // this file acts as a launcher for various gui2 dialogs
113 // so this reduces some boilerplate.
114 using namespace gui2::dialogs;
115 
116 static lg::log_domain log_config("config");
117 #define LOG_CONFIG LOG_STREAM(info, log_config)
118 
119 #define LOG_GENERAL LOG_STREAM(info, lg::general())
120 
121 static lg::log_domain log_preprocessor("preprocessor");
122 #define LOG_PREPROC LOG_STREAM(info, log_preprocessor)
123 
124 // this is needed to allow identical functionality with clean refactoring
125 // play_game only returns on an error, all returns within play_game can
126 // be replaced with this
127 static void safe_exit(int res)
128 {
129  LOG_GENERAL << "exiting with code " << res;
130  exit(res);
131 }
132 
133 static void handle_preprocess_string(const commandline_options& cmdline_opts)
134 {
135  preproc_map defines_map;
136 
137  if(cmdline_opts.preprocess_input_macros) {
138  std::string file = *cmdline_opts.preprocess_input_macros;
139  if(!filesystem::file_exists(file)) {
140  PLAIN_LOG << "please specify an existing file. File " << file << " doesn't exist.";
141  return;
142  }
143 
144  PLAIN_LOG << "Reading cached defines from: " << file;
145 
146  config cfg;
147 
148  try {
150  } catch(const config::error& e) {
151  PLAIN_LOG << "Caught a config error while parsing file '" << file << "':\n" << e.message;
152  }
153 
154  int read = 0;
155 
156  for(const auto [_, cfg] : cfg.all_children_view()) {
157  preproc_define::insert(defines_map, cfg);
158  ++read;
159  }
160 
161  PLAIN_LOG << "Read " << read << " defines.";
162  }
163 
164  if(cmdline_opts.preprocess_defines) {
165  // add the specified defines
166  for(const std::string& define : *cmdline_opts.preprocess_defines) {
167  if(define.empty()) {
168  PLAIN_LOG << "empty define supplied";
169  continue;
170  }
171 
172  LOG_PREPROC << "adding define: " << define;
173  defines_map.try_emplace(define, define);
174  }
175  }
176 
177  // add the WESNOTH_VERSION define
178  defines_map.try_emplace("WESNOTH_VERSION", game_config::wesnoth_version.str());
179 
180  // preprocess resource
181  PLAIN_LOG << "preprocessing specified string: " << *cmdline_opts.preprocess_source_string;
182  const utils::ms_optimer timer(
183  [](const auto& timer) { PLAIN_LOG << "preprocessing finished. Took " << timer << " ticks."; });
184  std::cout << preprocess_string(*cmdline_opts.preprocess_source_string, &defines_map) << std::endl;
185  PLAIN_LOG << "added " << defines_map.size() << " defines.";
186 }
187 
188 static void handle_preprocess_command(const commandline_options& cmdline_opts)
189 {
190  preproc_map input_macros;
191 
192  if(cmdline_opts.preprocess_input_macros) {
193  std::string file = *cmdline_opts.preprocess_input_macros;
194  if(filesystem::file_exists(file) == false) {
195  PLAIN_LOG << "please specify an existing file. File " << file << " doesn't exist.";
196  return;
197  }
198 
199  PLAIN_LOG << "Reading cached defines from: " << file;
200 
201  config cfg;
202 
203  try {
205  } catch(const config::error& e) {
206  PLAIN_LOG << "Caught a config error while parsing file '" << file << "':\n" << e.message;
207  }
208 
209  int read = 0;
210 
211  for(const auto [_, cfg] : cfg.all_children_view()) {
212  preproc_define::insert(input_macros, cfg);
213  ++read;
214  }
215 
216  PLAIN_LOG << "Read " << read << " defines.";
217  }
218 
219  const std::string resourceToProcess(*cmdline_opts.preprocess_path);
220  const std::string targetDir(*cmdline_opts.preprocess_target);
221 
222  const utils::ms_optimer timer(
223  [](const auto& timer) { PLAIN_LOG << "preprocessing finished. Took " << timer << " ticks."; });
224 
225  // If the users add the SKIP_CORE define we won't preprocess data/core
226  bool skipCore = false;
227  bool skipTerrainGFX = false;
228 
229  // The 'core_defines_map' is the one got from data/core macros
230  preproc_map defines_map(input_macros);
231 
232  if(cmdline_opts.preprocess_defines) {
233  // add the specified defines
234  for(const std::string& define : *cmdline_opts.preprocess_defines) {
235  if(define.empty()) {
236  PLAIN_LOG << "empty define supplied";
237  continue;
238  }
239 
240  LOG_PREPROC << "adding define: " << define;
241  defines_map.try_emplace(define, define);
242 
243  if(define == "SKIP_CORE") {
244  PLAIN_LOG << "'SKIP_CORE' defined.";
245  skipCore = true;
246  } else if(define == "NO_TERRAIN_GFX") {
247  PLAIN_LOG << "'NO_TERRAIN_GFX' defined.";
248  skipTerrainGFX = true;
249  }
250  }
251  }
252 
253  // add the WESNOTH_VERSION define
254  defines_map.try_emplace("WESNOTH_VERSION", game_config::wesnoth_version.str());
255 
256  PLAIN_LOG << "added " << defines_map.size() << " defines.";
257 
258  // preprocess core macros first if we don't skip the core
259  if(skipCore == false) {
260  PLAIN_LOG << "preprocessing common macros from 'data/core' ...";
261 
262  // process each folder explicitly to gain speed
263  preprocess_resource(game_config::path + "/data/core/macros", &defines_map);
264 
265  if(skipTerrainGFX == false) {
266  preprocess_resource(game_config::path + "/data/core/terrain-graphics", &defines_map);
267  }
268 
269  PLAIN_LOG << "acquired " << (defines_map.size() - input_macros.size()) << " 'data/core' defines.";
270  } else {
271  PLAIN_LOG << "skipped 'data/core'";
272  }
273 
274  // preprocess resource
275  PLAIN_LOG << "preprocessing specified resource: " << resourceToProcess << " ...";
276 
277  preprocess_resource(resourceToProcess, &defines_map, true, true, targetDir);
278  PLAIN_LOG << "acquired " << (defines_map.size() - input_macros.size()) << " total defines.";
279 
280  if(cmdline_opts.preprocess_output_macros) {
281  std::string outputFileName = "_MACROS_.cfg";
282  if(!cmdline_opts.preprocess_output_macros->empty()) {
283  outputFileName = *cmdline_opts.preprocess_output_macros;
284  }
285 
286  std::string outputPath = targetDir + "/" + outputFileName;
287 
288  PLAIN_LOG << "writing '" << outputPath << "' with " << defines_map.size() << " defines.";
289 
291  if(!out->fail()) {
292  config_writer writer(*out, false);
293 
294  for(auto& define_pair : defines_map) {
295  define_pair.second.write(writer, define_pair.first);
296  }
297  } else {
298  PLAIN_LOG << "couldn't open the file.";
299  }
300  }
301 }
302 
303 static int handle_validate_command(const std::string& file, abstract_validator& validator, const std::vector<std::string>& defines)
304 {
305  preproc_map defines_map;
306  defines_map.try_emplace("WESNOTH_VERSION", game_config::wesnoth_version.str());
307  defines_map.try_emplace("SCHEMA_VALIDATION");
308 
309  for(const std::string& define : defines) {
310  if(define.empty()) {
311  PLAIN_LOG << "empty define supplied";
312  continue;
313  }
314 
315  LOG_PREPROC << "adding define: " << define;
316  defines_map.try_emplace(define, define);
317  }
318 
319  PLAIN_LOG << "Validating " << file << " against schema " << validator.name_;
321  io::read(*preprocess_file(file, &defines_map), &validator);
322  if(lg::broke_strict()) {
323  std::cout << "validation failed\n";
324  } else {
325  std::cout << "validation succeeded\n";
326  }
327  return lg::broke_strict();
328 }
329 
330 /** Process commandline-arguments */
331 static int process_command_args(commandline_options& cmdline_opts)
332 {
333  // Options that output info unaffected by other options and return.
334  if(cmdline_opts.help) {
335  std::cout << cmdline_opts;
336  return 0;
337  }
338 
339  if(cmdline_opts.logdomains) {
340  std::cout << lg::list_log_domains(*cmdline_opts.logdomains);
341  return 0;
342  }
343 
344  if(cmdline_opts.version) {
345  std::cout << "Battle for Wesnoth" << " " << game_config::wesnoth_version.str() << "\n\n";
346  std::cout << "Library versions:\n" << game_config::library_versions_report() << '\n';
347  std::cout << "Optional features:\n" << game_config::optional_features_report();
348  return 0;
349  }
350 
351  if(cmdline_opts.simple_version) {
352  std::cout << game_config::wesnoth_version.str() << "\n";
353  return 0;
354  }
355 
356  // Options that don't change behavior based on any others should be checked alphabetically below.
357 
358  if(cmdline_opts.no_log_sanitize) {
359  lg::set_log_sanitize(false);
360  }
361 
362  if(cmdline_opts.usercache_dir) {
364  }
365 
366  if(cmdline_opts.userdata_dir) {
368  }
369 
370  // earliest possible point to ensure the userdata directory is known
372  filesystem::set_user_data_dir(std::string());
373  }
374 
375  // userdata is initialized, so initialize logging to file if enabled
376  // If true, output will be redirected to file, else output be written to console.
377  // On Windows, if Wesnoth was not started from a console, one will be allocated.
378  if(cmdline_opts.log_to_file
379  || (!cmdline_opts.no_log_to_file
380  && !getenv("WESNOTH_NO_LOG_FILE")
381  // command line options that imply not redirecting output to a log file
382  && !cmdline_opts.data_path
383  && !cmdline_opts.userdata_path
384  && !cmdline_opts.usercache_path
385  && !cmdline_opts.report
386  && !cmdline_opts.do_diff
387  && !cmdline_opts.do_patch
388  && !cmdline_opts.preprocess
389  && !cmdline_opts.render_image
390  && !cmdline_opts.screenshot
391  && !cmdline_opts.nogui
392  && !cmdline_opts.headless_unit_test
393  && !cmdline_opts.validate_schema
394  && !cmdline_opts.validate_wml
395  )
396  )
397  {
399  }
400 #ifdef _WIN32
401  // This forces a Windows console to be attached to the process even
402  // if Wesnoth is an IMAGE_SUBSYSTEM_WINDOWS_GUI executable because it
403  // turns Wesnoth into a CLI application. (unless --wnoconsole is given)
404  else if(!cmdline_opts.no_console) {
406  }
407 #endif
408 
409  if(cmdline_opts.log) {
410  for(const auto& log_pair : *cmdline_opts.log) {
411  const std::string log_domain = log_pair.second;
412  const lg::severity severity = log_pair.first;
413  if(!lg::set_log_domain_severity(log_domain, severity)) {
414  PLAIN_LOG << "unknown log domain: " << log_domain;
415  return 2;
416  }
417  }
418  }
419 
420  if(!cmdline_opts.nobanner) {
421  const auto now = std::chrono::system_clock::now();
422  PLAIN_LOG << "Battle for Wesnoth v" << game_config::revision << " " << game_config::build_arch();
423  PLAIN_LOG << "Started on " << chrono::format_local_timestamp(now, "%a %b %d %T %Y") << '\n';
424  }
425 
426  if(cmdline_opts.usercache_path) {
427  std::cout << filesystem::get_cache_dir();
428  return 0;
429  }
430 
431  if(cmdline_opts.userdata_path) {
432  std::cout << filesystem::get_user_data_dir();
433  return 0;
434  }
435 
436  if(cmdline_opts.data_dir) {
437  game_config::path = filesystem::normalize_path(*cmdline_opts.data_dir, true, true);
438  if(!cmdline_opts.nobanner) {
439  PLAIN_LOG << "Overriding data directory with '" << game_config::path << "'";
440  }
441  } else {
442  // if a pre-defined path does not exist this will empty it
443 #ifdef __ANDROID__
444  game_config::path = SDL_AndroidGetExternalStoragePath() + std::string("/gamedata");
445 #endif
447  if(game_config::path.empty()) {
448  if(std::string exe_dir = filesystem::get_exe_dir(); !exe_dir.empty()) {
449  if(std::string auto_dir = filesystem::autodetect_game_data_dir(std::move(exe_dir)); !auto_dir.empty()) {
450  if(!cmdline_opts.nobanner) {
451  PLAIN_LOG << "Automatically found a possible data directory at: " << auto_dir;
452  }
453  game_config::path = filesystem::normalize_path(auto_dir, true, true);
454  }
455  } else {
456  PLAIN_LOG << "Cannot find game data directory. Specify one with --data-dir";
457  return 1;
458  }
459  }
460  }
461 
463  PLAIN_LOG << "Could not find game data directory '" << game_config::path << "'";
464  return 1;
465  }
466 
467  if(cmdline_opts.data_path) {
468  std::cout << game_config::path;
469  return 0;
470  }
471 
472  if(cmdline_opts.debug_lua) {
473  game_config::debug_lua = true;
474  }
475 
476  if(cmdline_opts.allow_insecure) {
478  }
479 
480  if(cmdline_opts.addon_server_info) {
482  }
483 
484  if(cmdline_opts.strict_lua) {
486  }
487 
488  if(cmdline_opts.log_precise_timestamps) {
490  }
491 
492  if(cmdline_opts.rng_seed) {
493  srand(*cmdline_opts.rng_seed);
494  }
495 
496  if(cmdline_opts.render_image) {
497  SDL_setenv("SDL_VIDEODRIVER", "dummy", 1);
498  }
499 
500  if(cmdline_opts.strict_validation) {
502  }
503 
504  if(cmdline_opts.report) {
505  std::cout << "\n========= BUILD INFORMATION =========\n\n" << game_config::full_build_report();
506  return 0;
507  }
508 
509  if(cmdline_opts.validate_schema) {
511  validator.set_create_exceptions(false); // Don't crash if there's an error, just go ahead anyway
512  return handle_validate_command(*cmdline_opts.validate_schema, validator, {});
513  }
514 
515  if(cmdline_opts.do_diff) {
516  std::ifstream in_left(cmdline_opts.diff_left);
517  std::ifstream in_right(cmdline_opts.diff_right);
518  config left = io::read(in_left);
519  config right = io::read(in_right);
520  std::ostream* os = &std::cout;
521  if(cmdline_opts.output_file) {
522  os = new std::ofstream(*cmdline_opts.output_file);
523  }
525  out.write(right.get_diff(left));
526  if(os != &std::cout) delete os;
527  return 0;
528  }
529 
530  if(cmdline_opts.do_patch) {
531  std::ifstream in_base(cmdline_opts.diff_left);
532  std::ifstream in_diff(cmdline_opts.diff_right);
533  config base = io::read(in_base);
534  config diff = io::read(in_diff);
535  base.apply_diff(diff);
536  std::ostream* os = &std::cout;
537  if(cmdline_opts.output_file) {
538  os = new std::ofstream(*cmdline_opts.output_file);
539  }
541  out.write(base);
542  if(os != &std::cout) delete os;
543  return 0;
544  }
545 
546  if(cmdline_opts.generate_spritesheet) {
547  PLAIN_LOG << "sheet path " << *cmdline_opts.generate_spritesheet;
549  return 0;
550  }
551 
552  // Options changing their behavior dependent on some others should be checked below.
553 
554  if(cmdline_opts.preprocess) {
555  handle_preprocess_command(cmdline_opts);
556  return 0;
557  }
558 
559  if(cmdline_opts.preprocess_source_string.has_value()) {
560  handle_preprocess_string(cmdline_opts);
561  return 0;
562  }
563 
564  if(cmdline_opts.validate_wml) {
565  std::string schema_path;
566  if(cmdline_opts.validate_with) {
567  schema_path = *cmdline_opts.validate_with;
568  if(!filesystem::file_exists(schema_path)) {
569  if(auto check = filesystem::get_wml_location(schema_path)) {
570  schema_path = check.value();
571  } else {
572  PLAIN_LOG << "Could not find schema file: " << schema_path;
573  }
574  } else {
575  schema_path = filesystem::normalize_path(schema_path);
576  }
577  } else {
578  schema_path = filesystem::get_wml_location("schema/game_config.cfg").value();
579  }
581  validator.set_create_exceptions(false); // Don't crash if there's an error, just go ahead anyway
582  return handle_validate_command(*cmdline_opts.validate_wml, validator,
583  cmdline_opts.preprocess_defines.value_or<decltype(cmdline_opts.preprocess_defines)::value_type>({}));
584  }
585 
586  if(cmdline_opts.preprocess_defines || cmdline_opts.preprocess_input_macros || cmdline_opts.preprocess_path) {
587  // It would be good if this was supported for running tests too, possibly for other uses.
588  // For the moment show an error message instead of leaving the user wondering why it doesn't work.
589  PLAIN_LOG << "That --preprocess-* option is only supported when using --preprocess or --validate.";
590  return 2;
591  }
592 
593  // Not the most intuitive solution, but I wanted to leave current semantics for now
594  return -1;
595 }
596 
597 /**
598  * I would prefer to setup locale first so that early error
599  * messages can get localized, but we need the game_launcher
600  * initialized to have filesystem::get_intl_dir() to work. Note: setlocale()
601  * does not take GUI language setting into account.
602  */
603 static void init_locale()
604 {
605 #if defined _WIN32 || defined __APPLE__
606  setlocale(LC_ALL, "English");
607 #else
608  std::setlocale(LC_ALL, "C");
609 #endif
610 
611  const std::string& intl_dir = filesystem::get_intl_dir();
612 
613  translation::bind_textdomain(PACKAGE, intl_dir.c_str(), "UTF-8");
614  translation::bind_textdomain(PACKAGE "-lib", intl_dir.c_str(), "UTF-8");
616 }
617 
618 /**
619  * Print an alert and instructions to stderr about early initialization errors.
620  *
621  * This is provided as an aid for users dealing with potential data dir
622  * configuration issues. The first code to read core WML *has* the
623  * responsibility to call this function in the event of a problem, to inform
624  * the user of the most likely possible cause and suggest a course of action
625  * to solve the issue.
626  */
628 {
629  // NOTE: wrap output to 80 columns.
630  PLAIN_LOG << '\n'
631  << "An error at this point during initialization usually indicates that the data\n"
632  << "directory above was not correctly set or detected. Try passing the correct path\n"
633  << "in the command line with the --data-dir switch or as the only argument.";
634 }
635 
636 /**
637  * Handles the lua script command line arguments if present.
638  * This function will only run once.
639  */
641 {
642  static bool first_time = true;
643 
644  if(!first_time) {
645  return;
646  }
647 
648  first_time = false;
649 
650  if(!game->init_lua_script()) {
651  // PLAIN_LOG << "error when loading lua scripts at startup";
652  // PLAIN_LOG << "could not load lua script: " << *cmdline_opts.script_file;
653  }
654 }
655 
656 #ifdef _MSC_VER
657 static void check_fpu()
658 {
659  uint32_t f_control;
660 
661  if(_controlfp_s(&f_control, 0, 0) == 0) {
662  uint32_t unused;
663  uint32_t rounding_mode = f_control & _MCW_RC;
664 
665  if(rounding_mode != _RC_NEAR) {
666  PLAIN_LOG << "Floating point rounding mode is currently '"
667  << ((rounding_mode == _RC_CHOP)
668  ? "chop"
669  : (rounding_mode == _RC_UP)
670  ? "up"
671  : (rounding_mode == _RC_DOWN)
672  ? "down"
673  : (rounding_mode == _RC_NEAR) ? "near" : "unknown")
674  << "' setting to 'near'";
675 
676  if(_controlfp_s(&unused, _RC_NEAR, _MCW_RC)) {
677  PLAIN_LOG << "failed to set floating point rounding type to 'near'";
678  }
679  }
680 
681 #ifndef _M_AMD64
682  uint32_t precision_mode = f_control & _MCW_PC;
683  if(precision_mode != _PC_53) {
684  PLAIN_LOG << "Floating point precision mode is currently '"
685  << ((precision_mode == _PC_53)
686  ? "double"
687  : (precision_mode == _PC_24)
688  ? "single"
689  : (precision_mode == _PC_64) ? "double extended" : "unknown")
690  << "' setting to 'double'";
691 
692  if(_controlfp_s(&unused, _PC_53, _MCW_PC)) {
693  PLAIN_LOG << "failed to set floating point precision type to 'double'";
694  }
695  }
696 #endif
697 
698  } else {
699  PLAIN_LOG << "_controlfp_s failed.";
700  }
701 }
702 #else
703 static void check_fpu()
704 {
705  switch(fegetround()) {
706  case FE_TONEAREST:
707  break;
708  case FE_DOWNWARD:
709  STREAMING_LOG << "Floating point precision mode is currently 'downward'";
710  goto reset_fpu;
711  case FE_TOWARDZERO:
712  STREAMING_LOG << "Floating point precision mode is currently 'toward-zero'";
713  goto reset_fpu;
714  case FE_UPWARD:
715  STREAMING_LOG << "Floating point precision mode is currently 'upward'";
716  goto reset_fpu;
717  default:
718  STREAMING_LOG << "Floating point precision mode is currently 'unknown'";
719  goto reset_fpu;
720  reset_fpu:
721  STREAMING_LOG << " - setting to 'nearest'\n";
722  fesetround(FE_TONEAREST);
723  break;
724  }
725 }
726 #endif
727 
728 /**
729  * Setups the game environment and enters
730  * the titlescreen or game loops.
731  */
732 static int do_gameloop(commandline_options& cmdline_opts)
733 {
734  srand(std::time(nullptr));
735 
736  const auto game = std::make_unique<game_launcher>(cmdline_opts);
737 
738  init_locale();
739 
740  bool res;
741 
742  // Do initialize fonts before reading the game config, to have game
743  // config error messages displayed. fonts will be re-initialized later
744  // when the language is read from the game config.
745  res = font::load_font_config();
746  if(res == false) {
747  PLAIN_LOG << "could not initialize fonts";
748  // The most common symptom of a bogus data dir path -- warn the user.
750  return 1;
751  }
752 
753  res = game->init_language();
754  if(res == false) {
755  PLAIN_LOG << "could not initialize the language";
756  return 1;
757  }
758 
759  res = game->init_video();
760  if(res == false) {
761  PLAIN_LOG << "could not initialize display";
762  return 1;
763  }
764 
765  check_fpu();
766  const cursor::manager cursor_manager;
768 
769 #if(defined(_X11) && !defined(__APPLE__)) || defined(_WIN32)
770  SDL_EventState(SDL_SYSWMEVENT, SDL_ENABLE);
771 #endif
772 
773  gui2::init();
774  gui2::switch_theme(prefs::get().gui2_theme());
775  const gui2::event::manager gui_event_manager;
776 
777  // if the log directory is not writable, then this is the error condition so show the error message.
778  // if the log directory is writable, then there's no issue.
779  // if the optional isn't set, then logging to file has been disabled, so there's no issue.
780  if(!lg::log_dir_writable().value_or(true)) {
781  utils::string_map symbols;
782  symbols["logdir"] = filesystem::get_logs_dir();
783  std::string msg = VGETTEXT("Unable to create log files in directory $logdir. This is often caused by incorrect folder permissions, anti-virus software restricting folder access, or using OneDrive to manage your My Documents folder.", symbols);
784  gui2::show_message(_("Logging Failure"), msg, message::ok_button);
785  }
786 
787  game_config_manager config_manager(cmdline_opts);
788 
792  }
793 
794  loading_screen::display([&res, &config_manager, &cmdline_opts]() {
797 
798  if(res == false) {
799  PLAIN_LOG << "could not initialize game config";
800  return;
801  }
802 
804 
805  res = font::load_font_config();
806  if(res == false) {
807  PLAIN_LOG << "could not re-initialize fonts for the current language";
808  return;
809  }
810 
811  if(!game_config::no_addons && !cmdline_opts.noaddons) {
813 
815  }
816  });
817 
818  if(res == false) {
819  return 1;
820  }
821 
822  plugins_manager plugins_man(new application_lua_kernel);
823 
824  const plugins_context::reg_vec callbacks {
825  {"play_multiplayer", std::bind(&game_launcher::play_multiplayer, game.get(), game_launcher::mp_mode::CONNECT)},
826  {"play_local", std::bind(&game_launcher::play_multiplayer, game.get(), game_launcher::mp_mode::LOCAL)},
827  {"play_campaign", std::bind(&game_launcher::play_campaign, game.get())},
828  };
829 
830  const plugins_context::areg_vec accessors {
831  {"command_line", std::bind(&commandline_options::to_config, &cmdline_opts)},
832  };
833 
834  plugins_context plugins("titlescreen", callbacks, accessors);
835 
836  plugins.set_callback("exit", [](const config& cfg) { safe_exit(cfg["code"].to_int(0)); }, false);
837 
838  while(true) {
839  if(!game->has_load_data()) {
840  auto cfg = config_manager.game_config().optional_child("titlescreen_music");
841  if(cfg) {
842  for(const config& i : cfg->child_range("music")) {
844  }
845 
846  config title_music_config;
847  title_music_config["name"] = game_config::title_music;
848  title_music_config["append"] = true;
849  title_music_config["immediate"] = true;
850  sound::play_music_config(title_music_config);
851  } else {
854  }
855  }
856 
857  handle_lua_script_args(&*game, cmdline_opts);
858 
859  plugins.play_slice();
860  plugins.play_slice();
861 
862  if(!cmdline_opts.unit_test.empty()) {
863  return static_cast<int>(game->unit_test());
864  }
865 
866  if(game->play_test() == false) {
867  return 0;
868  }
869 
870  if(game->play_screenshot_mode() == false) {
871  return 0;
872  }
873 
874  if(game->play_render_image_mode() == false) {
875  return 0;
876  }
877 
878  // Start directly a campaign
879  if(game->goto_campaign() == false) {
880  if(game->jump_to_campaign_id().empty())
881  continue; // Go to main menu
882  else
883  return 1; // we got an error starting the campaign from command line
884  }
885 
886  // Start directly a multiplayer
887  // Eventually with a specified server
888  if(game->goto_multiplayer() == false) {
889  continue; // Go to main menu
890  }
891 
892  // Start directly a commandline multiplayer game
893  if(game->play_multiplayer_commandline() == false) {
894  return 0;
895  }
896 
897  if(game->goto_editor() == false) {
898  return 0;
899  }
900 
901  const font::floating_label_context label_manager;
902 
904 
905  // If loading a game, skip the titlescreen entirely
906  if(game->has_load_data() && game->load_game()) {
908  continue;
909  }
910 
911  int retval;
912  { // scope to not keep the title screen alive all game
913  title_screen dlg(*game);
914 
915  // Allows re-layout on resize.
916  // Since RELOAD_UI is not checked here, it causes
917  // the dialog to be closed and reshown with changes.
919  dlg.show();
920  }
921  retval = dlg.get_retval();
922  }
923 
924  switch(retval) {
926  LOG_GENERAL << "quitting game...";
927  return 0;
929  game->play_multiplayer(game_launcher::mp_mode::CONNECT);
930  break;
932  game->play_multiplayer(game_launcher::mp_mode::HOST);
933  break;
935  game->play_multiplayer(game_launcher::mp_mode::LOCAL);
936  break;
938  loading_screen::display([&config_manager]() {
939  config_manager.reload_changed_game_config();
940  gui2::init();
941  gui2::switch_theme(prefs::get().gui2_theme());
942  });
943  break;
945  game->start_editor();
946  break;
949  break;
951  break;
953  gui2::switch_theme(prefs::get().gui2_theme());
954  break;
955  }
956  }
957 }
958 
959 #ifdef _WIN32
960 #define error_exit(res) \
961  do { \
962  if(lg::using_own_console()) { \
963  std::cerr << "Press enter to continue..." << std::endl; \
964  std::cin.get(); \
965  } \
966  return res; \
967  } while(false)
968 #else
969 #define error_exit(res) return res
970 #endif
971 
972 #ifdef __APPLE__
973 extern "C" int wesnoth_main(int argc, char** argv);
974 int wesnoth_main(int argc, char** argv)
975 #else
976 int main(int argc, char** argv)
977 #endif
978 {
980  auto args = read_argv(argc, argv);
981  assert(!args.empty());
982 
983 #ifdef _WIN32
984  _putenv("PANGOCAIRO_BACKEND=fontconfig");
985  _putenv("FONTCONFIG_PATH=fonts");
986 #endif
987 #ifdef __APPLE__
988  // Using setenv with overwrite disabled so we can override this in the
989  // original process environment for research/testing purposes.
990  setenv("PANGOCAIRO_BACKEND", "fontconfig", 0);
991 #endif
992 #ifdef __ANDROID__
993  setenv("PANGOCAIRO_BACKEND", "fontconfig", 0);
994  setenv("SDL_HINT_AUDIODRIVER", "android", 0);
995 #endif
996 
997  try {
998  commandline_options cmdline_opts = commandline_options(args);
999  int finished = process_command_args(cmdline_opts);
1000 
1001  if(finished != -1) {
1002 #ifdef _WIN32
1003  if(lg::using_own_console()) {
1004  std::cerr << "Press enter to continue..." << std::endl;
1005  std::cin.get();
1006  }
1007 #endif
1008  safe_exit(finished);
1009  }
1010 
1011  SDL_SetHint(SDL_HINT_NO_SIGNAL_HANDLERS, "1");
1012  // Is there a reason not to just use SDL_INIT_EVERYTHING?
1013  if(SDL_Init(SDL_INIT_TIMER) < 0) {
1014  PLAIN_LOG << "Couldn't initialize SDL: " << SDL_GetError();
1015  return (1);
1016  }
1017  atexit(SDL_Quit);
1018 
1019  // Mac's touchpad generates touch events too.
1020  // Ignore them until Macs have a touchscreen: https://forums.libsdl.org/viewtopic.php?p=45758
1021 #if defined(__APPLE__) && !defined(__IPHONEOS__)
1022  SDL_EventState(SDL_FINGERMOTION, SDL_DISABLE);
1023  SDL_EventState(SDL_FINGERDOWN, SDL_DISABLE);
1024  SDL_EventState(SDL_FINGERUP, SDL_DISABLE);
1025 #endif
1026 
1027  // declare this here so that it will always be at the front of the event queue.
1028  events::event_context global_context;
1029 
1030 #ifndef __ANDROID__
1031  SDL_StartTextInput();
1032 #endif
1033  const int res = do_gameloop(cmdline_opts);
1034  safe_exit(res);
1035  } catch(const boost::program_options::error& e) {
1036  // logging hasn't been initialized by this point
1037  std::cerr << "Error in command line: " << e.what() << std::endl;
1038  std::string error = "Error parsing command line arguments: ";
1039  error += e.what();
1040  SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Error", error.c_str(), nullptr);
1041  error_exit(2);
1042  } catch(const video::error& e) {
1043  PLAIN_LOG << "Video system error: " << e.what();
1044  error_exit(1);
1045  } catch(const font::error& e) {
1046  PLAIN_LOG << "Could not initialize fonts.\n\n" << e.what() << "\n\nExiting.";
1047  error_exit(1);
1048  } catch(const config::error& e) {
1049  PLAIN_LOG << e.message;
1050  error_exit(1);
1051  } catch(const video::quit&) {
1052  // just means the game should quit
1053  } catch(const return_to_play_side_exception&) {
1054  PLAIN_LOG << "caught return_to_play_side_exception, please report this bug (quitting)";
1055  } catch(const quit_game_exception&) {
1056  PLAIN_LOG << "caught quit_game_exception (quitting)";
1057  } catch(const wml_exception& e) {
1058  PLAIN_LOG << "WML exception:\nUser message: " << e.user_message << "\nDev message: " << e.dev_message;
1059  error_exit(1);
1060  } catch(const wfl::formula_error& e) {
1061  PLAIN_LOG << e.what() << "\n\nGame will be aborted.";
1062  error_exit(1);
1063  } catch(const sdl::exception& e) {
1064  PLAIN_LOG << e.what();
1065  error_exit(1);
1066  } catch(const game::error& e) {
1067  PLAIN_LOG << "Game error: " << e.what();
1068  error_exit(1);
1069  } catch(const std::bad_alloc&) {
1070  PLAIN_LOG << "Ran out of memory. Aborted.";
1071  error_exit(ENOMEM);
1072 #if !defined(NO_CATCH_AT_GAME_END)
1073  } catch(const std::exception& e) {
1074  // Try to catch unexpected exceptions.
1075  PLAIN_LOG << "Caught general '" << typeid(e).name() << "' exception:\n" << e.what();
1076  error_exit(1);
1077  } catch(const std::string& e) {
1078  PLAIN_LOG << "Caught a string thrown as an exception:\n" << e;
1079  error_exit(1);
1080  } catch(const char* e) {
1081  PLAIN_LOG << "Caught a string thrown as an exception:\n" << e;
1082  error_exit(1);
1083  } catch(...) {
1084  // Ensure that even when we terminate with `throw 42`, the exception
1085  // is caught and all destructors are actually called. (Apparently,
1086  // some compilers will simply terminate without calling destructors if
1087  // the exception isn't caught.)
1088  PLAIN_LOG << "Caught general exception " << utils::get_unknown_exception_type() << ". Terminating.";
1089  error_exit(1);
1090 #endif
1091  }
1092 
1093  return 0;
1094 } // end main
int wesnoth_main(int argc, char **argv)
void refresh_addon_version_info_cache()
Refreshes the per-session cache of add-on's version information structs.
Definition: manager.cpp:381
Used in parsing config file.
Definition: validator.hpp:38
bool nogui
True if –nogui was given on the command line.
utils::optional< std::string > validate_wml
Non-empty if –validate was given on the command line.
bool simple_version
True if –simple-version was given on the command line.
bool report
True if –report was given on the command line.
bool headless_unit_test
True if –unit is used and –showgui is not present.
bool no_log_sanitize
True if –no-log-sanitize was given on the command line.
bool strict_lua
True if –strict-lua was given in the commandline.
utils::optional< std::vector< std::string > > preprocess_defines
Defines that were given to the –preprocess option.
utils::optional< std::string > usercache_dir
Non-empty if –usercache-dir was given on the command line.
utils::optional< std::string > validate_schema
Non-empty if –validate-schema was given on the command line.
utils::optional< std::string > userdata_dir
Non-empty if –userdata-dir was given on the command line.
bool nobanner
True if –nobanner was given on the command line.
utils::optional< std::vector< std::pair< lg::severity, std::string > > > log
Contains parsed arguments of –log-* (e.g.
utils::optional< std::string > generate_spritesheet
Path of which to generate a spritesheet.
utils::optional< std::string > render_image
Image path to render.
utils::optional< std::string > logdomains
Non-empty if –logdomains was given on the command line.
utils::optional< std::string > preprocess_input_macros
Non-empty if –preprocess-input-macros was given on the command line.
bool preprocess
True if –preprocess was given on the command line.
utils::optional< unsigned int > rng_seed
RNG seed specified by –rng-seed option.
std::string diff_left
Files for diffing or patching.
bool data_path
True if –data-path was given on the command line.
bool version
True if –version was given on the command line.
bool allow_insecure
True if –allow-insecure was given in the commandline.
utils::optional< std::string > validate_with
Non-empty if –use-schema was given on the command line.
bool noaddons
True if –noaddons was given on the command line.
utils::optional< std::string > output_file
Output filename for WML diff or preprocessing.
utils::optional< std::string > data_dir
Non-empty if –data-dir was given on the command line.
utils::optional< std::string > preprocess_target
Target (output) path that was given to the –preprocess option.
bool screenshot
True if –screenshot was given on the command line.
bool log_to_file
True if –log-to-file was given on the command line.
bool debug_lua
True if –debug-lua was given in the commandline.
std::vector< std::string > unit_test
Non-empty if –unit was given on the command line.
bool userdata_path
True if –userdata-path was given on the command line.
bool log_precise_timestamps
True if –log-precise was given on the command line.
utils::optional< std::string > preprocess_source_string
String to preprocess.
bool no_log_to_file
True if –no-log-to-file was given on the command line.
utils::optional< std::string > preprocess_output_macros
Non-empty if –preprocess-output-macros was given on the command line.
bool strict_validation
True if –strict-validation was given on the command line.
utils::optional< std::string > preprocess_path
Path to parse that was given to the –preprocess option.
bool help
True if –help was given on the command line.
bool usercache_path
True if –usercache-path was given on the command line.
Class for writing a config out to a file in pieces.
void write(const config &cfg)
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
child_itors child_range(config_key_type key)
Definition: config.cpp:268
void apply_diff(const config &diff, bool track=false)
A function to apply a diff config onto this config object.
Definition: config.cpp:1016
config get_diff(const config &c) const
A function to get the differences between this object, and 'c', as another config object.
Definition: config.cpp:900
@ NO_FORCE_RELOAD
Don't reload if the previous defines equal the new defines.
bool init_game_config(FORCE_RELOAD_CONFIG force_reload)
const game_config_view & game_config() const
optional_const_config optional_child(config_key_type key) const
bool play_multiplayer(mp_mode mode)
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)
@ ok_button
Shows an ok button.
Definition: message.hpp:73
bool show(const unsigned auto_close_time=0)
Shows the window.
This class implements the title screen.
int get_retval()
Definition: window.hpp:402
void play_slice()
Definition: context.cpp:103
std::vector< Reg > reg_vec
Definition: context.hpp:40
std::vector< aReg > areg_vec
Definition: context.hpp:41
void set_callback(const std::string &name, callback_function)
Definition: context.cpp:53
static prefs & get()
Exception used to escape form the ai or ui code to playsingle_controller::play_side.
Realization of serialization/validator.hpp abstract validator.
std::string str() const
Serializes the version number into string form.
Type that can be thrown as an exception to quit to desktop.
Definition: video.hpp:328
std::vector< std::string > read_argv([[maybe_unused]] int argc, [[maybe_unused]] char **argv)
Definitions for the interface to Wesnoth Markup Language (WML).
const config * cfg
Declarations for File-IO.
#define VGETTEXT(msgid,...)
Handy wrappers around interpolate_variables_into_string and gettext.
std::size_t i
Definition: function.cpp:1032
Contains the exception interfaces used to signal completion of a scenario, campaign or turn.
Interfaces for manipulating version numbers of engine, add-ons, etc.
static std::string _(const char *str)
Definition: gettext.hpp:97
Standard logging facilities (interface).
#define STREAMING_LOG
Definition: log.hpp:297
#define PLAIN_LOG
Definition: log.hpp:296
auto format_local_timestamp(const std::chrono::system_clock::time_point &time, std::string_view format="%F %T")
Definition: chrono.hpp:62
@ WAIT
Definition: cursor.hpp:28
@ NORMAL
Definition: cursor.hpp:28
void set(CURSOR_TYPE type)
Use the default parameter to reset cursors.
Definition: cursor.cpp:178
void set_main_thread()
Definition: events.cpp:468
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
std::string get_exe_dir()
bool is_directory(const std::string &fname)
Returns true if the given file is a directory.
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.
filesystem::scoped_ostream ostream_file(const std::string &fname, std::ios_base::openmode mode, bool create_directory)
std::string autodetect_game_data_dir(std::string exe_dir)
Try to autodetect the location of the game data dir.
void set_cache_dir(const std::string &newcachedir)
Definition: filesystem.cpp:835
std::string get_logs_dir()
Definition: filesystem.cpp:877
std::unique_ptr< std::ostream > scoped_ostream
Definition: filesystem.hpp:54
bool is_userdata_initialized()
Definition: filesystem.cpp:624
std::string get_intl_dir()
std::string normalize_path(const std::string &fpath, bool normalize_separators, bool resolve_dot_entries)
Returns the absolute path of a file.
void set_user_data_dir(std::string newprefdir)
Definition: filesystem.cpp:737
bool load_font_config()
Definition: font_config.cpp:78
std::string path
Definition: filesystem.cpp:106
bool addon_server_info
Definition: game_config.cpp:79
std::string full_build_report()
Produce a bug report-style info dump.
Definition: build_info.cpp:666
std::string library_versions_report()
Produce a plain-text report of library versions suitable for stdout/stderr.
Definition: build_info.cpp:656
const version_info wesnoth_version(VERSION)
bool allow_insecure
Definition: game_config.cpp:78
std::string title_music
std::string build_arch()
Obtain the processor architecture for this build.
Definition: build_info.cpp:316
std::string optional_features_report()
Produce a plain-text report of features suitable for stdout/stderr.
Definition: build_info.cpp:661
const std::string revision
bool check_migration
Definition: filesystem.cpp:114
void init()
Initializes the GUI subsystems.
Definition: gui.cpp:112
void switch_theme(const std::string &theme_id)
Set and activate the given gui2 theme.
Definition: gui.cpp:153
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
retval
Default window/dialog return values.
Definition: retval.hpp:30
void build_spritesheet_from(const std::string &entry_point)
config read(std::istream &in, abstract_validator *validator)
Definition: parser.cpp:600
bool using_own_console()
Returns true if a console was allocated by the Wesnoth process.
severity
Definition: log.hpp:82
std::string list_log_domains(const std::string &filter)
Definition: log.cpp:410
bool broke_strict()
Definition: log.cpp:430
void set_log_to_file()
Do the initial redirection to a log file if the logs directory is writable.
Definition: log.cpp:266
void set_log_sanitize(bool sanitize)
toggle log sanitization
Definition: log.cpp:434
utils::optional< bool > log_dir_writable()
Returns the result set by check_log_dir_writable().
Definition: log.cpp:312
void do_console_redirect()
Allocates a console if needed and redirects output to CONOUT.
void precise_timestamps(bool pt)
Definition: log.cpp:337
bool set_log_domain_severity(const std::string &name, severity severity)
Definition: log.cpp:379
void set_strict_severity(severity severity)
Definition: log.cpp:420
void empty_playlist()
Definition: sound.cpp:611
void play_music_config(const config &music_node, bool allow_interrupt_current_track, int i)
Definition: sound.cpp:689
void stop_music()
Definition: sound.cpp:554
void bind_textdomain(const char *domain, const char *directory, const char *)
Definition: gettext.cpp:479
void set_default_textdomain(const char *domain)
Definition: gettext.cpp:487
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
static void msg(const char *act, debug_info &i, const char *to="", const char *result="")
Definition: debugger.cpp:109
std::string preprocess_string(const std::string &contents, preproc_map *defines, const std::string &textdomain)
Function to use the WML preprocessor on a string.
void preprocess_resource(const std::string &res_name, preproc_map *defines_map, bool write_cfg, bool write_plain_cfg, const std::string &parent_directory)
filesystem::scoped_istream preprocess_file(const std::string &fname, preproc_map *defines)
Function to use the WML preprocessor on a file.
std::map< std::string, struct preproc_define > preproc_map
One of the realizations of serialization/validator.hpp abstract validator.
Contains a basic exception class for SDL operations.
structure which will hide all current floating labels, and cause floating labels instantiated after i...
Base class for all the errors encountered by the engine.
Definition: exceptions.hpp:29
static void insert(preproc_map &, const config &)
Reports time elapsed at the end of an object scope.
Definition: optimer.hpp:37
An error specifically indicating video subsystem problems.
Definition: video.hpp:321
Helper class, don't construct this directly.
bool strict_validation_enabled
Definition: validator.cpp:21
Some defines: VERSION, PACKAGE, MIN_SAVEGAME_VERSION.
#define PACKAGE
Definition: wesconfig.h:23
static lg::log_domain log_preprocessor("preprocessor")
static void handle_preprocess_string(const commandline_options &cmdline_opts)
Definition: wesnoth.cpp:133
static void safe_exit(int res)
Definition: wesnoth.cpp:127
static int do_gameloop(commandline_options &cmdline_opts)
Setups the game environment and enters the titlescreen or game loops.
Definition: wesnoth.cpp:732
static int handle_validate_command(const std::string &file, abstract_validator &validator, const std::vector< std::string > &defines)
Definition: wesnoth.cpp:303
int main(int argc, char **argv)
Definition: wesnoth.cpp:976
static int process_command_args(commandline_options &cmdline_opts)
Process commandline-arguments.
Definition: wesnoth.cpp:331
static void handle_preprocess_command(const commandline_options &cmdline_opts)
Definition: wesnoth.cpp:188
static void check_fpu()
Definition: wesnoth.cpp:703
#define LOG_PREPROC
Definition: wesnoth.cpp:122
static void init_locale()
I would prefer to setup locale first so that early error messages can get localized,...
Definition: wesnoth.cpp:603
static void handle_lua_script_args(game_launcher *game, commandline_options &)
Handles the lua script command line arguments if present.
Definition: wesnoth.cpp:640
#define error_exit(res)
Definition: wesnoth.cpp:969
static void warn_early_init_failure()
Print an alert and instructions to stderr about early initialization errors.
Definition: wesnoth.cpp:627
#define LOG_GENERAL
Definition: wesnoth.cpp:119
static lg::log_domain log_config("config")
Add a special kind of assert to validate whether the input from WML doesn't contain any problems that...
#define e