# 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   }
    00721
    00722   /* Fix the cache for cargo payments. */
    00723   CargoPayment *cp;
    00724   FOR_ALL_CARGO_PAYMENTS(cp) {
    00725     cp->front->cargo_payment = cp;
    00726     cp->current_station = cp->front->last_station_visited;
    00727   }
    00728
    00729   if (IsSavegameVersionBefore(72)) {
    00730     /* Locks in very old savegames had OWNER_WATER as owner */
    00731     for (TileIndex t = 0; t < MapSize(); t++) {
    00732       switch (GetTileType(t)) {
    00733         default: break;
    00734
    00735         case MP_WATER:
    00736           if (GetWaterTileType(t) == WATER_TILE_LOCK && GetTileOwner(t) == OWNER_WATER) SetTileOwner(t, OWNER_NONE);
    00737           break;
    00738
    00739         case MP_STATION: {
    00740           if (HasBit(_m[t].m6, 3)) SetBit(_m[t].m6, 2);
    00741           StationGfx gfx = GetStationGfx(t);
    00742           StationType st;
    00743           if (       IsInsideMM(gfx,   0,   8)) { // Rail station
    00744             st = STATION_RAIL;
    00745             SetStationGfx(t, gfx - 0);
    00746           } else if (IsInsideMM(gfx,   8,  67)) { // Airport
    00747             st = STATION_AIRPORT;
    00748             SetStationGfx(t, gfx - 8);
    00749           } else if (IsInsideMM(gfx,  67,  71)) { // Truck
    00750             st = STATION_TRUCK;
    00751             SetStationGfx(t, gfx - 67);
    00752           } else if (IsInsideMM(gfx,  71,  75)) { // Bus
    00753             st = STATION_BUS;
    00754             SetStationGfx(t, gfx - 71);
    00755           } else if (gfx == 75) {                 // Oil rig
    00756             st = STATION_OILRIG;
    00757             SetStationGfx(t, gfx - 75);
    00758           } else if (IsInsideMM(gfx,  76,  82)) { // Dock
    00759             st = STATION_DOCK;
    00760             SetStationGfx(t, gfx - 76);
    00761           } else if (gfx == 82) {                 // Buoy
    00762             st = STATION_BUOY;
    00763             SetStationGfx(t, gfx - 82);
    00764           } else if (IsInsideMM(gfx,  83, 168)) { // Extended airport
    00765             st = STATION_AIRPORT;
    00766             SetStationGfx(t, gfx - 83 + 67 - 8);
    00767           } else if (IsInsideMM(gfx, 168, 170)) { // Drive through truck
    00768             st = STATION_TRUCK;
    00769             SetStationGfx(t, gfx - 168 + GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);
    00770           } else if (IsInsideMM(gfx, 170, 172)) { // Drive through bus
    00771             st = STATION_BUS;
    00772             SetStationGfx(t, gfx - 170 + GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);
    00773           } else {
    00774             /* Restore the signals */
    00775             ResetSignalHandlers();
    00776             return false;
    00777           }
    00778           SB(_m[t].m6, 3, 3, st);
    00779           break;
    00780         }
    00781       }
    00782     }
    00783   }
    00784
    00785   for (TileIndex t = 0; t < map_size; t++) {
    00786     switch (GetTileType(t)) {
    00787       case MP_STATION: {
    00788         BaseStation *bst = BaseStation::GetByTile(t);
    00789
    00790         /* Set up station spread */
    00791         bst->rect.BeforeAddTile(t, StationRect::ADD_FORCE);
    00792
    00793         /* Waypoints don't have road stops/oil rigs in the old format */
    00794         if (!Station::IsExpected(bst)) break;
    00795         Station *st = Station::From(bst);
    00796
    00797         switch (GetStationType(t)) {
    00798           case STATION_TRUCK:
    00799           case STATION_BUS:
    00800             if (IsSavegameVersionBefore(6)) {
    00801               /* Before version 5 you could not have more than 250 stations.
    00802                * Version 6 adds large maps, so you could only place 253*253
    00803                * road stops on a map (no freeform edges) = 64009. So, yes
    00804                * someone could in theory create such a full map to trigger
    00805                * this assertion, it's safe to assume that's only something
    00806                * theoretical and does not happen in normal games. */
    00807               assert(RoadStop::CanAllocateItem());
    00808
    00809               /* From this version on there can be multiple road stops of the
    00810                * same type per station. Convert the existing stops to the new
    00811                * internal data structure. */
    00812               RoadStop *rs = new RoadStop(t);
    00813
    00814               RoadStop **head =
    00815                 IsTruckStop(t) ? &st->truck_stops : &st->bus_stops;
    00816               *head = rs;
    00817             }
    00818             break;
    00819
    00820           case STATION_OILRIG: {
    00821             /* Very old savegames sometimes have phantom oil rigs, i.e.
    00822              * an oil rig which got shut down, but not completly removed from
    00823              * the map
    00824              */
    00825             TileIndex t1 = TILE_ADDXY(t, 0, 1);
    00826             if (IsTileType(t1, MP_INDUSTRY) &&
    00827                 GetIndustryGfx(t1) == GFX_OILRIG_1) {
    00828               /* The internal encoding of oil rigs was changed twice.
    00829                * It was 3 (till 2.2) and later 5 (till 5.1).
    00830                * Setting it unconditionally does not hurt.
    00831                */
    00832               Station::GetByTile(t)->airport.type = AT_OILRIG;
    00833             } else {
    00834               DeleteOilRig(t);
    00835             }
    00836             break;
    00837           }
    00838
    00839           default: break;
    00840         }
    00841         break;
    00842       }
    00843
    00844       default: break;
    00845     }
    00846   }
    00847
    00848   /* In version 2.2 of the savegame, we have new airports, so status of all aircraft is reset.
    00849    * This has to be called after the oilrig airport_type update above ^^^ ! */
    00850   if (IsSavegameVersionBefore(2, 2)) UpdateOldAircraft();
    00851
    00852   /* In version 6.1 we put the town index in the map-array. To do this, we need
    00853    *  to use m2 (16bit big), so we need to clean m2, and that is where this is
    00854    *  all about ;) */
    00855   if (IsSavegameVersionBefore(6, 1)) {
    00856     for (TileIndex t = 0; t < map_size; t++) {
    00857       switch (GetTileType(t)) {
    00858         case MP_HOUSE:
    00859           _m[t].m4 = _m[t].m2;
    00860           SetTownIndex(t, CalcClosestTownFromTile(t)->index);
    00861           break;
    00862
    00863         case MP_ROAD:
    00864           _m[t].m4 |= (_m[t].m2 << 4);
    00865           if ((GB(_m[t].m5, 4, 2) == ROAD_TILE_CROSSING ? (Owner)_m[t].m3 : GetTileOwner(t)) == OWNER_TOWN) {
    00866             SetTownIndex(t, CalcClosestTownFromTile(t)->index);
    00867           } else {
    00868             SetTownIndex(t, 0);
    00869           }
    00870           break;
    00871
    00872         default: break;
    00873       }
    00874     }
    00875   }
    00876
    00877   /* Force the freeform edges to false for old savegames. */
    00878   if (IsSavegameVersionBefore(111)) {
    00879     _settings_game.construction.freeform_edges = false;
    00880   }
    00881
    00882   /* From version 9.0, we update the max passengers of a town (was sometimes negative
    00883    *  before that. */
    00884   if (IsSavegameVersionBefore(9)) {
    00885     Town *t;
    00886     FOR_ALL_TOWNS(t) UpdateTownMaxPass(t);
    00887   }
    00888
    00889   /* From version 16.0, we included autorenew on engines, which are now saved, but
    00890    *  of course, we do need to initialize them for older savegames. */
    00891   if (IsSavegameVersionBefore(16)) {
    00892     Company *c;
    00893     FOR_ALL_COMPANIES(c) {
    00894       c->engine_renew_list            = NULL;
    00895       c->settings.engine_renew        = false;
    00896       c->settings.engine_renew_months = 6;
    00897       c->settings.engine_renew_money  = 100000;
    00898     }
    00899
    00900     /* When loading a game, _local_company is not yet set to the correct value.
    00901      * However, in a dedicated server we are a spectator, so nothing needs to
    00902      * happen. In case we are not a dedicated server, the local company always
    00903      * becomes company 0, unless we are in the scenario editor where all the
    00904      * companies are 'invalid'.
    00905      */
    00906     c = Company::GetIfValid(COMPANY_FIRST);
    00907     if (!_network_dedicated && c != NULL) {
    00908       c->settings = _settings_client.company;
    00909     }
    00910   }
    00911
    00912   if (IsSavegameVersionBefore(48)) {
    00913     for (TileIndex t = 0; t < map_size; t++) {
    00914       switch (GetTileType(t)) {
    00915         case MP_RAILWAY:
    00916           if (IsPlainRail(t)) {
    00917             /* Swap ground type and signal type for plain rail tiles, so the
    00918              * ground type uses the same bits as for depots and waypoints. */
    00919             uint tmp = GB(_m[t].m4, 0, 4);
    00920             SB(_m[t].m4, 0, 4, GB(_m[t].m2, 0, 4));
    00921             SB(_m[t].m2, 0, 4, tmp);
    00922           } else if (HasBit(_m[t].m5, 2)) {
    00923             /* Split waypoint and depot rail type and remove the subtype. */
    00924             ClrBit(_m[t].m5, 2);
    00925             ClrBit(_m[t].m5, 6);
    00926           }
    00927           break;
    00928
    00929         case MP_ROAD:
    00930           /* Swap m3 and m4, so the track type for rail crossings is the
    00931            * same as for normal rail. */
    00932           Swap(_m[t].m3, _m[t].m4);
    00933           break;
    00934
    00935         default: break;
    00936       }
    00937     }
    00938   }
    00939
    00940   if (IsSavegameVersionBefore(61)) {
    00941     /* Added the RoadType */
    00942     bool old_bridge = IsSavegameVersionBefore(42);
    00943     for (TileIndex t = 0; t < map_size; t++) {
    00944       switch (GetTileType(t)) {
    00945         case MP_ROAD:
    00946           SB(_m[t].m5, 6, 2, GB(_m[t].m5, 4, 2));
    00947           switch (GetRoadTileType(t)) {
    00948             default: SlErrorCorrupt("Invalid road tile type");
    00949             case ROAD_TILE_NORMAL:
    00950               SB(_m[t].m4, 0, 4, GB(_m[t].m5, 0, 4));
    00951               SB(_m[t].m4, 4, 4, 0);
    00952               SB(_m[t].m6, 2, 4, 0);
    00953               break;
    00954             case ROAD_TILE_CROSSING:
    00955               SB(_m[t].m4, 5, 2, GB(_m[t].m5, 2, 2));
    00956               break;
    00957             case ROAD_TILE_DEPOT:    break;
    00958           }
    00959           SetRoadTypes(t, ROADTYPES_ROAD);
    00960           break;
    00961
    00962         case MP_STATION:
    00963           if (IsRoadStop(t)) SetRoadTypes(t, ROADTYPES_ROAD);
    00964           break;
    00965
    00966         case MP_TUNNELBRIDGE:
    00967           /* Middle part of "old" bridges */
    00968           if (old_bridge && IsBridge(t) && HasBit(_m[t].m5, 6)) break;
    00969           if (((old_bridge && IsBridge(t)) ? (TransportType)GB(_m[t].m5, 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) {
    00970             SetRoadTypes(t, ROADTYPES_ROAD);
    00971           }
    00972           break;
    00973
    00974         default: break;
    00975       }
    00976     }
    00977   }
    00978
    00979   if (IsSavegameVersionBefore(114)) {
    00980     bool fix_roadtypes = !IsSavegameVersionBefore(61);
    00981     bool old_bridge = IsSavegameVersionBefore(42);
    00982
    00983     for (TileIndex t = 0; t < map_size; t++) {
    00984       switch (GetTileType(t)) {
    00985         case MP_ROAD:
    00986           if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_me[t].m7, 5, 3));
    00987           SB(_me[t].m7, 5, 1, GB(_m[t].m3, 7, 1)); // snow/desert
    00988           switch (GetRoadTileType(t)) {
    00989             default: SlErrorCorrupt("Invalid road tile type");
    00990             case ROAD_TILE_NORMAL:
    00991               SB(_me[t].m7, 0, 4, GB(_m[t].m3, 0, 4)); // road works
    00992               SB(_m[t].m6, 3, 3, GB(_m[t].m3, 4, 3));  // ground
    00993               SB(_m[t].m3, 0, 4, GB(_m[t].m4, 4, 4));  // tram bits
    00994               SB(_m[t].m3, 4, 4, GB(_m[t].m5, 0, 4));  // tram owner
    00995               SB(_m[t].m5, 0, 4, GB(_m[t].m4, 0, 4));  // road bits
    00996               break;
    00997
    00998             case ROAD_TILE_CROSSING:
    00999               SB(_me[t].m7, 0, 5, GB(_m[t].m4, 0, 5)); // road owner
    01000               SB(_m[t].m6, 3, 3, GB(_m[t].m3, 4, 3));  // ground
    01001               SB(_m[t].m3, 4, 4, GB(_m[t].m5, 0, 4));  // tram owner
    01002               SB(_m[t].m5, 0, 1, GB(_m[t].m4, 6, 1));  // road axis
    01003               SB(_m[t].m5, 5, 1, GB(_m[t].m4, 5, 1));  // crossing state
    01004               break;
    01005
    01006             case ROAD_TILE_DEPOT:
    01007               break;
    01008           }
    01009           if (!IsRoadDepot(t) && !HasTownOwnedRoad(t)) {
    01010             const Town *town = CalcClosestTownFromTile(t);
    01011             if (town != NULL) SetTownIndex(t, town->index);
    01012           }
    01013           _m[t].m4 = 0;
    01014           break;
    01015
    01016         case MP_STATION:
    01017           if (!IsRoadStop(t)) break;
    01018
    01019           if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_m[t].m3, 0, 3));
    01020           SB(_me[t].m7, 0, 5, HasBit(_m[t].m6, 2) ? OWNER_TOWN : GetTileOwner(t));
    01021           SB(_m[t].m3, 4, 4, _m[t].m1);
    01022           _m[t].m4 = 0;
    01023           break;
    01024
    01025         case MP_TUNNELBRIDGE:
    01026           if (old_bridge && IsBridge(t) && HasBit(_m[t].m5, 6)) break;
    01027           if (((old_bridge && IsBridge(t)) ? (TransportType)GB(_m[t].m5, 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) {
    01028             if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_m[t].m3, 0, 3));
    01029
    01030             Owner o = GetTileOwner(t);
    01031             SB(_me[t].m7, 0, 5, o); // road owner
    01032             SB(_m[t].m3, 4, 4, o == OWNER_NONE ? OWNER_TOWN : o); // tram owner
    01033           }
    01034           SB(_m[t].m6, 2, 4, GB(_m[t].m2, 4, 4)); // bridge type
    01035           SB(_me[t].m7, 5, 1, GB(_m[t].m4, 7, 1)); // snow/desert
    01036
    01037           _m[t].m2 = 0;
    01038           _m[t].m4 = 0;
    01039           break;
    01040
    01041         default: break;
    01042       }
    01043     }
    01044   }
    01045
    01046   if (IsSavegameVersionBefore(42)) {
    01047     Vehicle *v;
    01048
    01049     for (TileIndex t = 0; t < map_size; t++) {
    01050       if (MayHaveBridgeAbove(t)) ClearBridgeMiddle(t);
    01051       if (IsBridgeTile(t)) {
    01052         if (HasBit(_m[t].m5, 6)) { // middle part
    01053           Axis axis = (Axis)GB(_m[t].m5, 0, 1);
    01054
    01055           if (HasBit(_m[t].m5, 5)) { // transport route under bridge?
    01056             if (GB(_m[t].m5, 3, 2) == TRANSPORT_RAIL) {
    01057               MakeRailNormal(
    01058                 t,
    01059                 GetTileOwner(t),
    01060                 axis == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X,
    01061                 GetRailType(t)
    01062               );
    01063             } else {
    01064               TownID town = IsTileOwner(t, OWNER_TOWN) ? ClosestTownFromTile(t, UINT_MAX)->index : 0;
    01065
    01066               MakeRoadNormal(
    01067                 t,
    01068                 axis == AXIS_X ? ROAD_Y : ROAD_X,
    01069                 ROADTYPES_ROAD,
    01070                 town,
    01071                 GetTileOwner(t), OWNER_NONE
    01072               );
    01073             }
    01074           } else {
    01075             if (GB(_m[t].m5, 3, 2) == 0) {
    01076               MakeClear(t, CLEAR_GRASS, 3);
    01077             } else {
    01078               if (GetTileSlope(t) != SLOPE_FLAT) {
    01079                 MakeShore(t);
    01080               } else {
    01081                 if (GetTileOwner(t) == OWNER_WATER) {
    01082                   MakeSea(t);
    01083                 } else {
    01084                   MakeCanal(t, GetTileOwner(t), Random());
    01085                 }
    01086               }
    01087             }
    01088           }
    01089           SetBridgeMiddle(t, axis);
    01090         } else { // ramp
    01091           Axis axis = (Axis)GB(_m[t].m5, 0, 1);
    01092           uint north_south = GB(_m[t].m5, 5, 1);
    01093           DiagDirection dir = ReverseDiagDir(XYNSToDiagDir(axis, north_south));
    01094           TransportType type = (TransportType)GB(_m[t].m5, 1, 2);
    01095
    01096           _m[t].m5 = 1 << 7 | type << 2 | dir;
    01097         }
    01098       }
    01099     }
    01100
    01101     FOR_ALL_VEHICLES(v) {
    01102       if (!v->IsGroundVehicle()) continue;
    01103       if (IsBridgeTile(v->tile)) {
    01104         DiagDirection dir = GetTunnelBridgeDirection(v->tile);
    01105
    01106         if (dir != DirToDiagDir(v->direction)) continue;
    01107         switch (dir) {
    01108           default: SlErrorCorrupt("Invalid vehicle direction");
    01109           case DIAGDIR_NE: if ((v->x_pos & 0xF) !=  0)            continue; break;
    01110           case DIAGDIR_SE: if ((v->y_pos & 0xF) != TILE_SIZE - 1) continue; break;
    01111           case DIAGDIR_SW: if ((v->x_pos & 0xF) != TILE_SIZE - 1) continue; break;
    01112           case DIAGDIR_NW: if ((v->y_pos & 0xF) !=  0)            continue; break;
    01113         }
    01114       } else if (v->z_pos > GetSlopePixelZ(v->x_pos, v->y_pos)) {
    01115         v->tile = GetNorthernBridgeEnd(v->tile);
    01116       } else {
    01117         continue;
    01118       }
    01119       if (v->type == VEH_TRAIN) {
    01120         Train::From(v)->track = TRACK_BIT_WORMHOLE;
    01121       } else {
    01122         RoadVehicle::From(v)->state = RVSB_WORMHOLE;
    01123       }
    01124     }
    01125   }
    01126
    01127   /* Elrails got added in rev 24 */
    01128   if (IsSavegameVersionBefore(24)) {
    01129     RailType min_rail = RAILTYPE_ELECTRIC;
    01130
    01131     Train *v;
    01132     FOR_ALL_TRAINS(v) {
    01133       RailType rt = RailVehInfo(v->engine_type)->railtype;
    01134
    01135       v->railtype = rt;
    01136       if (rt == RAILTYPE_ELECTRIC) min_rail = RAILTYPE_RAIL;
    01137     }
    01138
    01139     /* .. so we convert the entire map from normal to elrail (so maintain "fairness") */
    01140     for (TileIndex t = 0; t < map_size; t++) {
    01141       switch (GetTileType(t)) {
    01142         case MP_RAILWAY:
    01143           SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
    01144           break;
    01145
    01146         case MP_ROAD:
    01147           if (IsLevelCrossing(t)) {
    01148             SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
    01149           }
    01150           break;
    01151
    01152         case MP_STATION:
    01153           if (HasStationRail(t)) {
    01154             SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
    01155           }
    01156           break;
    01157
    01158         case MP_TUNNELBRIDGE:
    01159           if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) {
    01160             SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
    01161           }
    01162           break;
    01163
    01164         default:
    01165           break;
    01166       }
    01167     }
    01168
    01169     FOR_ALL_TRAINS(v) {
    01170       if (v->IsFrontEngine() || v->IsFreeWagon()) v->ConsistChanged(true);
    01171     }
    01172
    01173   }
    01174
    01175   /* In version 16.1 of the savegame a company can decide if trains, which get
    01176    * replaced, shall keep their old length. In all prior versions, just default
    01177    * to false */
    01178   if (IsSavegameVersionBefore(16, 1)) {
    01179     Company *c;
    01180     FOR_ALL_COMPANIES(c) c->settings.renew_keep_length = false;
    01181   }
    01182
    01183   if (IsSavegameVersionBefore(123)) {
    01184     /* Waypoints became subclasses of stations ... */
    01185     MoveWaypointsToBaseStations();
    01186     /* ... and buoys were moved to waypoints. */
    01187     MoveBuoysToWaypoints();
    01188   }
    01189
    01190   /* From version 15, we moved a semaphore bit from bit 2 to bit 3 in m4, making
    01191    *  room for PBS. Now in version 21 move it back :P. */
    01192   if (IsSavegameVersionBefore(21) && !IsSavegameVersionBefore(15)) {
    01193     for (TileIndex t = 0; t < map_size; t++) {
    01194       switch (GetTileType(t)) {
    01195         case MP_RAILWAY:
    01196           if (HasSignals(t)) {
    01197             /* convert PBS signals to combo-signals */
    01198             if (HasBit(_m[t].m2, 2)) SetSignalType(t, TRACK_X, SIGTYPE_COMBO);
    01199
    01200             /* move the signal variant back */
    01201             SetSignalVariant(t, TRACK_X, HasBit(_m[t].m2, 3) ? SIG_SEMAPHORE : SIG_ELECTRIC);
    01202             ClrBit(_m[t].m2, 3);
    01203           }
    01204
    01205           /* Clear PBS reservation on track */
    01206           if (!IsRailDepotTile(t)) {
    01207             SB(_m[t].m4, 4, 4, 0);
    01208           } else {
    01209             ClrBit(_m[t].m3, 6);
    01210           }
    01211           break;
    01212
    01213         case MP_STATION: // Clear PBS reservation on station
    01214           ClrBit(_m[t].m3, 6);
    01215           break;
    01216
    01217         default: break;
    01218       }
    01219     }
    01220   }
    01221
    01222   if (IsSavegameVersionBefore(25)) {
    01223     RoadVehicle *rv;
    01224     FOR_ALL_ROADVEHICLES(rv) {
    01225       rv->vehstatus &= ~0x40;
    01226     }
    01227   }
    01228
    01229   if (IsSavegameVersionBefore(26)) {
    01230     Station *st;
    01231     FOR_ALL_STATIONS(st) {
    01232       st->last_vehicle_type = VEH_INVALID;
    01233     }
    01234   }
    01235
    01236   YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK);
    01237
    01238   if (IsSavegameVersionBefore(34)) {
    01239     Company *c;
    01240     FOR_ALL_COMPANIES(c) ResetCompanyLivery(c);
    01241   }
    01242
    01243   Company *c;
    01244   FOR_ALL_COMPANIES(c) {
    01245     c->avail_railtypes = GetCompanyRailtypes(c->index);
    01246     c->avail_roadtypes = GetCompanyRoadtypes(c->index);
    01247   }
    01248
    01249   if (!IsSavegameVersionBefore(27)) AfterLoadStations();
    01250
    01251   /* Time starts at 0 instead of 1920.
    01252    * Account for this in older games by adding an offset */
    01253   if (IsSavegameVersionBefore(31)) {
    01254     Station *st;
    01255     Waypoint *wp;
    01256     Engine *e;
    01257     Industry *i;
    01258     Vehicle *v;
    01259
    01260     _date += DAYS_TILL_ORIGINAL_BASE_YEAR;
    01261     _cur_year += ORIGINAL_BASE_YEAR;
    01262
    01263     FOR_ALL_STATIONS(st)  st->build_date      += DAYS_TILL_ORIGINAL_BASE_YEAR;
    01264     FOR_ALL_WAYPOINTS(wp) wp->build_date      += DAYS_TILL_ORIGINAL_BASE_YEAR;
    01265     FOR_ALL_ENGINES(e)    e->intro_date       += DAYS_TILL_ORIGINAL_BASE_YEAR;
    01266     FOR_ALL_COMPANIES(c)  c->inaugurated_year += ORIGINAL_BASE_YEAR;
    01267     FOR_ALL_INDUSTRIES(i) i->last_prod_year   += ORIGINAL_BASE_YEAR;
    01268
    01269     FOR_ALL_VEHICLES(v) {
    01270       v->date_of_last_service += DAYS_TILL_ORIGINAL_BASE_YEAR;
    01271       v->build_year += ORIGINAL_BASE_YEAR;
    01272     }
    01273   }
    01274
    01275   /* From 32 on we save the industry who made the farmland.
    01276    *  To give this prettyness to old savegames, we remove all farmfields and
    01277    *  plant new ones. */
    01278   if (IsSavegameVersionBefore(32)) {
    01279     Industry *i;
    01280
    01281     for (TileIndex t = 0; t < map_size; t++) {
    01282       if (IsTileType(t, MP_CLEAR) && IsClearGround(t, CLEAR_FIELDS)) {
    01283         /* remove fields */
    01284         MakeClear(t, CLEAR_GRASS, 3);
    01285       }
    01286     }
    01287
    01288     FOR_ALL_INDUSTRIES(i) {
    01289       uint j;
    01290
    01291       if (GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_PLANT_ON_BUILT) {
    01292         for (j = 0; j != 50; j++) PlantRandomFarmField(i);
    01293       }
    01294     }
    01295   }
    01296
    01297   /* Setting no refit flags to all orders in savegames from before refit in orders were added */
    01298   if (IsSavegameVersionBefore(36)) {
    01299     Order *order;
    01300     Vehicle *v;
    01301
    01302     FOR_ALL_ORDERS(order) {
    01303       order->SetRefit(CT_NO_REFIT);
    01304     }
    01305
    01306     FOR_ALL_VEHICLES(v) {
    01307       v->current_order.SetRefit(CT_NO_REFIT);
    01308     }
    01309   }
    01310
    01311   /* from version 38 we have optional elrails, since we cannot know the
    01312    * preference of a user, let elrails enabled; it can be disabled manually */
    01313   if (IsSavegameVersionBefore(38)) _settings_game.vehicle.disable_elrails = false;
    01314   /* do the same as when elrails were enabled/disabled manually just now */
    01315   SettingsDisableElrail(_settings_game.vehicle.disable_elrails);
    01316   InitializeRailGUI();
    01317
    01318   /* From version 53, the map array was changed for house tiles to allow
    01319    * space for newhouses grf features. A new byte, m7, was also added. */
    01320   if (IsSavegameVersionBefore(53)) {
    01321     for (TileIndex t = 0; t < map_size; t++) {
    01322       if (IsTileType(t, MP_HOUSE)) {
    01323         if (GB(_m[t].m3, 6, 2) != TOWN_HOUSE_COMPLETED) {
    01324           /* Move the construction stage from m3[7..6] to m5[5..4].
    01325            * The construction counter does not have to move. */
    01326           SB(_m[t].m5, 3, 2, GB(_m[t].m3, 6, 2));
    01327           SB(_m[t].m3, 6, 2, 0);
    01328
    01329           /* The "house is completed" bit is now in m6[2]. */
    01330           SetHouseCompleted(t, false);
    01331         } else {
    01332           /* The "lift has destination" bit has been moved from
    01333            * m5[7] to m7[0]. */
    01334           SB(_me[t].m7, 0, 1, HasBit(_m[t].m5, 7));
    01335           ClrBit(_m[t].m5, 7);
    01336
    01337           /* The "lift is moving" bit has been removed, as it does
    01338            * the same job as the "lift has destination" bit. */
    01339           ClrBit(_m[t].m1, 7);
    01340
    01341           /* The position of the lift goes from m1[7..0] to m6[7..2],
    01342            * making m1 totally free, now. The lift position does not
    01343            * have to be a full byte since the maximum value is 36. */
    01344           SetLiftPosition(t, GB(_m[t].m1, 0, 6 ));
    01345
    01346           _m[t].m1 = 0;
    01347           _m[t].m3 = 0;
    01348           SetHouseCompleted(t, true);
    01349         }
    01350       }
    01351     }
    01352   }
    01353
    01354   /* Check and update house and town values */
    01355   UpdateHousesAndTowns();
    01356
    01357   if (IsSavegameVersionBefore(43)) {
    01358     for (TileIndex t = 0; t < map_size; t++) {
    01359       if (IsTileType(t, MP_INDUSTRY)) {
    01360         switch (GetIndustryGfx(t)) {
    01361           case GFX_POWERPLANT_SPARKS:
    01362             _m[t].m3 = GB(_m[t].m1, 2, 5);
    01363             break;
    01364
    01365           case GFX_OILWELL_ANIMATED_1:
    01366           case GFX_OILWELL_ANIMATED_2:
    01367           case GFX_OILWELL_ANIMATED_3:
    01368             _m[t].m3 = GB(_m[t].m1, 0, 2);
    01369             break;
    01370
    01371           case GFX_COAL_MINE_TOWER_ANIMATED:
    01372           case GFX_COPPER_MINE_TOWER_ANIMATED:
    01373           case GFX_GOLD_MINE_TOWER_ANIMATED:
    01374              _m[t].m3 = _m[t].m1;
    01375              break;
    01376
    01377           default: // No animation states to change
    01378             break;
    01379         }
    01380       }
    01381     }
    01382   }
    01383
    01384   if (IsSavegameVersionBefore(45)) {
    01385     Vehicle *v;
    01386     /* Originally just the fact that some cargo had been paid for was
    01387      * stored to stop people cheating and cashing in several times. This
    01388      * wasn't enough though as it was cleared when the vehicle started
    01389      * loading again, even if it didn't actually load anything, so now the
    01390      * amount that has been paid is stored. */
    01391     FOR_ALL_VEHICLES(v) {
    01392       ClrBit(v->vehicle_flags, 2);
    01393     }
    01394   }
    01395
    01396   /* Buoys do now store the owner of the previous water tile, which can never
    01397    * be OWNER_NONE. So replace OWNER_NONE with OWNER_WATER. */
    01398   if (IsSavegameVersionBefore(46)) {
    01399     Waypoint *wp;
    01400     FOR_ALL_WAYPOINTS(wp) {
    01401       if ((wp->facilities & FACIL_DOCK) != 0 && IsTileOwner(wp->xy, OWNER_NONE) && TileHeight(wp->xy) == 0) SetTileOwner(wp->xy, OWNER_WATER);
    01402     }
    01403   }
    01404
    01405   if (IsSavegameVersionBefore(50)) {
    01406     Aircraft *v;
    01407     /* Aircraft units changed from 8 mph to 1 km-ish/h */
    01408     FOR_ALL_AIRCRAFT(v) {
    01409       if (v->subtype <= AIR_AIRCRAFT) {
    01410         const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);
    01411         v->cur_speed *= 128;
    01412         v->cur_speed /= 10;
    01413         v->acceleration = avi->acceleration;
    01414       }
    01415     }
    01416   }
    01417
    01418   if (IsSavegameVersionBefore(49)) FOR_ALL_COMPANIES(c) c->face = ConvertFromOldCompanyManagerFace(c->face);
    01419
    01420   if (IsSavegameVersionBefore(52)) {
    01421     for (TileIndex t = 0; t < map_size; t++) {
    01422       if (IsStatueTile(t)) {
    01423         _m[t].m2 = CalcClosestTownFromTile(t)->index;
    01424       }
    01425     }
    01426   }
    01427
    01428   /* A setting containing the proportion of towns that grow twice as
    01429    * fast was added in version 54. From version 56 this is now saved in the
    01430    * town as cities can be built specifically in the scenario editor. */
    01431   if (IsSavegameVersionBefore(56)) {
    01432     Town *t;
    01433
    01434     FOR_ALL_TOWNS(t) {
    01435       if (_settings_game.economy.larger_towns != 0 && (t->index % _settings_game.economy.larger_towns) == 0) {
    01436         t->larger_town = true;
    01437       }
    01438     }
    01439   }
    01440
    01441   if (IsSavegameVersionBefore(57)) {
    01442     Vehicle *v;
    01443     /* Added a FIFO queue of vehicles loading at stations */
    01444     FOR_ALL_VEHICLES(v) {
    01445       if ((v->type != VEH_TRAIN || Train::From(v)->IsFrontEngine()) &&  // for all locs
    01446           !(v->vehstatus & (VS_STOPPED | VS_CRASHED)) && // not stopped or crashed
    01447           v->current_order.IsType(OT_LOADING)) {         // loading
    01448         Station::Get(v->last_station_visited)->loading_vehicles.push_back(v);
    01449
    01450         /* The loading finished flag is *only* set when actually completely
    01451          * finished. Because the vehicle is loading, it is not finished. */
    01452         ClrBit(v->vehicle_flags, VF_LOADING_FINISHED);
    01453       }
    01454     }
    01455   } else if (IsSavegameVersionBefore(59)) {
    01456     /* For some reason non-loading vehicles could be in the station's loading vehicle list */
    01457
    01458     Station *st;
    01459     FOR_ALL_STATIONS(st) {
    01460       std::list<Vehicle *>::iterator iter;
    01461       for (iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end();) {
    01462         Vehicle *v = *iter;
    01463         iter++;
    01464         if (!v->current_order.IsType(OT_LOADING)) st->loading_vehicles.remove(v);
    01465       }
    01466     }
    01467   }
    01468
    01469   if (IsSavegameVersionBefore(58)) {
    01470     /* Setting difficulty industry_density other than zero get bumped to +1
    01471      * since a new option (very low at position 1) has been added */
    01472     if (_settings_game.difficulty.industry_density > 0) {
    01473       _settings_game.difficulty.industry_density++;
    01474     }
    01475
    01476     /* Same goes for number of towns, although no test is needed, just an increment */
    01477     _settings_game.difficulty.number_towns++;
    01478   }
    01479
    01480   if (IsSavegameVersionBefore(64)) {
    01481     /* copy the signal type/variant and move signal states bits */
    01482     for (TileIndex t = 0; t < map_size; t++) {
    01483       if (IsTileType(t, MP_RAILWAY) && HasSignals(t)) {
    01484         SetSignalStates(t, GB(_m[t].m2, 4, 4));
    01485         SetSignalVariant(t, INVALID_TRACK, GetSignalVariant(t, TRACK_X));
    01486         SetSignalType(t, INVALID_TRACK, GetSignalType(t, TRACK_X));
    01487         ClrBit(_m[t].m2, 7);
    01488       }
    01489     }
    01490   }
    01491
    01492   if (IsSavegameVersionBefore(69)) {
    01493     /* In some old savegames a bit was cleared when it should not be cleared */
    01494     RoadVehicle *rv;
    01495     FOR_ALL_ROADVEHICLES(rv) {
    01496       if (rv->state == 250 || rv->state == 251) {
    01497         SetBit(rv->state, 2);
    01498       }
    01499     }
    01500   }
    01501
    01502   if (IsSavegameVersionBefore(70)) {
    01503     /* Added variables to support newindustries */
    01504     Industry *i;
    01505     FOR_ALL_INDUSTRIES(i) i->founder = OWNER_NONE;
    01506   }
    01507
    01508   /* From version 82, old style canals (above sealevel (0), WATER owner) are no longer supported.
    01509       Replace the owner for those by OWNER_NONE. */
    01510   if (IsSavegameVersionBefore(82)) {
    01511     for (TileIndex t = 0; t < map_size; t++) {
    01512       if (IsTileType(t, MP_WATER) &&
    01513           GetWaterTileType(t) == WATER_TILE_CLEAR &&
    01514           GetTileOwner(t) == OWNER_WATER &&
    01515           TileHeight(t) != 0) {
    01516         SetTileOwner(t, OWNER_NONE);
    01517       }
    01518     }
    01519   }
    01520
    01521   /*
    01522    * Add the 'previous' owner to the ship depots so we can reset it with
    01523    * the correct values when it gets destroyed. This prevents that
    01524    * someone can remove canals owned by somebody else and it prevents
    01525    * making floods using the removal of ship depots.
    01526    */
    01527   if (IsSavegameVersionBefore(83)) {
    01528     for (TileIndex t = 0; t < map_size; t++) {
    01529       if (IsShipDepotTile(t)) {
    01530         _m[t].m4 = (TileHeight(t) == 0) ? OWNER_WATER : OWNER_NONE;
    01531       }
    01532     }
    01533   }
    01534
    01535   if (IsSavegameVersionBefore(74)) {
    01536     Station *st;
    01537     FOR_ALL_STATIONS(st) {
    01538       for (CargoID c = 0; c < NUM_CARGO; c++) {
    01539         st->goods[c].last_speed = 0;
    01540         if (st->goods[c].cargo.Count() != 0) SetBit(st->goods[c].acceptance_pickup, GoodsEntry::GES_PICKUP);
    01541       }
    01542     }
    01543   }
    01544
    01545   if (IsSavegameVersionBefore(78)) {
    01546     Industry *i;
    01547     uint j;
    01548     FOR_ALL_INDUSTRIES(i) {
    01549       const IndustrySpec *indsp = GetIndustrySpec(i->type);
    01550       for (j = 0; j < lengthof(i->produced_cargo); j++) {
    01551         i->produced_cargo[j] = indsp->produced_cargo[j];
    01552       }
    01553       for (j = 0; j < lengthof(i->accepts_cargo); j++) {
    01554         i->accepts_cargo[j] = indsp->accepts_cargo[j];
    01555       }
    01556     }
    01557   }
    01558
    01559   /* Before version 81, the density of grass was always stored as zero, and
    01560    * grassy trees were always drawn fully grassy. Furthermore, trees on rough
    01561    * land used to have zero density, now they have full density. Therefore,
    01562    * make all grassy/rough land trees have a density of 3. */
    01563   if (IsSavegameVersionBefore(81)) {
    01564     for (TileIndex t = 0; t < map_size; t++) {
    01565       if (GetTileType(t) == MP_TREES) {
    01566         TreeGround groundType = (TreeGround)GB(_m[t].m2, 4, 2);
    01567         if (groundType != TREE_GROUND_SNOW_DESERT) SB(_m[t].m2, 6, 2, 3);
    01568       }
    01569     }
    01570   }
    01571
    01572
    01573   if (IsSavegameVersionBefore(93)) {
    01574     /* Rework of orders. */
    01575     Order *order;
    01576     FOR_ALL_ORDERS(order) order->ConvertFromOldSavegame();
    01577
    01578     Vehicle *v;
    01579     FOR_ALL_VEHICLES(v) {
    01580       if (v->orders.list != NULL && v->orders.list->GetFirstOrder() != NULL && v->orders.list->GetFirstOrder()->IsType(OT_NOTHING)) {
    01581         v->orders.list->FreeChain();
    01582         v->orders.list = NULL;
    01583       }
    01584
    01585       v->current_order.ConvertFromOldSavegame();
    01586       if (v->type == VEH_ROAD && v->IsPrimaryVehicle() && v->FirstShared() == v) {
    01587         FOR_VEHICLE_ORDERS(v, order) order->SetNonStopType(ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS);
    01588       }
    01589     }
    01590   } else if (IsSavegameVersionBefore(94)) {
    01591     /* Unload and transfer are now mutual exclusive. */
    01592     Order *order;
    01593     FOR_ALL_ORDERS(order) {
    01594       if ((order->GetUnloadType() & (OUFB_UNLOAD | OUFB_TRANSFER)) == (OUFB_UNLOAD | OUFB_TRANSFER)) {
    01595         order->SetUnloadType(OUFB_TRANSFER);
    01596         order->SetLoadType(OLFB_NO_LOAD);
    01597       }
    01598     }
    01599
    01600     Vehicle *v;
    01601     FOR_ALL_VEHICLES(v) {
    01602       if ((v->current_order.GetUnloadType() & (OUFB_UNLOAD | OUFB_TRANSFER)) == (OUFB_UNLOAD | OUFB_TRANSFER)) {
    01603         v->current_order.SetUnloadType(OUFB_TRANSFER);
    01604         v->current_order.SetLoadType(OLFB_NO_LOAD);
    01605       }
    01606     }
    01607   }
    01608
    01609   if (IsSavegameVersionBefore(84)) {
    01610     /* Set all share owners to INVALID_COMPANY for
    01611      * 1) all inactive companies
    01612      *     (when inactive companies were stored in the savegame - TTD, TTDP and some
    01613      *      *really* old revisions of OTTD; else it is already set in InitializeCompanies())
    01614      * 2) shares that are owned by inactive companies or self
    01615      *     (caused by cheating clients in earlier revisions) */
    01616     FOR_ALL_COMPANIES(c) {
    01617       for (uint i = 0; i < 4; i++) {
    01618         CompanyID company = c->share_owners[i];
    01619         if (company == INVALID_COMPANY) continue;
    01620         if (!Company::IsValidID(company) || company == c->index) c->share_owners[i] = INVALID_COMPANY;
    01621       }
    01622     }
    01623   }
    01624
    01625   /* The water class was moved/unified. */
    01626   if (IsSavegameVersionBefore(146)) {
    01627     for (TileIndex t = 0; t < map_size; t++) {
    01628       switch (GetTileType(t)) {
    01629         case MP_STATION:
    01630           switch (GetStationType(t)) {
    01631             case STATION_OILRIG:
    01632             case STATION_DOCK:
    01633             case STATION_BUOY:
    01634               SetWaterClass(t, (WaterClass)GB(_m[t].m3, 0, 2));
    01635               SB(_m[t].m3, 0, 2, 0);
    01636               break;
    01637
    01638             default:
    01639               SetWaterClass(t, WATER_CLASS_INVALID);
    01640               break;
    01641           }
    01642           break;
    01643
    01644         case MP_WATER:
    01645           SetWaterClass(t, (WaterClass)GB(_m[t].m3, 0, 2));
    01646           SB(_m[t].m3, 0, 2, 0);
    01647           break;
    01648
    01649         case MP_OBJECT:
    01650           SetWaterClass(t, WATER_CLASS_INVALID);
    01651           break;
    01652
    01653         default:
    01654           /* No water class. */
    01655           break;
    01656       }
    01657     }
    01658   }
    01659
    01660   if (IsSavegameVersionBefore(86)) {
    01661     for (TileIndex t = 0; t < map_size; t++) {
    01662       /* Move river flag and update canals to use water class */
    01663       if (IsTileType(t, MP_WATER)) {
    01664         if (GetWaterClass(t) != WATER_CLASS_RIVER) {
    01665           if (IsWater(t)) {
    01666             Owner o = GetTileOwner(t);
    01667             if (o == OWNER_WATER) {
    01668               MakeSea(t);
    01669             } else {
    01670               MakeCanal(t, o, Random());
    01671             }
    01672           } else if (IsShipDepot(t)) {
    01673             Owner o = (Owner)_m[t].m4; // Original water owner
    01674             SetWaterClass(t, o == OWNER_WATER ? WATER_CLASS_SEA : WATER_CLASS_CANAL);
    01675           }
    01676         }
    01677       }
    01678     }
    01679
    01680     /* Update locks, depots, docks and buoys to have a water class based
    01681      * on its neighbouring tiles. Done after river and canal updates to
    01682      * ensure neighbours are correct. */
    01683     for (TileIndex t = 0; t < map_size; t++) {
    01684       if (GetTileSlope(t) != SLOPE_FLAT) continue;
    01685
    01686       if (IsTileType(t, MP_WATER) && IsLock(t)) SetWaterClassDependingOnSurroundings(t, false);
    01687       if (IsTileType(t, MP_STATION) && (IsDock(t) || IsBuoy(t))) SetWaterClassDependingOnSurroundings(t, false);
    01688     }
    01689   }
    01690
    01691   if (IsSavegameVersionBefore(87)) {
    01692     for (TileIndex t = 0; t < map_size; t++) {
    01693       /* skip oil rigs at borders! */
    01694       if ((IsTileType(t, MP_WATER) || IsBuoyTile(t)) &&
    01695           (TileX(t) == 0 || TileY(t) == 0 || TileX(t) == MapMaxX() - 1 || TileY(t) == MapMaxY() - 1)) {
    01696         /* Some version 86 savegames have wrong water class at map borders (under buoy, or after removing buoy).
    01697          * This conversion has to be done before buoys with invalid owner are removed. */
    01698         SetWaterClass(t, WATER_CLASS_SEA);
    01699       }
    01700
    01701       if (IsBuoyTile(t) || IsDriveThroughStopTile(t) || IsTileType(t, MP_WATER)) {
    01702         Owner o = GetTileOwner(t);
    01703         if (o < MAX_COMPANIES && !Company::IsValidID(o)) {
    01704           Backup<CompanyByte> cur_company(_current_company, o, FILE_LINE);
    01705           ChangeTileOwner(t, o, INVALID_OWNER);
    01706           cur_company.Restore();
    01707         }
    01708         if (IsBuoyTile(t)) {
    01709           /* reset buoy owner to OWNER_NONE in the station struct
    01710            * (even if it is owned by active company) */
    01711           Waypoint::GetByTile(t)->owner = OWNER_NONE;
    01712         }
    01713       } else if (IsTileType(t, MP_ROAD)) {
    01714         /* works for all RoadTileType */
    01715         for (RoadType rt = ROADTYPE_ROAD; rt < ROADTYPE_END; rt++) {
    01716           /* update even non-existing road types to update tile owner too */
    01717           Owner o = GetRoadOwner(t, rt);
    01718           if (o < MAX_COMPANIES && !Company::IsValidID(o)) SetRoadOwner(t, rt, OWNER_NONE);
    01719         }
    01720         if (IsLevelCrossing(t)) {
    01721           if (!Company::IsValidID(GetTileOwner(t))) FixOwnerOfRailTrack(t);
    01722         }
    01723       } else if (IsPlainRailTile(t)) {
    01724         if (!Company::IsValidID(GetTileOwner(t))) FixOwnerOfRailTrack(t);
    01725       }
    01726     }
    01727
    01728     /* Convert old PF settings to new */
    01729     if (_settings_game.pf.yapf.rail_use_yapf || IsSavegameVersionBefore(28)) {
    01730       _settings_game.pf.pathfinder_for_trains = VPF_YAPF;
    01731     } else {
    01732       _settings_game.pf.pathfinder_for_trains = VPF_NPF;
    01733     }
    01734
    01735     if (_settings_game.pf.yapf.road_use_yapf || IsSavegameVersionBefore(28)) {
    01736       _settings_game.pf.pathfinder_for_roadvehs = VPF_YAPF;
    01737     } else {
    01738       _settings_game.pf.pathfinder_for_roadvehs = VPF_NPF;
    01739     }
    01740
    01741     if (_settings_game.pf.yapf.ship_use_yapf) {
    01742       _settings_game.pf.pathfinder_for_ships = VPF_YAPF;
    01743     } else {
    01744       _settings_game.pf.pathfinder_for_ships = (_settings_game.pf.new_pathfinding_all ? VPF_NPF : VPF_OPF);
    01745     }
    01746   }
    01747
    01748   if (IsSavegameVersionBefore(88)) {
    01749     /* Profits are now with 8 bit fract */
    01750     Vehicle *v;
    01751     FOR_ALL_VEHICLES(v) {
    01752       v->profit_this_year <<= 8;
    01753       v->profit_last_year <<= 8;
    01754       v->running_ticks = 0;
    01755     }
    01756   }
    01757
    01758   if (IsSavegameVersionBefore(91)) {
    01759     /* Increase HouseAnimationFrame from 5 to 7 bits */
    01760     for (TileIndex t = 0; t < map_size; t++) {
    01761       if (IsTileType(t, MP_HOUSE) && GetHouseType(t) >= NEW_HOUSE_OFFSET) {
    01762         SB(_m[t].m6, 2, 6, GB(_m[t].m6, 3, 5));
    01763         SB(_m[t].m3, 5, 1, 0);
    01764       }
    01765     }
    01766   }
    01767
    01768   if (IsSavegameVersionBefore(62)) {
    01769     /* Remove all trams from savegames without tram support.
    01770      * There would be trams without tram track under causing crashes sooner or later. */
    01771     RoadVehicle *v;
    01772     FOR_ALL_ROADVEHICLES(v) {
    01773       if (v->First() == v && HasBit(EngInfo(v->engine_type)->misc_flags, EF_ROAD_TRAM)) {
    01774         ShowErrorMessage(STR_WARNING_LOADGAME_REMOVED_TRAMS, INVALID_STRING_ID, WL_CRITICAL);
    01775         delete v;
    01776       }
    01777     }
    01778   }
    01779
    01780   if (IsSavegameVersionBefore(99)) {
    01781     for (TileIndex t = 0; t < map_size; t++) {
    01782       /* Set newly introduced WaterClass of industry tiles */
    01783       if (IsTileType(t, MP_STATION) && IsOilRig(t)) {
    01784         SetWaterClassDependingOnSurroundings(t, true);
    01785       }
    01786       if (IsTileType(t, MP_INDUSTRY)) {
    01787         if ((GetIndustrySpec(GetIndustryType(t))->behaviour & INDUSTRYBEH_BUILT_ONWATER) != 0) {
    01788           SetWaterClassDependingOnSurroundings(t, true);
    01789         } else {
    01790           SetWaterClass(t, WATER_CLASS_INVALID);
    01791         }
    01792       }
    01793
    01794       /* Replace "house construction year" with "house age" */
    01795       if (IsTileType(t, MP_HOUSE) && IsHouseCompleted(t)) {
    01796         _m[t].m5 = Clamp(_cur_year - (_m[t].m5 + ORIGINAL_BASE_YEAR), 0, 0xFF);
    01797       }
    01798     }
    01799   }
    01800
    01801   /* Move the signal variant back up one bit for PBS. We don't convert the old PBS
    01802    * format here, as an old layout wouldn't work properly anyway. To be safe, we
    01803    * clear any possible PBS reservations as well. */
    01804   if (IsSavegameVersionBefore(100)) {
    01805     for (TileIndex t = 0; t < map_size; t++) {
    01806       switch (GetTileType(t)) {
    01807         case MP_RAILWAY:
    01808           if (HasSignals(t)) {
    01809             /* move the signal variant */
    01810             SetSignalVariant(t, TRACK_UPPER, HasBit(_m[t].m2, 2) ? SIG_SEMAPHORE : SIG_ELECTRIC);
    01811             SetSignalVariant(t, TRACK_LOWER, HasBit(_m[t].m2, 6) ? SIG_SEMAPHORE : SIG_ELECTRIC);
    01812             ClrBit(_m[t].m2, 2);
    01813             ClrBit(_m[t].m2, 6);
    01814           }
    01815
    01816           /* Clear PBS reservation on track */
    01817           if (IsRailDepot(t)) {
    01818             SetDepotReservation(t, false);
    01819           } else {
    01820             SetTrackReservation(t, TRACK_BIT_NONE);
    01821           }
    01822           break;
    01823
    01824         case MP_ROAD: // Clear PBS reservation on crossing
    01825           if (IsLevelCrossing(t)) SetCrossingReservation(t, false);
    01826           break;
    01827
    01828         case MP_STATION: // Clear PBS reservation on station
    01829           if (HasStationRail(t)) SetRailStationReservation(t, false);
    01830           break;
    01831
    01832         case MP_TUNNELBRIDGE: // Clear PBS reservation on tunnels/birdges
    01833           if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) SetTunnelBridgeReservation(t, false);
    01834           break;
    01835
    01836         default: break;
    01837       }
    01838     }
    01839   }
    01840
    01841   /* Reserve all tracks trains are currently on. */
    01842   if (IsSavegameVersionBefore(101)) {
    01843     const Train *t;
    01844     FOR_ALL_TRAINS(t) {
    01845       if (t->First() == t) t->ReserveTrackUnderConsist();
    01846     }
    01847   }
    01848
    01849   if (IsSavegameVersionBefore(102)) {
    01850     for (TileIndex t = 0; t < map_size; t++) {
    01851       /* Now all crossings should be in correct state */
    01852       if (IsLevelCrossingTile(t)) UpdateLevelCrossing(t, false);
    01853     }
    01854   }
    01855
    01856   if (IsSavegameVersionBefore(103)) {
    01857     /* Non-town-owned roads now store the closest town */
    01858     UpdateNearestTownForRoadTiles(false);
    01859
    01860     /* signs with invalid owner left from older savegames */
    01861     Sign *si;
    01862     FOR_ALL_SIGNS(si) {
    01863       if (si->owner != OWNER_NONE && !Company::IsValidID(si->owner)) si->owner = OWNER_NONE;
    01864     }
    01865
    01866     /* Station can get named based on an industry type, but the current ones
    01867      * are not, so mark them as if they are not named by an industry. */
    01868     Station *st;
    01869     FOR_ALL_STATIONS(st) {
    01870       st->indtype = IT_INVALID;
    01871     }
    01872   }
    01873
    01874   if (IsSavegameVersionBefore(104)) {
    01875     Aircraft *a;
    01876     FOR_ALL_AIRCRAFT(a) {
    01877       /* Set engine_type of shadow and rotor */
    01878       if (!a->IsNormalAircraft()) {
    01879         a->engine_type = a->First()->engine_type;
    01880       }
    01881     }
    01882
    01883     /* More companies ... */
    01884     Company *c;
    01885     FOR_ALL_COMPANIES(c) {
    01886       if (c->bankrupt_asked == 0xFF) c->bankrupt_asked = 0xFFFF;
    01887     }
    01888
    01889     Engine *e;
    01890     FOR_ALL_ENGINES(e) {
    01891       if (e->company_avail == 0xFF) e->company_avail = 0xFFFF;
    01892     }
    01893
    01894     Town *t;
    01895     FOR_ALL_TOWNS(t) {
    01896       if (t->have_ratings == 0xFF) t->have_ratings = 0xFFFF;
    01897       for (uint i = 8; i != MAX_COMPANIES; i++) t->ratings[i] = RATING_INITIAL;
    01898     }
    01899   }
    01900
    01901   if (IsSavegameVersionBefore(112)) {
    01902     for (TileIndex t = 0; t < map_size; t++) {
    01903       /* Check for HQ bit being set, instead of using map accessor,
    01904        * since we've already changed it code-wise */
    01905       if (IsTileType(t, MP_OBJECT) && HasBit(_m[t].m5, 7)) {
    01906         /* Move size and part identification of HQ out of the m5 attribute,
    01907          * on new locations */
    01908         _m[t].m3 = GB(_m[t].m5, 0, 5);
    01909         _m[t].m5 = OBJECT_HQ;
    01910       }
    01911     }
    01912   }
    01913   if (IsSavegameVersionBefore(144)) {
    01914     for (TileIndex t = 0; t < map_size; t++) {
    01915       if (!IsTileType(t, MP_OBJECT)) continue;
    01916
    01917       /* Reordering/generalisation of the object bits. */
    01918       ObjectType type = GetObjectType(t);
    01919       SB(_m[t].m6, 2, 4, type == OBJECT_HQ ? GB(_m[t].m3, 2, 3) : 0);
    01920       _m[t].m3 = type == OBJECT_HQ ? GB(_m[t].m3, 1, 1) | GB(_m[t].m3, 0, 1) << 4 : 0;
    01921
    01922       /* Make sure those bits are clear as well! */
    01923       _m[t].m4 = 0;
    01924       _me[t].m7 = 0;
    01925     }
    01926   }
    01927
    01928   if (IsSavegameVersionBefore(147) && Object::GetNumItems() == 0) {
    01929     /* Make real objects for object tiles. */
    01930     for (TileIndex t = 0; t < map_size; t++) {
    01931       if (!IsTileType(t, MP_OBJECT)) continue;
    01932
    01933       if (Town::GetNumItems() == 0) {
    01934         /* No towns, so remove all objects! */
    01935         DoClearSquare(t);
    01936       } else {
    01937         uint offset = _m[t].m3;
    01938
    01939         /* Also move the animation state. */
    01940         _m[t].m3 = GB(_m[t].m6, 2, 4);
    01941         SB(_m[t].m6, 2, 4, 0);
    01942
    01943         if (offset == 0) {
    01944           /* No offset, so make the object. */
    01945           ObjectType type = GetObjectType(t);
    01946           int size = type == OBJECT_HQ ? 2 : 1;
    01947
    01948           if (!Object::CanAllocateItem()) {
    01949             /* Nice... you managed to place 64k lighthouses and
    01950              * antennae on the map... boohoo. */
    01951             SlError(STR_ERROR_TOO_MANY_OBJECTS);
    01952           }
    01953
    01954           Object *o = new Object();
    01955           o->location.tile = t;
    01956           o->location.w    = size;
    01957           o->location.h    = size;
    01958           o->build_date    = _date;
    01959           o->town          = type == OBJECT_STATUE ? Town::Get(_m[t].m2) : CalcClosestTownFromTile(t, UINT_MAX);
    01960           _m[t].m2 = o->index;
    01961           Object::IncTypeCount(type);
    01962         } else {
    01963           /* We're at an offset, so get the ID from our "root". */
    01964           TileIndex northern_tile = t - TileXY(GB(offset, 0, 4), GB(offset, 4, 4));
    01965           assert(IsTileType(northern_tile, MP_OBJECT));
    01966           _m[t].m2 = _m[northern_tile].m2;
    01967         }
    01968       }
    01969     }
    01970   }
    01971
    01972   if (IsSavegameVersionBefore(113)) {
    01973     /* allow_town_roads is added, set it if town_layout wasn't TL_NO_ROADS */
    01974     if (_settings_game.economy.town_layout == 0) { // was TL_NO_ROADS
    01975       _settings_game.economy.allow_town_roads = false;
    01976       _settings_game.economy.town_layout = TL_BETTER_ROADS;
    01977     } else {
    01978       _settings_game.economy.allow_town_roads = true;
    01979       _settings_game.economy.town_layout = _settings_game.economy.town_layout - 1;
    01980     }
    01981
    01982     /* Initialize layout of all towns. Older versions were using different
    01983      * generator for random town layout, use it if needed. */
    01984     Town *t;
    01985     FOR_ALL_TOWNS(t) {
    01986       if (_settings_game.economy.town_layout != TL_RANDOM) {
    01987         t->layout = _settings_game.economy.town_layout;
    01988         continue;
    01989       }
    01990
    01991       /* Use old layout randomizer code */
    01992       byte layout = TileHash(TileX(t->xy), TileY(t->xy)) % 6;
    01993       switch (layout) {
    01994         default: break;
    01995         case 5: layout = 1; break;
    01996         case 0: layout = 2; break;
    01997       }
    01998       t->layout = layout - 1;
    01999     }
    02000   }
    02001
    02002   if (IsSavegameVersionBefore(114)) {
    02003     /* There could be (deleted) stations with invalid owner, set owner to OWNER NONE.
    02004      * The conversion affects oil rigs and buoys too, but it doesn't matter as
    02005      * they have st->owner == OWNER_NONE already. */
    02006     Station *st;
    02007     FOR_ALL_STATIONS(st) {
    02008       if (!Company::IsValidID(st->owner)) st->owner = OWNER_NONE;
    02009     }
    02010   }
    02011
    02012   /* Trains could now stop in a specific location. */
    02013   if (IsSavegameVersionBefore(117)) {
    02014     Order *o;
    02015     FOR_ALL_ORDERS(o) {
    02016       if (o->IsType(OT_GOTO_STATION)) o->SetStopLocation(OSL_PLATFORM_FAR_END);
    02017     }
    02018   }
    02019
    02020   if (IsSavegameVersionBefore(120)) {
    02021     extern VehicleDefaultSettings _old_vds;
    02022     Company *c;
    02023     FOR_ALL_COMPANIES(c) {
    02024       c->settings.vehicle = _old_vds;
    02025     }
    02026   }
    02027
    02028   if (IsSavegameVersionBefore(121)) {
    02029     /* Delete small ufos heading for non-existing vehicles */
    02030     Vehicle *v;
    02031     FOR_ALL_DISASTERVEHICLES(v) {
    02032       if (v->subtype == 2/*ST_SMALL_UFO*/ && v->current_order.GetDestination() != 0) {
    02033         const Vehicle *u = Vehicle::GetIfValid(v->dest_tile);
    02034         if (u == NULL || u->type != VEH_ROAD || !RoadVehicle::From(u)->IsFrontEngine()) {
    02035           delete v;
    02036         }
    02037       }
    02038     }
    02039
    02040     /* We didn't store cargo payment yet, so make them for vehicles that are
    02041      * currently at a station and loading/unloading. If they don't get any
    02042      * payment anymore they just removed in the next load/unload cycle.
    02043      * However, some 0.7 versions might have cargo payment. For those we just
    02044      * add cargopayment for the vehicles that don't have it.
    02045      */
    02046     Station *st;
    02047     FOR_ALL_STATIONS(st) {
    02048       std::list<Vehicle *>::iterator iter;
    02049       for (iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end(); ++iter) {
    02050         /* There are always as many CargoPayments as Vehicles. We need to make the
    02051          * assert() in Pool::GetNew() happy by calling CanAllocateItem(). */
    02052         assert_compile(CargoPaymentPool::MAX_SIZE == VehiclePool::MAX_SIZE);
    02053         assert(CargoPayment::CanAllocateItem());
    02054         Vehicle *v = *iter;
    02055         if (v->cargo_payment == NULL) v->cargo_payment = new CargoPayment(v);
    02056       }
    02057     }
    02058   }
    02059
    02060   if (IsSavegameVersionBefore(122)) {
    02061     /* Animated tiles would sometimes not be actually animated or
    02062      * in case of old savegames duplicate. */
    02063
    02064     extern TileIndex *_animated_tile_list;
    02065     extern uint _animated_tile_count;
    02066
    02067     for (uint i = 0; i < _animated_tile_count; /* Nothing */) {
    02068       /* Remove if tile is not animated */
    02069       bool remove = _tile_type_procs[GetTileType(_animated_tile_list[i])]->animate_tile_proc == NULL;
    02070
    02071       /* and remove if duplicate */
    02072       for (uint j = 0; !remove && j < i; j++) {
    02073         remove = _animated_tile_list[i] == _animated_tile_list[j];
    02074       }
    02075
    02076       if (remove) {
    02077         DeleteAnimatedTile(_animated_tile_list[i]);
    02078       } else {
    02079         i++;
    02080       }
    02081     }
    02082   }
    02083
    02084   if (IsSavegameVersionBefore(124) && !IsSavegameVersionBefore(1)) {
    02085     /* The train station tile area was added, but for really old (TTDPatch) it's already valid. */
    02086     Waypoint *wp;
    02087     FOR_ALL_WAYPOINTS(wp) {
    02088       if (wp->facilities & FACIL_TRAIN) {
    02089         wp->train_station.tile = wp->xy;
    02090         wp->train_station.w = 1;
    02091         wp->train_station.h = 1;
    02092       } else {
    02093         wp->train_station.tile = INVALID_TILE;
    02094         wp->train_station.w = 0;
    02095         wp->train_station.h = 0;
    02096       }
    02097     }
    02098   }
    02099
    02100   if (IsSavegameVersionBefore(125)) {
    02101     /* Convert old subsidies */
    02102     Subsidy *s;
    02103     FOR_ALL_SUBSIDIES(s) {
    02104       if (s->remaining < 12) {
    02105         /* Converting nonawarded subsidy */
    02106         s->remaining = 12 - s->remaining; // convert "age" to "remaining"
    02107         s->awarded = INVALID_COMPANY; // not awarded to anyone
    02108         const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
    02109         switch (cs->town_effect) {
    02110           case TE_PASSENGERS:
    02111           case TE_MAIL:
    02112             /* Town -> Town */
    02113             s->src_type = s->dst_type = ST_TOWN;
    02114             if (Town::IsValidID(s->src) && Town::IsValidID(s->dst)) continue;
    02115             break;
    02116           case TE_GOODS:
    02117           case TE_FOOD:
    02118             /* Industry -> Town */
    02119             s->src_type = ST_INDUSTRY;
    02120             s->dst_type = ST_TOWN;
    02121             if (Industry::IsValidID(s->src) && Town::IsValidID(s->dst)) continue;
    02122             break;
    02123           default:
    02124             /* Industry -> Industry */
    02125             s->src_type = s->dst_type = ST_INDUSTRY;
    02126             if (Industry::IsValidID(s->src) && Industry::IsValidID(s->dst)) continue;
    02127             break;
    02128         }
    02129       } else {
    02130         /* Do our best for awarded subsidies. The original source or destination industry
    02131          * can't be determined anymore for awarded subsidies, so invalidate them.
    02132          * Town -> Town subsidies are converted using simple heuristic */
    02133         s->remaining = 24 - s->remaining; // convert "age of awarded subsidy" to "remaining"
    02134         const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
    02135         switch (cs->town_effect) {
    02136           case TE_PASSENGERS:
    02137           case TE_MAIL: {
    02138             /* Town -> Town */
    02139             const Station *ss = Station::GetIfValid(s->src);
    02140             const Station *sd = Station::GetIfValid(s->dst);
    02141             if (ss != NULL && sd != NULL && ss->owner == sd->owner &&
    02142                 Company::IsValidID(ss->owner)) {
    02143               s->src_type = s->dst_type = ST_TOWN;
    02144               s->src = ss->town->index;
    02145               s->dst = sd->town->index;
    02146               s->awarded = ss->owner;
    02147               continue;
    02148             }
    02149             break;
    02150           }
    02151           default:
    02152             break;
    02153         }
    02154       }
    02155       /* Awarded non-town subsidy or invalid source/destination, invalidate */
    02156       delete s;
    02157     }
    02158   }
    02159
    02160   if (IsSavegameVersionBefore(126)) {
    02161     /* Recompute inflation based on old unround loan limit
    02162      * Note: Max loan is 500000. With an inflation of 4% across 170 years
    02163      *       that results in a max loan of about 0.7 * 2^31.
    02164      *       So taking the 16 bit fractional part into account there are plenty of bits left
    02165      *       for unmodified savegames ...
    02166      */
    02167     uint64 aimed_inflation = (_economy.old_max_loan_unround << 16 | _economy.old_max_loan_unround_fract) / _settings_game.difficulty.max_loan;
    02168
    02169     /* ... well, just clamp it then. */
    02170     if (aimed_inflation > MAX_INFLATION) aimed_inflation = MAX_INFLATION;
    02171
    02172     /* Simulate the inflation, so we also get the payment inflation */
    02173     while (_economy.inflation_prices < aimed_inflation) {
    02174       if (AddInflation(false)) break;
    02175     }
    02176   }
    02177
    02178   if (IsSavegameVersionBefore(127)) {
    02179     Station *st;
    02180     FOR_ALL_STATIONS(st) UpdateStationAcceptance(st, false);
    02181   }
    02182
    02183   if (IsSavegameVersionBefore(128)) {
    02184     const Depot *d;
    02185     FOR_ALL_DEPOTS(d) {
    02186       _m[d->xy].m2 = d->index;
    02187       if (IsTileType(d->xy, MP_WATER)) _m[GetOtherShipDepotTile(d->xy)].m2 = d->index;
    02188     }
    02189   }
    02190
    02191   /* The behaviour of force_proceed has been changed. Now
    02192    * it counts signals instead of some random time out. */
    02193   if (IsSavegameVersionBefore(131)) {
    02194     Train *t;
    02195     FOR_ALL_TRAINS(t) {
    02196       if (t->force_proceed != TFP_NONE) {
    02197         t->force_proceed = TFP_STUCK;
    02198       }
    02199     }
    02200   }
    02201
    02202   /* The bits for the tree ground and tree density have
    02203    * been swapped (m2 bits 7..6 and 5..4. */
    02204   if (IsSavegameVersionBefore(135)) {
    02205     for (TileIndex t = 0; t < map_size; t++) {
    02206       if (IsTileType(t, MP_CLEAR)) {
    02207         if (GetRawClearGround(t) == CLEAR_SNOW) {
    02208           SetClearGroundDensity(t, CLEAR_GRASS, GetClearDensity(t));
    02209           SetBit(_m[t].m3, 4);
    02210         } else {
    02211           ClrBit(_m[t].m3, 4);
    02212         }
    02213       }
    02214       if (IsTileType(t, MP_TREES)) {
    02215         uint density = GB(_m[t].m2, 6, 2);
    02216         uint ground = GB(_m[t].m2, 4, 2);
    02217         uint counter = GB(_m[t].m2, 0, 4);
    02218         _m[t].m2 = ground << 6 | density << 4 | counter;
    02219       }
    02220     }
    02221   }
    02222
    02223   /* Wait counter and load/unload ticks got split. */
    02224   if (IsSavegameVersionBefore(136)) {
    02225     Aircraft *a;
    02226     FOR_ALL_AIRCRAFT(a) {
    02227       a->turn_counter = a->current_order.IsType(OT_LOADING) ? 0 : a->load_unload_ticks;
    02228     }
    02229
    02230     Train *t;
    02231     FOR_ALL_TRAINS(t) {
    02232       t->wait_counter = t->current_order.IsType(OT_LOADING) ? 0 : t->load_unload_ticks;
    02233     }
    02234   }
    02235
    02236   /* Airport tile animation uses animation frame instead of other graphics id */
    02237   if (IsSavegameVersionBefore(137)) {
    02238     struct AirportTileConversion {
    02239       byte old_start;
    02240       byte num_frames;
    02241     };
    02242     static const AirportTileConversion atc[] = {
    02243       {31,  12}, // APT_RADAR_GRASS_FENCE_SW
    02244       {50,   4}, // APT_GRASS_FENCE_NE_FLAG
    02245       {62,   2}, // 1 unused tile
    02246       {66,  12}, // APT_RADAR_FENCE_SW
    02247       {78,  12}, // APT_RADAR_FENCE_NE
    02248       {101, 10}, // 9 unused tiles
    02249       {111,  8}, // 7 unused tiles
    02250       {119, 15}, // 14 unused tiles (radar)
    02251       {140,  4}, // APT_GRASS_FENCE_NE_FLAG_2
    02252     };
    02253     for (TileIndex t = 0; t < map_size; t++) {
    02254       if (IsAirportTile(t)) {
    02255         StationGfx old_gfx = GetStationGfx(t);
    02256         byte offset = 0;
    02257         for (uint i = 0; i < lengthof(atc); i++) {
    02258           if (old_gfx < atc[i].old_start) {
    02259             SetStationGfx(t, old_gfx - offset);
    02260             break;
    02261           }
    02262           if (old_gfx < atc[i].old_start + atc[i].num_frames) {
    02263             SetAnimationFrame(t, old_gfx - atc[i].old_start);
    02264             SetStationGfx(t, atc[i].old_start - offset);
    02265             break;
    02266           }
    02267           offset += atc[i].num_frames - 1;
    02268         }
    02269       }
    02270     }
    02271   }
    02272
    02273   if (IsSavegameVersionBefore(140)) {
    02274     Station *st;
    02275     FOR_ALL_STATIONS(st) {
    02276       if (st->airport.tile != INVALID_TILE) {
    02277         st->airport.w = st->airport.GetSpec()->size_x;
    02278         st->airport.h = st->airport.GetSpec()->size_y;
    02279       }
    02280     }
    02281   }
    02282
    02283   if (IsSavegameVersionBefore(141)) {
    02284     for (TileIndex t = 0; t < map_size; t++) {
    02285       /* Reset tropic zone for VOID tiles, they shall not have any. */
    02286       if (IsTileType(t, MP_VOID)) SetTropicZone(t, TROPICZONE_NORMAL);
    02287     }
    02288
    02289     /* We need to properly number/name the depots.
    02290      * The first step is making sure none of the depots uses the
    02291      * 'default' names, after that we can assign the names. */
    02292     Depot *d;
    02293     FOR_ALL_DEPOTS(d) d->town_cn = UINT16_MAX;
    02294
    02295     FOR_ALL_DEPOTS(d) MakeDefaultName(d);
    02296   }
    02297
    02298   if (IsSavegameVersionBefore(142)) {
    02299     Depot *d;
    02300     FOR_ALL_DEPOTS(d) d->build_date = _date;
    02301   }
    02302
    02303   /* In old versions it was possible to remove an airport while a plane was
    02304    * taking off or landing. This gives all kind of problems when building
    02305    * another airport in the same station so we don't allow that anymore.
    02306    * For old savegames with such aircraft we just throw them in the air and
    02307    * treat the aircraft like they were flying already. */
    02308   if (IsSavegameVersionBefore(146)) {
    02309     Aircraft *v;
    02310     FOR_ALL_AIRCRAFT(v) {
    02311       if (!v->IsNormalAircraft()) continue;
    02312       Station *st = GetTargetAirportIfValid(v);
    02313       if (st == NULL && v->state != FLYING) {
    02314         v->state = FLYING;
    02315         UpdateAircraftCache(v);
    02316         AircraftNextAirportPos_and_Order(v);
    02317         /* get aircraft back on running altitude */
    02318         if ((v->vehstatus & VS_CRASHED) == 0) SetAircraftPosition(v, v->x_pos, v->y_pos, GetAircraftFlyingAltitude(v));
    02319       }
    02320     }
    02321   }
    02322
    02323   /* Move the animation frame to the same location (m7) for all objects. */
    02324   if (IsSavegameVersionBefore(147)) {
    02325     for (TileIndex t = 0; t < map_size; t++) {
    02326       switch (GetTileType(t)) {
    02327         case MP_HOUSE:
    02328           if (GetHouseType(t) >= NEW_HOUSE_OFFSET) {
    02329             uint per_proc = _me[t].m7;
    02330             _me[t].m7 = GB(_m[t].m6, 2, 6) | (GB(_m[t].m3, 5, 1) << 6);
    02331             SB(_m[t].m3, 5, 1, 0);
    02332             SB(_m[t].m6, 2, 6, min(per_proc, 63));
    02333           }
    02334           break;
    02335
    02336         case MP_INDUSTRY: {
    02337           uint rand = _me[t].m7;
    02338           _me[t].m7 = _m[t].m3;
    02339           _m[t].m3 = rand;
    02340           break;
    02341         }
    02342
    02343         case MP_OBJECT:
    02344           _me[t].m7 = _m[t].m3;
    02345           _m[t].m3 = 0;
    02346           break;
    02347
    02348         default:
    02349           /* For stations/airports it's already at m7 */
    02350           break;
    02351       }
    02352     }
    02353   }
    02354
    02355   /* Add (random) colour to all objects. */
    02356   if (IsSavegameVersionBefore(148)) {
    02357     Object *o;
    02358     FOR_ALL_OBJECTS(o) {
    02359       Owner owner = GetTileOwner(o->location.tile);
    02360       o->colour = (owner == OWNER_NONE) ? Random() & 0xF : Company::Get(owner)->livery->colour1;
    02361     }
    02362   }
    02363
    02364   if (IsSavegameVersionBefore(149)) {
    02365     for (TileIndex t = 0; t < map_size; t++) {
    02366       if (!IsTileType(t, MP_STATION)) continue;
    02367       if (!IsBuoy(t) && !IsOilRig(t) && !(IsDock(t) && GetTileSlope(t) == SLOPE_FLAT)) {
    02368         SetWaterClass(t, WATER_CLASS_INVALID);
    02369       }
    02370     }
    02371
    02372     /* Waypoints with custom name may have a non-unique town_cn,
    02373      * renumber those. First set all affected waypoints to the
    02374      * highest possible number to get them numbered in the
    02375      * order they have in the pool. */
    02376     Waypoint *wp;
    02377     FOR_ALL_WAYPOINTS(wp) {
    02378       if (wp->name != NULL) wp->town_cn = UINT16_MAX;
    02379     }
    02380
    02381     FOR_ALL_WAYPOINTS(wp) {
    02382       if (wp->name != NULL) MakeDefaultName(wp);
    02383     }
    02384   }
    02385
    02386   if (IsSavegameVersionBefore(152)) {
    02387     _industry_builder.Reset(); // Initialize industry build data.
    02388
    02389     /* The moment vehicles go from hidden to visible changed. This means
    02390      * that vehicles don't always get visible anymore causing things to
    02391      * get messed up just after loading the savegame. This fixes that. */
    02392     Vehicle *v;
    02393     FOR_ALL_VEHICLES(v) {
    02394       /* Not all vehicle types can be inside a tunnel. Furthermore,
    02395        * testing IsTunnelTile() for invalid tiles causes a crash. */
    02396       if (!v->IsGroundVehicle()) continue;
    02397
    02398       /* Is the vehicle in a tunnel? */
    02399       if (!IsTunnelTile(v->tile)) continue;
    02400
    02401       /* Is the vehicle actually at a tunnel entrance/exit? */
    02402       TileIndex vtile = TileVirtXY(v->x_pos, v->y_pos);
    02403       if (!IsTunnelTile(vtile)) continue;
    02404
    02405       /* Are we actually in this tunnel? Or maybe a lower tunnel? */
    02406       if (GetSlopePixelZ(v->x_pos, v->y_pos) != v->z_pos) continue;
    02407
    02408       /* What way are we going? */
    02409       const DiagDirection dir = GetTunnelBridgeDirection(vtile);
    02410       const DiagDirection vdir = DirToDiagDir(v->direction);
    02411
    02412       /* Have we passed the visibility "switch" state already? */
    02413       byte pos = (DiagDirToAxis(vdir) == AXIS_X ? v->x_pos : v->y_pos) & TILE_UNIT_MASK;
    02414       byte frame = (vdir == DIAGDIR_NE || vdir == DIAGDIR_NW) ? TILE_SIZE - 1 - pos : pos;
    02415       extern const byte _tunnel_visibility_frame[DIAGDIR_END];
    02416
    02417       /* Should the vehicle be hidden or not? */
    02418       bool hidden;
    02419       if (dir == vdir) { // Entering tunnel
    02420         hidden = frame >= _tunnel_visibility_frame[dir];
    02421         v->tile = vtile;
    02422       } else if (dir == ReverseDiagDir(vdir)) { // Leaving tunnel
    02423         hidden = frame < TILE_SIZE - _tunnel_visibility_frame[dir];
    02424         /* v->tile changes at the moment when the vehicle leaves the tunnel. */
    02425         v->tile = hidden ? GetOtherTunnelBridgeEnd(vtile) : vtile;
    02426       } else {
    02427         /* We could get here in two cases:
    02428          * - for road vehicles, it is reversing at the end of the tunnel
    02429          * - it is crashed in the tunnel entry (both train or RV destroyed by UFO)
    02430          * Whatever case it is, do not change anything and use the old values.
    02431          * Especially changing RV's state would break its reversing in the middle. */
    02432         continue;
    02433       }
    02434
    02435       if (hidden) {
    02436         v->vehstatus |= VS_HIDDEN;
    02437
    02438         switch (v->type) {
    02439           case VEH_TRAIN: Train::From(v)->track       = TRACK_BIT_WORMHOLE; break;
    02440           case VEH_ROAD:  RoadVehicle::From(v)->state = RVSB_WORMHOLE;      break;
    02441           default: NOT_REACHED();
    02442         }
    02443       } else {
    02444         v->vehstatus &= ~VS_HIDDEN;
    02445
    02446         switch (v->type) {
    02447           case VEH_TRAIN: Train::From(v)->track       = DiagDirToDiagTrackBits(vdir); break;
    02448           case VEH_ROAD:  RoadVehicle::From(v)->state = DiagDirToDiagTrackdir(vdir); RoadVehicle::From(v)->frame = frame; break;
    02449           default: NOT_REACHED();
    02450         }
    02451       }
    02452     }
    02453   }
    02454
    02455   if (IsSavegameVersionBefore(153)) {
    02456     RoadVehicle *rv;
    02457     FOR_ALL_ROADVEHICLES(rv) {
    02458       if (rv->state == RVSB_IN_DEPOT || rv->state == RVSB_WORMHOLE) continue;
    02459
    02460       bool loading = rv->current_order.IsType(OT_LOADING) || rv->current_order.IsType(OT_LEAVESTATION);
    02461       if (HasBit(rv->state, RVS_IN_ROAD_STOP)) {
    02462         extern const byte _road_stop_stop_frame[];
    02463         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)]);
    02464       } else if (HasBit(rv->state, RVS_IN_DT_ROAD_STOP)) {
    02465         SB(rv->state, RVS_ENTERED_STOP, 1, loading || rv->frame > RVC_DRIVE_THROUGH_STOP_FRAME);
    02466       }
    02467     }
    02468   }
    02469
    02470   if (IsSavegameVersionBefore(156)) {
    02471     /* The train's pathfinder lost flag got moved. */
    02472     Train *t;
    02473     FOR_ALL_TRAINS(t) {
    02474       if (!HasBit(t->flags, 5)) continue;
    02475
    02476       ClrBit(t->flags, 5);
    02477       SetBit(t->vehicle_flags, VF_PATHFINDER_LOST);
    02478     }
    02479
    02480     /* Introduced terraform/clear limits. */
    02481     Company *c;
    02482     FOR_ALL_COMPANIES(c) {
    02483       c->terraform_limit = _settings_game.construction.terraform_frame_burst << 16;
    02484       c->clear_limit     = _settings_game.construction.clear_frame_burst << 16;
    02485     }
    02486   }
    02487
    02488   if (IsSavegameVersionBefore(158)) {
    02489     Vehicle *v;
    02490     FOR_ALL_VEHICLES(v) {
    02491       switch (v->type) {
    02492         case VEH_TRAIN: {
    02493           Train *t = Train::From(v);
    02494
    02495           /* Clear old GOINGUP / GOINGDOWN flags.
    02496            * It was changed in savegame version 139, but savegame
    02497            * version 158 doesn't use these bits, so it doesn't hurt
    02498            * to clear them unconditionally. */
    02499           ClrBit(t->flags, 1);
    02500           ClrBit(t->flags, 2);
    02501
    02502           /* Clear both bits first. */
    02503           ClrBit(t->gv_flags, GVF_GOINGUP_BIT);
    02504           ClrBit(t->gv_flags, GVF_GOINGDOWN_BIT);
    02505
    02506           /* Crashed vehicles can't be going up/down. */
    02507           if (t->vehstatus & VS_CRASHED) break;
    02508
    02509           /* Only X/Y tracks can be sloped. */
    02510           if (t->track != TRACK_BIT_X && t->track != TRACK_BIT_Y) break;
    02511
    02512           t->gv_flags |= FixVehicleInclination(t, t->direction);
    02513           break;
    02514         }
    02515         case VEH_ROAD: {
    02516           RoadVehicle *rv = RoadVehicle::From(v);
    02517           ClrBit(rv->gv_flags, GVF_GOINGUP_BIT);
    02518           ClrBit(rv->gv_flags, GVF_GOINGDOWN_BIT);
    02519
    02520           /* Crashed vehicles can't be going up/down. */
    02521           if (rv->vehstatus & VS_CRASHED) break;
    02522
    02523           if (rv->state == RVSB_IN_DEPOT || rv->state == RVSB_WORMHOLE) break;
    02524
    02525           TrackStatus ts = GetTileTrackStatus(rv->tile, TRANSPORT_ROAD, rv->compatible_roadtypes);
    02526           TrackBits trackbits = TrackStatusToTrackBits(ts);
    02527
    02528           /* Only X/Y tracks can be sloped. */
    02529           if (trackbits != TRACK_BIT_X && trackbits != TRACK_BIT_Y) break;
    02530
    02531           Direction dir = rv->direction;
    02532
    02533           /* Test if we are reversing. */
    02534           Axis a = trackbits == TRACK_BIT_X ? AXIS_X : AXIS_Y;
    02535           if (AxisToDirection(a) != dir &&
    02536               AxisToDirection(a) != ReverseDir(dir)) {
    02537             /* When reversing, the road vehicle is on the edge of the tile,
    02538              * so it can be safely compared to the middle of the tile. */
    02539             dir = INVALID_DIR;
    02540           }
    02541
    02542           rv->gv_flags |= FixVehicleInclination(rv, dir);
    02543           break;
    02544         }
    02545         case VEH_SHIP:
    02546           break;
    02547
    02548         default:
    02549           continue;
    02550       }
    02551
    02552       if (IsBridgeTile(v->tile) && TileVirtXY(v->x_pos, v->y_pos) == v->tile) {
    02553         /* In old versions, z_pos was 1 unit lower on bridge heads.
    02554          * However, this invalid state could be converted to new savegames
    02555          * by loading and saving the game in a new version. */
    02556         v->z_pos = GetSlopePixelZ(v->x_pos, v->y_pos);
    02557         DiagDirection dir = GetTunnelBridgeDirection(v->tile);
    02558         if (v->type == VEH_TRAIN && !(v->vehstatus & VS_CRASHED) &&
    02559             v->direction != DiagDirToDir(dir)) {
    02560           /* If the train has left the bridge, it shouldn't have
    02561            * track == TRACK_BIT_WORMHOLE - this could happen
    02562            * when the train was reversed while on the last "tick"
    02563            * on the ramp before leaving the ramp to the bridge. */
    02564           Train::From(v)->track = DiagDirToDiagTrackBits(dir);
    02565         }
    02566       }
    02567
    02568       /* If the vehicle is really above v->tile (not in a wormhole),
    02569        * it should have set v->z_pos correctly. */
    02570       assert(v->tile != TileVirtXY(v->x_pos, v->y_pos) || v->z_pos == GetSlopePixelZ(v->x_pos, v->y_pos));
    02571     }
    02572
    02573     /* Fill Vehicle::cur_real_order_index */
    02574     FOR_ALL_VEHICLES(v) {
    02575       if (!v->IsPrimaryVehicle()) continue;
    02576
    02577       /* Older versions are less strict with indices being in range and fix them on the fly */
    02578       if (v->cur_implicit_order_index >= v->GetNumOrders()) v->cur_implicit_order_index = 0;
    02579
    02580       v->cur_real_order_index = v->cur_implicit_order_index;
    02581       v->UpdateRealOrderIndex();
    02582     }
    02583   }
    02584
    02585   if (IsSavegameVersionBefore(159)) {
    02586     /* If the savegame is old (before version 100), then the value of 255
    02587      * for these settings did not mean "disabled". As such everything
    02588      * before then did reverse.
    02589      * To simplify stuff we disable all turning around or we do not
    02590      * disable anything at all. So, if some reversing was disabled we
    02591      * will keep reversing disabled, otherwise it'll be turned on. */
    02592     _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);
    02593
    02594     Train *t;
    02595     FOR_ALL_TRAINS(t) {
    02596       _settings_game.vehicle.max_train_length = max<uint8>(_settings_game.vehicle.max_train_length, CeilDiv(t->gcache.cached_total_length, TILE_SIZE));
    02597     }
    02598   }
    02599
    02600   if (IsSavegameVersionBefore(160)) {
    02601     /* Setting difficulty industry_density other than zero get bumped to +1
    02602      * since a new option (minimal at position 1) has been added */
    02603     if (_settings_game.difficulty.industry_density > 0) {
    02604       _settings_game.difficulty.industry_density++;
    02605     }
    02606   }
    02607
    02608   if (IsSavegameVersionBefore(161)) {
    02609     /* Before savegame version 161, persistent storages were not stored in a pool. */
    02610
    02611     if (!IsSavegameVersionBefore(76)) {
    02612       Industry *ind;
    02613       FOR_ALL_INDUSTRIES(ind) {
    02614         assert(ind->psa != NULL);
    02615
    02616         /* Check if the old storage was empty. */
    02617         bool is_empty = true;
    02618         for (uint i = 0; i < sizeof(ind->psa->storage); i++) {
    02619           if (ind->psa->GetValue(i) != 0) {
    02620             is_empty = false;
    02621             break;
    02622           }
    02623         }
    02624
    02625         if (!is_empty) {
    02626           ind->psa->grfid = _industry_mngr.GetGRFID(ind->type);
    02627         } else {
    02628           delete ind->psa;
    02629           ind->psa = NULL;
    02630         }
    02631       }
    02632     }
    02633
    02634     if (!IsSavegameVersionBefore(145)) {
    02635       Station *st;
    02636       FOR_ALL_STATIONS(st) {
    02637         if (!(st->facilities & FACIL_AIRPORT)) continue;
    02638         assert(st->airport.psa != NULL);
    02639
    02640         /* Check if the old storage was empty. */
    02641         bool is_empty = true;
    02642         for (uint i = 0; i < sizeof(st->airport.psa->storage); i++) {
    02643           if (st->airport.psa->GetValue(i) != 0) {
    02644             is_empty = false;
    02645             break;
    02646           }
    02647         }
    02648
    02649         if (!is_empty) {
    02650           st->airport.psa->grfid = _airport_mngr.GetGRFID(st->airport.type);
    02651         } else {
    02652           delete st->airport.psa;
    02653           st->airport.psa = NULL;
    02654
    02655         }
    02656       }
    02657     }
    02658   }
    02659
    02660   /* This triggers only when old snow_lines were copied into the snow_line_height. */
    02661   if (IsSavegameVersionBefore(164) && _settings_game.game_creation.snow_line_height >= MIN_SNOWLINE_HEIGHT * TILE_HEIGHT) {
    02662     _settings_game.game_creation.snow_line_height /= TILE_HEIGHT;
    02663   }
    02664
    02665   if (IsSavegameVersionBefore(164) && !IsSavegameVersionBefore(32)) {
    02666     /* We store 4 fences in the field tiles instead of only SE and SW. */
    02667     for (TileIndex t = 0; t < map_size; t++) {
    02668       if (!IsTileType(t, MP_CLEAR) && !IsTileType(t, MP_TREES)) continue;
    02669       if (IsTileType(t, MP_CLEAR) && IsClearGround(t, CLEAR_FIELDS)) continue;
    02670       uint fence = GB(_m[t].m4, 5, 3);
    02671       if (fence != 0 && IsTileType(TILE_ADDXY(t, 1, 0), MP_CLEAR) && IsClearGround(TILE_ADDXY(t, 1, 0), CLEAR_FIELDS)) {
    02672         SetFenceNE(TILE_ADDXY(t, 1, 0), fence);
    02673       }
    02674       fence = GB(_m[t].m4, 2, 3);
    02675       if (fence != 0 && IsTileType(TILE_ADDXY(t, 0, 1), MP_CLEAR) && IsClearGround(TILE_ADDXY(t, 0, 1), CLEAR_FIELDS)) {
    02676         SetFenceNW(TILE_ADDXY(t, 0, 1), fence);
    02677       }
    02678       SB(_m[t].m4, 2, 3, 0);
    02679       SB(_m[t].m4, 5, 3, 0);
    02680     }
    02681   }
    02682
    02683   /* The center of train vehicles was changed, fix up spacing. */
    02684   if (IsSavegameVersionBefore(164)) FixupTrainLengths();
    02685
    02686   if (IsSavegameVersionBefore(165)) {
    02687     Town *t;
    02688
    02689     FOR_ALL_TOWNS(t) {
    02690       /* Set the default cargo requirement for town growth */
    02691       switch (_settings_game.game_creation.landscape) {
    02692         case LT_ARCTIC:
    02693           if (FindFirstCargoWithTownEffect(TE_FOOD) != NULL) t->goal[TE_FOOD] = TOWN_GROWTH_WINTER;
    02694           break;
    02695
    02696         case LT_TROPIC:
    02697           if (FindFirstCargoWithTownEffect(TE_FOOD) != NULL) t->goal[TE_FOOD] = TOWN_GROWTH_DESERT;
    02698           if (FindFirstCargoWithTownEffect(TE_WATER) != NULL) t->goal[TE_WATER] = TOWN_GROWTH_DESERT;
    02699           break;
    02700       }
    02701     }
    02702   }
    02703
    02704   if (IsSavegameVersionBefore(165)) {
    02705     /* Adjust zoom level to account for new levels */
    02706     _saved_scrollpos_zoom = _saved_scrollpos_zoom + ZOOM_LVL_SHIFT;
    02707     _saved_scrollpos_x *= ZOOM_LVL_BASE;
    02708     _saved_scrollpos_y *= ZOOM_LVL_BASE;
    02709   }
    02710
    02711   /* When any NewGRF has been changed the availability of some vehicles might
    02712    * have been changed too. e->company_avail must be set to 0 in that case
    02713    * which is done by StartupEngines(). */
    02714   if (gcf_res != GLC_ALL_GOOD) StartupEngines();
    02715
    02716   if (IsSavegameVersionBefore(166)) {
    02717     /* Update cargo acceptance map of towns. */
    02718     for (TileIndex t = 0; t < map_size; t++) {
    02719       if (!IsTileType(t, MP_HOUSE)) continue;
    02720       Town::Get(GetTownIndex(t))->cargo_accepted.Add(t);
    02721     }
    02722
    02723     Town *town;
    02724     FOR_ALL_TOWNS(town) {
    02725       UpdateTownCargoes(town);
    02726     }
    02727   }
    02728
    02729   /* The road owner of standard road stops was not properly accounted for. */
    02730   if (IsSavegameVersionBefore(172)) {
    02731     for (TileIndex t = 0; t < map_size; t++) {
    02732       if (!IsStandardRoadStopTile(t)) continue;
    02733       Owner o = GetTileOwner(t);
    02734       SetRoadOwner(t, ROADTYPE_ROAD, o);
    02735       SetRoadOwner(t, ROADTYPE_TRAM, o);
    02736     }
    02737   }
    02738
    02739   if (IsSavegameVersionBefore(175)) {
    02740     /* Introduced tree planting limit. */
    02741     Company *c;
    02742     FOR_ALL_COMPANIES(c) c->tree_limit = _settings_game.construction.tree_frame_burst << 16;
    02743   }
    02744
    02745   if (IsSavegameVersionBefore(177)) {
    02746     /* Fix too high inflation rates */
    02747     if (_economy.inflation_prices > MAX_INFLATION) _economy.inflation_prices = MAX_INFLATION;
    02748     if (_economy.inflation_payment > MAX_INFLATION) _economy.inflation_payment = MAX_INFLATION;
    02749
    02750     /* We have to convert the quarters of bankruptcy into months of bankruptcy */
    02751     FOR_ALL_COMPANIES(c) {
    02752       c->months_of_bankruptcy = 3 * c->months_of_bankruptcy;
    02753     }
    02754   }
    02755
    02756   /* Road stops is 'only' updating some caches */
    02757   AfterLoadRoadStops();
    02758   AfterLoadLabelMaps();
    02759   AfterLoadCompanyStats();
    02760
    02761   GamelogPrintDebug(1);
    02762
    02763   InitializeWindowsAndCaches();
    02764   /* Restore the signals */
    02765   ResetSignalHandlers();
    02766
    02767   AfterLoadLinkGraphs();
    02768   return true;
    02769 }
    02770
    02779 void ReloadNewGRFData()
    02780 {
    02781   /* reload grf data */
    02782   GfxLoadSprites();
    02783   LoadStringWidthTable();
    02784   RecomputePrices();
    02785   /* reload vehicles */
    02786   ResetVehicleHash();
    02787   AfterLoadVehicles(false);
    02788   StartupEngines();
    02789   GroupStatistics::UpdateAfterLoad();
    02790   /* update station graphics */
    02791   AfterLoadStations();
    02792   /* Update company statistics. */
    02793   AfterLoadCompanyStats();
    02794   /* Check and update house and town values */
    02795   UpdateHousesAndTowns();
    02796   /* Delete news referring to no longer existing entities */
    02797   DeleteInvalidEngineNews();
    02798   /* Update livery selection windows */
    02799   for (CompanyID i = COMPANY_FIRST; i < MAX_COMPANIES; i++) InvalidateWindowData(WC_COMPANY_COLOUR, i);
    02800   /* Update company infrastructure counts. */
    02801   InvalidateWindowClassesData(WC_COMPANY_INFRASTRUCTURE);
    02802   /* redraw the whole screen */
    02803   MarkWholeScreenDirty();
    02804   CheckTrainsLengths();
    02805 }