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 if (HasBit(_m[t].m2, 2)) SetSignalType(t, TRACK_X, SIGTYPE_COMBO);
01201
01202
01203 SetSignalVariant(t, TRACK_X, HasBit(_m[t].m2, 3) ? SIG_SEMAPHORE : SIG_ELECTRIC);
01204 ClrBit(_m[t].m2, 3);
01205 }
01206
01207
01208 if (!IsRailDepotTile(t)) {
01209 SB(_m[t].m4, 4, 4, 0);
01210 } else {
01211 ClrBit(_m[t].m3, 6);
01212 }
01213 break;
01214
01215 case MP_STATION:
01216 ClrBit(_m[t].m3, 6);
01217 break;
01218
01219 default: break;
01220 }
01221 }
01222 }
01223
01224 if (IsSavegameVersionBefore(25)) {
01225 RoadVehicle *rv;
01226 FOR_ALL_ROADVEHICLES(rv) {
01227 rv->vehstatus &= ~0x40;
01228 }
01229 }
01230
01231 if (IsSavegameVersionBefore(26)) {
01232 Station *st;
01233 FOR_ALL_STATIONS(st) {
01234 st->last_vehicle_type = VEH_INVALID;
01235 }
01236 }
01237
01238 YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK);
01239
01240 if (IsSavegameVersionBefore(34)) {
01241 Company *c;
01242 FOR_ALL_COMPANIES(c) ResetCompanyLivery(c);
01243 }
01244
01245 Company *c;
01246 FOR_ALL_COMPANIES(c) {
01247 c->avail_railtypes = GetCompanyRailtypes(c->index);
01248 c->avail_roadtypes = GetCompanyRoadtypes(c->index);
01249 }
01250
01251 if (!IsSavegameVersionBefore(27)) AfterLoadStations();
01252
01253
01254
01255 if (IsSavegameVersionBefore(31)) {
01256 Station *st;
01257 Waypoint *wp;
01258 Engine *e;
01259 Industry *i;
01260 Vehicle *v;
01261
01262 _date += DAYS_TILL_ORIGINAL_BASE_YEAR;
01263 _cur_year += ORIGINAL_BASE_YEAR;
01264
01265 FOR_ALL_STATIONS(st) st->build_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
01266 FOR_ALL_WAYPOINTS(wp) wp->build_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
01267 FOR_ALL_ENGINES(e) e->intro_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
01268 FOR_ALL_COMPANIES(c) c->inaugurated_year += ORIGINAL_BASE_YEAR;
01269 FOR_ALL_INDUSTRIES(i) i->last_prod_year += ORIGINAL_BASE_YEAR;
01270
01271 FOR_ALL_VEHICLES(v) {
01272 v->date_of_last_service += DAYS_TILL_ORIGINAL_BASE_YEAR;
01273 v->build_year += ORIGINAL_BASE_YEAR;
01274 }
01275 }
01276
01277
01278
01279
01280 if (IsSavegameVersionBefore(32)) {
01281 Industry *i;
01282
01283 for (TileIndex t = 0; t < map_size; t++) {
01284 if (IsTileType(t, MP_CLEAR) && IsClearGround(t, CLEAR_FIELDS)) {
01285
01286 MakeClear(t, CLEAR_GRASS, 3);
01287 }
01288 }
01289
01290 FOR_ALL_INDUSTRIES(i) {
01291 uint j;
01292
01293 if (GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_PLANT_ON_BUILT) {
01294 for (j = 0; j != 50; j++) PlantRandomFarmField(i);
01295 }
01296 }
01297 }
01298
01299
01300 if (IsSavegameVersionBefore(36)) {
01301 Order *order;
01302 Vehicle *v;
01303
01304 FOR_ALL_ORDERS(order) {
01305 order->SetRefit(CT_NO_REFIT);
01306 }
01307
01308 FOR_ALL_VEHICLES(v) {
01309 v->current_order.SetRefit(CT_NO_REFIT);
01310 }
01311 }
01312
01313
01314
01315 if (IsSavegameVersionBefore(38)) _settings_game.vehicle.disable_elrails = false;
01316
01317 SettingsDisableElrail(_settings_game.vehicle.disable_elrails);
01318 InitializeRailGUI();
01319
01320
01321
01322 if (IsSavegameVersionBefore(53)) {
01323 for (TileIndex t = 0; t < map_size; t++) {
01324 if (IsTileType(t, MP_HOUSE)) {
01325 if (GB(_m[t].m3, 6, 2) != TOWN_HOUSE_COMPLETED) {
01326
01327
01328 SB(_m[t].m5, 3, 2, GB(_m[t].m3, 6, 2));
01329 SB(_m[t].m3, 6, 2, 0);
01330
01331
01332 SetHouseCompleted(t, false);
01333 } else {
01334
01335
01336 SB(_me[t].m7, 0, 1, HasBit(_m[t].m5, 7));
01337 ClrBit(_m[t].m5, 7);
01338
01339
01340
01341 ClrBit(_m[t].m1, 7);
01342
01343
01344
01345
01346 SetLiftPosition(t, GB(_m[t].m1, 0, 6 ));
01347
01348 _m[t].m1 = 0;
01349 _m[t].m3 = 0;
01350 SetHouseCompleted(t, true);
01351 }
01352 }
01353 }
01354 }
01355
01356
01357 UpdateHousesAndTowns();
01358
01359 if (IsSavegameVersionBefore(43)) {
01360 for (TileIndex t = 0; t < map_size; t++) {
01361 if (IsTileType(t, MP_INDUSTRY)) {
01362 switch (GetIndustryGfx(t)) {
01363 case GFX_POWERPLANT_SPARKS:
01364 _m[t].m3 = GB(_m[t].m1, 2, 5);
01365 break;
01366
01367 case GFX_OILWELL_ANIMATED_1:
01368 case GFX_OILWELL_ANIMATED_2:
01369 case GFX_OILWELL_ANIMATED_3:
01370 _m[t].m3 = GB(_m[t].m1, 0, 2);
01371 break;
01372
01373 case GFX_COAL_MINE_TOWER_ANIMATED:
01374 case GFX_COPPER_MINE_TOWER_ANIMATED:
01375 case GFX_GOLD_MINE_TOWER_ANIMATED:
01376 _m[t].m3 = _m[t].m1;
01377 break;
01378
01379 default:
01380 break;
01381 }
01382 }
01383 }
01384 }
01385
01386 if (IsSavegameVersionBefore(45)) {
01387 Vehicle *v;
01388
01389
01390
01391
01392
01393 FOR_ALL_VEHICLES(v) {
01394 ClrBit(v->vehicle_flags, 2);
01395 }
01396 }
01397
01398
01399
01400 if (IsSavegameVersionBefore(46)) {
01401 Waypoint *wp;
01402 FOR_ALL_WAYPOINTS(wp) {
01403 if ((wp->facilities & FACIL_DOCK) != 0 && IsTileOwner(wp->xy, OWNER_NONE) && TileHeight(wp->xy) == 0) SetTileOwner(wp->xy, OWNER_WATER);
01404 }
01405 }
01406
01407 if (IsSavegameVersionBefore(50)) {
01408 Aircraft *v;
01409
01410 FOR_ALL_AIRCRAFT(v) {
01411 if (v->subtype <= AIR_AIRCRAFT) {
01412 const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);
01413 v->cur_speed *= 128;
01414 v->cur_speed /= 10;
01415 v->acceleration = avi->acceleration;
01416 }
01417 }
01418 }
01419
01420 if (IsSavegameVersionBefore(49)) FOR_ALL_COMPANIES(c) c->face = ConvertFromOldCompanyManagerFace(c->face);
01421
01422 if (IsSavegameVersionBefore(52)) {
01423 for (TileIndex t = 0; t < map_size; t++) {
01424 if (IsStatueTile(t)) {
01425 _m[t].m2 = CalcClosestTownFromTile(t)->index;
01426 }
01427 }
01428 }
01429
01430
01431
01432
01433 if (IsSavegameVersionBefore(56)) {
01434 Town *t;
01435
01436 FOR_ALL_TOWNS(t) {
01437 if (_settings_game.economy.larger_towns != 0 && (t->index % _settings_game.economy.larger_towns) == 0) {
01438 t->larger_town = true;
01439 }
01440 }
01441 }
01442
01443 if (IsSavegameVersionBefore(57)) {
01444 Vehicle *v;
01445
01446 FOR_ALL_VEHICLES(v) {
01447 if ((v->type != VEH_TRAIN || Train::From(v)->IsFrontEngine()) &&
01448 !(v->vehstatus & (VS_STOPPED | VS_CRASHED)) &&
01449 v->current_order.IsType(OT_LOADING)) {
01450 Station::Get(v->last_station_visited)->loading_vehicles.push_back(v);
01451
01452
01453
01454 ClrBit(v->vehicle_flags, VF_LOADING_FINISHED);
01455 }
01456 }
01457 } else if (IsSavegameVersionBefore(59)) {
01458
01459
01460 Station *st;
01461 FOR_ALL_STATIONS(st) {
01462 std::list<Vehicle *>::iterator iter;
01463 for (iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end();) {
01464 Vehicle *v = *iter;
01465 iter++;
01466 if (!v->current_order.IsType(OT_LOADING)) st->loading_vehicles.remove(v);
01467 }
01468 }
01469 }
01470
01471 if (IsSavegameVersionBefore(58)) {
01472
01473
01474 if (_settings_game.difficulty.industry_density > 0) {
01475 _settings_game.difficulty.industry_density++;
01476 }
01477
01478
01479 _settings_game.difficulty.number_towns++;
01480 }
01481
01482 if (IsSavegameVersionBefore(64)) {
01483
01484 for (TileIndex t = 0; t < map_size; t++) {
01485 if (IsTileType(t, MP_RAILWAY) && HasSignals(t)) {
01486 SetSignalStates(t, GB(_m[t].m2, 4, 4));
01487 SetSignalVariant(t, INVALID_TRACK, GetSignalVariant(t, TRACK_X));
01488 SetSignalType(t, INVALID_TRACK, GetSignalType(t, TRACK_X));
01489 ClrBit(_m[t].m2, 7);
01490 }
01491 }
01492 }
01493
01494 if (IsSavegameVersionBefore(69)) {
01495
01496 RoadVehicle *rv;
01497 FOR_ALL_ROADVEHICLES(rv) {
01498 if (rv->state == 250 || rv->state == 251) {
01499 SetBit(rv->state, 2);
01500 }
01501 }
01502 }
01503
01504 if (IsSavegameVersionBefore(70)) {
01505
01506 Industry *i;
01507 FOR_ALL_INDUSTRIES(i) i->founder = OWNER_NONE;
01508 }
01509
01510
01511
01512 if (IsSavegameVersionBefore(82)) {
01513 for (TileIndex t = 0; t < map_size; t++) {
01514 if (IsTileType(t, MP_WATER) &&
01515 GetWaterTileType(t) == WATER_TILE_CLEAR &&
01516 GetTileOwner(t) == OWNER_WATER &&
01517 TileHeight(t) != 0) {
01518 SetTileOwner(t, OWNER_NONE);
01519 }
01520 }
01521 }
01522
01523
01524
01525
01526
01527
01528
01529 if (IsSavegameVersionBefore(83)) {
01530 for (TileIndex t = 0; t < map_size; t++) {
01531 if (IsShipDepotTile(t)) {
01532 _m[t].m4 = (TileHeight(t) == 0) ? OWNER_WATER : OWNER_NONE;
01533 }
01534 }
01535 }
01536
01537 if (IsSavegameVersionBefore(74)) {
01538 Station *st;
01539 FOR_ALL_STATIONS(st) {
01540 for (CargoID c = 0; c < NUM_CARGO; c++) {
01541 st->goods[c].last_speed = 0;
01542 if (st->goods[c].cargo.AvailableCount() != 0) SetBit(st->goods[c].acceptance_pickup, GoodsEntry::GES_PICKUP);
01543 }
01544 }
01545 }
01546
01547 if (IsSavegameVersionBefore(78)) {
01548 Industry *i;
01549 uint j;
01550 FOR_ALL_INDUSTRIES(i) {
01551 const IndustrySpec *indsp = GetIndustrySpec(i->type);
01552 for (j = 0; j < lengthof(i->produced_cargo); j++) {
01553 i->produced_cargo[j] = indsp->produced_cargo[j];
01554 }
01555 for (j = 0; j < lengthof(i->accepts_cargo); j++) {
01556 i->accepts_cargo[j] = indsp->accepts_cargo[j];
01557 }
01558 }
01559 }
01560
01561
01562
01563
01564
01565 if (IsSavegameVersionBefore(81)) {
01566 for (TileIndex t = 0; t < map_size; t++) {
01567 if (GetTileType(t) == MP_TREES) {
01568 TreeGround groundType = (TreeGround)GB(_m[t].m2, 4, 2);
01569 if (groundType != TREE_GROUND_SNOW_DESERT) SB(_m[t].m2, 6, 2, 3);
01570 }
01571 }
01572 }
01573
01574
01575 if (IsSavegameVersionBefore(93)) {
01576
01577 Order *order;
01578 FOR_ALL_ORDERS(order) order->ConvertFromOldSavegame();
01579
01580 Vehicle *v;
01581 FOR_ALL_VEHICLES(v) {
01582 if (v->orders.list != NULL && v->orders.list->GetFirstOrder() != NULL && v->orders.list->GetFirstOrder()->IsType(OT_NOTHING)) {
01583 v->orders.list->FreeChain();
01584 v->orders.list = NULL;
01585 }
01586
01587 v->current_order.ConvertFromOldSavegame();
01588 if (v->type == VEH_ROAD && v->IsPrimaryVehicle() && v->FirstShared() == v) {
01589 FOR_VEHICLE_ORDERS(v, order) order->SetNonStopType(ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS);
01590 }
01591 }
01592 } else if (IsSavegameVersionBefore(94)) {
01593
01594 Order *order;
01595 FOR_ALL_ORDERS(order) {
01596 if ((order->GetUnloadType() & (OUFB_UNLOAD | OUFB_TRANSFER)) == (OUFB_UNLOAD | OUFB_TRANSFER)) {
01597 order->SetUnloadType(OUFB_TRANSFER);
01598 order->SetLoadType(OLFB_NO_LOAD);
01599 }
01600 }
01601
01602 Vehicle *v;
01603 FOR_ALL_VEHICLES(v) {
01604 if ((v->current_order.GetUnloadType() & (OUFB_UNLOAD | OUFB_TRANSFER)) == (OUFB_UNLOAD | OUFB_TRANSFER)) {
01605 v->current_order.SetUnloadType(OUFB_TRANSFER);
01606 v->current_order.SetLoadType(OLFB_NO_LOAD);
01607 }
01608 }
01609 }
01610
01611 if (IsSavegameVersionBefore(84)) {
01612
01613
01614
01615
01616
01617
01618 FOR_ALL_COMPANIES(c) {
01619 for (uint i = 0; i < 4; i++) {
01620 CompanyID company = c->share_owners[i];
01621 if (company == INVALID_COMPANY) continue;
01622 if (!Company::IsValidID(company) || company == c->index) c->share_owners[i] = INVALID_COMPANY;
01623 }
01624 }
01625 }
01626
01627
01628 if (IsSavegameVersionBefore(146)) {
01629 for (TileIndex t = 0; t < map_size; t++) {
01630 switch (GetTileType(t)) {
01631 case MP_STATION:
01632 switch (GetStationType(t)) {
01633 case STATION_OILRIG:
01634 case STATION_DOCK:
01635 case STATION_BUOY:
01636 SetWaterClass(t, (WaterClass)GB(_m[t].m3, 0, 2));
01637 SB(_m[t].m3, 0, 2, 0);
01638 break;
01639
01640 default:
01641 SetWaterClass(t, WATER_CLASS_INVALID);
01642 break;
01643 }
01644 break;
01645
01646 case MP_WATER:
01647 SetWaterClass(t, (WaterClass)GB(_m[t].m3, 0, 2));
01648 SB(_m[t].m3, 0, 2, 0);
01649 break;
01650
01651 case MP_OBJECT:
01652 SetWaterClass(t, WATER_CLASS_INVALID);
01653 break;
01654
01655 default:
01656
01657 break;
01658 }
01659 }
01660 }
01661
01662 if (IsSavegameVersionBefore(86)) {
01663 for (TileIndex t = 0; t < map_size; t++) {
01664
01665 if (IsTileType(t, MP_WATER)) {
01666 if (GetWaterClass(t) != WATER_CLASS_RIVER) {
01667 if (IsWater(t)) {
01668 Owner o = GetTileOwner(t);
01669 if (o == OWNER_WATER) {
01670 MakeSea(t);
01671 } else {
01672 MakeCanal(t, o, Random());
01673 }
01674 } else if (IsShipDepot(t)) {
01675 Owner o = (Owner)_m[t].m4;
01676 SetWaterClass(t, o == OWNER_WATER ? WATER_CLASS_SEA : WATER_CLASS_CANAL);
01677 }
01678 }
01679 }
01680 }
01681
01682
01683
01684
01685 for (TileIndex t = 0; t < map_size; t++) {
01686 if (GetTileSlope(t) != SLOPE_FLAT) continue;
01687
01688 if (IsTileType(t, MP_WATER) && IsLock(t)) SetWaterClassDependingOnSurroundings(t, false);
01689 if (IsTileType(t, MP_STATION) && (IsDock(t) || IsBuoy(t))) SetWaterClassDependingOnSurroundings(t, false);
01690 }
01691 }
01692
01693 if (IsSavegameVersionBefore(87)) {
01694 for (TileIndex t = 0; t < map_size; t++) {
01695
01696 if ((IsTileType(t, MP_WATER) || IsBuoyTile(t)) &&
01697 (TileX(t) == 0 || TileY(t) == 0 || TileX(t) == MapMaxX() - 1 || TileY(t) == MapMaxY() - 1)) {
01698
01699
01700 SetWaterClass(t, WATER_CLASS_SEA);
01701 }
01702
01703 if (IsBuoyTile(t) || IsDriveThroughStopTile(t) || IsTileType(t, MP_WATER)) {
01704 Owner o = GetTileOwner(t);
01705 if (o < MAX_COMPANIES && !Company::IsValidID(o)) {
01706 Backup<CompanyByte> cur_company(_current_company, o, FILE_LINE);
01707 ChangeTileOwner(t, o, INVALID_OWNER);
01708 cur_company.Restore();
01709 }
01710 if (IsBuoyTile(t)) {
01711
01712
01713 Waypoint::GetByTile(t)->owner = OWNER_NONE;
01714 }
01715 } else if (IsTileType(t, MP_ROAD)) {
01716
01717 for (RoadType rt = ROADTYPE_ROAD; rt < ROADTYPE_END; rt++) {
01718
01719 Owner o = GetRoadOwner(t, rt);
01720 if (o < MAX_COMPANIES && !Company::IsValidID(o)) SetRoadOwner(t, rt, OWNER_NONE);
01721 }
01722 if (IsLevelCrossing(t)) {
01723 if (!Company::IsValidID(GetTileOwner(t))) FixOwnerOfRailTrack(t);
01724 }
01725 } else if (IsPlainRailTile(t)) {
01726 if (!Company::IsValidID(GetTileOwner(t))) FixOwnerOfRailTrack(t);
01727 }
01728 }
01729
01730
01731 if (_settings_game.pf.yapf.rail_use_yapf || IsSavegameVersionBefore(28)) {
01732 _settings_game.pf.pathfinder_for_trains = VPF_YAPF;
01733 } else {
01734 _settings_game.pf.pathfinder_for_trains = VPF_NPF;
01735 }
01736
01737 if (_settings_game.pf.yapf.road_use_yapf || IsSavegameVersionBefore(28)) {
01738 _settings_game.pf.pathfinder_for_roadvehs = VPF_YAPF;
01739 } else {
01740 _settings_game.pf.pathfinder_for_roadvehs = VPF_NPF;
01741 }
01742
01743 if (_settings_game.pf.yapf.ship_use_yapf) {
01744 _settings_game.pf.pathfinder_for_ships = VPF_YAPF;
01745 } else {
01746 _settings_game.pf.pathfinder_for_ships = (_settings_game.pf.new_pathfinding_all ? VPF_NPF : VPF_OPF);
01747 }
01748 }
01749
01750 if (IsSavegameVersionBefore(88)) {
01751
01752 Vehicle *v;
01753 FOR_ALL_VEHICLES(v) {
01754 v->profit_this_year <<= 8;
01755 v->profit_last_year <<= 8;
01756 v->running_ticks = 0;
01757 }
01758 }
01759
01760 if (IsSavegameVersionBefore(91)) {
01761
01762 for (TileIndex t = 0; t < map_size; t++) {
01763 if (IsTileType(t, MP_HOUSE) && GetHouseType(t) >= NEW_HOUSE_OFFSET) {
01764 SB(_m[t].m6, 2, 6, GB(_m[t].m6, 3, 5));
01765 SB(_m[t].m3, 5, 1, 0);
01766 }
01767 }
01768 }
01769
01770 if (IsSavegameVersionBefore(62)) {
01771
01772
01773 RoadVehicle *v;
01774 FOR_ALL_ROADVEHICLES(v) {
01775 if (v->First() == v && HasBit(EngInfo(v->engine_type)->misc_flags, EF_ROAD_TRAM)) {
01776 ShowErrorMessage(STR_WARNING_LOADGAME_REMOVED_TRAMS, INVALID_STRING_ID, WL_CRITICAL);
01777 delete v;
01778 }
01779 }
01780 }
01781
01782 if (IsSavegameVersionBefore(99)) {
01783 for (TileIndex t = 0; t < map_size; t++) {
01784
01785 if (IsTileType(t, MP_STATION) && IsOilRig(t)) {
01786 SetWaterClassDependingOnSurroundings(t, true);
01787 }
01788 if (IsTileType(t, MP_INDUSTRY)) {
01789 if ((GetIndustrySpec(GetIndustryType(t))->behaviour & INDUSTRYBEH_BUILT_ONWATER) != 0) {
01790 SetWaterClassDependingOnSurroundings(t, true);
01791 } else {
01792 SetWaterClass(t, WATER_CLASS_INVALID);
01793 }
01794 }
01795
01796
01797 if (IsTileType(t, MP_HOUSE) && IsHouseCompleted(t)) {
01798 _m[t].m5 = Clamp(_cur_year - (_m[t].m5 + ORIGINAL_BASE_YEAR), 0, 0xFF);
01799 }
01800 }
01801 }
01802
01803
01804
01805
01806 if (IsSavegameVersionBefore(100)) {
01807 for (TileIndex t = 0; t < map_size; t++) {
01808 switch (GetTileType(t)) {
01809 case MP_RAILWAY:
01810 if (HasSignals(t)) {
01811
01812 SetSignalVariant(t, TRACK_UPPER, HasBit(_m[t].m2, 2) ? SIG_SEMAPHORE : SIG_ELECTRIC);
01813 SetSignalVariant(t, TRACK_LOWER, HasBit(_m[t].m2, 6) ? SIG_SEMAPHORE : SIG_ELECTRIC);
01814 ClrBit(_m[t].m2, 2);
01815 ClrBit(_m[t].m2, 6);
01816 }
01817
01818
01819 if (IsRailDepot(t)) {
01820 SetDepotReservation(t, false);
01821 } else {
01822 SetTrackReservation(t, TRACK_BIT_NONE);
01823 }
01824 break;
01825
01826 case MP_ROAD:
01827 if (IsLevelCrossing(t)) SetCrossingReservation(t, false);
01828 break;
01829
01830 case MP_STATION:
01831 if (HasStationRail(t)) SetRailStationReservation(t, false);
01832 break;
01833
01834 case MP_TUNNELBRIDGE:
01835 if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) SetTunnelBridgeReservation(t, false);
01836 break;
01837
01838 default: break;
01839 }
01840 }
01841 }
01842
01843
01844 if (IsSavegameVersionBefore(101)) {
01845 const Train *t;
01846 FOR_ALL_TRAINS(t) {
01847 if (t->First() == t) t->ReserveTrackUnderConsist();
01848 }
01849 }
01850
01851 if (IsSavegameVersionBefore(102)) {
01852 for (TileIndex t = 0; t < map_size; t++) {
01853
01854 if (IsLevelCrossingTile(t)) UpdateLevelCrossing(t, false);
01855 }
01856 }
01857
01858 if (IsSavegameVersionBefore(103)) {
01859
01860 UpdateNearestTownForRoadTiles(false);
01861
01862
01863 Sign *si;
01864 FOR_ALL_SIGNS(si) {
01865 if (si->owner != OWNER_NONE && !Company::IsValidID(si->owner)) si->owner = OWNER_NONE;
01866 }
01867
01868
01869
01870 Station *st;
01871 FOR_ALL_STATIONS(st) {
01872 st->indtype = IT_INVALID;
01873 }
01874 }
01875
01876 if (IsSavegameVersionBefore(104)) {
01877 Aircraft *a;
01878 FOR_ALL_AIRCRAFT(a) {
01879
01880 if (!a->IsNormalAircraft()) {
01881 a->engine_type = a->First()->engine_type;
01882 }
01883 }
01884
01885
01886 Company *c;
01887 FOR_ALL_COMPANIES(c) {
01888 if (c->bankrupt_asked == 0xFF) c->bankrupt_asked = 0xFFFF;
01889 }
01890
01891 Engine *e;
01892 FOR_ALL_ENGINES(e) {
01893 if (e->company_avail == 0xFF) e->company_avail = 0xFFFF;
01894 }
01895
01896 Town *t;
01897 FOR_ALL_TOWNS(t) {
01898 if (t->have_ratings == 0xFF) t->have_ratings = 0xFFFF;
01899 for (uint i = 8; i != MAX_COMPANIES; i++) t->ratings[i] = RATING_INITIAL;
01900 }
01901 }
01902
01903 if (IsSavegameVersionBefore(112)) {
01904 for (TileIndex t = 0; t < map_size; t++) {
01905
01906
01907 if (IsTileType(t, MP_OBJECT) && HasBit(_m[t].m5, 7)) {
01908
01909
01910 _m[t].m3 = GB(_m[t].m5, 0, 5);
01911 _m[t].m5 = OBJECT_HQ;
01912 }
01913 }
01914 }
01915 if (IsSavegameVersionBefore(144)) {
01916 for (TileIndex t = 0; t < map_size; t++) {
01917 if (!IsTileType(t, MP_OBJECT)) continue;
01918
01919
01920 ObjectType type = GetObjectType(t);
01921 SB(_m[t].m6, 2, 4, type == OBJECT_HQ ? GB(_m[t].m3, 2, 3) : 0);
01922 _m[t].m3 = type == OBJECT_HQ ? GB(_m[t].m3, 1, 1) | GB(_m[t].m3, 0, 1) << 4 : 0;
01923
01924
01925 _m[t].m4 = 0;
01926 _me[t].m7 = 0;
01927 }
01928 }
01929
01930 if (IsSavegameVersionBefore(147) && Object::GetNumItems() == 0) {
01931
01932 for (TileIndex t = 0; t < map_size; t++) {
01933 if (!IsTileType(t, MP_OBJECT)) continue;
01934
01935 if (Town::GetNumItems() == 0) {
01936
01937 DoClearSquare(t);
01938 } else {
01939 uint offset = _m[t].m3;
01940
01941
01942 _m[t].m3 = GB(_m[t].m6, 2, 4);
01943 SB(_m[t].m6, 2, 4, 0);
01944
01945 if (offset == 0) {
01946
01947 ObjectType type = GetObjectType(t);
01948 int size = type == OBJECT_HQ ? 2 : 1;
01949
01950 if (!Object::CanAllocateItem()) {
01951
01952
01953 SlError(STR_ERROR_TOO_MANY_OBJECTS);
01954 }
01955
01956 Object *o = new Object();
01957 o->location.tile = t;
01958 o->location.w = size;
01959 o->location.h = size;
01960 o->build_date = _date;
01961 o->town = type == OBJECT_STATUE ? Town::Get(_m[t].m2) : CalcClosestTownFromTile(t, UINT_MAX);
01962 _m[t].m2 = o->index;
01963 Object::IncTypeCount(type);
01964 } else {
01965
01966 TileIndex northern_tile = t - TileXY(GB(offset, 0, 4), GB(offset, 4, 4));
01967 assert(IsTileType(northern_tile, MP_OBJECT));
01968 _m[t].m2 = _m[northern_tile].m2;
01969 }
01970 }
01971 }
01972 }
01973
01974 if (IsSavegameVersionBefore(113)) {
01975
01976 if (_settings_game.economy.town_layout == 0) {
01977 _settings_game.economy.allow_town_roads = false;
01978 _settings_game.economy.town_layout = TL_BETTER_ROADS;
01979 } else {
01980 _settings_game.economy.allow_town_roads = true;
01981 _settings_game.economy.town_layout = _settings_game.economy.town_layout - 1;
01982 }
01983
01984
01985
01986 Town *t;
01987 FOR_ALL_TOWNS(t) {
01988 if (_settings_game.economy.town_layout != TL_RANDOM) {
01989 t->layout = _settings_game.economy.town_layout;
01990 continue;
01991 }
01992
01993
01994 byte layout = TileHash(TileX(t->xy), TileY(t->xy)) % 6;
01995 switch (layout) {
01996 default: break;
01997 case 5: layout = 1; break;
01998 case 0: layout = 2; break;
01999 }
02000 t->layout = layout - 1;
02001 }
02002 }
02003
02004 if (IsSavegameVersionBefore(114)) {
02005
02006
02007
02008 Station *st;
02009 FOR_ALL_STATIONS(st) {
02010 if (!Company::IsValidID(st->owner)) st->owner = OWNER_NONE;
02011 }
02012 }
02013
02014
02015 if (IsSavegameVersionBefore(117)) {
02016 Order *o;
02017 FOR_ALL_ORDERS(o) {
02018 if (o->IsType(OT_GOTO_STATION)) o->SetStopLocation(OSL_PLATFORM_FAR_END);
02019 }
02020 }
02021
02022 if (IsSavegameVersionBefore(120)) {
02023 extern VehicleDefaultSettings _old_vds;
02024 Company *c;
02025 FOR_ALL_COMPANIES(c) {
02026 c->settings.vehicle = _old_vds;
02027 }
02028 }
02029
02030 if (IsSavegameVersionBefore(121)) {
02031
02032 Vehicle *v;
02033 FOR_ALL_DISASTERVEHICLES(v) {
02034 if (v->subtype == 2 && v->current_order.GetDestination() != 0) {
02035 const Vehicle *u = Vehicle::GetIfValid(v->dest_tile);
02036 if (u == NULL || u->type != VEH_ROAD || !RoadVehicle::From(u)->IsFrontEngine()) {
02037 delete v;
02038 }
02039 }
02040 }
02041
02042
02043
02044
02045
02046
02047
02048 Station *st;
02049 FOR_ALL_STATIONS(st) {
02050 std::list<Vehicle *>::iterator iter;
02051 for (iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end(); ++iter) {
02052
02053
02054 assert_compile(CargoPaymentPool::MAX_SIZE == VehiclePool::MAX_SIZE);
02055 assert(CargoPayment::CanAllocateItem());
02056 Vehicle *v = *iter;
02057 if (v->cargo_payment == NULL) v->cargo_payment = new CargoPayment(v);
02058 }
02059 }
02060 }
02061
02062 if (IsSavegameVersionBefore(122)) {
02063
02064
02065
02066 extern TileIndex *_animated_tile_list;
02067 extern uint _animated_tile_count;
02068
02069 for (uint i = 0; i < _animated_tile_count; ) {
02070
02071 bool remove = _tile_type_procs[GetTileType(_animated_tile_list[i])]->animate_tile_proc == NULL;
02072
02073
02074 for (uint j = 0; !remove && j < i; j++) {
02075 remove = _animated_tile_list[i] == _animated_tile_list[j];
02076 }
02077
02078 if (remove) {
02079 DeleteAnimatedTile(_animated_tile_list[i]);
02080 } else {
02081 i++;
02082 }
02083 }
02084 }
02085
02086 if (IsSavegameVersionBefore(124) && !IsSavegameVersionBefore(1)) {
02087
02088 Waypoint *wp;
02089 FOR_ALL_WAYPOINTS(wp) {
02090 if (wp->facilities & FACIL_TRAIN) {
02091 wp->train_station.tile = wp->xy;
02092 wp->train_station.w = 1;
02093 wp->train_station.h = 1;
02094 } else {
02095 wp->train_station.tile = INVALID_TILE;
02096 wp->train_station.w = 0;
02097 wp->train_station.h = 0;
02098 }
02099 }
02100 }
02101
02102 if (IsSavegameVersionBefore(125)) {
02103
02104 Subsidy *s;
02105 FOR_ALL_SUBSIDIES(s) {
02106 if (s->remaining < 12) {
02107
02108 s->remaining = 12 - s->remaining;
02109 s->awarded = INVALID_COMPANY;
02110 const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
02111 switch (cs->town_effect) {
02112 case TE_PASSENGERS:
02113 case TE_MAIL:
02114
02115 s->src_type = s->dst_type = ST_TOWN;
02116 if (Town::IsValidID(s->src) && Town::IsValidID(s->dst)) continue;
02117 break;
02118 case TE_GOODS:
02119 case TE_FOOD:
02120
02121 s->src_type = ST_INDUSTRY;
02122 s->dst_type = ST_TOWN;
02123 if (Industry::IsValidID(s->src) && Town::IsValidID(s->dst)) continue;
02124 break;
02125 default:
02126
02127 s->src_type = s->dst_type = ST_INDUSTRY;
02128 if (Industry::IsValidID(s->src) && Industry::IsValidID(s->dst)) continue;
02129 break;
02130 }
02131 } else {
02132
02133
02134
02135 s->remaining = 24 - s->remaining;
02136 const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
02137 switch (cs->town_effect) {
02138 case TE_PASSENGERS:
02139 case TE_MAIL: {
02140
02141 const Station *ss = Station::GetIfValid(s->src);
02142 const Station *sd = Station::GetIfValid(s->dst);
02143 if (ss != NULL && sd != NULL && ss->owner == sd->owner &&
02144 Company::IsValidID(ss->owner)) {
02145 s->src_type = s->dst_type = ST_TOWN;
02146 s->src = ss->town->index;
02147 s->dst = sd->town->index;
02148 s->awarded = ss->owner;
02149 continue;
02150 }
02151 break;
02152 }
02153 default:
02154 break;
02155 }
02156 }
02157
02158 delete s;
02159 }
02160 }
02161
02162 if (IsSavegameVersionBefore(126)) {
02163
02164
02165
02166
02167
02168
02169 uint64 aimed_inflation = (_economy.old_max_loan_unround << 16 | _economy.old_max_loan_unround_fract) / _settings_game.difficulty.max_loan;
02170
02171
02172 if (aimed_inflation > MAX_INFLATION) aimed_inflation = MAX_INFLATION;
02173
02174
02175 while (_economy.inflation_prices < aimed_inflation) {
02176 if (AddInflation(false)) break;
02177 }
02178 }
02179
02180 if (IsSavegameVersionBefore(127)) {
02181 Station *st;
02182 FOR_ALL_STATIONS(st) UpdateStationAcceptance(st, false);
02183 }
02184
02185 if (IsSavegameVersionBefore(128)) {
02186 const Depot *d;
02187 FOR_ALL_DEPOTS(d) {
02188 _m[d->xy].m2 = d->index;
02189 if (IsTileType(d->xy, MP_WATER)) _m[GetOtherShipDepotTile(d->xy)].m2 = d->index;
02190 }
02191 }
02192
02193
02194
02195 if (IsSavegameVersionBefore(131)) {
02196 Train *t;
02197 FOR_ALL_TRAINS(t) {
02198 if (t->force_proceed != TFP_NONE) {
02199 t->force_proceed = TFP_STUCK;
02200 }
02201 }
02202 }
02203
02204
02205
02206 if (IsSavegameVersionBefore(135)) {
02207 for (TileIndex t = 0; t < map_size; t++) {
02208 if (IsTileType(t, MP_CLEAR)) {
02209 if (GetRawClearGround(t) == CLEAR_SNOW) {
02210 SetClearGroundDensity(t, CLEAR_GRASS, GetClearDensity(t));
02211 SetBit(_m[t].m3, 4);
02212 } else {
02213 ClrBit(_m[t].m3, 4);
02214 }
02215 }
02216 if (IsTileType(t, MP_TREES)) {
02217 uint density = GB(_m[t].m2, 6, 2);
02218 uint ground = GB(_m[t].m2, 4, 2);
02219 uint counter = GB(_m[t].m2, 0, 4);
02220 _m[t].m2 = ground << 6 | density << 4 | counter;
02221 }
02222 }
02223 }
02224
02225
02226 if (IsSavegameVersionBefore(136)) {
02227 Aircraft *a;
02228 FOR_ALL_AIRCRAFT(a) {
02229 a->turn_counter = a->current_order.IsType(OT_LOADING) ? 0 : a->load_unload_ticks;
02230 }
02231
02232 Train *t;
02233 FOR_ALL_TRAINS(t) {
02234 t->wait_counter = t->current_order.IsType(OT_LOADING) ? 0 : t->load_unload_ticks;
02235 }
02236 }
02237
02238
02239 if (IsSavegameVersionBefore(137)) {
02240 struct AirportTileConversion {
02241 byte old_start;
02242 byte num_frames;
02243 };
02244 static const AirportTileConversion atc[] = {
02245 {31, 12},
02246 {50, 4},
02247 {62, 2},
02248 {66, 12},
02249 {78, 12},
02250 {101, 10},
02251 {111, 8},
02252 {119, 15},
02253 {140, 4},
02254 };
02255 for (TileIndex t = 0; t < map_size; t++) {
02256 if (IsAirportTile(t)) {
02257 StationGfx old_gfx = GetStationGfx(t);
02258 byte offset = 0;
02259 for (uint i = 0; i < lengthof(atc); i++) {
02260 if (old_gfx < atc[i].old_start) {
02261 SetStationGfx(t, old_gfx - offset);
02262 break;
02263 }
02264 if (old_gfx < atc[i].old_start + atc[i].num_frames) {
02265 SetAnimationFrame(t, old_gfx - atc[i].old_start);
02266 SetStationGfx(t, atc[i].old_start - offset);
02267 break;
02268 }
02269 offset += atc[i].num_frames - 1;
02270 }
02271 }
02272 }
02273 }
02274
02275 if (IsSavegameVersionBefore(140)) {
02276 Station *st;
02277 FOR_ALL_STATIONS(st) {
02278 if (st->airport.tile != INVALID_TILE) {
02279 st->airport.w = st->airport.GetSpec()->size_x;
02280 st->airport.h = st->airport.GetSpec()->size_y;
02281 }
02282 }
02283 }
02284
02285 if (IsSavegameVersionBefore(141)) {
02286 for (TileIndex t = 0; t < map_size; t++) {
02287
02288 if (IsTileType(t, MP_VOID)) SetTropicZone(t, TROPICZONE_NORMAL);
02289 }
02290
02291
02292
02293
02294 Depot *d;
02295 FOR_ALL_DEPOTS(d) d->town_cn = UINT16_MAX;
02296
02297 FOR_ALL_DEPOTS(d) MakeDefaultName(d);
02298 }
02299
02300 if (IsSavegameVersionBefore(142)) {
02301 Depot *d;
02302 FOR_ALL_DEPOTS(d) d->build_date = _date;
02303 }
02304
02305
02306
02307
02308
02309
02310 if (IsSavegameVersionBefore(146)) {
02311 Aircraft *v;
02312 FOR_ALL_AIRCRAFT(v) {
02313 if (!v->IsNormalAircraft()) continue;
02314 Station *st = GetTargetAirportIfValid(v);
02315 if (st == NULL && v->state != FLYING) {
02316 v->state = FLYING;
02317 UpdateAircraftCache(v);
02318 AircraftNextAirportPos_and_Order(v);
02319
02320 if ((v->vehstatus & VS_CRASHED) == 0) SetAircraftPosition(v, v->x_pos, v->y_pos, GetAircraftFlyingAltitude(v));
02321 }
02322 }
02323 }
02324
02325
02326 if (IsSavegameVersionBefore(147)) {
02327 for (TileIndex t = 0; t < map_size; t++) {
02328 switch (GetTileType(t)) {
02329 case MP_HOUSE:
02330 if (GetHouseType(t) >= NEW_HOUSE_OFFSET) {
02331 uint per_proc = _me[t].m7;
02332 _me[t].m7 = GB(_m[t].m6, 2, 6) | (GB(_m[t].m3, 5, 1) << 6);
02333 SB(_m[t].m3, 5, 1, 0);
02334 SB(_m[t].m6, 2, 6, min(per_proc, 63));
02335 }
02336 break;
02337
02338 case MP_INDUSTRY: {
02339 uint rand = _me[t].m7;
02340 _me[t].m7 = _m[t].m3;
02341 _m[t].m3 = rand;
02342 break;
02343 }
02344
02345 case MP_OBJECT:
02346 _me[t].m7 = _m[t].m3;
02347 _m[t].m3 = 0;
02348 break;
02349
02350 default:
02351
02352 break;
02353 }
02354 }
02355 }
02356
02357
02358 if (IsSavegameVersionBefore(148)) {
02359 Object *o;
02360 FOR_ALL_OBJECTS(o) {
02361 Owner owner = GetTileOwner(o->location.tile);
02362 o->colour = (owner == OWNER_NONE) ? Random() & 0xF : Company::Get(owner)->livery->colour1;
02363 }
02364 }
02365
02366 if (IsSavegameVersionBefore(149)) {
02367 for (TileIndex t = 0; t < map_size; t++) {
02368 if (!IsTileType(t, MP_STATION)) continue;
02369 if (!IsBuoy(t) && !IsOilRig(t) && !(IsDock(t) && GetTileSlope(t) == SLOPE_FLAT)) {
02370 SetWaterClass(t, WATER_CLASS_INVALID);
02371 }
02372 }
02373
02374
02375
02376
02377
02378 Waypoint *wp;
02379 FOR_ALL_WAYPOINTS(wp) {
02380 if (wp->name != NULL) wp->town_cn = UINT16_MAX;
02381 }
02382
02383 FOR_ALL_WAYPOINTS(wp) {
02384 if (wp->name != NULL) MakeDefaultName(wp);
02385 }
02386 }
02387
02388 if (IsSavegameVersionBefore(152)) {
02389 _industry_builder.Reset();
02390
02391
02392
02393
02394 Vehicle *v;
02395 FOR_ALL_VEHICLES(v) {
02396
02397
02398 if (!v->IsGroundVehicle()) continue;
02399
02400
02401 if (!IsTunnelTile(v->tile)) continue;
02402
02403
02404 TileIndex vtile = TileVirtXY(v->x_pos, v->y_pos);
02405 if (!IsTunnelTile(vtile)) continue;
02406
02407
02408 if (GetSlopePixelZ(v->x_pos, v->y_pos) != v->z_pos) continue;
02409
02410
02411 const DiagDirection dir = GetTunnelBridgeDirection(vtile);
02412 const DiagDirection vdir = DirToDiagDir(v->direction);
02413
02414
02415 byte pos = (DiagDirToAxis(vdir) == AXIS_X ? v->x_pos : v->y_pos) & TILE_UNIT_MASK;
02416 byte frame = (vdir == DIAGDIR_NE || vdir == DIAGDIR_NW) ? TILE_SIZE - 1 - pos : pos;
02417 extern const byte _tunnel_visibility_frame[DIAGDIR_END];
02418
02419
02420 bool hidden;
02421 if (dir == vdir) {
02422 hidden = frame >= _tunnel_visibility_frame[dir];
02423 v->tile = vtile;
02424 } else if (dir == ReverseDiagDir(vdir)) {
02425 hidden = frame < TILE_SIZE - _tunnel_visibility_frame[dir];
02426
02427 v->tile = hidden ? GetOtherTunnelBridgeEnd(vtile) : vtile;
02428 } else {
02429
02430
02431
02432
02433
02434 continue;
02435 }
02436
02437 if (hidden) {
02438 v->vehstatus |= VS_HIDDEN;
02439
02440 switch (v->type) {
02441 case VEH_TRAIN: Train::From(v)->track = TRACK_BIT_WORMHOLE; break;
02442 case VEH_ROAD: RoadVehicle::From(v)->state = RVSB_WORMHOLE; break;
02443 default: NOT_REACHED();
02444 }
02445 } else {
02446 v->vehstatus &= ~VS_HIDDEN;
02447
02448 switch (v->type) {
02449 case VEH_TRAIN: Train::From(v)->track = DiagDirToDiagTrackBits(vdir); break;
02450 case VEH_ROAD: RoadVehicle::From(v)->state = DiagDirToDiagTrackdir(vdir); RoadVehicle::From(v)->frame = frame; break;
02451 default: NOT_REACHED();
02452 }
02453 }
02454 }
02455 }
02456
02457 if (IsSavegameVersionBefore(153)) {
02458 RoadVehicle *rv;
02459 FOR_ALL_ROADVEHICLES(rv) {
02460 if (rv->state == RVSB_IN_DEPOT || rv->state == RVSB_WORMHOLE) continue;
02461
02462 bool loading = rv->current_order.IsType(OT_LOADING) || rv->current_order.IsType(OT_LEAVESTATION);
02463 if (HasBit(rv->state, RVS_IN_ROAD_STOP)) {
02464 extern const byte _road_stop_stop_frame[];
02465 SB(rv->state, RVS_ENTERED_STOP, 1, loading || rv->frame > _road_stop_stop_frame[rv->state - RVSB_IN_ROAD_STOP + (_settings_game.vehicle.road_side << RVS_DRIVE_SIDE)]);
02466 } else if (HasBit(rv->state, RVS_IN_DT_ROAD_STOP)) {
02467 SB(rv->state, RVS_ENTERED_STOP, 1, loading || rv->frame > RVC_DRIVE_THROUGH_STOP_FRAME);
02468 }
02469 }
02470 }
02471
02472 if (IsSavegameVersionBefore(156)) {
02473
02474 Train *t;
02475 FOR_ALL_TRAINS(t) {
02476 if (!HasBit(t->flags, 5)) continue;
02477
02478 ClrBit(t->flags, 5);
02479 SetBit(t->vehicle_flags, VF_PATHFINDER_LOST);
02480 }
02481
02482
02483 Company *c;
02484 FOR_ALL_COMPANIES(c) {
02485 c->terraform_limit = _settings_game.construction.terraform_frame_burst << 16;
02486 c->clear_limit = _settings_game.construction.clear_frame_burst << 16;
02487 }
02488 }
02489
02490 if (IsSavegameVersionBefore(158)) {
02491 Vehicle *v;
02492 FOR_ALL_VEHICLES(v) {
02493 switch (v->type) {
02494 case VEH_TRAIN: {
02495 Train *t = Train::From(v);
02496
02497
02498
02499
02500
02501 ClrBit(t->flags, 1);
02502 ClrBit(t->flags, 2);
02503
02504
02505 ClrBit(t->gv_flags, GVF_GOINGUP_BIT);
02506 ClrBit(t->gv_flags, GVF_GOINGDOWN_BIT);
02507
02508
02509 if (t->vehstatus & VS_CRASHED) break;
02510
02511
02512 if (t->track != TRACK_BIT_X && t->track != TRACK_BIT_Y) break;
02513
02514 t->gv_flags |= FixVehicleInclination(t, t->direction);
02515 break;
02516 }
02517 case VEH_ROAD: {
02518 RoadVehicle *rv = RoadVehicle::From(v);
02519 ClrBit(rv->gv_flags, GVF_GOINGUP_BIT);
02520 ClrBit(rv->gv_flags, GVF_GOINGDOWN_BIT);
02521
02522
02523 if (rv->vehstatus & VS_CRASHED) break;
02524
02525 if (rv->state == RVSB_IN_DEPOT || rv->state == RVSB_WORMHOLE) break;
02526
02527 TrackStatus ts = GetTileTrackStatus(rv->tile, TRANSPORT_ROAD, rv->compatible_roadtypes);
02528 TrackBits trackbits = TrackStatusToTrackBits(ts);
02529
02530
02531 if (trackbits != TRACK_BIT_X && trackbits != TRACK_BIT_Y) break;
02532
02533 Direction dir = rv->direction;
02534
02535
02536 Axis a = trackbits == TRACK_BIT_X ? AXIS_X : AXIS_Y;
02537 if (AxisToDirection(a) != dir &&
02538 AxisToDirection(a) != ReverseDir(dir)) {
02539
02540
02541 dir = INVALID_DIR;
02542 }
02543
02544 rv->gv_flags |= FixVehicleInclination(rv, dir);
02545 break;
02546 }
02547 case VEH_SHIP:
02548 break;
02549
02550 default:
02551 continue;
02552 }
02553
02554 if (IsBridgeTile(v->tile) && TileVirtXY(v->x_pos, v->y_pos) == v->tile) {
02555
02556
02557
02558 v->z_pos = GetSlopePixelZ(v->x_pos, v->y_pos);
02559 DiagDirection dir = GetTunnelBridgeDirection(v->tile);
02560 if (v->type == VEH_TRAIN && !(v->vehstatus & VS_CRASHED) &&
02561 v->direction != DiagDirToDir(dir)) {
02562
02563
02564
02565
02566 Train::From(v)->track = DiagDirToDiagTrackBits(dir);
02567 }
02568 }
02569
02570
02571
02572 assert(v->tile != TileVirtXY(v->x_pos, v->y_pos) || v->z_pos == GetSlopePixelZ(v->x_pos, v->y_pos));
02573 }
02574
02575
02576 FOR_ALL_VEHICLES(v) {
02577 if (!v->IsPrimaryVehicle()) continue;
02578
02579
02580 if (v->cur_implicit_order_index >= v->GetNumOrders()) v->cur_implicit_order_index = 0;
02581
02582 v->cur_real_order_index = v->cur_implicit_order_index;
02583 v->UpdateRealOrderIndex();
02584 }
02585 }
02586
02587 if (IsSavegameVersionBefore(159)) {
02588
02589
02590
02591
02592
02593
02594 _settings_game.pf.reverse_at_signals = IsSavegameVersionBefore(100) || (_settings_game.pf.wait_oneway_signal != 255 && _settings_game.pf.wait_twoway_signal != 255 && _settings_game.pf.wait_for_pbs_path != 255);
02595
02596 Train *t;
02597 FOR_ALL_TRAINS(t) {
02598 _settings_game.vehicle.max_train_length = max<uint8>(_settings_game.vehicle.max_train_length, CeilDiv(t->gcache.cached_total_length, TILE_SIZE));
02599 }
02600 }
02601
02602 if (IsSavegameVersionBefore(160)) {
02603
02604
02605 if (_settings_game.difficulty.industry_density > 0) {
02606 _settings_game.difficulty.industry_density++;
02607 }
02608 }
02609
02610 if (IsSavegameVersionBefore(161)) {
02611
02612
02613 if (!IsSavegameVersionBefore(76)) {
02614 Industry *ind;
02615 FOR_ALL_INDUSTRIES(ind) {
02616 assert(ind->psa != NULL);
02617
02618
02619 bool is_empty = true;
02620 for (uint i = 0; i < sizeof(ind->psa->storage); i++) {
02621 if (ind->psa->GetValue(i) != 0) {
02622 is_empty = false;
02623 break;
02624 }
02625 }
02626
02627 if (!is_empty) {
02628 ind->psa->grfid = _industry_mngr.GetGRFID(ind->type);
02629 } else {
02630 delete ind->psa;
02631 ind->psa = NULL;
02632 }
02633 }
02634 }
02635
02636 if (!IsSavegameVersionBefore(145)) {
02637 Station *st;
02638 FOR_ALL_STATIONS(st) {
02639 if (!(st->facilities & FACIL_AIRPORT)) continue;
02640 assert(st->airport.psa != NULL);
02641
02642
02643 bool is_empty = true;
02644 for (uint i = 0; i < sizeof(st->airport.psa->storage); i++) {
02645 if (st->airport.psa->GetValue(i) != 0) {
02646 is_empty = false;
02647 break;
02648 }
02649 }
02650
02651 if (!is_empty) {
02652 st->airport.psa->grfid = _airport_mngr.GetGRFID(st->airport.type);
02653 } else {
02654 delete st->airport.psa;
02655 st->airport.psa = NULL;
02656
02657 }
02658 }
02659 }
02660 }
02661
02662
02663 if (IsSavegameVersionBefore(164) && _settings_game.game_creation.snow_line_height >= MIN_SNOWLINE_HEIGHT * TILE_HEIGHT) {
02664 _settings_game.game_creation.snow_line_height /= TILE_HEIGHT;
02665 }
02666
02667 if (IsSavegameVersionBefore(164) && !IsSavegameVersionBefore(32)) {
02668
02669 for (TileIndex t = 0; t < map_size; t++) {
02670 if (!IsTileType(t, MP_CLEAR) && !IsTileType(t, MP_TREES)) continue;
02671 if (IsTileType(t, MP_CLEAR) && IsClearGround(t, CLEAR_FIELDS)) continue;
02672 uint fence = GB(_m[t].m4, 5, 3);
02673 if (fence != 0 && IsTileType(TILE_ADDXY(t, 1, 0), MP_CLEAR) && IsClearGround(TILE_ADDXY(t, 1, 0), CLEAR_FIELDS)) {
02674 SetFenceNE(TILE_ADDXY(t, 1, 0), fence);
02675 }
02676 fence = GB(_m[t].m4, 2, 3);
02677 if (fence != 0 && IsTileType(TILE_ADDXY(t, 0, 1), MP_CLEAR) && IsClearGround(TILE_ADDXY(t, 0, 1), CLEAR_FIELDS)) {
02678 SetFenceNW(TILE_ADDXY(t, 0, 1), fence);
02679 }
02680 SB(_m[t].m4, 2, 3, 0);
02681 SB(_m[t].m4, 5, 3, 0);
02682 }
02683 }
02684
02685
02686 if (IsSavegameVersionBefore(164)) FixupTrainLengths();
02687
02688 if (IsSavegameVersionBefore(165)) {
02689 Town *t;
02690
02691 FOR_ALL_TOWNS(t) {
02692
02693 switch (_settings_game.game_creation.landscape) {
02694 case LT_ARCTIC:
02695 if (FindFirstCargoWithTownEffect(TE_FOOD) != NULL) t->goal[TE_FOOD] = TOWN_GROWTH_WINTER;
02696 break;
02697
02698 case LT_TROPIC:
02699 if (FindFirstCargoWithTownEffect(TE_FOOD) != NULL) t->goal[TE_FOOD] = TOWN_GROWTH_DESERT;
02700 if (FindFirstCargoWithTownEffect(TE_WATER) != NULL) t->goal[TE_WATER] = TOWN_GROWTH_DESERT;
02701 break;
02702 }
02703 }
02704 }
02705
02706 if (IsSavegameVersionBefore(165)) {
02707
02708 _saved_scrollpos_zoom = _saved_scrollpos_zoom + ZOOM_LVL_SHIFT;
02709 _saved_scrollpos_x *= ZOOM_LVL_BASE;
02710 _saved_scrollpos_y *= ZOOM_LVL_BASE;
02711 }
02712
02713
02714
02715
02716 if (gcf_res != GLC_ALL_GOOD) StartupEngines();
02717
02718 if (IsSavegameVersionBefore(166)) {
02719
02720 for (TileIndex t = 0; t < map_size; t++) {
02721 if (!IsTileType(t, MP_HOUSE)) continue;
02722 Town::Get(GetTownIndex(t))->cargo_accepted.Add(t);
02723 }
02724
02725 Town *town;
02726 FOR_ALL_TOWNS(town) {
02727 UpdateTownCargoes(town);
02728 }
02729 }
02730
02731
02732 if (IsSavegameVersionBefore(172)) {
02733 for (TileIndex t = 0; t < map_size; t++) {
02734 if (!IsStandardRoadStopTile(t)) continue;
02735 Owner o = GetTileOwner(t);
02736 SetRoadOwner(t, ROADTYPE_ROAD, o);
02737 SetRoadOwner(t, ROADTYPE_TRAM, o);
02738 }
02739 }
02740
02741 if (IsSavegameVersionBefore(175)) {
02742
02743 Company *c;
02744 FOR_ALL_COMPANIES(c) c->tree_limit = _settings_game.construction.tree_frame_burst << 16;
02745 }
02746
02747 if (IsSavegameVersionBefore(177)) {
02748
02749 if (_economy.inflation_prices > MAX_INFLATION) _economy.inflation_prices = MAX_INFLATION;
02750 if (_economy.inflation_payment > MAX_INFLATION) _economy.inflation_payment = MAX_INFLATION;
02751
02752
02753 FOR_ALL_COMPANIES(c) {
02754 c->months_of_bankruptcy = 3 * c->months_of_bankruptcy;
02755 }
02756 }
02757
02758 if (IsSavegameVersionBefore(178)) {
02759 extern uint8 _old_diff_level;
02760
02761 _settings_game.script.settings_profile = IsInsideMM(_old_diff_level, SP_BEGIN, SP_END) ? _old_diff_level : (uint)SP_MEDIUM;
02762 }
02763
02764 if (IsSavegameVersionBefore(182)) {
02765 Aircraft *v;
02766
02767 FOR_ALL_AIRCRAFT(v) {
02768 if (v->subtype <= AIR_AIRCRAFT) {
02769 const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);
02770 v->acceleration = avi->acceleration;
02771 }
02772 }
02773
02774
02775
02776 for (TileIndex t = 0; t < map_size; t++) {
02777 if (HasStationTileRail(t) && IsStationTileBlocked(t)) {
02778 SetRailStationReservation(t, false);
02779 }
02780 }
02781 }
02782
02783
02784 AfterLoadRoadStops();
02785 AfterLoadLabelMaps();
02786 AfterLoadCompanyStats();
02787
02788 GamelogPrintDebug(1);
02789
02790 InitializeWindowsAndCaches();
02791
02792 ResetSignalHandlers();
02793
02794 AfterLoadLinkGraphs();
02795 return true;
02796 }
02797
02806 void ReloadNewGRFData()
02807 {
02808
02809 GfxLoadSprites();
02810 LoadStringWidthTable();
02811 RecomputePrices();
02812
02813 ResetVehicleHash();
02814 AfterLoadVehicles(false);
02815 StartupEngines();
02816 GroupStatistics::UpdateAfterLoad();
02817
02818 AfterLoadStations();
02819
02820 AfterLoadCompanyStats();
02821
02822 UpdateHousesAndTowns();
02823
02824 DeleteInvalidEngineNews();
02825
02826 for (CompanyID i = COMPANY_FIRST; i < MAX_COMPANIES; i++) InvalidateWindowData(WC_COMPANY_COLOUR, i);
02827
02828 InvalidateWindowClassesData(WC_COMPANY_INFRASTRUCTURE);
02829
02830 MarkWholeScreenDirty();
02831 CheckTrainsLengths();
02832 }