afterload.cpp

Go to the documentation of this file.
00001 /* $Id: afterload.cpp 18912 2010-01-24 20:25:28Z yexo $ */
00002 
00003 /*
00004  * This file is part of OpenTTD.
00005  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
00006  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00007  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
00008  */
00009 
00012 #include "../stdafx.h"
00013 #include "../void_map.h"
00014 #include "../signs_base.h"
00015 #include "../depot_base.h"
00016 #include "../window_func.h"
00017 #include "../fios.h"
00018 #include "../gamelog_internal.h"
00019 #include "../network/network.h"
00020 #include "../gfxinit.h"
00021 #include "../functions.h"
00022 #include "../industry.h"
00023 #include "../clear_map.h"
00024 #include "../vehicle_func.h"
00025 #include "../debug.h"
00026 #include "../string_func.h"
00027 #include "../date_func.h"
00028 #include "../roadveh.h"
00029 #include "../train.h"
00030 #include "../station_base.h"
00031 #include "../waypoint_base.h"
00032 #include "../roadstop_base.h"
00033 #include "../tunnelbridge_map.h"
00034 #include "../landscape.h"
00035 #include "../pathfinder/yapf/yapf_cache.h"
00036 #include "../elrail_func.h"
00037 #include "../signs_func.h"
00038 #include "../aircraft.h"
00039 #include "../unmovable_map.h"
00040 #include "../tree_map.h"
00041 #include "../company_func.h"
00042 #include "../road_cmd.h"
00043 #include "../ai/ai.hpp"
00044 #include "../town.h"
00045 #include "../economy_base.h"
00046 #include "../animated_tile_func.h"
00047 #include "../subsidy_base.h"
00048 #include "../subsidy_func.h"
00049 #include "../company_base.h"
00050 #include "../newgrf.h"
00051 #include "../engine_base.h"
00052 #include "../engine_func.h"
00053 
00054 #include "table/strings.h"
00055 
00056 #include "saveload_internal.h"
00057 
00058 #include <signal.h>
00059 
00060 extern StringID _switch_mode_errorstr;
00061 extern Company *DoStartupNewCompany(bool is_ai, CompanyID company = INVALID_COMPANY);
00062 extern void InitializeRailGUI();
00063 
00074 void SetWaterClassDependingOnSurroundings(TileIndex t, bool include_invalid_water_class)
00075 {
00076   /* If the slope is not flat, we always assume 'land' (if allowed). Also for one-corner-raised-shores.
00077    * Note: Wrt. autosloping under industry tiles this is the most fool-proof behaviour. */
00078   if (GetTileSlope(t, NULL) != SLOPE_FLAT) {
00079     if (include_invalid_water_class) {
00080       SetWaterClass(t, WATER_CLASS_INVALID);
00081       return;
00082     } else {
00083       NOT_REACHED();
00084     }
00085   }
00086 
00087   /* Mark tile dirty in all cases */
00088   MarkTileDirtyByTile(t);
00089 
00090   if (TileX(t) == 0 || TileY(t) == 0 || TileX(t) == MapMaxX() - 1 || TileY(t) == MapMaxY() - 1) {
00091     /* tiles at map borders are always WATER_CLASS_SEA */
00092     SetWaterClass(t, WATER_CLASS_SEA);
00093     return;
00094   }
00095 
00096   bool has_water = false;
00097   bool has_canal = false;
00098   bool has_river = false;
00099 
00100   for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
00101     TileIndex neighbour = TileAddByDiagDir(t, dir);
00102     switch (GetTileType(neighbour)) {
00103       case MP_WATER:
00104         /* clear water and shipdepots have already a WaterClass associated */
00105         if (IsCoast(neighbour)) {
00106           has_water = true;
00107         } else if (!IsLock(neighbour)) {
00108           switch (GetWaterClass(neighbour)) {
00109             case WATER_CLASS_SEA:   has_water = true; break;
00110             case WATER_CLASS_CANAL: has_canal = true; break;
00111             case WATER_CLASS_RIVER: has_river = true; break;
00112             default: NOT_REACHED();
00113           }
00114         }
00115         break;
00116 
00117       case MP_RAILWAY:
00118         /* Shore or flooded halftile */
00119         has_water |= (GetRailGroundType(neighbour) == RAIL_GROUND_WATER);
00120         break;
00121 
00122       case MP_TREES:
00123         /* trees on shore */
00124         has_water |= (GB(_m[neighbour].m2, 4, 2) == TREE_GROUND_SHORE);
00125         break;
00126 
00127       default: break;
00128     }
00129   }
00130 
00131   if (!has_water && !has_canal && !has_river && include_invalid_water_class) {
00132     SetWaterClass(t, WATER_CLASS_INVALID);
00133     return;
00134   }
00135 
00136   if (has_river && !has_canal) {
00137     SetWaterClass(t, WATER_CLASS_RIVER);
00138   } else if (has_canal || !has_water) {
00139     SetWaterClass(t, WATER_CLASS_CANAL);
00140   } else {
00141     SetWaterClass(t, WATER_CLASS_SEA);
00142   }
00143 }
00144 
00145 static void ConvertTownOwner()
00146 {
00147   for (TileIndex tile = 0; tile != MapSize(); tile++) {
00148     switch (GetTileType(tile)) {
00149       case MP_ROAD:
00150         if (GB(_m[tile].m5, 4, 2) == ROAD_TILE_CROSSING && HasBit(_m[tile].m3, 7)) {
00151           _m[tile].m3 = OWNER_TOWN;
00152         }
00153         /* FALLTHROUGH */
00154 
00155       case MP_TUNNELBRIDGE:
00156         if (GetTileOwner(tile) & 0x80) SetTileOwner(tile, OWNER_TOWN);
00157         break;
00158 
00159       default: break;
00160     }
00161   }
00162 }
00163 
00164 /* since savegame version 4.1, exclusive transport rights are stored at towns */
00165 static void UpdateExclusiveRights()
00166 {
00167   Town *t;
00168 
00169   FOR_ALL_TOWNS(t) {
00170     t->exclusivity = INVALID_COMPANY;
00171   }
00172 
00173   /* FIXME old exclusive rights status is not being imported (stored in s->blocked_months_obsolete)
00174    *   could be implemented this way:
00175    * 1.) Go through all stations
00176    *     Build an array town_blocked[ town_id ][ company_id ]
00177    *     that stores if at least one station in that town is blocked for a company
00178    * 2.) Go through that array, if you find a town that is not blocked for
00179    *     one company, but for all others, then give him exclusivity.
00180    */
00181 }
00182 
00183 static const byte convert_currency[] = {
00184    0,  1, 12,  8,  3,
00185   10, 14, 19,  4,  5,
00186    9, 11, 13,  6, 17,
00187   16, 22, 21,  7, 15,
00188   18,  2, 20,
00189 };
00190 
00191 /* since savegame version 4.2 the currencies are arranged differently */
00192 static void UpdateCurrencies()
00193 {
00194   _settings_game.locale.currency = convert_currency[_settings_game.locale.currency];
00195 }
00196 
00197 /* Up to revision 1413 the invisible tiles at the southern border have not been
00198  * MP_VOID, even though they should have. This is fixed by this function
00199  */
00200 static void UpdateVoidTiles()
00201 {
00202   uint i;
00203 
00204   for (i = 0; i < MapMaxY(); ++i) MakeVoid(i * MapSizeX() + MapMaxX());
00205   for (i = 0; i < MapSizeX(); ++i) MakeVoid(MapSizeX() * MapMaxY() + i);
00206 }
00207 
00208 static inline RailType UpdateRailType(RailType rt, RailType min)
00209 {
00210   return rt >= min ? (RailType)(rt + 1): rt;
00211 }
00212 
00216 void UpdateAllVirtCoords()
00217 {
00218   UpdateAllStationVirtCoords();
00219   UpdateAllSignVirtCoords();
00220   UpdateAllTownVirtCoords();
00221 }
00222 
00232 static void InitializeWindowsAndCaches()
00233 {
00234   /* Initialize windows */
00235   ResetWindowSystem();
00236   SetupColoursAndInitialWindow();
00237 
00238   /* Update coordinates of the signs. */
00239   UpdateAllVirtCoords();
00240   ResetViewportAfterLoadGame();
00241 
00242   Company *c;
00243   FOR_ALL_COMPANIES(c) {
00244     /* For each company, verify (while loading a scenario) that the inauguration date is the current year and set it
00245      * accordingly if it is not the case.  No need to set it on companies that are not been used already,
00246      * thus the MIN_YEAR (which is really nothing more than Zero, initialized value) test */
00247     if (_file_to_saveload.filetype == FT_SCENARIO && c->inaugurated_year != MIN_YEAR) {
00248       c->inaugurated_year = _cur_year;
00249     }
00250   }
00251 
00252   RecomputePrices();
00253 
00254   SetCachedEngineCounts();
00255 
00256   Station::RecomputeIndustriesNearForAll();
00257   RebuildSubsidisedSourceAndDestinationCache();
00258 
00259   /* Towns have a noise controlled number of airports system
00260    * So each airport's noise value must be added to the town->noise_reached value
00261    * Reset each town's noise_reached value to '0' before. */
00262   UpdateAirportsNoise();
00263 
00264   CheckTrainsLengths();
00265   ShowNewGRFError();
00266 }
00267 
00268 typedef void (CDECL *SignalHandlerPointer)(int);
00269 static SignalHandlerPointer _prev_segfault = NULL;
00270 static SignalHandlerPointer _prev_abort    = NULL;
00271 static SignalHandlerPointer _prev_fpe      = NULL;
00272 
00273 static void CDECL HandleSavegameLoadCrash(int signum);
00274 
00279 static void SetSignalHandlers()
00280 {
00281   _prev_segfault = signal(SIGSEGV, HandleSavegameLoadCrash);
00282   _prev_abort    = signal(SIGABRT, HandleSavegameLoadCrash);
00283   _prev_fpe      = signal(SIGFPE,  HandleSavegameLoadCrash);
00284 }
00285 
00289 static void ResetSignalHandlers()
00290 {
00291   signal(SIGSEGV, _prev_segfault);
00292   signal(SIGABRT, _prev_abort);
00293   signal(SIGFPE,  _prev_fpe);
00294 }
00295 
00301 static const GRFIdentifier *GetOverriddenIdentifier(const GRFConfig *c)
00302 {
00303   const LoggedAction *la = &_gamelog_action[_gamelog_actions - 1];
00304   if (la->at != GLAT_LOAD) return c;
00305 
00306   const LoggedChange *lcend = &la->change[la->changes];
00307   for (const LoggedChange *lc = la->change; lc != lcend; lc++) {
00308     if (lc->ct == GLCT_GRFCOMPAT && lc->grfcompat.grfid == c->grfid) return &lc->grfcompat;
00309   }
00310 
00311   return c;
00312 }
00313 
00315 static bool _saveload_crash_with_missing_newgrfs = false;
00316 
00322 bool SaveloadCrashWithMissingNewGRFs()
00323 {
00324   return _saveload_crash_with_missing_newgrfs;
00325 }
00326 
00333 static void CDECL HandleSavegameLoadCrash(int signum)
00334 {
00335   ResetSignalHandlers();
00336 
00337   char buffer[8192];
00338   char *p = buffer;
00339   p += seprintf(p, lastof(buffer),
00340       "Loading your savegame caused OpenTTD to crash.\n"
00341       "This is most likely caused by a missing NewGRF or a NewGRF that has been\n"
00342       "loaded as replacement for a missing NewGRF. OpenTTD cannot easily\n"
00343       "determine whether a replacement NewGRF is of a newer or older version.\n"
00344       "It will load a NewGRF with the same GRF ID as the missing NewGRF. This\n"
00345       "means that if the author makes incompatible NewGRFs with the same GRF ID\n"
00346       "OpenTTD cannot magically do the right thing. In most cases OpenTTD will\n"
00347       "load the savegame and not crash, but this is an exception.\n"
00348       "Please load the savegame with the appropriate NewGRFs. When loading a\n"
00349       "savegame still crashes when all NewGRFs are found you should file a\n"
00350       "bug report. The missing NewGRFs are:\n");
00351 
00352   for (const GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
00353     if (HasBit(c->flags, GCF_COMPATIBLE)) {
00354       const GRFIdentifier *replaced = GetOverriddenIdentifier(c);
00355       char buf[40];
00356       md5sumToString(buf, lastof(buf), replaced->md5sum);
00357       p += seprintf(p, lastof(buffer), "NewGRF %08X (checksum %s) not found.\n  Loaded NewGRF \"%s\" with same GRF ID instead.\n", BSWAP32(c->grfid), buf, c->filename);
00358       _saveload_crash_with_missing_newgrfs = true;
00359     }
00360     if (c->status == GCS_NOT_FOUND) {
00361       char buf[40];
00362       md5sumToString(buf, lastof(buf), c->md5sum);
00363       p += seprintf(p, lastof(buffer), "NewGRF %08X (%s) not found; checksum %s.\n", BSWAP32(c->grfid), c->filename, buf);
00364       _saveload_crash_with_missing_newgrfs = true;
00365     }
00366   }
00367 
00368   ShowInfo(buffer);
00369 
00370   SignalHandlerPointer call = NULL;
00371   switch (signum) {
00372     case SIGSEGV: call = _prev_segfault; break;
00373     case SIGABRT: call = _prev_abort; break;
00374     case SIGFPE:  call = _prev_fpe; break;
00375     default: NOT_REACHED();
00376   }
00377   if (call != NULL) call(signum);
00378 }
00379 
00385 static void FixOwnerOfRailTrack(TileIndex t)
00386 {
00387   assert(!Company::IsValidID(GetTileOwner(t)) && (IsLevelCrossingTile(t) || IsPlainRailTile(t)));
00388 
00389   /* remove leftover rail piece from crossing (from very old savegames) */
00390   Train *v = NULL, *w;
00391   FOR_ALL_TRAINS(w) {
00392     if (w->tile == t) {
00393       v = w;
00394       break;
00395     }
00396   }
00397 
00398   if (v != NULL) {
00399     /* when there is a train on crossing (it could happen in TTD), set owner of crossing to train owner */
00400     SetTileOwner(t, v->owner);
00401     return;
00402   }
00403 
00404   /* try to find any connected rail */
00405   for (DiagDirection dd = DIAGDIR_BEGIN; dd < DIAGDIR_END; dd++) {
00406     TileIndex tt = t + TileOffsByDiagDir(dd);
00407     if (GetTileTrackStatus(t, TRANSPORT_RAIL, 0, dd) != 0 &&
00408         GetTileTrackStatus(tt, TRANSPORT_RAIL, 0, ReverseDiagDir(dd)) != 0 &&
00409         Company::IsValidID(GetTileOwner(tt))) {
00410       SetTileOwner(t, GetTileOwner(tt));
00411       return;
00412     }
00413   }
00414 
00415   if (IsLevelCrossingTile(t)) {
00416     /* else change the crossing to normal road (road vehicles won't care) */
00417     MakeRoadNormal(t, GetCrossingRoadBits(t), GetRoadTypes(t), GetTownIndex(t),
00418       GetRoadOwner(t, ROADTYPE_ROAD), GetRoadOwner(t, ROADTYPE_TRAM));
00419     return;
00420   }
00421 
00422   /* if it's not a crossing, make it clean land */
00423   MakeClear(t, CLEAR_GRASS, 0);
00424 }
00425 
00426 bool AfterLoadGame()
00427 {
00428   SetSignalHandlers();
00429 
00430   TileIndex map_size = MapSize();
00431   Company *c;
00432 
00433   if (CheckSavegameVersion(98)) GamelogOldver();
00434 
00435   GamelogTestRevision();
00436   GamelogTestMode();
00437 
00438   if (CheckSavegameVersion(98)) GamelogGRFAddList(_grfconfig);
00439 
00440   if (CheckSavegameVersion(119)) {
00441     _pause_mode = (_pause_mode == 2) ? PM_PAUSED_NORMAL : PM_UNPAUSED;
00442   } else if (_network_dedicated && (_pause_mode & PM_PAUSED_ERROR) != 0) {
00443     DEBUG(net, 0, "The loading savegame was paused due to an error state.");
00444     DEBUG(net, 0, "  The savegame cannot be used for multiplayer!");
00445     /* Restore the signals */
00446     ResetSignalHandlers();
00447     return false;
00448   } else if (!_networking || _network_server) {
00449     /* If we are in single player, i.e. not networking, and loading the
00450      * savegame or we are loading the savegame as network server we do
00451      * not want to be bothered by being paused because of the automatic
00452      * reason of a network server, e.g. joining clients or too few
00453      * active clients. Note that resetting these values for a network
00454      * client are very bad because then the client is going to execute
00455      * the game loop when the server is not, i.e. it desyncs. */
00456     _pause_mode &= ~PMB_PAUSED_NETWORK;
00457   }
00458 
00459   /* in very old versions, size of train stations was stored differently */
00460   if (CheckSavegameVersion(2)) {
00461     Station *st;
00462     FOR_ALL_STATIONS(st) {
00463       if (st->train_station.tile != 0 && st->train_station.h == 0) {
00464         uint n = _savegame_type == SGT_OTTD ? 4 : 3; // OTTD uses 4 bits per dimensions, TTD 3 bits
00465         uint w = GB(st->train_station.w, n, n);
00466         uint h = GB(st->train_station.w, 0, n);
00467 
00468         if (GetRailStationAxis(st->train_station.tile) != AXIS_X) Swap(w, h);
00469 
00470         st->train_station.w = w;
00471         st->train_station.h = h;
00472 
00473         assert(GetStationIndex(st->train_station.tile + TileDiffXY(w - 1, h - 1)) == st->index);
00474       }
00475     }
00476   }
00477 
00478   /* in version 2.1 of the savegame, town owner was unified. */
00479   if (CheckSavegameVersionOldStyle(2, 1)) ConvertTownOwner();
00480 
00481   /* from version 4.1 of the savegame, exclusive rights are stored at towns */
00482   if (CheckSavegameVersionOldStyle(4, 1)) UpdateExclusiveRights();
00483 
00484   /* from version 4.2 of the savegame, currencies are in a different order */
00485   if (CheckSavegameVersionOldStyle(4, 2)) UpdateCurrencies();
00486 
00487   /* In old version there seems to be a problem that water is owned by
00488    * OWNER_NONE, not OWNER_WATER.. I can't replicate it for the current
00489    * (4.3) version, so I just check when versions are older, and then
00490    * walk through the whole map.. */
00491   if (CheckSavegameVersionOldStyle(4, 3)) {
00492     for (TileIndex t = 0; t < map_size; t++) {
00493       if (IsTileType(t, MP_WATER) && GetTileOwner(t) >= MAX_COMPANIES) {
00494         SetTileOwner(t, OWNER_WATER);
00495       }
00496     }
00497   }
00498 
00499   if (CheckSavegameVersion(84)) {
00500     FOR_ALL_COMPANIES(c) {
00501       c->name = CopyFromOldName(c->name_1);
00502       if (c->name != NULL) c->name_1 = STR_SV_UNNAMED;
00503       c->president_name = CopyFromOldName(c->president_name_1);
00504       if (c->president_name != NULL) c->president_name_1 = SPECSTR_PRESIDENT_NAME;
00505     }
00506 
00507     Station *st;
00508     FOR_ALL_STATIONS(st) {
00509       st->name = CopyFromOldName(st->string_id);
00510       /* generating new name would be too much work for little effect, use the station name fallback */
00511       if (st->name != NULL) st->string_id = STR_SV_STNAME_FALLBACK;
00512     }
00513 
00514     Town *t;
00515     FOR_ALL_TOWNS(t) {
00516       t->name = CopyFromOldName(t->townnametype);
00517       if (t->name != NULL) t->townnametype = SPECSTR_TOWNNAME_START + _settings_game.game_creation.town_name;
00518     }
00519   }
00520 
00521   /* From this point the old names array is cleared. */
00522   ResetOldNames();
00523 
00524   if (CheckSavegameVersion(106)) {
00525     /* no station is determined by 'tile == INVALID_TILE' now (instead of '0') */
00526     Station *st;
00527     FOR_ALL_STATIONS(st) {
00528       if (st->airport_tile       == 0) st->airport_tile = INVALID_TILE;
00529       if (st->dock_tile          == 0) st->dock_tile    = INVALID_TILE;
00530       if (st->train_station.tile == 0) st->train_station.tile   = INVALID_TILE;
00531     }
00532 
00533     /* the same applies to Company::location_of_HQ */
00534     Company *c;
00535     FOR_ALL_COMPANIES(c) {
00536       if (c->location_of_HQ == 0 || (CheckSavegameVersion(4) && c->location_of_HQ == 0xFFFF)) {
00537         c->location_of_HQ = INVALID_TILE;
00538       }
00539     }
00540   }
00541 
00542   /* convert road side to my format. */
00543   if (_settings_game.vehicle.road_side) _settings_game.vehicle.road_side = 1;
00544 
00545   /* Check if all NewGRFs are present, we are very strict in MP mode */
00546   GRFListCompatibility gcf_res = IsGoodGRFConfigList();
00547   if (_networking && gcf_res != GLC_ALL_GOOD) {
00548     SetSaveLoadError(STR_NETWORK_ERROR_CLIENT_NEWGRF_MISMATCH);
00549     /* Restore the signals */
00550     ResetSignalHandlers();
00551     return false;
00552   }
00553 
00554   switch (gcf_res) {
00555     case GLC_COMPATIBLE: _switch_mode_errorstr = STR_NEWGRF_COMPATIBLE_LOAD_WARNING; break;
00556     case GLC_NOT_FOUND:  _switch_mode_errorstr = STR_NEWGRF_DISABLED_WARNING; _pause_mode = PM_PAUSED_ERROR; break;
00557     default: break;
00558   }
00559 
00560   /* Update current year
00561    * must be done before loading sprites as some newgrfs check it */
00562   SetDate(_date);
00563 
00564   /* Force dynamic engines off when loading older savegames */
00565   if (CheckSavegameVersion(95)) _settings_game.vehicle.dynamic_engines = 0;
00566 
00567   /* Load the sprites */
00568   GfxLoadSprites();
00569   LoadStringWidthTable();
00570 
00571   /* Copy temporary data to Engine pool */
00572   CopyTempEngineData();
00573 
00574   /* Connect front and rear engines of multiheaded trains and converts
00575    * subtype to the new format */
00576   if (CheckSavegameVersionOldStyle(17, 1)) ConvertOldMultiheadToNew();
00577 
00578   /* Connect front and rear engines of multiheaded trains */
00579   ConnectMultiheadedTrains();
00580 
00581   /* Fix the CargoPackets *and* fix the caches of CargoLists.
00582    * If this isn't done before Stations and especially Vehicles are
00583    * running their AfterLoad we might get in trouble. In the case of
00584    * vehicles we could give the wrong (cached) count of items in a
00585    * vehicle which causes different results when getting their caches
00586    * filled; and that could eventually lead to desyncs. */
00587   CargoPacket::AfterLoad();
00588 
00589   /* Update all vehicles */
00590   AfterLoadVehicles(true);
00591 
00592   /* Make sure there is an AI attached to an AI company */
00593   {
00594     Company *c;
00595     FOR_ALL_COMPANIES(c) {
00596       if (c->is_ai && c->ai_instance == NULL) AI::StartNew(c->index);
00597     }
00598   }
00599 
00600   /* make sure there is a town in the game */
00601   if (_game_mode == GM_NORMAL && !ClosestTownFromTile(0, UINT_MAX)) {
00602     SetSaveLoadError(STR_ERROR_NO_TOWN_IN_SCENARIO);
00603     /* Restore the signals */
00604     ResetSignalHandlers();
00605     return false;
00606   }
00607 
00608   /* The void tiles on the southern border used to belong to a wrong class (pre 4.3).
00609    * This problem appears in savegame version 21 too, see r3455. But after loading the
00610    * savegame and saving again, the buggy map array could be converted to new savegame
00611    * version. It didn't show up before r12070. */
00612   if (CheckSavegameVersion(87)) UpdateVoidTiles();
00613 
00614   /* If Load Scenario / New (Scenario) Game is used,
00615    *  a company does not exist yet. So create one here.
00616    * 1 exeption: network-games. Those can have 0 companies
00617    *   But this exeption is not true for non dedicated network_servers! */
00618   if (!Company::IsValidID(COMPANY_FIRST) && (!_networking || (_networking && _network_server && !_network_dedicated)))
00619     DoStartupNewCompany(false);
00620 
00621   /* Fix the cache for cargo payments. */
00622   CargoPayment *cp;
00623   FOR_ALL_CARGO_PAYMENTS(cp) {
00624     cp->front->cargo_payment = cp;
00625     cp->current_station = cp->front->last_station_visited;
00626   }
00627 
00628   if (CheckSavegameVersion(72)) {
00629     /* Locks/shiplifts in very old savegames had OWNER_WATER as owner */
00630     for (TileIndex t = 0; t < MapSize(); t++) {
00631       switch (GetTileType(t)) {
00632         default: break;
00633 
00634         case MP_WATER:
00635           if (GetWaterTileType(t) == WATER_TILE_LOCK && GetTileOwner(t) == OWNER_WATER) SetTileOwner(t, OWNER_NONE);
00636           break;
00637 
00638         case MP_STATION: {
00639           if (HasBit(_m[t].m6, 3)) SetBit(_m[t].m6, 2);
00640           StationGfx gfx = GetStationGfx(t);
00641           StationType st;
00642           if (       IsInsideMM(gfx,   0,   8)) { // Rail station
00643             st = STATION_RAIL;
00644             SetStationGfx(t, gfx - 0);
00645           } else if (IsInsideMM(gfx,   8,  67)) { // Airport
00646             st = STATION_AIRPORT;
00647             SetStationGfx(t, gfx - 8);
00648           } else if (IsInsideMM(gfx,  67,  71)) { // Truck
00649             st = STATION_TRUCK;
00650             SetStationGfx(t, gfx - 67);
00651           } else if (IsInsideMM(gfx,  71,  75)) { // Bus
00652             st = STATION_BUS;
00653             SetStationGfx(t, gfx - 71);
00654           } else if (gfx == 75) {                 // Oil rig
00655             st = STATION_OILRIG;
00656             SetStationGfx(t, gfx - 75);
00657           } else if (IsInsideMM(gfx,  76,  82)) { // Dock
00658             st = STATION_DOCK;
00659             SetStationGfx(t, gfx - 76);
00660           } else if (gfx == 82) {                 // Buoy
00661             st = STATION_BUOY;
00662             SetStationGfx(t, gfx - 82);
00663           } else if (IsInsideMM(gfx,  83, 168)) { // Extended airport
00664             st = STATION_AIRPORT;
00665             SetStationGfx(t, gfx - 83 + 67 - 8);
00666           } else if (IsInsideMM(gfx, 168, 170)) { // Drive through truck
00667             st = STATION_TRUCK;
00668             SetStationGfx(t, gfx - 168 + GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);
00669           } else if (IsInsideMM(gfx, 170, 172)) { // Drive through bus
00670             st = STATION_BUS;
00671             SetStationGfx(t, gfx - 170 + GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);
00672           } else {
00673             /* Restore the signals */
00674             ResetSignalHandlers();
00675             return false;
00676           }
00677           SB(_m[t].m6, 3, 3, st);
00678         } break;
00679       }
00680     }
00681   }
00682 
00683   for (TileIndex t = 0; t < map_size; t++) {
00684     switch (GetTileType(t)) {
00685       case MP_STATION: {
00686         BaseStation *bst = BaseStation::GetByTile(t);
00687 
00688         /* Set up station spread */
00689         bst->rect.BeforeAddTile(t, StationRect::ADD_FORCE);
00690 
00691         /* Waypoints don't have road stops/oil rigs in the old format */
00692         if (!Station::IsExpected(bst)) break;
00693         Station *st = Station::From(bst);
00694 
00695         switch (GetStationType(t)) {
00696           case STATION_TRUCK:
00697           case STATION_BUS:
00698             if (CheckSavegameVersion(6)) {
00699               /* From this version on there can be multiple road stops of the
00700                * same type per station. Convert the existing stops to the new
00701                * internal data structure. */
00702               RoadStop *rs = new RoadStop(t);
00703               if (rs == NULL) error("Too many road stops in savegame");
00704 
00705               RoadStop **head =
00706                 IsTruckStop(t) ? &st->truck_stops : &st->bus_stops;
00707               *head = rs;
00708             }
00709             break;
00710 
00711           case STATION_OILRIG: {
00712             /* Very old savegames sometimes have phantom oil rigs, i.e.
00713              * an oil rig which got shut down, but not completly removed from
00714              * the map
00715              */
00716             TileIndex t1 = TILE_ADDXY(t, 0, 1);
00717             if (IsTileType(t1, MP_INDUSTRY) &&
00718                 GetIndustryGfx(t1) == GFX_OILRIG_1) {
00719               /* The internal encoding of oil rigs was changed twice.
00720                * It was 3 (till 2.2) and later 5 (till 5.1).
00721                * Setting it unconditionally does not hurt.
00722                */
00723               Station::GetByTile(t)->airport_type = AT_OILRIG;
00724             } else {
00725               DeleteOilRig(t);
00726             }
00727             break;
00728           }
00729 
00730           default: break;
00731         }
00732         break;
00733       }
00734 
00735       default: break;
00736     }
00737   }
00738 
00739   /* In version 2.2 of the savegame, we have new airports, so status of all aircraft is reset.
00740    * This has to be called after the oilrig airport_type update above ^^^ ! */
00741   if (CheckSavegameVersionOldStyle(2, 2)) UpdateOldAircraft();
00742 
00743   /* In version 6.1 we put the town index in the map-array. To do this, we need
00744    *  to use m2 (16bit big), so we need to clean m2, and that is where this is
00745    *  all about ;) */
00746   if (CheckSavegameVersionOldStyle(6, 1)) {
00747     for (TileIndex t = 0; t < map_size; t++) {
00748       switch (GetTileType(t)) {
00749         case MP_HOUSE:
00750           _m[t].m4 = _m[t].m2;
00751           SetTownIndex(t, CalcClosestTownFromTile(t)->index);
00752           break;
00753 
00754         case MP_ROAD:
00755           _m[t].m4 |= (_m[t].m2 << 4);
00756           if ((GB(_m[t].m5, 4, 2) == ROAD_TILE_CROSSING ? (Owner)_m[t].m3 : GetTileOwner(t)) == OWNER_TOWN) {
00757             SetTownIndex(t, CalcClosestTownFromTile(t)->index);
00758           } else {
00759             SetTownIndex(t, 0);
00760           }
00761           break;
00762 
00763         default: break;
00764       }
00765     }
00766   }
00767 
00768   /* Force the freeform edges to false for old savegames. */
00769   if (CheckSavegameVersion(111)) {
00770     _settings_game.construction.freeform_edges = false;
00771   }
00772 
00773   /* From version 9.0, we update the max passengers of a town (was sometimes negative
00774    *  before that. */
00775   if (CheckSavegameVersion(9)) {
00776     Town *t;
00777     FOR_ALL_TOWNS(t) UpdateTownMaxPass(t);
00778   }
00779 
00780   /* From version 16.0, we included autorenew on engines, which are now saved, but
00781    *  of course, we do need to initialize them for older savegames. */
00782   if (CheckSavegameVersion(16)) {
00783     FOR_ALL_COMPANIES(c) {
00784       c->engine_renew_list            = NULL;
00785       c->settings.engine_renew        = false;
00786       c->settings.engine_renew_months = 6;
00787       c->settings.engine_renew_money  = 100000;
00788     }
00789 
00790     /* When loading a game, _local_company is not yet set to the correct value.
00791      * However, in a dedicated server we are a spectator, so nothing needs to
00792      * happen. In case we are not a dedicated server, the local company always
00793      * becomes company 0, unless we are in the scenario editor where all the
00794      * companies are 'invalid'.
00795      */
00796     c = Company::GetIfValid(COMPANY_FIRST);
00797     if (!_network_dedicated && c != NULL) {
00798       c->settings = _settings_client.company;
00799     }
00800   }
00801 
00802   if (CheckSavegameVersion(48)) {
00803     for (TileIndex t = 0; t < map_size; t++) {
00804       switch (GetTileType(t)) {
00805         case MP_RAILWAY:
00806           if (IsPlainRail(t)) {
00807             /* Swap ground type and signal type for plain rail tiles, so the
00808              * ground type uses the same bits as for depots and waypoints. */
00809             uint tmp = GB(_m[t].m4, 0, 4);
00810             SB(_m[t].m4, 0, 4, GB(_m[t].m2, 0, 4));
00811             SB(_m[t].m2, 0, 4, tmp);
00812           } else if (HasBit(_m[t].m5, 2)) {
00813             /* Split waypoint and depot rail type and remove the subtype. */
00814             ClrBit(_m[t].m5, 2);
00815             ClrBit(_m[t].m5, 6);
00816           }
00817           break;
00818 
00819         case MP_ROAD:
00820           /* Swap m3 and m4, so the track type for rail crossings is the
00821            * same as for normal rail. */
00822           Swap(_m[t].m3, _m[t].m4);
00823           break;
00824 
00825         default: break;
00826       }
00827     }
00828   }
00829 
00830   if (CheckSavegameVersion(61)) {
00831     /* Added the RoadType */
00832     bool old_bridge = CheckSavegameVersion(42);
00833     for (TileIndex t = 0; t < map_size; t++) {
00834       switch (GetTileType(t)) {
00835         case MP_ROAD:
00836           SB(_m[t].m5, 6, 2, GB(_m[t].m5, 4, 2));
00837           switch (GetRoadTileType(t)) {
00838             default: NOT_REACHED();
00839             case ROAD_TILE_NORMAL:
00840               SB(_m[t].m4, 0, 4, GB(_m[t].m5, 0, 4));
00841               SB(_m[t].m4, 4, 4, 0);
00842               SB(_m[t].m6, 2, 4, 0);
00843               break;
00844             case ROAD_TILE_CROSSING:
00845               SB(_m[t].m4, 5, 2, GB(_m[t].m5, 2, 2));
00846               break;
00847             case ROAD_TILE_DEPOT:    break;
00848           }
00849           SetRoadTypes(t, ROADTYPES_ROAD);
00850           break;
00851 
00852         case MP_STATION:
00853           if (IsRoadStop(t)) SetRoadTypes(t, ROADTYPES_ROAD);
00854           break;
00855 
00856         case MP_TUNNELBRIDGE:
00857           /* Middle part of "old" bridges */
00858           if (old_bridge && IsBridge(t) && HasBit(_m[t].m5, 6)) break;
00859           if (((old_bridge && IsBridge(t)) ? (TransportType)GB(_m[t].m5, 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) {
00860             SetRoadTypes(t, ROADTYPES_ROAD);
00861           }
00862           break;
00863 
00864         default: break;
00865       }
00866     }
00867   }
00868 
00869   if (CheckSavegameVersion(114)) {
00870     bool fix_roadtypes = !CheckSavegameVersion(61);
00871     bool old_bridge = CheckSavegameVersion(42);
00872 
00873     for (TileIndex t = 0; t < map_size; t++) {
00874       switch (GetTileType(t)) {
00875         case MP_ROAD:
00876           if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_me[t].m7, 5, 3));
00877           SB(_me[t].m7, 5, 1, GB(_m[t].m3, 7, 1)); // snow/desert
00878           switch (GetRoadTileType(t)) {
00879             default: NOT_REACHED();
00880             case ROAD_TILE_NORMAL:
00881               SB(_me[t].m7, 0, 4, GB(_m[t].m3, 0, 4)); // road works
00882               SB(_m[t].m6, 3, 3, GB(_m[t].m3, 4, 3));  // ground
00883               SB(_m[t].m3, 0, 4, GB(_m[t].m4, 4, 4));  // tram bits
00884               SB(_m[t].m3, 4, 4, GB(_m[t].m5, 0, 4));  // tram owner
00885               SB(_m[t].m5, 0, 4, GB(_m[t].m4, 0, 4));  // road bits
00886               break;
00887 
00888             case ROAD_TILE_CROSSING:
00889               SB(_me[t].m7, 0, 5, GB(_m[t].m4, 0, 5)); // road owner
00890               SB(_m[t].m6, 3, 3, GB(_m[t].m3, 4, 3));  // ground
00891               SB(_m[t].m3, 4, 4, GB(_m[t].m5, 0, 4));  // tram owner
00892               SB(_m[t].m5, 0, 1, GB(_m[t].m4, 6, 1));  // road axis
00893               SB(_m[t].m5, 5, 1, GB(_m[t].m4, 5, 1));  // crossing state
00894               break;
00895 
00896             case ROAD_TILE_DEPOT:
00897               break;
00898           }
00899           if (!IsRoadDepot(t) && !HasTownOwnedRoad(t)) {
00900             const Town *town = CalcClosestTownFromTile(t);
00901             if (town != NULL) SetTownIndex(t, town->index);
00902           }
00903           _m[t].m4 = 0;
00904           break;
00905 
00906         case MP_STATION:
00907           if (!IsRoadStop(t)) break;
00908 
00909           if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_m[t].m3, 0, 3));
00910           SB(_me[t].m7, 0, 5, HasBit(_m[t].m6, 2) ? OWNER_TOWN : GetTileOwner(t));
00911           SB(_m[t].m3, 4, 4, _m[t].m1);
00912           _m[t].m4 = 0;
00913           break;
00914 
00915         case MP_TUNNELBRIDGE:
00916           if (old_bridge && IsBridge(t) && HasBit(_m[t].m5, 6)) break;
00917           if (((old_bridge && IsBridge(t)) ? (TransportType)GB(_m[t].m5, 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) {
00918             if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_m[t].m3, 0, 3));
00919 
00920             Owner o = GetTileOwner(t);
00921             SB(_me[t].m7, 0, 5, o); // road owner
00922             SB(_m[t].m3, 4, 4, o == OWNER_NONE ? OWNER_TOWN : o); // tram owner
00923           }
00924           SB(_m[t].m6, 2, 4, GB(_m[t].m2, 4, 4)); // bridge type
00925           SB(_me[t].m7, 5, 1, GB(_m[t].m4, 7, 1)); // snow/desert
00926 
00927           _m[t].m2 = 0;
00928           _m[t].m4 = 0;
00929           break;
00930 
00931         default: break;
00932       }
00933     }
00934   }
00935 
00936   if (CheckSavegameVersion(42)) {
00937     Vehicle *v;
00938 
00939     for (TileIndex t = 0; t < map_size; t++) {
00940       if (MayHaveBridgeAbove(t)) ClearBridgeMiddle(t);
00941       if (IsBridgeTile(t)) {
00942         if (HasBit(_m[t].m5, 6)) { // middle part
00943           Axis axis = (Axis)GB(_m[t].m5, 0, 1);
00944 
00945           if (HasBit(_m[t].m5, 5)) { // transport route under bridge?
00946             if (GB(_m[t].m5, 3, 2) == TRANSPORT_RAIL) {
00947               MakeRailNormal(
00948                 t,
00949                 GetTileOwner(t),
00950                 axis == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X,
00951                 GetRailType(t)
00952               );
00953             } else {
00954               TownID town = IsTileOwner(t, OWNER_TOWN) ? ClosestTownFromTile(t, UINT_MAX)->index : 0;
00955 
00956               MakeRoadNormal(
00957                 t,
00958                 axis == AXIS_X ? ROAD_Y : ROAD_X,
00959                 ROADTYPES_ROAD,
00960                 town,
00961                 GetTileOwner(t), OWNER_NONE
00962               );
00963             }
00964           } else {
00965             if (GB(_m[t].m5, 3, 2) == 0) {
00966               MakeClear(t, CLEAR_GRASS, 3);
00967             } else {
00968               if (GetTileSlope(t, NULL) != SLOPE_FLAT) {
00969                 MakeShore(t);
00970               } else {
00971                 if (GetTileOwner(t) == OWNER_WATER) {
00972                   MakeSea(t);
00973                 } else {
00974                   MakeCanal(t, GetTileOwner(t), Random());
00975                 }
00976               }
00977             }
00978           }
00979           SetBridgeMiddle(t, axis);
00980         } else { // ramp
00981           Axis axis = (Axis)GB(_m[t].m5, 0, 1);
00982           uint north_south = GB(_m[t].m5, 5, 1);
00983           DiagDirection dir = ReverseDiagDir(XYNSToDiagDir(axis, north_south));
00984           TransportType type = (TransportType)GB(_m[t].m5, 1, 2);
00985 
00986           _m[t].m5 = 1 << 7 | type << 2 | dir;
00987         }
00988       }
00989     }
00990 
00991     FOR_ALL_VEHICLES(v) {
00992       if (v->type != VEH_TRAIN && v->type != VEH_ROAD) continue;
00993       if (IsBridgeTile(v->tile)) {
00994         DiagDirection dir = GetTunnelBridgeDirection(v->tile);
00995 
00996         if (dir != DirToDiagDir(v->direction)) continue;
00997         switch (dir) {
00998           default: NOT_REACHED();
00999           case DIAGDIR_NE: if ((v->x_pos & 0xF) !=  0)            continue; break;
01000           case DIAGDIR_SE: if ((v->y_pos & 0xF) != TILE_SIZE - 1) continue; break;
01001           case DIAGDIR_SW: if ((v->x_pos & 0xF) != TILE_SIZE - 1) continue; break;
01002           case DIAGDIR_NW: if ((v->y_pos & 0xF) !=  0)            continue; break;
01003         }
01004       } else if (v->z_pos > GetSlopeZ(v->x_pos, v->y_pos)) {
01005         v->tile = GetNorthernBridgeEnd(v->tile);
01006       } else {
01007         continue;
01008       }
01009       if (v->type == VEH_TRAIN) {
01010         Train::From(v)->track = TRACK_BIT_WORMHOLE;
01011       } else {
01012         RoadVehicle::From(v)->state = RVSB_WORMHOLE;
01013       }
01014     }
01015   }
01016 
01017   /* Elrails got added in rev 24 */
01018   if (CheckSavegameVersion(24)) {
01019     RailType min_rail = RAILTYPE_ELECTRIC;
01020 
01021     Train *v;
01022     FOR_ALL_TRAINS(v) {
01023       RailType rt = RailVehInfo(v->engine_type)->railtype;
01024 
01025       v->railtype = rt;
01026       if (rt == RAILTYPE_ELECTRIC) min_rail = RAILTYPE_RAIL;
01027     }
01028 
01029     /* .. so we convert the entire map from normal to elrail (so maintain "fairness") */
01030     for (TileIndex t = 0; t < map_size; t++) {
01031       switch (GetTileType(t)) {
01032         case MP_RAILWAY:
01033           SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
01034           break;
01035 
01036         case MP_ROAD:
01037           if (IsLevelCrossing(t)) {
01038             SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
01039           }
01040           break;
01041 
01042         case MP_STATION:
01043           if (HasStationRail(t)) {
01044             SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
01045           }
01046           break;
01047 
01048         case MP_TUNNELBRIDGE:
01049           if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) {
01050             SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
01051           }
01052           break;
01053 
01054         default:
01055           break;
01056       }
01057     }
01058 
01059     FOR_ALL_TRAINS(v) {
01060       if (v->IsFrontEngine() || v->IsFreeWagon()) v->ConsistChanged(true);
01061     }
01062 
01063   }
01064 
01065   /* In version 16.1 of the savegame a company can decide if trains, which get
01066    * replaced, shall keep their old length. In all prior versions, just default
01067    * to false */
01068   if (CheckSavegameVersionOldStyle(16, 1)) {
01069     FOR_ALL_COMPANIES(c) c->settings.renew_keep_length = false;
01070   }
01071 
01072   if (CheckSavegameVersion(123)) {
01073     /* Waypoints became subclasses of stations ... */
01074     MoveWaypointsToBaseStations();
01075     /* ... and buoys were moved to waypoints. */
01076     MoveBuoysToWaypoints();
01077   }
01078 
01079   /* From version 15, we moved a semaphore bit from bit 2 to bit 3 in m4, making
01080    *  room for PBS. Now in version 21 move it back :P. */
01081   if (CheckSavegameVersion(21) && !CheckSavegameVersion(15)) {
01082     for (TileIndex t = 0; t < map_size; t++) {
01083       switch (GetTileType(t)) {
01084         case MP_RAILWAY:
01085           if (HasSignals(t)) {
01086             /* convert PBS signals to combo-signals */
01087             if (HasBit(_m[t].m2, 2)) SetSignalType(t, TRACK_X, SIGTYPE_COMBO);
01088 
01089             /* move the signal variant back */
01090             SetSignalVariant(t, TRACK_X, HasBit(_m[t].m2, 3) ? SIG_SEMAPHORE : SIG_ELECTRIC);
01091             ClrBit(_m[t].m2, 3);
01092           }
01093 
01094           /* Clear PBS reservation on track */
01095           if (!IsRailDepotTile(t)) {
01096             SB(_m[t].m4, 4, 4, 0);
01097           } else {
01098             ClrBit(_m[t].m3, 6);
01099           }
01100           break;
01101 
01102         case MP_STATION: // Clear PBS reservation on station
01103           ClrBit(_m[t].m3, 6);
01104           break;
01105 
01106         default: break;
01107       }
01108     }
01109   }
01110 
01111   if (CheckSavegameVersion(25)) {
01112     RoadVehicle *rv;
01113     FOR_ALL_ROADVEHICLES(rv) {
01114       rv->vehstatus &= ~0x40;
01115     }
01116   }
01117 
01118   if (CheckSavegameVersion(26)) {
01119     Station *st;
01120     FOR_ALL_STATIONS(st) {
01121       st->last_vehicle_type = VEH_INVALID;
01122     }
01123   }
01124 
01125   YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK);
01126 
01127   if (CheckSavegameVersion(34)) FOR_ALL_COMPANIES(c) ResetCompanyLivery(c);
01128 
01129   FOR_ALL_COMPANIES(c) {
01130     c->avail_railtypes = GetCompanyRailtypes(c->index);
01131     c->avail_roadtypes = GetCompanyRoadtypes(c->index);
01132   }
01133 
01134   if (!CheckSavegameVersion(27)) AfterLoadStations();
01135 
01136   /* Time starts at 0 instead of 1920.
01137    * Account for this in older games by adding an offset */
01138   if (CheckSavegameVersion(31)) {
01139     Station *st;
01140     Waypoint *wp;
01141     Engine *e;
01142     Industry *i;
01143     Vehicle *v;
01144 
01145     _date += DAYS_TILL_ORIGINAL_BASE_YEAR;
01146     _cur_year += ORIGINAL_BASE_YEAR;
01147 
01148     FOR_ALL_STATIONS(st)  st->build_date      += DAYS_TILL_ORIGINAL_BASE_YEAR;
01149     FOR_ALL_WAYPOINTS(wp) wp->build_date      += DAYS_TILL_ORIGINAL_BASE_YEAR;
01150     FOR_ALL_ENGINES(e)    e->intro_date       += DAYS_TILL_ORIGINAL_BASE_YEAR;
01151     FOR_ALL_COMPANIES(c)  c->inaugurated_year += ORIGINAL_BASE_YEAR;
01152     FOR_ALL_INDUSTRIES(i) i->last_prod_year   += ORIGINAL_BASE_YEAR;
01153 
01154     FOR_ALL_VEHICLES(v) {
01155       v->date_of_last_service += DAYS_TILL_ORIGINAL_BASE_YEAR;
01156       v->build_year += ORIGINAL_BASE_YEAR;
01157     }
01158   }
01159 
01160   /* From 32 on we save the industry who made the farmland.
01161    *  To give this prettyness to old savegames, we remove all farmfields and
01162    *  plant new ones. */
01163   if (CheckSavegameVersion(32)) {
01164     Industry *i;
01165 
01166     for (TileIndex t = 0; t < map_size; t++) {
01167       if (IsTileType(t, MP_CLEAR) && IsClearGround(t, CLEAR_FIELDS)) {
01168         /* remove fields */
01169         MakeClear(t, CLEAR_GRASS, 3);
01170       } else if (IsTileType(t, MP_CLEAR) || IsTileType(t, MP_TREES)) {
01171         /* remove fences around fields */
01172         SetFenceSE(t, 0);
01173         SetFenceSW(t, 0);
01174       }
01175     }
01176 
01177     FOR_ALL_INDUSTRIES(i) {
01178       uint j;
01179 
01180       if (GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_PLANT_ON_BUILT) {
01181         for (j = 0; j != 50; j++) PlantRandomFarmField(i);
01182       }
01183     }
01184   }
01185 
01186   /* Setting no refit flags to all orders in savegames from before refit in orders were added */
01187   if (CheckSavegameVersion(36)) {
01188     Order *order;
01189     Vehicle *v;
01190 
01191     FOR_ALL_ORDERS(order) {
01192       order->SetRefit(CT_NO_REFIT);
01193     }
01194 
01195     FOR_ALL_VEHICLES(v) {
01196       v->current_order.SetRefit(CT_NO_REFIT);
01197     }
01198   }
01199 
01200   /* from version 38 we have optional elrails, since we cannot know the
01201    * preference of a user, let elrails enabled; it can be disabled manually */
01202   if (CheckSavegameVersion(38)) _settings_game.vehicle.disable_elrails = false;
01203   /* do the same as when elrails were enabled/disabled manually just now */
01204   SettingsDisableElrail(_settings_game.vehicle.disable_elrails);
01205   InitializeRailGUI();
01206 
01207   /* From version 53, the map array was changed for house tiles to allow
01208    * space for newhouses grf features. A new byte, m7, was also added. */
01209   if (CheckSavegameVersion(53)) {
01210     for (TileIndex t = 0; t < map_size; t++) {
01211       if (IsTileType(t, MP_HOUSE)) {
01212         if (GB(_m[t].m3, 6, 2) != TOWN_HOUSE_COMPLETED) {
01213           /* Move the construction stage from m3[7..6] to m5[5..4].
01214            * The construction counter does not have to move. */
01215           SB(_m[t].m5, 3, 2, GB(_m[t].m3, 6, 2));
01216           SB(_m[t].m3, 6, 2, 0);
01217 
01218           /* The "house is completed" bit is now in m6[2]. */
01219           SetHouseCompleted(t, false);
01220         } else {
01221           /* The "lift has destination" bit has been moved from
01222            * m5[7] to m7[0]. */
01223           SB(_me[t].m7, 0, 1, HasBit(_m[t].m5, 7));
01224           ClrBit(_m[t].m5, 7);
01225 
01226           /* The "lift is moving" bit has been removed, as it does
01227            * the same job as the "lift has destination" bit. */
01228           ClrBit(_m[t].m1, 7);
01229 
01230           /* The position of the lift goes from m1[7..0] to m6[7..2],
01231            * making m1 totally free, now. The lift position does not
01232            * have to be a full byte since the maximum value is 36. */
01233           SetLiftPosition(t, GB(_m[t].m1, 0, 6 ));
01234 
01235           _m[t].m1 = 0;
01236           _m[t].m3 = 0;
01237           SetHouseCompleted(t, true);
01238         }
01239       }
01240     }
01241   }
01242 
01243   /* Check and update house and town values */
01244   UpdateHousesAndTowns();
01245 
01246   if (CheckSavegameVersion(43)) {
01247     for (TileIndex t = 0; t < map_size; t++) {
01248       if (IsTileType(t, MP_INDUSTRY)) {
01249         switch (GetIndustryGfx(t)) {
01250           case GFX_POWERPLANT_SPARKS:
01251             SetIndustryAnimationState(t, GB(_m[t].m1, 2, 5));
01252             break;
01253 
01254           case GFX_OILWELL_ANIMATED_1:
01255           case GFX_OILWELL_ANIMATED_2:
01256           case GFX_OILWELL_ANIMATED_3:
01257             SetIndustryAnimationState(t, GB(_m[t].m1, 0, 2));
01258             break;
01259 
01260           case GFX_COAL_MINE_TOWER_ANIMATED:
01261           case GFX_COPPER_MINE_TOWER_ANIMATED:
01262           case GFX_GOLD_MINE_TOWER_ANIMATED:
01263              SetIndustryAnimationState(t, _m[t].m1);
01264              break;
01265 
01266           default: // No animation states to change
01267             break;
01268         }
01269       }
01270     }
01271   }
01272 
01273   if (CheckSavegameVersion(45)) {
01274     Vehicle *v;
01275     /* Originally just the fact that some cargo had been paid for was
01276      * stored to stop people cheating and cashing in several times. This
01277      * wasn't enough though as it was cleared when the vehicle started
01278      * loading again, even if it didn't actually load anything, so now the
01279      * amount that has been paid is stored. */
01280     FOR_ALL_VEHICLES(v) {
01281       ClrBit(v->vehicle_flags, 2);
01282     }
01283   }
01284 
01285   /* Buoys do now store the owner of the previous water tile, which can never
01286    * be OWNER_NONE. So replace OWNER_NONE with OWNER_WATER. */
01287   if (CheckSavegameVersion(46)) {
01288     Waypoint *wp;
01289     FOR_ALL_WAYPOINTS(wp) {
01290       if ((wp->facilities & FACIL_DOCK) != 0 && IsTileOwner(wp->xy, OWNER_NONE) && TileHeight(wp->xy) == 0) SetTileOwner(wp->xy, OWNER_WATER);
01291     }
01292   }
01293 
01294   if (CheckSavegameVersion(50)) {
01295     Aircraft *v;
01296     /* Aircraft units changed from 8 mph to 1 km/h */
01297     FOR_ALL_AIRCRAFT(v) {
01298       if (v->subtype <= AIR_AIRCRAFT) {
01299         const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);
01300         v->cur_speed *= 129;
01301         v->cur_speed /= 10;
01302         v->max_speed = avi->max_speed;
01303         v->acceleration = avi->acceleration;
01304       }
01305     }
01306   }
01307 
01308   if (CheckSavegameVersion(49)) FOR_ALL_COMPANIES(c) c->face = ConvertFromOldCompanyManagerFace(c->face);
01309 
01310   if (CheckSavegameVersion(52)) {
01311     for (TileIndex t = 0; t < map_size; t++) {
01312       if (IsStatueTile(t)) {
01313         _m[t].m2 = CalcClosestTownFromTile(t)->index;
01314       }
01315     }
01316   }
01317 
01318   /* A setting containing the proportion of towns that grow twice as
01319    * fast was added in version 54. From version 56 this is now saved in the
01320    * town as cities can be built specifically in the scenario editor. */
01321   if (CheckSavegameVersion(56)) {
01322     Town *t;
01323 
01324     FOR_ALL_TOWNS(t) {
01325       if (_settings_game.economy.larger_towns != 0 && (t->index % _settings_game.economy.larger_towns) == 0) {
01326         t->larger_town = true;
01327       }
01328     }
01329   }
01330 
01331   if (CheckSavegameVersion(57)) {
01332     Vehicle *v;
01333     /* Added a FIFO queue of vehicles loading at stations */
01334     FOR_ALL_VEHICLES(v) {
01335       if ((v->type != VEH_TRAIN || Train::From(v)->IsFrontEngine()) &&  // for all locs
01336           !(v->vehstatus & (VS_STOPPED | VS_CRASHED)) && // not stopped or crashed
01337           v->current_order.IsType(OT_LOADING)) {         // loading
01338         Station::Get(v->last_station_visited)->loading_vehicles.push_back(v);
01339 
01340         /* The loading finished flag is *only* set when actually completely
01341          * finished. Because the vehicle is loading, it is not finished. */
01342         ClrBit(v->vehicle_flags, VF_LOADING_FINISHED);
01343       }
01344     }
01345   } else if (CheckSavegameVersion(59)) {
01346     /* For some reason non-loading vehicles could be in the station's loading vehicle list */
01347 
01348     Station *st;
01349     FOR_ALL_STATIONS(st) {
01350       std::list<Vehicle *>::iterator iter;
01351       for (iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end();) {
01352         Vehicle *v = *iter;
01353         iter++;
01354         if (!v->current_order.IsType(OT_LOADING)) st->loading_vehicles.remove(v);
01355       }
01356     }
01357   }
01358 
01359   if (CheckSavegameVersion(58)) {
01360     /* Setting difficulty number_industries other than zero get bumped to +1
01361      * since a new option (very low at position1) has been added */
01362     if (_settings_game.difficulty.number_industries > 0) {
01363       _settings_game.difficulty.number_industries++;
01364     }
01365 
01366     /* Same goes for number of towns, although no test is needed, just an increment */
01367     _settings_game.difficulty.number_towns++;
01368   }
01369 
01370   if (CheckSavegameVersion(64)) {
01371     /* copy the signal type/variant and move signal states bits */
01372     for (TileIndex t = 0; t < map_size; t++) {
01373       if (IsTileType(t, MP_RAILWAY) && HasSignals(t)) {
01374         SetSignalStates(t, GB(_m[t].m2, 4, 4));
01375         SetSignalVariant(t, INVALID_TRACK, GetSignalVariant(t, TRACK_X));
01376         SetSignalType(t, INVALID_TRACK, GetSignalType(t, TRACK_X));
01377         ClrBit(_m[t].m2, 7);
01378       }
01379     }
01380   }
01381 
01382   if (CheckSavegameVersion(69)) {
01383     /* In some old savegames a bit was cleared when it should not be cleared */
01384     RoadVehicle *rv;
01385     FOR_ALL_ROADVEHICLES(rv) {
01386       if (rv->state == 250 || rv->state == 251) {
01387         SetBit(rv->state, 2);
01388       }
01389     }
01390   }
01391 
01392   if (CheckSavegameVersion(70)) {
01393     /* Added variables to support newindustries */
01394     Industry *i;
01395     FOR_ALL_INDUSTRIES(i) i->founder = OWNER_NONE;
01396   }
01397 
01398   /* From version 82, old style canals (above sealevel (0), WATER owner) are no longer supported.
01399       Replace the owner for those by OWNER_NONE. */
01400   if (CheckSavegameVersion(82)) {
01401     for (TileIndex t = 0; t < map_size; t++) {
01402       if (IsTileType(t, MP_WATER) &&
01403           GetWaterTileType(t) == WATER_TILE_CLEAR &&
01404           GetTileOwner(t) == OWNER_WATER &&
01405           TileHeight(t) != 0) {
01406         SetTileOwner(t, OWNER_NONE);
01407       }
01408     }
01409   }
01410 
01411   /*
01412    * Add the 'previous' owner to the ship depots so we can reset it with
01413    * the correct values when it gets destroyed. This prevents that
01414    * someone can remove canals owned by somebody else and it prevents
01415    * making floods using the removal of ship depots.
01416    */
01417   if (CheckSavegameVersion(83)) {
01418     for (TileIndex t = 0; t < map_size; t++) {
01419       if (IsTileType(t, MP_WATER) && IsShipDepot(t)) {
01420         _m[t].m4 = (TileHeight(t) == 0) ? OWNER_WATER : OWNER_NONE;
01421       }
01422     }
01423   }
01424 
01425   if (CheckSavegameVersion(74)) {
01426     Station *st;
01427     FOR_ALL_STATIONS(st) {
01428       for (CargoID c = 0; c < NUM_CARGO; c++) {
01429         st->goods[c].last_speed = 0;
01430         if (st->goods[c].cargo.Count() != 0) SetBit(st->goods[c].acceptance_pickup, GoodsEntry::PICKUP);
01431       }
01432     }
01433   }
01434 
01435   if (CheckSavegameVersion(78)) {
01436     Industry *i;
01437     uint j;
01438     FOR_ALL_INDUSTRIES(i) {
01439       const IndustrySpec *indsp = GetIndustrySpec(i->type);
01440       for (j = 0; j < lengthof(i->produced_cargo); j++) {
01441         i->produced_cargo[j] = indsp->produced_cargo[j];
01442       }
01443       for (j = 0; j < lengthof(i->accepts_cargo); j++) {
01444         i->accepts_cargo[j] = indsp->accepts_cargo[j];
01445       }
01446     }
01447   }
01448 
01449   /* Before version 81, the density of grass was always stored as zero, and
01450    * grassy trees were always drawn fully grassy. Furthermore, trees on rough
01451    * land used to have zero density, now they have full density. Therefore,
01452    * make all grassy/rough land trees have a density of 3. */
01453   if (CheckSavegameVersion(81)) {
01454     for (TileIndex t = 0; t < map_size; t++) {
01455       if (GetTileType(t) == MP_TREES) {
01456         TreeGround groundType = (TreeGround)GB(_m[t].m2, 4, 2);
01457         if (groundType != TREE_GROUND_SNOW_DESERT) SB(_m[t].m2, 6, 2, 3);
01458       }
01459     }
01460   }
01461 
01462 
01463   if (CheckSavegameVersion(93)) {
01464     /* Rework of orders. */
01465     Order *order;
01466     FOR_ALL_ORDERS(order) order->ConvertFromOldSavegame();
01467 
01468     Vehicle *v;
01469     FOR_ALL_VEHICLES(v) {
01470       if (v->orders.list != NULL && v->orders.list->GetFirstOrder() != NULL && v->orders.list->GetFirstOrder()->IsType(OT_NOTHING)) {
01471         v->orders.list->FreeChain();
01472         v->orders.list = NULL;
01473       }
01474 
01475       v->current_order.ConvertFromOldSavegame();
01476       if (v->type == VEH_ROAD && v->IsPrimaryVehicle() && v->FirstShared() == v) {
01477         FOR_VEHICLE_ORDERS(v, order) order->SetNonStopType(ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS);
01478       }
01479     }
01480   } else if (CheckSavegameVersion(94)) {
01481     /* Unload and transfer are now mutual exclusive. */
01482     Order *order;
01483     FOR_ALL_ORDERS(order) {
01484       if ((order->GetUnloadType() & (OUFB_UNLOAD | OUFB_TRANSFER)) == (OUFB_UNLOAD | OUFB_TRANSFER)) {
01485         order->SetUnloadType(OUFB_TRANSFER);
01486         order->SetLoadType(OLFB_NO_LOAD);
01487       }
01488     }
01489 
01490     Vehicle *v;
01491     FOR_ALL_VEHICLES(v) {
01492       if ((v->current_order.GetUnloadType() & (OUFB_UNLOAD | OUFB_TRANSFER)) == (OUFB_UNLOAD | OUFB_TRANSFER)) {
01493         v->current_order.SetUnloadType(OUFB_TRANSFER);
01494         v->current_order.SetLoadType(OLFB_NO_LOAD);
01495       }
01496     }
01497   }
01498 
01499   if (CheckSavegameVersion(84)) {
01500     /* Set all share owners to INVALID_COMPANY for
01501      * 1) all inactive companies
01502      *     (when inactive companies were stored in the savegame - TTD, TTDP and some
01503      *      *really* old revisions of OTTD; else it is already set in InitializeCompanies())
01504      * 2) shares that are owned by inactive companies or self
01505      *     (caused by cheating clients in earlier revisions) */
01506     FOR_ALL_COMPANIES(c) {
01507       for (uint i = 0; i < 4; i++) {
01508         CompanyID company = c->share_owners[i];
01509         if (company == INVALID_COMPANY) continue;
01510         if (!Company::IsValidID(company) || company == c->index) c->share_owners[i] = INVALID_COMPANY;
01511       }
01512     }
01513   }
01514 
01515   if (CheckSavegameVersion(86)) {
01516     for (TileIndex t = 0; t < map_size; t++) {
01517       /* Move river flag and update canals to use water class */
01518       if (IsTileType(t, MP_WATER)) {
01519         if (GetWaterClass(t) != WATER_CLASS_RIVER) {
01520           if (IsWater(t)) {
01521             Owner o = GetTileOwner(t);
01522             if (o == OWNER_WATER) {
01523               MakeSea(t);
01524             } else {
01525               MakeCanal(t, o, Random());
01526             }
01527           } else if (IsShipDepot(t)) {
01528             Owner o = (Owner)_m[t].m4; // Original water owner
01529             SetWaterClass(t, o == OWNER_WATER ? WATER_CLASS_SEA : WATER_CLASS_CANAL);
01530           }
01531         }
01532       }
01533     }
01534 
01535     /* Update locks, depots, docks and buoys to have a water class based
01536      * on its neighbouring tiles. Done after river and canal updates to
01537      * ensure neighbours are correct. */
01538     for (TileIndex t = 0; t < map_size; t++) {
01539       if (GetTileSlope(t, NULL) != SLOPE_FLAT) continue;
01540 
01541       if (IsTileType(t, MP_WATER) && IsLock(t)) SetWaterClassDependingOnSurroundings(t, false);
01542       if (IsTileType(t, MP_STATION) && (IsDock(t) || IsBuoy(t))) SetWaterClassDependingOnSurroundings(t, false);
01543     }
01544   }
01545 
01546   if (CheckSavegameVersion(87)) {
01547     for (TileIndex t = 0; t < map_size; t++) {
01548       /* skip oil rigs at borders! */
01549       if ((IsTileType(t, MP_WATER) || IsBuoyTile(t)) &&
01550           (TileX(t) == 0 || TileY(t) == 0 || TileX(t) == MapMaxX() - 1 || TileY(t) == MapMaxY() - 1)) {
01551         /* Some version 86 savegames have wrong water class at map borders (under buoy, or after removing buoy).
01552          * This conversion has to be done before buoys with invalid owner are removed. */
01553         SetWaterClass(t, WATER_CLASS_SEA);
01554       }
01555 
01556       if (IsBuoyTile(t) || IsDriveThroughStopTile(t) || IsTileType(t, MP_WATER)) {
01557         Owner o = GetTileOwner(t);
01558         if (o < MAX_COMPANIES && !Company::IsValidID(o)) {
01559           _current_company = o;
01560           ChangeTileOwner(t, o, INVALID_OWNER);
01561         }
01562         if (IsBuoyTile(t)) {
01563           /* reset buoy owner to OWNER_NONE in the station struct
01564            * (even if it is owned by active company) */
01565           Waypoint::GetByTile(t)->owner = OWNER_NONE;
01566         }
01567       } else if (IsTileType(t, MP_ROAD)) {
01568         /* works for all RoadTileType */
01569         for (RoadType rt = ROADTYPE_ROAD; rt < ROADTYPE_END; rt++) {
01570           /* update even non-existing road types to update tile owner too */
01571           Owner o = GetRoadOwner(t, rt);
01572           if (o < MAX_COMPANIES && !Company::IsValidID(o)) SetRoadOwner(t, rt, OWNER_NONE);
01573         }
01574         if (IsLevelCrossing(t)) {
01575           if (!Company::IsValidID(GetTileOwner(t))) FixOwnerOfRailTrack(t);
01576         }
01577       } else if (IsPlainRailTile(t)) {
01578         if (!Company::IsValidID(GetTileOwner(t))) FixOwnerOfRailTrack(t);
01579       }
01580     }
01581 
01582     /* Convert old PF settings to new */
01583     if (_settings_game.pf.yapf.rail_use_yapf || CheckSavegameVersion(28)) {
01584       _settings_game.pf.pathfinder_for_trains = VPF_YAPF;
01585     } else {
01586       _settings_game.pf.pathfinder_for_trains = VPF_NPF;
01587     }
01588 
01589     if (_settings_game.pf.yapf.road_use_yapf || CheckSavegameVersion(28)) {
01590       _settings_game.pf.pathfinder_for_roadvehs = VPF_YAPF;
01591     } else {
01592       _settings_game.pf.pathfinder_for_roadvehs = VPF_NPF;
01593     }
01594 
01595     if (_settings_game.pf.yapf.ship_use_yapf) {
01596       _settings_game.pf.pathfinder_for_ships = VPF_YAPF;
01597     } else {
01598       _settings_game.pf.pathfinder_for_ships = (_settings_game.pf.new_pathfinding_all ? VPF_NPF : VPF_OPF);
01599     }
01600   }
01601 
01602   if (CheckSavegameVersion(88)) {
01603     /* Profits are now with 8 bit fract */
01604     Vehicle *v;
01605     FOR_ALL_VEHICLES(v) {
01606       v->profit_this_year <<= 8;
01607       v->profit_last_year <<= 8;
01608       v->running_ticks = 0;
01609     }
01610   }
01611 
01612   if (CheckSavegameVersion(91)) {
01613     /* Increase HouseAnimationFrame from 5 to 7 bits */
01614     for (TileIndex t = 0; t < map_size; t++) {
01615       if (IsTileType(t, MP_HOUSE) && GetHouseType(t) >= NEW_HOUSE_OFFSET) {
01616         SetHouseAnimationFrame(t, GB(_m[t].m6, 3, 5));
01617       }
01618     }
01619   }
01620 
01621   if (CheckSavegameVersion(62)) {
01622     /* Remove all trams from savegames without tram support.
01623      * There would be trams without tram track under causing crashes sooner or later. */
01624     RoadVehicle *v;
01625     FOR_ALL_ROADVEHICLES(v) {
01626       if (v->First() == v && HasBit(EngInfo(v->engine_type)->misc_flags, EF_ROAD_TRAM)) {
01627         if (_switch_mode_errorstr == INVALID_STRING_ID || _switch_mode_errorstr == STR_NEWGRF_COMPATIBLE_LOAD_WARNING) {
01628           _switch_mode_errorstr = STR_WARNING_LOADGAME_REMOVED_TRAMS;
01629         }
01630         delete v;
01631       }
01632     }
01633   }
01634 
01635   if (CheckSavegameVersion(99)) {
01636     for (TileIndex t = 0; t < map_size; t++) {
01637       /* Set newly introduced WaterClass of industry tiles */
01638       if (IsTileType(t, MP_STATION) && IsOilRig(t)) {
01639         SetWaterClassDependingOnSurroundings(t, true);
01640       }
01641       if (IsTileType(t, MP_INDUSTRY)) {
01642         if ((GetIndustrySpec(GetIndustryType(t))->behaviour & INDUSTRYBEH_BUILT_ONWATER) != 0) {
01643           SetWaterClassDependingOnSurroundings(t, true);
01644         } else {
01645           SetWaterClass(t, WATER_CLASS_INVALID);
01646         }
01647       }
01648 
01649       /* Replace "house construction year" with "house age" */
01650       if (IsTileType(t, MP_HOUSE) && IsHouseCompleted(t)) {
01651         _m[t].m5 = Clamp(_cur_year - (_m[t].m5 + ORIGINAL_BASE_YEAR), 0, 0xFF);
01652       }
01653     }
01654   }
01655 
01656   /* Move the signal variant back up one bit for PBS. We don't convert the old PBS
01657    * format here, as an old layout wouldn't work properly anyway. To be safe, we
01658    * clear any possible PBS reservations as well. */
01659   if (CheckSavegameVersion(100)) {
01660     for (TileIndex t = 0; t < map_size; t++) {
01661       switch (GetTileType(t)) {
01662         case MP_RAILWAY:
01663           if (HasSignals(t)) {
01664             /* move the signal variant */
01665             SetSignalVariant(t, TRACK_UPPER, HasBit(_m[t].m2, 2) ? SIG_SEMAPHORE : SIG_ELECTRIC);
01666             SetSignalVariant(t, TRACK_LOWER, HasBit(_m[t].m2, 6) ? SIG_SEMAPHORE : SIG_ELECTRIC);
01667             ClrBit(_m[t].m2, 2);
01668             ClrBit(_m[t].m2, 6);
01669           }
01670 
01671           /* Clear PBS reservation on track */
01672           if (IsRailDepot(t)) {
01673             SetDepotReservation(t, false);
01674           } else {
01675             SetTrackReservation(t, TRACK_BIT_NONE);
01676           }
01677           break;
01678 
01679         case MP_ROAD: // Clear PBS reservation on crossing
01680           if (IsLevelCrossing(t)) SetCrossingReservation(t, false);
01681           break;
01682 
01683         case MP_STATION: // Clear PBS reservation on station
01684           if (HasStationRail(t)) SetRailStationReservation(t, false);
01685           break;
01686 
01687         case MP_TUNNELBRIDGE: // Clear PBS reservation on tunnels/birdges
01688           if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) SetTunnelBridgeReservation(t, false);
01689           break;
01690 
01691         default: break;
01692       }
01693     }
01694   }
01695 
01696   /* Reserve all tracks trains are currently on. */
01697   if (CheckSavegameVersion(101)) {
01698     const Train *t;
01699     FOR_ALL_TRAINS(t) {
01700       if (t->First() == t) t->ReserveTrackUnderConsist();
01701     }
01702   }
01703 
01704   if (CheckSavegameVersion(102)) {
01705     for (TileIndex t = 0; t < map_size; t++) {
01706       /* Now all crossings should be in correct state */
01707       if (IsLevelCrossingTile(t)) UpdateLevelCrossing(t, false);
01708     }
01709   }
01710 
01711   if (CheckSavegameVersion(103)) {
01712     /* Non-town-owned roads now store the closest town */
01713     UpdateNearestTownForRoadTiles(false);
01714 
01715     /* signs with invalid owner left from older savegames */
01716     Sign *si;
01717     FOR_ALL_SIGNS(si) {
01718       if (si->owner != OWNER_NONE && !Company::IsValidID(si->owner)) si->owner = OWNER_NONE;
01719     }
01720 
01721     /* Station can get named based on an industry type, but the current ones
01722      * are not, so mark them as if they are not named by an industry. */
01723     Station *st;
01724     FOR_ALL_STATIONS(st) {
01725       st->indtype = IT_INVALID;
01726     }
01727   }
01728 
01729   if (CheckSavegameVersion(104)) {
01730     Aircraft *a;
01731     FOR_ALL_AIRCRAFT(a) {
01732       /* Set engine_type of shadow and rotor */
01733       if (!a->IsNormalAircraft()) {
01734         a->engine_type = a->First()->engine_type;
01735       }
01736     }
01737 
01738     /* More companies ... */
01739     Company *c;
01740     FOR_ALL_COMPANIES(c) {
01741       if (c->bankrupt_asked == 0xFF) c->bankrupt_asked = 0xFFFF;
01742     }
01743 
01744     Engine *e;
01745     FOR_ALL_ENGINES(e) {
01746       if (e->company_avail == 0xFF) e->company_avail = 0xFFFF;
01747     }
01748 
01749     Town *t;
01750     FOR_ALL_TOWNS(t) {
01751       if (t->have_ratings == 0xFF) t->have_ratings = 0xFFFF;
01752       for (uint i = 8; i != MAX_COMPANIES; i++) t->ratings[i] = RATING_INITIAL;
01753     }
01754   }
01755 
01756   if (CheckSavegameVersion(112)) {
01757     for (TileIndex t = 0; t < map_size; t++) {
01758       /* Check for HQ bit being set, instead of using map accessor,
01759        * since we've already changed it code-wise */
01760       if (IsTileType(t, MP_UNMOVABLE) && HasBit(_m[t].m5, 7)) {
01761         /* Move size and part identification of HQ out of the m5 attribute,
01762          * on new locations */
01763         uint8 old_m5 = _m[t].m5;
01764         _m[t].m5 = UNMOVABLE_HQ;
01765         SetCompanyHQSize(t, GB(old_m5, 2, 3));
01766         SetCompanyHQSection(t, GB(old_m5, 0, 2));
01767       }
01768     }
01769   }
01770 
01771   if (CheckSavegameVersion(113)) {
01772     /* allow_town_roads is added, set it if town_layout wasn't TL_NO_ROADS */
01773     if (_settings_game.economy.town_layout == 0) { // was TL_NO_ROADS
01774       _settings_game.economy.allow_town_roads = false;
01775       _settings_game.economy.town_layout = TL_BETTER_ROADS;
01776     } else {
01777       _settings_game.economy.allow_town_roads = true;
01778       _settings_game.economy.town_layout = _settings_game.economy.town_layout - 1;
01779     }
01780 
01781     /* Initialize layout of all towns. Older versions were using different
01782      * generator for random town layout, use it if needed. */
01783     Town *t;
01784     FOR_ALL_TOWNS(t) {
01785       if (_settings_game.economy.town_layout != TL_RANDOM) {
01786         t->layout = _settings_game.economy.town_layout;
01787         continue;
01788       }
01789 
01790       /* Use old layout randomizer code */
01791       byte layout = TileHash(TileX(t->xy), TileY(t->xy)) % 6;
01792       switch (layout) {
01793         default: break;
01794         case 5: layout = 1; break;
01795         case 0: layout = 2; break;
01796       }
01797       t->layout = layout - 1;
01798     }
01799   }
01800 
01801   if (CheckSavegameVersion(114)) {
01802     /* There could be (deleted) stations with invalid owner, set owner to OWNER NONE.
01803      * The conversion affects oil rigs and buoys too, but it doesn't matter as
01804      * they have st->owner == OWNER_NONE already. */
01805     Station *st;
01806     FOR_ALL_STATIONS(st) {
01807       if (!Company::IsValidID(st->owner)) st->owner = OWNER_NONE;
01808     }
01809   }
01810 
01811   /* Trains could now stop in a specific location. */
01812   if (CheckSavegameVersion(117)) {
01813     Order *o;
01814     FOR_ALL_ORDERS(o) {
01815       if (o->IsType(OT_GOTO_STATION)) o->SetStopLocation(OSL_PLATFORM_FAR_END);
01816     }
01817   }
01818 
01819   if (CheckSavegameVersion(120)) {
01820     extern VehicleDefaultSettings _old_vds;
01821     Company *c;
01822     FOR_ALL_COMPANIES(c) {
01823       c->settings.vehicle = _old_vds;
01824     }
01825   }
01826 
01827   if (CheckSavegameVersion(121)) {
01828     /* Delete small ufos heading for non-existing vehicles */
01829     Vehicle *v;
01830     FOR_ALL_DISASTERVEHICLES(v) {
01831       if (v->subtype == 2/*ST_SMALL_UFO*/ && v->current_order.GetDestination() != 0) {
01832         const Vehicle *u = Vehicle::GetIfValid(v->dest_tile);
01833         if (u == NULL || u->type != VEH_ROAD || !RoadVehicle::From(u)->IsRoadVehFront()) {
01834           delete v;
01835         }
01836       }
01837     }
01838 
01839     /* We didn't store cargo payment yet, so make them for vehicles that are
01840      * currently at a station and loading/unloading. If they don't get any
01841      * payment anymore they just removed in the next load/unload cycle.
01842      * However, some 0.7 versions might have cargo payment. For those we just
01843      * add cargopayment for the vehicles that don't have it.
01844      */
01845     Station *st;
01846     FOR_ALL_STATIONS(st) {
01847       std::list<Vehicle *>::iterator iter;
01848       for (iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end(); ++iter) {
01849         Vehicle *v = *iter;
01850         if (v->cargo_payment == NULL) v->cargo_payment = new CargoPayment(v);
01851       }
01852     }
01853   }
01854 
01855   if (CheckSavegameVersion(122)) {
01856     /* Animated tiles would sometimes not be actually animated or
01857      * in case of old savegames duplicate. */
01858 
01859     extern TileIndex *_animated_tile_list;
01860     extern uint _animated_tile_count;
01861 
01862     for (uint i = 0; i < _animated_tile_count; /* Nothing */) {
01863       /* Remove if tile is not animated */
01864       bool remove = _tile_type_procs[GetTileType(_animated_tile_list[i])]->animate_tile_proc == NULL;
01865 
01866       /* and remove if duplicate */
01867       for (uint j = 0; !remove && j < i; j++) {
01868         remove = _animated_tile_list[i] == _animated_tile_list[j];
01869       }
01870 
01871       if (remove) {
01872         DeleteAnimatedTile(_animated_tile_list[i]);
01873       } else {
01874         i++;
01875       }
01876     }
01877   }
01878 
01879   if (CheckSavegameVersion(124)) {
01880     /* The train station tile area was added */
01881     Waypoint *wp;
01882     FOR_ALL_WAYPOINTS(wp) {
01883       if (wp->facilities & FACIL_TRAIN) {
01884         wp->train_station.tile = wp->xy;
01885         wp->train_station.w = 1;
01886         wp->train_station.h = 1;
01887       } else {;
01888         wp->train_station.tile = INVALID_TILE;
01889         wp->train_station.w = 0;
01890         wp->train_station.h = 0;
01891       }
01892     }
01893   }
01894 
01895   if (CheckSavegameVersion(125)) {
01896     /* Convert old subsidies */
01897     Subsidy *s;
01898     FOR_ALL_SUBSIDIES(s) {
01899       if (s->remaining < 12) {
01900         /* Converting nonawarded subsidy */
01901         s->remaining = 12 - s->remaining; // convert "age" to "remaining"
01902         s->awarded = INVALID_COMPANY; // not awarded to anyone
01903         const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
01904         switch (cs->town_effect) {
01905           case TE_PASSENGERS:
01906           case TE_MAIL:
01907             /* Town -> Town */
01908             s->src_type = s->dst_type = ST_TOWN;
01909             if (Town::IsValidID(s->src) && Town::IsValidID(s->dst)) continue;
01910             break;
01911           case TE_GOODS:
01912           case TE_FOOD:
01913             /* Industry -> Town */
01914             s->src_type = ST_INDUSTRY;
01915             s->dst_type = ST_TOWN;
01916             if (Industry::IsValidID(s->src) && Town::IsValidID(s->dst)) continue;
01917             break;
01918           default:
01919             /* Industry -> Industry */
01920             s->src_type = s->dst_type = ST_INDUSTRY;
01921             if (Industry::IsValidID(s->src) && Industry::IsValidID(s->dst)) continue;
01922             break;
01923         }
01924       } else {
01925         /* Do our best for awarded subsidies. The original source or destination industry
01926          * can't be determined anymore for awarded subsidies, so invalidate them.
01927          * Town -> Town subsidies are converted using simple heuristic */
01928         s->remaining = 24 - s->remaining; // convert "age of awarded subsidy" to "remaining"
01929         const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
01930         switch (cs->town_effect) {
01931           case TE_PASSENGERS:
01932           case TE_MAIL: {
01933             /* Town -> Town */
01934             const Station *ss = Station::GetIfValid(s->src);
01935             const Station *sd = Station::GetIfValid(s->dst);
01936             if (ss != NULL && sd != NULL && ss->owner == sd->owner &&
01937                 Company::IsValidID(ss->owner)) {
01938               s->src_type = s->dst_type = ST_TOWN;
01939               s->src = ss->town->index;
01940               s->dst = sd->town->index;
01941               s->awarded = ss->owner;
01942               continue;
01943             }
01944             break;
01945           }
01946           default:
01947             break;
01948         }
01949       }
01950       /* Awarded non-town subsidy or invalid source/destination, invalidate */
01951       delete s;
01952     }
01953   }
01954 
01955   if (CheckSavegameVersion(126)) {
01956     /* Recompute inflation based on old unround loan limit
01957      * Note: Max loan is 500000. With an inflation of 4% across 170 years
01958      *       that results in a max loan of about 0.7 * 2^31.
01959      *       So taking the 16 bit fractional part into account there are plenty of bits left
01960      *       for unmodified savegames ...
01961      */
01962     uint64 aimed_inflation = (_economy.old_max_loan_unround << 16 | _economy.old_max_loan_unround_fract) / _settings_game.difficulty.max_loan;
01963 
01964     /* ... well, just clamp it then. */
01965     if (aimed_inflation > MAX_INFLATION) aimed_inflation = MAX_INFLATION;
01966 
01967     /* Simulate the inflation, so we also get the payment inflation */
01968     while (_economy.inflation_prices < aimed_inflation) {
01969       AddInflation(false);
01970     }
01971   }
01972 
01973   if (CheckSavegameVersion(127)) {
01974     Station *st;
01975     FOR_ALL_STATIONS(st) UpdateStationAcceptance(st, false);
01976   }
01977 
01978   if (CheckSavegameVersion(128)) {
01979     const Depot *d;
01980     FOR_ALL_DEPOTS(d) {
01981       _m[d->xy].m2 = d->index;
01982       if (IsTileType(d->xy, MP_WATER)) _m[GetOtherShipDepotTile(d->xy)].m2 = d->index;
01983     }
01984   }
01985 
01986   /* The behaviour of force_proceed has been changed. Now
01987    * it counts signals instead of some random time out. */
01988   if (CheckSavegameVersion(131)) {
01989     Train *t;
01990     FOR_ALL_TRAINS(t) {
01991       t->force_proceed = min<byte>(t->force_proceed, 1);
01992     }
01993   }
01994 
01995   /* The bits for the tree ground and tree density have
01996    * been swapped (m2 bits 7..6 and 5..4. */
01997   if (CheckSavegameVersion(135)) {
01998     for (TileIndex t = 0; t < map_size; t++) {
01999       if (IsTileType(t, MP_CLEAR)) {
02000         if (GetRawClearGround(t) == CLEAR_SNOW) {
02001           SetClearGroundDensity(t, CLEAR_GRASS, GetClearDensity(t));
02002           SetBit(_m[t].m3, 4);
02003         } else {
02004           ClrBit(_m[t].m3, 4);
02005         }
02006       }
02007       if (IsTileType(t, MP_TREES)) {
02008         uint density = GB(_m[t].m2, 6, 2);
02009         uint ground = GB(_m[t].m2, 4, 2);
02010         uint counter = GB(_m[t].m2, 0, 4);
02011         _m[t].m2 = ground << 6 | density << 4 | counter;
02012       }
02013     }
02014   }
02015 
02016   /* Wait counter and load/unload ticks got split. */
02017   if (CheckSavegameVersion(136)) {
02018     Aircraft *a;
02019     FOR_ALL_AIRCRAFT(a) {
02020       a->turn_counter = a->current_order.IsType(OT_LOADING) ? 0 : a->load_unload_ticks;
02021     }
02022 
02023     Train *t;
02024     FOR_ALL_TRAINS(t) {
02025       t->wait_counter = t->current_order.IsType(OT_LOADING) ? 0 : t->load_unload_ticks;
02026     }
02027   }
02028 
02029   /* Airport tile animation uses animation frame instead of other graphics id */
02030   if (CheckSavegameVersion(137)) {
02031     struct AirportTileConversion {
02032       byte old_start;
02033       byte num_frames;
02034     };
02035     static const AirportTileConversion atc[] = {
02036       {31,  12}, // APT_RADAR_GRASS_FENCE_SW
02037       {50,   4}, // APT_GRASS_FENCE_NE_FLAG
02038       {62,   2}, // 1 unused tile
02039       {66,  12}, // APT_RADAR_FENCE_SW
02040       {78,  12}, // APT_RADAR_FENCE_NE
02041       {101, 10}, // 9 unused tiles
02042       {111,  8}, // 7 unused tiles
02043       {119, 15}, // 14 unused tiles (radar)
02044       {140,  4}, // APT_GRASS_FENCE_NE_FLAG_2
02045     };
02046     for (TileIndex t = 0; t < map_size; t++) {
02047       if (IsAirportTile(t)) {
02048         StationGfx old_gfx = GetStationGfx(t);
02049         byte offset = 0;
02050         for (uint i = 0; i < lengthof(atc); i++) {
02051           if (old_gfx < atc[i].old_start) {
02052             SetStationGfx(t, old_gfx - offset);
02053             break;
02054           }
02055           if (old_gfx < atc[i].old_start + atc[i].num_frames) {
02056             SetStationAnimationFrame(t, old_gfx - atc[i].old_start);
02057             SetStationGfx(t, atc[i].old_start - offset);
02058             break;
02059           }
02060           offset += atc[i].num_frames - 1;
02061         }
02062       }
02063     }
02064   }
02065 
02066   /* Road stops is 'only' updating some caches */
02067   AfterLoadRoadStops();
02068   AfterLoadLabelMaps();
02069 
02070   GamelogPrintDebug(1);
02071 
02072   InitializeWindowsAndCaches();
02073   /* Restore the signals */
02074   ResetSignalHandlers();
02075   return true;
02076 }
02077 
02084 void ReloadNewGRFData()
02085 {
02086   /* reload grf data */
02087   GfxLoadSprites();
02088   LoadStringWidthTable();
02089   RecomputePrices();
02090   /* reload vehicles */
02091   ResetVehiclePosHash();
02092   AfterLoadVehicles(false);
02093   StartupEngines();
02094   SetCachedEngineCounts();
02095   /* update station graphics */
02096   AfterLoadStations();
02097   /* Check and update house and town values */
02098   UpdateHousesAndTowns();
02099   /* Update livery selection windows */
02100   for (CompanyID i = COMPANY_FIRST; i < MAX_COMPANIES; i++) InvalidateWindowData(WC_COMPANY_COLOUR, i);
02101   /* redraw the whole screen */
02102   MarkWholeScreenDirty();
02103   CheckTrainsLengths();
02104 }

Generated on Thu Feb 4 17:20:27 2010 for OpenTTD by  doxygen 1.5.6