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