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