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