/* * This file is part of OpenTTD. * 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. * 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. * 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 . */ /** @file openttd.cpp Functions related to starting OpenTTD. */ #include "stdafx.h" #include "blitter/factory.hpp" #include "sound/sound_driver.hpp" #include "music/music_driver.hpp" #include "video/video_driver.hpp" #include "mixer.h" #include "fontcache.h" #include "error.h" #include "gui.h" #include "base_media_base.h" #include "saveload/saveload.h" #include "company_func.h" #include "command_func.h" #include "news_func.h" #include "fios.h" #include "aircraft.h" #include "roadveh.h" #include "train.h" #include "ship.h" #include "console_func.h" #include "screenshot.h" #include "network/network.h" #include "network/network_func.h" #include "ai/ai.hpp" #include "ai/ai_config.hpp" #include "settings_func.h" #include "genworld.h" #include "progress.h" #include "strings_func.h" #include "date_func.h" #include "vehicle_func.h" #include "gamelog.h" #include "animated_tile_func.h" #include "roadstop_base.h" #include "elrail_func.h" #include "rev.h" #include "highscore.h" #include "station_base.h" #include "crashlog.h" #include "engine_func.h" #include "core/random_func.hpp" #include "rail_gui.h" #include "road_gui.h" #include "core/backup_type.hpp" #include "hotkeys.h" #include "newgrf.h" #include "misc/getoptdata.h" #include "game/game.hpp" #include "game/game_config.hpp" #include "town.h" #include "subsidy_func.h" #include "gfx_layout.h" #include "viewport_func.h" #include "viewport_sprite_sorter.h" #include "framerate_type.h" #include "industry.h" #include "network/network_gui.h" #include "misc_cmd.h" #include "timer/timer.h" #include "timer/timer_game_calendar.h" #include "linkgraph/linkgraphschedule.h" #include #include #include "safeguards.h" #ifdef __EMSCRIPTEN__ # include # include #endif void CallLandscapeTick(); void DoPaletteAnimations(); void MusicLoop(); void ResetMusic(); void CallWindowGameTickEvent(); bool HandleBootstrap(); extern void AfterLoadCompanyStats(); extern Company *DoStartupNewCompany(bool is_ai, CompanyID company = INVALID_COMPANY); extern void OSOpenBrowser(const char *url); extern void RebuildTownCaches(); extern void ShowOSErrorBox(const char *buf, bool system); extern std::string _config_file; bool _save_config = false; bool _request_newgrf_scan = false; NewGRFScanCallback *_request_newgrf_scan_callback = nullptr; /** * Error handling for fatal user errors. * @param s the string to print. * @note Does NEVER return. */ void CDECL usererror(const char *s, ...) { va_list va; char buf[512]; va_start(va, s); vseprintf(buf, lastof(buf), s, va); va_end(va); ShowOSErrorBox(buf, false); if (VideoDriver::GetInstance() != nullptr) VideoDriver::GetInstance()->Stop(); #ifdef __EMSCRIPTEN__ emscripten_exit_pointerlock(); /* In effect, the game ends here. As emscripten_set_main_loop() caused * the stack to be unwound, the code after MainLoop() in * openttd_main() is never executed. */ EM_ASM(if (window["openttd_syncfs"]) openttd_syncfs()); EM_ASM(if (window["openttd_abort"]) openttd_abort()); #endif exit(1); } /** * Error handling for fatal non-user errors. * @param s the string to print. * @note Does NEVER return. */ void CDECL error(const char *s, ...) { va_list va; char buf[2048]; va_start(va, s); vseprintf(buf, lastof(buf), s, va); va_end(va); if (VideoDriver::GetInstance() == nullptr || VideoDriver::GetInstance()->HasGUI()) { ShowOSErrorBox(buf, true); } /* Set the error message for the crash log and then invoke it. */ CrashLog::SetErrorMessage(buf); abort(); } /** * Shows some information on the console/a popup box depending on the OS. * @param str the text to show. */ void CDECL ShowInfoF(const char *str, ...) { va_list va; char buf[1024]; va_start(va, str); vseprintf(buf, lastof(buf), str, va); va_end(va); ShowInfo(buf); } /** * Show the help message when someone passed a wrong parameter. */ static void ShowHelp() { char buf[8192]; char *p = buf; p += seprintf(p, lastof(buf), "OpenTTD %s\n", _openttd_revision); p = strecpy(p, "\n" "\n" "Command line options:\n" " -v drv = Set video driver (see below)\n" " -s drv = Set sound driver (see below)\n" " -m drv = Set music driver (see below)\n" " -b drv = Set the blitter to use (see below)\n" " -r res = Set resolution (for instance 800x600)\n" " -h = Display this help text\n" " -t year = Set starting year\n" " -d [[fac=]lvl[,...]]= Debug mode\n" " -e = Start Editor\n" " -g [savegame] = Start new/save game immediately\n" " -G seed = Set random seed\n" " -n [ip:port#company]= Join network game\n" " -p password = Password to join server\n" " -P password = Password to join company\n" " -D [ip][:port] = Start dedicated server\n" " -l ip[:port] = Redirect Debug()\n" #if !defined(_WIN32) " -f = Fork into the background (dedicated only)\n" #endif " -I graphics_set = Force the graphics set (see below)\n" " -S sounds_set = Force the sounds set (see below)\n" " -M music_set = Force the music set (see below)\n" " -c config_file = Use 'config_file' instead of 'openttd.cfg'\n" " -x = Never save configuration changes to disk\n" " -X = Don't use global folders to search for files\n" " -q savegame = Write some information about the savegame and exit\n" " -Q = Don't scan for/load NewGRF files on startup\n" " -QQ = Disable NewGRF scanning/loading entirely\n" "\n", lastof(buf) ); /* List the graphics packs */ p = BaseGraphics::GetSetsList(p, lastof(buf)); /* List the sounds packs */ p = BaseSounds::GetSetsList(p, lastof(buf)); /* List the music packs */ p = BaseMusic::GetSetsList(p, lastof(buf)); /* List the drivers */ p = DriverFactoryBase::GetDriversInfo(p, lastof(buf)); /* List the blitters */ p = BlitterFactory::GetBlittersInfo(p, lastof(buf)); /* List the debug facilities. */ p = DumpDebugFacilityNames(p, lastof(buf)); /* We need to initialize the AI, so it finds the AIs */ AI::Initialize(); const std::string ai_list = AI::GetConsoleList(true); p = strecpy(p, ai_list.c_str(), lastof(buf)); AI::Uninitialize(true); /* We need to initialize the GameScript, so it finds the GSs */ Game::Initialize(); const std::string game_list = Game::GetConsoleList(true); p = strecpy(p, game_list.c_str(), lastof(buf)); Game::Uninitialize(true); /* ShowInfo put output to stderr, but version information should go * to stdout; this is the only exception */ #if !defined(_WIN32) printf("%s\n", buf); #else ShowInfo(buf); #endif } static void WriteSavegameInfo(const char *name) { extern SaveLoadVersion _sl_version; uint32 last_ottd_rev = 0; byte ever_modified = 0; bool removed_newgrfs = false; GamelogInfo(_load_check_data.gamelog_action, _load_check_data.gamelog_actions, &last_ottd_rev, &ever_modified, &removed_newgrfs); char buf[8192]; char *p = buf; p += seprintf(p, lastof(buf), "Name: %s\n", name); p += seprintf(p, lastof(buf), "Savegame ver: %d\n", _sl_version); p += seprintf(p, lastof(buf), "NewGRF ver: 0x%08X\n", last_ottd_rev); p += seprintf(p, lastof(buf), "Modified: %d\n", ever_modified); if (removed_newgrfs) { p += seprintf(p, lastof(buf), "NewGRFs have been removed\n"); } p = strecpy(p, "NewGRFs:\n", lastof(buf)); if (_load_check_data.HasNewGrfs()) { for (GRFConfig *c = _load_check_data.grfconfig; c != nullptr; c = c->next) { char md5sum[33]; md5sumToString(md5sum, lastof(md5sum), HasBit(c->flags, GCF_COMPATIBLE) ? c->original_md5sum : c->ident.md5sum); p += seprintf(p, lastof(buf), "%08X %s %s\n", c->ident.grfid, md5sum, c->filename); } } /* ShowInfo put output to stderr, but version information should go * to stdout; this is the only exception */ #if !defined(_WIN32) printf("%s\n", buf); #else ShowInfo(buf); #endif } /** * Extract the resolution from the given string and store * it in the 'res' parameter. * @param res variable to store the resolution in. * @param s the string to decompose. */ static void ParseResolution(Dimension *res, const char *s) { const char *t = strchr(s, 'x'); if (t == nullptr) { ShowInfoF("Invalid resolution '%s'", s); return; } res->width = std::max(strtoul(s, nullptr, 0), 64UL); res->height = std::max(strtoul(t + 1, nullptr, 0), 64UL); } /** * Uninitializes drivers, frees allocated memory, cleans pools, ... * Generally, prepares the game for shutting down */ static void ShutdownGame() { IConsoleFree(); if (_network_available) NetworkShutDown(); // Shut down the network and close any open connections DriverFactoryBase::ShutdownDrivers(); UnInitWindowSystem(); /* stop the scripts */ AI::Uninitialize(false); Game::Uninitialize(false); /* Uninitialize variables that are allocated dynamically */ GamelogReset(); LinkGraphSchedule::Clear(); PoolBase::Clean(PT_ALL); /* No NewGRFs were loaded when it was still bootstrapping. */ if (_game_mode != GM_BOOTSTRAP) ResetNewGRFData(); UninitFontCache(); } /** * Load the introduction game. * @param load_newgrfs Whether to load the NewGRFs or not. */ static void LoadIntroGame(bool load_newgrfs = true) { _game_mode = GM_MENU; if (load_newgrfs) ResetGRFConfig(false); /* Setup main window */ ResetWindowSystem(); SetupColoursAndInitialWindow(); /* Load the default opening screen savegame */ if (SaveOrLoad("opntitle.dat", SLO_LOAD, DFT_GAME_FILE, BASESET_DIR) != SL_OK) { GenerateWorld(GWM_EMPTY, 64, 64); // if failed loading, make empty world. SetLocalCompany(COMPANY_SPECTATOR); } else { SetLocalCompany(COMPANY_FIRST); } FixTitleGameZoom(); _pause_mode = PM_UNPAUSED; _cursor.fix_at = false; CheckForMissingGlyphs(); MusicLoop(); // ensure music is correct } void MakeNewgameSettingsLive() { for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) { if (_settings_game.ai_config[c] != nullptr) { delete _settings_game.ai_config[c]; } } if (_settings_game.game_config != nullptr) { delete _settings_game.game_config; } /* Copy newgame settings to active settings. * Also initialise old settings needed for savegame conversion. */ _settings_game = _settings_newgame; _old_vds = _settings_client.company.vehicle; for (CompanyID c = COMPANY_FIRST; c < MAX_COMPANIES; c++) { _settings_game.ai_config[c] = nullptr; if (_settings_newgame.ai_config[c] != nullptr) { _settings_game.ai_config[c] = new AIConfig(_settings_newgame.ai_config[c]); if (!AIConfig::GetConfig(c, AIConfig::SSS_FORCE_GAME)->HasScript()) { AIConfig::GetConfig(c, AIConfig::SSS_FORCE_GAME)->Change(nullptr); } } } _settings_game.game_config = nullptr; if (_settings_newgame.game_config != nullptr) { _settings_game.game_config = new GameConfig(_settings_newgame.game_config); } } void OpenBrowser(const char *url) { /* Make sure we only accept urls that are sure to open a browser. */ if (strstr(url, "http://") != url && strstr(url, "https://") != url) return; OSOpenBrowser(url); } /** Callback structure of statements to be executed after the NewGRF scan. */ struct AfterNewGRFScan : NewGRFScanCallback { Year startyear = INVALID_YEAR; ///< The start year. uint32 generation_seed = GENERATE_NEW_SEED; ///< Seed for the new game. std::string dedicated_host; ///< Hostname for the dedicated server. uint16 dedicated_port = 0; ///< Port for the dedicated server. std::string connection_string; ///< Information about the server to connect to std::string join_server_password; ///< The password to join the server with. std::string join_company_password; ///< The password to join the company with. bool save_config = true; ///< The save config setting. /** * Create a new callback. */ AfterNewGRFScan() { /* Visual C++ 2015 fails compiling this line (AfterNewGRFScan::generation_seed undefined symbol) * if it's placed outside a member function, directly in the struct body. */ static_assert(sizeof(generation_seed) == sizeof(_settings_game.game_creation.generation_seed)); } virtual void OnNewGRFsScanned() { ResetGRFConfig(false); TarScanner::DoScan(TarScanner::SCENARIO); AI::Initialize(); Game::Initialize(); /* We want the new (correct) NewGRF count to survive the loading. */ uint last_newgrf_count = _settings_client.gui.last_newgrf_count; LoadFromConfig(); _settings_client.gui.last_newgrf_count = last_newgrf_count; /* Since the default for the palette might have changed due to * reading the configuration file, recalculate that now. */ UpdateNewGRFConfigPalette(); Game::Uninitialize(true); AI::Uninitialize(true); LoadFromHighScore(); LoadHotkeysFromConfig(); WindowDesc::LoadFromConfig(); /* We have loaded the config, so we may possibly save it. */ _save_config = save_config; /* restore saved music and effects volumes */ MusicDriver::GetInstance()->SetVolume(_settings_client.music.music_vol); SetEffectVolume(_settings_client.music.effect_vol); if (startyear != INVALID_YEAR) IConsoleSetSetting("game_creation.starting_year", startyear); if (generation_seed != GENERATE_NEW_SEED) _settings_newgame.game_creation.generation_seed = generation_seed; if (!dedicated_host.empty()) { _network_bind_list.clear(); _network_bind_list.emplace_back(dedicated_host); } if (dedicated_port != 0) _settings_client.network.server_port = dedicated_port; /* initialize the ingame console */ IConsoleInit(); InitializeGUI(); IConsoleCmdExec("exec scripts/autoexec.scr 0"); /* Make sure _settings is filled with _settings_newgame if we switch to a game directly */ if (_switch_mode != SM_NONE) MakeNewgameSettingsLive(); if (_network_available && !connection_string.empty()) { LoadIntroGame(); _switch_mode = SM_NONE; NetworkClientConnectGame(connection_string, COMPANY_NEW_COMPANY, join_server_password, join_company_password); } /* After the scan we're not used anymore. */ delete this; } }; #if defined(UNIX) extern void DedicatedFork(); #endif /** Options of OpenTTD. */ static const OptionData _options[] = { GETOPT_SHORT_VALUE('I'), GETOPT_SHORT_VALUE('S'), GETOPT_SHORT_VALUE('M'), GETOPT_SHORT_VALUE('m'), GETOPT_SHORT_VALUE('s'), GETOPT_SHORT_VALUE('v'), GETOPT_SHORT_VALUE('b'), GETOPT_SHORT_OPTVAL('D'), GETOPT_SHORT_OPTVAL('n'), GETOPT_SHORT_VALUE('l'), GETOPT_SHORT_VALUE('p'), GETOPT_SHORT_VALUE('P'), #if !defined(_WIN32) GETOPT_SHORT_NOVAL('f'), #endif GETOPT_SHORT_VALUE('r'), GETOPT_SHORT_VALUE('t'), GETOPT_SHORT_OPTVAL('d'), GETOPT_SHORT_NOVAL('e'), GETOPT_SHORT_OPTVAL('g'), GETOPT_SHORT_VALUE('G'), GETOPT_SHORT_VALUE('c'), GETOPT_SHORT_NOVAL('x'), GETOPT_SHORT_NOVAL('X'), GETOPT_SHORT_VALUE('q'), GETOPT_SHORT_NOVAL('h'), GETOPT_SHORT_NOVAL('Q'), GETOPT_END() }; /** * Main entry point for this lovely game. * @param argc The number of arguments passed to this game. * @param argv The values of the arguments. * @return 0 when there is no error. */ int openttd_main(int argc, char *argv[]) { std::string musicdriver; std::string sounddriver; std::string videodriver; std::string blitter; std::string graphics_set; std::string sounds_set; std::string music_set; Dimension resolution = {0, 0}; std::unique_ptr scanner(new AfterNewGRFScan()); bool dedicated = false; char *debuglog_conn = nullptr; bool only_local_path = false; extern bool _dedicated_forks; _dedicated_forks = false; _game_mode = GM_MENU; _switch_mode = SM_MENU; GetOptData mgo(argc - 1, argv + 1, _options); int ret = 0; int i; while ((i = mgo.GetOpt()) != -1) { switch (i) { case 'I': graphics_set = mgo.opt; break; case 'S': sounds_set = mgo.opt; break; case 'M': music_set = mgo.opt; break; case 'm': musicdriver = mgo.opt; break; case 's': sounddriver = mgo.opt; break; case 'v': videodriver = mgo.opt; break; case 'b': blitter = mgo.opt; break; case 'D': musicdriver = "null"; sounddriver = "null"; videodriver = "dedicated"; blitter = "null"; dedicated = true; SetDebugString("net=4", ShowInfo); if (mgo.opt != nullptr) { scanner->dedicated_host = ParseFullConnectionString(mgo.opt, scanner->dedicated_port); } break; case 'f': _dedicated_forks = true; break; case 'n': scanner->connection_string = mgo.opt; // optional IP:port#company parameter break; case 'l': debuglog_conn = mgo.opt; break; case 'p': scanner->join_server_password = mgo.opt; break; case 'P': scanner->join_company_password = mgo.opt; break; case 'r': ParseResolution(&resolution, mgo.opt); break; case 't': scanner->startyear = atoi(mgo.opt); break; case 'd': { #if defined(_WIN32) CreateConsole(); #endif if (mgo.opt != nullptr) SetDebugString(mgo.opt, ShowInfo); break; } case 'e': _switch_mode = (_switch_mode == SM_LOAD_GAME || _switch_mode == SM_LOAD_SCENARIO ? SM_LOAD_SCENARIO : SM_EDITOR); break; case 'g': if (mgo.opt != nullptr) { _file_to_saveload.SetName(mgo.opt); bool is_scenario = _switch_mode == SM_EDITOR || _switch_mode == SM_LOAD_SCENARIO; _switch_mode = is_scenario ? SM_LOAD_SCENARIO : SM_LOAD_GAME; _file_to_saveload.SetMode(SLO_LOAD, is_scenario ? FT_SCENARIO : FT_SAVEGAME, DFT_GAME_FILE); /* if the file doesn't exist or it is not a valid savegame, let the saveload code show an error */ auto t = _file_to_saveload.name.find_last_of('.'); if (t != std::string::npos) { FiosType ft = FiosGetSavegameListCallback(SLO_LOAD, _file_to_saveload.name, _file_to_saveload.name.substr(t).c_str(), nullptr, nullptr); if (ft != FIOS_TYPE_INVALID) _file_to_saveload.SetMode(ft); } break; } _switch_mode = SM_NEWGAME; /* Give a random map if no seed has been given */ if (scanner->generation_seed == GENERATE_NEW_SEED) { scanner->generation_seed = InteractiveRandom(); } break; case 'q': { DeterminePaths(argv[0], only_local_path); if (StrEmpty(mgo.opt)) { ret = 1; return ret; } char title[80]; title[0] = '\0'; FiosGetSavegameListCallback(SLO_LOAD, mgo.opt, strrchr(mgo.opt, '.'), title, lastof(title)); _load_check_data.Clear(); SaveOrLoadResult res = SaveOrLoad(mgo.opt, SLO_CHECK, DFT_GAME_FILE, SAVE_DIR, false); if (res != SL_OK || _load_check_data.HasErrors()) { fprintf(stderr, "Failed to open savegame\n"); if (_load_check_data.HasErrors()) { InitializeLanguagePacks(); // A language pack is needed for GetString() char buf[256]; SetDParamStr(0, _load_check_data.error_data); GetString(buf, _load_check_data.error, lastof(buf)); fprintf(stderr, "%s\n", buf); } return ret; } WriteSavegameInfo(title); return ret; } case 'Q': { extern int _skip_all_newgrf_scanning; _skip_all_newgrf_scanning += 1; break; } case 'G': scanner->generation_seed = strtoul(mgo.opt, nullptr, 10); break; case 'c': _config_file = mgo.opt; break; case 'x': scanner->save_config = false; break; case 'X': only_local_path = true; break; case 'h': i = -2; // Force printing of help. break; } if (i == -2) break; } if (i == -2 || mgo.numleft > 0) { /* Either the user typed '-h', they made an error, or they added unrecognized command line arguments. * In all cases, print the help, and exit. * * The next two functions are needed to list the graphics sets. We can't do them earlier * because then we cannot show it on the debug console as that hasn't been configured yet. */ DeterminePaths(argv[0], only_local_path); TarScanner::DoScan(TarScanner::BASESET); BaseGraphics::FindSets(); BaseSounds::FindSets(); BaseMusic::FindSets(); ShowHelp(); return ret; } DeterminePaths(argv[0], only_local_path); TarScanner::DoScan(TarScanner::BASESET); if (dedicated) Debug(net, 3, "Starting dedicated server, version {}", _openttd_revision); if (_dedicated_forks && !dedicated) _dedicated_forks = false; #if defined(UNIX) /* We must fork here, or we'll end up without some resources we need (like sockets) */ if (_dedicated_forks) DedicatedFork(); #endif LoadFromConfig(true); if (resolution.width != 0) _cur_resolution = resolution; /* Limit width times height times bytes per pixel to fit a 32 bit * integer, This way all internal drawing routines work correctly. * A resolution that has one component as 0 is treated as a marker to * auto-detect a good window size. */ _cur_resolution.width = std::min(_cur_resolution.width, UINT16_MAX / 2u); _cur_resolution.height = std::min(_cur_resolution.height, UINT16_MAX / 2u); /* Assume the cursor starts within the game as not all video drivers * get an event that the cursor is within the window when it is opened. * Saying the cursor is there makes no visible difference as it would * just be out of the bounds of the window. */ _cursor.in_window = true; /* enumerate language files */ InitializeLanguagePacks(); /* Initialize the font cache */ InitFontCache(false); /* This must be done early, since functions use the SetWindowDirty* calls */ InitWindowSystem(); BaseGraphics::FindSets(); if (graphics_set.empty() && !BaseGraphics::ini_set.empty()) graphics_set = BaseGraphics::ini_set; if (!BaseGraphics::SetSet(graphics_set)) { if (!graphics_set.empty()) { BaseGraphics::SetSet({}); ErrorMessageData msg(STR_CONFIG_ERROR, STR_CONFIG_ERROR_INVALID_BASE_GRAPHICS_NOT_FOUND); msg.SetDParamStr(0, graphics_set); ScheduleErrorMessage(msg); } } /* Initialize game palette */ GfxInitPalettes(); Debug(misc, 1, "Loading blitter..."); if (blitter.empty() && !_ini_blitter.empty()) blitter = _ini_blitter; _blitter_autodetected = blitter.empty(); /* Activate the initial blitter. * This is only some initial guess, after NewGRFs have been loaded SwitchNewGRFBlitter may switch to a different one. * - Never guess anything, if the user specified a blitter. (_blitter_autodetected) * - Use 32bpp blitter if baseset or 8bpp-support settings says so. * - Use 8bpp blitter otherwise. */ if (!_blitter_autodetected || (_support8bpp != S8BPP_NONE && (BaseGraphics::GetUsedSet() == nullptr || BaseGraphics::GetUsedSet()->blitter == BLT_8BPP)) || BlitterFactory::SelectBlitter("32bpp-anim") == nullptr) { if (BlitterFactory::SelectBlitter(blitter) == nullptr) { blitter.empty() ? usererror("Failed to autoprobe blitter") : usererror("Failed to select requested blitter '%s'; does it exist?", blitter.c_str()); } } if (videodriver.empty() && !_ini_videodriver.empty()) videodriver = _ini_videodriver; DriverFactoryBase::SelectDriver(videodriver, Driver::DT_VIDEO); InitializeSpriteSorter(); /* Initialize the zoom level of the screen to normal */ _screen.zoom = ZOOM_LVL_NORMAL; /* The video driver is now selected, now initialise GUI zoom */ AdjustGUIZoom(false); NetworkStartUp(); // initialize network-core if (debuglog_conn != nullptr && _network_available) { NetworkStartDebugLog(debuglog_conn); } if (!HandleBootstrap()) { ShutdownGame(); return ret; } VideoDriver::GetInstance()->ClaimMousePointer(); /* initialize screenshot formats */ InitializeScreenshotFormats(); BaseSounds::FindSets(); if (sounds_set.empty() && !BaseSounds::ini_set.empty()) sounds_set = BaseSounds::ini_set; if (!BaseSounds::SetSet(sounds_set)) { if (sounds_set.empty() || !BaseSounds::SetSet({})) { usererror("Failed to find a sounds set. Please acquire a sounds set for OpenTTD. See section 1.4 of README.md."); } else { ErrorMessageData msg(STR_CONFIG_ERROR, STR_CONFIG_ERROR_INVALID_BASE_SOUNDS_NOT_FOUND); msg.SetDParamStr(0, sounds_set); ScheduleErrorMessage(msg); } } BaseMusic::FindSets(); if (music_set.empty() && !BaseMusic::ini_set.empty()) music_set = BaseMusic::ini_set; if (!BaseMusic::SetSet(music_set)) { if (music_set.empty() || !BaseMusic::SetSet({})) { usererror("Failed to find a music set. Please acquire a music set for OpenTTD. See section 1.4 of README.md."); } else { ErrorMessageData msg(STR_CONFIG_ERROR, STR_CONFIG_ERROR_INVALID_BASE_MUSIC_NOT_FOUND); msg.SetDParamStr(0, music_set); ScheduleErrorMessage(msg); } } if (sounddriver.empty() && !_ini_sounddriver.empty()) sounddriver = _ini_sounddriver; DriverFactoryBase::SelectDriver(sounddriver, Driver::DT_SOUND); if (musicdriver.empty() && !_ini_musicdriver.empty()) musicdriver = _ini_musicdriver; DriverFactoryBase::SelectDriver(musicdriver, Driver::DT_MUSIC); GenerateWorld(GWM_EMPTY, 64, 64); // Make the viewport initialization happy LoadIntroGame(false); CheckForMissingGlyphs(); /* ScanNewGRFFiles now has control over the scanner. */ RequestNewGRFScan(scanner.release()); VideoDriver::GetInstance()->MainLoop(); WaitTillSaved(); /* only save config if we have to */ if (_save_config) { SaveToConfig(); SaveHotkeysToConfig(); WindowDesc::SaveToConfig(); SaveToHighScore(); } /* Reset windowing system, stop drivers, free used memory, ... */ ShutdownGame(); return ret; } void HandleExitGameRequest() { if (_game_mode == GM_MENU || _game_mode == GM_BOOTSTRAP) { // do not ask to quit on the main screen _exit_game = true; } else if (_settings_client.gui.autosave_on_exit) { DoExitSave(); _exit_game = true; } else { AskExitGame(); } } /** * Triggers everything required to set up a saved scenario for a new game. */ static void OnStartScenario() { /* Reset engine pool to simplify changing engine NewGRFs in scenario editor. */ EngineOverrideManager::ResetToCurrentNewGRFConfig(); /* Make sure all industries were built "this year", to avoid too early closures. (#9918) */ for (Industry *i : Industry::Iterate()) { i->last_prod_year = _cur_year; } } /** * Triggers everything that should be triggered when starting a game. * @param dedicated_server Whether this is a dedicated server or not. */ static void OnStartGame(bool dedicated_server) { /* Update the local company for a loaded game. It is either the first available company * or in the case of a dedicated server, a spectator */ SetLocalCompany(dedicated_server ? COMPANY_SPECTATOR : GetFirstPlayableCompanyID()); /* Update the static game info to set the values from the new game. */ NetworkServerUpdateGameInfo(); /* Execute the game-start script */ IConsoleCmdExec("exec scripts/game_start.scr 0"); } static void MakeNewGameDone() { SettingsDisableElrail(_settings_game.vehicle.disable_elrails); /* In a dedicated server, the server does not play */ if (!VideoDriver::GetInstance()->HasGUI()) { OnStartGame(true); if (_settings_client.gui.pause_on_newgame) Command::Post(PM_PAUSED_NORMAL, true); return; } /* Create a single company */ DoStartupNewCompany(false); Company *c = Company::Get(COMPANY_FIRST); c->settings = _settings_client.company; /* Overwrite color from settings if needed * COLOUR_END corresponds to Random colour */ if (_settings_client.gui.starting_colour != COLOUR_END) { c->colour = _settings_client.gui.starting_colour; ResetCompanyLivery(c); _company_colours[c->index] = (Colours)c->colour; } OnStartGame(false); InitializeRailGUI(); InitializeRoadGUI(); /* We are the server, we start a new company (not dedicated), * so set the default password *if* needed. */ if (_network_server && !_settings_client.network.default_company_pass.empty()) { NetworkChangeCompanyPassword(_local_company, _settings_client.network.default_company_pass); } if (_settings_client.gui.pause_on_newgame) Command::Post(PM_PAUSED_NORMAL, true); CheckEngines(); CheckIndustries(); MarkWholeScreenDirty(); if (_network_server && !_network_dedicated) ShowClientList(); } static void MakeNewGame(bool from_heightmap, bool reset_settings) { _game_mode = GM_NORMAL; if (!from_heightmap) { /* "reload" command needs to know what mode we were in. */ _file_to_saveload.SetMode(SLO_INVALID, FT_INVALID, DFT_INVALID); } ResetGRFConfig(true); GenerateWorldSetCallback(&MakeNewGameDone); GenerateWorld(from_heightmap ? GWM_HEIGHTMAP : GWM_NEWGAME, 1 << _settings_game.game_creation.map_x, 1 << _settings_game.game_creation.map_y, reset_settings); } static void MakeNewEditorWorldDone() { SetLocalCompany(OWNER_NONE); } static void MakeNewEditorWorld() { _game_mode = GM_EDITOR; /* "reload" command needs to know what mode we were in. */ _file_to_saveload.SetMode(SLO_INVALID, FT_INVALID, DFT_INVALID); ResetGRFConfig(true); GenerateWorldSetCallback(&MakeNewEditorWorldDone); GenerateWorld(GWM_EMPTY, 1 << _settings_game.game_creation.map_x, 1 << _settings_game.game_creation.map_y); } /** * Load the specified savegame but on error do different things. * If loading fails due to corrupt savegame, bad version, etc. go back to * a previous correct state. In the menu for example load the intro game again. * @param filename file to be loaded * @param fop mode of loading, always SLO_LOAD * @param newgm switch to this mode of loading fails due to some unknown error * @param subdir default directory to look for filename, set to 0 if not needed * @param lf Load filter to use, if nullptr: use filename + subdir. */ bool SafeLoad(const std::string &filename, SaveLoadOperation fop, DetailedFileType dft, GameMode newgm, Subdirectory subdir, struct LoadFilter *lf = nullptr) { assert(fop == SLO_LOAD); assert(dft == DFT_GAME_FILE || (lf == nullptr && dft == DFT_OLD_GAME_FILE)); GameMode ogm = _game_mode; _game_mode = newgm; SaveOrLoadResult result = (lf == nullptr) ? SaveOrLoad(filename, fop, dft, subdir) : LoadWithFilter(lf); if (result == SL_OK) return true; if (_network_dedicated && ogm == GM_MENU) { /* * If we are a dedicated server *and* we just were in the menu, then we * are loading the first savegame. If that fails, not starting the * server is a better reaction than starting the server with a newly * generated map as it is quite likely to be started from a script. */ Debug(net, 0, "Loading requested map failed; closing server."); _exit_game = true; return false; } if (result != SL_REINIT) { _game_mode = ogm; return false; } if (_network_dedicated) { /* * If we are a dedicated server, have already loaded/started a game, * and then loading the savegame fails in a manner that we need to * reinitialize everything. We must not fall back into the menu mode * with the intro game, as that is unjoinable by clients. So there is * nothing else to do than start a new game, as it might have failed * trying to reload the originally loaded savegame/scenario. */ Debug(net, 0, "Loading game failed, so a new (random) game will be started"); MakeNewGame(false, true); return false; } if (_network_server) { /* We can't load the intro game as server, so disconnect first. */ NetworkDisconnect(); } switch (ogm) { default: case GM_MENU: LoadIntroGame(); break; case GM_EDITOR: MakeNewEditorWorld(); break; } return false; } void SwitchToMode(SwitchMode new_mode) { /* If we are saving something, the network stays in its current state */ if (new_mode != SM_SAVE_GAME) { /* If the network is active, make it not-active */ if (_networking) { if (_network_server && (new_mode == SM_LOAD_GAME || new_mode == SM_NEWGAME || new_mode == SM_RESTARTGAME)) { NetworkReboot(); } else { NetworkDisconnect(); } } /* If we are a server, we restart the server */ if (_is_network_server) { /* But not if we are going to the menu */ if (new_mode != SM_MENU) { /* check if we should reload the config */ if (_settings_client.network.reload_cfg) { LoadFromConfig(); MakeNewgameSettingsLive(); ResetGRFConfig(false); } NetworkServerStart(); } else { /* This client no longer wants to be a network-server */ _is_network_server = false; } } } /* Make sure all AI controllers are gone at quitting game */ if (new_mode != SM_SAVE_GAME) AI::KillAll(); switch (new_mode) { case SM_EDITOR: // Switch to scenario editor MakeNewEditorWorld(); break; case SM_RELOADGAME: // Reload with what-ever started the game if (_file_to_saveload.abstract_ftype == FT_SAVEGAME || _file_to_saveload.abstract_ftype == FT_SCENARIO) { /* Reload current savegame/scenario */ _switch_mode = _game_mode == GM_EDITOR ? SM_LOAD_SCENARIO : SM_LOAD_GAME; SwitchToMode(_switch_mode); break; } else if (_file_to_saveload.abstract_ftype == FT_HEIGHTMAP) { /* Restart current heightmap */ _switch_mode = _game_mode == GM_EDITOR ? SM_LOAD_HEIGHTMAP : SM_RESTART_HEIGHTMAP; SwitchToMode(_switch_mode); break; } MakeNewGame(false, new_mode == SM_NEWGAME); break; case SM_RESTARTGAME: // Restart --> 'Random game' with current settings case SM_NEWGAME: // New Game --> 'Random game' MakeNewGame(false, new_mode == SM_NEWGAME); break; case SM_LOAD_GAME: { // Load game, Play Scenario ResetGRFConfig(true); ResetWindowSystem(); if (!SafeLoad(_file_to_saveload.name, _file_to_saveload.file_op, _file_to_saveload.detail_ftype, GM_NORMAL, NO_DIRECTORY)) { SetDParamStr(0, GetSaveLoadErrorString()); ShowErrorMessage(STR_JUST_RAW_STRING, INVALID_STRING_ID, WL_ERROR); } else { if (_file_to_saveload.abstract_ftype == FT_SCENARIO) { OnStartScenario(); } OnStartGame(_network_dedicated); /* Decrease pause counter (was increased from opening load dialog) */ Command::Post(PM_PAUSED_SAVELOAD, false); } break; } case SM_RESTART_HEIGHTMAP: // Load a heightmap and start a new game from it with current settings case SM_START_HEIGHTMAP: // Load a heightmap and start a new game from it MakeNewGame(true, new_mode == SM_START_HEIGHTMAP); break; case SM_LOAD_HEIGHTMAP: // Load heightmap from scenario editor SetLocalCompany(OWNER_NONE); GenerateWorld(GWM_HEIGHTMAP, 1 << _settings_game.game_creation.map_x, 1 << _settings_game.game_creation.map_y); MarkWholeScreenDirty(); break; case SM_LOAD_SCENARIO: { // Load scenario from scenario editor if (SafeLoad(_file_to_saveload.name, _file_to_saveload.file_op, _file_to_saveload.detail_ftype, GM_EDITOR, NO_DIRECTORY)) { SetLocalCompany(OWNER_NONE); _settings_newgame.game_creation.starting_year = _cur_year; /* Cancel the saveload pausing */ Command::Post(PM_PAUSED_SAVELOAD, false); } else { SetDParamStr(0, GetSaveLoadErrorString()); ShowErrorMessage(STR_JUST_RAW_STRING, INVALID_STRING_ID, WL_ERROR); } break; } case SM_JOIN_GAME: // Join a multiplayer game LoadIntroGame(); NetworkClientJoinGame(); break; case SM_MENU: // Switch to game intro menu LoadIntroGame(); if (BaseSounds::ini_set.empty() && BaseSounds::GetUsedSet()->fallback && SoundDriver::GetInstance()->HasOutput()) { ShowErrorMessage(STR_WARNING_FALLBACK_SOUNDSET, INVALID_STRING_ID, WL_CRITICAL); BaseSounds::ini_set = BaseSounds::GetUsedSet()->name; } break; case SM_SAVE_GAME: // Save game. /* Make network saved games on pause compatible to singleplayer mode */ if (SaveOrLoad(_file_to_saveload.name, SLO_SAVE, DFT_GAME_FILE, NO_DIRECTORY) != SL_OK) { SetDParamStr(0, GetSaveLoadErrorString()); ShowErrorMessage(STR_JUST_RAW_STRING, INVALID_STRING_ID, WL_ERROR); } else { CloseWindowById(WC_SAVELOAD, 0); } break; case SM_SAVE_HEIGHTMAP: // Save heightmap. MakeHeightmapScreenshot(_file_to_saveload.name.c_str()); CloseWindowById(WC_SAVELOAD, 0); break; case SM_GENRANDLAND: // Generate random land within scenario editor SetLocalCompany(OWNER_NONE); GenerateWorld(GWM_RANDOM, 1 << _settings_game.game_creation.map_x, 1 << _settings_game.game_creation.map_y); /* XXX: set date */ MarkWholeScreenDirty(); break; default: NOT_REACHED(); } } /** * Check the validity of some of the caches. * Especially in the sense of desyncs between * the cached value and what the value would * be when calculated from the 'base' data. */ static void CheckCaches() { /* Return here so it is easy to add checks that are run * always to aid testing of caches. */ if (_debug_desync_level <= 1) return; /* Check the town caches. */ std::vector old_town_caches; for (const Town *t : Town::Iterate()) { old_town_caches.push_back(t->cache); } RebuildTownCaches(); RebuildSubsidisedSourceAndDestinationCache(); uint i = 0; for (Town *t : Town::Iterate()) { if (MemCmpT(old_town_caches.data() + i, &t->cache) != 0) { Debug(desync, 2, "town cache mismatch: town {}", t->index); } i++; } /* Check company infrastructure cache. */ std::vector old_infrastructure; for (const Company *c : Company::Iterate()) old_infrastructure.push_back(c->infrastructure); AfterLoadCompanyStats(); i = 0; for (const Company *c : Company::Iterate()) { if (MemCmpT(old_infrastructure.data() + i, &c->infrastructure) != 0) { Debug(desync, 2, "infrastructure cache mismatch: company {}", c->index); } i++; } /* Strict checking of the road stop cache entries */ for (const RoadStop *rs : RoadStop::Iterate()) { if (IsStandardRoadStopTile(rs->xy)) continue; assert(rs->GetEntry(DIAGDIR_NE) != rs->GetEntry(DIAGDIR_NW)); rs->GetEntry(DIAGDIR_NE)->CheckIntegrity(rs); rs->GetEntry(DIAGDIR_NW)->CheckIntegrity(rs); } for (Vehicle *v : Vehicle::Iterate()) { if (v != v->First() || v->vehstatus & VS_CRASHED || !v->IsPrimaryVehicle()) continue; uint length = 0; for (const Vehicle *u = v; u != nullptr; u = u->Next()) length++; NewGRFCache *grf_cache = CallocT(length); VehicleCache *veh_cache = CallocT(length); GroundVehicleCache *gro_cache = CallocT(length); TrainCache *tra_cache = CallocT(length); length = 0; for (const Vehicle *u = v; u != nullptr; u = u->Next()) { FillNewGRFVehicleCache(u); grf_cache[length] = u->grf_cache; veh_cache[length] = u->vcache; switch (u->type) { case VEH_TRAIN: gro_cache[length] = Train::From(u)->gcache; tra_cache[length] = Train::From(u)->tcache; break; case VEH_ROAD: gro_cache[length] = RoadVehicle::From(u)->gcache; break; default: break; } length++; } switch (v->type) { case VEH_TRAIN: Train::From(v)->ConsistChanged(CCF_TRACK); break; case VEH_ROAD: RoadVehUpdateCache(RoadVehicle::From(v)); break; case VEH_AIRCRAFT: UpdateAircraftCache(Aircraft::From(v)); break; case VEH_SHIP: Ship::From(v)->UpdateCache(); break; default: break; } length = 0; for (const Vehicle *u = v; u != nullptr; u = u->Next()) { FillNewGRFVehicleCache(u); if (memcmp(&grf_cache[length], &u->grf_cache, sizeof(NewGRFCache)) != 0) { Debug(desync, 2, "newgrf cache mismatch: type {}, vehicle {}, company {}, unit number {}, wagon {}", v->type, v->index, v->owner, v->unitnumber, length); } if (memcmp(&veh_cache[length], &u->vcache, sizeof(VehicleCache)) != 0) { Debug(desync, 2, "vehicle cache mismatch: type {}, vehicle {}, company {}, unit number {}, wagon {}", v->type, v->index, v->owner, v->unitnumber, length); } switch (u->type) { case VEH_TRAIN: if (memcmp(&gro_cache[length], &Train::From(u)->gcache, sizeof(GroundVehicleCache)) != 0) { Debug(desync, 2, "train ground vehicle cache mismatch: vehicle {}, company {}, unit number {}, wagon {}", v->index, v->owner, v->unitnumber, length); } if (memcmp(&tra_cache[length], &Train::From(u)->tcache, sizeof(TrainCache)) != 0) { Debug(desync, 2, "train cache mismatch: vehicle {}, company {}, unit number {}, wagon {}", v->index, v->owner, v->unitnumber, length); } break; case VEH_ROAD: if (memcmp(&gro_cache[length], &RoadVehicle::From(u)->gcache, sizeof(GroundVehicleCache)) != 0) { Debug(desync, 2, "road vehicle ground vehicle cache mismatch: vehicle {}, company {}, unit number {}, wagon {}", v->index, v->owner, v->unitnumber, length); } break; default: break; } length++; } free(grf_cache); free(veh_cache); free(gro_cache); free(tra_cache); } /* Check whether the caches are still valid */ for (Vehicle *v : Vehicle::Iterate()) { byte buff[sizeof(VehicleCargoList)]; memcpy(buff, &v->cargo, sizeof(VehicleCargoList)); v->cargo.InvalidateCache(); assert(memcmp(&v->cargo, buff, sizeof(VehicleCargoList)) == 0); } /* Backup stations_near */ std::vector old_town_stations_near; for (Town *t : Town::Iterate()) old_town_stations_near.push_back(t->stations_near); std::vector old_industry_stations_near; for (Industry *ind : Industry::Iterate()) old_industry_stations_near.push_back(ind->stations_near); for (Station *st : Station::Iterate()) { for (CargoID c = 0; c < NUM_CARGO; c++) { byte buff[sizeof(StationCargoList)]; memcpy(buff, &st->goods[c].cargo, sizeof(StationCargoList)); st->goods[c].cargo.InvalidateCache(); assert(memcmp(&st->goods[c].cargo, buff, sizeof(StationCargoList)) == 0); } /* Check docking tiles */ TileArea ta; std::map docking_tiles; for (TileIndex tile : st->docking_station) { ta.Add(tile); docking_tiles[tile] = IsDockingTile(tile); } UpdateStationDockingTiles(st); if (ta.tile != st->docking_station.tile || ta.w != st->docking_station.w || ta.h != st->docking_station.h) { Debug(desync, 2, "station docking mismatch: station {}, company {}", st->index, st->owner); } for (TileIndex tile : ta) { if (docking_tiles[tile] != IsDockingTile(tile)) { Debug(desync, 2, "docking tile mismatch: tile {}", tile); } } /* Check industries_near */ IndustryList industries_near = st->industries_near; st->RecomputeCatchment(); if (st->industries_near != industries_near) { Debug(desync, 2, "station industries near mismatch: station {}", st->index); } } /* Check stations_near */ i = 0; for (Town *t : Town::Iterate()) { if (t->stations_near != old_town_stations_near[i]) { Debug(desync, 2, "town stations near mismatch: town {}", t->index); } i++; } i = 0; for (Industry *ind : Industry::Iterate()) { if (ind->stations_near != old_industry_stations_near[i]) { Debug(desync, 2, "industry stations near mismatch: industry {}", ind->index); } i++; } } /** * State controlling game loop. * The state must not be changed from anywhere but here. * That check is enforced in DoCommand. */ void StateGameLoop() { if (!_networking || _network_server) { StateGameLoop_LinkGraphPauseControl(); } /* Don't execute the state loop during pause or when modal windows are open. */ if (_pause_mode != PM_UNPAUSED || HasModalProgress()) { PerformanceMeasurer::Paused(PFE_GAMELOOP); PerformanceMeasurer::Paused(PFE_GL_ECONOMY); PerformanceMeasurer::Paused(PFE_GL_TRAINS); PerformanceMeasurer::Paused(PFE_GL_ROADVEHS); PerformanceMeasurer::Paused(PFE_GL_SHIPS); PerformanceMeasurer::Paused(PFE_GL_AIRCRAFT); PerformanceMeasurer::Paused(PFE_GL_LANDSCAPE); if (!HasModalProgress()) UpdateLandscapingLimits(); #ifndef DEBUG_DUMP_COMMANDS Game::GameLoop(); #endif return; } PerformanceMeasurer framerate(PFE_GAMELOOP); PerformanceAccumulator::Reset(PFE_GL_LANDSCAPE); Layouter::ReduceLineCache(); if (_game_mode == GM_EDITOR) { BasePersistentStorageArray::SwitchMode(PSM_ENTER_GAMELOOP); RunTileLoop(); CallVehicleTicks(); CallLandscapeTick(); BasePersistentStorageArray::SwitchMode(PSM_LEAVE_GAMELOOP); UpdateLandscapingLimits(); CallWindowGameTickEvent(); NewsLoop(); } else { if (_debug_desync_level > 2 && _date_fract == 0 && (_date & 0x1F) == 0) { /* Save the desync savegame if needed. */ char name[MAX_PATH]; seprintf(name, lastof(name), "dmp_cmds_%08x_%08x.sav", _settings_game.game_creation.generation_seed, _date); SaveOrLoad(name, SLO_SAVE, DFT_GAME_FILE, AUTOSAVE_DIR, false); } CheckCaches(); /* All these actions has to be done from OWNER_NONE * for multiplayer compatibility */ Backup cur_company(_current_company, OWNER_NONE, FILE_LINE); BasePersistentStorageArray::SwitchMode(PSM_ENTER_GAMELOOP); AnimateAnimatedTiles(); TimerManager::Elapsed(1); RunTileLoop(); CallVehicleTicks(); CallLandscapeTick(); BasePersistentStorageArray::SwitchMode(PSM_LEAVE_GAMELOOP); #ifndef DEBUG_DUMP_COMMANDS { PerformanceMeasurer script_framerate(PFE_ALLSCRIPTS); AI::GameLoop(); Game::GameLoop(); } #endif UpdateLandscapingLimits(); CallWindowGameTickEvent(); NewsLoop(); cur_company.Restore(); } assert(IsLocalCompany()); } /** * Create an autosave. The default name is "autosave#.sav". However with * the setting 'keep_all_autosave' the name defaults to company-name + date */ static void DoAutosave() { static FiosNumberedSaveName _autosave_ctr("autosave"); DoAutoOrNetsave(_autosave_ctr); } /** * Request a new NewGRF scan. This will be executed on the next game-tick. * This is mostly needed to ensure NewGRF scans (which are blocking) are * done in the game-thread, and not in the draw-thread (which most often * triggers this request). * @param callback Optional callback to call when NewGRF scan is completed. * @return True when the NewGRF scan was actually requested, false when the scan was already running. */ bool RequestNewGRFScan(NewGRFScanCallback *callback) { if (_request_newgrf_scan) return false; _request_newgrf_scan = true; _request_newgrf_scan_callback = callback; return true; } void GameLoop() { if (_game_mode == GM_BOOTSTRAP) { /* Check for UDP stuff */ if (_network_available) NetworkBackgroundLoop(); return; } if (_request_newgrf_scan) { ScanNewGRFFiles(_request_newgrf_scan_callback); _request_newgrf_scan = false; _request_newgrf_scan_callback = nullptr; /* In case someone closed the game during our scan, don't do anything else. */ if (_exit_game) return; } ProcessAsyncSaveFinish(); /* autosave game? */ if (_do_autosave) { DoAutosave(); _do_autosave = false; SetWindowDirty(WC_STATUS_BAR, 0); } /* switch game mode? */ if (_switch_mode != SM_NONE && !HasModalProgress()) { SwitchToMode(_switch_mode); _switch_mode = SM_NONE; } IncreaseSpriteLRU(); /* Check for UDP stuff */ if (_network_available) NetworkBackgroundLoop(); DebugSendRemoteMessages(); if (_networking && !HasModalProgress()) { /* Multiplayer */ NetworkGameLoop(); } else { if (_network_reconnect > 0 && --_network_reconnect == 0) { /* This means that we want to reconnect to the last host * We do this here, because it means that the network is really closed */ NetworkClientConnectGame(_settings_client.network.last_joined, COMPANY_SPECTATOR); } /* Singleplayer */ StateGameLoop(); } if (!_pause_mode && HasBit(_display_opt, DO_FULL_ANIMATION)) DoPaletteAnimations(); SoundDriver::GetInstance()->MainLoop(); MusicLoop(); }