OpenTTD
openttd.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of OpenTTD.
3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6  */
7 
10 #include "stdafx.h"
11 
12 #include "blitter/factory.hpp"
13 #include "sound/sound_driver.hpp"
14 #include "music/music_driver.hpp"
15 #include "video/video_driver.hpp"
16 
17 #include "fontcache.h"
18 #include "error.h"
19 #include "gui.h"
20 
21 #include "base_media_base.h"
22 #include "saveload/saveload.h"
23 #include "company_func.h"
24 #include "command_func.h"
25 #include "news_func.h"
26 #include "fios.h"
27 #include "aircraft.h"
28 #include "roadveh.h"
29 #include "train.h"
30 #include "ship.h"
31 #include "console_func.h"
32 #include "screenshot.h"
33 #include "network/network.h"
34 #include "network/network_func.h"
35 #include "ai/ai.hpp"
36 #include "ai/ai_config.hpp"
37 #include "settings_func.h"
38 #include "genworld.h"
39 #include "progress.h"
40 #include "strings_func.h"
41 #include "date_func.h"
42 #include "vehicle_func.h"
43 #include "gamelog.h"
44 #include "animated_tile_func.h"
45 #include "roadstop_base.h"
46 #include "elrail_func.h"
47 #include "rev.h"
48 #include "highscore.h"
49 #include "station_base.h"
50 #include "crashlog.h"
51 #include "engine_func.h"
52 #include "core/random_func.hpp"
53 #include "rail_gui.h"
54 #include "road_gui.h"
55 #include "core/backup_type.hpp"
56 #include "hotkeys.h"
57 #include "newgrf.h"
58 #include "misc/getoptdata.h"
59 #include "game/game.hpp"
60 #include "game/game_config.hpp"
61 #include "town.h"
62 #include "subsidy_func.h"
63 #include "gfx_layout.h"
64 #include "viewport_func.h"
65 #include "viewport_sprite_sorter.h"
66 #include "framerate_type.h"
67 
69 
70 #include <stdarg.h>
71 #include <system_error>
72 
73 #include "safeguards.h"
74 
75 void CallLandscapeTick();
76 void IncreaseDate();
77 void DoPaletteAnimations();
78 void MusicLoop();
79 void ResetMusic();
81 bool HandleBootstrap();
82 
83 extern Company *DoStartupNewCompany(bool is_ai, CompanyID company = INVALID_COMPANY);
84 extern void ShowOSErrorBox(const char *buf, bool system);
85 extern char *_config_file;
86 
92 void CDECL usererror(const char *s, ...)
93 {
94  va_list va;
95  char buf[512];
96 
97  va_start(va, s);
98  vseprintf(buf, lastof(buf), s, va);
99  va_end(va);
100 
101  ShowOSErrorBox(buf, false);
103 
104  exit(1);
105 }
106 
112 void CDECL error(const char *s, ...)
113 {
114  va_list va;
115  char buf[512];
116 
117  va_start(va, s);
118  vseprintf(buf, lastof(buf), s, va);
119  va_end(va);
120 
121  if (VideoDriver::GetInstance() == nullptr || VideoDriver::GetInstance()->HasGUI()) {
122  ShowOSErrorBox(buf, true);
123  }
124 
125  /* Set the error message for the crash log and then invoke it. */
127  abort();
128 }
129 
134 void CDECL ShowInfoF(const char *str, ...)
135 {
136  va_list va;
137  char buf[1024];
138  va_start(va, str);
139  vseprintf(buf, lastof(buf), str, va);
140  va_end(va);
141  ShowInfo(buf);
142 }
143 
147 static void ShowHelp()
148 {
149  char buf[8192];
150  char *p = buf;
151 
152  p += seprintf(p, lastof(buf), "OpenTTD %s\n", _openttd_revision);
153  p = strecpy(p,
154  "\n"
155  "\n"
156  "Command line options:\n"
157  " -v drv = Set video driver (see below)\n"
158  " -s drv = Set sound driver (see below) (param bufsize,hz)\n"
159  " -m drv = Set music driver (see below)\n"
160  " -b drv = Set the blitter to use (see below)\n"
161  " -r res = Set resolution (for instance 800x600)\n"
162  " -h = Display this help text\n"
163  " -t year = Set starting year\n"
164  " -d [[fac=]lvl[,...]]= Debug mode\n"
165  " -e = Start Editor\n"
166  " -g [savegame] = Start new/save game immediately\n"
167  " -G seed = Set random seed\n"
168  " -n [ip:port#company]= Join network game\n"
169  " -p password = Password to join server\n"
170  " -P password = Password to join company\n"
171  " -D [ip][:port] = Start dedicated server\n"
172  " -l ip[:port] = Redirect DEBUG()\n"
173 #if !defined(_WIN32)
174  " -f = Fork into the background (dedicated only)\n"
175 #endif
176  " -I graphics_set = Force the graphics set (see below)\n"
177  " -S sounds_set = Force the sounds set (see below)\n"
178  " -M music_set = Force the music set (see below)\n"
179  " -c config_file = Use 'config_file' instead of 'openttd.cfg'\n"
180  " -x = Do not automatically save to config file on exit\n"
181  " -q savegame = Write some information about the savegame and exit\n"
182  "\n",
183  lastof(buf)
184  );
185 
186  /* List the graphics packs */
187  p = BaseGraphics::GetSetsList(p, lastof(buf));
188 
189  /* List the sounds packs */
190  p = BaseSounds::GetSetsList(p, lastof(buf));
191 
192  /* List the music packs */
193  p = BaseMusic::GetSetsList(p, lastof(buf));
194 
195  /* List the drivers */
197 
198  /* List the blitters */
200 
201  /* List the debug facilities. */
202  p = DumpDebugFacilityNames(p, lastof(buf));
203 
204  /* We need to initialize the AI, so it finds the AIs */
205  AI::Initialize();
206  p = AI::GetConsoleList(p, lastof(buf), true);
207  AI::Uninitialize(true);
208 
209  /* We need to initialize the GameScript, so it finds the GSs */
211  p = Game::GetConsoleList(p, lastof(buf), true);
212  Game::Uninitialize(true);
213 
214  /* ShowInfo put output to stderr, but version information should go
215  * to stdout; this is the only exception */
216 #if !defined(_WIN32)
217  printf("%s\n", buf);
218 #else
219  ShowInfo(buf);
220 #endif
221 }
222 
223 static void WriteSavegameInfo(const char *name)
224 {
226  uint32 last_ottd_rev = 0;
227  byte ever_modified = 0;
228  bool removed_newgrfs = false;
229 
230  GamelogInfo(_load_check_data.gamelog_action, _load_check_data.gamelog_actions, &last_ottd_rev, &ever_modified, &removed_newgrfs);
231 
232  char buf[8192];
233  char *p = buf;
234  p += seprintf(p, lastof(buf), "Name: %s\n", name);
235  p += seprintf(p, lastof(buf), "Savegame ver: %d\n", _sl_version);
236  p += seprintf(p, lastof(buf), "NewGRF ver: 0x%08X\n", last_ottd_rev);
237  p += seprintf(p, lastof(buf), "Modified: %d\n", ever_modified);
238 
239  if (removed_newgrfs) {
240  p += seprintf(p, lastof(buf), "NewGRFs have been removed\n");
241  }
242 
243  p = strecpy(p, "NewGRFs:\n", lastof(buf));
245  for (GRFConfig *c = _load_check_data.grfconfig; c != nullptr; c = c->next) {
246  char md5sum[33];
247  md5sumToString(md5sum, lastof(md5sum), HasBit(c->flags, GCF_COMPATIBLE) ? c->original_md5sum : c->ident.md5sum);
248  p += seprintf(p, lastof(buf), "%08X %s %s\n", c->ident.grfid, md5sum, c->filename);
249  }
250  }
251 
252  /* ShowInfo put output to stderr, but version information should go
253  * to stdout; this is the only exception */
254 #if !defined(_WIN32)
255  printf("%s\n", buf);
256 #else
257  ShowInfo(buf);
258 #endif
259 }
260 
261 
268 static void ParseResolution(Dimension *res, const char *s)
269 {
270  const char *t = strchr(s, 'x');
271  if (t == nullptr) {
272  ShowInfoF("Invalid resolution '%s'", s);
273  return;
274  }
275 
276  res->width = max(strtoul(s, nullptr, 0), 64UL);
277  res->height = max(strtoul(t + 1, nullptr, 0), 64UL);
278 }
279 
280 
285 static void ShutdownGame()
286 {
287  IConsoleFree();
288 
289  if (_network_available) NetworkShutDown(); // Shut down the network and close any open connections
290 
292 
294 
295  /* stop the scripts */
296  AI::Uninitialize(false);
297  Game::Uninitialize(false);
298 
299  /* Uninitialize variables that are allocated dynamically */
300  GamelogReset();
301 
303 
306 
307  /* No NewGRFs were loaded when it was still bootstrapping. */
308  if (_game_mode != GM_BOOTSTRAP) ResetNewGRFData();
309 
310  /* Close all and any open filehandles */
311  FioCloseAll();
312 
313  UninitFreeType();
314 }
315 
320 static void LoadIntroGame(bool load_newgrfs = true)
321 {
322  _game_mode = GM_MENU;
323 
324  if (load_newgrfs) ResetGRFConfig(false);
325 
326  /* Setup main window */
329 
330  /* Load the default opening screen savegame */
331  if (SaveOrLoad("opntitle.dat", SLO_LOAD, DFT_GAME_FILE, BASESET_DIR) != SL_OK) {
332  GenerateWorld(GWM_EMPTY, 64, 64); // if failed loading, make empty world.
335  } else {
337  }
338 
339  FixTitleGameZoom();
341  _cursor.fix_at = false;
342 
344 
345  MusicLoop(); // ensure music is correct
346 }
347 
348 void MakeNewgameSettingsLive()
349 {
350  for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) {
351  if (_settings_game.ai_config[c] != nullptr) {
352  delete _settings_game.ai_config[c];
353  }
354  }
355  if (_settings_game.game_config != nullptr) {
357  }
358 
359  /* Copy newgame settings to active settings.
360  * Also initialise old settings needed for savegame conversion. */
363 
364  for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) {
365  _settings_game.ai_config[c] = nullptr;
366  if (_settings_newgame.ai_config[c] != nullptr) {
368  if (!AIConfig::GetConfig(c, AIConfig::SSS_FORCE_GAME)->HasScript()) {
370  }
371  }
372  }
373  _settings_game.game_config = nullptr;
374  if (_settings_newgame.game_config != nullptr) {
376  }
377 }
378 
379 void OpenBrowser(const char *url)
380 {
381  /* Make sure we only accept urls that are sure to open a browser. */
382  if (strstr(url, "http://") != url && strstr(url, "https://") != url) return;
383 
384  extern void OSOpenBrowser(const char *url);
385  OSOpenBrowser(url);
386 }
387 
393  uint16 dedicated_port;
394  char *network_conn;
395  const char *join_server_password;
396  const char *join_company_password;
398  bool save_config;
399 
405  AfterNewGRFScan(bool *save_config_ptr) :
406  startyear(INVALID_YEAR), generation_seed(GENERATE_NEW_SEED),
407  dedicated_host(nullptr), dedicated_port(0), network_conn(nullptr),
408  join_server_password(nullptr), join_company_password(nullptr),
409  save_config_ptr(save_config_ptr), save_config(true)
410  {
411  /* Visual C++ 2015 fails compiling this line (AfterNewGRFScan::generation_seed undefined symbol)
412  * if it's placed outside a member function, directly in the struct body. */
413  assert_compile(sizeof(generation_seed) == sizeof(_settings_game.game_creation.generation_seed));
414  }
415 
416  virtual void OnNewGRFsScanned()
417  {
418  ResetGRFConfig(false);
419 
421 
422  AI::Initialize();
424 
425  /* We want the new (correct) NewGRF count to survive the loading. */
426  uint last_newgrf_count = _settings_client.gui.last_newgrf_count;
427  LoadFromConfig();
428  _settings_client.gui.last_newgrf_count = last_newgrf_count;
429  /* Since the default for the palette might have changed due to
430  * reading the configuration file, recalculate that now. */
432 
433  Game::Uninitialize(true);
434  AI::Uninitialize(true);
438 
439  /* We have loaded the config, so we may possibly save it. */
440  *save_config_ptr = save_config;
441 
442  /* restore saved music volume */
444 
447 
448  if (dedicated_host != nullptr) {
449  _network_bind_list.clear();
450  _network_bind_list.emplace_back(dedicated_host);
451  }
452  if (dedicated_port != 0) _settings_client.network.server_port = dedicated_port;
453 
454  /* initialize the ingame console */
455  IConsoleInit();
456  InitializeGUI();
457  IConsoleCmdExec("exec scripts/autoexec.scr 0");
458 
459  /* Make sure _settings is filled with _settings_newgame if we switch to a game directly */
460  if (_switch_mode != SM_NONE) MakeNewgameSettingsLive();
461 
462  if (_network_available && network_conn != nullptr) {
463  const char *port = nullptr;
464  const char *company = nullptr;
465  uint16 rport = NETWORK_DEFAULT_PORT;
466  CompanyID join_as = COMPANY_NEW_COMPANY;
467 
468  ParseConnectionString(&company, &port, network_conn);
469 
470  if (company != nullptr) {
471  join_as = (CompanyID)atoi(company);
472 
473  if (join_as != COMPANY_SPECTATOR) {
474  join_as--;
475  if (join_as >= MAX_COMPANIES) {
476  delete this;
477  return;
478  }
479  }
480  }
481  if (port != nullptr) rport = atoi(port);
482 
483  LoadIntroGame();
484  _switch_mode = SM_NONE;
485  NetworkClientConnectGame(NetworkAddress(network_conn, rport), join_as, join_server_password, join_company_password);
486  }
487 
488  /* After the scan we're not used anymore. */
489  delete this;
490  }
491 };
492 
493 #if defined(UNIX)
494 extern void DedicatedFork();
495 #endif
496 
498 static const OptionData _options[] = {
499  GETOPT_SHORT_VALUE('I'),
500  GETOPT_SHORT_VALUE('S'),
501  GETOPT_SHORT_VALUE('M'),
502  GETOPT_SHORT_VALUE('m'),
503  GETOPT_SHORT_VALUE('s'),
504  GETOPT_SHORT_VALUE('v'),
505  GETOPT_SHORT_VALUE('b'),
506  GETOPT_SHORT_OPTVAL('D'),
507  GETOPT_SHORT_OPTVAL('n'),
508  GETOPT_SHORT_VALUE('l'),
509  GETOPT_SHORT_VALUE('p'),
510  GETOPT_SHORT_VALUE('P'),
511 #if !defined(_WIN32)
512  GETOPT_SHORT_NOVAL('f'),
513 #endif
514  GETOPT_SHORT_VALUE('r'),
515  GETOPT_SHORT_VALUE('t'),
516  GETOPT_SHORT_OPTVAL('d'),
517  GETOPT_SHORT_NOVAL('e'),
518  GETOPT_SHORT_OPTVAL('g'),
519  GETOPT_SHORT_VALUE('G'),
520  GETOPT_SHORT_VALUE('c'),
521  GETOPT_SHORT_NOVAL('x'),
522  GETOPT_SHORT_VALUE('q'),
523  GETOPT_SHORT_NOVAL('h'),
524  GETOPT_END()
525 };
526 
533 int openttd_main(int argc, char *argv[])
534 {
535  char *musicdriver = nullptr;
536  char *sounddriver = nullptr;
537  char *videodriver = nullptr;
538  char *blitter = nullptr;
539  char *graphics_set = nullptr;
540  char *sounds_set = nullptr;
541  char *music_set = nullptr;
542  Dimension resolution = {0, 0};
543  /* AfterNewGRFScan sets save_config to true after scanning completed. */
544  bool save_config = false;
545  AfterNewGRFScan *scanner = new AfterNewGRFScan(&save_config);
546  bool dedicated = false;
547  char *debuglog_conn = nullptr;
548 
549  extern bool _dedicated_forks;
550  _dedicated_forks = false;
551 
552  std::unique_lock<std::mutex> modal_work_lock(_modal_progress_work_mutex, std::defer_lock);
553  std::unique_lock<std::mutex> modal_paint_lock(_modal_progress_paint_mutex, std::defer_lock);
554 
555  _game_mode = GM_MENU;
557  _config_file = nullptr;
558 
559  GetOptData mgo(argc - 1, argv + 1, _options);
560  int ret = 0;
561 
562  int i;
563  while ((i = mgo.GetOpt()) != -1) {
564  switch (i) {
565  case 'I': free(graphics_set); graphics_set = stredup(mgo.opt); break;
566  case 'S': free(sounds_set); sounds_set = stredup(mgo.opt); break;
567  case 'M': free(music_set); music_set = stredup(mgo.opt); break;
568  case 'm': free(musicdriver); musicdriver = stredup(mgo.opt); break;
569  case 's': free(sounddriver); sounddriver = stredup(mgo.opt); break;
570  case 'v': free(videodriver); videodriver = stredup(mgo.opt); break;
571  case 'b': free(blitter); blitter = stredup(mgo.opt); break;
572  case 'D':
573  free(musicdriver);
574  free(sounddriver);
575  free(videodriver);
576  free(blitter);
577  musicdriver = stredup("null");
578  sounddriver = stredup("null");
579  videodriver = stredup("dedicated");
580  blitter = stredup("null");
581  dedicated = true;
582  SetDebugString("net=6");
583  if (mgo.opt != nullptr) {
584  /* Use the existing method for parsing (openttd -n).
585  * However, we do ignore the #company part. */
586  const char *temp = nullptr;
587  const char *port = nullptr;
588  ParseConnectionString(&temp, &port, mgo.opt);
589  if (!StrEmpty(mgo.opt)) scanner->dedicated_host = mgo.opt;
590  if (port != nullptr) scanner->dedicated_port = atoi(port);
591  }
592  break;
593  case 'f': _dedicated_forks = true; break;
594  case 'n':
595  scanner->network_conn = mgo.opt; // optional IP parameter, nullptr if unset
596  break;
597  case 'l':
598  debuglog_conn = mgo.opt;
599  break;
600  case 'p':
601  scanner->join_server_password = mgo.opt;
602  break;
603  case 'P':
604  scanner->join_company_password = mgo.opt;
605  break;
606  case 'r': ParseResolution(&resolution, mgo.opt); break;
607  case 't': scanner->startyear = atoi(mgo.opt); break;
608  case 'd': {
609 #if defined(_WIN32)
610  CreateConsole();
611 #endif
612  if (mgo.opt != nullptr) SetDebugString(mgo.opt);
613  break;
614  }
616  case 'g':
617  if (mgo.opt != nullptr) {
619  bool is_scenario = _switch_mode == SM_EDITOR || _switch_mode == SM_LOAD_SCENARIO;
620  _switch_mode = is_scenario ? SM_LOAD_SCENARIO : SM_LOAD_GAME;
622 
623  /* if the file doesn't exist or it is not a valid savegame, let the saveload code show an error */
624  const char *t = strrchr(_file_to_saveload.name, '.');
625  if (t != nullptr) {
627  if (ft != FIOS_TYPE_INVALID) _file_to_saveload.SetMode(ft);
628  }
629 
630  break;
631  }
632 
634  /* Give a random map if no seed has been given */
635  if (scanner->generation_seed == GENERATE_NEW_SEED) {
636  scanner->generation_seed = InteractiveRandom();
637  }
638  break;
639  case 'q': {
640  DeterminePaths(argv[0]);
641  if (StrEmpty(mgo.opt)) {
642  ret = 1;
643  goto exit_noshutdown;
644  }
645 
646  char title[80];
647  title[0] = '\0';
648  FiosGetSavegameListCallback(SLO_LOAD, mgo.opt, strrchr(mgo.opt, '.'), title, lastof(title));
649 
652  if (res != SL_OK || _load_check_data.HasErrors()) {
653  fprintf(stderr, "Failed to open savegame\n");
654  if (_load_check_data.HasErrors()) {
655  char buf[256];
657  GetString(buf, _load_check_data.error, lastof(buf));
658  fprintf(stderr, "%s\n", buf);
659  }
660  goto exit_noshutdown;
661  }
662 
663  WriteSavegameInfo(title);
664 
665  goto exit_noshutdown;
666  }
667  case 'G': scanner->generation_seed = strtoul(mgo.opt, nullptr, 10); break;
668  case 'c': free(_config_file); _config_file = stredup(mgo.opt); break;
669  case 'x': scanner->save_config = false; break;
670  case 'h':
671  i = -2; // Force printing of help.
672  break;
673  }
674  if (i == -2) break;
675  }
676 
677  if (i == -2 || mgo.numleft > 0) {
678  /* Either the user typed '-h', he made an error, or he added unrecognized command line arguments.
679  * In all cases, print the help, and exit.
680  *
681  * The next two functions are needed to list the graphics sets. We can't do them earlier
682  * because then we cannot show it on the debug console as that hasn't been configured yet. */
683  DeterminePaths(argv[0]);
688  ShowHelp();
689 
690  goto exit_noshutdown;
691  }
692 
693  DeterminePaths(argv[0]);
695 
696  if (dedicated) DEBUG(net, 0, "Starting dedicated version %s", _openttd_revision);
697  if (_dedicated_forks && !dedicated) _dedicated_forks = false;
698 
699 #if defined(UNIX)
700  /* We must fork here, or we'll end up without some resources we need (like sockets) */
701  if (_dedicated_forks) DedicatedFork();
702 #endif
703 
704  LoadFromConfig(true);
705 
706  if (resolution.width != 0) _cur_resolution = resolution;
707 
708  /*
709  * The width and height must be at least 1 pixel and width times
710  * height times bytes per pixel must still fit within a 32 bits
711  * integer, even for 32 bpp video modes. This way all internal
712  * drawing routines work correctly.
713  */
714  _cur_resolution.width = ClampU(_cur_resolution.width, 1, UINT16_MAX / 2);
715  _cur_resolution.height = ClampU(_cur_resolution.height, 1, UINT16_MAX / 2);
716 
717  /* Assume the cursor starts within the game as not all video drivers
718  * get an event that the cursor is within the window when it is opened.
719  * Saying the cursor is there makes no visible difference as it would
720  * just be out of the bounds of the window. */
721  _cursor.in_window = true;
722 
723  /* enumerate language files */
725 
726  /* Initialize the regular font for FreeType */
727  InitFreeType(false);
728 
729  /* This must be done early, since functions use the SetWindowDirty* calls */
731 
733  if (graphics_set == nullptr && BaseGraphics::ini_set != nullptr) graphics_set = stredup(BaseGraphics::ini_set);
734  if (!BaseGraphics::SetSet(graphics_set)) {
735  if (!StrEmpty(graphics_set)) {
736  BaseGraphics::SetSet(nullptr);
737 
738  ErrorMessageData msg(STR_CONFIG_ERROR, STR_CONFIG_ERROR_INVALID_BASE_GRAPHICS_NOT_FOUND);
739  msg.SetDParamStr(0, graphics_set);
741  }
742  }
743  free(graphics_set);
744 
745  /* Initialize game palette */
746  GfxInitPalettes();
747 
748  DEBUG(misc, 1, "Loading blitter...");
749  if (blitter == nullptr && _ini_blitter != nullptr) blitter = stredup(_ini_blitter);
750  _blitter_autodetected = StrEmpty(blitter);
751  /* Activate the initial blitter.
752  * This is only some initial guess, after NewGRFs have been loaded SwitchNewGRFBlitter may switch to a different one.
753  * - Never guess anything, if the user specified a blitter. (_blitter_autodetected)
754  * - Use 32bpp blitter if baseset or 8bpp-support settings says so.
755  * - Use 8bpp blitter otherwise.
756  */
757  if (!_blitter_autodetected ||
758  (_support8bpp != S8BPP_NONE && (BaseGraphics::GetUsedSet() == nullptr || BaseGraphics::GetUsedSet()->blitter == BLT_8BPP)) ||
759  BlitterFactory::SelectBlitter("32bpp-anim") == nullptr) {
760  if (BlitterFactory::SelectBlitter(blitter) == nullptr) {
761  StrEmpty(blitter) ?
762  usererror("Failed to autoprobe blitter") :
763  usererror("Failed to select requested blitter '%s'; does it exist?", blitter);
764  }
765  }
766  free(blitter);
767 
768  if (videodriver == nullptr && _ini_videodriver != nullptr) videodriver = stredup(_ini_videodriver);
770  free(videodriver);
771 
773 
774  /* Initialize the zoom level of the screen to normal */
775  _screen.zoom = ZOOM_LVL_NORMAL;
776 
777  NetworkStartUp(); // initialize network-core
778 
779  if (debuglog_conn != nullptr && _network_available) {
780  const char *not_used = nullptr;
781  const char *port = nullptr;
782  uint16 rport;
783 
785 
786  ParseConnectionString(&not_used, &port, debuglog_conn);
787  if (port != nullptr) rport = atoi(port);
788 
789  NetworkStartDebugLog(NetworkAddress(debuglog_conn, rport));
790  }
791 
792  if (!HandleBootstrap()) {
793  ShutdownGame();
794 
795  goto exit_bootstrap;
796  }
797 
798  VideoDriver::GetInstance()->ClaimMousePointer();
799 
800  /* initialize screenshot formats */
802 
804  if (sounds_set == nullptr && BaseSounds::ini_set != nullptr) sounds_set = stredup(BaseSounds::ini_set);
805  if (!BaseSounds::SetSet(sounds_set)) {
806  if (StrEmpty(sounds_set) || !BaseSounds::SetSet(nullptr)) {
807  usererror("Failed to find a sounds set. Please acquire a sounds set for OpenTTD. See section 4.1 of README.md.");
808  } else {
809  ErrorMessageData msg(STR_CONFIG_ERROR, STR_CONFIG_ERROR_INVALID_BASE_SOUNDS_NOT_FOUND);
810  msg.SetDParamStr(0, sounds_set);
812  }
813  }
814  free(sounds_set);
815 
817  if (music_set == nullptr && BaseMusic::ini_set != nullptr) music_set = stredup(BaseMusic::ini_set);
818  if (!BaseMusic::SetSet(music_set)) {
819  if (StrEmpty(music_set) || !BaseMusic::SetSet(nullptr)) {
820  usererror("Failed to find a music set. Please acquire a music set for OpenTTD. See section 4.1 of README.md.");
821  } else {
822  ErrorMessageData msg(STR_CONFIG_ERROR, STR_CONFIG_ERROR_INVALID_BASE_MUSIC_NOT_FOUND);
823  msg.SetDParamStr(0, music_set);
825  }
826  }
827  free(music_set);
828 
829  if (sounddriver == nullptr && _ini_sounddriver != nullptr) sounddriver = stredup(_ini_sounddriver);
831  free(sounddriver);
832 
833  if (musicdriver == nullptr && _ini_musicdriver != nullptr) musicdriver = stredup(_ini_musicdriver);
835  free(musicdriver);
836 
837  /* Take our initial lock on whatever we might want to do! */
838  try {
839  modal_work_lock.lock();
840  modal_paint_lock.lock();
841  } catch (const std::system_error&) {
842  /* If there is some error we assume that threads aren't usable on the system we run. */
843  extern bool _use_threaded_modal_progress; // From progress.cpp
844  _use_threaded_modal_progress = false;
845  }
846 
847  GenerateWorld(GWM_EMPTY, 64, 64); // Make the viewport initialization happy
849 
850  LoadIntroGame(false);
851 
853 
854  /* ScanNewGRFFiles now has control over the scanner. */
855  ScanNewGRFFiles(scanner);
856  scanner = nullptr;
857 
859 
860  WaitTillSaved();
861  WaitTillGeneratedWorld(); // Make sure any generate world threads have been joined.
862 
863  /* only save config if we have to */
864  if (save_config) {
865  SaveToConfig();
868  SaveToHighScore();
869  }
870 
871  /* Reset windowing system, stop drivers, free used memory, ... */
872  ShutdownGame();
873  goto exit_normal;
874 
875 exit_noshutdown:
876  /* These three are normally freed before bootstrap. */
877  free(graphics_set);
878  free(videodriver);
879  free(blitter);
880 
881 exit_bootstrap:
882  /* These are normally freed before exit, but after bootstrap. */
883  free(sounds_set);
884  free(music_set);
885  free(musicdriver);
886  free(sounddriver);
887 
888 exit_normal:
892 
897 
898  delete scanner;
899 
900  extern FILE *_log_fd;
901  if (_log_fd != nullptr) {
902  fclose(_log_fd);
903  }
904 
905  return ret;
906 }
907 
908 void HandleExitGameRequest()
909 {
910  if (_game_mode == GM_MENU || _game_mode == GM_BOOTSTRAP) { // do not ask to quit on the main screen
911  _exit_game = true;
913  DoExitSave();
914  _exit_game = true;
915  } else {
916  AskExitGame();
917  }
918 }
919 
920 static void MakeNewGameDone()
921 {
923 
924  /* In a dedicated server, the server does not play */
925  if (!VideoDriver::GetInstance()->HasGUI()) {
928  IConsoleCmdExec("exec scripts/game_start.scr 0");
929  return;
930  }
931 
932  /* Create a single company */
933  DoStartupNewCompany(false);
934 
937 
938  /* Overwrite color from settings if needed
939  * COLOUR_END corresponds to Random colour */
940  if (_settings_client.gui.starting_colour != COLOUR_END) {
943  _company_colours[c->index] = (Colours)c->colour;
944  }
945 
946  IConsoleCmdExec("exec scripts/game_start.scr 0");
947 
949 
952 
953  /* We are the server, we start a new company (not dedicated),
954  * so set the default password *if* needed. */
957  }
958 
960 
961  CheckEngines();
962  CheckIndustries();
964 }
965 
966 static void MakeNewGame(bool from_heightmap, bool reset_settings)
967 {
968  _game_mode = GM_NORMAL;
969 
970  ResetGRFConfig(true);
971 
972  GenerateWorldSetCallback(&MakeNewGameDone);
974 }
975 
976 static void MakeNewEditorWorldDone()
977 {
979 }
980 
981 static void MakeNewEditorWorld()
982 {
983  _game_mode = GM_EDITOR;
984 
985  ResetGRFConfig(true);
986 
987  GenerateWorldSetCallback(&MakeNewEditorWorldDone);
989 }
990 
1001 bool SafeLoad(const char *filename, SaveLoadOperation fop, DetailedFileType dft, GameMode newgm, Subdirectory subdir, struct LoadFilter *lf = nullptr)
1002 {
1003  assert(fop == SLO_LOAD);
1004  assert(dft == DFT_GAME_FILE || (lf == nullptr && dft == DFT_OLD_GAME_FILE));
1005  GameMode ogm = _game_mode;
1006 
1007  _game_mode = newgm;
1008 
1009  switch (lf == nullptr ? SaveOrLoad(filename, fop, dft, subdir) : LoadWithFilter(lf)) {
1010  case SL_OK: return true;
1011 
1012  case SL_REINIT:
1013  if (_network_dedicated) {
1014  /*
1015  * We need to reinit a network map...
1016  * We can't simply load the intro game here as that game has many
1017  * special cases which make clients desync immediately. So we fall
1018  * back to just generating a new game with the current settings.
1019  */
1020  DEBUG(net, 0, "Loading game failed, so a new (random) game will be started!");
1021  MakeNewGame(false, true);
1022  return false;
1023  }
1024  if (_network_server) {
1025  /* We can't load the intro game as server, so disconnect first. */
1027  }
1028 
1029  switch (ogm) {
1030  default:
1031  case GM_MENU: LoadIntroGame(); break;
1032  case GM_EDITOR: MakeNewEditorWorld(); break;
1033  }
1034  return false;
1035 
1036  default:
1037  _game_mode = ogm;
1038  return false;
1039  }
1040 }
1041 
1042 void SwitchToMode(SwitchMode new_mode)
1043 {
1044  /* If we are saving something, the network stays in his current state */
1045  if (new_mode != SM_SAVE_GAME) {
1046  /* If the network is active, make it not-active */
1047  if (_networking) {
1048  if (_network_server && (new_mode == SM_LOAD_GAME || new_mode == SM_NEWGAME || new_mode == SM_RESTARTGAME)) {
1049  NetworkReboot();
1050  } else {
1052  }
1053  }
1054 
1055  /* If we are a server, we restart the server */
1056  if (_is_network_server) {
1057  /* But not if we are going to the menu */
1058  if (new_mode != SM_MENU) {
1059  /* check if we should reload the config */
1061  LoadFromConfig();
1062  MakeNewgameSettingsLive();
1063  ResetGRFConfig(false);
1064  }
1065  NetworkServerStart();
1066  } else {
1067  /* This client no longer wants to be a network-server */
1068  _is_network_server = false;
1069  }
1070  }
1071  }
1072 
1073  /* Make sure all AI controllers are gone at quitting game */
1074  if (new_mode != SM_SAVE_GAME) AI::KillAll();
1075 
1076  switch (new_mode) {
1077  case SM_EDITOR: // Switch to scenario editor
1078  MakeNewEditorWorld();
1079  break;
1080 
1081  case SM_RESTARTGAME: // Restart --> 'Random game' with current settings
1082  case SM_NEWGAME: // New Game --> 'Random game'
1083  if (_network_server) {
1085  }
1086  MakeNewGame(false, new_mode == SM_NEWGAME);
1087  break;
1088 
1089  case SM_LOAD_GAME: { // Load game, Play Scenario
1090  ResetGRFConfig(true);
1092 
1095  ShowErrorMessage(STR_JUST_RAW_STRING, INVALID_STRING_ID, WL_ERROR);
1096  } else {
1098  /* Reset engine pool to simplify changing engine NewGRFs in scenario editor. */
1100  }
1101  /* Update the local company for a loaded game. It is either always
1102  * company #1 (eg 0) or in the case of a dedicated server a spectator */
1104  /* Execute the game-start script */
1105  IConsoleCmdExec("exec scripts/game_start.scr 0");
1106  /* Decrease pause counter (was increased from opening load dialog) */
1108  if (_network_server) {
1110  }
1111  }
1112  break;
1113  }
1114 
1115  case SM_START_HEIGHTMAP: // Load a heightmap and start a new game from it
1116  if (_network_server) {
1118  }
1119  MakeNewGame(true, true);
1120  break;
1121 
1122  case SM_LOAD_HEIGHTMAP: // Load heightmap from scenario editor
1124 
1127  break;
1128 
1129  case SM_LOAD_SCENARIO: { // Load scenario from scenario editor
1133  /* Cancel the saveload pausing */
1135  } else {
1137  ShowErrorMessage(STR_JUST_RAW_STRING, INVALID_STRING_ID, WL_ERROR);
1138  }
1139  break;
1140  }
1141 
1142  case SM_MENU: // Switch to game intro menu
1143  LoadIntroGame();
1144  if (BaseSounds::ini_set == nullptr && BaseSounds::GetUsedSet()->fallback) {
1145  ShowErrorMessage(STR_WARNING_FALLBACK_SOUNDSET, INVALID_STRING_ID, WL_CRITICAL);
1147  }
1148  break;
1149 
1150  case SM_SAVE_GAME: // Save game.
1151  /* Make network saved games on pause compatible to singleplayer */
1154  ShowErrorMessage(STR_JUST_RAW_STRING, INVALID_STRING_ID, WL_ERROR);
1155  } else {
1157  }
1158  break;
1159 
1160  case SM_SAVE_HEIGHTMAP: // Save heightmap.
1163  break;
1164 
1165  case SM_GENRANDLAND: // Generate random land within scenario editor
1168  /* XXX: set date */
1170  break;
1171 
1172  default: NOT_REACHED();
1173  }
1174 }
1175 
1176 
1183 static void CheckCaches()
1184 {
1185  /* Return here so it is easy to add checks that are run
1186  * always to aid testing of caches. */
1187  if (_debug_desync_level <= 1) return;
1188 
1189  /* Check the town caches. */
1190  std::vector<TownCache> old_town_caches;
1191  for (const Town *t : Town::Iterate()) {
1192  old_town_caches.push_back(t->cache);
1193  }
1194 
1195  extern void RebuildTownCaches();
1198 
1199  uint i = 0;
1200  for (Town *t : Town::Iterate()) {
1201  if (MemCmpT(old_town_caches.data() + i, &t->cache) != 0) {
1202  DEBUG(desync, 2, "town cache mismatch: town %i", (int)t->index);
1203  }
1204  i++;
1205  }
1206 
1207  /* Check company infrastructure cache. */
1208  std::vector<CompanyInfrastructure> old_infrastructure;
1209  for (const Company *c : Company::Iterate()) old_infrastructure.push_back(c->infrastructure);
1210 
1211  extern void AfterLoadCompanyStats();
1213 
1214  i = 0;
1215  for (const Company *c : Company::Iterate()) {
1216  if (MemCmpT(old_infrastructure.data() + i, &c->infrastructure) != 0) {
1217  DEBUG(desync, 2, "infrastructure cache mismatch: company %i", (int)c->index);
1218  }
1219  i++;
1220  }
1221 
1222  /* Strict checking of the road stop cache entries */
1223  for (const RoadStop *rs : RoadStop::Iterate()) {
1224  if (IsStandardRoadStopTile(rs->xy)) continue;
1225 
1226  assert(rs->GetEntry(DIAGDIR_NE) != rs->GetEntry(DIAGDIR_NW));
1227  rs->GetEntry(DIAGDIR_NE)->CheckIntegrity(rs);
1228  rs->GetEntry(DIAGDIR_NW)->CheckIntegrity(rs);
1229  }
1230 
1231  for (Vehicle *v : Vehicle::Iterate()) {
1232  extern void FillNewGRFVehicleCache(const Vehicle *v);
1233  if (v != v->First() || v->vehstatus & VS_CRASHED || !v->IsPrimaryVehicle()) continue;
1234 
1235  uint length = 0;
1236  for (const Vehicle *u = v; u != nullptr; u = u->Next()) length++;
1237 
1238  NewGRFCache *grf_cache = CallocT<NewGRFCache>(length);
1239  VehicleCache *veh_cache = CallocT<VehicleCache>(length);
1240  GroundVehicleCache *gro_cache = CallocT<GroundVehicleCache>(length);
1241  TrainCache *tra_cache = CallocT<TrainCache>(length);
1242 
1243  length = 0;
1244  for (const Vehicle *u = v; u != nullptr; u = u->Next()) {
1246  grf_cache[length] = u->grf_cache;
1247  veh_cache[length] = u->vcache;
1248  switch (u->type) {
1249  case VEH_TRAIN:
1250  gro_cache[length] = Train::From(u)->gcache;
1251  tra_cache[length] = Train::From(u)->tcache;
1252  break;
1253  case VEH_ROAD:
1254  gro_cache[length] = RoadVehicle::From(u)->gcache;
1255  break;
1256  default:
1257  break;
1258  }
1259  length++;
1260  }
1261 
1262  switch (v->type) {
1263  case VEH_TRAIN: Train::From(v)->ConsistChanged(CCF_TRACK); break;
1266  case VEH_SHIP: Ship::From(v)->UpdateCache(); break;
1267  default: break;
1268  }
1269 
1270  length = 0;
1271  for (const Vehicle *u = v; u != nullptr; u = u->Next()) {
1273  if (memcmp(&grf_cache[length], &u->grf_cache, sizeof(NewGRFCache)) != 0) {
1274  DEBUG(desync, 2, "newgrf cache mismatch: type %i, vehicle %i, company %i, unit number %i, wagon %i", (int)v->type, v->index, (int)v->owner, v->unitnumber, length);
1275  }
1276  if (memcmp(&veh_cache[length], &u->vcache, sizeof(VehicleCache)) != 0) {
1277  DEBUG(desync, 2, "vehicle cache mismatch: type %i, vehicle %i, company %i, unit number %i, wagon %i", (int)v->type, v->index, (int)v->owner, v->unitnumber, length);
1278  }
1279  switch (u->type) {
1280  case VEH_TRAIN:
1281  if (memcmp(&gro_cache[length], &Train::From(u)->gcache, sizeof(GroundVehicleCache)) != 0) {
1282  DEBUG(desync, 2, "train ground vehicle cache mismatch: vehicle %i, company %i, unit number %i, wagon %i", v->index, (int)v->owner, v->unitnumber, length);
1283  }
1284  if (memcmp(&tra_cache[length], &Train::From(u)->tcache, sizeof(TrainCache)) != 0) {
1285  DEBUG(desync, 2, "train cache mismatch: vehicle %i, company %i, unit number %i, wagon %i", v->index, (int)v->owner, v->unitnumber, length);
1286  }
1287  break;
1288  case VEH_ROAD:
1289  if (memcmp(&gro_cache[length], &RoadVehicle::From(u)->gcache, sizeof(GroundVehicleCache)) != 0) {
1290  DEBUG(desync, 2, "road vehicle ground vehicle cache mismatch: vehicle %i, company %i, unit number %i, wagon %i", v->index, (int)v->owner, v->unitnumber, length);
1291  }
1292  break;
1293  default:
1294  break;
1295  }
1296  length++;
1297  }
1298 
1299  free(grf_cache);
1300  free(veh_cache);
1301  free(gro_cache);
1302  free(tra_cache);
1303  }
1304 
1305  /* Check whether the caches are still valid */
1306  for (Vehicle *v : Vehicle::Iterate()) {
1307  byte buff[sizeof(VehicleCargoList)];
1308  memcpy(buff, &v->cargo, sizeof(VehicleCargoList));
1309  v->cargo.InvalidateCache();
1310  assert(memcmp(&v->cargo, buff, sizeof(VehicleCargoList)) == 0);
1311  }
1312 
1313  for (Station *st : Station::Iterate()) {
1314  for (CargoID c = 0; c < NUM_CARGO; c++) {
1315  byte buff[sizeof(StationCargoList)];
1316  memcpy(buff, &st->goods[c].cargo, sizeof(StationCargoList));
1317  st->goods[c].cargo.InvalidateCache();
1318  assert(memcmp(&st->goods[c].cargo, buff, sizeof(StationCargoList)) == 0);
1319  }
1320  }
1321 }
1322 
1329 {
1330  /* don't execute the state loop during pause */
1331  if (_pause_mode != PM_UNPAUSED) {
1339 
1341 #ifndef DEBUG_DUMP_COMMANDS
1342  Game::GameLoop();
1343 #endif
1344  return;
1345  }
1346 
1347  PerformanceMeasurer framerate(PFE_GAMELOOP);
1349  if (HasModalProgress()) return;
1350 
1352 
1353  if (_game_mode == GM_EDITOR) {
1355  RunTileLoop();
1356  CallVehicleTicks();
1357  CallLandscapeTick();
1360 
1362  NewsLoop();
1363  } else {
1364  if (_debug_desync_level > 2 && _date_fract == 0 && (_date & 0x1F) == 0) {
1365  /* Save the desync savegame if needed. */
1366  char name[MAX_PATH];
1367  seprintf(name, lastof(name), "dmp_cmds_%08x_%08x.sav", _settings_game.game_creation.generation_seed, _date);
1369  }
1370 
1371  CheckCaches();
1372 
1373  /* All these actions has to be done from OWNER_NONE
1374  * for multiplayer compatibility */
1375  Backup<CompanyID> cur_company(_current_company, OWNER_NONE, FILE_LINE);
1376 
1379  IncreaseDate();
1380  RunTileLoop();
1381  CallVehicleTicks();
1382  CallLandscapeTick();
1384 
1385 #ifndef DEBUG_DUMP_COMMANDS
1386  {
1388  AI::GameLoop();
1389  Game::GameLoop();
1390  }
1391 #endif
1393 
1395  NewsLoop();
1396  cur_company.Restore();
1397  }
1398 
1399  assert(IsLocalCompany());
1400 }
1401 
1406 static void DoAutosave()
1407 {
1408  char buf[MAX_PATH];
1409 
1411  GenerateDefaultSaveName(buf, lastof(buf));
1412  strecat(buf, ".sav", lastof(buf));
1413  } else {
1414  static int _autosave_ctr = 0;
1415 
1416  /* generate a savegame name and number according to _settings_client.gui.max_num_autosaves */
1417  seprintf(buf, lastof(buf), "autosave%d.sav", _autosave_ctr);
1418 
1419  if (++_autosave_ctr >= _settings_client.gui.max_num_autosaves) _autosave_ctr = 0;
1420  }
1421 
1422  DEBUG(sl, 2, "Autosaving to '%s'", buf);
1424  ShowErrorMessage(STR_ERROR_AUTOSAVE_FAILED, INVALID_STRING_ID, WL_ERROR);
1425  }
1426 }
1427 
1428 void GameLoop()
1429 {
1430  if (_game_mode == GM_BOOTSTRAP) {
1431  /* Check for UDP stuff */
1433  InputLoop();
1434  return;
1435  }
1436 
1438 
1439  /* autosave game? */
1440  if (_do_autosave) {
1441  DoAutosave();
1442  _do_autosave = false;
1444  }
1445 
1446  /* switch game mode? */
1447  if (_switch_mode != SM_NONE && !HasModalProgress()) {
1448  SwitchToMode(_switch_mode);
1449  _switch_mode = SM_NONE;
1450  }
1451 
1452  IncreaseSpriteLRU();
1453  InteractiveRandom();
1454 
1455  /* Check for UDP stuff */
1457 
1458  if (_networking && !HasModalProgress()) {
1459  /* Multiplayer */
1460  NetworkGameLoop();
1461  } else {
1462  if (_network_reconnect > 0 && --_network_reconnect == 0) {
1463  /* This means that we want to reconnect to the last host
1464  * We do this here, because it means that the network is really closed */
1466  }
1467  /* Singleplayer */
1468  StateGameLoop();
1469  }
1470 
1471  if (!_pause_mode && HasBit(_display_opt, DO_FULL_ANIMATION)) DoPaletteAnimations();
1472 
1473  InputLoop();
1474 
1476  MusicLoop();
1477 }
bool disable_elrails
when true, the elrails are disabled
FiosType
Elements of a file system that are recognized.
Definition: fileio_type.h:67
void SetupColoursAndInitialWindow()
Initialise the default colours (remaps and the likes), and load the main windows. ...
Definition: main_gui.cpp:552
Functions related to OTTD&#39;s strings.
void UpdateLandscapingLimits()
Update the landscaping limits per company.
Owner
Enum for all companies/owners.
Definition: company_type.h:18
char * _ini_videodriver
The video driver a stored in the configuration file.
Definition: driver.cpp:19
Road vehicle states.
All pool types.
Definition: pool_type.hpp:24
VehicleSettings vehicle
options for vehicles
Cached often queried (NewGRF) values.
Definition: vehicle_base.h:65
static bool IsLocalCompany()
Is the current company the local company?
Definition: company_func.h:43
Time spent processing cargo movement.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:79
void CheckForMissingGlyphs(bool base_font, MissingGlyphSearcher *searcher)
Check whether the currently loaded language pack uses characters that the currently loaded font does ...
Definition: strings.cpp:2097
void ParseConnectionString(const char **company, const char **port, char *connection_string)
Converts a string to ip/port/company Format: IP:port::company.
Definition: network.cpp:460
bool _networking
are we in networking mode?
Definition: network.cpp:52
Base of all video drivers.
void InitializeScreenshotFormats()
Initialize screenshot format information on startup, with _screenshot_format_name filled from the loa...
Definition: screenshot.cpp:577
#define GETOPT_SHORT_OPTVAL(shortname)
Short option with optional value.
Definition: getoptdata.h:104
void CheckEngines()
Check for engines that have an appropriate availability.
Definition: engine.cpp:1129
Scan for base sets.
Definition: fileio_func.h:98
Company * DoStartupNewCompany(bool is_ai, CompanyID company=INVALID_COMPANY)
Create a new company and sets all company variables default values.
bool _blitter_autodetected
Was the blitter autodetected or specified by the user?
Definition: driver.cpp:29
FiosType FiosGetSavegameListCallback(SaveLoadOperation fop, const char *file, const char *ext, char *title, const char *last)
Callback for FiosGetFileList.
Definition: fios.cpp:459
virtual void MainLoop()
Called once every tick.
bool HandleBootstrap()
Handle all procedures for bootstrapping OpenTTD without a base graphics set.
FILE * _log_fd
File to reroute output of a forked OpenTTD to.
Definition: dedicated.cpp:13
#define GETOPT_SHORT_VALUE(shortname)
Short option with value.
Definition: getoptdata.h:97
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition: window.cpp:3215
static int MemCmpT(const T *ptr1, const T *ptr2, size_t num=1)
Type-safe version of memcmp().
Definition: mem_func.hpp:63
int openttd_main(int argc, char *argv[])
Main entry point for this lovely game.
Definition: openttd.cpp:533
static char * strecat(char *dst, const char *src, const char *last)
Appends characters from one string to another.
Definition: depend.cpp:97
void SetDParamStr(uint n, const char *str)
Set a rawstring parameter.
Definition: error_gui.cpp:160
Base class for roadstops.
Subdirectory
The different kinds of subdirectories OpenTTD uses.
Definition: fileio_type.h:108
bool keep_all_autosave
name the autosave in a different way
uint16 last_port
port of the last joined server
Load heightmap from scenario editor.
Definition: openttd.h:36
#define GETOPT_SHORT_NOVAL(shortname)
Short option without value.
Definition: getoptdata.h:91
void GenerateDefaultSaveName(char *buf, const char *last)
Fill the buffer with the default name for a savegame or screenshot.
Definition: saveload.cpp:2812
static void GameLoop()
Called every game-tick to let Game do something.
Definition: game_core.cpp:31
Saveload window; Window numbers:
Definition: window_type.h:137
SaveLoadVersion
SaveLoad versions Previous savegame versions, the trunk revision where they were introduced and the r...
Definition: saveload.h:29
GameConfig stores the configuration settings of every Game.
byte _display_opt
What do we want to draw/do?
void AfterLoadCompanyStats()
Rebuilding of company statistics after loading a savegame.
Definition: company_sl.cpp:94
Train vehicle type.
Definition: vehicle_type.h:24
CargoList that is used for stations.
Definition: cargopacket.h:448
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:291
struct LoggedAction * gamelog_action
Gamelog actions.
Definition: fios.h:46
Switch to game intro menu.
Definition: openttd.h:30
void SetName(const char *name)
Set the name of the file.
Definition: saveload.cpp:2874
static uint FindSets()
Do the scan for files.
Hotkey related functions.
Functions related to dates.
Northwest.
Generate a map for a new game.
Definition: genworld.h:28
int CDECL seprintf(char *str, const char *last, const char *format,...)
Safer implementation of snprintf; same as snprintf except:
Definition: string.cpp:407
Load game, Play Scenario.
Definition: openttd.h:29
static const OptionData _options[]
Options of OpenTTD.
Definition: openttd.cpp:498
Base for the train class.
bool pause_on_newgame
whether to start new games paused or not
Functions/types related to the road GUIs.
Ship vehicle type.
Definition: vehicle_type.h:26
bool * save_config_ptr
The pointer to the save config setting.
Definition: openttd.cpp:397
static char * GetConsoleList(char *p, const char *last, bool newest_only=false)
Wrapper function for AIScanner::GetAIConsoleList.
Definition: ai_core.cpp:318
Maximal number of cargo types in a game.
Definition: cargo_type.h:64
Functions to be called to log possibly unsafe game events.
Types for recording game performance data.
Generic functions for replacing base data (graphics, sounds).
FileToSaveLoad _file_to_saveload
File to save or load in the openttd loop.
Definition: saveload.cpp:58
void InitWindowSystem()
(re)initialize the windowing system
Definition: window.cpp:1893
static void Paused(PerformanceElement elem)
Indicate that a cycle of "pause" where no processing occurs.
static void Uninitialize(bool keepConfig)
Uninitialize the Game system.
Definition: game_core.cpp:97
void RebuildTownCaches()
Rebuild all the cached variables of towns.
Definition: town_sl.cpp:25
int CDECL vseprintf(char *str, const char *last, const char *format, va_list ap)
Safer implementation of vsnprintf; same as vsnprintf except:
Definition: string.cpp:60
The client wants a new company.
Definition: company_type.h:34
Functions related to vehicles.
char * md5sumToString(char *buf, const char *last, const uint8 md5sum[16])
Convert the md5sum to a hexadecimal string representation.
Definition: string.cpp:425
SaveLoadVersion _sl_version
the major savegame version identifier
Definition: saveload.cpp:61
static void ShutdownDrivers()
Shuts down all active drivers.
Definition: driver.h:113
char title[255]
Internal name of the game.
Definition: saveload.h:321
MusicSettings music
settings related to music/sound
Base for all sound drivers.
static void Initialize()
Initialize the AI system.
Definition: ai_core.cpp:161
Vehicle data structure.
Definition: vehicle_base.h:210
void Change(const char *name, int version=-1, bool force_exact_match=false, bool is_random=false)
Set another Script to be loaded in this slot.
GRFConfig * grfconfig
NewGrf configuration from save.
Definition: fios.h:43
void FioCloseAll()
Close all slotted open files.
Definition: fileio.cpp:211
static const Year INVALID_YEAR
Representation of an invalid year.
Definition: date_type.h:107
Wrapper for (un)resolved network addresses; there&#39;s no reason to transform a numeric IP to a string a...
Definition: address.h:27
Generate a newgame from a heightmap.
Definition: genworld.h:31
static void Clean(PoolType)
Clean all pools of given type.
Definition: pool_func.cpp:30
Tindex index
Index of this pool item.
Definition: pool_type.hpp:189
void NetworkStartUp()
This tries to launch the network for a given OS.
Definition: network.cpp:1050
void ShowErrorMessage(StringID summary_msg, StringID detailed_msg, WarningLevel wl, int x=0, int y=0, const GRFFile *textref_stack_grffile=nullptr, uint textref_stack_size=0, const uint32 *textref_stack=nullptr)
Display an error message in a window.
Definition: error_gui.cpp:380
Cached often queried values common to all vehicles.
Definition: vehicle_base.h:120
Dimension _cur_resolution
The current resolution.
Definition: driver.cpp:21
uint16 dedicated_port
Port for the dedicated server.
Definition: openttd.cpp:393
Data of an option.
Definition: getoptdata.h:22
void DoExitSave()
Do a save when exiting the game (_settings_client.gui.autosave_on_exit)
Definition: saveload.cpp:2802
Base for aircraft.
#define lastof(x)
Get the last element of an fixed size array.
Definition: depend.cpp:48
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
Functions related to world/map generation.
static char * GetDriversInfo(char *p, const char *last)
Build a human readable list of available drivers, grouped by type.
Definition: driver.cpp:188
Functions to make screenshots.
bool UpdateNewGRFConfigPalette(int32 p1)
Update the palettes of the graphics from the config file.
bool reload_cfg
reload the config file before restarting
static bool SetSet(const char *name)
Set the set to be used.
static bool IsStandardRoadStopTile(TileIndex t)
Is tile t a standard (non-drive through) road stop station?
Definition: station_map.h:223
void SaveToConfig()
Save the values to the configuration file.
Definition: settings.cpp:1742
Base set has 8 bpp sprites only.
int32 Year
Type for the year, note: 0 based, i.e. starts at the year 0.
Definition: date_type.h:18
uint8 map_x
X size of map.
RAII class for measuring simple elements of performance.
Subdirectory for all base data (base sets, intro game)
Definition: fileio_type.h:116
static T max(const T a, const T b)
Returns the maximum of two values.
Definition: math_func.hpp:24
uint32 last_newgrf_count
the numbers of NewGRFs we found during the last scan
Functions related to laying out the texts.
byte vehstatus
Status.
Definition: vehicle_base.h:315
Year _cur_year
Current year, starting at 0.
Definition: date.cpp:24
Cached, frequently calculated values.
Time spent processing aircraft.
static void Reset(PerformanceElement elem)
Store the previous accumulator value and reset for a new cycle of accumulating measurements.
static Train * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
void InputLoop()
Regular call from the global game loop.
Definition: window.cpp:3084
CompanySettings settings
settings specific for each company
Definition: company_base.h:127
const char * GetSaveLoadErrorString()
Get the string representation of the error message.
Definition: saveload.cpp:2430
File is being saved.
Definition: fileio_type.h:50
struct GRFConfig * next
NOSAVE: Next item in the linked list.
Speed of gameloop processing.
Functions/types etc.
Load file for checking and/or preview.
Definition: fileio_type.h:48
static const uint32 GENERATE_NEW_SEED
Create a new random seed.
Definition: genworld.h:24
static uint ClampU(const uint a, const uint min, const uint max)
Clamp an unsigned integer between an interval.
Definition: math_func.hpp:182
bool _network_available
is network mode available?
Definition: network.cpp:54
Variables that are cached to improve performance and such.
Definition: train.h:69
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:55
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:21
static char * GetConsoleList(char *p, const char *last, bool newest_only=false)
Wrapper function for GameScanner::GetConsoleList.
Definition: game_core.cpp:228
static void CheckCaches()
Check the validity of some of the caches.
Definition: openttd.cpp:1183
Functions related to (drawing on) viewports.
Pseudo random number generator.
uint8 map_y
Y size of map.
void InitFreeType(bool monospace)
(Re)initialize the freetype related things, i.e.
Definition: fontcache.cpp:1034
Library for parsing command-line options.
std::mutex _modal_progress_work_mutex
Rights for the performing work.
Definition: progress.cpp:21
void ProcessAsyncSaveFinish()
Handle async save finishes.
Definition: saveload.cpp:398
void CDECL ShowInfoF(const char *str,...)
Shows some information on the console/a popup box depending on the OS.
Definition: openttd.cpp:134
Save game or scenario file.
Definition: fileio_type.h:31
Interface for filtering a savegame till it is loaded.
old or new savegame
Definition: fileio_type.h:18
old or new scenario
Definition: fileio_type.h:19
Functions to read fonts from files and cache them.
Critical errors, the MessageBox is shown in all cases.
Definition: error.h:24
void SetDParamStr(uint n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
Definition: strings.cpp:279
LoadCheckData _load_check_data
Data loaded from save during SL_LOAD_CHECK.
Definition: fios_gui.cpp:38
Tile animation!
static char * GetBlittersInfo(char *p, const char *last)
Fill a buffer with information about the blitters.
Definition: factory.hpp:156
Callback structure of statements to be executed after the NewGRF scan.
Definition: openttd.cpp:389
void GamelogInfo(LoggedAction *gamelog_action, uint gamelog_actions, uint32 *last_ottd_rev, byte *ever_modified, bool *removed_newgrfs)
Get some basic information from the given gamelog.
Definition: gamelog.cpp:801
NetworkSettings network
settings related to the network
Vehicle is crashed.
Definition: vehicle_base.h:37
bool _is_network_server
Does this client wants to be a network-server?
Definition: network.cpp:56
The tile has no ownership.
Definition: company_type.h:25
void UpdateCache()
Update the caches of this ship.
Definition: ship_cmd.cpp:202
void GamelogReset()
Resets and frees all memory allocated - used before loading or starting a new game.
Definition: gamelog.cpp:110
Functions/types related to saving and loading games.
virtual bool IsPrimaryVehicle() const
Whether this is the primary vehicle in the chain.
Definition: vehicle_base.h:431
void MusicLoop()
Check music playback status and start/stop/song-finished.
Definition: music_gui.cpp:424
void GenerateWorld(GenWorldMode mode, uint size_x, uint size_y, bool reset_settings)
Generate a world.
Definition: genworld.cpp:301
A music driver, needs to be before sound to properly shut down extmidi forked music players...
Definition: driver.h:41
Functions related to errors.
Load a heightmap and start a new game from it.
Definition: openttd.h:35
char * _ini_blitter
The blitter as stored in the configuration file.
Definition: driver.cpp:28
UnitID unitnumber
unit number, for display purposes only
Definition: vehicle_base.h:289
virtual void SetVolume(byte vol)=0
Set the volume, if possible.
Switch to scenario editor.
Definition: openttd.h:28
DateFract _date_fract
Fractional part of the day.
Definition: date.cpp:27
static void GameLoop()
Called every game-tick to let AIs do something.
Definition: ai_core.cpp:67
SaveOrLoadResult
Save or load result codes.
Definition: saveload.h:309
static void ShowHelp()
Show the help message when someone passed a wrong parameter.
Definition: openttd.cpp:147
void UpdateAircraftCache(Aircraft *v, bool update_range=false)
Update cached values of an aircraft.
A normal unpaused game.
Definition: openttd.h:56
The client is spectating.
Definition: company_type.h:35
virtual void Stop()=0
Stop this driver.
CompanySettings company
default values for per-company settings
Information about GRF, used in the game and (part of it) in savegames.
char * _ini_sounddriver
The sound driver a stored in the configuration file.
Definition: driver.cpp:24
void ConsistChanged(ConsistChangeFlags allowed_changes)
Recalculates the cached stuff of a train.
Definition: train_cmd.cpp:106
GameMode
Mode which defines the state of the game.
Definition: openttd.h:16
Old save game or scenario file.
Definition: fileio_type.h:30
VehicleDefaultSettings vehicle
default settings for vehicles
Functions related to engines.
static void SwitchMode(PersistentStorageMode mode, bool ignore_prev_mode=false)
Clear temporary changes made since the last call to SwitchMode, and set whether subsequent changes sh...
static void Uninitialize(bool keepConfig)
Uninitialize the AI system.
Definition: ai_core.cpp:175
static Blitter * SelectBlitter(const char *name)
Find the requested blitter and return his class.
Definition: factory.hpp:94
A game paused for saving/loading.
Definition: openttd.h:58
Time spend processing road vehicles.
void InitializeRoadGUI()
I really don&#39;t know why rail_gui.cpp has this too, shouldn&#39;t be included in the other one...
Definition: road_gui.cpp:1261
void IConsoleCmdExec(const char *cmdstr)
Execute a given command passed to us.
Definition: console.cpp:401
Functions related to setting/changing the settings.
static const uint16 NETWORK_DEFAULT_DEBUGLOG_PORT
The default port debug-log is sent to (TCP)
Definition: config.h:31
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:78
Functions related to modal progress.
A path without any base directory.
Definition: fileio_type.h:125
virtual void OnNewGRFsScanned()
Called whenever the NewGRF scan completed.
Definition: openttd.cpp:416
Base for all music playback.
Definition of base types and functions in a cross-platform compatible way.
Enter the gameloop, changes will be permanent.
char * _config_file
Configuration file of OpenTTD.
Definition: settings.cpp:82
void Clear()
Reset read data.
Definition: fios_gui.cpp:47
void CDECL usererror(const char *s,...)
Error handling for fatal user errors.
Definition: openttd.cpp:92
A number of safeguards to prevent using unsafe methods.
void StateGameLoop()
State controlling game loop.
Definition: openttd.cpp:1328
void SetLocalCompany(CompanyID new_company)
Sets the local company and updates the settings that are set on a per-company basis to reflect the co...
Declaration of link graph schedule used for cargo distribution.
GameSettings _settings_newgame
Game settings for new games (updated from the intro screen).
Definition: settings.cpp:80
static void SaveToConfig()
Save all WindowDesc settings to _windows_file.
Definition: window.cpp:164
uint8 _network_reconnect
Reconnect timeout.
Definition: network.cpp:62
void FillNewGRFVehicleCache(const Vehicle *v)
Fill the grf_cache of the given vehicle.
Scan for scenarios and heightmaps.
Definition: fileio_func.h:101
Base directory for all savegames.
Definition: fileio_type.h:110
Subdirectory of save for autosaves.
Definition: fileio_type.h:111
const char * join_server_password
The password to join the server with.
Definition: openttd.cpp:395
byte starting_colour
default color scheme for the company to start a new game with
static AIConfig * GetConfig(CompanyID company, ScriptSettingSource source=SSS_DEFAULT)
Get the config of a company.
Definition: ai_config.cpp:45
char * stredup(const char *s, const char *last)
Create a duplicate of the given string.
Definition: string.cpp:136
AfterNewGRFScan(bool *save_config_ptr)
Create a new callback.
Definition: openttd.cpp:405
void LoadFromConfig(bool minimal)
Load the values from the configuration files.
Definition: settings.cpp:1712
Console functions used outside of the console code.
char * error_data
Data to pass to SetDParamStr when displaying error.
Definition: fios.h:34
#define GETOPT_END()
Option terminator.
Definition: getoptdata.h:107
void ScheduleErrorMessage(const ErrorMessageData &data)
Schedule an error.
Definition: error_gui.cpp:442
char * DumpDebugFacilityNames(char *buf, char *last)
Dump the available debug facility names in the help text.
Definition: debug.cpp:84
A sound driver.
Definition: driver.h:42
static void ShutdownGame()
Uninitializes drivers, frees allocated memory, cleans pools, ...
Definition: openttd.cpp:285
bool fix_at
mouse is moving, but cursor is not (used for scrolling)
Definition: gfx_type.h:120
SaveOrLoadResult LoadWithFilter(LoadFilter *reader)
Load the game using a (reader) filter.
Definition: saveload.cpp:2697
const char * join_company_password
The password to join the company with.
Definition: openttd.cpp:396
bool HasErrors()
Check whether loading the game resulted in errors.
Definition: fios.h:67
bool autosave_on_exit
save an autosave when you quit the game, but do not ask "Do you really want to quit?"
A game normally paused.
Definition: openttd.h:57
void CheckIndustries()
Verify whether the generated industries are complete, and warn the user if not.
Generate an empty map (sea-level)
Definition: genworld.h:29
static MusicDriver * GetInstance()
Get the currently active instance of the music driver.
char * opt
Option value, if available (else nullptr).
Definition: getoptdata.h:31
Basic functions/variables used all over the place.
Time spent processing other world features.
SaveOrLoadResult SaveOrLoad(const char *filename, SaveLoadOperation fop, DetailedFileType dft, Subdirectory sb, bool threaded)
Main Save or Load function where the high-level saveload functions are handled.
Definition: saveload.cpp:2717
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:271
void NetworkShutDown()
This shuts the network down.
Definition: network.cpp:1071
bool DoCommandP(const CommandContainer *container, bool my_cmd)
Shortcut for the long DoCommandP when having a container with the data.
Definition: command.cpp:532
NetworkServerGameInfo _network_game_info
Information about our game.
Definition: network.cpp:57
bool save_config
The save config setting.
Definition: openttd.cpp:398
File is being loaded.
Definition: fileio_type.h:49
PauseMode _pause_mode
The current pause mode.
Definition: gfx.cpp:47
void InitializeLanguagePacks()
Make a list of the available language packs.
Definition: strings.cpp:1949
bool _use_threaded_modal_progress
Threading usable for modal progress?
Definition: progress.cpp:19
StringID error
Error message from loading. INVALID_STRING_ID if no error.
Definition: fios.h:33
Vehicle * First() const
Get the first vehicle of this vehicle chain.
Definition: vehicle_base.h:592
void WaitTillGeneratedWorld()
This will wait for the thread to finish up his work.
Definition: genworld.cpp:247
SaveLoadOperation
Operation performed on the file.
Definition: fileio_type.h:47
void CallWindowGameTickEvent()
Dispatch OnGameTick event over all windows.
Definition: window.cpp:3348
void UnInitWindowSystem()
Close down the windowing system.
Definition: window.cpp:1914
class GameConfig * game_config
settings for gamescript
Save game.
Definition: openttd.h:31
Functions to be called to log a crash.
char * dedicated_host
Hostname for the dedicated server.
Definition: openttd.cpp:392
uint DoScan(Subdirectory sd)
Perform the scanning of a particular subdirectory.
Definition: fileio.cpp:608
StringID name
The name for this object.
Definition: newgrf_object.h:62
#define DEBUG(name, level,...)
Output a line of debugging information.
Definition: debug.h:35
static void Initialize()
Initialize the Game system.
Definition: game_core.cpp:57
char map_name[NETWORK_NAME_LENGTH]
Map which is played ["random" for a randomized map].
Definition: game.h:25
uint16 server_port
port the server listens on
static SoundDriver * GetInstance()
Get the currently active instance of the sound driver.
void DeleteWindowById(WindowClass cls, WindowNumber number, bool force)
Delete a window by its class and window number (if it is open).
Definition: window.cpp:1162
void GenerateWorldSetCallback(GWDoneProc *proc)
Set here the function, if any, that you want to be called when landscape generation is done...
Definition: genworld.cpp:228
Callback for NewGRF scanning.
byte music_vol
The requested music volume.
void IncreaseDate()
Increases the tick counter, increases date and possibly calls procedures that have to be called daily...
Definition: date.cpp:262
void LoadHotkeysFromConfig()
Load the hotkeys from the config file.
Definition: hotkeys.cpp:331
Functions related to companies.
No support for 8bpp by OS or hardware, force 32bpp blitters.
Definition: gfx_type.h:316
An invalid company.
Definition: company_type.h:30
static const uint16 NETWORK_DEFAULT_PORT
The default port of the game server (TCP & UDP)
Definition: config.h:29
The data of the error message.
Definition: error.h:28
Leave the gameloop, changes will be temporary.
uint32 generation_seed
noise seed for world generation
Declaration of functions and types defined in highscore.h and highscore_gui.h.
Data storage for parsing command line options.
Definition: getoptdata.h:30
GUISettings gui
settings related to the GUI
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:340
static bool ResetToCurrentNewGRFConfig()
Tries to reset the engine mapping to match the current NewGRF configuration.
Definition: engine.cpp:527
CargoList that is used for vehicles.
Definition: cargopacket.h:268
Time spent processing ships.
void DeterminePaths(const char *exe)
Acquire the base paths (personal dir and game data dir), fill all other paths (save dir...
Definition: fileio.cpp:1125
static void DoAutosave()
Create an autosave.
Definition: openttd.cpp:1406
void RoadVehUpdateCache(RoadVehicle *v, bool same_length=false)
Update the cache of a road vehicle.
static bool StrEmpty(const char *s)
Check if a string buffer is empty.
Definition: string_func.h:57
static void SelectDriver(const char *name, Driver::Type type)
Find the requested driver and return its class.
Definition: driver.cpp:85
void ResetNewGRFData()
Reset all NewGRF loaded data.
Definition: newgrf.cpp:8546
Declarations for savegames operations.
Vehicle * Next() const
Get the next vehicle of this vehicle.
Definition: vehicle_base.h:579
First company, same as owner.
Definition: company_type.h:22
static VideoDriver * GetInstance()
Get the currently active instance of the video driver.
byte colour
Company colour.
Definition: company_base.h:69
static void KillAll()
Kill any and all AIs we manage.
Definition: ai_core.cpp:151
static void LoadFromConfig()
Load all WindowDesc settings from _windows_file.
Definition: window.cpp:141
Restart –> &#39;Random game&#39; with current settings.
Definition: openttd.h:27
void CDECL error(const char *s,...)
Error handling for fatal non-user errors.
Definition: openttd.cpp:112
static char * GetSetsList(char *p, const char *last)
Returns a list with the sets.
void ResetGRFConfig(bool defaults)
Reset the current GRF Config to either blank or newgame settings.
char * network_conn
Information about the server to connect to, or nullptr.
Definition: openttd.cpp:394
void RebuildSubsidisedSourceAndDestinationCache()
Perform a full rebuild of the subsidies cache.
Definition: subsidy.cpp:131
static void Clear()
Clear all link graphs and jobs from the schedule.
virtual void MainLoop()=0
Perform the actual drawing.
char * strecpy(char *dst, const char *src, const char *last)
Copies characters from one buffer to another.
Definition: depend.cpp:66
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:52
VehicleDefaultSettings _old_vds
Used for loading default vehicles settings from old savegames.
Definition: settings.cpp:81
Maximum number of companies.
Definition: company_type.h:23
Town data structure.
Definition: town.h:53
bool in_window
mouse inside this window, determines drawing logic
Definition: gfx_type.h:141
SwitchMode _switch_mode
The next mainloop command.
Definition: gfx.cpp:46
char default_company_pass[NETWORK_PASSWORD_LENGTH]
default password for new companies in encrypted form
uint gamelog_actions
Number of gamelog actions.
Definition: fios.h:47
The normal zoom level.
Definition: zoom_type.h:22
void ScanNewGRFFiles(NewGRFScanCallback *callback)
Scan for all NewGRFs.
Statusbar (at the bottom of your screen); Window numbers:
Definition: window_type.h:57
Base functions for all Games.
Functions related to commands.
Network functions used by other parts of OpenTTD.
char name[MAX_PATH]
Name of the file.
Definition: saveload.h:320
bool _network_server
network-server is active
Definition: network.cpp:53
SaveLoadOperation file_op
File operation to perform.
Definition: saveload.h:317
A Stop for a Road Vehicle.
Definition: roadstop_base.h:22
static void ReduceLineCache()
Reduce the size of linecache if necessary to prevent infinite growth.
Definition: gfx_layout.cpp:906
void SaveHotkeysToConfig()
Save the hotkeys to the config file.
Definition: hotkeys.cpp:337
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:45
void UninitFreeType()
Free everything allocated w.r.t.
Definition: fontcache.cpp:1053
void InitializeRailGUI()
Resets the rail GUI - sets default railtype to build and resets the signal GUI.
Definition: rail_gui.cpp:1979
Perform palette animation.
Definition: openttd.h:44
static void LoadIntroGame(bool load_newgrfs=true)
Load the introduction game.
Definition: openttd.cpp:320
class AIConfig * ai_config[MAX_COMPANIES]
settings per company
Colours _company_colours[MAX_COMPANIES]
NOSAVE: can be determined from company structs.
Definition: company_cmd.cpp:46
void NetworkBackgroundLoop()
We have to do some (simple) background stuff that runs normally, even when we are not in multiplayer...
Definition: network.cpp:836
AbstractFileType abstract_ftype
Abstract type of file (scenario, heightmap, etc).
Definition: saveload.h:319
byte max_num_autosaves
controls how many autosavegames are made before the game starts to overwrite (names them 0 to max_num...
bool SafeLoad(const char *filename, SaveLoadOperation fop, DetailedFileType dft, GameMode newgm, Subdirectory subdir, struct LoadFilter *lf=nullptr)
Load the specified savegame but on error do different things.
Definition: openttd.cpp:1001
header file for electrified rail specific functions
A video driver.
Definition: driver.h:43
int GetOpt()
Find the next option.
Definition: getoptdata.cpp:22
Base for ships.
void NetworkDisconnect(bool blocking, bool close_admins)
We want to disconnect from the host/clients.
Definition: network.cpp:780
Load scenario from scenario editor.
Definition: openttd.h:34
uint32 generation_seed
Seed for the new game.
Definition: openttd.cpp:391
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Definition: strings_type.h:17
Aircraft vehicle type.
Definition: vehicle_type.h:27
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: depend.cpp:129
static void ParseResolution(Dimension *res, const char *s)
Extract the resolution from the given string and store it in the &#39;res&#39; parameter. ...
Definition: openttd.cpp:268
char last_host[NETWORK_HOSTNAME_LENGTH]
IP address of the last joined server.
declaration of OTTD revision dependent variables
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
bool HasNewGrfs()
Check whether the game uses any NewGrfs.
Definition: fios.h:76
completed successfully
Definition: saveload.h:310
void InitializeSpriteSorter()
Choose the "best" sprite sorter and set _vp_sprite_sorter.
Definition: viewport.cpp:3385
Types related to sprite sorting.
void Restore()
Restore the variable.
Base functions for all AIs.
char * _ini_musicdriver
The music driver a stored in the configuration file.
Definition: driver.cpp:26
Base of the town class.
std::mutex _modal_progress_paint_mutex
Rights for the painting.
Definition: progress.cpp:23
Northeast, upper right on your monitor.
void RunTileLoop()
Gradually iterate over all tiles on the map, calling their TileLoopProcs once every 256 ticks...
Definition: landscape.cpp:801
GRF file does not exactly match the requested GRF (different MD5SUM), but grfid matches) ...
Definition: newgrf_config.h:25
GameCreationSettings game_creation
settings used during the creation of a game (map)
void SetMode(FiosType ft)
Set the mode and file type of the file to save or load based on the type of file entry at the file sy...
Definition: saveload.cpp:2845
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
DetailedFileType detail_ftype
Concrete file type (PNG, BMP, old save, etc).
Definition: saveload.h:318
void SetDebugString(const char *s)
Set debugging levels by parsing the text in s.
Definition: debug.cpp:172
StringList _network_bind_list
The addresses to bind on.
Definition: network.cpp:63
Generate random land within scenario editor.
Definition: openttd.h:33
AIConfig stores the configuration settings of every AI.
void ResetWindowSystem()
Reset the windowing system, by means of shutting it down followed by re-initialization.
Definition: window.cpp:1934
int numleft
Number of arguments left in argv.
Definition: getoptdata.h:32
const char * NetworkChangeCompanyPassword(CompanyID company_id, const char *password)
Change the company password of a given company.
Definition: network.cpp:162
GUI functions that shouldn&#39;t be here.
Functions related to news.
void SaveToHighScore()
Save HighScore table to file.
Definition: highscore.cpp:124
bool MakeHeightmapScreenshot(const char *filename)
Make a heightmap of the current map.
Definition: screenshot.cpp:790
Base classes/functions for stations.
Errors (eg. saving/loading failed)
Definition: error.h:23
Date _date
Current date in days (day counter)
Definition: date.cpp:26
void ResetCompanyLivery(Company *c)
Reset the livery schemes to the company&#39;s primary colour.
Get the Script config from the current game.
Year startyear
The start year.
Definition: openttd.cpp:390
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:44
DetailedFileType
Kinds of files in each AbstractFileType.
Definition: fileio_type.h:28
Dimensions (a width and height) of a rectangle in 2D.
Valid changes while vehicle is driving, and possibly changing tracks.
Definition: train.h:48
static void SetErrorMessage(const char *message)
Sets a message for the error message handler.
Definition: crashlog.cpp:498
Generate a random map for SE.
Definition: genworld.h:30
bool _do_autosave
are we doing an autosave at the moment?
Definition: saveload.cpp:64
Year starting_year
starting date
void AnimateAnimatedTiles()
Animate all tiles in the animated tile list, i.e. call AnimateTile on them.
Class for backupping variables and making sure they are restored later.
Station data structure.
Definition: station_base.h:450
Time spent processing trains.
Factory to &#39;query&#39; all available blitters.
static const GraphicsSet * GetUsedSet()
Return the used set.
Functions related to subsidies.
New Game –> &#39;Random game&#39;.
Definition: openttd.h:26
Road vehicle type.
Definition: vehicle_type.h:25
SwitchMode
Mode which defines what mode we&#39;re switching to.
Definition: openttd.h:24
static bool HasModalProgress()
Check if we are currently in a modal progress state.
Definition: progress.h:21
void LoadFromHighScore()
Initialize the highscore table to 0 and if any file exists, load in values.
Definition: highscore.cpp:152
Save heightmap.
Definition: openttd.h:32
GroundVehicleCache gcache
Cache of often calculated values.
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition: gfx.cpp:1462
Sum of all GS/AI scripts.
bool SettingsDisableElrail(int32 p1)
_settings_game.disable_elrail callback
Definition: elrail.cpp:592
Base for the NewGRF implementation.
static const char * ini_set
The set as saved in the config file.
error that was caught in the middle of updating game state, need to clear it. (can only happen during...
Definition: saveload.h:312
pause the game
Definition: command_type.h:254