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 "core/backup_type.hpp"
57 #include "hotkeys.h"
58 #include "newgrf.h"
59 #include "misc/getoptdata.h"
60 #include "game/game.hpp"
61 #include "game/game_config.hpp"
62 #include "town.h"
63 #include "subsidy_func.h"
64 #include "gfx_layout.h"
65 #include "viewport_sprite_sorter.h"
66 #include "framerate_type.h"
67 
69 
70 #include <stdarg.h>
71 
72 #include "safeguards.h"
73 
74 void CallLandscapeTick();
75 void IncreaseDate();
76 void DoPaletteAnimations();
77 void MusicLoop();
78 void ResetMusic();
80 bool HandleBootstrap();
81 
82 extern Company *DoStartupNewCompany(bool is_ai, CompanyID company = INVALID_COMPANY);
83 extern void ShowOSErrorBox(const char *buf, bool system);
84 extern char *_config_file;
85 
91 void CDECL usererror(const char *s, ...)
92 {
93  va_list va;
94  char buf[512];
95 
96  va_start(va, s);
97  vseprintf(buf, lastof(buf), s, va);
98  va_end(va);
99 
100  ShowOSErrorBox(buf, false);
102 
103  exit(1);
104 }
105 
111 void CDECL error(const char *s, ...)
112 {
113  va_list va;
114  char buf[512];
115 
116  va_start(va, s);
117  vseprintf(buf, lastof(buf), s, va);
118  va_end(va);
119 
120  if (VideoDriver::GetInstance() == NULL || VideoDriver::GetInstance()->HasGUI()) {
121  ShowOSErrorBox(buf, true);
122  }
123 
124  /* Set the error message for the crash log and then invoke it. */
126  abort();
127 }
128 
133 void CDECL ShowInfoF(const char *str, ...)
134 {
135  va_list va;
136  char buf[1024];
137  va_start(va, str);
138  vseprintf(buf, lastof(buf), str, va);
139  va_end(va);
140  ShowInfo(buf);
141 }
142 
146 static void ShowHelp()
147 {
148  char buf[8192];
149  char *p = buf;
150 
151  p += seprintf(p, lastof(buf), "OpenTTD %s\n", _openttd_revision);
152  p = strecpy(p,
153  "\n"
154  "\n"
155  "Command line options:\n"
156  " -v drv = Set video driver (see below)\n"
157  " -s drv = Set sound driver (see below) (param bufsize,hz)\n"
158  " -m drv = Set music driver (see below)\n"
159  " -b drv = Set the blitter to use (see below)\n"
160  " -r res = Set resolution (for instance 800x600)\n"
161  " -h = Display this help text\n"
162  " -t year = Set starting year\n"
163  " -d [[fac=]lvl[,...]]= Debug mode\n"
164  " -e = Start Editor\n"
165  " -g [savegame] = Start new/save game immediately\n"
166  " -G seed = Set random seed\n"
167 #if defined(ENABLE_NETWORK)
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(__MORPHOS__) && !defined(__AMIGA__) && !defined(_WIN32)
174  " -f = Fork into the background (dedicated only)\n"
175 #endif
176 #endif /* ENABLE_NETWORK */
177  " -I graphics_set = Force the graphics set (see below)\n"
178  " -S sounds_set = Force the sounds set (see below)\n"
179  " -M music_set = Force the music set (see below)\n"
180  " -c config_file = Use 'config_file' instead of 'openttd.cfg'\n"
181  " -x = Do not automatically save to config file on exit\n"
182  " -q savegame = Write some information about the savegame and exit\n"
183  "\n",
184  lastof(buf)
185  );
186 
187  /* List the graphics packs */
188  p = BaseGraphics::GetSetsList(p, lastof(buf));
189 
190  /* List the sounds packs */
191  p = BaseSounds::GetSetsList(p, lastof(buf));
192 
193  /* List the music packs */
194  p = BaseMusic::GetSetsList(p, lastof(buf));
195 
196  /* List the drivers */
198 
199  /* List the blitters */
201 
202  /* List the debug facilities. */
203  p = DumpDebugFacilityNames(p, lastof(buf));
204 
205  /* We need to initialize the AI, so it finds the AIs */
206  AI::Initialize();
207  p = AI::GetConsoleList(p, lastof(buf), true);
208  AI::Uninitialize(true);
209 
210  /* We need to initialize the GameScript, so it finds the GSs */
212  p = Game::GetConsoleList(p, lastof(buf), true);
213  Game::Uninitialize(true);
214 
215  /* ShowInfo put output to stderr, but version information should go
216  * to stdout; this is the only exception */
217 #if !defined(_WIN32)
218  printf("%s\n", buf);
219 #else
220  ShowInfo(buf);
221 #endif
222 }
223 
224 static void WriteSavegameInfo(const char *name)
225 {
227  uint32 last_ottd_rev = 0;
228  byte ever_modified = 0;
229  bool removed_newgrfs = false;
230 
231  GamelogInfo(_load_check_data.gamelog_action, _load_check_data.gamelog_actions, &last_ottd_rev, &ever_modified, &removed_newgrfs);
232 
233  char buf[8192];
234  char *p = buf;
235  p += seprintf(p, lastof(buf), "Name: %s\n", name);
236  p += seprintf(p, lastof(buf), "Savegame ver: %d\n", _sl_version);
237  p += seprintf(p, lastof(buf), "NewGRF ver: 0x%08X\n", last_ottd_rev);
238  p += seprintf(p, lastof(buf), "Modified: %d\n", ever_modified);
239 
240  if (removed_newgrfs) {
241  p += seprintf(p, lastof(buf), "NewGRFs have been removed\n");
242  }
243 
244  p = strecpy(p, "NewGRFs:\n", lastof(buf));
246  for (GRFConfig *c = _load_check_data.grfconfig; c != NULL; c = c->next) {
247  char md5sum[33];
248  md5sumToString(md5sum, lastof(md5sum), HasBit(c->flags, GCF_COMPATIBLE) ? c->original_md5sum : c->ident.md5sum);
249  p += seprintf(p, lastof(buf), "%08X %s %s\n", c->ident.grfid, md5sum, c->filename);
250  }
251  }
252 
253  /* ShowInfo put output to stderr, but version information should go
254  * to stdout; this is the only exception */
255 #if !defined(_WIN32)
256  printf("%s\n", buf);
257 #else
258  ShowInfo(buf);
259 #endif
260 }
261 
262 
269 static void ParseResolution(Dimension *res, const char *s)
270 {
271  const char *t = strchr(s, 'x');
272  if (t == NULL) {
273  ShowInfoF("Invalid resolution '%s'", s);
274  return;
275  }
276 
277  res->width = max(strtoul(s, NULL, 0), 64UL);
278  res->height = max(strtoul(t + 1, NULL, 0), 64UL);
279 }
280 
281 
286 static void ShutdownGame()
287 {
288  IConsoleFree();
289 
290  if (_network_available) NetworkShutDown(); // Shut down the network and close any open connections
291 
293 
295 
296  /* stop the scripts */
297  AI::Uninitialize(false);
298  Game::Uninitialize(false);
299 
300  /* Uninitialize variables that are allocated dynamically */
301  GamelogReset();
302 
303 #ifdef ENABLE_NETWORK
305 #endif
306 
309 
310  /* No NewGRFs were loaded when it was still bootstrapping. */
311  if (_game_mode != GM_BOOTSTRAP) ResetNewGRFData();
312 
313  /* Close all and any open filehandles */
314  FioCloseAll();
315 
316  UninitFreeType();
317 }
318 
323 static void LoadIntroGame(bool load_newgrfs = true)
324 {
325  _game_mode = GM_MENU;
326 
327  if (load_newgrfs) ResetGRFConfig(false);
328 
329  /* Setup main window */
332 
333  /* Load the default opening screen savegame */
334  if (SaveOrLoad("opntitle.dat", SLO_LOAD, DFT_GAME_FILE, BASESET_DIR) != SL_OK) {
335  GenerateWorld(GWM_EMPTY, 64, 64); // if failed loading, make empty world.
338  } else {
340  }
341 
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] != NULL) {
354  delete _settings_game.ai_config[c];
355  }
356  }
357  if (_settings_game.game_config != NULL) {
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] = NULL;
368  if (_settings_newgame.ai_config[c] != NULL) {
370  if (!AIConfig::GetConfig(c, AIConfig::SSS_FORCE_GAME)->HasScript()) {
372  }
373  }
374  }
376  if (_settings_newgame.game_config != NULL) {
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(NULL), dedicated_port(0), network_conn(NULL),
410  join_server_password(NULL), join_company_password(NULL),
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);
437  CheckConfig();
441 
442  /* We have loaded the config, so we may possibly save it. */
443  *save_config_ptr = save_config;
444 
445  /* restore saved music volume */
447 
450 
451 #if defined(ENABLE_NETWORK)
452  if (dedicated_host != NULL) {
454  *_network_bind_list.Append() = stredup(dedicated_host);
455  }
456  if (dedicated_port != 0) _settings_client.network.server_port = dedicated_port;
457 #endif /* ENABLE_NETWORK */
458 
459  /* initialize the ingame console */
460  IConsoleInit();
461  InitializeGUI();
462  IConsoleCmdExec("exec scripts/autoexec.scr 0");
463 
464  /* Make sure _settings is filled with _settings_newgame if we switch to a game directly */
465  if (_switch_mode != SM_NONE) MakeNewgameSettingsLive();
466 
467 #ifdef ENABLE_NETWORK
468  if (_network_available && network_conn != NULL) {
469  const char *port = NULL;
470  const char *company = NULL;
471  uint16 rport = NETWORK_DEFAULT_PORT;
472  CompanyID join_as = COMPANY_NEW_COMPANY;
473 
474  ParseConnectionString(&company, &port, network_conn);
475 
476  if (company != NULL) {
477  join_as = (CompanyID)atoi(company);
478 
479  if (join_as != COMPANY_SPECTATOR) {
480  join_as--;
481  if (join_as >= MAX_COMPANIES) {
482  delete this;
483  return;
484  }
485  }
486  }
487  if (port != NULL) rport = atoi(port);
488 
489  LoadIntroGame();
490  _switch_mode = SM_NONE;
491  NetworkClientConnectGame(NetworkAddress(network_conn, rport), join_as, join_server_password, join_company_password);
492  }
493 #endif /* ENABLE_NETWORK */
494 
495  /* After the scan we're not used anymore. */
496  delete this;
497  }
498 };
499 
500 #if defined(UNIX) && !defined(__MORPHOS__)
501 extern void DedicatedFork();
502 #endif
503 
505 static const OptionData _options[] = {
506  GETOPT_SHORT_VALUE('I'),
507  GETOPT_SHORT_VALUE('S'),
508  GETOPT_SHORT_VALUE('M'),
509  GETOPT_SHORT_VALUE('m'),
510  GETOPT_SHORT_VALUE('s'),
511  GETOPT_SHORT_VALUE('v'),
512  GETOPT_SHORT_VALUE('b'),
513 #if defined(ENABLE_NETWORK)
514  GETOPT_SHORT_OPTVAL('D'),
515  GETOPT_SHORT_OPTVAL('n'),
516  GETOPT_SHORT_VALUE('l'),
517  GETOPT_SHORT_VALUE('p'),
518  GETOPT_SHORT_VALUE('P'),
519 #if !defined(__MORPHOS__) && !defined(__AMIGA__) && !defined(_WIN32)
520  GETOPT_SHORT_NOVAL('f'),
521 #endif
522 #endif /* ENABLE_NETWORK */
523  GETOPT_SHORT_VALUE('r'),
524  GETOPT_SHORT_VALUE('t'),
525  GETOPT_SHORT_OPTVAL('d'),
526  GETOPT_SHORT_NOVAL('e'),
527  GETOPT_SHORT_OPTVAL('g'),
528  GETOPT_SHORT_VALUE('G'),
529  GETOPT_SHORT_VALUE('c'),
530  GETOPT_SHORT_NOVAL('x'),
531  GETOPT_SHORT_VALUE('q'),
532  GETOPT_SHORT_NOVAL('h'),
533  GETOPT_END()
534 };
535 
542 int openttd_main(int argc, char *argv[])
543 {
544  char *musicdriver = NULL;
545  char *sounddriver = NULL;
546  char *videodriver = NULL;
547  char *blitter = NULL;
548  char *graphics_set = NULL;
549  char *sounds_set = NULL;
550  char *music_set = NULL;
551  Dimension resolution = {0, 0};
552  /* AfterNewGRFScan sets save_config to true after scanning completed. */
553  bool save_config = false;
554  AfterNewGRFScan *scanner = new AfterNewGRFScan(&save_config);
555 #if defined(ENABLE_NETWORK)
556  bool dedicated = false;
557  char *debuglog_conn = NULL;
558 
559  extern bool _dedicated_forks;
560  _dedicated_forks = false;
561 #endif /* ENABLE_NETWORK */
562 
563  _game_mode = GM_MENU;
565  _config_file = NULL;
566 
567  GetOptData mgo(argc - 1, argv + 1, _options);
568  int ret = 0;
569 
570  int i;
571  while ((i = mgo.GetOpt()) != -1) {
572  switch (i) {
573  case 'I': free(graphics_set); graphics_set = stredup(mgo.opt); break;
574  case 'S': free(sounds_set); sounds_set = stredup(mgo.opt); break;
575  case 'M': free(music_set); music_set = stredup(mgo.opt); break;
576  case 'm': free(musicdriver); musicdriver = stredup(mgo.opt); break;
577  case 's': free(sounddriver); sounddriver = stredup(mgo.opt); break;
578  case 'v': free(videodriver); videodriver = stredup(mgo.opt); break;
579  case 'b': free(blitter); blitter = stredup(mgo.opt); break;
580 #if defined(ENABLE_NETWORK)
581  case 'D':
582  free(musicdriver);
583  free(sounddriver);
584  free(videodriver);
585  free(blitter);
586  musicdriver = stredup("null");
587  sounddriver = stredup("null");
588  videodriver = stredup("dedicated");
589  blitter = stredup("null");
590  dedicated = true;
591  SetDebugString("net=6");
592  if (mgo.opt != NULL) {
593  /* Use the existing method for parsing (openttd -n).
594  * However, we do ignore the #company part. */
595  const char *temp = NULL;
596  const char *port = NULL;
597  ParseConnectionString(&temp, &port, mgo.opt);
598  if (!StrEmpty(mgo.opt)) scanner->dedicated_host = mgo.opt;
599  if (port != NULL) scanner->dedicated_port = atoi(port);
600  }
601  break;
602  case 'f': _dedicated_forks = true; break;
603  case 'n':
604  scanner->network_conn = mgo.opt; // optional IP parameter, NULL if unset
605  break;
606  case 'l':
607  debuglog_conn = mgo.opt;
608  break;
609  case 'p':
610  scanner->join_server_password = mgo.opt;
611  break;
612  case 'P':
613  scanner->join_company_password = mgo.opt;
614  break;
615 #endif /* ENABLE_NETWORK */
616  case 'r': ParseResolution(&resolution, mgo.opt); break;
617  case 't': scanner->startyear = atoi(mgo.opt); break;
618  case 'd': {
619 #if defined(_WIN32)
620  CreateConsole();
621 #endif
622  if (mgo.opt != NULL) SetDebugString(mgo.opt);
623  break;
624  }
626  case 'g':
627  if (mgo.opt != NULL) {
629  bool is_scenario = _switch_mode == SM_EDITOR || _switch_mode == SM_LOAD_SCENARIO;
630  _switch_mode = is_scenario ? SM_LOAD_SCENARIO : SM_LOAD_GAME;
632 
633  /* if the file doesn't exist or it is not a valid savegame, let the saveload code show an error */
634  const char *t = strrchr(_file_to_saveload.name, '.');
635  if (t != NULL) {
637  if (ft != FIOS_TYPE_INVALID) _file_to_saveload.SetMode(ft);
638  }
639 
640  break;
641  }
642 
644  /* Give a random map if no seed has been given */
645  if (scanner->generation_seed == GENERATE_NEW_SEED) {
646  scanner->generation_seed = InteractiveRandom();
647  }
648  break;
649  case 'q': {
650  DeterminePaths(argv[0]);
651  if (StrEmpty(mgo.opt)) {
652  ret = 1;
653  goto exit_noshutdown;
654  }
655 
656  char title[80];
657  title[0] = '\0';
658  FiosGetSavegameListCallback(SLO_LOAD, mgo.opt, strrchr(mgo.opt, '.'), title, lastof(title));
659 
662  if (res != SL_OK || _load_check_data.HasErrors()) {
663  fprintf(stderr, "Failed to open savegame\n");
664  if (_load_check_data.HasErrors()) {
665  char buf[256];
667  GetString(buf, _load_check_data.error, lastof(buf));
668  fprintf(stderr, "%s\n", buf);
669  }
670  goto exit_noshutdown;
671  }
672 
673  WriteSavegameInfo(title);
674 
675  goto exit_noshutdown;
676  }
677  case 'G': scanner->generation_seed = strtoul(mgo.opt, NULL, 10); break;
678  case 'c': free(_config_file); _config_file = stredup(mgo.opt); break;
679  case 'x': scanner->save_config = false; break;
680  case 'h':
681  i = -2; // Force printing of help.
682  break;
683  }
684  if (i == -2) break;
685  }
686 
687  if (i == -2 || mgo.numleft > 0) {
688  /* Either the user typed '-h', he made an error, or he added unrecognized command line arguments.
689  * In all cases, print the help, and exit.
690  *
691  * The next two functions are needed to list the graphics sets. We can't do them earlier
692  * because then we cannot show it on the debug console as that hasn't been configured yet. */
693  DeterminePaths(argv[0]);
698  ShowHelp();
699 
700  goto exit_noshutdown;
701  }
702 
703  DeterminePaths(argv[0]);
705 
706 #if defined(ENABLE_NETWORK)
707  if (dedicated) DEBUG(net, 0, "Starting dedicated version %s", _openttd_revision);
708  if (_dedicated_forks && !dedicated) _dedicated_forks = false;
709 
710 #if defined(UNIX) && !defined(__MORPHOS__)
711  /* We must fork here, or we'll end up without some resources we need (like sockets) */
712  if (_dedicated_forks) DedicatedFork();
713 #endif
714 #endif
715 
716  LoadFromConfig(true);
717 
718  if (resolution.width != 0) _cur_resolution = resolution;
719 
720  /*
721  * The width and height must be at least 1 pixel and width times
722  * height times bytes per pixel must still fit within a 32 bits
723  * integer, even for 32 bpp video modes. This way all internal
724  * drawing routines work correctly.
725  */
726  _cur_resolution.width = ClampU(_cur_resolution.width, 1, UINT16_MAX / 2);
727  _cur_resolution.height = ClampU(_cur_resolution.height, 1, UINT16_MAX / 2);
728 
729  /* Assume the cursor starts within the game as not all video drivers
730  * get an event that the cursor is within the window when it is opened.
731  * Saying the cursor is there makes no visible difference as it would
732  * just be out of the bounds of the window. */
733  _cursor.in_window = true;
734 
735  /* enumerate language files */
737 
738  /* Initialize the regular font for FreeType */
739  InitFreeType(false);
740 
741  /* This must be done early, since functions use the SetWindowDirty* calls */
743 
745  if (graphics_set == NULL && BaseGraphics::ini_set != NULL) graphics_set = stredup(BaseGraphics::ini_set);
746  if (!BaseGraphics::SetSet(graphics_set)) {
747  if (!StrEmpty(graphics_set)) {
748  BaseGraphics::SetSet(NULL);
749 
750  ErrorMessageData msg(STR_CONFIG_ERROR, STR_CONFIG_ERROR_INVALID_BASE_GRAPHICS_NOT_FOUND);
751  msg.SetDParamStr(0, graphics_set);
753  }
754  }
755  free(graphics_set);
756 
757  /* Initialize game palette */
758  GfxInitPalettes();
759 
760  DEBUG(misc, 1, "Loading blitter...");
761  if (blitter == NULL && _ini_blitter != NULL) blitter = stredup(_ini_blitter);
762  _blitter_autodetected = StrEmpty(blitter);
763  /* Activate the initial blitter.
764  * This is only some initial guess, after NewGRFs have been loaded SwitchNewGRFBlitter may switch to a different one.
765  * - Never guess anything, if the user specified a blitter. (_blitter_autodetected)
766  * - Use 32bpp blitter if baseset or 8bpp-support settings says so.
767  * - Use 8bpp blitter otherwise.
768  */
769  if (!_blitter_autodetected ||
770  (_support8bpp != S8BPP_NONE && (BaseGraphics::GetUsedSet() == NULL || BaseGraphics::GetUsedSet()->blitter == BLT_8BPP)) ||
771  BlitterFactory::SelectBlitter("32bpp-anim") == NULL) {
772  if (BlitterFactory::SelectBlitter(blitter) == NULL) {
773  StrEmpty(blitter) ?
774  usererror("Failed to autoprobe blitter") :
775  usererror("Failed to select requested blitter '%s'; does it exist?", blitter);
776  }
777  }
778  free(blitter);
779 
780  if (videodriver == NULL && _ini_videodriver != NULL) videodriver = stredup(_ini_videodriver);
782  free(videodriver);
783 
785 
786  /* Initialize the zoom level of the screen to normal */
787  _screen.zoom = ZOOM_LVL_NORMAL;
788 
789  NetworkStartUp(); // initialize network-core
790 
791 #if defined(ENABLE_NETWORK)
792  if (debuglog_conn != NULL && _network_available) {
793  const char *not_used = NULL;
794  const char *port = NULL;
795  uint16 rport;
796 
798 
799  ParseConnectionString(&not_used, &port, debuglog_conn);
800  if (port != NULL) rport = atoi(port);
801 
802  NetworkStartDebugLog(NetworkAddress(debuglog_conn, rport));
803  }
804 #endif /* ENABLE_NETWORK */
805 
806  if (!HandleBootstrap()) {
807  ShutdownGame();
808 
809  goto exit_bootstrap;
810  }
811 
812  VideoDriver::GetInstance()->ClaimMousePointer();
813 
814  /* initialize screenshot formats */
816 
818  if (sounds_set == NULL && BaseSounds::ini_set != NULL) sounds_set = stredup(BaseSounds::ini_set);
819  if (!BaseSounds::SetSet(sounds_set)) {
820  if (StrEmpty(sounds_set) || !BaseSounds::SetSet(NULL)) {
821  usererror("Failed to find a sounds set. Please acquire a sounds set for OpenTTD. See section 4.1 of README.md.");
822  } else {
823  ErrorMessageData msg(STR_CONFIG_ERROR, STR_CONFIG_ERROR_INVALID_BASE_SOUNDS_NOT_FOUND);
824  msg.SetDParamStr(0, sounds_set);
826  }
827  }
828  free(sounds_set);
829 
831  if (music_set == NULL && BaseMusic::ini_set != NULL) music_set = stredup(BaseMusic::ini_set);
832  if (!BaseMusic::SetSet(music_set)) {
833  if (StrEmpty(music_set) || !BaseMusic::SetSet(NULL)) {
834  usererror("Failed to find a music set. Please acquire a music set for OpenTTD. See section 4.1 of README.md.");
835  } else {
836  ErrorMessageData msg(STR_CONFIG_ERROR, STR_CONFIG_ERROR_INVALID_BASE_MUSIC_NOT_FOUND);
837  msg.SetDParamStr(0, music_set);
839  }
840  }
841  free(music_set);
842 
843  if (sounddriver == NULL && _ini_sounddriver != NULL) sounddriver = stredup(_ini_sounddriver);
845  free(sounddriver);
846 
847  if (musicdriver == NULL && _ini_musicdriver != NULL) musicdriver = stredup(_ini_musicdriver);
849  free(musicdriver);
850 
851  /* Take our initial lock on whatever we might want to do! */
854 
855  GenerateWorld(GWM_EMPTY, 64, 64); // Make the viewport initialization happy
857 
858  LoadIntroGame(false);
859 
861 
862  /* ScanNewGRFFiles now has control over the scanner. */
863  ScanNewGRFFiles(scanner);
864  scanner = NULL;
865 
867 
868  WaitTillSaved();
869 
870  /* only save config if we have to */
871  if (save_config) {
872  SaveToConfig();
875  SaveToHighScore();
876  }
877 
878  /* Reset windowing system, stop drivers, free used memory, ... */
879  ShutdownGame();
880  goto exit_normal;
881 
882 exit_noshutdown:
883  /* These three are normally freed before bootstrap. */
884  free(graphics_set);
885  free(videodriver);
886  free(blitter);
887 
888 exit_bootstrap:
889  /* These are normally freed before exit, but after bootstrap. */
890  free(sounds_set);
891  free(music_set);
892  free(musicdriver);
893  free(sounddriver);
894 
895 exit_normal:
899 
904 
905  delete scanner;
906 
907 #ifdef ENABLE_NETWORK
908  extern FILE *_log_fd;
909  if (_log_fd != NULL) {
910  fclose(_log_fd);
911  }
912 #endif /* ENABLE_NETWORK */
913 
914  return ret;
915 }
916 
917 void HandleExitGameRequest()
918 {
919  if (_game_mode == GM_MENU || _game_mode == GM_BOOTSTRAP) { // do not ask to quit on the main screen
920  _exit_game = true;
922  DoExitSave();
923  _exit_game = true;
924  } else {
925  AskExitGame();
926  }
927 }
928 
929 static void MakeNewGameDone()
930 {
932 
933  /* In a dedicated server, the server does not play */
934  if (!VideoDriver::GetInstance()->HasGUI()) {
937  IConsoleCmdExec("exec scripts/game_start.scr 0");
938  return;
939  }
940 
941  /* Create a single company */
942  DoStartupNewCompany(false);
943 
946 
947  /* Overwrite color from settings if needed
948  * COLOUR_END corresponds to Random colour */
949  if (_settings_client.gui.starting_colour != COLOUR_END) {
952  _company_colours[c->index] = (Colours)c->colour;
953  }
954 
955  IConsoleCmdExec("exec scripts/game_start.scr 0");
956 
958 
960 
961 #ifdef ENABLE_NETWORK
962  /* We are the server, we start a new company (not dedicated),
963  * so set the default password *if* needed. */
966  }
967 #endif /* ENABLE_NETWORK */
968 
970 
971  CheckEngines();
972  CheckIndustries();
974 }
975 
976 static void MakeNewGame(bool from_heightmap, bool reset_settings)
977 {
978  _game_mode = GM_NORMAL;
979 
980  ResetGRFConfig(true);
981 
982  GenerateWorldSetCallback(&MakeNewGameDone);
984 }
985 
986 static void MakeNewEditorWorldDone()
987 {
989 }
990 
991 static void MakeNewEditorWorld()
992 {
993  _game_mode = GM_EDITOR;
994 
995  ResetGRFConfig(true);
996 
997  GenerateWorldSetCallback(&MakeNewEditorWorldDone);
999 }
1000 
1011 bool SafeLoad(const char *filename, SaveLoadOperation fop, DetailedFileType dft, GameMode newgm, Subdirectory subdir, struct LoadFilter *lf = NULL)
1012 {
1013  assert(fop == SLO_LOAD);
1014  assert(dft == DFT_GAME_FILE || (lf == NULL && dft == DFT_OLD_GAME_FILE));
1015  GameMode ogm = _game_mode;
1016 
1017  _game_mode = newgm;
1018 
1019  switch (lf == NULL ? SaveOrLoad(filename, fop, dft, subdir) : LoadWithFilter(lf)) {
1020  case SL_OK: return true;
1021 
1022  case SL_REINIT:
1023 #ifdef ENABLE_NETWORK
1024  if (_network_dedicated) {
1025  /*
1026  * We need to reinit a network map...
1027  * We can't simply load the intro game here as that game has many
1028  * special cases which make clients desync immediately. So we fall
1029  * back to just generating a new game with the current settings.
1030  */
1031  DEBUG(net, 0, "Loading game failed, so a new (random) game will be started!");
1032  MakeNewGame(false, true);
1033  return false;
1034  }
1035  if (_network_server) {
1036  /* We can't load the intro game as server, so disconnect first. */
1038  }
1039 #endif /* ENABLE_NETWORK */
1040 
1041  switch (ogm) {
1042  default:
1043  case GM_MENU: LoadIntroGame(); break;
1044  case GM_EDITOR: MakeNewEditorWorld(); break;
1045  }
1046  return false;
1047 
1048  default:
1049  _game_mode = ogm;
1050  return false;
1051  }
1052 }
1053 
1054 void SwitchToMode(SwitchMode new_mode)
1055 {
1056 #ifdef ENABLE_NETWORK
1057  /* If we are saving something, the network stays in his current state */
1058  if (new_mode != SM_SAVE_GAME) {
1059  /* If the network is active, make it not-active */
1060  if (_networking) {
1061  if (_network_server && (new_mode == SM_LOAD_GAME || new_mode == SM_NEWGAME || new_mode == SM_RESTARTGAME)) {
1062  NetworkReboot();
1063  } else {
1065  }
1066  }
1067 
1068  /* If we are a server, we restart the server */
1069  if (_is_network_server) {
1070  /* But not if we are going to the menu */
1071  if (new_mode != SM_MENU) {
1072  /* check if we should reload the config */
1074  LoadFromConfig();
1075  MakeNewgameSettingsLive();
1076  ResetGRFConfig(false);
1077  }
1078  NetworkServerStart();
1079  } else {
1080  /* This client no longer wants to be a network-server */
1081  _is_network_server = false;
1082  }
1083  }
1084  }
1085 #endif /* ENABLE_NETWORK */
1086  /* Make sure all AI controllers are gone at quitting game */
1087  if (new_mode != SM_SAVE_GAME) AI::KillAll();
1088 
1089  switch (new_mode) {
1090  case SM_EDITOR: // Switch to scenario editor
1091  MakeNewEditorWorld();
1092  break;
1093 
1094  case SM_RESTARTGAME: // Restart --> 'Random game' with current settings
1095  case SM_NEWGAME: // New Game --> 'Random game'
1096 #ifdef ENABLE_NETWORK
1097  if (_network_server) {
1099  }
1100 #endif /* ENABLE_NETWORK */
1101  MakeNewGame(false, new_mode == SM_NEWGAME);
1102  break;
1103 
1104  case SM_LOAD_GAME: { // Load game, Play Scenario
1105  ResetGRFConfig(true);
1107 
1110  ShowErrorMessage(STR_JUST_RAW_STRING, INVALID_STRING_ID, WL_ERROR);
1111  } else {
1113  /* Reset engine pool to simplify changing engine NewGRFs in scenario editor. */
1115  }
1116  /* Update the local company for a loaded game. It is either always
1117  * company #1 (eg 0) or in the case of a dedicated server a spectator */
1119  /* Execute the game-start script */
1120  IConsoleCmdExec("exec scripts/game_start.scr 0");
1121  /* Decrease pause counter (was increased from opening load dialog) */
1123 #ifdef ENABLE_NETWORK
1124  if (_network_server) {
1126  }
1127 #endif /* ENABLE_NETWORK */
1128  }
1129  break;
1130  }
1131 
1132  case SM_START_HEIGHTMAP: // Load a heightmap and start a new game from it
1133 #ifdef ENABLE_NETWORK
1134  if (_network_server) {
1136  }
1137 #endif /* ENABLE_NETWORK */
1138  MakeNewGame(true, true);
1139  break;
1140 
1141  case SM_LOAD_HEIGHTMAP: // Load heightmap from scenario editor
1143 
1146  break;
1147 
1148  case SM_LOAD_SCENARIO: { // Load scenario from scenario editor
1152  /* Cancel the saveload pausing */
1154  } else {
1156  ShowErrorMessage(STR_JUST_RAW_STRING, INVALID_STRING_ID, WL_ERROR);
1157  }
1158  break;
1159  }
1160 
1161  case SM_MENU: // Switch to game intro menu
1162  LoadIntroGame();
1163  if (BaseSounds::ini_set == NULL && BaseSounds::GetUsedSet()->fallback) {
1164  ShowErrorMessage(STR_WARNING_FALLBACK_SOUNDSET, INVALID_STRING_ID, WL_CRITICAL);
1166  }
1167  break;
1168 
1169  case SM_SAVE_GAME: // Save game.
1170  /* Make network saved games on pause compatible to singleplayer */
1173  ShowErrorMessage(STR_JUST_RAW_STRING, INVALID_STRING_ID, WL_ERROR);
1174  } else {
1176  }
1177  break;
1178 
1179  case SM_SAVE_HEIGHTMAP: // Save heightmap.
1182  break;
1183 
1184  case SM_GENRANDLAND: // Generate random land within scenario editor
1187  /* XXX: set date */
1189  break;
1190 
1191  default: NOT_REACHED();
1192  }
1193 }
1194 
1195 
1202 static void CheckCaches()
1203 {
1204  /* Return here so it is easy to add checks that are run
1205  * always to aid testing of caches. */
1206  if (_debug_desync_level <= 1) return;
1207 
1208  /* Check the town caches. */
1209  SmallVector<TownCache, 4> old_town_caches;
1210  Town *t;
1211  FOR_ALL_TOWNS(t) {
1212  MemCpyT(old_town_caches.Append(), &t->cache);
1213  }
1214 
1215  extern void RebuildTownCaches();
1218 
1219  uint i = 0;
1220  FOR_ALL_TOWNS(t) {
1221  if (MemCmpT(old_town_caches.Get(i), &t->cache) != 0) {
1222  DEBUG(desync, 2, "town cache mismatch: town %i", (int)t->index);
1223  }
1224  i++;
1225  }
1226 
1227  /* Check company infrastructure cache. */
1228  SmallVector<CompanyInfrastructure, 4> old_infrastructure;
1229  Company *c;
1230  FOR_ALL_COMPANIES(c) MemCpyT(old_infrastructure.Append(), &c->infrastructure);
1231 
1232  extern void AfterLoadCompanyStats();
1234 
1235  i = 0;
1236  FOR_ALL_COMPANIES(c) {
1237  if (MemCmpT(old_infrastructure.Get(i), &c->infrastructure) != 0) {
1238  DEBUG(desync, 2, "infrastructure cache mismatch: company %i", (int)c->index);
1239  }
1240  i++;
1241  }
1242 
1243  /* Strict checking of the road stop cache entries */
1244  const RoadStop *rs;
1245  FOR_ALL_ROADSTOPS(rs) {
1246  if (IsStandardRoadStopTile(rs->xy)) continue;
1247 
1248  assert(rs->GetEntry(DIAGDIR_NE) != rs->GetEntry(DIAGDIR_NW));
1251  }
1252 
1253  Vehicle *v;
1254  FOR_ALL_VEHICLES(v) {
1255  extern void FillNewGRFVehicleCache(const Vehicle *v);
1256  if (v != v->First() || v->vehstatus & VS_CRASHED || !v->IsPrimaryVehicle()) continue;
1257 
1258  uint length = 0;
1259  for (const Vehicle *u = v; u != NULL; u = u->Next()) length++;
1260 
1261  NewGRFCache *grf_cache = CallocT<NewGRFCache>(length);
1262  VehicleCache *veh_cache = CallocT<VehicleCache>(length);
1263  GroundVehicleCache *gro_cache = CallocT<GroundVehicleCache>(length);
1264  TrainCache *tra_cache = CallocT<TrainCache>(length);
1265 
1266  length = 0;
1267  for (const Vehicle *u = v; u != NULL; u = u->Next()) {
1269  grf_cache[length] = u->grf_cache;
1270  veh_cache[length] = u->vcache;
1271  switch (u->type) {
1272  case VEH_TRAIN:
1273  gro_cache[length] = Train::From(u)->gcache;
1274  tra_cache[length] = Train::From(u)->tcache;
1275  break;
1276  case VEH_ROAD:
1277  gro_cache[length] = RoadVehicle::From(u)->gcache;
1278  break;
1279  default:
1280  break;
1281  }
1282  length++;
1283  }
1284 
1285  switch (v->type) {
1286  case VEH_TRAIN: Train::From(v)->ConsistChanged(CCF_TRACK); break;
1289  case VEH_SHIP: Ship::From(v)->UpdateCache(); break;
1290  default: break;
1291  }
1292 
1293  length = 0;
1294  for (const Vehicle *u = v; u != NULL; u = u->Next()) {
1296  if (memcmp(&grf_cache[length], &u->grf_cache, sizeof(NewGRFCache)) != 0) {
1297  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);
1298  }
1299  if (memcmp(&veh_cache[length], &u->vcache, sizeof(VehicleCache)) != 0) {
1300  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);
1301  }
1302  switch (u->type) {
1303  case VEH_TRAIN:
1304  if (memcmp(&gro_cache[length], &Train::From(u)->gcache, sizeof(GroundVehicleCache)) != 0) {
1305  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);
1306  }
1307  if (memcmp(&tra_cache[length], &Train::From(u)->tcache, sizeof(TrainCache)) != 0) {
1308  DEBUG(desync, 2, "train cache mismatch: vehicle %i, company %i, unit number %i, wagon %i", v->index, (int)v->owner, v->unitnumber, length);
1309  }
1310  break;
1311  case VEH_ROAD:
1312  if (memcmp(&gro_cache[length], &RoadVehicle::From(u)->gcache, sizeof(GroundVehicleCache)) != 0) {
1313  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);
1314  }
1315  break;
1316  default:
1317  break;
1318  }
1319  length++;
1320  }
1321 
1322  free(grf_cache);
1323  free(veh_cache);
1324  free(gro_cache);
1325  free(tra_cache);
1326  }
1327 
1328  /* Check whether the caches are still valid */
1329  FOR_ALL_VEHICLES(v) {
1330  byte buff[sizeof(VehicleCargoList)];
1331  memcpy(buff, &v->cargo, sizeof(VehicleCargoList));
1332  v->cargo.InvalidateCache();
1333  assert(memcmp(&v->cargo, buff, sizeof(VehicleCargoList)) == 0);
1334  }
1335 
1336  Station *st;
1337  FOR_ALL_STATIONS(st) {
1338  for (CargoID c = 0; c < NUM_CARGO; c++) {
1339  byte buff[sizeof(StationCargoList)];
1340  memcpy(buff, &st->goods[c].cargo, sizeof(StationCargoList));
1341  st->goods[c].cargo.InvalidateCache();
1342  assert(memcmp(&st->goods[c].cargo, buff, sizeof(StationCargoList)) == 0);
1343  }
1344  }
1345 }
1346 
1353 {
1354  /* don't execute the state loop during pause */
1355  if (_pause_mode != PM_UNPAUSED) {
1363 
1365 #ifndef DEBUG_DUMP_COMMANDS
1366  Game::GameLoop();
1367 #endif
1368  return;
1369  }
1370 
1371  PerformanceMeasurer framerate(PFE_GAMELOOP);
1373  if (HasModalProgress()) return;
1374 
1376 
1377  if (_game_mode == GM_EDITOR) {
1379  RunTileLoop();
1380  CallVehicleTicks();
1381  CallLandscapeTick();
1384 
1386  NewsLoop();
1387  } else {
1388  if (_debug_desync_level > 2 && _date_fract == 0 && (_date & 0x1F) == 0) {
1389  /* Save the desync savegame if needed. */
1390  char name[MAX_PATH];
1391  seprintf(name, lastof(name), "dmp_cmds_%08x_%08x.sav", _settings_game.game_creation.generation_seed, _date);
1393  }
1394 
1395  CheckCaches();
1396 
1397  /* All these actions has to be done from OWNER_NONE
1398  * for multiplayer compatibility */
1399  Backup<CompanyByte> cur_company(_current_company, OWNER_NONE, FILE_LINE);
1400 
1403  IncreaseDate();
1404  RunTileLoop();
1405  CallVehicleTicks();
1406  CallLandscapeTick();
1408 
1409 #ifndef DEBUG_DUMP_COMMANDS
1410  AI::GameLoop();
1411  Game::GameLoop();
1412 #endif
1414 
1416  NewsLoop();
1417  cur_company.Restore();
1418  }
1419 
1420  assert(IsLocalCompany());
1421 }
1422 
1427 static void DoAutosave()
1428 {
1429  char buf[MAX_PATH];
1430 
1432  GenerateDefaultSaveName(buf, lastof(buf));
1433  strecat(buf, ".sav", lastof(buf));
1434  } else {
1435  static int _autosave_ctr = 0;
1436 
1437  /* generate a savegame name and number according to _settings_client.gui.max_num_autosaves */
1438  seprintf(buf, lastof(buf), "autosave%d.sav", _autosave_ctr);
1439 
1440  if (++_autosave_ctr >= _settings_client.gui.max_num_autosaves) _autosave_ctr = 0;
1441  }
1442 
1443  DEBUG(sl, 2, "Autosaving to '%s'", buf);
1445  ShowErrorMessage(STR_ERROR_AUTOSAVE_FAILED, INVALID_STRING_ID, WL_ERROR);
1446  }
1447 }
1448 
1449 void GameLoop()
1450 {
1451  if (_game_mode == GM_BOOTSTRAP) {
1452 #ifdef ENABLE_NETWORK
1453  /* Check for UDP stuff */
1455 #endif
1456  InputLoop();
1457  return;
1458  }
1459 
1461 
1462  /* autosave game? */
1463  if (_do_autosave) {
1464  DoAutosave();
1465  _do_autosave = false;
1467  }
1468 
1469  /* switch game mode? */
1470  if (_switch_mode != SM_NONE && !HasModalProgress()) {
1471  SwitchToMode(_switch_mode);
1472  _switch_mode = SM_NONE;
1473  }
1474 
1475  IncreaseSpriteLRU();
1476  InteractiveRandom();
1477 
1478 #ifdef ENABLE_NETWORK
1479  /* Check for UDP stuff */
1481 
1482  if (_networking && !HasModalProgress()) {
1483  /* Multiplayer */
1484  NetworkGameLoop();
1485  } else {
1486  if (_network_reconnect > 0 && --_network_reconnect == 0) {
1487  /* This means that we want to reconnect to the last host
1488  * We do this here, because it means that the network is really closed */
1490  }
1491  /* Singleplayer */
1492  StateGameLoop();
1493  }
1494 #else
1495  StateGameLoop();
1496 #endif /* ENABLE_NETWORK */
1497 
1498  if (!_pause_mode && HasBit(_display_opt, DO_FULL_ANIMATION)) DoPaletteAnimations();
1499 
1500  InputLoop();
1501 
1503  MusicLoop();
1504 }
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:551
Functions related to OTTD&#39;s strings.
void UpdateLandscapingLimits()
Update the landscaping limits per company.
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:77
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:474
bool _networking
are we in networking mode?
Definition: network.cpp:56
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:1128
Scan for base sets.
Definition: fileio_func.h:102
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:32
FiosType FiosGetSavegameListCallback(SaveLoadOperation fop, const char *file, const char *ext, char *title, const char *last)
Callback for FiosGetFileList.
Definition: fios.cpp:458
virtual void MainLoop()
Called once every tick.
bool HandleBootstrap()
Handle all procedures for bootstrapping OpenTTD without a base graphics set.
A game normally paused.
Definition: openttd.h:59
FILE * _log_fd
File to reroute output of a forked OpenTTD to.
Definition: dedicated.cpp:17
A normal unpaused game.
Definition: openttd.h:58
#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:3179
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:542
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:158
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:2797
static void GameLoop()
Called every game-tick to let Game do something.
Definition: game_core.cpp:32
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
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:2860
static uint FindSets()
Do the scan for files.
Hotkey related functions.
Functions related to dates.
Generate a map for a new game.
Definition: genworld.h:29
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:505
Base for the train class.
bool pause_on_newgame
whether to start new games paused or not
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:317
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:59
void InitWindowSystem()
(re)initialize the windowing system
Definition: window.cpp:1874
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:90
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
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:62
static void ShutdownDrivers()
Shuts down all active drivers.
Definition: driver.h:115
char title[255]
Internal name of the game.
Definition: saveload.h:311
MusicSettings music
settings related to music/sound
Base for all sound drivers.
static void Initialize()
Initialize the AI system.
Definition: ai_core.cpp:160
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:31
Generate a newgame from a heightmap.
Definition: genworld.h:32
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:1070
Northeast, upper right on your monitor.
Cached often queried values common to all vehicles.
Definition: vehicle_base.h:122
Dimension _cur_resolution
The current resolution.
Definition: driver.cpp:24
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:2787
Base for aircraft.
#define lastof(x)
Get the last element of an fixed size array.
Definition: depend.cpp:50
The client is spectating.
Definition: company_type.h:37
The client wants a new company.
Definition: company_type.h:36
Simple vector template class.
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:191
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:224
void SaveToConfig()
Save the values to the configuration file.
Definition: settings.cpp:1740
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:255
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:3046
CompanySettings settings
settings specific for each company
Definition: company_base.h:126
const char * GetSaveLoadErrorString()
Get the string representation of the error message.
Definition: saveload.cpp:2408
GoodsEntry goods[NUM_CARGO]
Goods at this station.
Definition: station_base.h:472
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:25
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:58
Variables that are cached to improve performance and such.
Definition: train.h:72
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:59
T * Append(uint to_add=1)
Append an item and return it.
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:23
CompanyByte _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
static char * GetConsoleList(char *p, const char *last, bool newest_only=false)
Wrapper function for GameScanner::GetConsoleList.
Definition: game_core.cpp:221
static void CheckCaches()
Check the validity of some of the caches.
Definition: openttd.cpp:1202
ThreadMutex * _modal_progress_work_mutex
Rights for the performing work.
Definition: progress.cpp:21
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:660
Library for parsing command-line options.
void ProcessAsyncSaveFinish()
Handle async save finishes.
Definition: saveload.cpp:373
void CDECL ShowInfoF(const char *str,...)
Shows some information on the console/a popup box depending on the OS.
Definition: openttd.cpp:133
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 ShowErrorMessage(StringID summary_msg, StringID detailed_msg, WarningLevel wl, int x=0, int y=0, const GRFFile *textref_stack_grffile=NULL, uint textref_stack_size=0, const uint32 *textref_stack=NULL)
Display an error message in a window.
Definition: error_gui.cpp:378
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:40
Aircraft vehicle type.
Definition: vehicle_type.h:29
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:802
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:60
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:298
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:31
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:68
SaveOrLoadResult
Save or load result codes.
Definition: saveload.h:299
static void ShowHelp()
Show the help message when someone passed a wrong parameter.
Definition: openttd.cpp:146
void UpdateAircraftCache(Aircraft *v, bool update_range=false)
Update cached values of an aircraft.
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:27
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:174
static Blitter * SelectBlitter(const char *name)
Find the requested blitter and return his class.
Definition: factory.hpp:96
Time spend processing road vehicles.
void IConsoleCmdExec(const char *cmdstr)
Execute a given command passed to us.
Definition: console.cpp:409
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:76
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:80
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:91
A number of safeguards to prevent using unsafe methods.
void StateGameLoop()
State controlling game loop.
Definition: openttd.cpp:1352
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:78
First company, same as owner.
Definition: company_type.h:24
static void SaveToConfig()
Save all WindowDesc settings to _windows_file.
Definition: window.cpp:165
uint8 _network_reconnect
Reconnect timeout.
Definition: network.cpp:66
void FillNewGRFVehicleCache(const Vehicle *v)
Fill the grf_cache of the given vehicle.
Scan for scenarios and heightmaps.
Definition: fileio_func.h:105
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:38
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:1710
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:440
char * DumpDebugFacilityNames(char *buf, char *last)
Dump the available debug facility names in the help text.
Definition: debug.cpp:88
bool SafeLoad(const char *filename, SaveLoadOperation fop, DetailedFileType dft, GameMode newgm, Subdirectory subdir, struct LoadFilter *lf=NULL)
Load the specified savegame but on error do different things.
Definition: openttd.cpp:1011
A sound driver.
Definition: driver.h:44
static void ShutdownGame()
Uninitializes drivers, frees allocated memory, cleans pools, ...
Definition: openttd.cpp:286
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:2682
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
The tile has no ownership.
Definition: company_type.h:27
bool autosave_on_exit
save an autosave when you quit the game, but do not ask "Do you really want to quit?"
Northwest.
void CheckIndustries()
Verify whether the generated industries are complete, and warn the user if not.
Generate an empty map (sea-level)
Definition: genworld.h:30
static MusicDriver * GetInstance()
Get the currently active instance of the music driver.
char * opt
Option value, if available (else NULL).
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:2702
void NetworkShutDown()
This shuts the network down.
Definition: network.cpp:1091
bool DoCommandP(const CommandContainer *container, bool my_cmd)
Shortcut for the long DoCommandP when having a container with the data.
Definition: command.cpp:531
NetworkServerGameInfo _network_game_info
Information about our game.
Definition: network.cpp:61
PauseModeByte _pause_mode
The current pause mode.
Definition: gfx.cpp:48
Road vehicle type.
Definition: vehicle_type.h:27
bool save_config
The save config setting.
Definition: openttd.cpp:400
File is being loaded.
Definition: fileio_type.h:51
void InitializeLanguagePacks()
Make a list of the available language packs.
Definition: strings.cpp:1954
ThreadMutex * _modal_progress_paint_mutex
Rights for the painting.
Definition: progress.cpp:23
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:242
SaveLoadOperation
Operation performed on the file.
Definition: fileio_type.h:49
void CallWindowGameTickEvent()
Dispatch OnGameTick event over all windows.
Definition: window.cpp:3311
Maximum number of companies.
Definition: company_type.h:25
void UnInitWindowSystem()
Close down the windowing system.
Definition: window.cpp:1895
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
Ship vehicle type.
Definition: vehicle_type.h:28
uint DoScan(Subdirectory sd)
Perform the scanning of a particular subdirectory.
Definition: fileio.cpp:637
static void MemCpyT(T *destination, const T *source, size_t num=1)
Type-safe version of memcpy().
Definition: mem_func.hpp:25
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:36
static void Initialize()
Initialize the Game system.
Definition: game_core.cpp:50
char map_name[NETWORK_NAME_LENGTH]
Map which is played ["random" for a randomized map].
Definition: game.h:29
uint16 server_port
port the server listens on
CompanyInfrastructure infrastructure
NOSAVE: Counts of company owned infrastructure.
Definition: company_base.h:130
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:1143
void GenerateWorldSetCallback(GWDoneProc *proc)
Set here the function, if any, that you want to be called when landscape generation is done...
Definition: genworld.cpp:223
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:275
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:317
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:528
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:1162
static void DoAutosave()
Create an autosave.
Definition: openttd.cpp:1427
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:88
void ResetNewGRFData()
Reset all NewGRF loaded data TODO.
Definition: newgrf.cpp:8242
Declarations for savegames operations.
CompanyByte _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
Vehicle * Next() const
Get the next vehicle of this vehicle.
Definition: vehicle_base.h:581
static VideoDriver * GetInstance()
Get the currently active instance of the video driver.
byte colour
Company colour.
Definition: company_base.h:68
static void KillAll()
Kill any and all AIs we manage.
Definition: ai_core.cpp:149
static void LoadFromConfig()
Load all WindowDesc settings from _windows_file.
Definition: window.cpp:142
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:111
static char * GetSetsList(char *p, const char *last)
Returns a list with the sets.
OwnerByte owner
Which company owns the vehicle?
Definition: vehicle_base.h:273
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 NULL.
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
VehicleDefaultSettings _old_vds
Used for loading default vehicles settings from old savegames.
Definition: settings.cpp:79
TownCache cache
Container for all cacheable data.
Definition: town.h:58
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:47
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.
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:310
bool _network_server
network-server is active
Definition: network.cpp:57
SaveLoadOperation file_op
File operation to perform.
Definition: saveload.h:307
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:895
void SaveHotkeysToConfig()
Save the hotkeys to the config file.
Definition: hotkeys.cpp:337
void Clear()
Remove all items from the list.
void UninitFreeType()
Free everything allocated w.r.t.
Definition: fontcache.cpp:677
void InitializeRailGUI()
Resets the rail GUI - sets default railtype to build and resets the signal GUI.
Definition: rail_gui.cpp:1973
Perform palette animation.
Definition: openttd.h:46
static void LoadIntroGame(bool load_newgrfs=true)
Load the introduction game.
Definition: openttd.cpp:323
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:856
AbstractFileType abstract_ftype
Abstract type of file (scenario, heightmap, etc).
Definition: saveload.h:309
byte max_num_autosaves
controls how many autosavegames are made before the game starts to overwrite (names them 0 to max_num...
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:798
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
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: depend.cpp:114
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:269
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:300
void InitializeSpriteSorter()
Choose the "best" sprite sorter and set _vp_sprite_sorter.
Definition: viewport.cpp:3107
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:29
Base of the town class.
const T * Get(uint index) const
Get the pointer to item "number" (const)
The normal zoom level.
Definition: zoom_type.h:24
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:2831
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:308
void SetDebugString(const char *s)
Set debugging levels by parsing the text in s.
Definition: debug.cpp:180
StringList _network_bind_list
The addresses to bind on.
Definition: network.cpp:67
A game paused for saving/loading.
Definition: openttd.h:60
Generate random land within scenario editor.
Definition: openttd.h:35
virtual void BeginCritical(bool allow_recursive=false)=0
Begin the critical section.
AIConfig stores the configuration settings of every AI.
Owner
Enum for all companies/owners.
Definition: company_type.h:20
void ResetWindowSystem()
Reset the windowing system, by means of shutting it down followed by re-initialization.
Definition: window.cpp:1915
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:174
GUI functions that shouldn&#39;t be here.
Functions related to news.
void SaveToHighScore()
Save HighScore table to file.
Definition: highscore.cpp:128
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.
An invalid company.
Definition: company_type.h:32
Year startyear
The start year.
Definition: openttd.cpp:392
DetailedFileType
Kinds of files in each AbstractFileType.
Definition: fileio_type.h:30
VehicleTypeByte type
Type of vehicle.
Definition: vehicle_type.h:56
Dimensions (a width and height) of a rectangle in 2D.
Valid changes while vehicle is driving, and possibly changing tracks.
Definition: train.h:51
static void SetErrorMessage(const char *message)
Sets a message for the error message handler.
Definition: crashlog.cpp:503
Generate a random map for SE.
Definition: genworld.h:31
bool _do_autosave
are we doing an autosave at the moment?
Definition: saveload.cpp:65
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:446
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
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:156
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:1461
Train vehicle type.
Definition: vehicle_type.h:26
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:302
pause the game
Definition: command_type.h:255