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