afterload.cpp

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