00001
00002
00003
00004
00005
00006
00007
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
00076
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
00087 MarkTileDirtyByTile(t);
00088
00089 if (TileX(t) == 0 || TileY(t) == 0 || TileX(t) == MapMaxX() - 1 || TileY(t) == MapMaxY() - 1) {
00090
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
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
00118 has_water |= (GetRailGroundType(neighbour) == RAIL_GROUND_WATER);
00119 break;
00120
00121 case MP_TREES:
00122
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
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
00164 static void UpdateExclusiveRights()
00165 {
00166 Town *t;
00167
00168 FOR_ALL_TOWNS(t) {
00169 t->exclusivity = INVALID_COMPANY;
00170 }
00171
00172
00173
00174
00175
00176
00177
00178
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
00191 static void UpdateCurrencies()
00192 {
00193 _settings_game.locale.currency = convert_currency[_settings_game.locale.currency];
00194 }
00195
00196
00197
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
00234 ResetWindowSystem();
00235 SetupColoursAndInitialWindow();
00236
00237
00238 UpdateAllVirtCoords();
00239 ResetViewportAfterLoadGame();
00240
00241 Company *c;
00242 FOR_ALL_COMPANIES(c) {
00243
00244
00245
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
00259
00260
00261 UpdateAirportsNoise();
00262
00263 CheckTrainsLengths();
00264 ShowNewGRFError();
00265 ShowAIDebugWindowIfAIError();
00266
00267
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
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
00413 SetTileOwner(t, v->owner);
00414 return;
00415 }
00416
00417
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
00430 MakeRoadNormal(t, GetCrossingRoadBits(t), GetRoadTypes(t), GetTownIndex(t),
00431 GetRoadOwner(t, ROADTYPE_ROAD), GetRoadOwner(t, ROADTYPE_TRAM));
00432 return;
00433 }
00434
00435
00436 MakeClear(t, CLEAR_GRASS, 0);
00437 }
00438
00445 static uint FixVehicleInclination(Vehicle *v, Direction dir)
00446 {
00447
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
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
00466 if (middle_z == entry_z) return 0;
00467
00468
00469 if (middle_z < entry_z) return 1U << GVF_GOINGDOWN_BIT;
00470
00471
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;
00487
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
00503 ResetSignalHandlers();
00504 return false;
00505 } else if (!_networking || _network_server) {
00506
00507
00508
00509
00510
00511
00512
00513 _pause_mode &= ~PMB_PAUSED_NETWORK;
00514 }
00515
00516
00517
00518
00519
00520
00521
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;
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
00541 if (IsSavegameVersionBefore(2, 1)) ConvertTownOwner();
00542
00543
00544 if (IsSavegameVersionBefore(4, 1)) UpdateExclusiveRights();
00545
00546
00547 if (IsSavegameVersionBefore(4, 2)) UpdateCurrencies();
00548
00549
00550
00551
00552
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
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
00585 ResetOldNames();
00586
00587 if (IsSavegameVersionBefore(106)) {
00588
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
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
00606 if (_settings_game.vehicle.road_side) _settings_game.vehicle.road_side = 1;
00607
00608
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
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
00632 if (IsSavegameVersionBefore(11, 1) || (IsSavegameVersionBefore(147) && _date_fract > DAY_TICKS)) _date_fract /= 885;
00633
00634
00635
00636 SetDate(_date, _date_fract);
00637
00638
00639
00640
00641
00642
00643
00644
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
00656 GfxLoadSprites();
00657 LoadStringWidthTable();
00658
00659
00660 CopyTempEngineData();
00661
00662
00663
00664 if (IsSavegameVersionBefore(17, 1)) ConvertOldMultiheadToNew();
00665
00666
00667 ConnectMultiheadedTrains();
00668
00669
00670
00671
00672
00673
00674
00675 CargoPacket::AfterLoad();
00676
00677
00678
00679
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
00690 AfterLoadVehicles(true);
00691
00692
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
00701 if (_game_mode == GM_NORMAL && Town::GetNumItems() == 0) {
00702 SetSaveLoadError(STR_ERROR_NO_TOWN_IN_SCENARIO);
00703
00704 ResetSignalHandlers();
00705 return false;
00706 }
00707
00708
00709
00710
00711
00712 if (IsSavegameVersionBefore(87)) UpdateVoidTiles();
00713
00714
00715
00716
00717
00718 if (!Company::IsValidID(COMPANY_FIRST) && (!_networking || (_networking && _network_server && !_network_dedicated))) {
00719 DoStartupNewCompany(false);
00720 Company *c = Company::Get(COMPANY_FIRST);
00721 c->settings = _settings_client.company;
00722 }
00723
00724
00725 CargoPayment *cp;
00726 FOR_ALL_CARGO_PAYMENTS(cp) {
00727 cp->front->cargo_payment = cp;
00728 cp->current_station = cp->front->last_station_visited;
00729 }
00730
00731 if (IsSavegameVersionBefore(72)) {
00732
00733 for (TileIndex t = 0; t < MapSize(); t++) {
00734 switch (GetTileType(t)) {
00735 default: break;
00736
00737 case MP_WATER:
00738 if (GetWaterTileType(t) == WATER_TILE_LOCK && GetTileOwner(t) == OWNER_WATER) SetTileOwner(t, OWNER_NONE);
00739 break;
00740
00741 case MP_STATION: {
00742 if (HasBit(_m[t].m6, 3)) SetBit(_m[t].m6, 2);
00743 StationGfx gfx = GetStationGfx(t);
00744 StationType st;
00745 if ( IsInsideMM(gfx, 0, 8)) {
00746 st = STATION_RAIL;
00747 SetStationGfx(t, gfx - 0);
00748 } else if (IsInsideMM(gfx, 8, 67)) {
00749 st = STATION_AIRPORT;
00750 SetStationGfx(t, gfx - 8);
00751 } else if (IsInsideMM(gfx, 67, 71)) {
00752 st = STATION_TRUCK;
00753 SetStationGfx(t, gfx - 67);
00754 } else if (IsInsideMM(gfx, 71, 75)) {
00755 st = STATION_BUS;
00756 SetStationGfx(t, gfx - 71);
00757 } else if (gfx == 75) {
00758 st = STATION_OILRIG;
00759 SetStationGfx(t, gfx - 75);
00760 } else if (IsInsideMM(gfx, 76, 82)) {
00761 st = STATION_DOCK;
00762 SetStationGfx(t, gfx - 76);
00763 } else if (gfx == 82) {
00764 st = STATION_BUOY;
00765 SetStationGfx(t, gfx - 82);
00766 } else if (IsInsideMM(gfx, 83, 168)) {
00767 st = STATION_AIRPORT;
00768 SetStationGfx(t, gfx - 83 + 67 - 8);
00769 } else if (IsInsideMM(gfx, 168, 170)) {
00770 st = STATION_TRUCK;
00771 SetStationGfx(t, gfx - 168 + GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);
00772 } else if (IsInsideMM(gfx, 170, 172)) {
00773 st = STATION_BUS;
00774 SetStationGfx(t, gfx - 170 + GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);
00775 } else {
00776
00777 ResetSignalHandlers();
00778 return false;
00779 }
00780 SB(_m[t].m6, 3, 3, st);
00781 break;
00782 }
00783 }
00784 }
00785 }
00786
00787 for (TileIndex t = 0; t < map_size; t++) {
00788 switch (GetTileType(t)) {
00789 case MP_STATION: {
00790 BaseStation *bst = BaseStation::GetByTile(t);
00791
00792
00793 bst->rect.BeforeAddTile(t, StationRect::ADD_FORCE);
00794
00795
00796 if (!Station::IsExpected(bst)) break;
00797 Station *st = Station::From(bst);
00798
00799 switch (GetStationType(t)) {
00800 case STATION_TRUCK:
00801 case STATION_BUS:
00802 if (IsSavegameVersionBefore(6)) {
00803
00804
00805
00806
00807
00808
00809 assert(RoadStop::CanAllocateItem());
00810
00811
00812
00813
00814 RoadStop *rs = new RoadStop(t);
00815
00816 RoadStop **head =
00817 IsTruckStop(t) ? &st->truck_stops : &st->bus_stops;
00818 *head = rs;
00819 }
00820 break;
00821
00822 case STATION_OILRIG: {
00823
00824
00825
00826
00827 TileIndex t1 = TILE_ADDXY(t, 0, 1);
00828 if (IsTileType(t1, MP_INDUSTRY) &&
00829 GetIndustryGfx(t1) == GFX_OILRIG_1) {
00830
00831
00832
00833
00834 Station::GetByTile(t)->airport.type = AT_OILRIG;
00835 } else {
00836 DeleteOilRig(t);
00837 }
00838 break;
00839 }
00840
00841 default: break;
00842 }
00843 break;
00844 }
00845
00846 default: break;
00847 }
00848 }
00849
00850
00851
00852 if (IsSavegameVersionBefore(2, 2)) UpdateOldAircraft();
00853
00854
00855
00856
00857 if (IsSavegameVersionBefore(6, 1)) {
00858 for (TileIndex t = 0; t < map_size; t++) {
00859 switch (GetTileType(t)) {
00860 case MP_HOUSE:
00861 _m[t].m4 = _m[t].m2;
00862 SetTownIndex(t, CalcClosestTownFromTile(t)->index);
00863 break;
00864
00865 case MP_ROAD:
00866 _m[t].m4 |= (_m[t].m2 << 4);
00867 if ((GB(_m[t].m5, 4, 2) == ROAD_TILE_CROSSING ? (Owner)_m[t].m3 : GetTileOwner(t)) == OWNER_TOWN) {
00868 SetTownIndex(t, CalcClosestTownFromTile(t)->index);
00869 } else {
00870 SetTownIndex(t, 0);
00871 }
00872 break;
00873
00874 default: break;
00875 }
00876 }
00877 }
00878
00879
00880 if (IsSavegameVersionBefore(111)) {
00881 _settings_game.construction.freeform_edges = false;
00882 }
00883
00884
00885
00886 if (IsSavegameVersionBefore(9)) {
00887 Town *t;
00888 FOR_ALL_TOWNS(t) UpdateTownMaxPass(t);
00889 }
00890
00891
00892
00893 if (IsSavegameVersionBefore(16)) {
00894 Company *c;
00895 FOR_ALL_COMPANIES(c) {
00896 c->engine_renew_list = NULL;
00897 c->settings.engine_renew = false;
00898 c->settings.engine_renew_months = 6;
00899 c->settings.engine_renew_money = 100000;
00900 }
00901
00902
00903
00904
00905
00906
00907
00908 c = Company::GetIfValid(COMPANY_FIRST);
00909 if (!_network_dedicated && c != NULL) {
00910 c->settings = _settings_client.company;
00911 }
00912 }
00913
00914 if (IsSavegameVersionBefore(48)) {
00915 for (TileIndex t = 0; t < map_size; t++) {
00916 switch (GetTileType(t)) {
00917 case MP_RAILWAY:
00918 if (IsPlainRail(t)) {
00919
00920
00921 uint tmp = GB(_m[t].m4, 0, 4);
00922 SB(_m[t].m4, 0, 4, GB(_m[t].m2, 0, 4));
00923 SB(_m[t].m2, 0, 4, tmp);
00924 } else if (HasBit(_m[t].m5, 2)) {
00925
00926 ClrBit(_m[t].m5, 2);
00927 ClrBit(_m[t].m5, 6);
00928 }
00929 break;
00930
00931 case MP_ROAD:
00932
00933
00934 Swap(_m[t].m3, _m[t].m4);
00935 break;
00936
00937 default: break;
00938 }
00939 }
00940 }
00941
00942 if (IsSavegameVersionBefore(61)) {
00943
00944 bool old_bridge = IsSavegameVersionBefore(42);
00945 for (TileIndex t = 0; t < map_size; t++) {
00946 switch (GetTileType(t)) {
00947 case MP_ROAD:
00948 SB(_m[t].m5, 6, 2, GB(_m[t].m5, 4, 2));
00949 switch (GetRoadTileType(t)) {
00950 default: SlErrorCorrupt("Invalid road tile type");
00951 case ROAD_TILE_NORMAL:
00952 SB(_m[t].m4, 0, 4, GB(_m[t].m5, 0, 4));
00953 SB(_m[t].m4, 4, 4, 0);
00954 SB(_m[t].m6, 2, 4, 0);
00955 break;
00956 case ROAD_TILE_CROSSING:
00957 SB(_m[t].m4, 5, 2, GB(_m[t].m5, 2, 2));
00958 break;
00959 case ROAD_TILE_DEPOT: break;
00960 }
00961 SetRoadTypes(t, ROADTYPES_ROAD);
00962 break;
00963
00964 case MP_STATION:
00965 if (IsRoadStop(t)) SetRoadTypes(t, ROADTYPES_ROAD);
00966 break;
00967
00968 case MP_TUNNELBRIDGE:
00969
00970 if (old_bridge && IsBridge(t) && HasBit(_m[t].m5, 6)) break;
00971 if (((old_bridge && IsBridge(t)) ? (TransportType)GB(_m[t].m5, 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) {
00972 SetRoadTypes(t, ROADTYPES_ROAD);
00973 }
00974 break;
00975
00976 default: break;
00977 }
00978 }
00979 }
00980
00981 if (IsSavegameVersionBefore(114)) {
00982 bool fix_roadtypes = !IsSavegameVersionBefore(61);
00983 bool old_bridge = IsSavegameVersionBefore(42);
00984
00985 for (TileIndex t = 0; t < map_size; t++) {
00986 switch (GetTileType(t)) {
00987 case MP_ROAD:
00988 if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_me[t].m7, 5, 3));
00989 SB(_me[t].m7, 5, 1, GB(_m[t].m3, 7, 1));
00990 switch (GetRoadTileType(t)) {
00991 default: SlErrorCorrupt("Invalid road tile type");
00992 case ROAD_TILE_NORMAL:
00993 SB(_me[t].m7, 0, 4, GB(_m[t].m3, 0, 4));
00994 SB(_m[t].m6, 3, 3, GB(_m[t].m3, 4, 3));
00995 SB(_m[t].m3, 0, 4, GB(_m[t].m4, 4, 4));
00996 SB(_m[t].m3, 4, 4, GB(_m[t].m5, 0, 4));
00997 SB(_m[t].m5, 0, 4, GB(_m[t].m4, 0, 4));
00998 break;
00999
01000 case ROAD_TILE_CROSSING:
01001 SB(_me[t].m7, 0, 5, GB(_m[t].m4, 0, 5));
01002 SB(_m[t].m6, 3, 3, GB(_m[t].m3, 4, 3));
01003 SB(_m[t].m3, 4, 4, GB(_m[t].m5, 0, 4));
01004 SB(_m[t].m5, 0, 1, GB(_m[t].m4, 6, 1));
01005 SB(_m[t].m5, 5, 1, GB(_m[t].m4, 5, 1));
01006 break;
01007
01008 case ROAD_TILE_DEPOT:
01009 break;
01010 }
01011 if (!IsRoadDepot(t) && !HasTownOwnedRoad(t)) {
01012 const Town *town = CalcClosestTownFromTile(t);
01013 if (town != NULL) SetTownIndex(t, town->index);
01014 }
01015 _m[t].m4 = 0;
01016 break;
01017
01018 case MP_STATION:
01019 if (!IsRoadStop(t)) break;
01020
01021 if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_m[t].m3, 0, 3));
01022 SB(_me[t].m7, 0, 5, HasBit(_m[t].m6, 2) ? OWNER_TOWN : GetTileOwner(t));
01023 SB(_m[t].m3, 4, 4, _m[t].m1);
01024 _m[t].m4 = 0;
01025 break;
01026
01027 case MP_TUNNELBRIDGE:
01028 if (old_bridge && IsBridge(t) && HasBit(_m[t].m5, 6)) break;
01029 if (((old_bridge && IsBridge(t)) ? (TransportType)GB(_m[t].m5, 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) {
01030 if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_m[t].m3, 0, 3));
01031
01032 Owner o = GetTileOwner(t);
01033 SB(_me[t].m7, 0, 5, o);
01034 SB(_m[t].m3, 4, 4, o == OWNER_NONE ? OWNER_TOWN : o);
01035 }
01036 SB(_m[t].m6, 2, 4, GB(_m[t].m2, 4, 4));
01037 SB(_me[t].m7, 5, 1, GB(_m[t].m4, 7, 1));
01038
01039 _m[t].m2 = 0;
01040 _m[t].m4 = 0;
01041 break;
01042
01043 default: break;
01044 }
01045 }
01046 }
01047
01048 if (IsSavegameVersionBefore(42)) {
01049 Vehicle *v;
01050
01051 for (TileIndex t = 0; t < map_size; t++) {
01052 if (MayHaveBridgeAbove(t)) ClearBridgeMiddle(t);
01053 if (IsBridgeTile(t)) {
01054 if (HasBit(_m[t].m5, 6)) {
01055 Axis axis = (Axis)GB(_m[t].m5, 0, 1);
01056
01057 if (HasBit(_m[t].m5, 5)) {
01058 if (GB(_m[t].m5, 3, 2) == TRANSPORT_RAIL) {
01059 MakeRailNormal(
01060 t,
01061 GetTileOwner(t),
01062 axis == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X,
01063 GetRailType(t)
01064 );
01065 } else {
01066 TownID town = IsTileOwner(t, OWNER_TOWN) ? ClosestTownFromTile(t, UINT_MAX)->index : 0;
01067
01068 MakeRoadNormal(
01069 t,
01070 axis == AXIS_X ? ROAD_Y : ROAD_X,
01071 ROADTYPES_ROAD,
01072 town,
01073 GetTileOwner(t), OWNER_NONE
01074 );
01075 }
01076 } else {
01077 if (GB(_m[t].m5, 3, 2) == 0) {
01078 MakeClear(t, CLEAR_GRASS, 3);
01079 } else {
01080 if (GetTileSlope(t) != SLOPE_FLAT) {
01081 MakeShore(t);
01082 } else {
01083 if (GetTileOwner(t) == OWNER_WATER) {
01084 MakeSea(t);
01085 } else {
01086 MakeCanal(t, GetTileOwner(t), Random());
01087 }
01088 }
01089 }
01090 }
01091 SetBridgeMiddle(t, axis);
01092 } else {
01093 Axis axis = (Axis)GB(_m[t].m5, 0, 1);
01094 uint north_south = GB(_m[t].m5, 5, 1);
01095 DiagDirection dir = ReverseDiagDir(XYNSToDiagDir(axis, north_south));
01096 TransportType type = (TransportType)GB(_m[t].m5, 1, 2);
01097
01098 _m[t].m5 = 1 << 7 | type << 2 | dir;
01099 }
01100 }
01101 }
01102
01103 FOR_ALL_VEHICLES(v) {
01104 if (!v->IsGroundVehicle()) continue;
01105 if (IsBridgeTile(v->tile)) {
01106 DiagDirection dir = GetTunnelBridgeDirection(v->tile);
01107
01108 if (dir != DirToDiagDir(v->direction)) continue;
01109 switch (dir) {
01110 default: SlErrorCorrupt("Invalid vehicle direction");
01111 case DIAGDIR_NE: if ((v->x_pos & 0xF) != 0) continue; break;
01112 case DIAGDIR_SE: if ((v->y_pos & 0xF) != TILE_SIZE - 1) continue; break;
01113 case DIAGDIR_SW: if ((v->x_pos & 0xF) != TILE_SIZE - 1) continue; break;
01114 case DIAGDIR_NW: if ((v->y_pos & 0xF) != 0) continue; break;
01115 }
01116 } else if (v->z_pos > GetSlopePixelZ(v->x_pos, v->y_pos)) {
01117 v->tile = GetNorthernBridgeEnd(v->tile);
01118 } else {
01119 continue;
01120 }
01121 if (v->type == VEH_TRAIN) {
01122 Train::From(v)->track = TRACK_BIT_WORMHOLE;
01123 } else {
01124 RoadVehicle::From(v)->state = RVSB_WORMHOLE;
01125 }
01126 }
01127 }
01128
01129
01130 if (IsSavegameVersionBefore(24)) {
01131 RailType min_rail = RAILTYPE_ELECTRIC;
01132
01133 Train *v;
01134 FOR_ALL_TRAINS(v) {
01135 RailType rt = RailVehInfo(v->engine_type)->railtype;
01136
01137 v->railtype = rt;
01138 if (rt == RAILTYPE_ELECTRIC) min_rail = RAILTYPE_RAIL;
01139 }
01140
01141
01142 for (TileIndex t = 0; t < map_size; t++) {
01143 switch (GetTileType(t)) {
01144 case MP_RAILWAY:
01145 SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
01146 break;
01147
01148 case MP_ROAD:
01149 if (IsLevelCrossing(t)) {
01150 SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
01151 }
01152 break;
01153
01154 case MP_STATION:
01155 if (HasStationRail(t)) {
01156 SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
01157 }
01158 break;
01159
01160 case MP_TUNNELBRIDGE:
01161 if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) {
01162 SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
01163 }
01164 break;
01165
01166 default:
01167 break;
01168 }
01169 }
01170
01171 FOR_ALL_TRAINS(v) {
01172 if (v->IsFrontEngine() || v->IsFreeWagon()) v->ConsistChanged(true);
01173 }
01174
01175 }
01176
01177
01178
01179
01180 if (IsSavegameVersionBefore(16, 1)) {
01181 Company *c;
01182 FOR_ALL_COMPANIES(c) c->settings.renew_keep_length = false;
01183 }
01184
01185 if (IsSavegameVersionBefore(123)) {
01186
01187 MoveWaypointsToBaseStations();
01188
01189 MoveBuoysToWaypoints();
01190 }
01191
01192
01193
01194 if (IsSavegameVersionBefore(21) && !IsSavegameVersionBefore(15)) {
01195 for (TileIndex t = 0; t < map_size; t++) {
01196 switch (GetTileType(t)) {
01197 case MP_RAILWAY:
01198 if (HasSignals(t)) {
01199
01200
01201
01202
01203
01204 if (HasBit(_m[t].m2, 2)) SB(_m[t].m2, 0, 2, SIGTYPE_COMBO);
01205
01206
01207 SB(_m[t].m2, 2, 1, HasBit(_m[t].m2, 3) ? SIG_SEMAPHORE : SIG_ELECTRIC);
01208 ClrBit(_m[t].m2, 3);
01209 }
01210
01211
01212 if (!IsRailDepotTile(t)) {
01213 SB(_m[t].m4, 4, 4, 0);
01214 } else {
01215 ClrBit(_m[t].m3, 6);
01216 }
01217 break;
01218
01219 case MP_STATION:
01220 ClrBit(_m[t].m3, 6);
01221 break;
01222
01223 default: break;
01224 }
01225 }
01226 }
01227
01228 if (IsSavegameVersionBefore(25)) {
01229 RoadVehicle *rv;
01230 FOR_ALL_ROADVEHICLES(rv) {
01231 rv->vehstatus &= ~0x40;
01232 }
01233 }
01234
01235 if (IsSavegameVersionBefore(26)) {
01236 Station *st;
01237 FOR_ALL_STATIONS(st) {
01238 st->last_vehicle_type = VEH_INVALID;
01239 }
01240 }
01241
01242 YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK);
01243
01244 if (IsSavegameVersionBefore(34)) {
01245 Company *c;
01246 FOR_ALL_COMPANIES(c) ResetCompanyLivery(c);
01247 }
01248
01249 Company *c;
01250 FOR_ALL_COMPANIES(c) {
01251 c->avail_railtypes = GetCompanyRailtypes(c->index);
01252 c->avail_roadtypes = GetCompanyRoadtypes(c->index);
01253 }
01254
01255 if (!IsSavegameVersionBefore(27)) AfterLoadStations();
01256
01257
01258
01259 if (IsSavegameVersionBefore(31)) {
01260 Station *st;
01261 Waypoint *wp;
01262 Engine *e;
01263 Industry *i;
01264 Vehicle *v;
01265
01266 _date += DAYS_TILL_ORIGINAL_BASE_YEAR;
01267 _cur_year += ORIGINAL_BASE_YEAR;
01268
01269 FOR_ALL_STATIONS(st) st->build_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
01270 FOR_ALL_WAYPOINTS(wp) wp->build_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
01271 FOR_ALL_ENGINES(e) e->intro_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
01272 FOR_ALL_COMPANIES(c) c->inaugurated_year += ORIGINAL_BASE_YEAR;
01273 FOR_ALL_INDUSTRIES(i) i->last_prod_year += ORIGINAL_BASE_YEAR;
01274
01275 FOR_ALL_VEHICLES(v) {
01276 v->date_of_last_service += DAYS_TILL_ORIGINAL_BASE_YEAR;
01277 v->build_year += ORIGINAL_BASE_YEAR;
01278 }
01279 }
01280
01281
01282
01283
01284 if (IsSavegameVersionBefore(32)) {
01285 Industry *i;
01286
01287 for (TileIndex t = 0; t < map_size; t++) {
01288 if (IsTileType(t, MP_CLEAR) && IsClearGround(t, CLEAR_FIELDS)) {
01289
01290 MakeClear(t, CLEAR_GRASS, 3);
01291 }
01292 }
01293
01294 FOR_ALL_INDUSTRIES(i) {
01295 uint j;
01296
01297 if (GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_PLANT_ON_BUILT) {
01298 for (j = 0; j != 50; j++) PlantRandomFarmField(i);
01299 }
01300 }
01301 }
01302
01303
01304 if (IsSavegameVersionBefore(36)) {
01305 Order *order;
01306 Vehicle *v;
01307
01308 FOR_ALL_ORDERS(order) {
01309 order->SetRefit(CT_NO_REFIT);
01310 }
01311
01312 FOR_ALL_VEHICLES(v) {
01313 v->current_order.SetRefit(CT_NO_REFIT);
01314 }
01315 }
01316
01317
01318
01319 if (IsSavegameVersionBefore(38)) _settings_game.vehicle.disable_elrails = false;
01320
01321 SettingsDisableElrail(_settings_game.vehicle.disable_elrails);
01322 InitializeRailGUI();
01323
01324
01325
01326 if (IsSavegameVersionBefore(53)) {
01327 for (TileIndex t = 0; t < map_size; t++) {
01328 if (IsTileType(t, MP_HOUSE)) {
01329 if (GB(_m[t].m3, 6, 2) != TOWN_HOUSE_COMPLETED) {
01330
01331
01332 SB(_m[t].m5, 3, 2, GB(_m[t].m3, 6, 2));
01333 SB(_m[t].m3, 6, 2, 0);
01334
01335
01336 SetHouseCompleted(t, false);
01337 } else {
01338
01339
01340 SB(_me[t].m7, 0, 1, HasBit(_m[t].m5, 7));
01341 ClrBit(_m[t].m5, 7);
01342
01343
01344
01345 ClrBit(_m[t].m1, 7);
01346
01347
01348
01349
01350 SetLiftPosition(t, GB(_m[t].m1, 0, 6 ));
01351
01352 _m[t].m1 = 0;
01353 _m[t].m3 = 0;
01354 SetHouseCompleted(t, true);
01355 }
01356 }
01357 }
01358 }
01359
01360
01361 UpdateHousesAndTowns();
01362
01363 if (IsSavegameVersionBefore(43)) {
01364 for (TileIndex t = 0; t < map_size; t++) {
01365 if (IsTileType(t, MP_INDUSTRY)) {
01366 switch (GetIndustryGfx(t)) {
01367 case GFX_POWERPLANT_SPARKS:
01368 _m[t].m3 = GB(_m[t].m1, 2, 5);
01369 break;
01370
01371 case GFX_OILWELL_ANIMATED_1:
01372 case GFX_OILWELL_ANIMATED_2:
01373 case GFX_OILWELL_ANIMATED_3:
01374 _m[t].m3 = GB(_m[t].m1, 0, 2);
01375 break;
01376
01377 case GFX_COAL_MINE_TOWER_ANIMATED:
01378 case GFX_COPPER_MINE_TOWER_ANIMATED:
01379 case GFX_GOLD_MINE_TOWER_ANIMATED:
01380 _m[t].m3 = _m[t].m1;
01381 break;
01382
01383 default:
01384 break;
01385 }
01386 }
01387 }
01388 }
01389
01390 if (IsSavegameVersionBefore(45)) {
01391 Vehicle *v;
01392
01393
01394
01395
01396
01397 FOR_ALL_VEHICLES(v) {
01398 ClrBit(v->vehicle_flags, 2);
01399 }
01400 }
01401
01402
01403
01404 if (IsSavegameVersionBefore(46)) {
01405 Waypoint *wp;
01406 FOR_ALL_WAYPOINTS(wp) {
01407 if ((wp->facilities & FACIL_DOCK) != 0 && IsTileOwner(wp->xy, OWNER_NONE) && TileHeight(wp->xy) == 0) SetTileOwner(wp->xy, OWNER_WATER);
01408 }
01409 }
01410
01411 if (IsSavegameVersionBefore(50)) {
01412 Aircraft *v;
01413
01414 FOR_ALL_AIRCRAFT(v) {
01415 if (v->subtype <= AIR_AIRCRAFT) {
01416 const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);
01417 v->cur_speed *= 128;
01418 v->cur_speed /= 10;
01419 v->acceleration = avi->acceleration;
01420 }
01421 }
01422 }
01423
01424 if (IsSavegameVersionBefore(49)) FOR_ALL_COMPANIES(c) c->face = ConvertFromOldCompanyManagerFace(c->face);
01425
01426 if (IsSavegameVersionBefore(52)) {
01427 for (TileIndex t = 0; t < map_size; t++) {
01428 if (IsStatueTile(t)) {
01429 _m[t].m2 = CalcClosestTownFromTile(t)->index;
01430 }
01431 }
01432 }
01433
01434
01435
01436
01437 if (IsSavegameVersionBefore(56)) {
01438 Town *t;
01439
01440 FOR_ALL_TOWNS(t) {
01441 if (_settings_game.economy.larger_towns != 0 && (t->index % _settings_game.economy.larger_towns) == 0) {
01442 t->larger_town = true;
01443 }
01444 }
01445 }
01446
01447 if (IsSavegameVersionBefore(57)) {
01448 Vehicle *v;
01449
01450 FOR_ALL_VEHICLES(v) {
01451 if ((v->type != VEH_TRAIN || Train::From(v)->IsFrontEngine()) &&
01452 !(v->vehstatus & (VS_STOPPED | VS_CRASHED)) &&
01453 v->current_order.IsType(OT_LOADING)) {
01454 Station::Get(v->last_station_visited)->loading_vehicles.push_back(v);
01455
01456
01457
01458 ClrBit(v->vehicle_flags, VF_LOADING_FINISHED);
01459 }
01460 }
01461 } else if (IsSavegameVersionBefore(59)) {
01462
01463
01464 Station *st;
01465 FOR_ALL_STATIONS(st) {
01466 std::list<Vehicle *>::iterator iter;
01467 for (iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end();) {
01468 Vehicle *v = *iter;
01469 iter++;
01470 if (!v->current_order.IsType(OT_LOADING)) st->loading_vehicles.remove(v);
01471 }
01472 }
01473 }
01474
01475 if (IsSavegameVersionBefore(58)) {
01476
01477
01478 if (_settings_game.difficulty.industry_density > 0) {
01479 _settings_game.difficulty.industry_density++;
01480 }
01481
01482
01483 _settings_game.difficulty.number_towns++;
01484 }
01485
01486 if (IsSavegameVersionBefore(64)) {
01487
01488
01489 for (TileIndex t = 0; t < map_size; t++) {
01490 if (IsTileType(t, MP_RAILWAY) && HasSignals(t)) {
01491
01492 SetSignalStates(t, GB(_m[t].m2, 4, 4));
01493 SB(_m[t].m2, 4, 4, 0);
01494
01495 SB(_m[t].m2, 4, 3, GB(_m[t].m2, 0, 3));
01496 }
01497 }
01498 }
01499
01500 if (IsSavegameVersionBefore(69)) {
01501
01502 RoadVehicle *rv;
01503 FOR_ALL_ROADVEHICLES(rv) {
01504 if (rv->state == 250 || rv->state == 251) {
01505 SetBit(rv->state, 2);
01506 }
01507 }
01508 }
01509
01510 if (IsSavegameVersionBefore(70)) {
01511
01512 Industry *i;
01513 FOR_ALL_INDUSTRIES(i) i->founder = OWNER_NONE;
01514 }
01515
01516
01517
01518 if (IsSavegameVersionBefore(82)) {
01519 for (TileIndex t = 0; t < map_size; t++) {
01520 if (IsTileType(t, MP_WATER) &&
01521 GetWaterTileType(t) == WATER_TILE_CLEAR &&
01522 GetTileOwner(t) == OWNER_WATER &&
01523 TileHeight(t) != 0) {
01524 SetTileOwner(t, OWNER_NONE);
01525 }
01526 }
01527 }
01528
01529
01530
01531
01532
01533
01534
01535 if (IsSavegameVersionBefore(83)) {
01536 for (TileIndex t = 0; t < map_size; t++) {
01537 if (IsShipDepotTile(t)) {
01538 _m[t].m4 = (TileHeight(t) == 0) ? OWNER_WATER : OWNER_NONE;
01539 }
01540 }
01541 }
01542
01543 if (IsSavegameVersionBefore(74)) {
01544 Station *st;
01545 FOR_ALL_STATIONS(st) {
01546 for (CargoID c = 0; c < NUM_CARGO; c++) {
01547 st->goods[c].last_speed = 0;
01548 if (st->goods[c].cargo.Count() != 0) SetBit(st->goods[c].acceptance_pickup, GoodsEntry::GES_PICKUP);
01549 }
01550 }
01551 }
01552
01553 if (IsSavegameVersionBefore(78)) {
01554 Industry *i;
01555 uint j;
01556 FOR_ALL_INDUSTRIES(i) {
01557 const IndustrySpec *indsp = GetIndustrySpec(i->type);
01558 for (j = 0; j < lengthof(i->produced_cargo); j++) {
01559 i->produced_cargo[j] = indsp->produced_cargo[j];
01560 }
01561 for (j = 0; j < lengthof(i->accepts_cargo); j++) {
01562 i->accepts_cargo[j] = indsp->accepts_cargo[j];
01563 }
01564 }
01565 }
01566
01567
01568
01569
01570
01571 if (IsSavegameVersionBefore(81)) {
01572 for (TileIndex t = 0; t < map_size; t++) {
01573 if (GetTileType(t) == MP_TREES) {
01574 TreeGround groundType = (TreeGround)GB(_m[t].m2, 4, 2);
01575 if (groundType != TREE_GROUND_SNOW_DESERT) SB(_m[t].m2, 6, 2, 3);
01576 }
01577 }
01578 }
01579
01580
01581 if (IsSavegameVersionBefore(93)) {
01582
01583 Order *order;
01584 FOR_ALL_ORDERS(order) order->ConvertFromOldSavegame();
01585
01586 Vehicle *v;
01587 FOR_ALL_VEHICLES(v) {
01588 if (v->orders.list != NULL && v->orders.list->GetFirstOrder() != NULL && v->orders.list->GetFirstOrder()->IsType(OT_NOTHING)) {
01589 v->orders.list->FreeChain();
01590 v->orders.list = NULL;
01591 }
01592
01593 v->current_order.ConvertFromOldSavegame();
01594 if (v->type == VEH_ROAD && v->IsPrimaryVehicle() && v->FirstShared() == v) {
01595 FOR_VEHICLE_ORDERS(v, order) order->SetNonStopType(ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS);
01596 }
01597 }
01598 } else if (IsSavegameVersionBefore(94)) {
01599
01600 Order *order;
01601 FOR_ALL_ORDERS(order) {
01602 if ((order->GetUnloadType() & (OUFB_UNLOAD | OUFB_TRANSFER)) == (OUFB_UNLOAD | OUFB_TRANSFER)) {
01603 order->SetUnloadType(OUFB_TRANSFER);
01604 order->SetLoadType(OLFB_NO_LOAD);
01605 }
01606 }
01607
01608 Vehicle *v;
01609 FOR_ALL_VEHICLES(v) {
01610 if ((v->current_order.GetUnloadType() & (OUFB_UNLOAD | OUFB_TRANSFER)) == (OUFB_UNLOAD | OUFB_TRANSFER)) {
01611 v->current_order.SetUnloadType(OUFB_TRANSFER);
01612 v->current_order.SetLoadType(OLFB_NO_LOAD);
01613 }
01614 }
01615 }
01616
01617 if (IsSavegameVersionBefore(84)) {
01618
01619
01620
01621
01622
01623
01624 FOR_ALL_COMPANIES(c) {
01625 for (uint i = 0; i < 4; i++) {
01626 CompanyID company = c->share_owners[i];
01627 if (company == INVALID_COMPANY) continue;
01628 if (!Company::IsValidID(company) || company == c->index) c->share_owners[i] = INVALID_COMPANY;
01629 }
01630 }
01631 }
01632
01633
01634 if (IsSavegameVersionBefore(146)) {
01635 for (TileIndex t = 0; t < map_size; t++) {
01636 switch (GetTileType(t)) {
01637 case MP_STATION:
01638 switch (GetStationType(t)) {
01639 case STATION_OILRIG:
01640 case STATION_DOCK:
01641 case STATION_BUOY:
01642 SetWaterClass(t, (WaterClass)GB(_m[t].m3, 0, 2));
01643 SB(_m[t].m3, 0, 2, 0);
01644 break;
01645
01646 default:
01647 SetWaterClass(t, WATER_CLASS_INVALID);
01648 break;
01649 }
01650 break;
01651
01652 case MP_WATER:
01653 SetWaterClass(t, (WaterClass)GB(_m[t].m3, 0, 2));
01654 SB(_m[t].m3, 0, 2, 0);
01655 break;
01656
01657 case MP_OBJECT:
01658 SetWaterClass(t, WATER_CLASS_INVALID);
01659 break;
01660
01661 default:
01662
01663 break;
01664 }
01665 }
01666 }
01667
01668 if (IsSavegameVersionBefore(86)) {
01669 for (TileIndex t = 0; t < map_size; t++) {
01670
01671 if (IsTileType(t, MP_WATER)) {
01672 if (GetWaterClass(t) != WATER_CLASS_RIVER) {
01673 if (IsWater(t)) {
01674 Owner o = GetTileOwner(t);
01675 if (o == OWNER_WATER) {
01676 MakeSea(t);
01677 } else {
01678 MakeCanal(t, o, Random());
01679 }
01680 } else if (IsShipDepot(t)) {
01681 Owner o = (Owner)_m[t].m4;
01682 SetWaterClass(t, o == OWNER_WATER ? WATER_CLASS_SEA : WATER_CLASS_CANAL);
01683 }
01684 }
01685 }
01686 }
01687
01688
01689
01690
01691 for (TileIndex t = 0; t < map_size; t++) {
01692 if (GetTileSlope(t) != SLOPE_FLAT) continue;
01693
01694 if (IsTileType(t, MP_WATER) && IsLock(t)) SetWaterClassDependingOnSurroundings(t, false);
01695 if (IsTileType(t, MP_STATION) && (IsDock(t) || IsBuoy(t))) SetWaterClassDependingOnSurroundings(t, false);
01696 }
01697 }
01698
01699 if (IsSavegameVersionBefore(87)) {
01700 for (TileIndex t = 0; t < map_size; t++) {
01701
01702 if ((IsTileType(t, MP_WATER) || IsBuoyTile(t)) &&
01703 (TileX(t) == 0 || TileY(t) == 0 || TileX(t) == MapMaxX() - 1 || TileY(t) == MapMaxY() - 1)) {
01704
01705
01706 SetWaterClass(t, WATER_CLASS_SEA);
01707 }
01708
01709 if (IsBuoyTile(t) || IsDriveThroughStopTile(t) || IsTileType(t, MP_WATER)) {
01710 Owner o = GetTileOwner(t);
01711 if (o < MAX_COMPANIES && !Company::IsValidID(o)) {
01712 Backup<CompanyByte> cur_company(_current_company, o, FILE_LINE);
01713 ChangeTileOwner(t, o, INVALID_OWNER);
01714 cur_company.Restore();
01715 }
01716 if (IsBuoyTile(t)) {
01717
01718
01719 Waypoint::GetByTile(t)->owner = OWNER_NONE;
01720 }
01721 } else if (IsTileType(t, MP_ROAD)) {
01722
01723 for (RoadType rt = ROADTYPE_ROAD; rt < ROADTYPE_END; rt++) {
01724
01725 Owner o = GetRoadOwner(t, rt);
01726 if (o < MAX_COMPANIES && !Company::IsValidID(o)) SetRoadOwner(t, rt, OWNER_NONE);
01727 }
01728 if (IsLevelCrossing(t)) {
01729 if (!Company::IsValidID(GetTileOwner(t))) FixOwnerOfRailTrack(t);
01730 }
01731 } else if (IsPlainRailTile(t)) {
01732 if (!Company::IsValidID(GetTileOwner(t))) FixOwnerOfRailTrack(t);
01733 }
01734 }
01735
01736
01737 if (_settings_game.pf.yapf.rail_use_yapf || IsSavegameVersionBefore(28)) {
01738 _settings_game.pf.pathfinder_for_trains = VPF_YAPF;
01739 } else {
01740 _settings_game.pf.pathfinder_for_trains = VPF_NPF;
01741 }
01742
01743 if (_settings_game.pf.yapf.road_use_yapf || IsSavegameVersionBefore(28)) {
01744 _settings_game.pf.pathfinder_for_roadvehs = VPF_YAPF;
01745 } else {
01746 _settings_game.pf.pathfinder_for_roadvehs = VPF_NPF;
01747 }
01748
01749 if (_settings_game.pf.yapf.ship_use_yapf) {
01750 _settings_game.pf.pathfinder_for_ships = VPF_YAPF;
01751 } else {
01752 _settings_game.pf.pathfinder_for_ships = (_settings_game.pf.new_pathfinding_all ? VPF_NPF : VPF_OPF);
01753 }
01754 }
01755
01756 if (IsSavegameVersionBefore(88)) {
01757
01758 Vehicle *v;
01759 FOR_ALL_VEHICLES(v) {
01760 v->profit_this_year <<= 8;
01761 v->profit_last_year <<= 8;
01762 v->running_ticks = 0;
01763 }
01764 }
01765
01766 if (IsSavegameVersionBefore(91)) {
01767
01768 for (TileIndex t = 0; t < map_size; t++) {
01769 if (IsTileType(t, MP_HOUSE) && GetHouseType(t) >= NEW_HOUSE_OFFSET) {
01770 SB(_m[t].m6, 2, 6, GB(_m[t].m6, 3, 5));
01771 SB(_m[t].m3, 5, 1, 0);
01772 }
01773 }
01774 }
01775
01776 if (IsSavegameVersionBefore(62)) {
01777
01778
01779 RoadVehicle *v;
01780 FOR_ALL_ROADVEHICLES(v) {
01781 if (v->First() == v && HasBit(EngInfo(v->engine_type)->misc_flags, EF_ROAD_TRAM)) {
01782 ShowErrorMessage(STR_WARNING_LOADGAME_REMOVED_TRAMS, INVALID_STRING_ID, WL_CRITICAL);
01783 delete v;
01784 }
01785 }
01786 }
01787
01788 if (IsSavegameVersionBefore(99)) {
01789 for (TileIndex t = 0; t < map_size; t++) {
01790
01791 if (IsTileType(t, MP_STATION) && IsOilRig(t)) {
01792 SetWaterClassDependingOnSurroundings(t, true);
01793 }
01794 if (IsTileType(t, MP_INDUSTRY)) {
01795 if ((GetIndustrySpec(GetIndustryType(t))->behaviour & INDUSTRYBEH_BUILT_ONWATER) != 0) {
01796 SetWaterClassDependingOnSurroundings(t, true);
01797 } else {
01798 SetWaterClass(t, WATER_CLASS_INVALID);
01799 }
01800 }
01801
01802
01803 if (IsTileType(t, MP_HOUSE) && IsHouseCompleted(t)) {
01804 _m[t].m5 = Clamp(_cur_year - (_m[t].m5 + ORIGINAL_BASE_YEAR), 0, 0xFF);
01805 }
01806 }
01807 }
01808
01809
01810
01811
01812 if (IsSavegameVersionBefore(100)) {
01813 for (TileIndex t = 0; t < map_size; t++) {
01814 switch (GetTileType(t)) {
01815 case MP_RAILWAY:
01816 if (HasSignals(t)) {
01817
01818 SetSignalVariant(t, TRACK_UPPER, HasBit(_m[t].m2, 2) ? SIG_SEMAPHORE : SIG_ELECTRIC);
01819 SetSignalVariant(t, TRACK_LOWER, HasBit(_m[t].m2, 6) ? SIG_SEMAPHORE : SIG_ELECTRIC);
01820 ClrBit(_m[t].m2, 2);
01821 ClrBit(_m[t].m2, 6);
01822 }
01823
01824
01825 if (IsRailDepot(t)) {
01826 SetDepotReservation(t, false);
01827 } else {
01828 SetTrackReservation(t, TRACK_BIT_NONE);
01829 }
01830 break;
01831
01832 case MP_ROAD:
01833 if (IsLevelCrossing(t)) SetCrossingReservation(t, false);
01834 break;
01835
01836 case MP_STATION:
01837 if (HasStationRail(t)) SetRailStationReservation(t, false);
01838 break;
01839
01840 case MP_TUNNELBRIDGE:
01841 if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) SetTunnelBridgeReservation(t, false);
01842 break;
01843
01844 default: break;
01845 }
01846 }
01847 }
01848
01849
01850 if (IsSavegameVersionBefore(101)) {
01851 const Train *t;
01852 FOR_ALL_TRAINS(t) {
01853 if (t->First() == t) t->ReserveTrackUnderConsist();
01854 }
01855 }
01856
01857 if (IsSavegameVersionBefore(102)) {
01858 for (TileIndex t = 0; t < map_size; t++) {
01859
01860 if (IsLevelCrossingTile(t)) UpdateLevelCrossing(t, false);
01861 }
01862 }
01863
01864 if (IsSavegameVersionBefore(103)) {
01865
01866 UpdateNearestTownForRoadTiles(false);
01867
01868
01869 Sign *si;
01870 FOR_ALL_SIGNS(si) {
01871 if (si->owner != OWNER_NONE && !Company::IsValidID(si->owner)) si->owner = OWNER_NONE;
01872 }
01873
01874
01875
01876 Station *st;
01877 FOR_ALL_STATIONS(st) {
01878 st->indtype = IT_INVALID;
01879 }
01880 }
01881
01882 if (IsSavegameVersionBefore(104)) {
01883 Aircraft *a;
01884 FOR_ALL_AIRCRAFT(a) {
01885
01886 if (!a->IsNormalAircraft()) {
01887 a->engine_type = a->First()->engine_type;
01888 }
01889 }
01890
01891
01892 Company *c;
01893 FOR_ALL_COMPANIES(c) {
01894 if (c->bankrupt_asked == 0xFF) c->bankrupt_asked = 0xFFFF;
01895 }
01896
01897 Engine *e;
01898 FOR_ALL_ENGINES(e) {
01899 if (e->company_avail == 0xFF) e->company_avail = 0xFFFF;
01900 }
01901
01902 Town *t;
01903 FOR_ALL_TOWNS(t) {
01904 if (t->have_ratings == 0xFF) t->have_ratings = 0xFFFF;
01905 for (uint i = 8; i != MAX_COMPANIES; i++) t->ratings[i] = RATING_INITIAL;
01906 }
01907 }
01908
01909 if (IsSavegameVersionBefore(112)) {
01910 for (TileIndex t = 0; t < map_size; t++) {
01911
01912
01913 if (IsTileType(t, MP_OBJECT) && HasBit(_m[t].m5, 7)) {
01914
01915
01916 _m[t].m3 = GB(_m[t].m5, 0, 5);
01917 _m[t].m5 = OBJECT_HQ;
01918 }
01919 }
01920 }
01921 if (IsSavegameVersionBefore(144)) {
01922 for (TileIndex t = 0; t < map_size; t++) {
01923 if (!IsTileType(t, MP_OBJECT)) continue;
01924
01925
01926 ObjectType type = GetObjectType(t);
01927 SB(_m[t].m6, 2, 4, type == OBJECT_HQ ? GB(_m[t].m3, 2, 3) : 0);
01928 _m[t].m3 = type == OBJECT_HQ ? GB(_m[t].m3, 1, 1) | GB(_m[t].m3, 0, 1) << 4 : 0;
01929
01930
01931 _m[t].m4 = 0;
01932 _me[t].m7 = 0;
01933 }
01934 }
01935
01936 if (IsSavegameVersionBefore(147) && Object::GetNumItems() == 0) {
01937
01938 for (TileIndex t = 0; t < map_size; t++) {
01939 if (!IsTileType(t, MP_OBJECT)) continue;
01940
01941 if (Town::GetNumItems() == 0) {
01942
01943 DoClearSquare(t);
01944 } else {
01945 uint offset = _m[t].m3;
01946
01947
01948 _m[t].m3 = GB(_m[t].m6, 2, 4);
01949 SB(_m[t].m6, 2, 4, 0);
01950
01951 if (offset == 0) {
01952
01953 ObjectType type = GetObjectType(t);
01954 int size = type == OBJECT_HQ ? 2 : 1;
01955
01956 if (!Object::CanAllocateItem()) {
01957
01958
01959 SlError(STR_ERROR_TOO_MANY_OBJECTS);
01960 }
01961
01962 Object *o = new Object();
01963 o->location.tile = t;
01964 o->location.w = size;
01965 o->location.h = size;
01966 o->build_date = _date;
01967 o->town = type == OBJECT_STATUE ? Town::Get(_m[t].m2) : CalcClosestTownFromTile(t, UINT_MAX);
01968 _m[t].m2 = o->index;
01969 Object::IncTypeCount(type);
01970 } else {
01971
01972 TileIndex northern_tile = t - TileXY(GB(offset, 0, 4), GB(offset, 4, 4));
01973 assert(IsTileType(northern_tile, MP_OBJECT));
01974 _m[t].m2 = _m[northern_tile].m2;
01975 }
01976 }
01977 }
01978 }
01979
01980 if (IsSavegameVersionBefore(113)) {
01981
01982 if (_settings_game.economy.town_layout == 0) {
01983 _settings_game.economy.allow_town_roads = false;
01984 _settings_game.economy.town_layout = TL_BETTER_ROADS;
01985 } else {
01986 _settings_game.economy.allow_town_roads = true;
01987 _settings_game.economy.town_layout = _settings_game.economy.town_layout - 1;
01988 }
01989
01990
01991
01992 Town *t;
01993 FOR_ALL_TOWNS(t) {
01994 if (_settings_game.economy.town_layout != TL_RANDOM) {
01995 t->layout = _settings_game.economy.town_layout;
01996 continue;
01997 }
01998
01999
02000 byte layout = TileHash(TileX(t->xy), TileY(t->xy)) % 6;
02001 switch (layout) {
02002 default: break;
02003 case 5: layout = 1; break;
02004 case 0: layout = 2; break;
02005 }
02006 t->layout = layout - 1;
02007 }
02008 }
02009
02010 if (IsSavegameVersionBefore(114)) {
02011
02012
02013
02014 Station *st;
02015 FOR_ALL_STATIONS(st) {
02016 if (!Company::IsValidID(st->owner)) st->owner = OWNER_NONE;
02017 }
02018 }
02019
02020
02021 if (IsSavegameVersionBefore(117)) {
02022 Order *o;
02023 FOR_ALL_ORDERS(o) {
02024 if (o->IsType(OT_GOTO_STATION)) o->SetStopLocation(OSL_PLATFORM_FAR_END);
02025 }
02026 }
02027
02028 if (IsSavegameVersionBefore(120)) {
02029 extern VehicleDefaultSettings _old_vds;
02030 Company *c;
02031 FOR_ALL_COMPANIES(c) {
02032 c->settings.vehicle = _old_vds;
02033 }
02034 }
02035
02036 if (IsSavegameVersionBefore(121)) {
02037
02038 Vehicle *v;
02039 FOR_ALL_DISASTERVEHICLES(v) {
02040 if (v->subtype == 2 && v->current_order.GetDestination() != 0) {
02041 const Vehicle *u = Vehicle::GetIfValid(v->dest_tile);
02042 if (u == NULL || u->type != VEH_ROAD || !RoadVehicle::From(u)->IsFrontEngine()) {
02043 delete v;
02044 }
02045 }
02046 }
02047
02048
02049
02050
02051
02052
02053
02054 Station *st;
02055 FOR_ALL_STATIONS(st) {
02056 std::list<Vehicle *>::iterator iter;
02057 for (iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end(); ++iter) {
02058
02059
02060 assert_compile(CargoPaymentPool::MAX_SIZE == VehiclePool::MAX_SIZE);
02061 assert(CargoPayment::CanAllocateItem());
02062 Vehicle *v = *iter;
02063 if (v->cargo_payment == NULL) v->cargo_payment = new CargoPayment(v);
02064 }
02065 }
02066 }
02067
02068 if (IsSavegameVersionBefore(122)) {
02069
02070
02071
02072 extern TileIndex *_animated_tile_list;
02073 extern uint _animated_tile_count;
02074
02075 for (uint i = 0; i < _animated_tile_count; ) {
02076
02077 bool remove = _tile_type_procs[GetTileType(_animated_tile_list[i])]->animate_tile_proc == NULL;
02078
02079
02080 for (uint j = 0; !remove && j < i; j++) {
02081 remove = _animated_tile_list[i] == _animated_tile_list[j];
02082 }
02083
02084 if (remove) {
02085 DeleteAnimatedTile(_animated_tile_list[i]);
02086 } else {
02087 i++;
02088 }
02089 }
02090 }
02091
02092 if (IsSavegameVersionBefore(124) && !IsSavegameVersionBefore(1)) {
02093
02094 Waypoint *wp;
02095 FOR_ALL_WAYPOINTS(wp) {
02096 if (wp->facilities & FACIL_TRAIN) {
02097 wp->train_station.tile = wp->xy;
02098 wp->train_station.w = 1;
02099 wp->train_station.h = 1;
02100 } else {
02101 wp->train_station.tile = INVALID_TILE;
02102 wp->train_station.w = 0;
02103 wp->train_station.h = 0;
02104 }
02105 }
02106 }
02107
02108 if (IsSavegameVersionBefore(125)) {
02109
02110 Subsidy *s;
02111 FOR_ALL_SUBSIDIES(s) {
02112 if (s->remaining < 12) {
02113
02114 s->remaining = 12 - s->remaining;
02115 s->awarded = INVALID_COMPANY;
02116 const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
02117 switch (cs->town_effect) {
02118 case TE_PASSENGERS:
02119 case TE_MAIL:
02120
02121 s->src_type = s->dst_type = ST_TOWN;
02122 if (Town::IsValidID(s->src) && Town::IsValidID(s->dst)) continue;
02123 break;
02124 case TE_GOODS:
02125 case TE_FOOD:
02126
02127 s->src_type = ST_INDUSTRY;
02128 s->dst_type = ST_TOWN;
02129 if (Industry::IsValidID(s->src) && Town::IsValidID(s->dst)) continue;
02130 break;
02131 default:
02132
02133 s->src_type = s->dst_type = ST_INDUSTRY;
02134 if (Industry::IsValidID(s->src) && Industry::IsValidID(s->dst)) continue;
02135 break;
02136 }
02137 } else {
02138
02139
02140
02141 s->remaining = 24 - s->remaining;
02142 const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
02143 switch (cs->town_effect) {
02144 case TE_PASSENGERS:
02145 case TE_MAIL: {
02146
02147 const Station *ss = Station::GetIfValid(s->src);
02148 const Station *sd = Station::GetIfValid(s->dst);
02149 if (ss != NULL && sd != NULL && ss->owner == sd->owner &&
02150 Company::IsValidID(ss->owner)) {
02151 s->src_type = s->dst_type = ST_TOWN;
02152 s->src = ss->town->index;
02153 s->dst = sd->town->index;
02154 s->awarded = ss->owner;
02155 continue;
02156 }
02157 break;
02158 }
02159 default:
02160 break;
02161 }
02162 }
02163
02164 delete s;
02165 }
02166 }
02167
02168 if (IsSavegameVersionBefore(126)) {
02169
02170
02171
02172
02173
02174
02175 uint64 aimed_inflation = (_economy.old_max_loan_unround << 16 | _economy.old_max_loan_unround_fract) / _settings_game.difficulty.max_loan;
02176
02177
02178 if (aimed_inflation > MAX_INFLATION) aimed_inflation = MAX_INFLATION;
02179
02180
02181 while (_economy.inflation_prices < aimed_inflation) {
02182 if (AddInflation(false)) break;
02183 }
02184 }
02185
02186 if (IsSavegameVersionBefore(127)) {
02187 Station *st;
02188 FOR_ALL_STATIONS(st) UpdateStationAcceptance(st, false);
02189 }
02190
02191 if (IsSavegameVersionBefore(128)) {
02192 const Depot *d;
02193 FOR_ALL_DEPOTS(d) {
02194 _m[d->xy].m2 = d->index;
02195 if (IsTileType(d->xy, MP_WATER)) _m[GetOtherShipDepotTile(d->xy)].m2 = d->index;
02196 }
02197 }
02198
02199
02200
02201 if (IsSavegameVersionBefore(131)) {
02202 Train *t;
02203 FOR_ALL_TRAINS(t) {
02204 if (t->force_proceed != TFP_NONE) {
02205 t->force_proceed = TFP_STUCK;
02206 }
02207 }
02208 }
02209
02210
02211
02212 if (IsSavegameVersionBefore(135)) {
02213 for (TileIndex t = 0; t < map_size; t++) {
02214 if (IsTileType(t, MP_CLEAR)) {
02215 if (GetRawClearGround(t) == CLEAR_SNOW) {
02216 SetClearGroundDensity(t, CLEAR_GRASS, GetClearDensity(t));
02217 SetBit(_m[t].m3, 4);
02218 } else {
02219 ClrBit(_m[t].m3, 4);
02220 }
02221 }
02222 if (IsTileType(t, MP_TREES)) {
02223 uint density = GB(_m[t].m2, 6, 2);
02224 uint ground = GB(_m[t].m2, 4, 2);
02225 uint counter = GB(_m[t].m2, 0, 4);
02226 _m[t].m2 = ground << 6 | density << 4 | counter;
02227 }
02228 }
02229 }
02230
02231
02232 if (IsSavegameVersionBefore(136)) {
02233 Aircraft *a;
02234 FOR_ALL_AIRCRAFT(a) {
02235 a->turn_counter = a->current_order.IsType(OT_LOADING) ? 0 : a->load_unload_ticks;
02236 }
02237
02238 Train *t;
02239 FOR_ALL_TRAINS(t) {
02240 t->wait_counter = t->current_order.IsType(OT_LOADING) ? 0 : t->load_unload_ticks;
02241 }
02242 }
02243
02244
02245 if (IsSavegameVersionBefore(137)) {
02246 struct AirportTileConversion {
02247 byte old_start;
02248 byte num_frames;
02249 };
02250 static const AirportTileConversion atc[] = {
02251 {31, 12},
02252 {50, 4},
02253 {62, 2},
02254 {66, 12},
02255 {78, 12},
02256 {101, 10},
02257 {111, 8},
02258 {119, 15},
02259 {140, 4},
02260 };
02261 for (TileIndex t = 0; t < map_size; t++) {
02262 if (IsAirportTile(t)) {
02263 StationGfx old_gfx = GetStationGfx(t);
02264 byte offset = 0;
02265 for (uint i = 0; i < lengthof(atc); i++) {
02266 if (old_gfx < atc[i].old_start) {
02267 SetStationGfx(t, old_gfx - offset);
02268 break;
02269 }
02270 if (old_gfx < atc[i].old_start + atc[i].num_frames) {
02271 SetAnimationFrame(t, old_gfx - atc[i].old_start);
02272 SetStationGfx(t, atc[i].old_start - offset);
02273 break;
02274 }
02275 offset += atc[i].num_frames - 1;
02276 }
02277 }
02278 }
02279 }
02280
02281 if (IsSavegameVersionBefore(140)) {
02282 Station *st;
02283 FOR_ALL_STATIONS(st) {
02284 if (st->airport.tile != INVALID_TILE) {
02285 st->airport.w = st->airport.GetSpec()->size_x;
02286 st->airport.h = st->airport.GetSpec()->size_y;
02287 }
02288 }
02289 }
02290
02291 if (IsSavegameVersionBefore(141)) {
02292 for (TileIndex t = 0; t < map_size; t++) {
02293
02294 if (IsTileType(t, MP_VOID)) SetTropicZone(t, TROPICZONE_NORMAL);
02295 }
02296
02297
02298
02299
02300 Depot *d;
02301 FOR_ALL_DEPOTS(d) d->town_cn = UINT16_MAX;
02302
02303 FOR_ALL_DEPOTS(d) MakeDefaultName(d);
02304 }
02305
02306 if (IsSavegameVersionBefore(142)) {
02307 Depot *d;
02308 FOR_ALL_DEPOTS(d) d->build_date = _date;
02309 }
02310
02311
02312
02313
02314
02315
02316 if (IsSavegameVersionBefore(146)) {
02317 Aircraft *v;
02318 FOR_ALL_AIRCRAFT(v) {
02319 if (!v->IsNormalAircraft()) continue;
02320 Station *st = GetTargetAirportIfValid(v);
02321 if (st == NULL && v->state != FLYING) {
02322 v->state = FLYING;
02323 UpdateAircraftCache(v);
02324 AircraftNextAirportPos_and_Order(v);
02325
02326 if ((v->vehstatus & VS_CRASHED) == 0) SetAircraftPosition(v, v->x_pos, v->y_pos, GetAircraftFlyingAltitude(v));
02327 }
02328 }
02329 }
02330
02331
02332 if (IsSavegameVersionBefore(147)) {
02333 for (TileIndex t = 0; t < map_size; t++) {
02334 switch (GetTileType(t)) {
02335 case MP_HOUSE:
02336 if (GetHouseType(t) >= NEW_HOUSE_OFFSET) {
02337 uint per_proc = _me[t].m7;
02338 _me[t].m7 = GB(_m[t].m6, 2, 6) | (GB(_m[t].m3, 5, 1) << 6);
02339 SB(_m[t].m3, 5, 1, 0);
02340 SB(_m[t].m6, 2, 6, min(per_proc, 63));
02341 }
02342 break;
02343
02344 case MP_INDUSTRY: {
02345 uint rand = _me[t].m7;
02346 _me[t].m7 = _m[t].m3;
02347 _m[t].m3 = rand;
02348 break;
02349 }
02350
02351 case MP_OBJECT:
02352 _me[t].m7 = _m[t].m3;
02353 _m[t].m3 = 0;
02354 break;
02355
02356 default:
02357
02358 break;
02359 }
02360 }
02361 }
02362
02363
02364 if (IsSavegameVersionBefore(148)) {
02365 Object *o;
02366 FOR_ALL_OBJECTS(o) {
02367 Owner owner = GetTileOwner(o->location.tile);
02368 o->colour = (owner == OWNER_NONE) ? Random() & 0xF : Company::Get(owner)->livery->colour1;
02369 }
02370 }
02371
02372 if (IsSavegameVersionBefore(149)) {
02373 for (TileIndex t = 0; t < map_size; t++) {
02374 if (!IsTileType(t, MP_STATION)) continue;
02375 if (!IsBuoy(t) && !IsOilRig(t) && !(IsDock(t) && GetTileSlope(t) == SLOPE_FLAT)) {
02376 SetWaterClass(t, WATER_CLASS_INVALID);
02377 }
02378 }
02379
02380
02381
02382
02383
02384 Waypoint *wp;
02385 FOR_ALL_WAYPOINTS(wp) {
02386 if (wp->name != NULL) wp->town_cn = UINT16_MAX;
02387 }
02388
02389 FOR_ALL_WAYPOINTS(wp) {
02390 if (wp->name != NULL) MakeDefaultName(wp);
02391 }
02392 }
02393
02394 if (IsSavegameVersionBefore(152)) {
02395 _industry_builder.Reset();
02396
02397
02398
02399
02400 Vehicle *v;
02401 FOR_ALL_VEHICLES(v) {
02402
02403
02404 if (!v->IsGroundVehicle()) continue;
02405
02406
02407 if (!IsTunnelTile(v->tile)) continue;
02408
02409
02410 TileIndex vtile = TileVirtXY(v->x_pos, v->y_pos);
02411 if (!IsTunnelTile(vtile)) continue;
02412
02413
02414 if (GetSlopePixelZ(v->x_pos, v->y_pos) != v->z_pos) continue;
02415
02416
02417 const DiagDirection dir = GetTunnelBridgeDirection(vtile);
02418 const DiagDirection vdir = DirToDiagDir(v->direction);
02419
02420
02421 byte pos = (DiagDirToAxis(vdir) == AXIS_X ? v->x_pos : v->y_pos) & TILE_UNIT_MASK;
02422 byte frame = (vdir == DIAGDIR_NE || vdir == DIAGDIR_NW) ? TILE_SIZE - 1 - pos : pos;
02423 extern const byte _tunnel_visibility_frame[DIAGDIR_END];
02424
02425
02426 bool hidden;
02427 if (dir == vdir) {
02428 hidden = frame >= _tunnel_visibility_frame[dir];
02429 v->tile = vtile;
02430 } else if (dir == ReverseDiagDir(vdir)) {
02431 hidden = frame < TILE_SIZE - _tunnel_visibility_frame[dir];
02432
02433 v->tile = hidden ? GetOtherTunnelBridgeEnd(vtile) : vtile;
02434 } else {
02435
02436
02437
02438
02439
02440 continue;
02441 }
02442
02443 if (hidden) {
02444 v->vehstatus |= VS_HIDDEN;
02445
02446 switch (v->type) {
02447 case VEH_TRAIN: Train::From(v)->track = TRACK_BIT_WORMHOLE; break;
02448 case VEH_ROAD: RoadVehicle::From(v)->state = RVSB_WORMHOLE; break;
02449 default: NOT_REACHED();
02450 }
02451 } else {
02452 v->vehstatus &= ~VS_HIDDEN;
02453
02454 switch (v->type) {
02455 case VEH_TRAIN: Train::From(v)->track = DiagDirToDiagTrackBits(vdir); break;
02456 case VEH_ROAD: RoadVehicle::From(v)->state = DiagDirToDiagTrackdir(vdir); RoadVehicle::From(v)->frame = frame; break;
02457 default: NOT_REACHED();
02458 }
02459 }
02460 }
02461 }
02462
02463 if (IsSavegameVersionBefore(153)) {
02464 RoadVehicle *rv;
02465 FOR_ALL_ROADVEHICLES(rv) {
02466 if (rv->state == RVSB_IN_DEPOT || rv->state == RVSB_WORMHOLE) continue;
02467
02468 bool loading = rv->current_order.IsType(OT_LOADING) || rv->current_order.IsType(OT_LEAVESTATION);
02469 if (HasBit(rv->state, RVS_IN_ROAD_STOP)) {
02470 extern const byte _road_stop_stop_frame[];
02471 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)]);
02472 } else if (HasBit(rv->state, RVS_IN_DT_ROAD_STOP)) {
02473 SB(rv->state, RVS_ENTERED_STOP, 1, loading || rv->frame > RVC_DRIVE_THROUGH_STOP_FRAME);
02474 }
02475 }
02476 }
02477
02478 if (IsSavegameVersionBefore(156)) {
02479
02480 Train *t;
02481 FOR_ALL_TRAINS(t) {
02482 if (!HasBit(t->flags, 5)) continue;
02483
02484 ClrBit(t->flags, 5);
02485 SetBit(t->vehicle_flags, VF_PATHFINDER_LOST);
02486 }
02487
02488
02489 Company *c;
02490 FOR_ALL_COMPANIES(c) {
02491 c->terraform_limit = _settings_game.construction.terraform_frame_burst << 16;
02492 c->clear_limit = _settings_game.construction.clear_frame_burst << 16;
02493 }
02494 }
02495
02496 if (IsSavegameVersionBefore(158)) {
02497 Vehicle *v;
02498 FOR_ALL_VEHICLES(v) {
02499 switch (v->type) {
02500 case VEH_TRAIN: {
02501 Train *t = Train::From(v);
02502
02503
02504
02505
02506
02507 ClrBit(t->flags, 1);
02508 ClrBit(t->flags, 2);
02509
02510
02511 ClrBit(t->gv_flags, GVF_GOINGUP_BIT);
02512 ClrBit(t->gv_flags, GVF_GOINGDOWN_BIT);
02513
02514
02515 if (t->vehstatus & VS_CRASHED) break;
02516
02517
02518 if (t->track != TRACK_BIT_X && t->track != TRACK_BIT_Y) break;
02519
02520 t->gv_flags |= FixVehicleInclination(t, t->direction);
02521 break;
02522 }
02523 case VEH_ROAD: {
02524 RoadVehicle *rv = RoadVehicle::From(v);
02525 ClrBit(rv->gv_flags, GVF_GOINGUP_BIT);
02526 ClrBit(rv->gv_flags, GVF_GOINGDOWN_BIT);
02527
02528
02529 if (rv->vehstatus & VS_CRASHED) break;
02530
02531 if (rv->state == RVSB_IN_DEPOT || rv->state == RVSB_WORMHOLE) break;
02532
02533 TrackStatus ts = GetTileTrackStatus(rv->tile, TRANSPORT_ROAD, rv->compatible_roadtypes);
02534 TrackBits trackbits = TrackStatusToTrackBits(ts);
02535
02536
02537 if (trackbits != TRACK_BIT_X && trackbits != TRACK_BIT_Y) break;
02538
02539 Direction dir = rv->direction;
02540
02541
02542 Axis a = trackbits == TRACK_BIT_X ? AXIS_X : AXIS_Y;
02543 if (AxisToDirection(a) != dir &&
02544 AxisToDirection(a) != ReverseDir(dir)) {
02545
02546
02547 dir = INVALID_DIR;
02548 }
02549
02550 rv->gv_flags |= FixVehicleInclination(rv, dir);
02551 break;
02552 }
02553 case VEH_SHIP:
02554 break;
02555
02556 default:
02557 continue;
02558 }
02559
02560 if (IsBridgeTile(v->tile) && TileVirtXY(v->x_pos, v->y_pos) == v->tile) {
02561
02562
02563
02564 v->z_pos = GetSlopePixelZ(v->x_pos, v->y_pos);
02565 DiagDirection dir = GetTunnelBridgeDirection(v->tile);
02566 if (v->type == VEH_TRAIN && !(v->vehstatus & VS_CRASHED) &&
02567 v->direction != DiagDirToDir(dir)) {
02568
02569
02570
02571
02572 Train::From(v)->track = DiagDirToDiagTrackBits(dir);
02573 }
02574 }
02575
02576
02577
02578 assert(v->tile != TileVirtXY(v->x_pos, v->y_pos) || v->z_pos == GetSlopePixelZ(v->x_pos, v->y_pos));
02579 }
02580
02581
02582 FOR_ALL_VEHICLES(v) {
02583 if (!v->IsPrimaryVehicle()) continue;
02584
02585
02586 if (v->cur_implicit_order_index >= v->GetNumOrders()) v->cur_implicit_order_index = 0;
02587
02588 v->cur_real_order_index = v->cur_implicit_order_index;
02589 v->UpdateRealOrderIndex();
02590 }
02591 }
02592
02593 if (IsSavegameVersionBefore(159)) {
02594
02595
02596
02597
02598
02599
02600 _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);
02601
02602 Train *t;
02603 FOR_ALL_TRAINS(t) {
02604 _settings_game.vehicle.max_train_length = max<uint8>(_settings_game.vehicle.max_train_length, CeilDiv(t->gcache.cached_total_length, TILE_SIZE));
02605 }
02606 }
02607
02608 if (IsSavegameVersionBefore(160)) {
02609
02610
02611 if (_settings_game.difficulty.industry_density > 0) {
02612 _settings_game.difficulty.industry_density++;
02613 }
02614 }
02615
02616 if (IsSavegameVersionBefore(161)) {
02617
02618
02619 if (!IsSavegameVersionBefore(76)) {
02620 Industry *ind;
02621 FOR_ALL_INDUSTRIES(ind) {
02622 assert(ind->psa != NULL);
02623
02624
02625 bool is_empty = true;
02626 for (uint i = 0; i < sizeof(ind->psa->storage); i++) {
02627 if (ind->psa->GetValue(i) != 0) {
02628 is_empty = false;
02629 break;
02630 }
02631 }
02632
02633 if (!is_empty) {
02634 ind->psa->grfid = _industry_mngr.GetGRFID(ind->type);
02635 } else {
02636 delete ind->psa;
02637 ind->psa = NULL;
02638 }
02639 }
02640 }
02641
02642 if (!IsSavegameVersionBefore(145)) {
02643 Station *st;
02644 FOR_ALL_STATIONS(st) {
02645 if (!(st->facilities & FACIL_AIRPORT)) continue;
02646 assert(st->airport.psa != NULL);
02647
02648
02649 bool is_empty = true;
02650 for (uint i = 0; i < sizeof(st->airport.psa->storage); i++) {
02651 if (st->airport.psa->GetValue(i) != 0) {
02652 is_empty = false;
02653 break;
02654 }
02655 }
02656
02657 if (!is_empty) {
02658 st->airport.psa->grfid = _airport_mngr.GetGRFID(st->airport.type);
02659 } else {
02660 delete st->airport.psa;
02661 st->airport.psa = NULL;
02662
02663 }
02664 }
02665 }
02666 }
02667
02668
02669 if (IsSavegameVersionBefore(164) && _settings_game.game_creation.snow_line_height >= MIN_SNOWLINE_HEIGHT * TILE_HEIGHT) {
02670 _settings_game.game_creation.snow_line_height /= TILE_HEIGHT;
02671 }
02672
02673 if (IsSavegameVersionBefore(164) && !IsSavegameVersionBefore(32)) {
02674
02675 for (TileIndex t = 0; t < map_size; t++) {
02676 if (!IsTileType(t, MP_CLEAR) && !IsTileType(t, MP_TREES)) continue;
02677 if (IsTileType(t, MP_CLEAR) && IsClearGround(t, CLEAR_FIELDS)) continue;
02678 uint fence = GB(_m[t].m4, 5, 3);
02679 if (fence != 0 && IsTileType(TILE_ADDXY(t, 1, 0), MP_CLEAR) && IsClearGround(TILE_ADDXY(t, 1, 0), CLEAR_FIELDS)) {
02680 SetFenceNE(TILE_ADDXY(t, 1, 0), fence);
02681 }
02682 fence = GB(_m[t].m4, 2, 3);
02683 if (fence != 0 && IsTileType(TILE_ADDXY(t, 0, 1), MP_CLEAR) && IsClearGround(TILE_ADDXY(t, 0, 1), CLEAR_FIELDS)) {
02684 SetFenceNW(TILE_ADDXY(t, 0, 1), fence);
02685 }
02686 SB(_m[t].m4, 2, 3, 0);
02687 SB(_m[t].m4, 5, 3, 0);
02688 }
02689 }
02690
02691
02692 if (IsSavegameVersionBefore(164)) FixupTrainLengths();
02693
02694 if (IsSavegameVersionBefore(165)) {
02695 Town *t;
02696
02697 FOR_ALL_TOWNS(t) {
02698
02699 switch (_settings_game.game_creation.landscape) {
02700 case LT_ARCTIC:
02701 if (FindFirstCargoWithTownEffect(TE_FOOD) != NULL) t->goal[TE_FOOD] = TOWN_GROWTH_WINTER;
02702 break;
02703
02704 case LT_TROPIC:
02705 if (FindFirstCargoWithTownEffect(TE_FOOD) != NULL) t->goal[TE_FOOD] = TOWN_GROWTH_DESERT;
02706 if (FindFirstCargoWithTownEffect(TE_WATER) != NULL) t->goal[TE_WATER] = TOWN_GROWTH_DESERT;
02707 break;
02708 }
02709 }
02710 }
02711
02712 if (IsSavegameVersionBefore(165)) {
02713
02714 _saved_scrollpos_zoom = _saved_scrollpos_zoom + ZOOM_LVL_SHIFT;
02715 _saved_scrollpos_x *= ZOOM_LVL_BASE;
02716 _saved_scrollpos_y *= ZOOM_LVL_BASE;
02717 }
02718
02719
02720
02721
02722 if (gcf_res != GLC_ALL_GOOD) StartupEngines();
02723
02724 if (IsSavegameVersionBefore(166)) {
02725
02726 for (TileIndex t = 0; t < map_size; t++) {
02727 if (!IsTileType(t, MP_HOUSE)) continue;
02728 Town::Get(GetTownIndex(t))->cargo_accepted.Add(t);
02729 }
02730
02731 Town *town;
02732 FOR_ALL_TOWNS(town) {
02733 UpdateTownCargoes(town);
02734 }
02735 }
02736
02737
02738 if (IsSavegameVersionBefore(172)) {
02739 for (TileIndex t = 0; t < map_size; t++) {
02740 if (!IsStandardRoadStopTile(t)) continue;
02741 Owner o = GetTileOwner(t);
02742 SetRoadOwner(t, ROADTYPE_ROAD, o);
02743 SetRoadOwner(t, ROADTYPE_TRAM, o);
02744 }
02745 }
02746
02747 if (IsSavegameVersionBefore(175)) {
02748
02749 Company *c;
02750 FOR_ALL_COMPANIES(c) c->tree_limit = _settings_game.construction.tree_frame_burst << 16;
02751 }
02752
02753 if (IsSavegameVersionBefore(177)) {
02754
02755 if (_economy.inflation_prices > MAX_INFLATION) _economy.inflation_prices = MAX_INFLATION;
02756 if (_economy.inflation_payment > MAX_INFLATION) _economy.inflation_payment = MAX_INFLATION;
02757
02758
02759 FOR_ALL_COMPANIES(c) {
02760 c->months_of_bankruptcy = 3 * c->months_of_bankruptcy;
02761 }
02762 }
02763
02764 if (IsSavegameVersionBefore(178)) {
02765 extern uint8 _old_diff_level;
02766
02767 _settings_game.script.settings_profile = IsInsideMM(_old_diff_level, SP_BEGIN, SP_END) ? _old_diff_level : (uint)SP_MEDIUM;
02768 }
02769
02770 if (IsSavegameVersionBefore(182)) {
02771 Aircraft *v;
02772
02773 FOR_ALL_AIRCRAFT(v) {
02774 if (v->subtype <= AIR_AIRCRAFT) {
02775 const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);
02776 v->acceleration = avi->acceleration;
02777 }
02778 }
02779
02780
02781
02782 for (TileIndex t = 0; t < map_size; t++) {
02783 if (HasStationTileRail(t) && IsStationTileBlocked(t)) {
02784 SetRailStationReservation(t, false);
02785 }
02786 }
02787 }
02788
02789
02790 AfterLoadRoadStops();
02791 AfterLoadLabelMaps();
02792 AfterLoadCompanyStats();
02793
02794 GamelogPrintDebug(1);
02795
02796 InitializeWindowsAndCaches();
02797
02798 ResetSignalHandlers();
02799 return true;
02800 }
02801
02810 void ReloadNewGRFData()
02811 {
02812
02813 GfxLoadSprites();
02814 LoadStringWidthTable();
02815 RecomputePrices();
02816
02817 ResetVehicleHash();
02818 AfterLoadVehicles(false);
02819 StartupEngines();
02820 GroupStatistics::UpdateAfterLoad();
02821
02822 AfterLoadStations();
02823
02824 AfterLoadCompanyStats();
02825
02826 UpdateHousesAndTowns();
02827
02828 DeleteInvalidEngineNews();
02829
02830 for (CompanyID i = COMPANY_FIRST; i < MAX_COMPANIES; i++) InvalidateWindowData(WC_COMPANY_COLOUR, i);
02831
02832 InvalidateWindowClassesData(WC_COMPANY_INFRASTRUCTURE);
02833
02834 MarkWholeScreenDirty();
02835 CheckTrainsLengths();
02836 }