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