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