OpenTTD

- Main Page
- Related Pages
- Modules
- Namespaces
- Data Structures
- Files

- File List
- Globals

openttd.cpp
Go to the documentation of this file.
1 /* $Id: openttd.cpp 27653 2016-09-04 16:06:50Z alberth $ */
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
67 #include "linkgraph/linkgraphschedule.h"
68
69 #include <stdarg.h>
70
71 #include "safeguards.h"
72
73 void CallLandscapeTick();
74 void IncreaseDate();
75 void DoPaletteAnimations();
76 void MusicLoop();
77 void ResetMusic();
78 void CallWindowTickEvent();
79 bool HandleBootstrap();
80
81 extern Company *DoStartupNewCompany(bool is_ai, CompanyID company = INVALID_COMPANY);
82 extern void ShowOSErrorBox(const char *buf, bool system);
83 extern char *_config_file;
84
90 void CDECL usererror(const char *s, ...)
91 {
92 va_list va;
93 char buf[512];
94
95 va_start(va, s);
96 vseprintf(buf, lastof(buf), s, va);
97 va_end(va);
98
99 ShowOSErrorBox(buf, false);
100 if (VideoDriver::GetInstance() != NULL) VideoDriver::GetInstance()->Stop();
101
102 exit(1);
103 }
104
110 void CDECL error(const char *s, ...)
111 {
112 va_list va;
113 char buf[512];
114
115 va_start(va, s);
116 vseprintf(buf, lastof(buf), s, va);
117 va_end(va);
118
119 ShowOSErrorBox(buf, true);
120
121 /* Set the error message for the crash log and then invoke it. */
122 CrashLog::SetErrorMessage(buf);
123 abort();
124 }
125
130 void CDECL ShowInfoF(const char *str, ...)
131 {
132 va_list va;
133 char buf[1024];
134 va_start(va, str);
135 vseprintf(buf, lastof(buf), str, va);
136 va_end(va);
137 ShowInfo(buf);
138 }
139
143 static void ShowHelp()
144 {
145 char buf[8192];
146 char *p = buf;
147
148 p += seprintf(p, lastof(buf), "OpenTTD %s\n", _openttd_revision);
149 p = strecpy(p,
150 "\n"
151 "\n"
152 "Command line options:\n"
153 " -v drv = Set video driver (see below)\n"
154 " -s drv = Set sound driver (see below) (param bufsize,hz)\n"
155 " -m drv = Set music driver (see below)\n"
156 " -b drv = Set the blitter to use (see below)\n"
157 " -r res = Set resolution (for instance 800x600)\n"
158 " -h = Display this help text\n"
159 " -t year = Set starting year\n"
160 " -d [[fac=]lvl[,...]]= Debug mode\n"
161 " -e = Start Editor\n"
162 " -g [savegame] = Start new/save game immediately\n"
163 " -G seed = Set random seed\n"
164 #if defined(ENABLE_NETWORK)
165 " -n [ip:port#company]= Join network game\n"
166 " -p password = Password to join server\n"
167 " -P password = Password to join company\n"
168 " -D [ip][:port] = Start dedicated server\n"
169 " -l ip[:port] = Redirect DEBUG()\n"
170 #if !defined(__MORPHOS__) && !defined(__AMIGA__) && !defined(WIN32)
171 " -f = Fork into the background (dedicated only)\n"
172 #endif
173 #endif /* ENABLE_NETWORK */
174 " -I graphics_set = Force the graphics set (see below)\n"
175 " -S sounds_set = Force the sounds set (see below)\n"
176 " -M music_set = Force the music set (see below)\n"
177 " -c config_file = Use 'config_file' instead of 'openttd.cfg'\n"
178 " -x = Do not automatically save to config file on exit\n"
179 " -q savegame = Write some information about the savegame and exit\n"
180 "\n",
181 lastof(buf)
182 );
183
184 /* List the graphics packs */
185 p = BaseGraphics::GetSetsList(p, lastof(buf));
186
187 /* List the sounds packs */
188 p = BaseSounds::GetSetsList(p, lastof(buf));
189
190 /* List the music packs */
191 p = BaseMusic::GetSetsList(p, lastof(buf));
192
193 /* List the drivers */
194 p = DriverFactoryBase::GetDriversInfo(p, lastof(buf));
195
196 /* List the blitters */
197 p = BlitterFactory::GetBlittersInfo(p, lastof(buf));
198
199 /* List the debug facilities. */
200 p = DumpDebugFacilityNames(p, lastof(buf));
201
202 /* We need to initialize the AI, so it finds the AIs */
203 AI::Initialize();
204 p = AI::GetConsoleList(p, lastof(buf), true);
205 AI::Uninitialize(true);
206
207 /* We need to initialize the GameScript, so it finds the GSs */
208 Game::Initialize();
209 p = Game::GetConsoleList(p, lastof(buf), true);
210 Game::Uninitialize(true);
211
212 /* ShowInfo put output to stderr, but version information should go
213 * to stdout; this is the only exception */
214 #if !defined(WIN32) && !defined(WIN64)
215 printf("%s\n", buf);
216 #else
217 ShowInfo(buf);
218 #endif
219 }
220
221 static void WriteSavegameInfo(const char *name)
222 {
223 extern uint16 _sl_version;
224 uint32 last_ottd_rev = 0;
225 byte ever_modified = 0;
226 bool removed_newgrfs = false;
227
228 GamelogInfo(_load_check_data.gamelog_action, _load_check_data.gamelog_actions, &last_ottd_rev, &ever_modified, &removed_newgrfs);
229
230 char buf[8192];
231 char *p = buf;
232 p += seprintf(p, lastof(buf), "Name: %s\n", name);
233 p += seprintf(p, lastof(buf), "Savegame ver: %d\n", _sl_version);
234 p += seprintf(p, lastof(buf), "NewGRF ver: 0x%08X\n", last_ottd_rev);
235 p += seprintf(p, lastof(buf), "Modified: %d\n", ever_modified);
236
237 if (removed_newgrfs) {
238 p += seprintf(p, lastof(buf), "NewGRFs have been removed\n");
239 }
240
241 p = strecpy(p, "NewGRFs:\n", lastof(buf));
242 if (_load_check_data.HasNewGrfs()) {
243 for (GRFConfig *c = _load_check_data.grfconfig; c != NULL; c = c->next) {
244 char md5sum[33];
245 md5sumToString(md5sum, lastof(md5sum), HasBit(c->flags, GCF_COMPATIBLE) ? c->original_md5sum : c->ident.md5sum);
246 p += seprintf(p, lastof(buf), "%08X %s %s\n", c->ident.grfid, md5sum, c->filename);
247 }
248 }
249
250 /* ShowInfo put output to stderr, but version information should go
251 * to stdout; this is the only exception */
252 #if !defined(WIN32) && !defined(WIN64)
253 printf("%s\n", buf);
254 #else
255 ShowInfo(buf);
256 #endif
257 }
258
259
266 static void ParseResolution(Dimension *res, const char *s)
267 {
268 const char *t = strchr(s, 'x');
269 if (t == NULL) {
270 ShowInfoF("Invalid resolution '%s'", s);
271 return;
272 }
273
274 res->width = max(strtoul(s, NULL, 0), 64UL);
275 res->height = max(strtoul(t + 1, NULL, 0), 64UL);
276 }
277
278
283 static void ShutdownGame()
284 {
285 IConsoleFree();
286
287 if (_network_available) NetworkShutDown(); // Shut down the network and close any open connections
288
289 DriverFactoryBase::ShutdownDrivers();
290
291 UnInitWindowSystem();
292
293 /* stop the scripts */
294 AI::Uninitialize(false);
295 Game::Uninitialize(false);
296
297 /* Uninitialize variables that are allocated dynamically */
298 GamelogReset();
299
300 #ifdef ENABLE_NETWORK
301 free(_config_file);
302 #endif
303
304 LinkGraphSchedule::Clear();
305 PoolBase::Clean(PT_ALL);
306
307 /* No NewGRFs were loaded when it was still bootstrapping. */
308 if (_game_mode != GM_BOOTSTRAP) ResetNewGRFData();
309
310 /* Close all and any open filehandles */
311 FioCloseAll();
312
313 UninitFreeType();
314 }
315
320 static void LoadIntroGame(bool load_newgrfs = true)
321 {
322 _game_mode = GM_MENU;
323
324 if (load_newgrfs) ResetGRFConfig(false);
325
326 /* Setup main window */
327 ResetWindowSystem();
328 SetupColoursAndInitialWindow();
329
330 /* Load the default opening screen savegame */
331 if (SaveOrLoad("opntitle.dat", SLO_LOAD, DFT_GAME_FILE, BASESET_DIR) != SL_OK) {
332 GenerateWorld(GWM_EMPTY, 64, 64); // if failed loading, make empty world.
333 WaitTillGeneratedWorld();
334 SetLocalCompany(COMPANY_SPECTATOR);
335 } else {
336 SetLocalCompany(COMPANY_FIRST);
337 }
338
339 _pause_mode = PM_UNPAUSED;
340 _cursor.fix_at = false;
341
342 if (load_newgrfs) CheckForMissingSprites();
343 CheckForMissingGlyphs();
344
345 /* Play main theme */
346 if (MusicDriver::GetInstance()->IsSongPlaying()) ResetMusic();
347 }
348
349 void MakeNewgameSettingsLive()
350 {
351 for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) {
352 if (_settings_game.ai_config[c] != NULL) {
353 delete _settings_game.ai_config[c];
354 }
355 }
356 if (_settings_game.game_config != NULL) {
357 delete _settings_game.game_config;
358 }
359
360 /* Copy newgame settings to active settings.
361 * Also initialise old settings needed for savegame conversion. */
362 _settings_game = _settings_newgame;
363 _old_vds = _settings_client.company.vehicle;
364
365 for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) {
366 _settings_game.ai_config[c] = NULL;
367 if (_settings_newgame.ai_config[c] != NULL) {
368 _settings_game.ai_config[c] = new AIConfig(_settings_newgame.ai_config[c]);
369 }
370 }
371 _settings_game.game_config = NULL;
372 if (_settings_newgame.game_config != NULL) {
373 _settings_game.game_config = new GameConfig(_settings_newgame.game_config);
374 }
375 }
376
377 void OpenBrowser(const char *url)
378 {
379 /* Make sure we only accept urls that are sure to open a browser. */
380 if (strstr(url, "http://") != url && strstr(url, "https://") != url) return;
381
382 extern void OSOpenBrowser(const char *url);
383 OSOpenBrowser(url);
384 }
385
387 struct AfterNewGRFScan : NewGRFScanCallback {
388 Year startyear;
389 uint generation_seed;
390 char *dedicated_host;
391 uint16 dedicated_port;
392 char *network_conn;
393 const char *join_server_password;
394 const char *join_company_password;
395 bool *save_config_ptr;
396 bool save_config;
397
403 AfterNewGRFScan(bool *save_config_ptr) :
404 startyear(INVALID_YEAR), generation_seed(GENERATE_NEW_SEED),
405 dedicated_host(NULL), dedicated_port(0), network_conn(NULL),
406 join_server_password(NULL), join_company_password(NULL),
407 save_config_ptr(save_config_ptr), save_config(true)
408 {
409 }
410
411 virtual void OnNewGRFsScanned()
412 {
413 ResetGRFConfig(false);
414
415 TarScanner::DoScan(TarScanner::SCENARIO);
416
417 AI::Initialize();
418 Game::Initialize();
419
420 /* We want the new (correct) NewGRF count to survive the loading. */
421 uint last_newgrf_count = _settings_client.gui.last_newgrf_count;
422 LoadFromConfig();
423 _settings_client.gui.last_newgrf_count = last_newgrf_count;
424 /* Since the default for the palette might have changed due to
425 * reading the configuration file, recalculate that now. */
426 UpdateNewGRFConfigPalette();
427
428 Game::Uninitialize(true);
429 AI::Uninitialize(true);
430 CheckConfig();
431 LoadFromHighScore();
432 LoadHotkeysFromConfig();
433 WindowDesc::LoadFromConfig();
434
435 /* We have loaded the config, so we may possibly save it. */
436 *save_config_ptr = save_config;
437
438 /* restore saved music volume */
439 MusicDriver::GetInstance()->SetVolume(_settings_client.music.music_vol);
440
441 if (startyear != INVALID_YEAR) _settings_newgame.game_creation.starting_year = startyear;
442 if (generation_seed != GENERATE_NEW_SEED) _settings_newgame.game_creation.generation_seed = generation_seed;
443
444 #if defined(ENABLE_NETWORK)
445 if (dedicated_host != NULL) {
446 _network_bind_list.Clear();
447 *_network_bind_list.Append() = stredup(dedicated_host);
448 }
449 if (dedicated_port != 0) _settings_client.network.server_port = dedicated_port;
450 #endif /* ENABLE_NETWORK */
451
452 /* initialize the ingame console */
453 IConsoleInit();
454 InitializeGUI();
455 IConsoleCmdExec("exec scripts/autoexec.scr 0");
456
457 /* Make sure _settings is filled with _settings_newgame if we switch to a game directly */
458 if (_switch_mode != SM_NONE) MakeNewgameSettingsLive();
459
460 #ifdef ENABLE_NETWORK
461 if (_network_available && network_conn != NULL) {
462 const char *port = NULL;
463 const char *company = NULL;
464 uint16 rport = NETWORK_DEFAULT_PORT;
465 CompanyID join_as = COMPANY_NEW_COMPANY;
466
467 ParseConnectionString(&company, &port, network_conn);
468
469 if (company != NULL) {
470 join_as = (CompanyID)atoi(company);
471
472 if (join_as != COMPANY_SPECTATOR) {
473 join_as--;
474 if (join_as >= MAX_COMPANIES) {
475 delete this;
476 return;
477 }
478 }
479 }
480 if (port != NULL) rport = atoi(port);
481
482 LoadIntroGame();
483 _switch_mode = SM_NONE;
484 NetworkClientConnectGame(NetworkAddress(network_conn, rport), join_as, join_server_password, join_company_password);
485 }
486 #endif /* ENABLE_NETWORK */
487
488 /* After the scan we're not used anymore. */
489 delete this;
490 }
491 };
492
493 #if defined(UNIX) && !defined(__MORPHOS__)
494 extern void DedicatedFork();
495 #endif
496
498 static const OptionData _options[] = {
499 GETOPT_SHORT_VALUE('I'),
500 GETOPT_SHORT_VALUE('S'),
501 GETOPT_SHORT_VALUE('M'),
502 GETOPT_SHORT_VALUE('m'),
503 GETOPT_SHORT_VALUE('s'),
504 GETOPT_SHORT_VALUE('v'),
505 GETOPT_SHORT_VALUE('b'),
506 #if defined(ENABLE_NETWORK)
507 GETOPT_SHORT_OPTVAL('D'),
508 GETOPT_SHORT_OPTVAL('n'),
509 GETOPT_SHORT_VALUE('l'),
510 GETOPT_SHORT_VALUE('p'),
511 GETOPT_SHORT_VALUE('P'),
512 #if !defined(__MORPHOS__) && !defined(__AMIGA__) && !defined(WIN32)
513 GETOPT_SHORT_NOVAL('f'),
514 #endif
515 #endif /* ENABLE_NETWORK */
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 = NULL;
538 char *sounddriver = NULL;
539 char *videodriver = NULL;
540 char *blitter = NULL;
541 char *graphics_set = NULL;
542 char *sounds_set = NULL;
543 char *music_set = NULL;
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 #if defined(ENABLE_NETWORK)
549 bool dedicated = false;
550 char *debuglog_conn = NULL;
551
552 extern bool _dedicated_forks;
553 _dedicated_forks = false;
554 #endif /* ENABLE_NETWORK */
555
556 _game_mode = GM_MENU;
557 _switch_mode = SM_MENU;
558 _config_file = NULL;
559
560 GetOptData mgo(argc - 1, argv + 1, _options);
561 int ret = 0;
562
563 int i;
564 while ((i = mgo.GetOpt()) != -1) {
565 switch (i) {
566 case 'I': free(graphics_set); graphics_set = stredup(mgo.opt); break;
567 case 'S': free(sounds_set); sounds_set = stredup(mgo.opt); break;
568 case 'M': free(music_set); music_set = stredup(mgo.opt); break;
569 case 'm': free(musicdriver); musicdriver = stredup(mgo.opt); break;
570 case 's': free(sounddriver); sounddriver = stredup(mgo.opt); break;
571 case 'v': free(videodriver); videodriver = stredup(mgo.opt); break;
572 case 'b': free(blitter); blitter = stredup(mgo.opt); break;
573 #if defined(ENABLE_NETWORK)
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 != NULL) {
586 /* Use the existing method for parsing (openttd -n).
587 * However, we do ignore the #company part. */
588 const char *temp = NULL;
589 const char *port = NULL;
590 ParseConnectionString(&temp, &port, mgo.opt);
591 if (!StrEmpty(mgo.opt)) scanner->dedicated_host = mgo.opt;
592 if (port != NULL) 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, NULL 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 #endif /* ENABLE_NETWORK */
609 case 'r': ParseResolution(&resolution, mgo.opt); break;
610 case 't': scanner->startyear = atoi(mgo.opt); break;
611 case 'd': {
612 #if defined(WIN32)
613 CreateConsole();
614 #endif
615 if (mgo.opt != NULL) SetDebugString(mgo.opt);
616 break;
617 }
618 case 'e': _switch_mode = (_switch_mode == SM_LOAD_GAME || _switch_mode == SM_LOAD_SCENARIO ? SM_LOAD_SCENARIO : SM_EDITOR); break;
619 case 'g':
620 if (mgo.opt != NULL) {
621 _file_to_saveload.SetName(mgo.opt);
622 bool is_scenario = _switch_mode == SM_EDITOR || _switch_mode == SM_LOAD_SCENARIO;
623 _switch_mode = is_scenario ? SM_LOAD_SCENARIO : SM_LOAD_GAME;
624 _file_to_saveload.SetMode(SLO_LOAD, is_scenario ? FT_SCENARIO : FT_SAVEGAME, DFT_GAME_FILE);
625
626 /* if the file doesn't exist or it is not a valid savegame, let the saveload code show an error */
627 const char *t = strrchr(_file_to_saveload.name, '.');
628 if (t != NULL) {
629 FiosType ft = FiosGetSavegameListCallback(SLO_LOAD, _file_to_saveload.name, t, NULL, NULL);
630 if (ft != FIOS_TYPE_INVALID) _file_to_saveload.SetMode(ft);
631 }
632
633 break;
634 }
635
636 _switch_mode = SM_NEWGAME;
637 /* Give a random map if no seed has been given */
638 if (scanner->generation_seed == GENERATE_NEW_SEED) {
639 scanner->generation_seed = InteractiveRandom();
640 }
641 break;
642 case 'q': {
643 DeterminePaths(argv[0]);
644 if (StrEmpty(mgo.opt)) {
645 ret = 1;
646 goto exit_noshutdown;
647 }
648
649 char title[80];
650 title[0] = '\0';
651 FiosGetSavegameListCallback(SLO_LOAD, mgo.opt, strrchr(mgo.opt, '.'), title, lastof(title));
652
653 _load_check_data.Clear();
654 SaveOrLoadResult res = SaveOrLoad(mgo.opt, SLO_CHECK, DFT_GAME_FILE, SAVE_DIR, false);
655 if (res != SL_OK || _load_check_data.HasErrors()) {
656 fprintf(stderr, "Failed to open savegame\n");
657 if (_load_check_data.HasErrors()) {
658 char buf[256];
659 SetDParamStr(0, _load_check_data.error_data);
660 GetString(buf, _load_check_data.error, lastof(buf));
661 fprintf(stderr, "%s\n", buf);
662 }
663 goto exit_noshutdown;
664 }
665
666 WriteSavegameInfo(title);
667
668 goto exit_noshutdown;
669 }
670 case 'G': scanner->generation_seed = atoi(mgo.opt); break;
671 case 'c': free(_config_file); _config_file = stredup(mgo.opt); break;
672 case 'x': scanner->save_config = false; break;
673 case 'h':
674 i = -2; // Force printing of help.
675 break;
676 }
677 if (i == -2) break;
678 }
679
680 if (i == -2 || mgo.numleft > 0) {
681 /* Either the user typed '-h', he made an error, or he added unrecognized command line arguments.
682 * In all cases, print the help, and exit.
683 *
684 * The next two functions are needed to list the graphics sets. We can't do them earlier
685 * because then we cannot show it on the debug console as that hasn't been configured yet. */
686 DeterminePaths(argv[0]);
687 TarScanner::DoScan(TarScanner::BASESET);
688 BaseGraphics::FindSets();
689 BaseSounds::FindSets();
690 BaseMusic::FindSets();
691 ShowHelp();
692
693 goto exit_noshutdown;
694 }
695
696 #if defined(WINCE) && defined(_DEBUG)
697 /* Switch on debug lvl 4 for WinCE if Debug release, as you can't give params, and you most likely do want this information */
698 SetDebugString("4");
699 #endif
700
701 DeterminePaths(argv[0]);
702 TarScanner::DoScan(TarScanner::BASESET);
703
704 #if defined(ENABLE_NETWORK)
705 if (dedicated) DEBUG(net, 0, "Starting dedicated version %s", _openttd_revision);
706 if (_dedicated_forks && !dedicated) _dedicated_forks = false;
707
708 #if defined(UNIX) && !defined(__MORPHOS__)
709 /* We must fork here, or we'll end up without some resources we need (like sockets) */
710 if (_dedicated_forks) DedicatedFork();
711 #endif
712 #endif
713
714 LoadFromConfig(true);
715
716 if (resolution.width != 0) _cur_resolution = resolution;
717
718 /*
719 * The width and height must be at least 1 pixel and width times
720 * height times bytes per pixel must still fit within a 32 bits
721 * integer, even for 32 bpp video modes. This way all internal
722 * drawing routines work correctly.
723 */
724 _cur_resolution.width = ClampU(_cur_resolution.width, 1, UINT16_MAX / 2);
725 _cur_resolution.height = ClampU(_cur_resolution.height, 1, UINT16_MAX / 2);
726
727 /* Assume the cursor starts within the game as not all video drivers
728 * get an event that the cursor is within the window when it is opened.
729 * Saying the cursor is there makes no visible difference as it would
730 * just be out of the bounds of the window. */
731 _cursor.in_window = true;
732
733 /* enumerate language files */
734 InitializeLanguagePacks();
735
736 /* Initialize the regular font for FreeType */
737 InitFreeType(false);
738
739 /* This must be done early, since functions use the SetWindowDirty* calls */
740 InitWindowSystem();
741
742 BaseGraphics::FindSets();
743 if (graphics_set == NULL && BaseGraphics::ini_set != NULL) graphics_set = stredup(BaseGraphics::ini_set);
744 if (!BaseGraphics::SetSet(graphics_set)) {
745 if (!StrEmpty(graphics_set)) {
746 BaseGraphics::SetSet(NULL);
747
748 ErrorMessageData msg(STR_CONFIG_ERROR, STR_CONFIG_ERROR_INVALID_BASE_GRAPHICS_NOT_FOUND);
749 msg.SetDParamStr(0, graphics_set);
750 ScheduleErrorMessage(msg);
751 }
752 }
753 free(graphics_set);
754
755 /* Initialize game palette */
756 GfxInitPalettes();
757
758 DEBUG(misc, 1, "Loading blitter...");
759 if (blitter == NULL && _ini_blitter != NULL) blitter = stredup(_ini_blitter);
760 _blitter_autodetected = StrEmpty(blitter);
761 /* Activate the initial blitter.
762 * This is only some initial guess, after NewGRFs have been loaded SwitchNewGRFBlitter may switch to a different one.
763 * - Never guess anything, if the user specified a blitter. (_blitter_autodetected)
764 * - Use 32bpp blitter if baseset or 8bpp-support settings says so.
765 * - Use 8bpp blitter otherwise.
766 */
767 if (!_blitter_autodetected ||
768 (_support8bpp != S8BPP_NONE && (BaseGraphics::GetUsedSet() == NULL || BaseGraphics::GetUsedSet()->blitter == BLT_8BPP)) ||
769 BlitterFactory::SelectBlitter("32bpp-anim") == NULL) {
770 if (BlitterFactory::SelectBlitter(blitter) == NULL) {
771 StrEmpty(blitter) ?
772 usererror("Failed to autoprobe blitter") :
773 usererror("Failed to select requested blitter '%s'; does it exist?", blitter);
774 }
775 }
776 free(blitter);
777
778 if (videodriver == NULL && _ini_videodriver != NULL) videodriver = stredup(_ini_videodriver);
779 DriverFactoryBase::SelectDriver(videodriver, Driver::DT_VIDEO);
780 free(videodriver);
781
782 InitializeSpriteSorter();
783
784 /* Initialize the zoom level of the screen to normal */
785 _screen.zoom = ZOOM_LVL_NORMAL;
786
787 NetworkStartUp(); // initialize network-core
788
789 #if defined(ENABLE_NETWORK)
790 if (debuglog_conn != NULL && _network_available) {
791 const char *not_used = NULL;
792 const char *port = NULL;
793 uint16 rport;
794
795 rport = NETWORK_DEFAULT_DEBUGLOG_PORT;
796
797 ParseConnectionString(&not_used, &port, debuglog_conn);
798 if (port != NULL) rport = atoi(port);
799
800 NetworkStartDebugLog(NetworkAddress(debuglog_conn, rport));
801 }
802 #endif /* ENABLE_NETWORK */
803
804 if (!HandleBootstrap()) {
805 ShutdownGame();
806
807 goto exit_bootstrap;
808 }
809
810 VideoDriver::GetInstance()->ClaimMousePointer();
811
812 /* initialize screenshot formats */
813 InitializeScreenshotFormats();
814
815 BaseSounds::FindSets();
816 if (sounds_set == NULL && BaseSounds::ini_set != NULL) sounds_set = stredup(BaseSounds::ini_set);
817 if (!BaseSounds::SetSet(sounds_set)) {
818 if (StrEmpty(sounds_set) || !BaseSounds::SetSet(NULL)) {
819 usererror("Failed to find a sounds set. Please acquire a sounds set for OpenTTD. See section 4.1 of readme.txt.");
820 } else {
821 ErrorMessageData msg(STR_CONFIG_ERROR, STR_CONFIG_ERROR_INVALID_BASE_SOUNDS_NOT_FOUND);
822 msg.SetDParamStr(0, sounds_set);
823 ScheduleErrorMessage(msg);
824 }
825 }
826 free(sounds_set);
827
828 BaseMusic::FindSets();
829 if (music_set == NULL && BaseMusic::ini_set != NULL) music_set = stredup(BaseMusic::ini_set);
830 if (!BaseMusic::SetSet(music_set)) {
831 if (StrEmpty(music_set) || !BaseMusic::SetSet(NULL)) {
832 usererror("Failed to find a music set. Please acquire a music set for OpenTTD. See section 4.1 of readme.txt.");
833 } else {
834 ErrorMessageData msg(STR_CONFIG_ERROR, STR_CONFIG_ERROR_INVALID_BASE_MUSIC_NOT_FOUND);
835 msg.SetDParamStr(0, music_set);
836 ScheduleErrorMessage(msg);
837 }
838 }
839 free(music_set);
840
841 if (sounddriver == NULL && _ini_sounddriver != NULL) sounddriver = stredup(_ini_sounddriver);
842 DriverFactoryBase::SelectDriver(sounddriver, Driver::DT_SOUND);
843 free(sounddriver);
844
845 if (musicdriver == NULL && _ini_musicdriver != NULL) musicdriver = stredup(_ini_musicdriver);
846 DriverFactoryBase::SelectDriver(musicdriver, Driver::DT_MUSIC);
847 free(musicdriver);
848
849 /* Take our initial lock on whatever we might want to do! */
850 _modal_progress_paint_mutex->BeginCritical();
851 _modal_progress_work_mutex->BeginCritical();
852
853 GenerateWorld(GWM_EMPTY, 64, 64); // Make the viewport initialization happy
854 WaitTillGeneratedWorld();
855
856 LoadIntroGame(false);
857
858 CheckForMissingGlyphs();
859
860 /* ScanNewGRFFiles now has control over the scanner. */
861 ScanNewGRFFiles(scanner);
862 scanner = NULL;
863
864 VideoDriver::GetInstance()->MainLoop();
865
866 WaitTillSaved();
867
868 /* only save config if we have to */
869 if (save_config) {
870 SaveToConfig();
871 SaveHotkeysToConfig();
872 WindowDesc::SaveToConfig();
873 SaveToHighScore();
874 }
875
876 /* Reset windowing system, stop drivers, free used memory, ... */
877 ShutdownGame();
878 goto exit_normal;
879
880 exit_noshutdown:
881 /* These three are normally freed before bootstrap. */
882 free(graphics_set);
883 free(videodriver);
884 free(blitter);
885
886 exit_bootstrap:
887 /* These are normally freed before exit, but after bootstrap. */
888 free(sounds_set);
889 free(music_set);
890 free(musicdriver);
891 free(sounddriver);
892
893 exit_normal:
894 free(BaseGraphics::ini_set);
895 free(BaseSounds::ini_set);
896 free(BaseMusic::ini_set);
897
898 free(_ini_musicdriver);
899 free(_ini_sounddriver);
900 free(_ini_videodriver);
901 free(_ini_blitter);
902
903 delete scanner;
904
905 #ifdef ENABLE_NETWORK
906 extern FILE *_log_fd;
907 if (_log_fd != NULL) {
908 fclose(_log_fd);
909 }
910 #endif /* ENABLE_NETWORK */
911
912 return ret;
913 }
914
915 void HandleExitGameRequest()
916 {
917 if (_game_mode == GM_MENU || _game_mode == GM_BOOTSTRAP) { // do not ask to quit on the main screen
918 _exit_game = true;
919 } else if (_settings_client.gui.autosave_on_exit) {
920 DoExitSave();
921 _exit_game = true;
922 } else {
923 AskExitGame();
924 }
925 }
926
927 static void MakeNewGameDone()
928 {
929 SettingsDisableElrail(_settings_game.vehicle.disable_elrails);
930
931 /* In a dedicated server, the server does not play */
932 if (!VideoDriver::GetInstance()->HasGUI()) {
933 SetLocalCompany(COMPANY_SPECTATOR);
934 if (_settings_client.gui.pause_on_newgame) DoCommandP(0, PM_PAUSED_NORMAL, 1, CMD_PAUSE);
935 IConsoleCmdExec("exec scripts/game_start.scr 0");
936 return;
937 }
938
939 /* Create a single company */
940 DoStartupNewCompany(false);
941
942 Company *c = Company::Get(COMPANY_FIRST);
943 c->settings = _settings_client.company;
944
945 IConsoleCmdExec("exec scripts/game_start.scr 0");
946
947 SetLocalCompany(COMPANY_FIRST);
948
949 InitializeRailGUI();
950
951 #ifdef ENABLE_NETWORK
952 /* We are the server, we start a new company (not dedicated),
953 * so set the default password *if* needed. */
954 if (_network_server && !StrEmpty(_settings_client.network.default_company_pass)) {
955 NetworkChangeCompanyPassword(_local_company, _settings_client.network.default_company_pass);
956 }
957 #endif /* ENABLE_NETWORK */
958
959 if (_settings_client.gui.pause_on_newgame) DoCommandP(0, PM_PAUSED_NORMAL, 1, CMD_PAUSE);
960
961 CheckEngines();
962 CheckIndustries();
963 MarkWholeScreenDirty();
964 }
965
966 static void MakeNewGame(bool from_heightmap, bool reset_settings)
967 {
968 _game_mode = GM_NORMAL;
969
970 ResetGRFConfig(true);
971
972 GenerateWorldSetCallback(&MakeNewGameDone);
973 GenerateWorld(from_heightmap ? GWM_HEIGHTMAP : GWM_NEWGAME, 1 << _settings_game.game_creation.map_x, 1 << _settings_game.game_creation.map_y, reset_settings);
974 }
975
976 static void MakeNewEditorWorldDone()
977 {
978 SetLocalCompany(OWNER_NONE);
979 }
980
981 static void MakeNewEditorWorld()
982 {
983 _game_mode = GM_EDITOR;
984
985 ResetGRFConfig(true);
986
987 GenerateWorldSetCallback(&MakeNewEditorWorldDone);
988 GenerateWorld(GWM_EMPTY, 1 << _settings_game.game_creation.map_x, 1 << _settings_game.game_creation.map_y);
989 }
990
1001 bool SafeLoad(const char *filename, SaveLoadOperation fop, DetailedFileType dft, GameMode newgm, Subdirectory subdir, struct LoadFilter *lf = NULL)
1002 {
1003 assert(fop == SLO_LOAD);
1004 assert(dft == DFT_GAME_FILE || (lf == NULL && dft == DFT_OLD_GAME_FILE));
1005 GameMode ogm = _game_mode;
1006
1007 _game_mode = newgm;
1008
1009 switch (lf == NULL ? SaveOrLoad(filename, fop, dft, subdir) : LoadWithFilter(lf)) {
1010 case SL_OK: return true;
1011
1012 case SL_REINIT:
1013 #ifdef ENABLE_NETWORK
1014 if (_network_dedicated) {
1015 /*
1016 * We need to reinit a network map...
1017 * We can't simply load the intro game here as that game has many
1018 * special cases which make clients desync immediately. So we fall
1019 * back to just generating a new game with the current settings.
1020 */
1021 DEBUG(net, 0, "Loading game failed, so a new (random) game will be started!");
1022 MakeNewGame(false, true);
1023 return false;
1024 }
1025 if (_network_server) {
1026 /* We can't load the intro game as server, so disconnect first. */
1027 NetworkDisconnect();
1028 }
1029 #endif /* ENABLE_NETWORK */
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 #ifdef ENABLE_NETWORK
1047 /* If we are saving something, the network stays in his current state */
1048 if (new_mode != SM_SAVE_GAME) {
1049 /* If the network is active, make it not-active */
1050 if (_networking) {
1051 if (_network_server && (new_mode == SM_LOAD_GAME || new_mode == SM_NEWGAME || new_mode == SM_RESTARTGAME)) {
1052 NetworkReboot();
1053 } else {
1054 NetworkDisconnect();
1055 }
1056 }
1057
1058 /* If we are a server, we restart the server */
1059 if (_is_network_server) {
1060 /* But not if we are going to the menu */
1061 if (new_mode != SM_MENU) {
1062 /* check if we should reload the config */
1063 if (_settings_client.network.reload_cfg) {
1064 LoadFromConfig();
1065 MakeNewgameSettingsLive();
1066 ResetGRFConfig(false);
1067 }
1068 NetworkServerStart();
1069 } else {
1070 /* This client no longer wants to be a network-server */
1071 _is_network_server = false;
1072 }
1073 }
1074 }
1075 #endif /* ENABLE_NETWORK */
1076 /* Make sure all AI controllers are gone at quitting game */
1077 if (new_mode != SM_SAVE_GAME) AI::KillAll();
1078
1079 switch (new_mode) {
1080 case SM_EDITOR: // Switch to scenario editor
1081 MakeNewEditorWorld();
1082 break;
1083
1084 case SM_RESTARTGAME: // Restart --> 'Random game' with current settings
1085 case SM_NEWGAME: // New Game --> 'Random game'
1086 #ifdef ENABLE_NETWORK
1087 if (_network_server) {
1088 seprintf(_network_game_info.map_name, lastof(_network_game_info.map_name), "Random Map");
1089 }
1090 #endif /* ENABLE_NETWORK */
1091 MakeNewGame(false, new_mode == SM_NEWGAME);
1092 break;
1093
1094 case SM_LOAD_GAME: { // Load game, Play Scenario
1095 ResetGRFConfig(true);
1096 ResetWindowSystem();
1097
1098 if (!SafeLoad(_file_to_saveload.name, _file_to_saveload.file_op, _file_to_saveload.detail_ftype, GM_NORMAL, NO_DIRECTORY)) {
1099 SetDParamStr(0, GetSaveLoadErrorString());
1100 ShowErrorMessage(STR_JUST_RAW_STRING, INVALID_STRING_ID, WL_ERROR);
1101 } else {
1102 if (_file_to_saveload.abstract_ftype == FT_SCENARIO) {
1103 /* Reset engine pool to simplify changing engine NewGRFs in scenario editor. */
1104 EngineOverrideManager::ResetToCurrentNewGRFConfig();
1105 }
1106 /* Update the local company for a loaded game. It is either always
1107 * company #1 (eg 0) or in the case of a dedicated server a spectator */
1108 SetLocalCompany(_network_dedicated ? COMPANY_SPECTATOR : COMPANY_FIRST);
1109 /* Execute the game-start script */
1110 IConsoleCmdExec("exec scripts/game_start.scr 0");
1111 /* Decrease pause counter (was increased from opening load dialog) */
1112 DoCommandP(0, PM_PAUSED_SAVELOAD, 0, CMD_PAUSE);
1113 #ifdef ENABLE_NETWORK
1114 if (_network_server) {
1115 seprintf(_network_game_info.map_name, lastof(_network_game_info.map_name), "%s (Loaded game)", _file_to_saveload.title);
1116 }
1117 #endif /* ENABLE_NETWORK */
1118 }
1119 break;
1120 }
1121
1122 case SM_START_HEIGHTMAP: // Load a heightmap and start a new game from it
1123 #ifdef ENABLE_NETWORK
1124 if (_network_server) {
1125 seprintf(_network_game_info.map_name, lastof(_network_game_info.map_name), "%s (Heightmap)", _file_to_saveload.title);
1126 }
1127 #endif /* ENABLE_NETWORK */
1128 MakeNewGame(true, true);
1129 break;
1130
1131 case SM_LOAD_HEIGHTMAP: // Load heightmap from scenario editor
1132 SetLocalCompany(OWNER_NONE);
1133
1134 GenerateWorld(GWM_HEIGHTMAP, 1 << _settings_game.game_creation.map_x, 1 << _settings_game.game_creation.map_y);
1135 MarkWholeScreenDirty();
1136 break;
1137
1138 case SM_LOAD_SCENARIO: { // Load scenario from scenario editor
1139 if (SafeLoad(_file_to_saveload.name, _file_to_saveload.file_op, _file_to_saveload.detail_ftype, GM_EDITOR, NO_DIRECTORY)) {
1140 SetLocalCompany(OWNER_NONE);
1141 _settings_newgame.game_creation.starting_year = _cur_year;
1142 /* Cancel the saveload pausing */
1143 DoCommandP(0, PM_PAUSED_SAVELOAD, 0, CMD_PAUSE);
1144 } else {
1145 SetDParamStr(0, GetSaveLoadErrorString());
1146 ShowErrorMessage(STR_JUST_RAW_STRING, INVALID_STRING_ID, WL_ERROR);
1147 }
1148 break;
1149 }
1150
1151 case SM_MENU: // Switch to game intro menu
1152 LoadIntroGame();
1153 if (BaseSounds::ini_set == NULL && BaseSounds::GetUsedSet()->fallback) {
1154 ShowErrorMessage(STR_WARNING_FALLBACK_SOUNDSET, INVALID_STRING_ID, WL_CRITICAL);
1155 BaseSounds::ini_set = stredup(BaseSounds::GetUsedSet()->name);
1156 }
1157 break;
1158
1159 case SM_SAVE_GAME: // Save game.
1160 /* Make network saved games on pause compatible to singleplayer */
1161 if (SaveOrLoad(_file_to_saveload.name, SLO_SAVE, DFT_GAME_FILE, NO_DIRECTORY) != SL_OK) {
1162 SetDParamStr(0, GetSaveLoadErrorString());
1163 ShowErrorMessage(STR_JUST_RAW_STRING, INVALID_STRING_ID, WL_ERROR);
1164 } else {
1165 DeleteWindowById(WC_SAVELOAD, 0);
1166 }
1167 break;
1168
1169 case SM_SAVE_HEIGHTMAP: // Save heightmap.
1170 MakeHeightmapScreenshot(_file_to_saveload.name);
1171 DeleteWindowById(WC_SAVELOAD, 0);
1172 break;
1173
1174 case SM_GENRANDLAND: // Generate random land within scenario editor
1175 SetLocalCompany(OWNER_NONE);
1176 GenerateWorld(GWM_RANDOM, 1 << _settings_game.game_creation.map_x, 1 << _settings_game.game_creation.map_y);
1177 /* XXX: set date */
1178 MarkWholeScreenDirty();
1179 break;
1180
1181 default: NOT_REACHED();
1182 }
1183 }
1184
1185
1192 static void CheckCaches()
1193 {
1194 /* Return here so it is easy to add checks that are run
1195 * always to aid testing of caches. */
1196 if (_debug_desync_level <= 1) return;
1197
1198 /* Check the town caches. */
1199 SmallVector<TownCache, 4> old_town_caches;
1200 Town *t;
1201 FOR_ALL_TOWNS(t) {
1202 MemCpyT(old_town_caches.Append(), &t->cache);
1203 }
1204
1205 extern void RebuildTownCaches();
1206 RebuildTownCaches();
1207 RebuildSubsidisedSourceAndDestinationCache();
1208
1209 uint i = 0;
1210 FOR_ALL_TOWNS(t) {
1211 if (MemCmpT(old_town_caches.Get(i), &t->cache) != 0) {
1212 DEBUG(desync, 2, "town cache mismatch: town %i", (int)t->index);
1213 }
1214 i++;
1215 }
1216
1217 /* Check company infrastructure cache. */
1218 SmallVector<CompanyInfrastructure, 4> old_infrastructure;
1219 Company *c;
1220 FOR_ALL_COMPANIES(c) MemCpyT(old_infrastructure.Append(), &c->infrastructure);
1221
1222 extern void AfterLoadCompanyStats();
1223 AfterLoadCompanyStats();
1224
1225 i = 0;
1226 FOR_ALL_COMPANIES(c) {
1227 if (MemCmpT(old_infrastructure.Get(i), &c->infrastructure) != 0) {
1228 DEBUG(desync, 2, "infrastructure cache mismatch: company %i", (int)c->index);
1229 }
1230 i++;
1231 }
1232
1233 /* Strict checking of the road stop cache entries */
1234 const RoadStop *rs;
1235 FOR_ALL_ROADSTOPS(rs) {
1236 if (IsStandardRoadStopTile(rs->xy)) continue;
1237
1238 assert(rs->GetEntry(DIAGDIR_NE) != rs->GetEntry(DIAGDIR_NW));
1239 rs->GetEntry(DIAGDIR_NE)->CheckIntegrity(rs);
1240 rs->GetEntry(DIAGDIR_NW)->CheckIntegrity(rs);
1241 }
1242
1243 Vehicle *v;
1244 FOR_ALL_VEHICLES(v) {
1245 extern void FillNewGRFVehicleCache(const Vehicle *v);
1246 if (v != v->First() || v->vehstatus & VS_CRASHED || !v->IsPrimaryVehicle()) continue;
1247
1248 uint length = 0;
1249 for (const Vehicle *u = v; u != NULL; u = u->Next()) length++;
1250
1251 NewGRFCache *grf_cache = CallocT<NewGRFCache>(length);
1252 VehicleCache *veh_cache = CallocT<VehicleCache>(length);
1253 GroundVehicleCache *gro_cache = CallocT<GroundVehicleCache>(length);
1254 TrainCache *tra_cache = CallocT<TrainCache>(length);
1255
1256 length = 0;
1257 for (const Vehicle *u = v; u != NULL; u = u->Next()) {
1258 FillNewGRFVehicleCache(u);
1259 grf_cache[length] = u->grf_cache;
1260 veh_cache[length] = u->vcache;
1261 switch (u->type) {
1262 case VEH_TRAIN:
1263 gro_cache[length] = Train::From(u)->gcache;
1264 tra_cache[length] = Train::From(u)->tcache;
1265 break;
1266 case VEH_ROAD:
1267 gro_cache[length] = RoadVehicle::From(u)->gcache;
1268 break;
1269 default:
1270 break;
1271 }
1272 length++;
1273 }
1274
1275 switch (v->type) {
1276 case VEH_TRAIN: Train::From(v)->ConsistChanged(CCF_TRACK); break;
1277 case VEH_ROAD: RoadVehUpdateCache(RoadVehicle::From(v)); break;
1278 case VEH_AIRCRAFT: UpdateAircraftCache(Aircraft::From(v)); break;
1279 case VEH_SHIP: Ship::From(v)->UpdateCache(); break;
1280 default: break;
1281 }
1282
1283 length = 0;
1284 for (const Vehicle *u = v; u != NULL; u = u->Next()) {
1285 FillNewGRFVehicleCache(u);
1286 if (memcmp(&grf_cache[length], &u->grf_cache, sizeof(NewGRFCache)) != 0) {
1287 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);
1288 }
1289 if (memcmp(&veh_cache[length], &u->vcache, sizeof(VehicleCache)) != 0) {
1290 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);
1291 }
1292 switch (u->type) {
1293 case VEH_TRAIN:
1294 if (memcmp(&gro_cache[length], &Train::From(u)->gcache, sizeof(GroundVehicleCache)) != 0) {
1295 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);
1296 }
1297 if (memcmp(&tra_cache[length], &Train::From(u)->tcache, sizeof(TrainCache)) != 0) {
1298 DEBUG(desync, 2, "train cache mismatch: vehicle %i, company %i, unit number %i, wagon %i", v->index, (int)v->owner, v->unitnumber, length);
1299 }
1300 break;
1301 case VEH_ROAD:
1302 if (memcmp(&gro_cache[length], &RoadVehicle::From(u)->gcache, sizeof(GroundVehicleCache)) != 0) {
1303 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);
1304 }
1305 break;
1306 default:
1307 break;
1308 }
1309 length++;
1310 }
1311
1312 free(grf_cache);
1313 free(veh_cache);
1314 free(gro_cache);
1315 free(tra_cache);
1316 }
1317
1318 /* Check whether the caches are still valid */
1319 FOR_ALL_VEHICLES(v) {
1320 byte buff[sizeof(VehicleCargoList)];
1321 memcpy(buff, &v->cargo, sizeof(VehicleCargoList));
1322 v->cargo.InvalidateCache();
1323 assert(memcmp(&v->cargo, buff, sizeof(VehicleCargoList)) == 0);
1324 }
1325
1326 Station *st;
1327 FOR_ALL_STATIONS(st) {
1328 for (CargoID c = 0; c < NUM_CARGO; c++) {
1329 byte buff[sizeof(StationCargoList)];
1330 memcpy(buff, &st->goods[c].cargo, sizeof(StationCargoList));
1331 st->goods[c].cargo.InvalidateCache();
1332 assert(memcmp(&st->goods[c].cargo, buff, sizeof(StationCargoList)) == 0);
1333 }
1334 }
1335 }
1336
1342 void StateGameLoop()
1343 {
1344 /* don't execute the state loop during pause */
1345 if (_pause_mode != PM_UNPAUSED) {
1346 UpdateLandscapingLimits();
1347 #ifndef DEBUG_DUMP_COMMANDS
1348 Game::GameLoop();
1349 #endif
1350 CallWindowTickEvent();
1351 return;
1352 }
1353 if (HasModalProgress()) return;
1354
1355 Layouter::ReduceLineCache();
1356
1357 if (_game_mode == GM_EDITOR) {
1358 BasePersistentStorageArray::SwitchMode(PSM_ENTER_GAMELOOP);
1359 RunTileLoop();
1360 CallVehicleTicks();
1361 CallLandscapeTick();
1362 BasePersistentStorageArray::SwitchMode(PSM_LEAVE_GAMELOOP);
1363 UpdateLandscapingLimits();
1364
1365 CallWindowTickEvent();
1366 NewsLoop();
1367 } else {
1368 if (_debug_desync_level > 2 && _date_fract == 0 && (_date & 0x1F) == 0) {
1369 /* Save the desync savegame if needed. */
1370 char name[MAX_PATH];
1371 seprintf(name, lastof(name), "dmp_cmds_%08x_%08x.sav", _settings_game.game_creation.generation_seed, _date);
1372 SaveOrLoad(name, SLO_SAVE, DFT_GAME_FILE, AUTOSAVE_DIR, false);
1373 }
1374
1375 CheckCaches();
1376
1377 /* All these actions has to be done from OWNER_NONE
1378 * for multiplayer compatibility */
1379 Backup<CompanyByte> cur_company(_current_company, OWNER_NONE, FILE_LINE);
1380
1381 BasePersistentStorageArray::SwitchMode(PSM_ENTER_GAMELOOP);
1382 AnimateAnimatedTiles();
1383 IncreaseDate();
1384 RunTileLoop();
1385 CallVehicleTicks();
1386 CallLandscapeTick();
1387 BasePersistentStorageArray::SwitchMode(PSM_LEAVE_GAMELOOP);
1388
1389 #ifndef DEBUG_DUMP_COMMANDS
1390 AI::GameLoop();
1391 Game::GameLoop();
1392 #endif
1393 UpdateLandscapingLimits();
1394
1395 CallWindowTickEvent();
1396 NewsLoop();
1397 cur_company.Restore();
1398 }
1399
1400 assert(IsLocalCompany());
1401 }
1402
1407 static void DoAutosave()
1408 {
1409 char buf[MAX_PATH];
1410
1411 #if defined(PSP)
1412 /* Autosaving in networking is too time expensive for the PSP */
1413 if (_networking) return;
1414 #endif /* PSP */
1415
1416 if (_settings_client.gui.keep_all_autosave) {
1417 GenerateDefaultSaveName(buf, lastof(buf));
1418 strecat(buf, ".sav", lastof(buf));
1419 } else {
1420 static int _autosave_ctr = 0;
1421
1422 /* generate a savegame name and number according to _settings_client.gui.max_num_autosaves */
1423 seprintf(buf, lastof(buf), "autosave%d.sav", _autosave_ctr);
1424
1425 if (++_autosave_ctr >= _settings_client.gui.max_num_autosaves) _autosave_ctr = 0;
1426 }
1427
1428 DEBUG(sl, 2, "Autosaving to '%s'", buf);
1429 if (SaveOrLoad(buf, SLO_SAVE, DFT_GAME_FILE, AUTOSAVE_DIR) != SL_OK) {
1430 ShowErrorMessage(STR_ERROR_AUTOSAVE_FAILED, INVALID_STRING_ID, WL_ERROR);
1431 }
1432 }
1433
1434 void GameLoop()
1435 {
1436 if (_game_mode == GM_BOOTSTRAP) {
1437 #ifdef ENABLE_NETWORK
1438 /* Check for UDP stuff */
1439 if (_network_available) NetworkBackgroundLoop();
1440 #endif
1441 InputLoop();
1442 return;
1443 }
1444
1445 ProcessAsyncSaveFinish();
1446
1447 /* autosave game? */
1448 if (_do_autosave) {
1449 DoAutosave();
1450 _do_autosave = false;
1451 SetWindowDirty(WC_STATUS_BAR, 0);
1452 }
1453
1454 /* switch game mode? */
1455 if (_switch_mode != SM_NONE && !HasModalProgress()) {
1456 SwitchToMode(_switch_mode);
1457 _switch_mode = SM_NONE;
1458 }
1459
1460 IncreaseSpriteLRU();
1461 InteractiveRandom();
1462
1463 extern int _caret_timer;
1464 _caret_timer += 3;
1465 CursorTick();
1466
1467 #ifdef ENABLE_NETWORK
1468 /* Check for UDP stuff */
1469 if (_network_available) NetworkBackgroundLoop();
1470
1471 if (_networking && !HasModalProgress()) {
1472 /* Multiplayer */
1473 NetworkGameLoop();
1474 } else {
1475 if (_network_reconnect > 0 && --_network_reconnect == 0) {
1476 /* This means that we want to reconnect to the last host
1477 * We do this here, because it means that the network is really closed */
1478 NetworkClientConnectGame(NetworkAddress(_settings_client.network.last_host, _settings_client.network.last_port), COMPANY_SPECTATOR);
1479 }
1480 /* Singleplayer */
1481 StateGameLoop();
1482 }
1483
1484 /* Check chat messages roughly once a second. */
1485 static uint check_message = 0;
1486 if (++check_message > 1000 / MILLISECONDS_PER_TICK) {
1487 check_message = 0;
1488 NetworkChatMessageLoop();
1489 }
1490 #else
1491 StateGameLoop();
1492 #endif /* ENABLE_NETWORK */
1493
1494 if (!_pause_mode && HasBit(_display_opt, DO_FULL_ANIMATION)) DoPaletteAnimations();
1495
1496 if (!_pause_mode || _game_mode == GM_EDITOR || _settings_game.construction.command_pause_level > CMDPL_NO_CONSTRUCTION) MoveAllTextEffects();
1497
1498 InputLoop();
1499
1500 SoundDriver::GetInstance()->MainLoop();
1501 MusicLoop();
1502 }