--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/openttd.cpp Thu Jan 11 13:41:16 2007 +0000
@@ -0,0 +1,1734 @@
+/* $Id$ */
+
+#include "stdafx.h"
+#include "string.h"
+#include "table/strings.h"
+#include "debug.h"
+#include "driver.h"
+#include "saveload.h"
+#include "strings.h"
+#include "map.h"
+#include "tile.h"
+#include "void_map.h"
+
+#define VARDEF
+#include "openttd.h"
+#include "bridge_map.h"
+#include "functions.h"
+#include "mixer.h"
+#include "spritecache.h"
+#include "strings.h"
+#include "gfx.h"
+#include "gfxinit.h"
+#include "gui.h"
+#include "station.h"
+#include "station_map.h"
+#include "town_map.h"
+#include "tunnel_map.h"
+#include "vehicle.h"
+#include "viewport.h"
+#include "window.h"
+#include "player.h"
+#include "command.h"
+#include "town.h"
+#include "industry.h"
+#include "news.h"
+#include "engine.h"
+#include "sound.h"
+#include "economy.h"
+#include "fileio.h"
+#include "hal.h"
+#include "airport.h"
+#include "console.h"
+#include "screenshot.h"
+#include "network/network.h"
+#include "signs.h"
+#include "depot.h"
+#include "waypoint.h"
+#include "ai/ai.h"
+#include "train.h"
+#include "yapf/yapf.h"
+#include "settings.h"
+#include "genworld.h"
+#include "date.h"
+#include "clear_map.h"
+#include "fontcache.h"
+#include "newgrf_config.h"
+
+#include "bridge_map.h"
+#include "clear_map.h"
+#include "rail_map.h"
+#include "road_map.h"
+#include "water_map.h"
+#include "industry_map.h"
+
+#include <stdarg.h>
+
+void CallLandscapeTick(void);
+void IncreaseDate(void);
+void DoPaletteAnimations(void);
+void MusicLoop(void);
+void ResetMusic(void);
+void InitializeStations(void);
+void DeleteAllPlayerStations(void);
+
+extern void SetDifficultyLevel(int mode, GameOptions *gm_opt);
+extern void DoStartupNewPlayer(bool is_ai);
+extern void ShowOSErrorBox(const char *buf);
+
+/* TODO: usrerror() for errors which are not of an internal nature but
+ * caused by the user, i.e. missing files or fatal configuration errors.
+ * Post-0.4.0 since Celestar doesn't want this in SVN before. --pasky */
+
+void CDECL error(const char *s, ...)
+{
+ va_list va;
+ char buf[512];
+
+ va_start(va, s);
+ vsnprintf(buf, lengthof(buf), s, va);
+ va_end(va);
+
+ ShowOSErrorBox(buf);
+ if (_video_driver != NULL) _video_driver->stop();
+
+ assert(0);
+ exit(1);
+}
+
+void CDECL ShowInfoF(const char *str, ...)
+{
+ va_list va;
+ char buf[1024];
+ va_start(va, str);
+ vsnprintf(buf, lengthof(buf), str, va);
+ va_end(va);
+ ShowInfo(buf);
+}
+
+
+void *ReadFileToMem(const char *filename, size_t *lenp, size_t maxsize)
+{
+ FILE *in;
+ byte *mem;
+ size_t len;
+
+ in = fopen(filename, "rb");
+ if (in == NULL) return NULL;
+
+ fseek(in, 0, SEEK_END);
+ len = ftell(in);
+ fseek(in, 0, SEEK_SET);
+ if (len > maxsize || (mem = malloc(len + 1)) == NULL) {
+ fclose(in);
+ return NULL;
+ }
+ mem[len] = 0;
+ if (fread(mem, len, 1, in) != 1) {
+ fclose(in);
+ free(mem);
+ return NULL;
+ }
+ fclose(in);
+
+ *lenp = len;
+ return mem;
+}
+
+static void showhelp(void)
+{
+ extern const char _openttd_revision[];
+ char buf[4096], *p;
+
+ p = buf;
+
+ p += snprintf(p, lengthof(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"
+ " -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#player] = Start networkgame\n"
+ " -D [ip][:port] = Start dedicated server\n"
+#if !defined(__MORPHOS__) && !defined(__AMIGA__) && !defined(WIN32)
+ " -f = Fork into the background (dedicated only)\n"
+#endif
+ " -i = Force to use the DOS palette\n"
+ " (use this if you see a lot of pink)\n"
+ " -c config_file = Use 'config_file' instead of 'openttd.cfg'\n"
+ " -x = Do not automatically save to config file on exit\n",
+ lastof(buf)
+ );
+
+ p = GetDriverList(p, lastof(buf));
+
+ ShowInfo(buf);
+}
+
+
+typedef struct {
+ char *opt;
+ int numleft;
+ char **argv;
+ const char *options;
+ char *cont;
+} MyGetOptData;
+
+static void MyGetOptInit(MyGetOptData *md, int argc, char **argv, const char *options)
+{
+ md->cont = NULL;
+ md->numleft = argc;
+ md->argv = argv;
+ md->options = options;
+}
+
+static int MyGetOpt(MyGetOptData *md)
+{
+ char *s,*r,*t;
+
+ s = md->cont;
+ if (s != NULL)
+ goto md_continue_here;
+
+ for (;;) {
+ if (--md->numleft < 0) return -1;
+
+ s = *md->argv++;
+ if (*s == '-') {
+md_continue_here:;
+ s++;
+ if (*s != 0) {
+ // Found argument, try to locate it in options.
+ if (*s == ':' || (r = strchr(md->options, *s)) == NULL) {
+ // ERROR!
+ return -2;
+ }
+ if (r[1] == ':') {
+ // Item wants an argument. Check if the argument follows, or if it comes as a separate arg.
+ if (!*(t = s + 1)) {
+ // It comes as a separate arg. Check if out of args?
+ if (--md->numleft < 0 || *(t = *md->argv) == '-') {
+ // Check if item is optional?
+ if (r[2] != ':')
+ return -2;
+ md->numleft++;
+ t = NULL;
+ } else {
+ md->argv++;
+ }
+ }
+ md->opt = t;
+ md->cont = NULL;
+ return *s;
+ }
+ md->opt = NULL;
+ md->cont = s;
+ return *s;
+ }
+ } else {
+ // This is currently not supported.
+ return -2;
+ }
+ }
+}
+
+
+static void ParseResolution(int res[2], const char *s)
+{
+ char *t = strchr(s, 'x');
+ if (t == NULL) {
+ ShowInfoF("Invalid resolution '%s'", s);
+ return;
+ }
+
+ res[0] = clamp(strtoul(s, NULL, 0), 64, MAX_SCREEN_WIDTH);
+ res[1] = clamp(strtoul(t + 1, NULL, 0), 64, MAX_SCREEN_HEIGHT);
+}
+
+static void InitializeDynamicVariables(void)
+{
+ /* Dynamic stuff needs to be initialized somewhere... */
+ _town_sort = NULL;
+ _industry_sort = NULL;
+}
+
+static void UnInitializeDynamicVariables(void)
+{
+ /* Dynamic stuff needs to be free'd somewhere... */
+ CleanPool(&_Town_pool);
+ CleanPool(&_Industry_pool);
+ CleanPool(&_Station_pool);
+ CleanPool(&_Vehicle_pool);
+ CleanPool(&_Sign_pool);
+ CleanPool(&_Order_pool);
+
+ free((void*)_town_sort);
+ free((void*)_industry_sort);
+}
+
+static void UnInitializeGame(void)
+{
+ UnInitWindowSystem();
+
+ free(_config_file);
+}
+
+static void LoadIntroGame(void)
+{
+ char filename[256];
+
+ _game_mode = GM_MENU;
+ CLRBITS(_display_opt, DO_TRANS_BUILDINGS); // don't make buildings transparent in intro
+ _opt_ptr = &_opt_newgame;
+ ResetGRFConfig(false);
+
+ // Setup main window
+ ResetWindowSystem();
+ SetupColorsAndInitialWindow();
+
+ // Generate a world.
+ snprintf(filename, lengthof(filename), "%sopntitle.dat", _paths.data_dir);
+#if defined SECOND_DATA_DIR
+ if (SaveOrLoad(filename, SL_LOAD) != SL_OK) {
+ snprintf(filename, lengthof(filename), "%sopntitle.dat", _paths.second_data_dir);
+ }
+#endif
+ if (SaveOrLoad(filename, SL_LOAD) != SL_OK) {
+ GenerateWorld(GW_EMPTY, 64, 64); // if failed loading, make empty world.
+ WaitTillGeneratedWorld();
+ }
+
+ _pause = 0;
+ SetLocalPlayer(0);
+ /* Make sure you can't scroll in the menu */
+ _scrolling_viewport = 0;
+ _cursor.fix_at = false;
+ MarkWholeScreenDirty();
+
+ // Play main theme
+ if (_music_driver->is_song_playing()) ResetMusic();
+}
+
+#if defined(UNIX) && !defined(__MORPHOS__)
+extern void DedicatedFork(void);
+#endif
+
+int ttd_main(int argc, char *argv[])
+{
+ MyGetOptData mgo;
+ int i;
+ const char *optformat;
+ char musicdriver[16], sounddriver[16], videodriver[16];
+ int resolution[2] = {0,0};
+ Year startyear = INVALID_YEAR;
+ uint generation_seed = GENERATE_NEW_SEED;
+ bool dedicated = false;
+ bool network = false;
+ bool save_config = true;
+ char *network_conn = NULL;
+ char *dedicated_host = NULL;
+ uint16 dedicated_port = 0;
+
+ musicdriver[0] = sounddriver[0] = videodriver[0] = 0;
+
+ _game_mode = GM_MENU;
+ _switch_mode = SM_MENU;
+ _switch_mode_errorstr = INVALID_STRING_ID;
+ _dedicated_forks = false;
+ _config_file = NULL;
+
+ // The last param of the following function means this:
+ // a letter means: it accepts that param (e.g.: -h)
+ // a ':' behind it means: it need a param (e.g.: -m<driver>)
+ // a '::' behind it means: it can optional have a param (e.g.: -d<debug>)
+ optformat = "m:s:v:hD::n::eit:d::r:g::G:c:x"
+#if !defined(__MORPHOS__) && !defined(__AMIGA__) && !defined(WIN32)
+ "f"
+#endif
+ ;
+
+ MyGetOptInit(&mgo, argc-1, argv+1, optformat);
+ while ((i = MyGetOpt(&mgo)) != -1) {
+ switch (i) {
+ case 'm': ttd_strlcpy(musicdriver, mgo.opt, sizeof(musicdriver)); break;
+ case 's': ttd_strlcpy(sounddriver, mgo.opt, sizeof(sounddriver)); break;
+ case 'v': ttd_strlcpy(videodriver, mgo.opt, sizeof(videodriver)); break;
+ case 'D':
+ strcpy(musicdriver, "null");
+ strcpy(sounddriver, "null");
+ strcpy(videodriver, "dedicated");
+ dedicated = true;
+ if (mgo.opt != NULL)
+ {
+ /* Use the existing method for parsing (openttd -n).
+ * However, we do ignore the #player part. */
+ const char *temp = NULL;
+ const char *port = NULL;
+ ParseConnectionString(&temp, &port, mgo.opt);
+ if (*mgo.opt != '\0') dedicated_host = mgo.opt;
+ if (port != NULL) dedicated_port = atoi(port);
+ }
+ break;
+ case 'f': _dedicated_forks = true; break;
+ case 'n':
+ network = true;
+ network_conn = mgo.opt; // optional IP parameter, NULL if unset
+ break;
+ case 'r': ParseResolution(resolution, mgo.opt); break;
+ case 't': startyear = atoi(mgo.opt); break;
+ case 'd': {
+#if defined(WIN32)
+ CreateConsole();
+#endif
+ if (mgo.opt != NULL) SetDebugString(mgo.opt);
+ } break;
+ case 'e': _switch_mode = SM_EDITOR; break;
+ case 'i': _use_dos_palette = true; break;
+ case 'g':
+ if (mgo.opt != NULL) {
+ strcpy(_file_to_saveload.name, mgo.opt);
+ _switch_mode = SM_LOAD;
+ } else {
+ _switch_mode = SM_NEWGAME;
+ }
+ break;
+ case 'G': generation_seed = atoi(mgo.opt); break;
+ case 'c': _config_file = strdup(mgo.opt); break;
+ case 'x': save_config = false; break;
+ case -2:
+ case 'h':
+ showhelp();
+ return 0;
+ }
+ }
+
+ DeterminePaths();
+ CheckExternalFiles();
+
+#if defined(UNIX) && !defined(__MORPHOS__)
+ // We must fork here, or we'll end up without some resources we need (like sockets)
+ if (_dedicated_forks)
+ DedicatedFork();
+#endif
+
+ LoadFromConfig();
+ CheckConfig();
+ LoadFromHighScore();
+
+ // override config?
+ if (musicdriver[0]) ttd_strlcpy(_ini_musicdriver, musicdriver, sizeof(_ini_musicdriver));
+ if (sounddriver[0]) ttd_strlcpy(_ini_sounddriver, sounddriver, sizeof(_ini_sounddriver));
+ if (videodriver[0]) ttd_strlcpy(_ini_videodriver, videodriver, sizeof(_ini_videodriver));
+ if (resolution[0]) { _cur_resolution[0] = resolution[0]; _cur_resolution[1] = resolution[1]; }
+ if (startyear != INVALID_YEAR) _patches_newgame.starting_year = startyear;
+ if (generation_seed != GENERATE_NEW_SEED) _patches_newgame.generation_seed = generation_seed;
+
+ if (dedicated_host) snprintf(_network_server_bind_ip_host, NETWORK_HOSTNAME_LENGTH, "%s", dedicated_host);
+ if (dedicated_port) _network_server_port = dedicated_port;
+ if (_dedicated_forks && !dedicated) _dedicated_forks = false;
+
+ // enumerate language files
+ InitializeLanguagePacks();
+
+ // initialize screenshot formats
+ InitializeScreenshotFormats();
+
+ // initialize airport state machines
+ InitializeAirports();
+
+ /* initialize all variables that are allocated dynamically */
+ InitializeDynamicVariables();
+
+ /* start the AI */
+ AI_Initialize();
+
+ // Sample catalogue
+ DEBUG(misc, 1, "Loading sound effects...");
+ MxInitialize(11025);
+ SoundInitialize("sample.cat");
+
+ /* Initialize FreeType */
+ InitFreeType();
+
+ // This must be done early, since functions use the InvalidateWindow* calls
+ InitWindowSystem();
+
+ /* Initialize game palette */
+ GfxInitPalettes();
+
+ DEBUG(driver, 1, "Loading drivers...");
+ LoadDriver(SOUND_DRIVER, _ini_sounddriver);
+ LoadDriver(MUSIC_DRIVER, _ini_musicdriver);
+ LoadDriver(VIDEO_DRIVER, _ini_videodriver); // load video last, to prevent an empty window while sound and music loads
+ _savegame_sort_order = SORT_BY_DATE | SORT_DESCENDING;
+
+ // restore saved music volume
+ _music_driver->set_volume(msf.music_vol);
+
+ NetworkStartUp(); // initialize network-core
+
+ ScanNewGRFFiles();
+
+ _opt_ptr = &_opt_newgame;
+ ResetGRFConfig(false);
+
+ /* XXX - ugly hack, if diff_level is 9, it means we got no setting from the config file */
+ if (_opt_newgame.diff_level == 9) SetDifficultyLevel(0, &_opt_newgame);
+
+ /* Make sure _patches is filled with _patches_newgame if we switch to a game directly */
+ if (_switch_mode != SM_NONE) {
+ _opt = _opt_newgame;
+ UpdatePatches();
+ }
+
+ // initialize the ingame console
+ IConsoleInit();
+ _cursor.in_window = true;
+ InitializeGUI();
+ IConsoleCmdExec("exec scripts/autoexec.scr 0");
+
+ GenerateWorld(GW_EMPTY, 64, 64); // Make the viewport initialization happy
+ WaitTillGeneratedWorld();
+
+#ifdef ENABLE_NETWORK
+ if (network && _network_available) {
+ if (network_conn != NULL) {
+ const char *port = NULL;
+ const char *player = NULL;
+ uint16 rport;
+
+ rport = NETWORK_DEFAULT_PORT;
+ _network_playas = PLAYER_NEW_COMPANY;
+
+ ParseConnectionString(&player, &port, network_conn);
+
+ if (player != NULL) {
+ _network_playas = atoi(player);
+
+ if (_network_playas != PLAYER_SPECTATOR) {
+ _network_playas--;
+ if (!IsValidPlayer(_network_playas)) return false;
+ }
+ }
+ if (port != NULL) rport = atoi(port);
+
+ LoadIntroGame();
+ _switch_mode = SM_NONE;
+ NetworkClientConnectGame(network_conn, rport);
+ }
+ }
+#endif /* ENABLE_NETWORK */
+
+ _video_driver->main_loop();
+
+ WaitTillSaved();
+ IConsoleFree();
+
+ if (_network_available) NetworkShutDown(); // Shut down the network and close any open connections
+
+ _video_driver->stop();
+ _music_driver->stop();
+ _sound_driver->stop();
+
+ /* only save config if we have to */
+ if (save_config) {
+ SaveToConfig();
+ SaveToHighScore();
+ }
+
+ // uninitialize airport state machines
+ UnInitializeAirports();
+
+ /* uninitialize variables that are allocated dynamic */
+ UnInitializeDynamicVariables();
+
+ /* stop the AI */
+ AI_Uninitialize();
+
+ /* Close all and any open filehandles */
+ FioCloseAll();
+ UnInitializeGame();
+
+ return 0;
+}
+
+void HandleExitGameRequest(void)
+{
+ if (_game_mode == GM_MENU) { // do not ask to quit on the main screen
+ _exit_game = true;
+ } else if (_patches.autosave_on_exit) {
+ DoExitSave();
+ _exit_game = true;
+ } else {
+ AskExitGame();
+ }
+}
+
+
+/** Mutex so that only one thread can communicate with the main program
+ * at any given time */
+static ThreadMsg _message = MSG_OTTD_NO_MESSAGE;
+
+static inline void OTTD_ReleaseMutex(void) {_message = MSG_OTTD_NO_MESSAGE;}
+static inline ThreadMsg OTTD_PollThreadEvent(void) {return _message;}
+
+/** Called by running thread to execute some action in the main game.
+ * It will stall as long as the mutex is not freed (handled) by the game */
+void OTTD_SendThreadMessage(ThreadMsg msg)
+{
+ if (_exit_game) return;
+ while (_message != MSG_OTTD_NO_MESSAGE) CSleep(10);
+
+ _message = msg;
+}
+
+
+/** Handle the user-messages sent to us
+ * @param message message sent
+ */
+static void ProcessSentMessage(ThreadMsg message)
+{
+ switch (message) {
+ case MSG_OTTD_SAVETHREAD_DONE: SaveFileDone(); break;
+ case MSG_OTTD_SAVETHREAD_ERROR: SaveFileError(); break;
+ default: NOT_REACHED();
+ }
+
+ OTTD_ReleaseMutex(); // release mutex so that other threads, messages can be handled
+}
+
+static void ShowScreenshotResult(bool b)
+{
+ if (b) {
+ SetDParamStr(0, _screenshot_name);
+ ShowErrorMessage(INVALID_STRING_ID, STR_031B_SCREENSHOT_SUCCESSFULLY, 0, 0);
+ } else {
+ ShowErrorMessage(INVALID_STRING_ID, STR_031C_SCREENSHOT_FAILED, 0, 0);
+ }
+
+}
+
+static void MakeNewGameDone(void)
+{
+ /* In a dedicated server, the server does not play */
+ if (_network_dedicated) {
+ SetLocalPlayer(PLAYER_SPECTATOR);
+ return;
+ }
+
+ /* Create a single player */
+ DoStartupNewPlayer(false);
+
+ SetLocalPlayer(0);
+ _current_player = _local_player;
+ DoCommandP(0, (_patches.autorenew << 15 ) | (_patches.autorenew_months << 16) | 4, _patches.autorenew_money, NULL, CMD_SET_AUTOREPLACE);
+
+ SettingsDisableElrail(_patches.disable_elrails);
+
+ MarkWholeScreenDirty();
+}
+
+static void MakeNewGame(bool from_heightmap)
+{
+ _game_mode = GM_NORMAL;
+
+ ResetGRFConfig(true);
+
+ GenerateWorldSetCallback(&MakeNewGameDone);
+ GenerateWorld(from_heightmap ? GW_HEIGHTMAP : GW_NEWGAME, 1 << _patches.map_x, 1 << _patches.map_y);
+}
+
+static void MakeNewEditorWorldDone(void)
+{
+ SetLocalPlayer(OWNER_NONE);
+
+ MarkWholeScreenDirty();
+}
+
+static void MakeNewEditorWorld(void)
+{
+ _game_mode = GM_EDITOR;
+
+ ResetGRFConfig(true);
+
+ GenerateWorldSetCallback(&MakeNewEditorWorldDone);
+ GenerateWorld(GW_EMPTY, 1 << _patches.map_x, 1 << _patches.map_y);
+}
+
+void StartupPlayers(void);
+void StartupDisasters(void);
+extern void StartupEconomy(void);
+
+/**
+ * Start Scenario starts a new game based on a scenario.
+ * Eg 'New Game' --> select a preset scenario
+ * This starts a scenario based on your current difficulty settings
+ */
+static void StartScenario(void)
+{
+ _game_mode = GM_NORMAL;
+
+ // invalid type
+ if (_file_to_saveload.mode == SL_INVALID) {
+ DEBUG(sl, 0, "Savegame is obsolete or invalid format: '%s'", _file_to_saveload.name);
+ ShowErrorMessage(INVALID_STRING_ID, STR_4009_GAME_LOAD_FAILED, 0, 0);
+ _game_mode = GM_MENU;
+ return;
+ }
+
+ // Reinitialize windows
+ ResetWindowSystem();
+
+ SetupColorsAndInitialWindow();
+
+ ResetGRFConfig(true);
+
+ // Load game
+ if (SaveOrLoad(_file_to_saveload.name, _file_to_saveload.mode) != SL_OK) {
+ LoadIntroGame();
+ ShowErrorMessage(INVALID_STRING_ID, STR_4009_GAME_LOAD_FAILED, 0, 0);
+ }
+
+ _opt_ptr = &_opt;
+ _opt_ptr->diff = _opt_newgame.diff;
+ _opt.diff_level = _opt_newgame.diff_level;
+
+ // Inititalize data
+ StartupEconomy();
+ StartupPlayers();
+ StartupEngines();
+ StartupDisasters();
+
+ SetLocalPlayer(0);
+ _current_player = _local_player;
+ DoCommandP(0, (_patches.autorenew << 15 ) | (_patches.autorenew_months << 16) | 4, _patches.autorenew_money, NULL, CMD_SET_AUTOREPLACE);
+
+ MarkWholeScreenDirty();
+}
+
+bool SafeSaveOrLoad(const char *filename, int mode, int newgm)
+{
+ byte ogm = _game_mode;
+
+ _game_mode = newgm;
+ switch (SaveOrLoad(filename, mode)) {
+ case SL_OK: return true;
+
+ case SL_REINIT:
+ switch (ogm) {
+ case GM_MENU: LoadIntroGame(); break;
+ case GM_EDITOR: MakeNewEditorWorld(); break;
+ default: MakeNewGame(false); break;
+ }
+ return false;
+
+ default:
+ _game_mode = ogm;
+ return false;
+ }
+}
+
+void SwitchMode(int new_mode)
+{
+#ifdef ENABLE_NETWORK
+ // If we are saving something, the network stays in his current state
+ if (new_mode != SM_SAVE) {
+ // If the network is active, make it not-active
+ if (_networking) {
+ if (_network_server && (new_mode == SM_LOAD || new_mode == SM_NEWGAME)) {
+ NetworkReboot();
+ NetworkUDPStop();
+ } else {
+ NetworkDisconnect();
+ NetworkUDPStop();
+ }
+ }
+
+ // 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) {
+ NetworkServerStart();
+ } else {
+ // This client no longer wants to be a network-server
+ _is_network_server = false;
+ }
+ }
+ }
+#endif /* ENABLE_NETWORK */
+
+ switch (new_mode) {
+ case SM_EDITOR: /* Switch to scenario editor */
+ MakeNewEditorWorld();
+ break;
+
+ case SM_NEWGAME: /* New Game --> 'Random game' */
+#ifdef ENABLE_NETWORK
+ if (_network_server) {
+ snprintf(_network_game_info.map_name, lengthof(_network_game_info.map_name), "Random Map");
+ }
+#endif /* ENABLE_NETWORK */
+ MakeNewGame(false);
+ break;
+
+ case SM_START_SCENARIO: /* New Game --> Choose one of the preset scenarios */
+#ifdef ENABLE_NETWORK
+ if (_network_server) {
+ snprintf(_network_game_info.map_name, lengthof(_network_game_info.map_name), "%s (Loaded scenario)", _file_to_saveload.title);
+ }
+#endif /* ENABLE_NETWORK */
+ StartScenario();
+ break;
+
+ case SM_LOAD: { /* Load game, Play Scenario */
+ _opt_ptr = &_opt;
+ ResetGRFConfig(true);
+
+ if (!SafeSaveOrLoad(_file_to_saveload.name, _file_to_saveload.mode, GM_NORMAL)) {
+ LoadIntroGame();
+ ShowErrorMessage(INVALID_STRING_ID, STR_4009_GAME_LOAD_FAILED, 0, 0);
+ } else {
+ /* Update the local player for a loaded game. It is either always
+ * player #1 (eg 0) or in the case of a dedicated server a spectator */
+ SetLocalPlayer(_network_dedicated ? PLAYER_SPECTATOR : 0);
+ DoCommandP(0, 0, 0, NULL, CMD_PAUSE); // decrease pause counter (was increased from opening load dialog)
+#ifdef ENABLE_NETWORK
+ if (_network_server) {
+ snprintf(_network_game_info.map_name, lengthof(_network_game_info.map_name), "%s (Loaded game)", _file_to_saveload.title);
+ }
+#endif /* ENABLE_NETWORK */
+ }
+ break;
+ }
+
+ case SM_START_HEIGHTMAP: /* Load a heightmap and start a new game from it */
+#ifdef ENABLE_NETWORK
+ if (_network_server) {
+ snprintf(_network_game_info.map_name, lengthof(_network_game_info.map_name), "%s (Heightmap)", _file_to_saveload.title);
+ }
+#endif /* ENABLE_NETWORK */
+ MakeNewGame(true);
+ break;
+
+ case SM_LOAD_HEIGHTMAP: /* Load heightmap from scenario editor */
+ SetLocalPlayer(OWNER_NONE);
+
+ GenerateWorld(GW_HEIGHTMAP, 1 << _patches.map_x, 1 << _patches.map_y);
+ MarkWholeScreenDirty();
+ break;
+
+ case SM_LOAD_SCENARIO: { /* Load scenario from scenario editor */
+ if (SafeSaveOrLoad(_file_to_saveload.name, _file_to_saveload.mode, GM_EDITOR)) {
+ Player *p;
+
+ _opt_ptr = &_opt;
+
+ SetLocalPlayer(OWNER_NONE);
+ _generating_world = true;
+ /* Delete all players */
+ FOR_ALL_PLAYERS(p) {
+ if (p->is_active) {
+ ChangeOwnershipOfPlayerItems(p->index, PLAYER_SPECTATOR);
+ p->is_active = false;
+ }
+ }
+ _generating_world = false;
+ _patches_newgame.starting_year = _cur_year;
+ // delete all stations owned by a player
+ DeleteAllPlayerStations();
+ } else {
+ ShowErrorMessage(INVALID_STRING_ID, STR_4009_GAME_LOAD_FAILED, 0, 0);
+ }
+ break;
+ }
+
+ case SM_MENU: /* Switch to game intro menu */
+ LoadIntroGame();
+ break;
+
+ case SM_SAVE: /* Save game */
+ if (SaveOrLoad(_file_to_saveload.name, SL_SAVE) != SL_OK) {
+ ShowErrorMessage(INVALID_STRING_ID, STR_4007_GAME_SAVE_FAILED, 0, 0);
+ } else {
+ DeleteWindowById(WC_SAVELOAD, 0);
+ }
+ break;
+
+ case SM_GENRANDLAND: /* Generate random land within scenario editor */
+ SetLocalPlayer(OWNER_NONE);
+ GenerateWorld(GW_RANDOM, 1 << _patches.map_x, 1 << _patches.map_y);
+ // XXX: set date
+ MarkWholeScreenDirty();
+ break;
+ }
+
+ if (_switch_mode_errorstr != INVALID_STRING_ID) {
+ ShowErrorMessage(INVALID_STRING_ID, _switch_mode_errorstr, 0, 0);
+ }
+}
+
+
+// State controlling game loop.
+// The state must not be changed from anywhere
+// but here.
+// That check is enforced in DoCommand.
+void StateGameLoop(void)
+{
+ // dont execute the state loop during pause
+ if (_pause) return;
+ if (IsGeneratingWorld()) return;
+
+ if (_game_mode == GM_EDITOR) {
+ RunTileLoop();
+ CallVehicleTicks();
+ CallLandscapeTick();
+ CallWindowTickEvent();
+ NewsLoop();
+ } else {
+ // All these actions has to be done from OWNER_NONE
+ // for multiplayer compatibility
+ PlayerID p = _current_player;
+ _current_player = OWNER_NONE;
+
+ AnimateAnimatedTiles();
+ IncreaseDate();
+ RunTileLoop();
+ CallVehicleTicks();
+ CallLandscapeTick();
+
+ AI_RunGameLoop();
+
+ CallWindowTickEvent();
+ NewsLoop();
+ _current_player = p;
+ }
+}
+
+static void DoAutosave(void)
+{
+ char buf[200];
+
+ if (_patches.keep_all_autosave && _local_player != PLAYER_SPECTATOR) {
+ const Player *p = GetPlayer(_local_player);
+ char* s = buf;
+
+ s += snprintf(buf, lengthof(buf), "%s%s", _paths.autosave_dir, PATHSEP);
+
+ SetDParam(0, p->name_1);
+ SetDParam(1, p->name_2);
+ SetDParam(2, _date);
+ s = GetString(s, STR_4004, lastof(buf));
+ strecpy(s, ".sav", lastof(buf));
+ } else { /* generate a savegame name and number according to _patches.max_num_autosaves */
+ snprintf(buf, lengthof(buf), "%s%sautosave%d.sav", _paths.autosave_dir, PATHSEP, _autosave_ctr);
+
+ _autosave_ctr++;
+ if (_autosave_ctr >= _patches.max_num_autosaves) {
+ // we reached the limit for numbers of autosaves. We will start over
+ _autosave_ctr = 0;
+ }
+ }
+
+ DEBUG(sl, 2, "Autosaving to '%s'", buf);
+ if (SaveOrLoad(buf, SL_SAVE) != SL_OK)
+ ShowErrorMessage(INVALID_STRING_ID, STR_AUTOSAVE_FAILED, 0, 0);
+}
+
+static void ScrollMainViewport(int x, int y)
+{
+ if (_game_mode != GM_MENU) {
+ Window *w = FindWindowById(WC_MAIN_WINDOW, 0);
+ assert(w);
+
+ WP(w,vp_d).scrollpos_x += x << w->viewport->zoom;
+ WP(w,vp_d).scrollpos_y += y << w->viewport->zoom;
+ }
+}
+
+static const int8 scrollamt[16][2] = {
+ { 0, 0},
+ {-2, 0}, // 1 : left
+ { 0, -2}, // 2 : up
+ {-2, -1}, // 3 : left + up
+ { 2, 0}, // 4 : right
+ { 0, 0}, // 5 : left + right
+ { 2, -1}, // 6 : right + up
+ { 0, -2}, // 7 : left + right + up = up
+ { 0 ,2}, // 8 : down
+ {-2 ,1}, // 9 : down+left
+ { 0, 0}, // 10 : impossible
+ {-2, 0}, // 11 : left + up + down = left
+ { 2, 1}, // 12 : down+right
+ { 0, 2}, // 13 : left + right + down = down
+ { 0, -2}, // 14 : left + right + up = up
+ { 0, 0}, // 15 : impossible
+};
+
+static void HandleKeyScrolling(void)
+{
+ if (_dirkeys && !_no_scroll) {
+ int factor = _shift_pressed ? 50 : 10;
+ ScrollMainViewport(scrollamt[_dirkeys][0] * factor, scrollamt[_dirkeys][1] * factor);
+ }
+}
+
+void GameLoop(void)
+{
+ ThreadMsg message;
+
+ if ((message = OTTD_PollThreadEvent()) != 0) ProcessSentMessage(message);
+
+ // autosave game?
+ if (_do_autosave) {
+ _do_autosave = false;
+ DoAutosave();
+ RedrawAutosave();
+ }
+
+ // handle scrolling of the main window
+ HandleKeyScrolling();
+
+ // make a screenshot?
+ if (IsScreenshotRequested()) ShowScreenshotResult(MakeScreenshot());
+
+ // switch game mode?
+ if (_switch_mode != SM_NONE) {
+ SwitchMode(_switch_mode);
+ _switch_mode = SM_NONE;
+ }
+
+ IncreaseSpriteLRU();
+ InteractiveRandom();
+
+ if (_scroller_click_timeout > 3) {
+ _scroller_click_timeout -= 3;
+ } else {
+ _scroller_click_timeout = 0;
+ }
+
+ _caret_timer += 3;
+ _timer_counter += 8;
+ CursorTick();
+
+#ifdef ENABLE_NETWORK
+ // Check for UDP stuff
+ if (_network_available) NetworkUDPGameLoop();
+
+ if (_networking && !IsGeneratingWorld()) {
+ // 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(_network_last_host, _network_last_port);
+ }
+ // Singleplayer
+ StateGameLoop();
+ }
+#else
+ StateGameLoop();
+#endif /* ENABLE_NETWORK */
+
+ if (!_pause && _display_opt & DO_FULL_ANIMATION) DoPaletteAnimations();
+
+ if (!_pause || _cheats.build_in_pause.value) MoveAllTextEffects();
+
+ InputLoop();
+
+ MusicLoop();
+}
+
+void BeforeSaveGame(void)
+{
+ const Window *w = FindWindowById(WC_MAIN_WINDOW, 0);
+
+ if (w != NULL) {
+ _saved_scrollpos_x = WP(w, const vp_d).scrollpos_x;
+ _saved_scrollpos_y = WP(w, const vp_d).scrollpos_y;
+ _saved_scrollpos_zoom = w->viewport->zoom;
+ }
+}
+
+static void ConvertTownOwner(void)
+{
+ TileIndex tile;
+
+ for (tile = 0; tile != MapSize(); tile++) {
+ switch (GetTileType(tile)) {
+ case MP_STREET:
+ if (IsLevelCrossing(tile) && GetCrossingRoadOwner(tile) & 0x80) {
+ SetCrossingRoadOwner(tile, OWNER_TOWN);
+ }
+ /* FALLTHROUGH */
+
+ case MP_TUNNEL: case MP_STREET_BRIDGE:
+ if (GetTileOwner(tile) & 0x80) SetTileOwner(tile, OWNER_TOWN);
+ break;
+
+ default: break;
+ }
+ }
+}
+
+// before savegame version 4, the name of the company determined if it existed
+static void CheckIsPlayerActive(void)
+{
+ Player *p;
+
+ FOR_ALL_PLAYERS(p) {
+ if (p->name_1 != 0) p->is_active = true;
+ }
+}
+
+// since savegame version 4.1, exclusive transport rights are stored at towns
+static void UpdateExclusiveRights(void)
+{
+ Town *t;
+
+ FOR_ALL_TOWNS(t) {
+ t->exclusivity = (byte)-1;
+ }
+
+ /* FIXME old exclusive rights status is not being imported (stored in s->blocked_months_obsolete)
+ * could be implemented this way:
+ * 1.) Go through all stations
+ * Build an array town_blocked[ town_id ][ player_id ]
+ * that stores if at least one station in that town is blocked for a player
+ * 2.) Go through that array, if you find a town that is not blocked for
+ * one player, but for all others, then give him exclusivity.
+ */
+}
+
+static const byte convert_currency[] = {
+ 0, 1, 12, 8, 3,
+ 10, 14, 19, 4, 5,
+ 9, 11, 13, 6, 17,
+ 16, 22, 21, 7, 15,
+ 18, 2, 20, };
+
+// since savegame version 4.2 the currencies are arranged differently
+static void UpdateCurrencies(void)
+{
+ _opt.currency = convert_currency[_opt.currency];
+}
+
+/* Up to revision 1413 the invisible tiles at the southern border have not been
+ * MP_VOID, even though they should have. This is fixed by this function
+ */
+static void UpdateVoidTiles(void)
+{
+ uint i;
+
+ for (i = 0; i < MapMaxY(); ++i) MakeVoid(i * MapSizeX() + MapMaxX());
+ for (i = 0; i < MapSizeX(); ++i) MakeVoid(MapSizeX() * MapMaxY() + i);
+}
+
+// since savegame version 6.0 each sign has an "owner", signs without owner (from old games are set to 255)
+static void UpdateSignOwner(void)
+{
+ Sign *si;
+
+ FOR_ALL_SIGNS(si) si->owner = OWNER_NONE;
+}
+
+extern void UpdateOldAircraft( void );
+extern void UpdateOilRig( void );
+
+
+static inline RailType UpdateRailType(RailType rt, RailType min)
+{
+ return rt >= min ? (RailType)(rt + 1): rt;
+}
+
+bool AfterLoadGame(void)
+{
+ Window *w;
+ ViewPort *vp;
+ Player *p;
+
+ // in version 2.1 of the savegame, town owner was unified.
+ if (CheckSavegameVersionOldStyle(2, 1)) ConvertTownOwner();
+
+ // from version 4.1 of the savegame, exclusive rights are stored at towns
+ if (CheckSavegameVersionOldStyle(4, 1)) UpdateExclusiveRights();
+
+ // from version 4.2 of the savegame, currencies are in a different order
+ if (CheckSavegameVersionOldStyle(4, 2)) UpdateCurrencies();
+
+ // from version 6.1 of the savegame, signs have an "owner"
+ if (CheckSavegameVersionOldStyle(6, 1)) UpdateSignOwner();
+
+ /* In old version there seems to be a problem that water is owned by
+ OWNER_NONE, not OWNER_WATER.. I can't replicate it for the current
+ (4.3) version, so I just check when versions are older, and then
+ walk through the whole map.. */
+ if (CheckSavegameVersionOldStyle(4, 3)) {
+ TileIndex tile = TileXY(0, 0);
+ uint w = MapSizeX();
+ uint h = MapSizeY();
+
+ BEGIN_TILE_LOOP(tile_cur, w, h, tile)
+ if (IsTileType(tile_cur, MP_WATER) && GetTileOwner(tile_cur) >= MAX_PLAYERS)
+ SetTileOwner(tile_cur, OWNER_WATER);
+ END_TILE_LOOP(tile_cur, w, h, tile)
+ }
+
+ // convert road side to my format.
+ if (_opt.road_side) _opt.road_side = 1;
+
+ /* Check all NewGRFs are present */
+ if (!IsGoodGRFConfigList()) return false;
+
+ /* Update current year
+ * must be done before loading sprites as some newgrfs check it */
+ SetDate(_date);
+
+ // Load the sprites
+ GfxLoadSprites();
+ LoadStringWidthTable();
+
+ /* Connect front and rear engines of multiheaded trains and converts
+ * subtype to the new format */
+ if (CheckSavegameVersionOldStyle(17, 1)) ConvertOldMultiheadToNew();
+
+ /* Connect front and rear engines of multiheaded trains */
+ ConnectMultiheadedTrains();
+
+ // reinit the landscape variables (landscape might have changed)
+ InitializeLandscapeVariables(true);
+
+ // Update all vehicles
+ AfterLoadVehicles();
+
+ // Update all waypoints
+ if (CheckSavegameVersion(12)) FixOldWaypoints();
+
+ UpdateAllWaypointSigns();
+
+ // in version 2.2 of the savegame, we have new airports
+ if (CheckSavegameVersionOldStyle(2, 2)) UpdateOldAircraft();
+
+ UpdateAllStationVirtCoord();
+
+ // Setup town coords
+ AfterLoadTown();
+ UpdateAllSignVirtCoords();
+
+ // make sure there is a town in the game
+ if (_game_mode == GM_NORMAL && !ClosestTownFromTile(0, (uint)-1)) {
+ _error_message = STR_NO_TOWN_IN_SCENARIO;
+ return false;
+ }
+
+ // Initialize windows
+ ResetWindowSystem();
+ SetupColorsAndInitialWindow();
+
+ w = FindWindowById(WC_MAIN_WINDOW, 0);
+
+ WP(w,vp_d).scrollpos_x = _saved_scrollpos_x;
+ WP(w,vp_d).scrollpos_y = _saved_scrollpos_y;
+
+ vp = w->viewport;
+ vp->zoom = _saved_scrollpos_zoom;
+ vp->virtual_width = vp->width << vp->zoom;
+ vp->virtual_height = vp->height << vp->zoom;
+
+ // in version 4.1 of the savegame, is_active was introduced to determine
+ // if a player does exist, rather then checking name_1
+ if (CheckSavegameVersionOldStyle(4, 1)) CheckIsPlayerActive();
+
+ // the void tiles on the southern border used to belong to a wrong class (pre 4.3).
+ if (CheckSavegameVersionOldStyle(4, 3)) UpdateVoidTiles();
+
+ // If Load Scenario / New (Scenario) Game is used,
+ // a player does not exist yet. So create one here.
+ // 1 exeption: network-games. Those can have 0 players
+ // But this exeption is not true for network_servers!
+ if (!_players[0].is_active && (!_networking || (_networking && _network_server)))
+ DoStartupNewPlayer(false);
+
+ DoZoomInOutWindow(ZOOM_NONE, w); // update button status
+ MarkWholeScreenDirty();
+
+ // In 5.1, Oilrigs have been moved (again)
+ if (CheckSavegameVersionOldStyle(5, 1)) UpdateOilRig();
+
+ /* In version 6.1 we put the town index in the map-array. To do this, we need
+ * to use m2 (16bit big), so we need to clean m2, and that is where this is
+ * all about ;) */
+ if (CheckSavegameVersionOldStyle(6, 1)) {
+ BEGIN_TILE_LOOP(tile, MapSizeX(), MapSizeY(), 0) {
+ switch (GetTileType(tile)) {
+ case MP_HOUSE:
+ _m[tile].m4 = _m[tile].m2;
+ SetTownIndex(tile, CalcClosestTownFromTile(tile, (uint)-1)->index);
+ break;
+
+ case MP_STREET:
+ _m[tile].m4 |= (_m[tile].m2 << 4);
+ if (IsTileOwner(tile, OWNER_TOWN)) {
+ SetTownIndex(tile, CalcClosestTownFromTile(tile, (uint)-1)->index);
+ } else {
+ SetTownIndex(tile, 0);
+ }
+ break;
+
+ default: break;
+ }
+ } END_TILE_LOOP(tile, MapSizeX(), MapSizeY(), 0);
+ }
+
+ /* From version 9.0, we update the max passengers of a town (was sometimes negative
+ * before that. */
+ if (CheckSavegameVersion(9)) {
+ Town *t;
+ FOR_ALL_TOWNS(t) UpdateTownMaxPass(t);
+ }
+
+ /* From version 16.0, we included autorenew on engines, which are now saved, but
+ * of course, we do need to initialize them for older savegames. */
+ if (CheckSavegameVersion(16)) {
+ FOR_ALL_PLAYERS(p) {
+ p->engine_renew_list = NULL;
+ p->engine_renew = false;
+ p->engine_renew_months = -6;
+ p->engine_renew_money = 100000;
+ }
+
+ /* When loading a game, _local_player is not yet set to the correct value.
+ * However, in a dedicated server we are a spectator, so nothing needs to
+ * happen. In case we are not a dedicated server, the local player always
+ * becomes player 0, unless we are in the scenario editor where all the
+ * players are 'invalid'.
+ */
+ if (!_network_dedicated && IsValidPlayer(0)) {
+ p = GetPlayer(0);
+ p->engine_renew = _patches.autorenew;
+ p->engine_renew_months = _patches.autorenew_months;
+ p->engine_renew_money = _patches.autorenew_money;
+ }
+ }
+
+ if (CheckSavegameVersion(42)) {
+ TileIndex map_end = MapSize();
+ TileIndex tile;
+
+ for (tile = 0; tile != map_end; tile++) {
+ if (MayHaveBridgeAbove(tile)) ClearBridgeMiddle(tile);
+ if (IsTileType(tile, MP_TUNNEL) && HASBIT(_m[tile].m5, 7)) {
+ if (HASBIT(_m[tile].m5, 6)) { // middle part
+ Axis axis = (Axis)GB(_m[tile].m5, 0, 1);
+
+ if (HASBIT(_m[tile].m5, 5)) { // transport route under bridge?
+ if (GB(_m[tile].m5, 3, 2) == TRANSPORT_RAIL) {
+ MakeRailNormal(
+ tile,
+ GetTileOwner(tile),
+ axis == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X,
+ GetRailType(tile)
+ );
+ } else {
+ TownID town = IsTileOwner(tile, OWNER_TOWN) ? ClosestTownFromTile(tile, (uint)-1)->index : 0;
+
+ MakeRoadNormal(
+ tile,
+ GetTileOwner(tile),
+ axis == AXIS_X ? ROAD_Y : ROAD_X,
+ town
+ );
+ }
+ } else {
+ if (GB(_m[tile].m5, 3, 2) == 0) {
+ MakeClear(tile, CLEAR_GRASS, 3);
+ } else {
+ MakeCanal(tile, GetTileOwner(tile));
+ }
+ }
+ SetBridgeMiddle(tile, axis);
+ } else { // ramp
+ Axis axis = (Axis)GB(_m[tile].m5, 0, 1);
+ uint north_south = GB(_m[tile].m5, 5, 1);
+ DiagDirection dir = ReverseDiagDir(XYNSToDiagDir(axis, north_south));
+ TransportType type = (TransportType)GB(_m[tile].m5, 1, 2);
+
+ _m[tile].m5 = 1 << 7 | type << 2 | dir;
+ }
+ }
+ }
+ }
+
+ /* Divide MP_TUNNELBRIDGE into more tile types */
+ if (CheckSavegameVersion(43)) {
+ TileIndex tile;
+
+ for (tile = 0; tile != MapSize(); tile++) {
+ if (IsTileType(tile, MP_TUNNEL)) {
+ if (HASBIT(_m[tile].m5, 7)) { /* Bridge */
+ DiagDirection dd = GB(_m[tile].m5, 0, 2);
+ SB(_m[tile].m5, 0, 2, 0);
+ if (GB(_m[tile].m5, 2, 2) == 0) { /* Railway Bridge */
+ SetTileType(tile, MP_RAILWAY_BRIDGE);
+ if (dd == DIAGDIR_NE || dd == DIAGDIR_SW) {
+ SETBIT(_m[tile].m5, 0);
+ } else {
+ SETBIT(_m[tile].m5, 1);
+ }
+ } else {
+ SetTileType(tile, MP_STREET_BRIDGE);
+ }
+ CLRBIT(_m[tile].m5, 7);
+ SB(_m[tile].m5, 2, 2, 0);
+ SB(_m[tile].m4, 5, 2, dd);
+ /* Move the bridge type around */
+ SB(_m[tile].m2, 12, 4, GB(_m[tile].m2, 4, 4));
+ SB(_m[tile].m2, 4, 4, 0);
+ } else { /* Tunnel */
+ SetTileType(tile, MP_TUNNEL);
+ }
+ }
+ }
+ }
+
+ if (CheckSavegameVersion(42)) {
+ Vehicle* v;
+ FOR_ALL_VEHICLES(v) {
+ if (v->type != VEH_Train && v->type != VEH_Road) continue;
+ if (IsBridgeTile(v->tile)) {
+ DiagDirection dir = GetBridgeRampDirection(v->tile);
+
+ if (dir != DirToDiagDir(v->direction)) continue;
+ switch (dir) {
+ default: NOT_REACHED();
+ case DIAGDIR_NE: if ((v->x_pos & 0xF) != 0) continue; break;
+ case DIAGDIR_SE: if ((v->y_pos & 0xF) != TILE_SIZE - 1) continue; break;
+ case DIAGDIR_SW: if ((v->x_pos & 0xF) != TILE_SIZE - 1) continue; break;
+ case DIAGDIR_NW: if ((v->y_pos & 0xF) != 0) continue; break;
+ }
+ } else if (v->z_pos > GetSlopeZ(v->x_pos, v->y_pos)) {
+ v->tile = GetNorthernBridgeEnd(v->tile);
+ } else {
+ continue;
+ }
+ if (v->type == VEH_Train) {
+ v->u.rail.track = 0x40;
+ } else {
+ v->u.road.state = 0xFF;
+ }
+ }
+ }
+
+ /* Elrails got added in rev 24 */
+ if (CheckSavegameVersion(24)) {
+ Vehicle *v;
+ uint i;
+ TileIndex t;
+ RailType min_rail = RAILTYPE_ELECTRIC;
+
+ for (i = 0; i < lengthof(_engines); i++) {
+ Engine *e = GetEngine(i);
+ if (e->type == VEH_Train &&
+ (e->railtype != RAILTYPE_RAIL || RailVehInfo(i)->engclass == 2)) {
+ e->railtype++;
+ }
+ }
+
+ FOR_ALL_VEHICLES(v) {
+ if (v->type == VEH_Train) {
+ RailType rt = GetEngine(v->engine_type)->railtype;
+
+ v->u.rail.railtype = rt;
+ if (rt == RAILTYPE_ELECTRIC) min_rail = RAILTYPE_RAIL;
+ }
+ }
+
+ /* .. so we convert the entire map from normal to elrail (so maintain "fairness") */
+ for (t = 0; t < MapSize(); t++) {
+ switch (GetTileType(t)) {
+ case MP_RAILWAY:
+ SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
+ break;
+
+ case MP_STREET:
+ if (IsLevelCrossing(t)) {
+ SetRailTypeCrossing(t, UpdateRailType(GetRailTypeCrossing(t), min_rail));
+ }
+ break;
+
+ case MP_STATION:
+ if (IsRailwayStation(t)) {
+ SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
+ }
+ break;
+
+ case MP_TUNNEL:
+ if (GetTunnelTransportType(t) == TRANSPORT_RAIL) SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
+ break;
+
+ case MP_RAILWAY_BRIDGE:
+ SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ FOR_ALL_VEHICLES(v) {
+ if (v->type == VEH_Train && (IsFrontEngine(v) || IsFreeWagon(v))) TrainConsistChanged(v);
+ }
+
+ }
+
+ /* In version 16.1 of the savegame a player can decide if trains, which get
+ * replaced, shall keep their old length. In all prior versions, just default
+ * to false */
+ if (CheckSavegameVersionOldStyle(16, 1)) {
+ FOR_ALL_PLAYERS(p) p->renew_keep_length = false;
+ }
+
+ /* In version 17, ground type is moved from m2 to m4 for depots and
+ * waypoints to make way for storing the index in m2. The custom graphics
+ * id which was stored in m4 is now saved as a grf/id reference in the
+ * waypoint struct. */
+ if (CheckSavegameVersion(17)) {
+ Waypoint *wp;
+
+ FOR_ALL_WAYPOINTS(wp) {
+ if (wp->deleted == 0) {
+ const StationSpec *statspec = NULL;
+
+ if (HASBIT(_m[wp->xy].m3, 4))
+ statspec = GetCustomStationSpec(STAT_CLASS_WAYP, _m[wp->xy].m4 + 1);
+
+ if (statspec != NULL) {
+ wp->stat_id = _m[wp->xy].m4 + 1;
+ wp->grfid = statspec->grfid;
+ wp->localidx = statspec->localidx;
+ } else {
+ // No custom graphics set, so set to default.
+ wp->stat_id = 0;
+ wp->grfid = 0;
+ wp->localidx = 0;
+ }
+
+ // Move ground type bits from m2 to m4.
+ _m[wp->xy].m4 = GB(_m[wp->xy].m2, 0, 4);
+ // Store waypoint index in the tile.
+ _m[wp->xy].m2 = wp->index;
+ }
+ }
+ } else {
+ /* As of version 17, we recalculate the custom graphic ID of waypoints
+ * from the GRF ID / station index. */
+ AfterLoadWaypoints();
+ }
+
+ /* From version 15, we moved a semaphore bit from bit 2 to bit 3 in m4, making
+ * room for PBS. Now in version 21 move it back :P. */
+ if (CheckSavegameVersion(21) && !CheckSavegameVersion(15)) {
+ BEGIN_TILE_LOOP(tile, MapSizeX(), MapSizeY(), 0) {
+ if (IsTileType(tile, MP_RAILWAY)) {
+ if (HasSignals(tile)) {
+ // convert PBS signals to combo-signals
+ if (HASBIT(_m[tile].m4, 2)) SetSignalType(tile, SIGTYPE_COMBO);
+
+ // move the signal variant back
+ SetSignalVariant(tile, HASBIT(_m[tile].m4, 3) ? SIG_SEMAPHORE : SIG_ELECTRIC);
+ CLRBIT(_m[tile].m4, 3);
+ }
+
+ // Clear PBS reservation on track
+ if (!IsTileDepotType(tile, TRANSPORT_RAIL)) {
+ SB(_m[tile].m4, 4, 4, 0);
+ } else {
+ CLRBIT(_m[tile].m3, 6);
+ }
+ }
+
+ // Clear PBS reservation on crossing
+ if (IsTileType(tile, MP_STREET) && IsLevelCrossing(tile))
+ CLRBIT(_m[tile].m5, 0);
+
+ // Clear PBS reservation on station
+ if (IsTileType(tile, MP_STATION))
+ CLRBIT(_m[tile].m3, 6);
+ } END_TILE_LOOP(tile, MapSizeX(), MapSizeY(), 0);
+ }
+
+ if (CheckSavegameVersion(22)) UpdatePatches();
+
+ if (CheckSavegameVersion(25)) {
+ Vehicle *v;
+ FOR_ALL_VEHICLES(v) {
+ if (v->type == VEH_Road) {
+ v->vehstatus &= ~0x40;
+ v->u.road.slot = NULL;
+ v->u.road.slot_age = 0;
+ }
+ }
+ }
+
+ if (CheckSavegameVersion(26)) {
+ Station *st;
+ FOR_ALL_STATIONS(st) {
+ st->last_vehicle_type = VEH_Invalid;
+ }
+ }
+
+ YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK);
+
+ if (CheckSavegameVersion(34)) FOR_ALL_PLAYERS(p) ResetPlayerLivery(p);
+
+ FOR_ALL_PLAYERS(p) p->avail_railtypes = GetPlayerRailtypes(p->index);
+
+ if (!CheckSavegameVersion(27)) AfterLoadStations();
+
+ {
+ /* Set up the engine count for all players */
+ Player *players[MAX_PLAYERS];
+ int i;
+ const Vehicle *v;
+
+ for (i = 0; i < MAX_PLAYERS; i++) players[i] = GetPlayer(i);
+
+ FOR_ALL_VEHICLES(v) {
+ if (!IsEngineCountable(v)) continue;
+ players[v->owner]->num_engines[v->engine_type]++;
+ }
+ }
+
+ /* Time starts at 0 instead of 1920.
+ * Account for this in older games by adding an offset */
+ if (CheckSavegameVersion(31)) {
+ Station *st;
+ Waypoint *wp;
+ Engine *e;
+ Player *player;
+ Industry *i;
+ Vehicle *v;
+
+ _date += DAYS_TILL_ORIGINAL_BASE_YEAR;
+ _cur_year += ORIGINAL_BASE_YEAR;
+
+ FOR_ALL_STATIONS(st) st->build_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
+ FOR_ALL_WAYPOINTS(wp) wp->build_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
+ FOR_ALL_ENGINES(e) e->intro_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
+ FOR_ALL_PLAYERS(player) player->inaugurated_year += ORIGINAL_BASE_YEAR;
+ FOR_ALL_INDUSTRIES(i) i->last_prod_year += ORIGINAL_BASE_YEAR;
+
+ FOR_ALL_VEHICLES(v) {
+ v->date_of_last_service += DAYS_TILL_ORIGINAL_BASE_YEAR;
+ v->build_year += ORIGINAL_BASE_YEAR;
+ }
+ }
+
+ /* From 32 on we save the industry who made the farmland.
+ * To give this prettyness to old savegames, we remove all farmfields and
+ * plant new ones. */
+ if (CheckSavegameVersion(32)) {
+ Industry *i;
+
+ BEGIN_TILE_LOOP(tile_cur, MapSizeX(), MapSizeY(), 0) {
+ if (IsTileType(tile_cur, MP_CLEAR) && IsClearGround(tile_cur, CLEAR_FIELDS)) {
+ MakeClear(tile_cur, CLEAR_GRASS, 3);
+ }
+ } END_TILE_LOOP(tile_cur, MapSizeX(), MapSizeY(), 0)
+
+ FOR_ALL_INDUSTRIES(i) {
+ uint j;
+
+ if (i->type == IT_FARM || i->type == IT_FARM_2) {
+ for (j = 0; j != 50; j++) PlantRandomFarmField(i);
+ }
+ }
+ }
+
+ /* Setting no refit flags to all orders in savegames from before refit in orders were added */
+ if (CheckSavegameVersion(36)) {
+ Order *order;
+ Vehicle *v;
+
+ FOR_ALL_ORDERS(order) {
+ order->refit_cargo = CT_NO_REFIT;
+ order->refit_subtype = CT_NO_REFIT;
+ }
+
+ FOR_ALL_VEHICLES(v) {
+ v->current_order.refit_cargo = CT_NO_REFIT;
+ v->current_order.refit_subtype = CT_NO_REFIT;
+ }
+ }
+
+ if (CheckSavegameVersion(37)) {
+ ConvertNameArray();
+ }
+
+ /* from version 38 we have optional elrails, since we cannot know the
+ * preference of a user, let elrails enabled; it can be disabled manually */
+ if (CheckSavegameVersion(38)) {
+ _patches.disable_elrails = false; // enable elrails
+ /* do the same as when elrails were enabled/disabled manually just now */
+ SettingsDisableElrail(_patches.disable_elrails);
+ }
+
+ if (CheckSavegameVersion(43)) {
+ BEGIN_TILE_LOOP(tile_cur, MapSizeX(), MapSizeY(), 0) {
+ if (IsTileType(tile_cur, MP_INDUSTRY)) {
+ switch (GetIndustryGfx(tile_cur)) {
+ case GFX_POWERPLANT_SPARKS:
+ SetIndustryAnimationState(tile_cur, GB(_m[tile_cur].m1, 2, 5));
+ break;
+
+ case GFX_OILWELL_ANIMATED_1:
+ case GFX_OILWELL_ANIMATED_2:
+ case GFX_OILWELL_ANIMATED_3:
+ SetIndustryAnimationState(tile_cur, GB(_m[tile_cur].m1, 0, 2));
+ break;
+
+ case GFX_COAL_MINE_TOWER_ANIMATED:
+ case GFX_COPPER_MINE_TOWER_ANIMATED:
+ case GFX_GOLD_MINE_TOWER_ANIMATED:
+ SetIndustryAnimationState(tile_cur, _m[tile_cur].m1);
+ break;
+
+ default: /* No animation states to change */
+ break;
+ }
+ }
+ } END_TILE_LOOP(tile_cur, MapSizeX(), MapSizeY(), 0)
+ }
+
+ return true;
+}
+
+/** Reload all NewGRF files during a running game. This is a cut-down
+ * version of AfterLoadGame().
+ * XXX - We need to reset the vehicle position hash because with a non-empty
+ * hash AfterLoadVehicles() will loop infinitely. We need AfterLoadVehicles()
+ * to recalculate vehicle data as some NewGRF vehicle sets could have been
+ * removed or added and changed statistics */
+void ReloadNewGRFData(void)
+{
+ /* reload grf data */
+ GfxLoadSprites();
+ LoadStringWidthTable();
+ /* reload vehicles */
+ ResetVehiclePosHash();
+ AfterLoadVehicles();
+ /* update station and waypoint graphics */
+ AfterLoadWaypoints();
+ AfterLoadStations();
+ /* redraw the whole screen */
+ MarkWholeScreenDirty();
+}