afterload.cpp

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