# afterload.cpp

Go to the documentation of this file.

    00001 /* $Id$ */
    00002
    00003 /*
    00004  * This file is part of OpenTTD.
    00005  * 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.
    00006  * 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.
    00007  * 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/>.
    00008  */
    00009
    00012 #include "../stdafx.h"
    00013 #include "../void_map.h"
    00014 #include "../signs_base.h"
    00015 #include "../depot_base.h"
    00016 #include "../fios.h"
    00017 #include "../gamelog_internal.h"
    00018 #include "../network/network.h"
    00019 #include "../gfxinit.h"
    00020 #include "../viewport_func.h"
    00021 #include "../industry.h"
    00022 #include "../clear_map.h"
    00023 #include "../vehicle_func.h"
    00024 #include "../string_func.h"
    00025 #include "../date_func.h"
    00026 #include "../roadveh.h"
    00027 #include "../train.h"
    00028 #include "../station_base.h"
    00029 #include "../waypoint_base.h"
    00030 #include "../roadstop_base.h"
    00031 #include "../tunnelbridge_map.h"
    00032 #include "../pathfinder/yapf/yapf_cache.h"
    00033 #include "../elrail_func.h"
    00034 #include "../signs_func.h"
    00035 #include "../aircraft.h"
    00036 #include "../object_map.h"
    00037 #include "../object_base.h"
    00038 #include "../tree_map.h"
    00039 #include "../company_func.h"
    00040 #include "../road_cmd.h"
    00041 #include "../ai/ai.hpp"
    00042 #include "../ai/ai_gui.hpp"
    00043 #include "../town.h"
    00044 #include "../economy_base.h"
    00045 #include "../animated_tile_func.h"
    00046 #include "../subsidy_base.h"
    00047 #include "../subsidy_func.h"
    00048 #include "../newgrf.h"
    00049 #include "../engine_func.h"
    00050 #include "../rail_gui.h"
    00051 #include "../core/backup_type.hpp"
    00052 #include "../smallmap_gui.h"
    00053 #include "../news_func.h"
    00054 #include "../error.h"
    00055
    00056
    00057 #include "saveload_internal.h"
    00058
    00059 #include <signal.h>
    00060
    00061 extern Company *DoStartupNewCompany(bool is_ai, CompanyID company = INVALID_COMPANY);
    00062
    00073 void SetWaterClassDependingOnSurroundings(TileIndex t, bool include_invalid_water_class)
    00074 {
    00075   /* If the slope is not flat, we always assume 'land' (if allowed). Also for one-corner-raised-shores.
    00076    * Note: Wrt. autosloping under industry tiles this is the most fool-proof behaviour. */
    00077   if (GetTileSlope(t) != SLOPE_FLAT) {
    00078     if (include_invalid_water_class) {
    00079       SetWaterClass(t, WATER_CLASS_INVALID);
    00080       return;
    00081     } else {
    00082       SlErrorCorrupt("Invalid water class for dry tile");
    00083     }
    00084   }
    00085
    00086   /* Mark tile dirty in all cases */
    00087   MarkTileDirtyByTile(t);
    00088
    00089   if (TileX(t) == 0 || TileY(t) == 0 || TileX(t) == MapMaxX() - 1 || TileY(t) == MapMaxY() - 1) {
    00090     /* tiles at map borders are always WATER_CLASS_SEA */
    00091     SetWaterClass(t, WATER_CLASS_SEA);
    00092     return;
    00093   }
    00094
    00095   bool has_water = false;
    00096   bool has_canal = false;
    00097   bool has_river = false;
    00098
    00099   for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
    00100     TileIndex neighbour = TileAddByDiagDir(t, dir);
    00101     switch (GetTileType(neighbour)) {
    00102       case MP_WATER:
    00103         /* clear water and shipdepots have already a WaterClass associated */
    00104         if (IsCoast(neighbour)) {
    00105           has_water = true;
    00106         } else if (!IsLock(neighbour)) {
    00107           switch (GetWaterClass(neighbour)) {
    00108             case WATER_CLASS_SEA:   has_water = true; break;
    00109             case WATER_CLASS_CANAL: has_canal = true; break;
    00110             case WATER_CLASS_RIVER: has_river = true; break;
    00111             default: SlErrorCorrupt("Invalid water class for tile");
    00112           }
    00113         }
    00114         break;
    00115
    00116       case MP_RAILWAY:
    00117         /* Shore or flooded halftile */
    00118         has_water |= (GetRailGroundType(neighbour) == RAIL_GROUND_WATER);
    00119         break;
    00120
    00121       case MP_TREES:
    00122         /* trees on shore */
    00123         has_water |= (GB(_m[neighbour].m2, 4, 2) == TREE_GROUND_SHORE);
    00124         break;
    00125
    00126       default: break;
    00127     }
    00128   }
    00129
    00130   if (!has_water && !has_canal && !has_river && include_invalid_water_class) {
    00131     SetWaterClass(t, WATER_CLASS_INVALID);
    00132     return;
    00133   }
    00134
    00135   if (has_river && !has_canal) {
    00136     SetWaterClass(t, WATER_CLASS_RIVER);
    00137   } else if (has_canal || !has_water) {
    00138     SetWaterClass(t, WATER_CLASS_CANAL);
    00139   } else {
    00140     SetWaterClass(t, WATER_CLASS_SEA);
    00141   }
    00142 }
    00143
    00144 static void ConvertTownOwner()
    00145 {
    00146   for (TileIndex tile = 0; tile != MapSize(); tile++) {
    00147     switch (GetTileType(tile)) {
    00148       case MP_ROAD:
    00149         if (GB(_m[tile].m5, 4, 2) == ROAD_TILE_CROSSING && HasBit(_m[tile].m3, 7)) {
    00150           _m[tile].m3 = OWNER_TOWN;
    00151         }
    00152         /* FALL THROUGH */
    00153
    00154       case MP_TUNNELBRIDGE:
    00155         if (_m[tile].m1 & 0x80) SetTileOwner(tile, OWNER_TOWN);
    00156         break;
    00157
    00158       default: break;
    00159     }
    00160   }
    00161 }
    00162
    00163 /* since savegame version 4.1, exclusive transport rights are stored at towns */
    00164 static void UpdateExclusiveRights()
    00165 {
    00166   Town *t;
    00167
    00168   FOR_ALL_TOWNS(t) {
    00169     t->exclusivity = INVALID_COMPANY;
    00170   }
    00171
    00172   /* FIXME old exclusive rights status is not being imported (stored in s->blocked_months_obsolete)
    00173    *   could be implemented this way:
    00174    * 1.) Go through all stations
    00175    *     Build an array town_blocked[ town_id ][ company_id ]
    00176    *     that stores if at least one station in that town is blocked for a company
    00177    * 2.) Go through that array, if you find a town that is not blocked for
    00178    *     one company, but for all others, then give him exclusivity.
    00179    */
    00180 }
    00181
    00182 static const byte convert_currency[] = {
    00183    0,  1, 12,  8,  3,
    00184   10, 14, 19,  4,  5,
    00185    9, 11, 13,  6, 17,
    00186   16, 22, 21,  7, 15,
    00187   18,  2, 20,
    00188 };
    00189
    00190 /* since savegame version 4.2 the currencies are arranged differently */
    00191 static void UpdateCurrencies()
    00192 {
    00193   _settings_game.locale.currency = convert_currency[_settings_game.locale.currency];
    00194 }
    00195
    00196 /* Up to revision 1413 the invisible tiles at the southern border have not been
    00197  * MP_VOID, even though they should have. This is fixed by this function
    00198  */
    00199 static void UpdateVoidTiles()
    00200 {
    00201   uint i;
    00202
    00203   for (i = 0; i < MapMaxY(); ++i) MakeVoid(i * MapSizeX() + MapMaxX());
    00204   for (i = 0; i < MapSizeX(); ++i) MakeVoid(MapSizeX() * MapMaxY() + i);
    00205 }
    00206
    00207 static inline RailType UpdateRailType(RailType rt, RailType min)
    00208 {
    00209   return rt >= min ? (RailType)(rt + 1): rt;
    00210 }
    00211
    00215 void UpdateAllVirtCoords()
    00216 {
    00217   UpdateAllStationVirtCoords();
    00218   UpdateAllSignVirtCoords();
    00219   UpdateAllTownVirtCoords();
    00220 }
    00221
    00231 static void InitializeWindowsAndCaches()
    00232 {
    00233   /* Initialize windows */
    00234   ResetWindowSystem();
    00235   SetupColoursAndInitialWindow();
    00236
    00237   /* Update coordinates of the signs. */
    00238   UpdateAllVirtCoords();
    00239   ResetViewportAfterLoadGame();
    00240
    00241   Company *c;
    00242   FOR_ALL_COMPANIES(c) {
    00243     /* For each company, verify (while loading a scenario) that the inauguration date is the current year and set it
    00244      * accordingly if it is not the case.  No need to set it on companies that are not been used already,
    00245      * thus the MIN_YEAR (which is really nothing more than Zero, initialized value) test */
    00246     if (_file_to_saveload.filetype == FT_SCENARIO && c->inaugurated_year != MIN_YEAR) {
    00247       c->inaugurated_year = _cur_year;
    00248     }
    00249   }
    00250
    00251   RecomputePrices();
    00252
    00253   GroupStatistics::UpdateAfterLoad();
    00254
    00255   Station::RecomputeIndustriesNearForAll();
    00256   RebuildSubsidisedSourceAndDestinationCache();
    00257
    00258   /* Towns have a noise controlled number of airports system
    00259    * So each airport's noise value must be added to the town->noise_reached value
    00260    * Reset each town's noise_reached value to '0' before. */
    00261   UpdateAirportsNoise();
    00262
    00263   CheckTrainsLengths();
    00264   ShowNewGRFError();
    00265   ShowAIDebugWindowIfAIError();
    00266
    00267   /* Rebuild the smallmap list of owners. */
    00268   BuildOwnerLegend();
    00269 }
    00270
    00271 typedef void (CDECL *SignalHandlerPointer)(int);
    00272 static SignalHandlerPointer _prev_segfault = NULL;
    00273 static SignalHandlerPointer _prev_abort    = NULL;
    00274 static SignalHandlerPointer _prev_fpe      = NULL;
    00275
    00276 static void CDECL HandleSavegameLoadCrash(int signum);
    00277
    00282 static void SetSignalHandlers()
    00283 {
    00284   _prev_segfault = signal(SIGSEGV, HandleSavegameLoadCrash);
    00285   _prev_abort    = signal(SIGABRT, HandleSavegameLoadCrash);
    00286   _prev_fpe      = signal(SIGFPE,  HandleSavegameLoadCrash);
    00287 }
    00288
    00292 static void ResetSignalHandlers()
    00293 {
    00294   signal(SIGSEGV, _prev_segfault);
    00295   signal(SIGABRT, _prev_abort);
    00296   signal(SIGFPE,  _prev_fpe);
    00297 }
    00298
    00304 static const GRFIdentifier *GetOverriddenIdentifier(const GRFConfig *c)
    00305 {
    00306   const LoggedAction *la = &_gamelog_action[_gamelog_actions - 1];
    00307   if (la->at != GLAT_LOAD) return &c->ident;
    00308
    00309   const LoggedChange *lcend = &la->change[la->changes];
    00310   for (const LoggedChange *lc = la->change; lc != lcend; lc++) {
    00311     if (lc->ct == GLCT_GRFCOMPAT && lc->grfcompat.grfid == c->ident.grfid) return &lc->grfcompat;
    00312   }
    00313
    00314   return &c->ident;
    00315 }
    00316
    00318 static bool _saveload_crash_with_missing_newgrfs = false;
    00319
    00325 bool SaveloadCrashWithMissingNewGRFs()
    00326 {
    00327   return _saveload_crash_with_missing_newgrfs;
    00328 }
    00329
    00336 static void CDECL HandleSavegameLoadCrash(int signum)
    00337 {
    00338   ResetSignalHandlers();
    00339
    00340   char buffer[8192];
    00341   char *p = buffer;
    00342   p += seprintf(p, lastof(buffer), "Loading your savegame caused OpenTTD to crash.\n");
    00343
    00344   for (const GRFConfig *c = _grfconfig; !_saveload_crash_with_missing_newgrfs && c != NULL; c = c->next) {
    00345     _saveload_crash_with_missing_newgrfs = HasBit(c->flags, GCF_COMPATIBLE) || c->status == GCS_NOT_FOUND;
    00346   }
    00347
    00348   if (_saveload_crash_with_missing_newgrfs) {
    00349     p += seprintf(p, lastof(buffer),
    00350       "This is most likely caused by a missing NewGRF or a NewGRF that\n"
    00351       "has been loaded as replacement for a missing NewGRF. OpenTTD\n"
    00352       "cannot easily determine whether a replacement NewGRF is of a newer\n"
    00353       "or older version.\n"
    00354       "It will load a NewGRF with the same GRF ID as the missing NewGRF.\n"
    00355       "This means that if the author makes incompatible NewGRFs with the\n"
    00356       "same GRF ID OpenTTD cannot magically do the right thing. In most\n"
    00357       "cases OpenTTD will load the savegame and not crash, but this is an\n"
    00358       "exception.\n"
    00359       "Please load the savegame with the appropriate NewGRFs installed.\n"
    00360       "The missing/compatible NewGRFs are:\n");
    00361
    00362     for (const GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
    00363       if (HasBit(c->flags, GCF_COMPATIBLE)) {
    00364         const GRFIdentifier *replaced = GetOverriddenIdentifier(c);
    00365         char buf[40];
    00366         md5sumToString(buf, lastof(buf), replaced->md5sum);
    00367         p += seprintf(p, lastof(buffer), "NewGRF %08X (checksum %s) not found.\n  Loaded NewGRF \"%s\" with same GRF ID instead.\n", BSWAP32(c->ident.grfid), buf, c->filename);
    00368       }
    00369       if (c->status == GCS_NOT_FOUND) {
    00370         char buf[40];
    00371         md5sumToString(buf, lastof(buf), c->ident.md5sum);
    00372         p += seprintf(p, lastof(buffer), "NewGRF %08X (%s) not found; checksum %s.\n", BSWAP32(c->ident.grfid), c->filename, buf);
    00373       }
    00374     }
    00375   } else {
    00376     p += seprintf(p, lastof(buffer),
    00377       "This is probably caused by a corruption in the savegame.\n"
    00378       "Please file a bug report and attach this savegame.\n");
    00379   }
    00380
    00381   ShowInfo(buffer);
    00382
    00383   SignalHandlerPointer call = NULL;
    00384   switch (signum) {
    00385     case SIGSEGV: call = _prev_segfault; break;
    00386     case SIGABRT: call = _prev_abort; break;
    00387     case SIGFPE:  call = _prev_fpe; break;
    00388     default: NOT_REACHED();
    00389   }
    00390   if (call != NULL) call(signum);
    00391 }
    00392
    00398 static void FixOwnerOfRailTrack(TileIndex t)
    00399 {
    00400   assert(!Company::IsValidID(GetTileOwner(t)) && (IsLevelCrossingTile(t) || IsPlainRailTile(t)));
    00401
    00402   /* remove leftover rail piece from crossing (from very old savegames) */
    00403   Train *v = NULL, *w;
    00404   FOR_ALL_TRAINS(w) {
    00405     if (w->tile == t) {
    00406       v = w;
    00407       break;
    00408     }
    00409   }
    00410
    00411   if (v != NULL) {
    00412     /* when there is a train on crossing (it could happen in TTD), set owner of crossing to train owner */
    00413     SetTileOwner(t, v->owner);
    00414     return;
    00415   }
    00416
    00417   /* try to find any connected rail */
    00418   for (DiagDirection dd = DIAGDIR_BEGIN; dd < DIAGDIR_END; dd++) {
    00419     TileIndex tt = t + TileOffsByDiagDir(dd);
    00420     if (GetTileTrackStatus(t, TRANSPORT_RAIL, 0, dd) != 0 &&
    00421         GetTileTrackStatus(tt, TRANSPORT_RAIL, 0, ReverseDiagDir(dd)) != 0 &&
    00422         Company::IsValidID(GetTileOwner(tt))) {
    00423       SetTileOwner(t, GetTileOwner(tt));
    00424       return;
    00425     }
    00426   }
    00427
    00428   if (IsLevelCrossingTile(t)) {
    00429     /* else change the crossing to normal road (road vehicles won't care) */
    00430     MakeRoadNormal(t, GetCrossingRoadBits(t), GetRoadTypes(t), GetTownIndex(t),
    00431       GetRoadOwner(t, ROADTYPE_ROAD), GetRoadOwner(t, ROADTYPE_TRAM));
    00432     return;
    00433   }
    00434
    00435   /* if it's not a crossing, make it clean land */
    00436   MakeClear(t, CLEAR_GRASS, 0);
    00437 }
    00438
    00445 static uint FixVehicleInclination(Vehicle *v, Direction dir)
    00446 {
    00447   /* Compute place where this vehicle entered the tile */
    00448   int entry_x = v->x_pos;
    00449   int entry_y = v->y_pos;
    00450   switch (dir) {
    00451     case DIR_NE: entry_x |= TILE_UNIT_MASK; break;
    00452     case DIR_NW: entry_y |= TILE_UNIT_MASK; break;
    00453     case DIR_SW: entry_x &= ~TILE_UNIT_MASK; break;
    00454     case DIR_SE: entry_y &= ~TILE_UNIT_MASK; break;
    00455     case INVALID_DIR: break;
    00456     default: NOT_REACHED();
    00457   }
    00458   byte entry_z = GetSlopePixelZ(entry_x, entry_y);
    00459
    00460   /* Compute middle of the tile. */
    00461   int middle_x = (v->x_pos & ~TILE_UNIT_MASK) + TILE_SIZE / 2;
    00462   int middle_y = (v->y_pos & ~TILE_UNIT_MASK) + TILE_SIZE / 2;
    00463   byte middle_z = GetSlopePixelZ(middle_x, middle_y);
    00464
    00465   /* middle_z == entry_z, no height change. */
    00466   if (middle_z == entry_z) return 0;
    00467
    00468   /* middle_z < entry_z, we are going downwards. */
    00469   if (middle_z < entry_z) return 1U << GVF_GOINGDOWN_BIT;
    00470
    00471   /* middle_z > entry_z, we are going upwards. */
    00472   return 1U << GVF_GOINGUP_BIT;
    00473 }
    00474
    00480 bool AfterLoadGame()
    00481 {
    00482   SetSignalHandlers();
    00483
    00484   TileIndex map_size = MapSize();
    00485
    00486   extern TileIndex _cur_tileloop_tile; // From landscape.cpp.
    00487   /* The LFSR used in RunTileLoop iteration cannot have a zeroed state, make it non-zeroed. */
    00488   if (_cur_tileloop_tile == 0) _cur_tileloop_tile = 1;
    00489
    00490   if (IsSavegameVersionBefore(98)) GamelogOldver();
    00491
    00492   GamelogTestRevision();
    00493   GamelogTestMode();
    00494
    00495   if (IsSavegameVersionBefore(98)) GamelogGRFAddList(_grfconfig);
    00496
    00497   if (IsSavegameVersionBefore(119)) {
    00498     _pause_mode = (_pause_mode == 2) ? PM_PAUSED_NORMAL : PM_UNPAUSED;
    00499   } else if (_network_dedicated && (_pause_mode & PM_PAUSED_ERROR) != 0) {
    00500     DEBUG(net, 0, "The loading savegame was paused due to an error state.");
    00501     DEBUG(net, 0, "  The savegame cannot be used for multiplayer!");
    00502     /* Restore the signals */
    00503     ResetSignalHandlers();
    00504     return false;
    00505   } else if (!_networking || _network_server) {
    00506     /* If we are in single player, i.e. not networking, and loading the
    00507      * savegame or we are loading the savegame as network server we do
    00508      * not want to be bothered by being paused because of the automatic
    00509      * reason of a network server, e.g. joining clients or too few
    00510      * active clients. Note that resetting these values for a network
    00511      * client are very bad because then the client is going to execute
    00512      * the game loop when the server is not, i.e. it desyncs. */
    00513     _pause_mode &= ~PMB_PAUSED_NETWORK;
    00514   }
    00515
    00516   /* In very old versions, size of train stations was stored differently.
    00517    * They had swapped width and height if station was built along the Y axis.
    00518    * TTO and TTD used 3 bits for width/height, while OpenTTD used 4.
    00519    * Because the data stored by TTDPatch are unusable for rail stations > 7x7,
    00520    * recompute the width and height. Doing this unconditionally for all old
    00521    * savegames simplifies the code. */
    00522   if (IsSavegameVersionBefore(2)) {
    00523     Station *st;
    00524     FOR_ALL_STATIONS(st) {
    00525       st->train_station.w = st->train_station.h = 0;
    00526     }
    00527     for (TileIndex t = 0; t < map_size; t++) {
    00528       if (!IsTileType(t, MP_STATION)) continue;
    00529       if (_m[t].m5 > 7) continue; // is it a rail station tile?
    00530       st = Station::Get(_m[t].m2);
    00531       assert(st->train_station.tile != 0);
    00532       int dx = TileX(t) - TileX(st->train_station.tile);
    00533       int dy = TileY(t) - TileY(st->train_station.tile);
    00534       assert(dx >= 0 && dy >= 0);
    00535       st->train_station.w = max<uint>(st->train_station.w, dx + 1);
    00536       st->train_station.h = max<uint>(st->train_station.h, dy + 1);
    00537     }
    00538   }
    00539
    00540   /* in version 2.1 of the savegame, town owner was unified. */
    00541   if (IsSavegameVersionBefore(2, 1)) ConvertTownOwner();
    00542
    00543   /* from version 4.1 of the savegame, exclusive rights are stored at towns */
    00544   if (IsSavegameVersionBefore(4, 1)) UpdateExclusiveRights();
    00545
    00546   /* from version 4.2 of the savegame, currencies are in a different order */
    00547   if (IsSavegameVersionBefore(4, 2)) UpdateCurrencies();
    00548
    00549   /* In old version there seems to be a problem that water is owned by
    00550    * OWNER_NONE, not OWNER_WATER.. I can't replicate it for the current
    00551    * (4.3) version, so I just check when versions are older, and then
    00552    * walk through the whole map.. */
    00553   if (IsSavegameVersionBefore(4, 3)) {
    00554     for (TileIndex t = 0; t < map_size; t++) {
    00555       if (IsTileType(t, MP_WATER) && GetTileOwner(t) >= MAX_COMPANIES) {
    00556         SetTileOwner(t, OWNER_WATER);
    00557       }
    00558     }
    00559   }
    00560
    00561   if (IsSavegameVersionBefore(84)) {
    00562     Company *c;
    00563     FOR_ALL_COMPANIES(c) {
    00564       c->name = CopyFromOldName(c->name_1);
    00565       if (c->name != NULL) c->name_1 = STR_SV_UNNAMED;
    00566       c->president_name = CopyFromOldName(c->president_name_1);
    00567       if (c->president_name != NULL) c->president_name_1 = SPECSTR_PRESIDENT_NAME;
    00568     }
    00569
    00570     Station *st;
    00571     FOR_ALL_STATIONS(st) {
    00572       st->name = CopyFromOldName(st->string_id);
    00573       /* generating new name would be too much work for little effect, use the station name fallback */
    00574       if (st->name != NULL) st->string_id = STR_SV_STNAME_FALLBACK;
    00575     }
    00576
    00577     Town *t;
    00578     FOR_ALL_TOWNS(t) {
    00579       t->name = CopyFromOldName(t->townnametype);
    00580       if (t->name != NULL) t->townnametype = SPECSTR_TOWNNAME_START + _settings_game.game_creation.town_name;
    00581     }
    00582   }
    00583
    00584   /* From this point the old names array is cleared. */
    00585   ResetOldNames();
    00586
    00587   if (IsSavegameVersionBefore(106)) {
    00588     /* no station is determined by 'tile == INVALID_TILE' now (instead of '0') */
    00589     Station *st;
    00590     FOR_ALL_STATIONS(st) {
    00591       if (st->airport.tile       == 0) st->airport.tile = INVALID_TILE;
    00592       if (st->dock_tile          == 0) st->dock_tile    = INVALID_TILE;
    00593       if (st->train_station.tile == 0) st->train_station.tile   = INVALID_TILE;
    00594     }
    00595
    00596     /* the same applies to Company::location_of_HQ */
    00597     Company *c;
    00598     FOR_ALL_COMPANIES(c) {
    00599       if (c->location_of_HQ == 0 || (IsSavegameVersionBefore(4) && c->location_of_HQ == 0xFFFF)) {
    00600         c->location_of_HQ = INVALID_TILE;
    00601       }
    00602     }
    00603   }
    00604
    00605   /* convert road side to my format. */
    00606   if (_settings_game.vehicle.road_side) _settings_game.vehicle.road_side = 1;
    00607
    00608   /* Check if all NewGRFs are present, we are very strict in MP mode */
    00609   GRFListCompatibility gcf_res = IsGoodGRFConfigList(_grfconfig);
    00610   for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
    00611     if (c->status == GCS_NOT_FOUND) {
    00612       GamelogGRFRemove(c->ident.grfid);
    00613     } else if (HasBit(c->flags, GCF_COMPATIBLE)) {
    00614       GamelogGRFCompatible(&c->ident);
    00615     }
    00616   }
    00617
    00618   if (_networking && gcf_res != GLC_ALL_GOOD) {
    00619     SetSaveLoadError(STR_NETWORK_ERROR_CLIENT_NEWGRF_MISMATCH);
    00620     /* Restore the signals */
    00621     ResetSignalHandlers();
    00622     return false;
    00623   }
    00624
    00625   switch (gcf_res) {
    00626     case GLC_COMPATIBLE: ShowErrorMessage(STR_NEWGRF_COMPATIBLE_LOAD_WARNING, INVALID_STRING_ID, WL_CRITICAL); break;
    00627     case GLC_NOT_FOUND:  ShowErrorMessage(STR_NEWGRF_DISABLED_WARNING, INVALID_STRING_ID, WL_CRITICAL); _pause_mode = PM_PAUSED_ERROR; break;
    00628     default: break;
    00629   }
    00630
    00631   /* The value of _date_fract got divided, so make sure that old games are converted correctly. */
    00632   if (IsSavegameVersionBefore(11, 1) || (IsSavegameVersionBefore(147) && _date_fract > DAY_TICKS)) _date_fract /= 885;
    00633
    00634   /* Update current year
    00635    * must be done before loading sprites as some newgrfs check it */
    00636   SetDate(_date, _date_fract);
    00637
    00638   /*
    00639    * Force the old behaviour for compatability reasons with old savegames.
    00640    *
    00641    * Note that there is no non-stop in here. This is because the setting could have
    00642    * either value in TTDPatch. To convert it properly the user has to make sure the
    00643    * right value has been chosen in the settings. Otherwise we will be converting
    00644    * it incorrectly in half of the times without a means to correct that.
    00645    */
    00646   if (IsSavegameVersionBefore(4, 2)) _settings_game.station.modified_catchment = false;
    00647   if (IsSavegameVersionBefore(6, 1)) _settings_game.pf.forbid_90_deg = false;
    00648   if (IsSavegameVersionBefore(21))   _settings_game.vehicle.train_acceleration_model = 0;
    00649   if (IsSavegameVersionBefore(90))   _settings_game.vehicle.plane_speed = 4;
    00650   if (IsSavegameVersionBefore(95))   _settings_game.vehicle.dynamic_engines = 0;
    00651   if (IsSavegameVersionBefore(133))  _settings_game.vehicle.roadveh_acceleration_model = 0;
    00652   if (IsSavegameVersionBefore(159))  _settings_game.vehicle.max_train_length = 50;
    00653   if (IsSavegameVersionBefore(166))  _settings_game.economy.infrastructure_maintenance = false;
    00654
    00655   /* Load the sprites */
    00656   GfxLoadSprites();
    00657   LoadStringWidthTable();
    00658
    00659   /* Copy temporary data to Engine pool */
    00660   CopyTempEngineData();
    00661
    00662   /* Connect front and rear engines of multiheaded trains and converts
    00663    * subtype to the new format */
    00664   if (IsSavegameVersionBefore(17, 1)) ConvertOldMultiheadToNew();
    00665
    00666   /* Connect front and rear engines of multiheaded trains */
    00667   ConnectMultiheadedTrains();
    00668
    00669   /* Fix the CargoPackets *and* fix the caches of CargoLists.
    00670    * If this isn't done before Stations and especially Vehicles are
    00671    * running their AfterLoad we might get in trouble. In the case of
    00672    * vehicles we could give the wrong (cached) count of items in a
    00673    * vehicle which causes different results when getting their caches
    00674    * filled; and that could eventually lead to desyncs. */
    00675   CargoPacket::AfterLoad();
    00676
    00677   /* Oilrig was moved from id 15 to 9. We have to do this conversion
    00678    * here as AfterLoadVehicles can check it indirectly via the newgrf
    00679    * code. */
    00680   if (IsSavegameVersionBefore(139)) {
    00681     Station *st;
    00682     FOR_ALL_STATIONS(st) {
    00683       if (st->airport.tile != INVALID_TILE && st->airport.type == 15) {
    00684         st->airport.type = AT_OILRIG;
    00685       }
    00686     }
    00687   }
    00688
    00689   /* Update all vehicles */
    00690   AfterLoadVehicles(true);
    00691
    00692   /* Make sure there is an AI attached to an AI company */
    00693   {
    00694     Company *c;
    00695     FOR_ALL_COMPANIES(c) {
    00696       if (c->is_ai && c->ai_instance == NULL) AI::StartNew(c->index);
    00697     }
    00698   }
    00699
    00700   /* make sure there is a town in the game */
    00701   if (_game_mode == GM_NORMAL && Town::GetNumItems() == 0) {
    00702     SetSaveLoadError(STR_ERROR_NO_TOWN_IN_SCENARIO);
    00703     /* Restore the signals */
    00704     ResetSignalHandlers();
    00705     return false;
    00706   }
    00707
    00708   /* The void tiles on the southern border used to belong to a wrong class (pre 4.3).
    00709    * This problem appears in savegame version 21 too, see r3455. But after loading the
    00710    * savegame and saving again, the buggy map array could be converted to new savegame
    00711    * version. It didn't show up before r12070. */
    00712   if (IsSavegameVersionBefore(87)) UpdateVoidTiles();
    00713
    00714   /* If Load Scenario / New (Scenario) Game is used,
    00715    *  a company does not exist yet. So create one here.
    00716    * 1 exeption: network-games. Those can have 0 companies
    00717    *   But this exeption is not true for non dedicated network_servers! */
    00718   if (!Company::IsValidID(COMPANY_FIRST) && (!_networking || (_networking && _network_server && !_network_dedicated))) {
    00719     DoStartupNewCompany(false);
    00720     Company *c = Company::Get(COMPANY_FIRST);
    00721     c->settings = _settings_client.company;
    00722   }
    00723
    00724   /* Fix the cache for cargo payments. */
    00725   CargoPayment *cp;
    00726   FOR_ALL_CARGO_PAYMENTS(cp) {
    00727     cp->front->cargo_payment = cp;
    00728     cp->current_station = cp->front->last_station_visited;
    00729   }
    00730
    00731   if (IsSavegameVersionBefore(72)) {
    00732     /* Locks in very old savegames had OWNER_WATER as owner */
    00733     for (TileIndex t = 0; t < MapSize(); t++) {
    00734       switch (GetTileType(t)) {
    00735         default: break;
    00736
    00737         case MP_WATER:
    00738           if (GetWaterTileType(t) == WATER_TILE_LOCK && GetTileOwner(t) == OWNER_WATER) SetTileOwner(t, OWNER_NONE);
    00739           break;
    00740
    00741         case MP_STATION: {
    00742           if (HasBit(_m[t].m6, 3)) SetBit(_m[t].m6, 2);
    00743           StationGfx gfx = GetStationGfx(t);
    00744           StationType st;
    00745           if (       IsInsideMM(gfx,   0,   8)) { // Rail station
    00746             st = STATION_RAIL;
    00747             SetStationGfx(t, gfx - 0);
    00748           } else if (IsInsideMM(gfx,   8,  67)) { // Airport
    00749             st = STATION_AIRPORT;
    00750             SetStationGfx(t, gfx - 8);
    00751           } else if (IsInsideMM(gfx,  67,  71)) { // Truck
    00752             st = STATION_TRUCK;
    00753             SetStationGfx(t, gfx - 67);
    00754           } else if (IsInsideMM(gfx,  71,  75)) { // Bus
    00755             st = STATION_BUS;
    00756             SetStationGfx(t, gfx - 71);
    00757           } else if (gfx == 75) {                 // Oil rig
    00758             st = STATION_OILRIG;
    00759             SetStationGfx(t, gfx - 75);
    00760           } else if (IsInsideMM(gfx,  76,  82)) { // Dock
    00761             st = STATION_DOCK;
    00762             SetStationGfx(t, gfx - 76);
    00763           } else if (gfx == 82) {                 // Buoy
    00764             st = STATION_BUOY;
    00765             SetStationGfx(t, gfx - 82);
    00766           } else if (IsInsideMM(gfx,  83, 168)) { // Extended airport
    00767             st = STATION_AIRPORT;
    00768             SetStationGfx(t, gfx - 83 + 67 - 8);
    00769           } else if (IsInsideMM(gfx, 168, 170)) { // Drive through truck
    00770             st = STATION_TRUCK;
    00771             SetStationGfx(t, gfx - 168 + GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);
    00772           } else if (IsInsideMM(gfx, 170, 172)) { // Drive through bus
    00773             st = STATION_BUS;
    00774             SetStationGfx(t, gfx - 170 + GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);
    00775           } else {
    00776             /* Restore the signals */
    00777             ResetSignalHandlers();
    00778             return false;
    00779           }
    00780           SB(_m[t].m6, 3, 3, st);
    00781           break;
    00782         }
    00783       }
    00784     }
    00785   }
    00786
    00787   for (TileIndex t = 0; t < map_size; t++) {
    00788     switch (GetTileType(t)) {
    00789       case MP_STATION: {
    00790         BaseStation *bst = BaseStation::GetByTile(t);
    00791
    00792         /* Set up station spread */
    00793         bst->rect.BeforeAddTile(t, StationRect::ADD_FORCE);
    00794
    00795         /* Waypoints don't have road stops/oil rigs in the old format */
    00796         if (!Station::IsExpected(bst)) break;
    00797         Station *st = Station::From(bst);
    00798
    00799         switch (GetStationType(t)) {
    00800           case STATION_TRUCK:
    00801           case STATION_BUS:
    00802             if (IsSavegameVersionBefore(6)) {
    00803               /* Before version 5 you could not have more than 250 stations.
    00804                * Version 6 adds large maps, so you could only place 253*253
    00805                * road stops on a map (no freeform edges) = 64009. So, yes
    00806                * someone could in theory create such a full map to trigger
    00807                * this assertion, it's safe to assume that's only something
    00808                * theoretical and does not happen in normal games. */
    00809               assert(RoadStop::CanAllocateItem());
    00810
    00811               /* From this version on there can be multiple road stops of the
    00812                * same type per station. Convert the existing stops to the new
    00813                * internal data structure. */
    00814               RoadStop *rs = new RoadStop(t);
    00815
    00816               RoadStop **head =
    00817                 IsTruckStop(t) ? &st->truck_stops : &st->bus_stops;
    00818               *head = rs;
    00819             }
    00820             break;
    00821
    00822           case STATION_OILRIG: {
    00823             /* Very old savegames sometimes have phantom oil rigs, i.e.
    00824              * an oil rig which got shut down, but not completly removed from
    00825              * the map
    00826              */
    00827             TileIndex t1 = TILE_ADDXY(t, 0, 1);
    00828             if (IsTileType(t1, MP_INDUSTRY) &&
    00829                 GetIndustryGfx(t1) == GFX_OILRIG_1) {
    00830               /* The internal encoding of oil rigs was changed twice.
    00831                * It was 3 (till 2.2) and later 5 (till 5.1).
    00832                * Setting it unconditionally does not hurt.
    00833                */
    00834               Station::GetByTile(t)->airport.type = AT_OILRIG;
    00835             } else {
    00836               DeleteOilRig(t);
    00837             }
    00838             break;
    00839           }
    00840
    00841           default: break;
    00842         }
    00843         break;
    00844       }
    00845
    00846       default: break;
    00847     }
    00848   }
    00849
    00850   /* In version 2.2 of the savegame, we have new airports, so status of all aircraft is reset.
    00851    * This has to be called after the oilrig airport_type update above ^^^ ! */
    00852   if (IsSavegameVersionBefore(2, 2)) UpdateOldAircraft();
    00853
    00854   /* In version 6.1 we put the town index in the map-array. To do this, we need
    00855    *  to use m2 (16bit big), so we need to clean m2, and that is where this is
    00856    *  all about ;) */
    00857   if (IsSavegameVersionBefore(6, 1)) {
    00858     for (TileIndex t = 0; t < map_size; t++) {
    00859       switch (GetTileType(t)) {
    00860         case MP_HOUSE:
    00861           _m[t].m4 = _m[t].m2;
    00862           SetTownIndex(t, CalcClosestTownFromTile(t)->index);
    00863           break;
    00864
    00865         case MP_ROAD:
    00866           _m[t].m4 |= (_m[t].m2 << 4);
    00867           if ((GB(_m[t].m5, 4, 2) == ROAD_TILE_CROSSING ? (Owner)_m[t].m3 : GetTileOwner(t)) == OWNER_TOWN) {
    00868             SetTownIndex(t, CalcClosestTownFromTile(t)->index);
    00869           } else {
    00870             SetTownIndex(t, 0);
    00871           }
    00872           break;
    00873
    00874         default: break;
    00875       }
    00876     }
    00877   }
    00878
    00879   /* Force the freeform edges to false for old savegames. */
    00880   if (IsSavegameVersionBefore(111)) {
    00881     _settings_game.construction.freeform_edges = false;
    00882   }
    00883
    00884   /* From version 9.0, we update the max passengers of a town (was sometimes negative
    00885    *  before that. */
    00886   if (IsSavegameVersionBefore(9)) {
    00887     Town *t;
    00888     FOR_ALL_TOWNS(t) UpdateTownMaxPass(t);
    00889   }
    00890
    00891   /* From version 16.0, we included autorenew on engines, which are now saved, but
    00892    *  of course, we do need to initialize them for older savegames. */
    00893   if (IsSavegameVersionBefore(16)) {
    00894     Company *c;
    00895     FOR_ALL_COMPANIES(c) {
    00896       c->engine_renew_list            = NULL;
    00897       c->settings.engine_renew        = false;
    00898       c->settings.engine_renew_months = 6;
    00899       c->settings.engine_renew_money  = 100000;
    00900     }
    00901
    00902     /* When loading a game, _local_company is not yet set to the correct value.
    00903      * However, in a dedicated server we are a spectator, so nothing needs to
    00904      * happen. In case we are not a dedicated server, the local company always
    00905      * becomes company 0, unless we are in the scenario editor where all the
    00906      * companies are 'invalid'.
    00907      */
    00908     c = Company::GetIfValid(COMPANY_FIRST);
    00909     if (!_network_dedicated && c != NULL) {
    00910       c->settings = _settings_client.company;
    00911     }
    00912   }
    00913
    00914   if (IsSavegameVersionBefore(48)) {
    00915     for (TileIndex t = 0; t < map_size; t++) {
    00916       switch (GetTileType(t)) {
    00917         case MP_RAILWAY:
    00918           if (IsPlainRail(t)) {
    00919             /* Swap ground type and signal type for plain rail tiles, so the
    00920              * ground type uses the same bits as for depots and waypoints. */
    00921             uint tmp = GB(_m[t].m4, 0, 4);
    00922             SB(_m[t].m4, 0, 4, GB(_m[t].m2, 0, 4));
    00923             SB(_m[t].m2, 0, 4, tmp);
    00924           } else if (HasBit(_m[t].m5, 2)) {
    00925             /* Split waypoint and depot rail type and remove the subtype. */
    00926             ClrBit(_m[t].m5, 2);
    00927             ClrBit(_m[t].m5, 6);
    00928           }
    00929           break;
    00930
    00931         case MP_ROAD:
    00932           /* Swap m3 and m4, so the track type for rail crossings is the
    00933            * same as for normal rail. */
    00934           Swap(_m[t].m3, _m[t].m4);
    00935           break;
    00936
    00937         default: break;
    00938       }
    00939     }
    00940   }
    00941
    00942   if (IsSavegameVersionBefore(61)) {
    00943     /* Added the RoadType */
    00944     bool old_bridge = IsSavegameVersionBefore(42);
    00945     for (TileIndex t = 0; t < map_size; t++) {
    00946       switch (GetTileType(t)) {
    00947         case MP_ROAD:
    00948           SB(_m[t].m5, 6, 2, GB(_m[t].m5, 4, 2));
    00949           switch (GetRoadTileType(t)) {
    00950             default: SlErrorCorrupt("Invalid road tile type");
    00951             case ROAD_TILE_NORMAL:
    00952               SB(_m[t].m4, 0, 4, GB(_m[t].m5, 0, 4));
    00953               SB(_m[t].m4, 4, 4, 0);
    00954               SB(_m[t].m6, 2, 4, 0);
    00955               break;
    00956             case ROAD_TILE_CROSSING:
    00957               SB(_m[t].m4, 5, 2, GB(_m[t].m5, 2, 2));
    00958               break;
    00959             case ROAD_TILE_DEPOT:    break;
    00960           }
    00961           SetRoadTypes(t, ROADTYPES_ROAD);
    00962           break;
    00963
    00964         case MP_STATION:
    00965           if (IsRoadStop(t)) SetRoadTypes(t, ROADTYPES_ROAD);
    00966           break;
    00967
    00968         case MP_TUNNELBRIDGE:
    00969           /* Middle part of "old" bridges */
    00970           if (old_bridge && IsBridge(t) && HasBit(_m[t].m5, 6)) break;
    00971           if (((old_bridge && IsBridge(t)) ? (TransportType)GB(_m[t].m5, 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) {
    00972             SetRoadTypes(t, ROADTYPES_ROAD);
    00973           }
    00974           break;
    00975
    00976         default: break;
    00977       }
    00978     }
    00979   }
    00980
    00981   if (IsSavegameVersionBefore(114)) {
    00982     bool fix_roadtypes = !IsSavegameVersionBefore(61);
    00983     bool old_bridge = IsSavegameVersionBefore(42);
    00984
    00985     for (TileIndex t = 0; t < map_size; t++) {
    00986       switch (GetTileType(t)) {
    00987         case MP_ROAD:
    00988           if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_me[t].m7, 5, 3));
    00989           SB(_me[t].m7, 5, 1, GB(_m[t].m3, 7, 1)); // snow/desert
    00990           switch (GetRoadTileType(t)) {
    00991             default: SlErrorCorrupt("Invalid road tile type");
    00992             case ROAD_TILE_NORMAL:
    00993               SB(_me[t].m7, 0, 4, GB(_m[t].m3, 0, 4)); // road works
    00994               SB(_m[t].m6, 3, 3, GB(_m[t].m3, 4, 3));  // ground
    00995               SB(_m[t].m3, 0, 4, GB(_m[t].m4, 4, 4));  // tram bits
    00996               SB(_m[t].m3, 4, 4, GB(_m[t].m5, 0, 4));  // tram owner
    00997               SB(_m[t].m5, 0, 4, GB(_m[t].m4, 0, 4));  // road bits
    00998               break;
    00999
    01000             case ROAD_TILE_CROSSING:
    01001               SB(_me[t].m7, 0, 5, GB(_m[t].m4, 0, 5)); // road owner
    01002               SB(_m[t].m6, 3, 3, GB(_m[t].m3, 4, 3));  // ground
    01003               SB(_m[t].m3, 4, 4, GB(_m[t].m5, 0, 4));  // tram owner
    01004               SB(_m[t].m5, 0, 1, GB(_m[t].m4, 6, 1));  // road axis
    01005               SB(_m[t].m5, 5, 1, GB(_m[t].m4, 5, 1));  // crossing state
    01006               break;
    01007
    01008             case ROAD_TILE_DEPOT:
    01009               break;
    01010           }
    01011           if (!IsRoadDepot(t) && !HasTownOwnedRoad(t)) {
    01012             const Town *town = CalcClosestTownFromTile(t);
    01013             if (town != NULL) SetTownIndex(t, town->index);
    01014           }
    01015           _m[t].m4 = 0;
    01016           break;
    01017
    01018         case MP_STATION:
    01019           if (!IsRoadStop(t)) break;
    01020
    01021           if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_m[t].m3, 0, 3));
    01022           SB(_me[t].m7, 0, 5, HasBit(_m[t].m6, 2) ? OWNER_TOWN : GetTileOwner(t));
    01023           SB(_m[t].m3, 4, 4, _m[t].m1);
    01024           _m[t].m4 = 0;
    01025           break;
    01026
    01027         case MP_TUNNELBRIDGE:
    01028           if (old_bridge && IsBridge(t) && HasBit(_m[t].m5, 6)) break;
    01029           if (((old_bridge && IsBridge(t)) ? (TransportType)GB(_m[t].m5, 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) {
    01030             if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_m[t].m3, 0, 3));
    01031
    01032             Owner o = GetTileOwner(t);
    01033             SB(_me[t].m7, 0, 5, o); // road owner
    01034             SB(_m[t].m3, 4, 4, o == OWNER_NONE ? OWNER_TOWN : o); // tram owner
    01035           }
    01036           SB(_m[t].m6, 2, 4, GB(_m[t].m2, 4, 4)); // bridge type
    01037           SB(_me[t].m7, 5, 1, GB(_m[t].m4, 7, 1)); // snow/desert
    01038
    01039           _m[t].m2 = 0;
    01040           _m[t].m4 = 0;
    01041           break;
    01042
    01043         default: break;
    01044       }
    01045     }
    01046   }
    01047
    01048   if (IsSavegameVersionBefore(42)) {
    01049     Vehicle *v;
    01050
    01051     for (TileIndex t = 0; t < map_size; t++) {
    01052       if (MayHaveBridgeAbove(t)) ClearBridgeMiddle(t);
    01053       if (IsBridgeTile(t)) {
    01054         if (HasBit(_m[t].m5, 6)) { // middle part
    01055           Axis axis = (Axis)GB(_m[t].m5, 0, 1);
    01056
    01057           if (HasBit(_m[t].m5, 5)) { // transport route under bridge?
    01058             if (GB(_m[t].m5, 3, 2) == TRANSPORT_RAIL) {
    01059               MakeRailNormal(
    01060                 t,
    01061                 GetTileOwner(t),
    01062                 axis == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X,
    01063                 GetRailType(t)
    01064               );
    01065             } else {
    01066               TownID town = IsTileOwner(t, OWNER_TOWN) ? ClosestTownFromTile(t, UINT_MAX)->index : 0;
    01067
    01068               MakeRoadNormal(
    01069                 t,
    01070                 axis == AXIS_X ? ROAD_Y : ROAD_X,
    01071                 ROADTYPES_ROAD,
    01072                 town,
    01073                 GetTileOwner(t), OWNER_NONE
    01074               );
    01075             }
    01076           } else {
    01077             if (GB(_m[t].m5, 3, 2) == 0) {
    01078               MakeClear(t, CLEAR_GRASS, 3);
    01079             } else {
    01080               if (GetTileSlope(t) != SLOPE_FLAT) {
    01081                 MakeShore(t);
    01082               } else {
    01083                 if (GetTileOwner(t) == OWNER_WATER) {
    01084                   MakeSea(t);
    01085                 } else {
    01086                   MakeCanal(t, GetTileOwner(t), Random());
    01087                 }
    01088               }
    01089             }
    01090           }
    01091           SetBridgeMiddle(t, axis);
    01092         } else { // ramp
    01093           Axis axis = (Axis)GB(_m[t].m5, 0, 1);
    01094           uint north_south = GB(_m[t].m5, 5, 1);
    01095           DiagDirection dir = ReverseDiagDir(XYNSToDiagDir(axis, north_south));
    01096           TransportType type = (TransportType)GB(_m[t].m5, 1, 2);
    01097
    01098           _m[t].m5 = 1 << 7 | type << 2 | dir;
    01099         }
    01100       }
    01101     }
    01102
    01103     FOR_ALL_VEHICLES(v) {
    01104       if (!v->IsGroundVehicle()) continue;
    01105       if (IsBridgeTile(v->tile)) {
    01106         DiagDirection dir = GetTunnelBridgeDirection(v->tile);
    01107
    01108         if (dir != DirToDiagDir(v->direction)) continue;
    01109         switch (dir) {
    01110           default: SlErrorCorrupt("Invalid vehicle direction");
    01111           case DIAGDIR_NE: if ((v->x_pos & 0xF) !=  0)            continue; break;
    01112           case DIAGDIR_SE: if ((v->y_pos & 0xF) != TILE_SIZE - 1) continue; break;
    01113           case DIAGDIR_SW: if ((v->x_pos & 0xF) != TILE_SIZE - 1) continue; break;
    01114           case DIAGDIR_NW: if ((v->y_pos & 0xF) !=  0)            continue; break;
    01115         }
    01116       } else if (v->z_pos > GetSlopePixelZ(v->x_pos, v->y_pos)) {
    01117         v->tile = GetNorthernBridgeEnd(v->tile);
    01118       } else {
    01119         continue;
    01120       }
    01121       if (v->type == VEH_TRAIN) {
    01122         Train::From(v)->track = TRACK_BIT_WORMHOLE;
    01123       } else {
    01124         RoadVehicle::From(v)->state = RVSB_WORMHOLE;
    01125       }
    01126     }
    01127   }
    01128
    01129   /* Elrails got added in rev 24 */
    01130   if (IsSavegameVersionBefore(24)) {
    01131     RailType min_rail = RAILTYPE_ELECTRIC;
    01132
    01133     Train *v;
    01134     FOR_ALL_TRAINS(v) {
    01135       RailType rt = RailVehInfo(v->engine_type)->railtype;
    01136
    01137       v->railtype = rt;
    01138       if (rt == RAILTYPE_ELECTRIC) min_rail = RAILTYPE_RAIL;
    01139     }
    01140
    01141     /* .. so we convert the entire map from normal to elrail (so maintain "fairness") */
    01142     for (TileIndex t = 0; t < map_size; t++) {
    01143       switch (GetTileType(t)) {
    01144         case MP_RAILWAY:
    01145           SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
    01146           break;
    01147
    01148         case MP_ROAD:
    01149           if (IsLevelCrossing(t)) {
    01150             SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
    01151           }
    01152           break;
    01153
    01154         case MP_STATION:
    01155           if (HasStationRail(t)) {
    01156             SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
    01157           }
    01158           break;
    01159
    01160         case MP_TUNNELBRIDGE:
    01161           if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) {
    01162             SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
    01163           }
    01164           break;
    01165
    01166         default:
    01167           break;
    01168       }
    01169     }
    01170
    01171     FOR_ALL_TRAINS(v) {
    01172       if (v->IsFrontEngine() || v->IsFreeWagon()) v->ConsistChanged(true);
    01173     }
    01174
    01175   }
    01176
    01177   /* In version 16.1 of the savegame a company can decide if trains, which get
    01178    * replaced, shall keep their old length. In all prior versions, just default
    01179    * to false */
    01180   if (IsSavegameVersionBefore(16, 1)) {
    01181     Company *c;
    01182     FOR_ALL_COMPANIES(c) c->settings.renew_keep_length = false;
    01183   }
    01184
    01185   if (IsSavegameVersionBefore(123)) {
    01186     /* Waypoints became subclasses of stations ... */
    01187     MoveWaypointsToBaseStations();
    01188     /* ... and buoys were moved to waypoints. */
    01189     MoveBuoysToWaypoints();
    01190   }
    01191
    01192   /* From version 15, we moved a semaphore bit from bit 2 to bit 3 in m4, making
    01193    *  room for PBS. Now in version 21 move it back :P. */
    01194   if (IsSavegameVersionBefore(21) && !IsSavegameVersionBefore(15)) {
    01195     for (TileIndex t = 0; t < map_size; t++) {
    01196       switch (GetTileType(t)) {
    01197         case MP_RAILWAY:
    01198           if (HasSignals(t)) {
    01199             /* convert PBS signals to combo-signals */
    01200             if (HasBit(_m[t].m2, 2)) SetSignalType(t, TRACK_X, SIGTYPE_COMBO);
    01201
    01202             /* move the signal variant back */
    01203             SetSignalVariant(t, TRACK_X, HasBit(_m[t].m2, 3) ? SIG_SEMAPHORE : SIG_ELECTRIC);
    01204             ClrBit(_m[t].m2, 3);
    01205           }
    01206
    01207           /* Clear PBS reservation on track */
    01208           if (!IsRailDepotTile(t)) {
    01209             SB(_m[t].m4, 4, 4, 0);
    01210           } else {
    01211             ClrBit(_m[t].m3, 6);
    01212           }
    01213           break;
    01214
    01215         case MP_STATION: // Clear PBS reservation on station
    01216           ClrBit(_m[t].m3, 6);
    01217           break;
    01218
    01219         default: break;
    01220       }
    01221     }
    01222   }
    01223
    01224   if (IsSavegameVersionBefore(25)) {
    01225     RoadVehicle *rv;
    01226     FOR_ALL_ROADVEHICLES(rv) {
    01227       rv->vehstatus &= ~0x40;
    01228     }
    01229   }
    01230
    01231   if (IsSavegameVersionBefore(26)) {
    01232     Station *st;
    01233     FOR_ALL_STATIONS(st) {
    01234       st->last_vehicle_type = VEH_INVALID;
    01235     }
    01236   }
    01237
    01238   YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK);
    01239
    01240   if (IsSavegameVersionBefore(34)) {
    01241     Company *c;
    01242     FOR_ALL_COMPANIES(c) ResetCompanyLivery(c);
    01243   }
    01244
    01245   Company *c;
    01246   FOR_ALL_COMPANIES(c) {
    01247     c->avail_railtypes = GetCompanyRailtypes(c->index);
    01248     c->avail_roadtypes = GetCompanyRoadtypes(c->index);
    01249   }
    01250
    01251   if (!IsSavegameVersionBefore(27)) AfterLoadStations();
    01252
    01253   /* Time starts at 0 instead of 1920.
    01254    * Account for this in older games by adding an offset */
    01255   if (IsSavegameVersionBefore(31)) {
    01256     Station *st;
    01257     Waypoint *wp;
    01258     Engine *e;
    01259     Industry *i;
    01260     Vehicle *v;
    01261
    01262     _date += DAYS_TILL_ORIGINAL_BASE_YEAR;
    01263     _cur_year += ORIGINAL_BASE_YEAR;
    01264
    01265     FOR_ALL_STATIONS(st)  st->build_date      += DAYS_TILL_ORIGINAL_BASE_YEAR;
    01266     FOR_ALL_WAYPOINTS(wp) wp->build_date      += DAYS_TILL_ORIGINAL_BASE_YEAR;
    01267     FOR_ALL_ENGINES(e)    e->intro_date       += DAYS_TILL_ORIGINAL_BASE_YEAR;
    01268     FOR_ALL_COMPANIES(c)  c->inaugurated_year += ORIGINAL_BASE_YEAR;
    01269     FOR_ALL_INDUSTRIES(i) i->last_prod_year   += ORIGINAL_BASE_YEAR;
    01270
    01271     FOR_ALL_VEHICLES(v) {
    01272       v->date_of_last_service += DAYS_TILL_ORIGINAL_BASE_YEAR;
    01273       v->build_year += ORIGINAL_BASE_YEAR;
    01274     }
    01275   }
    01276
    01277   /* From 32 on we save the industry who made the farmland.
    01278    *  To give this prettyness to old savegames, we remove all farmfields and
    01279    *  plant new ones. */
    01280   if (IsSavegameVersionBefore(32)) {
    01281     Industry *i;
    01282
    01283     for (TileIndex t = 0; t < map_size; t++) {
    01284       if (IsTileType(t, MP_CLEAR) && IsClearGround(t, CLEAR_FIELDS)) {
    01285         /* remove fields */
    01286         MakeClear(t, CLEAR_GRASS, 3);
    01287       }
    01288     }
    01289
    01290     FOR_ALL_INDUSTRIES(i) {
    01291       uint j;
    01292
    01293       if (GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_PLANT_ON_BUILT) {
    01294         for (j = 0; j != 50; j++) PlantRandomFarmField(i);
    01295       }
    01296     }
    01297   }
    01298
    01299   /* Setting no refit flags to all orders in savegames from before refit in orders were added */
    01300   if (IsSavegameVersionBefore(36)) {
    01301     Order *order;
    01302     Vehicle *v;
    01303
    01304     FOR_ALL_ORDERS(order) {
    01305       order->SetRefit(CT_NO_REFIT);
    01306     }
    01307
    01308     FOR_ALL_VEHICLES(v) {
    01309       v->current_order.SetRefit(CT_NO_REFIT);
    01310     }
    01311   }
    01312
    01313   /* from version 38 we have optional elrails, since we cannot know the
    01314    * preference of a user, let elrails enabled; it can be disabled manually */
    01315   if (IsSavegameVersionBefore(38)) _settings_game.vehicle.disable_elrails = false;
    01316   /* do the same as when elrails were enabled/disabled manually just now */
    01317   SettingsDisableElrail(_settings_game.vehicle.disable_elrails);
    01318   InitializeRailGUI();
    01319
    01320   /* From version 53, the map array was changed for house tiles to allow
    01321    * space for newhouses grf features. A new byte, m7, was also added. */
    01322   if (IsSavegameVersionBefore(53)) {
    01323     for (TileIndex t = 0; t < map_size; t++) {
    01324       if (IsTileType(t, MP_HOUSE)) {
    01325         if (GB(_m[t].m3, 6, 2) != TOWN_HOUSE_COMPLETED) {
    01326           /* Move the construction stage from m3[7..6] to m5[5..4].
    01327            * The construction counter does not have to move. */
    01328           SB(_m[t].m5, 3, 2, GB(_m[t].m3, 6, 2));
    01329           SB(_m[t].m3, 6, 2, 0);
    01330
    01331           /* The "house is completed" bit is now in m6[2]. */
    01332           SetHouseCompleted(t, false);
    01333         } else {
    01334           /* The "lift has destination" bit has been moved from
    01335            * m5[7] to m7[0]. */
    01336           SB(_me[t].m7, 0, 1, HasBit(_m[t].m5, 7));
    01337           ClrBit(_m[t].m5, 7);
    01338
    01339           /* The "lift is moving" bit has been removed, as it does
    01340            * the same job as the "lift has destination" bit. */
    01341           ClrBit(_m[t].m1, 7);
    01342
    01343           /* The position of the lift goes from m1[7..0] to m6[7..2],
    01344            * making m1 totally free, now. The lift position does not
    01345            * have to be a full byte since the maximum value is 36. */
    01346           SetLiftPosition(t, GB(_m[t].m1, 0, 6 ));
    01347
    01348           _m[t].m1 = 0;
    01349           _m[t].m3 = 0;
    01350           SetHouseCompleted(t, true);
    01351         }
    01352       }
    01353     }
    01354   }
    01355
    01356   /* Check and update house and town values */
    01357   UpdateHousesAndTowns();
    01358
    01359   if (IsSavegameVersionBefore(43)) {
    01360     for (TileIndex t = 0; t < map_size; t++) {
    01361       if (IsTileType(t, MP_INDUSTRY)) {
    01362         switch (GetIndustryGfx(t)) {
    01363           case GFX_POWERPLANT_SPARKS:
    01364             _m[t].m3 = GB(_m[t].m1, 2, 5);
    01365             break;
    01366
    01367           case GFX_OILWELL_ANIMATED_1:
    01368           case GFX_OILWELL_ANIMATED_2:
    01369           case GFX_OILWELL_ANIMATED_3:
    01370             _m[t].m3 = GB(_m[t].m1, 0, 2);
    01371             break;
    01372
    01373           case GFX_COAL_MINE_TOWER_ANIMATED:
    01374           case GFX_COPPER_MINE_TOWER_ANIMATED:
    01375           case GFX_GOLD_MINE_TOWER_ANIMATED:
    01376              _m[t].m3 = _m[t].m1;
    01377              break;
    01378
    01379           default: // No animation states to change
    01380             break;
    01381         }
    01382       }
    01383     }
    01384   }
    01385
    01386   if (IsSavegameVersionBefore(45)) {
    01387     Vehicle *v;
    01388     /* Originally just the fact that some cargo had been paid for was
    01389      * stored to stop people cheating and cashing in several times. This
    01390      * wasn't enough though as it was cleared when the vehicle started
    01391      * loading again, even if it didn't actually load anything, so now the
    01392      * amount that has been paid is stored. */
    01393     FOR_ALL_VEHICLES(v) {
    01394       ClrBit(v->vehicle_flags, 2);
    01395     }
    01396   }
    01397
    01398   /* Buoys do now store the owner of the previous water tile, which can never
    01399    * be OWNER_NONE. So replace OWNER_NONE with OWNER_WATER. */
    01400   if (IsSavegameVersionBefore(46)) {
    01401     Waypoint *wp;
    01402     FOR_ALL_WAYPOINTS(wp) {
    01403       if ((wp->facilities & FACIL_DOCK) != 0 && IsTileOwner(wp->xy, OWNER_NONE) && TileHeight(wp->xy) == 0) SetTileOwner(wp->xy, OWNER_WATER);
    01404     }
    01405   }
    01406
    01407   if (IsSavegameVersionBefore(50)) {
    01408     Aircraft *v;
    01409     /* Aircraft units changed from 8 mph to 1 km-ish/h */
    01410     FOR_ALL_AIRCRAFT(v) {
    01411       if (v->subtype <= AIR_AIRCRAFT) {
    01412         const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);
    01413         v->cur_speed *= 128;
    01414         v->cur_speed /= 10;
    01415         v->acceleration = avi->acceleration;
    01416       }
    01417     }
    01418   }
    01419
    01420   if (IsSavegameVersionBefore(49)) FOR_ALL_COMPANIES(c) c->face = ConvertFromOldCompanyManagerFace(c->face);
    01421
    01422   if (IsSavegameVersionBefore(52)) {
    01423     for (TileIndex t = 0; t < map_size; t++) {
    01424       if (IsStatueTile(t)) {
    01425         _m[t].m2 = CalcClosestTownFromTile(t)->index;
    01426       }
    01427     }
    01428   }
    01429
    01430   /* A setting containing the proportion of towns that grow twice as
    01431    * fast was added in version 54. From version 56 this is now saved in the
    01432    * town as cities can be built specifically in the scenario editor. */
    01433   if (IsSavegameVersionBefore(56)) {
    01434     Town *t;
    01435
    01436     FOR_ALL_TOWNS(t) {
    01437       if (_settings_game.economy.larger_towns != 0 && (t->index % _settings_game.economy.larger_towns) == 0) {
    01438         t->larger_town = true;
    01439       }
    01440     }
    01441   }
    01442
    01443   if (IsSavegameVersionBefore(57)) {
    01444     Vehicle *v;
    01445     /* Added a FIFO queue of vehicles loading at stations */
    01446     FOR_ALL_VEHICLES(v) {
    01447       if ((v->type != VEH_TRAIN || Train::From(v)->IsFrontEngine()) &&  // for all locs
    01448           !(v->vehstatus & (VS_STOPPED | VS_CRASHED)) && // not stopped or crashed
    01449           v->current_order.IsType(OT_LOADING)) {         // loading
    01450         Station::Get(v->last_station_visited)->loading_vehicles.push_back(v);
    01451
    01452         /* The loading finished flag is *only* set when actually completely
    01453          * finished. Because the vehicle is loading, it is not finished. */
    01454         ClrBit(v->vehicle_flags, VF_LOADING_FINISHED);
    01455       }
    01456     }
    01457   } else if (IsSavegameVersionBefore(59)) {
    01458     /* For some reason non-loading vehicles could be in the station's loading vehicle list */
    01459
    01460     Station *st;
    01461     FOR_ALL_STATIONS(st) {
    01462       std::list<Vehicle *>::iterator iter;
    01463       for (iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end();) {
    01464         Vehicle *v = *iter;
    01465         iter++;
    01466         if (!v->current_order.IsType(OT_LOADING)) st->loading_vehicles.remove(v);
    01467       }
    01468     }
    01469   }
    01470
    01471   if (IsSavegameVersionBefore(58)) {
    01472     /* Setting difficulty industry_density other than zero get bumped to +1
    01473      * since a new option (very low at position 1) has been added */
    01474     if (_settings_game.difficulty.industry_density > 0) {
    01475       _settings_game.difficulty.industry_density++;
    01476     }
    01477
    01478     /* Same goes for number of towns, although no test is needed, just an increment */
    01479     _settings_game.difficulty.number_towns++;
    01480   }
    01481
    01482   if (IsSavegameVersionBefore(64)) {
    01483     /* copy the signal type/variant and move signal states bits */
    01484     for (TileIndex t = 0; t < map_size; t++) {
    01485       if (IsTileType(t, MP_RAILWAY) && HasSignals(t)) {
    01486         SetSignalStates(t, GB(_m[t].m2, 4, 4));
    01487         SetSignalVariant(t, INVALID_TRACK, GetSignalVariant(t, TRACK_X));
    01488         SetSignalType(t, INVALID_TRACK, GetSignalType(t, TRACK_X));
    01489         ClrBit(_m[t].m2, 7);
    01490       }
    01491     }
    01492   }
    01493
    01494   if (IsSavegameVersionBefore(69)) {
    01495     /* In some old savegames a bit was cleared when it should not be cleared */
    01496     RoadVehicle *rv;
    01497     FOR_ALL_ROADVEHICLES(rv) {
    01498       if (rv->state == 250 || rv->state == 251) {
    01499         SetBit(rv->state, 2);
    01500       }
    01501     }
    01502   }
    01503
    01504   if (IsSavegameVersionBefore(70)) {
    01505     /* Added variables to support newindustries */
    01506     Industry *i;
    01507     FOR_ALL_INDUSTRIES(i) i->founder = OWNER_NONE;
    01508   }
    01509
    01510   /* From version 82, old style canals (above sealevel (0), WATER owner) are no longer supported.
    01511       Replace the owner for those by OWNER_NONE. */
    01512   if (IsSavegameVersionBefore(82)) {
    01513     for (TileIndex t = 0; t < map_size; t++) {
    01514       if (IsTileType(t, MP_WATER) &&
    01515           GetWaterTileType(t) == WATER_TILE_CLEAR &&
    01516           GetTileOwner(t) == OWNER_WATER &&
    01517           TileHeight(t) != 0) {
    01518         SetTileOwner(t, OWNER_NONE);
    01519       }
    01520     }
    01521   }
    01522
    01523   /*
    01524    * Add the 'previous' owner to the ship depots so we can reset it with
    01525    * the correct values when it gets destroyed. This prevents that
    01526    * someone can remove canals owned by somebody else and it prevents
    01527    * making floods using the removal of ship depots.
    01528    */
    01529   if (IsSavegameVersionBefore(83)) {
    01530     for (TileIndex t = 0; t < map_size; t++) {
    01531       if (IsShipDepotTile(t)) {
    01532         _m[t].m4 = (TileHeight(t) == 0) ? OWNER_WATER : OWNER_NONE;
    01533       }
    01534     }
    01535   }
    01536
    01537   if (IsSavegameVersionBefore(74)) {
    01538     Station *st;
    01539     FOR_ALL_STATIONS(st) {
    01540       for (CargoID c = 0; c < NUM_CARGO; c++) {
    01541         st->goods[c].last_speed = 0;
    01542         if (st->goods[c].cargo.Count() != 0) SetBit(st->goods[c].acceptance_pickup, GoodsEntry::GES_PICKUP);
    01543       }
    01544     }
    01545   }
    01546
    01547   if (IsSavegameVersionBefore(78)) {
    01548     Industry *i;
    01549     uint j;
    01550     FOR_ALL_INDUSTRIES(i) {
    01551       const IndustrySpec *indsp = GetIndustrySpec(i->type);
    01552       for (j = 0; j < lengthof(i->produced_cargo); j++) {
    01553         i->produced_cargo[j] = indsp->produced_cargo[j];
    01554       }
    01555       for (j = 0; j < lengthof(i->accepts_cargo); j++) {
    01556         i->accepts_cargo[j] = indsp->accepts_cargo[j];
    01557       }
    01558     }
    01559   }
    01560
    01561   /* Before version 81, the density of grass was always stored as zero, and
    01562    * grassy trees were always drawn fully grassy. Furthermore, trees on rough
    01563    * land used to have zero density, now they have full density. Therefore,
    01564    * make all grassy/rough land trees have a density of 3. */
    01565   if (IsSavegameVersionBefore(81)) {
    01566     for (TileIndex t = 0; t < map_size; t++) {
    01567       if (GetTileType(t) == MP_TREES) {
    01568         TreeGround groundType = (TreeGround)GB(_m[t].m2, 4, 2);
    01569         if (groundType != TREE_GROUND_SNOW_DESERT) SB(_m[t].m2, 6, 2, 3);
    01570       }
    01571     }
    01572   }
    01573
    01574
    01575   if (IsSavegameVersionBefore(93)) {
    01576     /* Rework of orders. */
    01577     Order *order;
    01578     FOR_ALL_ORDERS(order) order->ConvertFromOldSavegame();
    01579
    01580     Vehicle *v;
    01581     FOR_ALL_VEHICLES(v) {
    01582       if (v->orders.list != NULL && v->orders.list->GetFirstOrder() != NULL && v->orders.list->GetFirstOrder()->IsType(OT_NOTHING)) {
    01583         v->orders.list->FreeChain();
    01584         v->orders.list = NULL;
    01585       }
    01586
    01587       v->current_order.ConvertFromOldSavegame();
    01588       if (v->type == VEH_ROAD && v->IsPrimaryVehicle() && v->FirstShared() == v) {
    01589         FOR_VEHICLE_ORDERS(v, order) order->SetNonStopType(ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS);
    01590       }
    01591     }
    01592   } else if (IsSavegameVersionBefore(94)) {
    01593     /* Unload and transfer are now mutual exclusive. */
    01594     Order *order;
    01595     FOR_ALL_ORDERS(order) {
    01596       if ((order->GetUnloadType() & (OUFB_UNLOAD | OUFB_TRANSFER)) == (OUFB_UNLOAD | OUFB_TRANSFER)) {
    01597         order->SetUnloadType(OUFB_TRANSFER);
    01598         order->SetLoadType(OLFB_NO_LOAD);
    01599       }
    01600     }
    01601
    01602     Vehicle *v;
    01603     FOR_ALL_VEHICLES(v) {
    01604       if ((v->current_order.GetUnloadType() & (OUFB_UNLOAD | OUFB_TRANSFER)) == (OUFB_UNLOAD | OUFB_TRANSFER)) {
    01605         v->current_order.SetUnloadType(OUFB_TRANSFER);
    01606         v->current_order.SetLoadType(OLFB_NO_LOAD);
    01607       }
    01608     }
    01609   }
    01610
    01611   if (IsSavegameVersionBefore(84)) {
    01612     /* Set all share owners to INVALID_COMPANY for
    01613      * 1) all inactive companies
    01614      *     (when inactive companies were stored in the savegame - TTD, TTDP and some
    01615      *      *really* old revisions of OTTD; else it is already set in InitializeCompanies())
    01616      * 2) shares that are owned by inactive companies or self
    01617      *     (caused by cheating clients in earlier revisions) */
    01618     FOR_ALL_COMPANIES(c) {
    01619       for (uint i = 0; i < 4; i++) {
    01620         CompanyID company = c->share_owners[i];
    01621         if (company == INVALID_COMPANY) continue;
    01622         if (!Company::IsValidID(company) || company == c->index) c->share_owners[i] = INVALID_COMPANY;
    01623       }
    01624     }
    01625   }
    01626
    01627   /* The water class was moved/unified. */
    01628   if (IsSavegameVersionBefore(146)) {
    01629     for (TileIndex t = 0; t < map_size; t++) {
    01630       switch (GetTileType(t)) {
    01631         case MP_STATION:
    01632           switch (GetStationType(t)) {
    01633             case STATION_OILRIG:
    01634             case STATION_DOCK:
    01635             case STATION_BUOY:
    01636               SetWaterClass(t, (WaterClass)GB(_m[t].m3, 0, 2));
    01637               SB(_m[t].m3, 0, 2, 0);
    01638               break;
    01639
    01640             default:
    01641               SetWaterClass(t, WATER_CLASS_INVALID);
    01642               break;
    01643           }
    01644           break;
    01645
    01646         case MP_WATER:
    01647           SetWaterClass(t, (WaterClass)GB(_m[t].m3, 0, 2));
    01648           SB(_m[t].m3, 0, 2, 0);
    01649           break;
    01650
    01651         case MP_OBJECT:
    01652           SetWaterClass(t, WATER_CLASS_INVALID);
    01653           break;
    01654
    01655         default:
    01656           /* No water class. */
    01657           break;
    01658       }
    01659     }
    01660   }
    01661
    01662   if (IsSavegameVersionBefore(86)) {
    01663     for (TileIndex t = 0; t < map_size; t++) {
    01664       /* Move river flag and update canals to use water class */
    01665       if (IsTileType(t, MP_WATER)) {
    01666         if (GetWaterClass(t) != WATER_CLASS_RIVER) {
    01667           if (IsWater(t)) {
    01668             Owner o = GetTileOwner(t);
    01669             if (o == OWNER_WATER) {
    01670               MakeSea(t);
    01671             } else {
    01672               MakeCanal(t, o, Random());
    01673             }
    01674           } else if (IsShipDepot(t)) {
    01675             Owner o = (Owner)_m[t].m4; // Original water owner
    01676             SetWaterClass(t, o == OWNER_WATER ? WATER_CLASS_SEA : WATER_CLASS_CANAL);
    01677           }
    01678         }
    01679       }
    01680     }
    01681
    01682     /* Update locks, depots, docks and buoys to have a water class based
    01683      * on its neighbouring tiles. Done after river and canal updates to
    01684      * ensure neighbours are correct. */
    01685     for (TileIndex t = 0; t < map_size; t++) {
    01686       if (GetTileSlope(t) != SLOPE_FLAT) continue;
    01687
    01688       if (IsTileType(t, MP_WATER) && IsLock(t)) SetWaterClassDependingOnSurroundings(t, false);
    01689       if (IsTileType(t, MP_STATION) && (IsDock(t) || IsBuoy(t))) SetWaterClassDependingOnSurroundings(t, false);
    01690     }
    01691   }
    01692
    01693   if (IsSavegameVersionBefore(87)) {
    01694     for (TileIndex t = 0; t < map_size; t++) {
    01695       /* skip oil rigs at borders! */
    01696       if ((IsTileType(t, MP_WATER) || IsBuoyTile(t)) &&
    01697           (TileX(t) == 0 || TileY(t) == 0 || TileX(t) == MapMaxX() - 1 || TileY(t) == MapMaxY() - 1)) {
    01698         /* Some version 86 savegames have wrong water class at map borders (under buoy, or after removing buoy).
    01699          * This conversion has to be done before buoys with invalid owner are removed. */
    01700         SetWaterClass(t, WATER_CLASS_SEA);
    01701       }
    01702
    01703       if (IsBuoyTile(t) || IsDriveThroughStopTile(t) || IsTileType(t, MP_WATER)) {
    01704         Owner o = GetTileOwner(t);
    01705         if (o < MAX_COMPANIES && !Company::IsValidID(o)) {
    01706           Backup<CompanyByte> cur_company(_current_company, o, FILE_LINE);
    01707           ChangeTileOwner(t, o, INVALID_OWNER);
    01708           cur_company.Restore();
    01709         }
    01710         if (IsBuoyTile(t)) {
    01711           /* reset buoy owner to OWNER_NONE in the station struct
    01712            * (even if it is owned by active company) */
    01713           Waypoint::GetByTile(t)->owner = OWNER_NONE;
    01714         }
    01715       } else if (IsTileType(t, MP_ROAD)) {
    01716         /* works for all RoadTileType */
    01717         for (RoadType rt = ROADTYPE_ROAD; rt < ROADTYPE_END; rt++) {
    01718           /* update even non-existing road types to update tile owner too */
    01719           Owner o = GetRoadOwner(t, rt);
    01720           if (o < MAX_COMPANIES && !Company::IsValidID(o)) SetRoadOwner(t, rt, OWNER_NONE);
    01721         }
    01722         if (IsLevelCrossing(t)) {
    01723           if (!Company::IsValidID(GetTileOwner(t))) FixOwnerOfRailTrack(t);
    01724         }
    01725       } else if (IsPlainRailTile(t)) {
    01726         if (!Company::IsValidID(GetTileOwner(t))) FixOwnerOfRailTrack(t);
    01727       }
    01728     }
    01729
    01730     /* Convert old PF settings to new */
    01731     if (_settings_game.pf.yapf.rail_use_yapf || IsSavegameVersionBefore(28)) {
    01732       _settings_game.pf.pathfinder_for_trains = VPF_YAPF;
    01733     } else {
    01734       _settings_game.pf.pathfinder_for_trains = VPF_NPF;
    01735     }
    01736
    01737     if (_settings_game.pf.yapf.road_use_yapf || IsSavegameVersionBefore(28)) {
    01738       _settings_game.pf.pathfinder_for_roadvehs = VPF_YAPF;
    01739     } else {
    01740       _settings_game.pf.pathfinder_for_roadvehs = VPF_NPF;
    01741     }
    01742
    01743     if (_settings_game.pf.yapf.ship_use_yapf) {
    01744       _settings_game.pf.pathfinder_for_ships = VPF_YAPF;
    01745     } else {
    01746       _settings_game.pf.pathfinder_for_ships = (_settings_game.pf.new_pathfinding_all ? VPF_NPF : VPF_OPF);
    01747     }
    01748   }
    01749
    01750   if (IsSavegameVersionBefore(88)) {
    01751     /* Profits are now with 8 bit fract */
    01752     Vehicle *v;
    01753     FOR_ALL_VEHICLES(v) {
    01754       v->profit_this_year <<= 8;
    01755       v->profit_last_year <<= 8;
    01756       v->running_ticks = 0;
    01757     }
    01758   }
    01759
    01760   if (IsSavegameVersionBefore(91)) {
    01761     /* Increase HouseAnimationFrame from 5 to 7 bits */
    01762     for (TileIndex t = 0; t < map_size; t++) {
    01763       if (IsTileType(t, MP_HOUSE) && GetHouseType(t) >= NEW_HOUSE_OFFSET) {
    01764         SB(_m[t].m6, 2, 6, GB(_m[t].m6, 3, 5));
    01765         SB(_m[t].m3, 5, 1, 0);
    01766       }
    01767     }
    01768   }
    01769
    01770   if (IsSavegameVersionBefore(62)) {
    01771     /* Remove all trams from savegames without tram support.
    01772      * There would be trams without tram track under causing crashes sooner or later. */
    01773     RoadVehicle *v;
    01774     FOR_ALL_ROADVEHICLES(v) {
    01775       if (v->First() == v && HasBit(EngInfo(v->engine_type)->misc_flags, EF_ROAD_TRAM)) {
    01776         ShowErrorMessage(STR_WARNING_LOADGAME_REMOVED_TRAMS, INVALID_STRING_ID, WL_CRITICAL);
    01777         delete v;
    01778       }
    01779     }
    01780   }
    01781
    01782   if (IsSavegameVersionBefore(99)) {
    01783     for (TileIndex t = 0; t < map_size; t++) {
    01784       /* Set newly introduced WaterClass of industry tiles */
    01785       if (IsTileType(t, MP_STATION) && IsOilRig(t)) {
    01786         SetWaterClassDependingOnSurroundings(t, true);
    01787       }
    01788       if (IsTileType(t, MP_INDUSTRY)) {
    01789         if ((GetIndustrySpec(GetIndustryType(t))->behaviour & INDUSTRYBEH_BUILT_ONWATER) != 0) {
    01790           SetWaterClassDependingOnSurroundings(t, true);
    01791         } else {
    01792           SetWaterClass(t, WATER_CLASS_INVALID);
    01793         }
    01794       }
    01795
    01796       /* Replace "house construction year" with "house age" */
    01797       if (IsTileType(t, MP_HOUSE) && IsHouseCompleted(t)) {
    01798         _m[t].m5 = Clamp(_cur_year - (_m[t].m5 + ORIGINAL_BASE_YEAR), 0, 0xFF);
    01799       }
    01800     }
    01801   }
    01802
    01803   /* Move the signal variant back up one bit for PBS. We don't convert the old PBS
    01804    * format here, as an old layout wouldn't work properly anyway. To be safe, we
    01805    * clear any possible PBS reservations as well. */
    01806   if (IsSavegameVersionBefore(100)) {
    01807     for (TileIndex t = 0; t < map_size; t++) {
    01808       switch (GetTileType(t)) {
    01809         case MP_RAILWAY:
    01810           if (HasSignals(t)) {
    01811             /* move the signal variant */
    01812             SetSignalVariant(t, TRACK_UPPER, HasBit(_m[t].m2, 2) ? SIG_SEMAPHORE : SIG_ELECTRIC);
    01813             SetSignalVariant(t, TRACK_LOWER, HasBit(_m[t].m2, 6) ? SIG_SEMAPHORE : SIG_ELECTRIC);
    01814             ClrBit(_m[t].m2, 2);
    01815             ClrBit(_m[t].m2, 6);
    01816           }
    01817
    01818           /* Clear PBS reservation on track */
    01819           if (IsRailDepot(t)) {
    01820             SetDepotReservation(t, false);
    01821           } else {
    01822             SetTrackReservation(t, TRACK_BIT_NONE);
    01823           }
    01824           break;
    01825
    01826         case MP_ROAD: // Clear PBS reservation on crossing
    01827           if (IsLevelCrossing(t)) SetCrossingReservation(t, false);
    01828           break;
    01829
    01830         case MP_STATION: // Clear PBS reservation on station
    01831           if (HasStationRail(t)) SetRailStationReservation(t, false);
    01832           break;
    01833
    01834         case MP_TUNNELBRIDGE: // Clear PBS reservation on tunnels/birdges
    01835           if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) SetTunnelBridgeReservation(t, false);
    01836           break;
    01837
    01838         default: break;
    01839       }
    01840     }
    01841   }
    01842
    01843   /* Reserve all tracks trains are currently on. */
    01844   if (IsSavegameVersionBefore(101)) {
    01845     const Train *t;
    01846     FOR_ALL_TRAINS(t) {
    01847       if (t->First() == t) t->ReserveTrackUnderConsist();
    01848     }
    01849   }
    01850
    01851   if (IsSavegameVersionBefore(102)) {
    01852     for (TileIndex t = 0; t < map_size; t++) {
    01853       /* Now all crossings should be in correct state */
    01854       if (IsLevelCrossingTile(t)) UpdateLevelCrossing(t, false);
    01855     }
    01856   }
    01857
    01858   if (IsSavegameVersionBefore(103)) {
    01859     /* Non-town-owned roads now store the closest town */
    01860     UpdateNearestTownForRoadTiles(false);
    01861
    01862     /* signs with invalid owner left from older savegames */
    01863     Sign *si;
    01864     FOR_ALL_SIGNS(si) {
    01865       if (si->owner != OWNER_NONE && !Company::IsValidID(si->owner)) si->owner = OWNER_NONE;
    01866     }
    01867
    01868     /* Station can get named based on an industry type, but the current ones
    01869      * are not, so mark them as if they are not named by an industry. */
    01870     Station *st;
    01871     FOR_ALL_STATIONS(st) {
    01872       st->indtype = IT_INVALID;
    01873     }
    01874   }
    01875
    01876   if (IsSavegameVersionBefore(104)) {
    01877     Aircraft *a;
    01878     FOR_ALL_AIRCRAFT(a) {
    01879       /* Set engine_type of shadow and rotor */
    01880       if (!a->IsNormalAircraft()) {
    01881         a->engine_type = a->First()->engine_type;
    01882       }
    01883     }
    01884
    01885     /* More companies ... */
    01886     Company *c;
    01887     FOR_ALL_COMPANIES(c) {
    01888       if (c->bankrupt_asked == 0xFF) c->bankrupt_asked = 0xFFFF;
    01889     }
    01890
    01891     Engine *e;
    01892     FOR_ALL_ENGINES(e) {
    01893       if (e->company_avail == 0xFF) e->company_avail = 0xFFFF;
    01894     }
    01895
    01896     Town *t;
    01897     FOR_ALL_TOWNS(t) {
    01898       if (t->have_ratings == 0xFF) t->have_ratings = 0xFFFF;
    01899       for (uint i = 8; i != MAX_COMPANIES; i++) t->ratings[i] = RATING_INITIAL;
    01900     }
    01901   }
    01902
    01903   if (IsSavegameVersionBefore(112)) {
    01904     for (TileIndex t = 0; t < map_size; t++) {
    01905       /* Check for HQ bit being set, instead of using map accessor,
    01906        * since we've already changed it code-wise */
    01907       if (IsTileType(t, MP_OBJECT) && HasBit(_m[t].m5, 7)) {
    01908         /* Move size and part identification of HQ out of the m5 attribute,
    01909          * on new locations */
    01910         _m[t].m3 = GB(_m[t].m5, 0, 5);
    01911         _m[t].m5 = OBJECT_HQ;
    01912       }
    01913     }
    01914   }
    01915   if (IsSavegameVersionBefore(144)) {
    01916     for (TileIndex t = 0; t < map_size; t++) {
    01917       if (!IsTileType(t, MP_OBJECT)) continue;
    01918
    01919       /* Reordering/generalisation of the object bits. */
    01920       ObjectType type = GetObjectType(t);
    01921       SB(_m[t].m6, 2, 4, type == OBJECT_HQ ? GB(_m[t].m3, 2, 3) : 0);
    01922       _m[t].m3 = type == OBJECT_HQ ? GB(_m[t].m3, 1, 1) | GB(_m[t].m3, 0, 1) << 4 : 0;
    01923
    01924       /* Make sure those bits are clear as well! */
    01925       _m[t].m4 = 0;
    01926       _me[t].m7 = 0;
    01927     }
    01928   }
    01929
    01930   if (IsSavegameVersionBefore(147) && Object::GetNumItems() == 0) {
    01931     /* Make real objects for object tiles. */
    01932     for (TileIndex t = 0; t < map_size; t++) {
    01933       if (!IsTileType(t, MP_OBJECT)) continue;
    01934
    01935       if (Town::GetNumItems() == 0) {
    01936         /* No towns, so remove all objects! */
    01937         DoClearSquare(t);
    01938       } else {
    01939         uint offset = _m[t].m3;
    01940
    01941         /* Also move the animation state. */
    01942         _m[t].m3 = GB(_m[t].m6, 2, 4);
    01943         SB(_m[t].m6, 2, 4, 0);
    01944
    01945         if (offset == 0) {
    01946           /* No offset, so make the object. */
    01947           ObjectType type = GetObjectType(t);
    01948           int size = type == OBJECT_HQ ? 2 : 1;
    01949
    01950           if (!Object::CanAllocateItem()) {
    01951             /* Nice... you managed to place 64k lighthouses and
    01952              * antennae on the map... boohoo. */
    01953             SlError(STR_ERROR_TOO_MANY_OBJECTS);
    01954           }
    01955
    01956           Object *o = new Object();
    01957           o->location.tile = t;
    01958           o->location.w    = size;
    01959           o->location.h    = size;
    01960           o->build_date    = _date;
    01961           o->town          = type == OBJECT_STATUE ? Town::Get(_m[t].m2) : CalcClosestTownFromTile(t, UINT_MAX);
    01962           _m[t].m2 = o->index;
    01963           Object::IncTypeCount(type);
    01964         } else {
    01965           /* We're at an offset, so get the ID from our "root". */
    01966           TileIndex northern_tile = t - TileXY(GB(offset, 0, 4), GB(offset, 4, 4));
    01967           assert(IsTileType(northern_tile, MP_OBJECT));
    01968           _m[t].m2 = _m[northern_tile].m2;
    01969         }
    01970       }
    01971     }
    01972   }
    01973
    01974   if (IsSavegameVersionBefore(113)) {
    01975     /* allow_town_roads is added, set it if town_layout wasn't TL_NO_ROADS */
    01976     if (_settings_game.economy.town_layout == 0) { // was TL_NO_ROADS
    01977       _settings_game.economy.allow_town_roads = false;
    01978       _settings_game.economy.town_layout = TL_BETTER_ROADS;
    01979     } else {
    01980       _settings_game.economy.allow_town_roads = true;
    01981       _settings_game.economy.town_layout = _settings_game.economy.town_layout - 1;
    01982     }
    01983
    01984     /* Initialize layout of all towns. Older versions were using different
    01985      * generator for random town layout, use it if needed. */
    01986     Town *t;
    01987     FOR_ALL_TOWNS(t) {
    01988       if (_settings_game.economy.town_layout != TL_RANDOM) {
    01989         t->layout = _settings_game.economy.town_layout;
    01990         continue;
    01991       }
    01992
    01993       /* Use old layout randomizer code */
    01994       byte layout = TileHash(TileX(t->xy), TileY(t->xy)) % 6;
    01995       switch (layout) {
    01996         default: break;
    01997         case 5: layout = 1; break;
    01998         case 0: layout = 2; break;
    01999       }
    02000       t->layout = layout - 1;
    02001     }
    02002   }
    02003
    02004   if (IsSavegameVersionBefore(114)) {
    02005     /* There could be (deleted) stations with invalid owner, set owner to OWNER NONE.
    02006      * The conversion affects oil rigs and buoys too, but it doesn't matter as
    02007      * they have st->owner == OWNER_NONE already. */
    02008     Station *st;
    02009     FOR_ALL_STATIONS(st) {
    02010       if (!Company::IsValidID(st->owner)) st->owner = OWNER_NONE;
    02011     }
    02012   }
    02013
    02014   /* Trains could now stop in a specific location. */
    02015   if (IsSavegameVersionBefore(117)) {
    02016     Order *o;
    02017     FOR_ALL_ORDERS(o) {
    02018       if (o->IsType(OT_GOTO_STATION)) o->SetStopLocation(OSL_PLATFORM_FAR_END);
    02019     }
    02020   }
    02021
    02022   if (IsSavegameVersionBefore(120)) {
    02023     extern VehicleDefaultSettings _old_vds;
    02024     Company *c;
    02025     FOR_ALL_COMPANIES(c) {
    02026       c->settings.vehicle = _old_vds;
    02027     }
    02028   }
    02029
    02030   if (IsSavegameVersionBefore(121)) {
    02031     /* Delete small ufos heading for non-existing vehicles */
    02032     Vehicle *v;
    02033     FOR_ALL_DISASTERVEHICLES(v) {
    02034       if (v->subtype == 2/*ST_SMALL_UFO*/ && v->current_order.GetDestination() != 0) {
    02035         const Vehicle *u = Vehicle::GetIfValid(v->dest_tile);
    02036         if (u == NULL || u->type != VEH_ROAD || !RoadVehicle::From(u)->IsFrontEngine()) {
    02037           delete v;
    02038         }
    02039       }
    02040     }
    02041
    02042     /* We didn't store cargo payment yet, so make them for vehicles that are
    02043      * currently at a station and loading/unloading. If they don't get any
    02044      * payment anymore they just removed in the next load/unload cycle.
    02045      * However, some 0.7 versions might have cargo payment. For those we just
    02046      * add cargopayment for the vehicles that don't have it.
    02047      */
    02048     Station *st;
    02049     FOR_ALL_STATIONS(st) {
    02050       std::list<Vehicle *>::iterator iter;
    02051       for (iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end(); ++iter) {
    02052         /* There are always as many CargoPayments as Vehicles. We need to make the
    02053          * assert() in Pool::GetNew() happy by calling CanAllocateItem(). */
    02054         assert_compile(CargoPaymentPool::MAX_SIZE == VehiclePool::MAX_SIZE);
    02055         assert(CargoPayment::CanAllocateItem());
    02056         Vehicle *v = *iter;
    02057         if (v->cargo_payment == NULL) v->cargo_payment = new CargoPayment(v);
    02058       }
    02059     }
    02060   }
    02061
    02062   if (IsSavegameVersionBefore(122)) {
    02063     /* Animated tiles would sometimes not be actually animated or
    02064      * in case of old savegames duplicate. */
    02065
    02066     extern TileIndex *_animated_tile_list;
    02067     extern uint _animated_tile_count;
    02068
    02069     for (uint i = 0; i < _animated_tile_count; /* Nothing */) {
    02070       /* Remove if tile is not animated */
    02071       bool remove = _tile_type_procs[GetTileType(_animated_tile_list[i])]->animate_tile_proc == NULL;
    02072
    02073       /* and remove if duplicate */
    02074       for (uint j = 0; !remove && j < i; j++) {
    02075         remove = _animated_tile_list[i] == _animated_tile_list[j];
    02076       }
    02077
    02078       if (remove) {
    02079         DeleteAnimatedTile(_animated_tile_list[i]);
    02080       } else {
    02081         i++;
    02082       }
    02083     }
    02084   }
    02085
    02086   if (IsSavegameVersionBefore(124) && !IsSavegameVersionBefore(1)) {
    02087     /* The train station tile area was added, but for really old (TTDPatch) it's already valid. */
    02088     Waypoint *wp;
    02089     FOR_ALL_WAYPOINTS(wp) {
    02090       if (wp->facilities & FACIL_TRAIN) {
    02091         wp->train_station.tile = wp->xy;
    02092         wp->train_station.w = 1;
    02093         wp->train_station.h = 1;
    02094       } else {
    02095         wp->train_station.tile = INVALID_TILE;
    02096         wp->train_station.w = 0;
    02097         wp->train_station.h = 0;
    02098       }
    02099     }
    02100   }
    02101
    02102   if (IsSavegameVersionBefore(125)) {
    02103     /* Convert old subsidies */
    02104     Subsidy *s;
    02105     FOR_ALL_SUBSIDIES(s) {
    02106       if (s->remaining < 12) {
    02107         /* Converting nonawarded subsidy */
    02108         s->remaining = 12 - s->remaining; // convert "age" to "remaining"
    02109         s->awarded = INVALID_COMPANY; // not awarded to anyone
    02110         const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
    02111         switch (cs->town_effect) {
    02112           case TE_PASSENGERS:
    02113           case TE_MAIL:
    02114             /* Town -> Town */
    02115             s->src_type = s->dst_type = ST_TOWN;
    02116             if (Town::IsValidID(s->src) && Town::IsValidID(s->dst)) continue;
    02117             break;
    02118           case TE_GOODS:
    02119           case TE_FOOD:
    02120             /* Industry -> Town */
    02121             s->src_type = ST_INDUSTRY;
    02122             s->dst_type = ST_TOWN;
    02123             if (Industry::IsValidID(s->src) && Town::IsValidID(s->dst)) continue;
    02124             break;
    02125           default:
    02126             /* Industry -> Industry */
    02127             s->src_type = s->dst_type = ST_INDUSTRY;
    02128             if (Industry::IsValidID(s->src) && Industry::IsValidID(s->dst)) continue;
    02129             break;
    02130         }
    02131       } else {
    02132         /* Do our best for awarded subsidies. The original source or destination industry
    02133          * can't be determined anymore for awarded subsidies, so invalidate them.
    02134          * Town -> Town subsidies are converted using simple heuristic */
    02135         s->remaining = 24 - s->remaining; // convert "age of awarded subsidy" to "remaining"
    02136         const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
    02137         switch (cs->town_effect) {
    02138           case TE_PASSENGERS:
    02139           case TE_MAIL: {
    02140             /* Town -> Town */
    02141             const Station *ss = Station::GetIfValid(s->src);
    02142             const Station *sd = Station::GetIfValid(s->dst);
    02143             if (ss != NULL && sd != NULL && ss->owner == sd->owner &&
    02144                 Company::IsValidID(ss->owner)) {
    02145               s->src_type = s->dst_type = ST_TOWN;
    02146               s->src = ss->town->index;
    02147               s->dst = sd->town->index;
    02148               s->awarded = ss->owner;
    02149               continue;
    02150             }
    02151             break;
    02152           }
    02153           default:
    02154             break;
    02155         }
    02156       }
    02157       /* Awarded non-town subsidy or invalid source/destination, invalidate */
    02158       delete s;
    02159     }
    02160   }
    02161
    02162   if (IsSavegameVersionBefore(126)) {
    02163     /* Recompute inflation based on old unround loan limit
    02164      * Note: Max loan is 500000. With an inflation of 4% across 170 years
    02165      *       that results in a max loan of about 0.7 * 2^31.
    02166      *       So taking the 16 bit fractional part into account there are plenty of bits left
    02167      *       for unmodified savegames ...
    02168      */
    02169     uint64 aimed_inflation = (_economy.old_max_loan_unround << 16 | _economy.old_max_loan_unround_fract) / _settings_game.difficulty.max_loan;
    02170
    02171     /* ... well, just clamp it then. */
    02172     if (aimed_inflation > MAX_INFLATION) aimed_inflation = MAX_INFLATION;
    02173
    02174     /* Simulate the inflation, so we also get the payment inflation */
    02175     while (_economy.inflation_prices < aimed_inflation) {
    02176       if (AddInflation(false)) break;
    02177     }
    02178   }
    02179
    02180   if (IsSavegameVersionBefore(127)) {
    02181     Station *st;
    02182     FOR_ALL_STATIONS(st) UpdateStationAcceptance(st, false);
    02183   }
    02184
    02185   if (IsSavegameVersionBefore(128)) {
    02186     const Depot *d;
    02187     FOR_ALL_DEPOTS(d) {
    02188       _m[d->xy].m2 = d->index;
    02189       if (IsTileType(d->xy, MP_WATER)) _m[GetOtherShipDepotTile(d->xy)].m2 = d->index;
    02190     }
    02191   }
    02192
    02193   /* The behaviour of force_proceed has been changed. Now
    02194    * it counts signals instead of some random time out. */
    02195   if (IsSavegameVersionBefore(131)) {
    02196     Train *t;
    02197     FOR_ALL_TRAINS(t) {
    02198       if (t->force_proceed != TFP_NONE) {
    02199         t->force_proceed = TFP_STUCK;
    02200       }
    02201     }
    02202   }
    02203
    02204   /* The bits for the tree ground and tree density have
    02205    * been swapped (m2 bits 7..6 and 5..4. */
    02206   if (IsSavegameVersionBefore(135)) {
    02207     for (TileIndex t = 0; t < map_size; t++) {
    02208       if (IsTileType(t, MP_CLEAR)) {
    02209         if (GetRawClearGround(t) == CLEAR_SNOW) {
    02210           SetClearGroundDensity(t, CLEAR_GRASS, GetClearDensity(t));
    02211           SetBit(_m[t].m3, 4);
    02212         } else {
    02213           ClrBit(_m[t].m3, 4);
    02214         }
    02215       }
    02216       if (IsTileType(t, MP_TREES)) {
    02217         uint density = GB(_m[t].m2, 6, 2);
    02218         uint ground = GB(_m[t].m2, 4, 2);
    02219         uint counter = GB(_m[t].m2, 0, 4);
    02220         _m[t].m2 = ground << 6 | density << 4 | counter;
    02221       }
    02222     }
    02223   }
    02224
    02225   /* Wait counter and load/unload ticks got split. */
    02226   if (IsSavegameVersionBefore(136)) {
    02227     Aircraft *a;
    02228     FOR_ALL_AIRCRAFT(a) {
    02229       a->turn_counter = a->current_order.IsType(OT_LOADING) ? 0 : a->load_unload_ticks;
    02230     }
    02231
    02232     Train *t;
    02233     FOR_ALL_TRAINS(t) {
    02234       t->wait_counter = t->current_order.IsType(OT_LOADING) ? 0 : t->load_unload_ticks;
    02235     }
    02236   }
    02237
    02238   /* Airport tile animation uses animation frame instead of other graphics id */
    02239   if (IsSavegameVersionBefore(137)) {
    02240     struct AirportTileConversion {
    02241       byte old_start;
    02242       byte num_frames;
    02243     };
    02244     static const AirportTileConversion atc[] = {
    02245       {31,  12}, // APT_RADAR_GRASS_FENCE_SW
    02246       {50,   4}, // APT_GRASS_FENCE_NE_FLAG
    02247       {62,   2}, // 1 unused tile
    02248       {66,  12}, // APT_RADAR_FENCE_SW
    02249       {78,  12}, // APT_RADAR_FENCE_NE
    02250       {101, 10}, // 9 unused tiles
    02251       {111,  8}, // 7 unused tiles
    02252       {119, 15}, // 14 unused tiles (radar)
    02253       {140,  4}, // APT_GRASS_FENCE_NE_FLAG_2
    02254     };
    02255     for (TileIndex t = 0; t < map_size; t++) {
    02256       if (IsAirportTile(t)) {
    02257         StationGfx old_gfx = GetStationGfx(t);
    02258         byte offset = 0;
    02259         for (uint i = 0; i < lengthof(atc); i++) {
    02260           if (old_gfx < atc[i].old_start) {
    02261             SetStationGfx(t, old_gfx - offset);
    02262             break;
    02263           }
    02264           if (old_gfx < atc[i].old_start + atc[i].num_frames) {
    02265             SetAnimationFrame(t, old_gfx - atc[i].old_start);
    02266             SetStationGfx(t, atc[i].old_start - offset);
    02267             break;
    02268           }
    02269           offset += atc[i].num_frames - 1;
    02270         }
    02271       }
    02272     }
    02273   }
    02274
    02275   if (IsSavegameVersionBefore(140)) {
    02276     Station *st;
    02277     FOR_ALL_STATIONS(st) {
    02278       if (st->airport.tile != INVALID_TILE) {
    02279         st->airport.w = st->airport.GetSpec()->size_x;
    02280         st->airport.h = st->airport.GetSpec()->size_y;
    02281       }
    02282     }
    02283   }
    02284
    02285   if (IsSavegameVersionBefore(141)) {
    02286     for (TileIndex t = 0; t < map_size; t++) {
    02287       /* Reset tropic zone for VOID tiles, they shall not have any. */
    02288       if (IsTileType(t, MP_VOID)) SetTropicZone(t, TROPICZONE_NORMAL);
    02289     }
    02290
    02291     /* We need to properly number/name the depots.
    02292      * The first step is making sure none of the depots uses the
    02293      * 'default' names, after that we can assign the names. */
    02294     Depot *d;
    02295     FOR_ALL_DEPOTS(d) d->town_cn = UINT16_MAX;
    02296
    02297     FOR_ALL_DEPOTS(d) MakeDefaultName(d);
    02298   }
    02299
    02300   if (IsSavegameVersionBefore(142)) {
    02301     Depot *d;
    02302     FOR_ALL_DEPOTS(d) d->build_date = _date;
    02303   }
    02304
    02305   /* In old versions it was possible to remove an airport while a plane was
    02306    * taking off or landing. This gives all kind of problems when building
    02307    * another airport in the same station so we don't allow that anymore.
    02308    * For old savegames with such aircraft we just throw them in the air and
    02309    * treat the aircraft like they were flying already. */
    02310   if (IsSavegameVersionBefore(146)) {
    02311     Aircraft *v;
    02312     FOR_ALL_AIRCRAFT(v) {
    02313       if (!v->IsNormalAircraft()) continue;
    02314       Station *st = GetTargetAirportIfValid(v);
    02315       if (st == NULL && v->state != FLYING) {
    02316         v->state = FLYING;
    02317         UpdateAircraftCache(v);
    02318         AircraftNextAirportPos_and_Order(v);
    02319         /* get aircraft back on running altitude */
    02320         if ((v->vehstatus & VS_CRASHED) == 0) SetAircraftPosition(v, v->x_pos, v->y_pos, GetAircraftFlyingAltitude(v));
    02321       }
    02322     }
    02323   }
    02324
    02325   /* Move the animation frame to the same location (m7) for all objects. */
    02326   if (IsSavegameVersionBefore(147)) {
    02327     for (TileIndex t = 0; t < map_size; t++) {
    02328       switch (GetTileType(t)) {
    02329         case MP_HOUSE:
    02330           if (GetHouseType(t) >= NEW_HOUSE_OFFSET) {
    02331             uint per_proc = _me[t].m7;
    02332             _me[t].m7 = GB(_m[t].m6, 2, 6) | (GB(_m[t].m3, 5, 1) << 6);
    02333             SB(_m[t].m3, 5, 1, 0);
    02334             SB(_m[t].m6, 2, 6, min(per_proc, 63));
    02335           }
    02336           break;
    02337
    02338         case MP_INDUSTRY: {
    02339           uint rand = _me[t].m7;
    02340           _me[t].m7 = _m[t].m3;
    02341           _m[t].m3 = rand;
    02342           break;
    02343         }
    02344
    02345         case MP_OBJECT:
    02346           _me[t].m7 = _m[t].m3;
    02347           _m[t].m3 = 0;
    02348           break;
    02349
    02350         default:
    02351           /* For stations/airports it's already at m7 */
    02352           break;
    02353       }
    02354     }
    02355   }
    02356
    02357   /* Add (random) colour to all objects. */
    02358   if (IsSavegameVersionBefore(148)) {
    02359     Object *o;
    02360     FOR_ALL_OBJECTS(o) {
    02361       Owner owner = GetTileOwner(o->location.tile);
    02362       o->colour = (owner == OWNER_NONE) ? Random() & 0xF : Company::Get(owner)->livery->colour1;
    02363     }
    02364   }
    02365
    02366   if (IsSavegameVersionBefore(149)) {
    02367     for (TileIndex t = 0; t < map_size; t++) {
    02368       if (!IsTileType(t, MP_STATION)) continue;
    02369       if (!IsBuoy(t) && !IsOilRig(t) && !(IsDock(t) && GetTileSlope(t) == SLOPE_FLAT)) {
    02370         SetWaterClass(t, WATER_CLASS_INVALID);
    02371       }
    02372     }
    02373
    02374     /* Waypoints with custom name may have a non-unique town_cn,
    02375      * renumber those. First set all affected waypoints to the
    02376      * highest possible number to get them numbered in the
    02377      * order they have in the pool. */
    02378     Waypoint *wp;
    02379     FOR_ALL_WAYPOINTS(wp) {
    02380       if (wp->name != NULL) wp->town_cn = UINT16_MAX;
    02381     }
    02382
    02383     FOR_ALL_WAYPOINTS(wp) {
    02384       if (wp->name != NULL) MakeDefaultName(wp);
    02385     }
    02386   }
    02387
    02388   if (IsSavegameVersionBefore(152)) {
    02389     _industry_builder.Reset(); // Initialize industry build data.
    02390
    02391     /* The moment vehicles go from hidden to visible changed. This means
    02392      * that vehicles don't always get visible anymore causing things to
    02393      * get messed up just after loading the savegame. This fixes that. */
    02394     Vehicle *v;
    02395     FOR_ALL_VEHICLES(v) {
    02396       /* Not all vehicle types can be inside a tunnel. Furthermore,
    02397        * testing IsTunnelTile() for invalid tiles causes a crash. */
    02398       if (!v->IsGroundVehicle()) continue;
    02399
    02400       /* Is the vehicle in a tunnel? */
    02401       if (!IsTunnelTile(v->tile)) continue;
    02402
    02403       /* Is the vehicle actually at a tunnel entrance/exit? */
    02404       TileIndex vtile = TileVirtXY(v->x_pos, v->y_pos);
    02405       if (!IsTunnelTile(vtile)) continue;
    02406
    02407       /* Are we actually in this tunnel? Or maybe a lower tunnel? */
    02408       if (GetSlopePixelZ(v->x_pos, v->y_pos) != v->z_pos) continue;
    02409
    02410       /* What way are we going? */
    02411       const DiagDirection dir = GetTunnelBridgeDirection(vtile);
    02412       const DiagDirection vdir = DirToDiagDir(v->direction);
    02413
    02414       /* Have we passed the visibility "switch" state already? */
    02415       byte pos = (DiagDirToAxis(vdir) == AXIS_X ? v->x_pos : v->y_pos) & TILE_UNIT_MASK;
    02416       byte frame = (vdir == DIAGDIR_NE || vdir == DIAGDIR_NW) ? TILE_SIZE - 1 - pos : pos;
    02417       extern const byte _tunnel_visibility_frame[DIAGDIR_END];
    02418
    02419       /* Should the vehicle be hidden or not? */
    02420       bool hidden;
    02421       if (dir == vdir) { // Entering tunnel
    02422         hidden = frame >= _tunnel_visibility_frame[dir];
    02423         v->tile = vtile;
    02424       } else if (dir == ReverseDiagDir(vdir)) { // Leaving tunnel
    02425         hidden = frame < TILE_SIZE - _tunnel_visibility_frame[dir];
    02426         /* v->tile changes at the moment when the vehicle leaves the tunnel. */
    02427         v->tile = hidden ? GetOtherTunnelBridgeEnd(vtile) : vtile;
    02428       } else {
    02429         /* We could get here in two cases:
    02430          * - for road vehicles, it is reversing at the end of the tunnel
    02431          * - it is crashed in the tunnel entry (both train or RV destroyed by UFO)
    02432          * Whatever case it is, do not change anything and use the old values.
    02433          * Especially changing RV's state would break its reversing in the middle. */
    02434         continue;
    02435       }
    02436
    02437       if (hidden) {
    02438         v->vehstatus |= VS_HIDDEN;
    02439
    02440         switch (v->type) {
    02441           case VEH_TRAIN: Train::From(v)->track       = TRACK_BIT_WORMHOLE; break;
    02442           case VEH_ROAD:  RoadVehicle::From(v)->state = RVSB_WORMHOLE;      break;
    02443           default: NOT_REACHED();
    02444         }
    02445       } else {
    02446         v->vehstatus &= ~VS_HIDDEN;
    02447
    02448         switch (v->type) {
    02449           case VEH_TRAIN: Train::From(v)->track       = DiagDirToDiagTrackBits(vdir); break;
    02450           case VEH_ROAD:  RoadVehicle::From(v)->state = DiagDirToDiagTrackdir(vdir); RoadVehicle::From(v)->frame = frame; break;
    02451           default: NOT_REACHED();
    02452         }
    02453       }
    02454     }
    02455   }
    02456
    02457   if (IsSavegameVersionBefore(153)) {
    02458     RoadVehicle *rv;
    02459     FOR_ALL_ROADVEHICLES(rv) {
    02460       if (rv->state == RVSB_IN_DEPOT || rv->state == RVSB_WORMHOLE) continue;
    02461
    02462       bool loading = rv->current_order.IsType(OT_LOADING) || rv->current_order.IsType(OT_LEAVESTATION);
    02463       if (HasBit(rv->state, RVS_IN_ROAD_STOP)) {
    02464         extern const byte _road_stop_stop_frame[];
    02465         SB(rv->state, RVS_ENTERED_STOP, 1, loading || rv->frame > _road_stop_stop_frame[rv->state - RVSB_IN_ROAD_STOP + (_settings_game.vehicle.road_side << RVS_DRIVE_SIDE)]);
    02466       } else if (HasBit(rv->state, RVS_IN_DT_ROAD_STOP)) {
    02467         SB(rv->state, RVS_ENTERED_STOP, 1, loading || rv->frame > RVC_DRIVE_THROUGH_STOP_FRAME);
    02468       }
    02469     }
    02470   }
    02471
    02472   if (IsSavegameVersionBefore(156)) {
    02473     /* The train's pathfinder lost flag got moved. */
    02474     Train *t;
    02475     FOR_ALL_TRAINS(t) {
    02476       if (!HasBit(t->flags, 5)) continue;
    02477
    02478       ClrBit(t->flags, 5);
    02479       SetBit(t->vehicle_flags, VF_PATHFINDER_LOST);
    02480     }
    02481
    02482     /* Introduced terraform/clear limits. */
    02483     Company *c;
    02484     FOR_ALL_COMPANIES(c) {
    02485       c->terraform_limit = _settings_game.construction.terraform_frame_burst << 16;
    02486       c->clear_limit     = _settings_game.construction.clear_frame_burst << 16;
    02487     }
    02488   }
    02489
    02490   if (IsSavegameVersionBefore(158)) {
    02491     Vehicle *v;
    02492     FOR_ALL_VEHICLES(v) {
    02493       switch (v->type) {
    02494         case VEH_TRAIN: {
    02495           Train *t = Train::From(v);
    02496
    02497           /* Clear old GOINGUP / GOINGDOWN flags.
    02498            * It was changed in savegame version 139, but savegame
    02499            * version 158 doesn't use these bits, so it doesn't hurt
    02500            * to clear them unconditionally. */
    02501           ClrBit(t->flags, 1);
    02502           ClrBit(t->flags, 2);
    02503
    02504           /* Clear both bits first. */
    02505           ClrBit(t->gv_flags, GVF_GOINGUP_BIT);
    02506           ClrBit(t->gv_flags, GVF_GOINGDOWN_BIT);
    02507
    02508           /* Crashed vehicles can't be going up/down. */
    02509           if (t->vehstatus & VS_CRASHED) break;
    02510
    02511           /* Only X/Y tracks can be sloped. */
    02512           if (t->track != TRACK_BIT_X && t->track != TRACK_BIT_Y) break;
    02513
    02514           t->gv_flags |= FixVehicleInclination(t, t->direction);
    02515           break;
    02516         }
    02517         case VEH_ROAD: {
    02518           RoadVehicle *rv = RoadVehicle::From(v);
    02519           ClrBit(rv->gv_flags, GVF_GOINGUP_BIT);
    02520           ClrBit(rv->gv_flags, GVF_GOINGDOWN_BIT);
    02521
    02522           /* Crashed vehicles can't be going up/down. */
    02523           if (rv->vehstatus & VS_CRASHED) break;
    02524
    02525           if (rv->state == RVSB_IN_DEPOT || rv->state == RVSB_WORMHOLE) break;
    02526
    02527           TrackStatus ts = GetTileTrackStatus(rv->tile, TRANSPORT_ROAD, rv->compatible_roadtypes);
    02528           TrackBits trackbits = TrackStatusToTrackBits(ts);
    02529
    02530           /* Only X/Y tracks can be sloped. */
    02531           if (trackbits != TRACK_BIT_X && trackbits != TRACK_BIT_Y) break;
    02532
    02533           Direction dir = rv->direction;
    02534
    02535           /* Test if we are reversing. */
    02536           Axis a = trackbits == TRACK_BIT_X ? AXIS_X : AXIS_Y;
    02537           if (AxisToDirection(a) != dir &&
    02538               AxisToDirection(a) != ReverseDir(dir)) {
    02539             /* When reversing, the road vehicle is on the edge of the tile,
    02540              * so it can be safely compared to the middle of the tile. */
    02541             dir = INVALID_DIR;
    02542           }
    02543
    02544           rv->gv_flags |= FixVehicleInclination(rv, dir);
    02545           break;
    02546         }
    02547         case VEH_SHIP:
    02548           break;
    02549
    02550         default:
    02551           continue;
    02552       }
    02553
    02554       if (IsBridgeTile(v->tile) && TileVirtXY(v->x_pos, v->y_pos) == v->tile) {
    02555         /* In old versions, z_pos was 1 unit lower on bridge heads.
    02556          * However, this invalid state could be converted to new savegames
    02557          * by loading and saving the game in a new version. */
    02558         v->z_pos = GetSlopePixelZ(v->x_pos, v->y_pos);
    02559         DiagDirection dir = GetTunnelBridgeDirection(v->tile);
    02560         if (v->type == VEH_TRAIN && !(v->vehstatus & VS_CRASHED) &&
    02561             v->direction != DiagDirToDir(dir)) {
    02562           /* If the train has left the bridge, it shouldn't have
    02563            * track == TRACK_BIT_WORMHOLE - this could happen
    02564            * when the train was reversed while on the last "tick"
    02565            * on the ramp before leaving the ramp to the bridge. */
    02566           Train::From(v)->track = DiagDirToDiagTrackBits(dir);
    02567         }
    02568       }
    02569
    02570       /* If the vehicle is really above v->tile (not in a wormhole),
    02571        * it should have set v->z_pos correctly. */
    02572       assert(v->tile != TileVirtXY(v->x_pos, v->y_pos) || v->z_pos == GetSlopePixelZ(v->x_pos, v->y_pos));
    02573     }
    02574
    02575     /* Fill Vehicle::cur_real_order_index */
    02576     FOR_ALL_VEHICLES(v) {
    02577       if (!v->IsPrimaryVehicle()) continue;
    02578
    02579       /* Older versions are less strict with indices being in range and fix them on the fly */
    02580       if (v->cur_implicit_order_index >= v->GetNumOrders()) v->cur_implicit_order_index = 0;
    02581
    02582       v->cur_real_order_index = v->cur_implicit_order_index;
    02583       v->UpdateRealOrderIndex();
    02584     }
    02585   }
    02586
    02587   if (IsSavegameVersionBefore(159)) {
    02588     /* If the savegame is old (before version 100), then the value of 255
    02589      * for these settings did not mean "disabled". As such everything
    02590      * before then did reverse.
    02591      * To simplify stuff we disable all turning around or we do not
    02592      * disable anything at all. So, if some reversing was disabled we
    02593      * will keep reversing disabled, otherwise it'll be turned on. */
    02594     _settings_game.pf.reverse_at_signals = IsSavegameVersionBefore(100) || (_settings_game.pf.wait_oneway_signal != 255 && _settings_game.pf.wait_twoway_signal != 255 && _settings_game.pf.wait_for_pbs_path != 255);
    02595
    02596     Train *t;
    02597     FOR_ALL_TRAINS(t) {
    02598       _settings_game.vehicle.max_train_length = max<uint8>(_settings_game.vehicle.max_train_length, CeilDiv(t->gcache.cached_total_length, TILE_SIZE));
    02599     }
    02600   }
    02601
    02602   if (IsSavegameVersionBefore(160)) {
    02603     /* Setting difficulty industry_density other than zero get bumped to +1
    02604      * since a new option (minimal at position 1) has been added */
    02605     if (_settings_game.difficulty.industry_density > 0) {
    02606       _settings_game.difficulty.industry_density++;
    02607     }
    02608   }
    02609
    02610   if (IsSavegameVersionBefore(161)) {
    02611     /* Before savegame version 161, persistent storages were not stored in a pool. */
    02612
    02613     if (!IsSavegameVersionBefore(76)) {
    02614       Industry *ind;
    02615       FOR_ALL_INDUSTRIES(ind) {
    02616         assert(ind->psa != NULL);
    02617
    02618         /* Check if the old storage was empty. */
    02619         bool is_empty = true;
    02620         for (uint i = 0; i < sizeof(ind->psa->storage); i++) {
    02621           if (ind->psa->GetValue(i) != 0) {
    02622             is_empty = false;
    02623             break;
    02624           }
    02625         }
    02626
    02627         if (!is_empty) {
    02628           ind->psa->grfid = _industry_mngr.GetGRFID(ind->type);
    02629         } else {
    02630           delete ind->psa;
    02631           ind->psa = NULL;
    02632         }
    02633       }
    02634     }
    02635
    02636     if (!IsSavegameVersionBefore(145)) {
    02637       Station *st;
    02638       FOR_ALL_STATIONS(st) {
    02639         if (!(st->facilities & FACIL_AIRPORT)) continue;
    02640         assert(st->airport.psa != NULL);
    02641
    02642         /* Check if the old storage was empty. */
    02643         bool is_empty = true;
    02644         for (uint i = 0; i < sizeof(st->airport.psa->storage); i++) {
    02645           if (st->airport.psa->GetValue(i) != 0) {
    02646             is_empty = false;
    02647             break;
    02648           }
    02649         }
    02650
    02651         if (!is_empty) {
    02652           st->airport.psa->grfid = _airport_mngr.GetGRFID(st->airport.type);
    02653         } else {
    02654           delete st->airport.psa;
    02655           st->airport.psa = NULL;
    02656
    02657         }
    02658       }
    02659     }
    02660   }
    02661
    02662   /* This triggers only when old snow_lines were copied into the snow_line_height. */
    02663   if (IsSavegameVersionBefore(164) && _settings_game.game_creation.snow_line_height >= MIN_SNOWLINE_HEIGHT * TILE_HEIGHT) {
    02664     _settings_game.game_creation.snow_line_height /= TILE_HEIGHT;
    02665   }
    02666
    02667   if (IsSavegameVersionBefore(164) && !IsSavegameVersionBefore(32)) {
    02668     /* We store 4 fences in the field tiles instead of only SE and SW. */
    02669     for (TileIndex t = 0; t < map_size; t++) {
    02670       if (!IsTileType(t, MP_CLEAR) && !IsTileType(t, MP_TREES)) continue;
    02671       if (IsTileType(t, MP_CLEAR) && IsClearGround(t, CLEAR_FIELDS)) continue;
    02672       uint fence = GB(_m[t].m4, 5, 3);
    02673       if (fence != 0 && IsTileType(TILE_ADDXY(t, 1, 0), MP_CLEAR) && IsClearGround(TILE_ADDXY(t, 1, 0), CLEAR_FIELDS)) {
    02674         SetFenceNE(TILE_ADDXY(t, 1, 0), fence);
    02675       }
    02676       fence = GB(_m[t].m4, 2, 3);
    02677       if (fence != 0 && IsTileType(TILE_ADDXY(t, 0, 1), MP_CLEAR) && IsClearGround(TILE_ADDXY(t, 0, 1), CLEAR_FIELDS)) {
    02678         SetFenceNW(TILE_ADDXY(t, 0, 1), fence);
    02679       }
    02680       SB(_m[t].m4, 2, 3, 0);
    02681       SB(_m[t].m4, 5, 3, 0);
    02682     }
    02683   }
    02684
    02685   /* The center of train vehicles was changed, fix up spacing. */
    02686   if (IsSavegameVersionBefore(164)) FixupTrainLengths();
    02687
    02688   if (IsSavegameVersionBefore(165)) {
    02689     Town *t;
    02690
    02691     FOR_ALL_TOWNS(t) {
    02692       /* Set the default cargo requirement for town growth */
    02693       switch (_settings_game.game_creation.landscape) {
    02694         case LT_ARCTIC:
    02695           if (FindFirstCargoWithTownEffect(TE_FOOD) != NULL) t->goal[TE_FOOD] = TOWN_GROWTH_WINTER;
    02696           break;
    02697
    02698         case LT_TROPIC:
    02699           if (FindFirstCargoWithTownEffect(TE_FOOD) != NULL) t->goal[TE_FOOD] = TOWN_GROWTH_DESERT;
    02700           if (FindFirstCargoWithTownEffect(TE_WATER) != NULL) t->goal[TE_WATER] = TOWN_GROWTH_DESERT;
    02701           break;
    02702       }
    02703     }
    02704   }
    02705
    02706   if (IsSavegameVersionBefore(165)) {
    02707     /* Adjust zoom level to account for new levels */
    02708     _saved_scrollpos_zoom = _saved_scrollpos_zoom + ZOOM_LVL_SHIFT;
    02709     _saved_scrollpos_x *= ZOOM_LVL_BASE;
    02710     _saved_scrollpos_y *= ZOOM_LVL_BASE;
    02711   }
    02712
    02713   /* When any NewGRF has been changed the availability of some vehicles might
    02714    * have been changed too. e->company_avail must be set to 0 in that case
    02715    * which is done by StartupEngines(). */
    02716   if (gcf_res != GLC_ALL_GOOD) StartupEngines();
    02717
    02718   if (IsSavegameVersionBefore(166)) {
    02719     /* Update cargo acceptance map of towns. */
    02720     for (TileIndex t = 0; t < map_size; t++) {
    02721       if (!IsTileType(t, MP_HOUSE)) continue;
    02722       Town::Get(GetTownIndex(t))->cargo_accepted.Add(t);
    02723     }
    02724
    02725     Town *town;
    02726     FOR_ALL_TOWNS(town) {
    02727       UpdateTownCargoes(town);
    02728     }
    02729   }
    02730
    02731   /* The road owner of standard road stops was not properly accounted for. */
    02732   if (IsSavegameVersionBefore(172)) {
    02733     for (TileIndex t = 0; t < map_size; t++) {
    02734       if (!IsStandardRoadStopTile(t)) continue;
    02735       Owner o = GetTileOwner(t);
    02736       SetRoadOwner(t, ROADTYPE_ROAD, o);
    02737       SetRoadOwner(t, ROADTYPE_TRAM, o);
    02738     }
    02739   }
    02740
    02741   if (IsSavegameVersionBefore(175)) {
    02742     /* Introduced tree planting limit. */
    02743     Company *c;
    02744     FOR_ALL_COMPANIES(c) c->tree_limit = _settings_game.construction.tree_frame_burst << 16;
    02745   }
    02746
    02747   if (IsSavegameVersionBefore(177)) {
    02748     /* Fix too high inflation rates */
    02749     if (_economy.inflation_prices > MAX_INFLATION) _economy.inflation_prices = MAX_INFLATION;
    02750     if (_economy.inflation_payment > MAX_INFLATION) _economy.inflation_payment = MAX_INFLATION;
    02751
    02752     /* We have to convert the quarters of bankruptcy into months of bankruptcy */
    02753     FOR_ALL_COMPANIES(c) {
    02754       c->months_of_bankruptcy = 3 * c->months_of_bankruptcy;
    02755     }
    02756   }
    02757
    02758   /* Road stops is 'only' updating some caches */
    02759   AfterLoadRoadStops();
    02760   AfterLoadLabelMaps();
    02761   AfterLoadCompanyStats();
    02762
    02763   GamelogPrintDebug(1);
    02764
    02765   InitializeWindowsAndCaches();
    02766   /* Restore the signals */
    02767   ResetSignalHandlers();
    02768
    02769   AfterLoadLinkGraphs();
    02770   return true;
    02771 }
    02772
    02781 void ReloadNewGRFData()
    02782 {
    02783   /* reload grf data */
    02784   GfxLoadSprites();
    02785   LoadStringWidthTable();
    02786   RecomputePrices();
    02787   /* reload vehicles */
    02788   ResetVehicleHash();
    02789   AfterLoadVehicles(false);
    02790   StartupEngines();
    02791   GroupStatistics::UpdateAfterLoad();
    02792   /* update station graphics */
    02793   AfterLoadStations();
    02794   /* Update company statistics. */
    02795   AfterLoadCompanyStats();
    02796   /* Check and update house and town values */
    02797   UpdateHousesAndTowns();
    02798   /* Delete news referring to no longer existing entities */
    02799   DeleteInvalidEngineNews();
    02800   /* Update livery selection windows */
    02801   for (CompanyID i = COMPANY_FIRST; i < MAX_COMPANIES; i++) InvalidateWindowData(WC_COMPANY_COLOUR, i);
    02802   /* Update company infrastructure counts. */
    02803   InvalidateWindowClassesData(WC_COMPANY_INFRASTRUCTURE);
    02804   /* redraw the whole screen */
    02805   MarkWholeScreenDirty();
    02806   CheckTrainsLengths();
    02807 }