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