00001
00002
00005 #include "../stdafx.h"
00006 #include "../void_map.h"
00007 #include "../signs_base.h"
00008 #include "../window_func.h"
00009 #include "../fios.h"
00010 #include "../train.h"
00011 #include "../roadveh.h"
00012 #include "../string_func.h"
00013 #include "../gamelog.h"
00014 #include "../network/network.h"
00015 #include "../gfxinit.h"
00016 #include "../functions.h"
00017 #include "../industry_map.h"
00018 #include "../town_map.h"
00019 #include "../clear_map.h"
00020 #include "../vehicle_func.h"
00021 #include "../newgrf_station.h"
00022 #include "../yapf/yapf.hpp"
00023 #include "../elrail_func.h"
00024 #include "../signs_func.h"
00025 #include "../aircraft.h"
00026 #include "../unmovable_map.h"
00027 #include "../tree_map.h"
00028 #include "../company_func.h"
00029 #include "../road_cmd.h"
00030 #include "../ai/ai.hpp"
00031 #include "../animated_tile_func.h"
00032
00033 #include "../economy_base.h"
00034 #include "table/strings.h"
00035
00036 #include "saveload_internal.h"
00037
00038 #include <signal.h>
00039
00040 extern StringID _switch_mode_errorstr;
00041 extern Company *DoStartupNewCompany(bool is_ai);
00042 extern void InitializeRailGUI();
00043
00055 void SetWaterClassDependingOnSurroundings(TileIndex t, bool include_invalid_water_class)
00056 {
00057
00058
00059 if (GetTileSlope(t, NULL) != SLOPE_FLAT) {
00060 if (include_invalid_water_class) {
00061 SetWaterClass(t, WATER_CLASS_INVALID);
00062 return;
00063 } else {
00064 NOT_REACHED();
00065 }
00066 }
00067
00068
00069 MarkTileDirtyByTile(t);
00070
00071 if (TileX(t) == 0 || TileY(t) == 0 || TileX(t) == MapMaxX() - 1 || TileY(t) == MapMaxY() - 1) {
00072
00073 SetWaterClass(t, WATER_CLASS_SEA);
00074 return;
00075 }
00076
00077 bool has_water = false;
00078 bool has_canal = false;
00079 bool has_river = false;
00080
00081 for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
00082 TileIndex neighbour = TileAddByDiagDir(t, dir);
00083 switch (GetTileType(neighbour)) {
00084 case MP_WATER:
00085
00086 if (IsCoast(neighbour)) {
00087 has_water = true;
00088 } else if (!IsLock(neighbour)) {
00089 switch (GetWaterClass(neighbour)) {
00090 case WATER_CLASS_SEA: has_water = true; break;
00091 case WATER_CLASS_CANAL: has_canal = true; break;
00092 case WATER_CLASS_RIVER: has_river = true; break;
00093 default: NOT_REACHED();
00094 }
00095 }
00096 break;
00097
00098 case MP_RAILWAY:
00099
00100 has_water |= (GetRailGroundType(neighbour) == RAIL_GROUND_WATER);
00101 break;
00102
00103 case MP_TREES:
00104
00105 has_water |= (GetTreeGround(neighbour) == TREE_GROUND_SHORE);
00106 break;
00107
00108 default: break;
00109 }
00110 }
00111
00112 if (!has_water && !has_canal && !has_river && include_invalid_water_class) {
00113 SetWaterClass(t, WATER_CLASS_INVALID);
00114 return;
00115 }
00116
00117 if (has_river && !has_canal) {
00118 SetWaterClass(t, WATER_CLASS_RIVER);
00119 } else if (has_canal || !has_water) {
00120 SetWaterClass(t, WATER_CLASS_CANAL);
00121 } else {
00122 SetWaterClass(t, WATER_CLASS_SEA);
00123 }
00124 }
00125
00126 static void ConvertTownOwner()
00127 {
00128 for (TileIndex tile = 0; tile != MapSize(); tile++) {
00129 switch (GetTileType(tile)) {
00130 case MP_ROAD:
00131 if (GB(_m[tile].m5, 4, 2) == ROAD_TILE_CROSSING && HasBit(_m[tile].m3, 7)) {
00132 _m[tile].m3 = OWNER_TOWN;
00133 }
00134
00135
00136 case MP_TUNNELBRIDGE:
00137 if (GetTileOwner(tile) & 0x80) SetTileOwner(tile, OWNER_TOWN);
00138 break;
00139
00140 default: break;
00141 }
00142 }
00143 }
00144
00145
00146 static void UpdateExclusiveRights()
00147 {
00148 Town *t;
00149
00150 FOR_ALL_TOWNS(t) {
00151 t->exclusivity = INVALID_COMPANY;
00152 }
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162 }
00163
00164 static const byte convert_currency[] = {
00165 0, 1, 12, 8, 3,
00166 10, 14, 19, 4, 5,
00167 9, 11, 13, 6, 17,
00168 16, 22, 21, 7, 15,
00169 18, 2, 20,
00170 };
00171
00172
00173 static void UpdateCurrencies()
00174 {
00175 _settings_game.locale.currency = convert_currency[_settings_game.locale.currency];
00176 }
00177
00178
00179
00180
00181 static void UpdateVoidTiles()
00182 {
00183 uint i;
00184
00185 for (i = 0; i < MapMaxY(); ++i) MakeVoid(i * MapSizeX() + MapMaxX());
00186 for (i = 0; i < MapSizeX(); ++i) MakeVoid(MapSizeX() * MapMaxY() + i);
00187 }
00188
00189 static inline RailType UpdateRailType(RailType rt, RailType min)
00190 {
00191 return rt >= min ? (RailType)(rt + 1): rt;
00192 }
00193
00205 static bool InitializeWindowsAndCaches()
00206 {
00207
00208 ResetWindowSystem();
00209 SetupColoursAndInitialWindow();
00210
00211 ResetViewportAfterLoadGame();
00212
00213
00214 UpdateAllStationVirtCoord();
00215 UpdateAllSignVirtCoords();
00216 UpdateAllTownVirtCoords();
00217 UpdateAllWaypointSigns();
00218
00219 Company *c;
00220 FOR_ALL_COMPANIES(c) {
00221
00222
00223
00224 if (_file_to_saveload.filetype == FT_SCENARIO && c->inaugurated_year != MIN_YEAR) {
00225 c->inaugurated_year = _cur_year;
00226 }
00227 }
00228
00229 SetCachedEngineCounts();
00230
00231
00232
00233
00234 UpdateAirportsNoise();
00235
00236 CheckTrainsLengths();
00237
00238 return true;
00239 }
00240
00241 typedef void (CDECL *SignalHandlerPointer)(int);
00242 static SignalHandlerPointer _prev_segfault = NULL;
00243 static SignalHandlerPointer _prev_abort = NULL;
00244 static SignalHandlerPointer _prev_fpe = NULL;
00245
00246 static void CDECL HandleSavegameLoadCrash(int signum);
00247
00252 static void SetSignalHandlers()
00253 {
00254 _prev_segfault = signal(SIGSEGV, HandleSavegameLoadCrash);
00255 _prev_abort = signal(SIGABRT, HandleSavegameLoadCrash);
00256 _prev_fpe = signal(SIGFPE, HandleSavegameLoadCrash);
00257 }
00258
00262 static void ResetSignalHandlers()
00263 {
00264 signal(SIGSEGV, _prev_segfault);
00265 signal(SIGABRT, _prev_abort);
00266 signal(SIGFPE, _prev_fpe);
00267 }
00268
00275 static void CDECL HandleSavegameLoadCrash(int signum)
00276 {
00277 ResetSignalHandlers();
00278
00279 char buffer[8192];
00280 char *p = buffer;
00281 p += seprintf(p, lastof(buffer),
00282 "Loading your savegame caused OpenTTD to crash.\n"
00283 "This is most likely caused by a missing NewGRF or a NewGRF that has been\n"
00284 "loaded as replacement for a missing NewGRF. OpenTTD cannot easily\n"
00285 "determine whether a replacement NewGRF is of a newer or older version.\n"
00286 "It will load a NewGRF with the same GRF ID as the missing NewGRF. This\n"
00287 "means that if the author makes incompatible NewGRFs with the same GRF ID\n"
00288 "OpenTTD cannot magically do the right thing. In most cases OpenTTD will\n"
00289 "load the savegame and not crash, but this is an exception.\n"
00290 "Please load the savegame with the appropriate NewGRFs. When loading a\n"
00291 "savegame still crashes when all NewGRFs are found you should file a\n"
00292 "bug report. The missing NewGRFs are:\n");
00293
00294 for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
00295 if (HasBit(c->flags, GCF_COMPATIBLE)) {
00296 char buf[40];
00297 md5sumToString(buf, lastof(buf), c->md5sum);
00298 p += seprintf(p, lastof(buffer), "NewGRF %08X (%s) not found; checksum %s. Tried another NewGRF with same GRF ID\n", BSWAP32(c->grfid), c->filename, buf);
00299 }
00300 if (c->status == GCS_NOT_FOUND) {
00301 char buf[40];
00302 md5sumToString(buf, lastof(buf), c->md5sum);
00303 p += seprintf(p, lastof(buffer), "NewGRF %08X (%s) not found; checksum %s\n", BSWAP32(c->grfid), c->filename, buf);
00304 }
00305 }
00306
00307 ShowInfo(buffer);
00308
00309 SignalHandlerPointer call = NULL;
00310 switch (signum) {
00311 case SIGSEGV: call = _prev_segfault; break;
00312 case SIGABRT: call = _prev_abort; break;
00313 case SIGFPE: call = _prev_fpe; break;
00314 default: NOT_REACHED();
00315 }
00316 if (call != NULL) call(signum);
00317 }
00318
00324 static void FixOwnerOfRailTrack(TileIndex t)
00325 {
00326 assert(!IsValidCompanyID(GetTileOwner(t)) && (IsLevelCrossingTile(t) || IsPlainRailTile(t)));
00327
00328
00329 Vehicle *v = NULL, *w;
00330 FOR_ALL_VEHICLES(w) {
00331 if (w->type == VEH_TRAIN && w->tile == t) {
00332 v = w;
00333 break;
00334 }
00335 }
00336
00337 if (v != NULL) {
00338
00339 SetTileOwner(t, v->owner);
00340 return;
00341 }
00342
00343
00344 for (DiagDirection dd = DIAGDIR_BEGIN; dd < DIAGDIR_END; dd++) {
00345 TileIndex tt = t + TileOffsByDiagDir(dd);
00346 if (GetTileTrackStatus(t, TRANSPORT_RAIL, 0, dd) != 0 &&
00347 GetTileTrackStatus(tt, TRANSPORT_RAIL, 0, ReverseDiagDir(dd)) != 0 &&
00348 IsValidCompanyID(GetTileOwner(tt))) {
00349 SetTileOwner(t, GetTileOwner(tt));
00350 return;
00351 }
00352 }
00353
00354 if (IsLevelCrossingTile(t)) {
00355
00356 MakeRoadNormal(t, GetCrossingRoadBits(t), GetRoadTypes(t), GetTownIndex(t),
00357 GetRoadOwner(t, ROADTYPE_ROAD), GetRoadOwner(t, ROADTYPE_TRAM));
00358 return;
00359 }
00360
00361
00362 MakeClear(t, CLEAR_GRASS, 0);
00363 }
00364
00365 bool AfterLoadGame()
00366 {
00367 SetSignalHandlers();
00368
00369 TileIndex map_size = MapSize();
00370 Company *c;
00371
00372 if (CheckSavegameVersion(98)) GamelogOldver();
00373
00374 GamelogTestRevision();
00375 GamelogTestMode();
00376
00377 if (CheckSavegameVersion(98)) GamelogGRFAddList(_grfconfig);
00378
00379
00380 if (CheckSavegameVersion(2)) {
00381 Station *st;
00382 FOR_ALL_STATIONS(st) {
00383 if (st->train_tile != 0 && st->trainst_h == 0) {
00384 uint n = _savegame_type == SGT_OTTD ? 4 : 3;
00385 uint w = GB(st->trainst_w, n, n);
00386 uint h = GB(st->trainst_w, 0, n);
00387
00388 if (GetRailStationAxis(st->train_tile) != AXIS_X) Swap(w, h);
00389
00390 st->trainst_w = w;
00391 st->trainst_h = h;
00392
00393 assert(GetStationIndex(st->train_tile + TileDiffXY(w - 1, h - 1)) == st->index);
00394 }
00395 }
00396 }
00397
00398
00399 if (CheckSavegameVersionOldStyle(2, 1)) ConvertTownOwner();
00400
00401
00402 if (CheckSavegameVersionOldStyle(4, 1)) UpdateExclusiveRights();
00403
00404
00405 if (CheckSavegameVersionOldStyle(4, 2)) UpdateCurrencies();
00406
00407
00408
00409
00410
00411 if (CheckSavegameVersionOldStyle(4, 3)) {
00412 for (TileIndex t = 0; t < map_size; t++) {
00413 if (IsTileType(t, MP_WATER) && GetTileOwner(t) >= MAX_COMPANIES) {
00414 SetTileOwner(t, OWNER_WATER);
00415 }
00416 }
00417 }
00418
00419 if (CheckSavegameVersion(84)) {
00420 FOR_ALL_COMPANIES(c) {
00421 c->name = CopyFromOldName(c->name_1);
00422 if (c->name != NULL) c->name_1 = STR_SV_UNNAMED;
00423 c->president_name = CopyFromOldName(c->president_name_1);
00424 if (c->president_name != NULL) c->president_name_1 = SPECSTR_PRESIDENT_NAME;
00425 }
00426
00427 Station *st;
00428 FOR_ALL_STATIONS(st) {
00429 st->name = CopyFromOldName(st->string_id);
00430
00431 if (st->name != NULL) st->string_id = STR_SV_STNAME_FALLBACK;
00432 }
00433
00434 Town *t;
00435 FOR_ALL_TOWNS(t) {
00436 t->name = CopyFromOldName(t->townnametype);
00437 if (t->name != NULL) t->townnametype = SPECSTR_TOWNNAME_START + _settings_game.game_creation.town_name;
00438 }
00439
00440 Waypoint *wp;
00441 FOR_ALL_WAYPOINTS(wp) {
00442 wp->name = CopyFromOldName(wp->string);
00443 wp->string = STR_EMPTY;
00444 }
00445 }
00446
00447
00448 ResetOldNames();
00449
00450 if (CheckSavegameVersion(106)) {
00451
00452 Station *st;
00453 FOR_ALL_STATIONS(st) {
00454 if (st->airport_tile == 0) st->airport_tile = INVALID_TILE;
00455 if (st->dock_tile == 0) st->dock_tile = INVALID_TILE;
00456 if (st->train_tile == 0) st->train_tile = INVALID_TILE;
00457 }
00458
00459
00460 Company *c;
00461 FOR_ALL_COMPANIES(c) {
00462 if (c->location_of_HQ == 0 || (CheckSavegameVersion(4) && c->location_of_HQ == 0xFFFF)) {
00463 c->location_of_HQ = INVALID_TILE;
00464 }
00465 }
00466 }
00467
00468
00469 if (_settings_game.vehicle.road_side) _settings_game.vehicle.road_side = 1;
00470
00471
00472 GRFListCompatibility gcf_res = IsGoodGRFConfigList();
00473 if (_networking && gcf_res != GLC_ALL_GOOD) {
00474 SetSaveLoadError(STR_NETWORK_ERR_CLIENT_NEWGRF_MISMATCH);
00475
00476 ResetSignalHandlers();
00477 return false;
00478 }
00479
00480 switch (gcf_res) {
00481 case GLC_COMPATIBLE: _switch_mode_errorstr = STR_NEWGRF_COMPATIBLE_LOAD_WARNING; break;
00482 case GLC_NOT_FOUND: _switch_mode_errorstr = STR_NEWGRF_DISABLED_WARNING; _pause_game = -1; break;
00483 default: break;
00484 }
00485
00486
00487
00488 SetDate(_date);
00489
00490
00491 if (CheckSavegameVersion(95)) _settings_game.vehicle.dynamic_engines = 0;
00492
00493
00494 GfxLoadSprites();
00495 LoadStringWidthTable();
00496
00497
00498 CopyTempEngineData();
00499
00500
00501
00502 if (CheckSavegameVersionOldStyle(17, 1)) ConvertOldMultiheadToNew();
00503
00504
00505 ConnectMultiheadedTrains();
00506
00507
00508 InitializeLandscapeVariables(true);
00509
00510
00511 AfterLoadVehicles(true);
00512
00513
00514 {
00515 Company *c;
00516 FOR_ALL_COMPANIES(c) {
00517 if (c->is_ai && c->ai_instance == NULL) AI::StartNew(c->index);
00518 }
00519 }
00520
00521
00522 if (CheckSavegameVersion(12)) FixOldWaypoints();
00523
00524
00525 if (_game_mode == GM_NORMAL && !ClosestTownFromTile(0, UINT_MAX)) {
00526 SetSaveLoadError(STR_NO_TOWN_IN_SCENARIO);
00527
00528 ResetSignalHandlers();
00529 return false;
00530 }
00531
00532
00533
00534
00535
00536 if (CheckSavegameVersion(87)) UpdateVoidTiles();
00537
00538
00539
00540
00541
00542 if (!IsValidCompanyID(COMPANY_FIRST) && (!_networking || (_networking && _network_server && !_network_dedicated)))
00543 DoStartupNewCompany(false);
00544
00545
00546 CargoPayment *cp;
00547 FOR_ALL_CARGO_PAYMENTS(cp) {
00548 cp->front->cargo_payment = cp;
00549 cp->current_station = cp->front->last_station_visited;
00550 }
00551
00552 if (CheckSavegameVersion(72)) {
00553
00554 for (TileIndex t = 0; t < MapSize(); t++) {
00555 switch (GetTileType(t)) {
00556 default: break;
00557
00558 case MP_WATER:
00559 if (GetWaterTileType(t) == WATER_TILE_LOCK && GetTileOwner(t) == OWNER_WATER) SetTileOwner(t, OWNER_NONE);
00560 break;
00561
00562 case MP_STATION: {
00563 if (HasBit(_m[t].m6, 3)) SetBit(_m[t].m6, 2);
00564 StationGfx gfx = GetStationGfx(t);
00565 StationType st;
00566 if ( IsInsideMM(gfx, 0, 8)) {
00567 st = STATION_RAIL;
00568 SetStationGfx(t, gfx - 0);
00569 } else if (IsInsideMM(gfx, 8, 67)) {
00570 st = STATION_AIRPORT;
00571 SetStationGfx(t, gfx - 8);
00572 } else if (IsInsideMM(gfx, 67, 71)) {
00573 st = STATION_TRUCK;
00574 SetStationGfx(t, gfx - 67);
00575 } else if (IsInsideMM(gfx, 71, 75)) {
00576 st = STATION_BUS;
00577 SetStationGfx(t, gfx - 71);
00578 } else if (gfx == 75) {
00579 st = STATION_OILRIG;
00580 SetStationGfx(t, gfx - 75);
00581 } else if (IsInsideMM(gfx, 76, 82)) {
00582 st = STATION_DOCK;
00583 SetStationGfx(t, gfx - 76);
00584 } else if (gfx == 82) {
00585 st = STATION_BUOY;
00586 SetStationGfx(t, gfx - 82);
00587 } else if (IsInsideMM(gfx, 83, 168)) {
00588 st = STATION_AIRPORT;
00589 SetStationGfx(t, gfx - 83 + 67 - 8);
00590 } else if (IsInsideMM(gfx, 168, 170)) {
00591 st = STATION_TRUCK;
00592 SetStationGfx(t, gfx - 168 + GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);
00593 } else if (IsInsideMM(gfx, 170, 172)) {
00594 st = STATION_BUS;
00595 SetStationGfx(t, gfx - 170 + GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);
00596 } else {
00597
00598 ResetSignalHandlers();
00599 return false;
00600 }
00601 SB(_m[t].m6, 3, 3, st);
00602 } break;
00603 }
00604 }
00605 }
00606
00607 for (TileIndex t = 0; t < map_size; t++) {
00608 switch (GetTileType(t)) {
00609 case MP_STATION: {
00610 Station *st = GetStationByTile(t);
00611
00612
00613 if (!IsBuoy(t)) st->rect.BeforeAddTile(t, StationRect::ADD_FORCE);
00614
00615 switch (GetStationType(t)) {
00616 case STATION_TRUCK:
00617 case STATION_BUS:
00618 if (CheckSavegameVersion(6)) {
00619
00620
00621
00622 RoadStop *rs = new RoadStop(t);
00623 if (rs == NULL) error("Too many road stops in savegame");
00624
00625 RoadStop **head =
00626 IsTruckStop(t) ? &st->truck_stops : &st->bus_stops;
00627 *head = rs;
00628 }
00629 break;
00630
00631 case STATION_OILRIG: {
00632
00633
00634
00635
00636 TileIndex t1 = TILE_ADDXY(t, 0, 1);
00637 if (IsTileType(t1, MP_INDUSTRY) &&
00638 GetIndustryGfx(t1) == GFX_OILRIG_1) {
00639
00640
00641
00642
00643 GetStationByTile(t)->airport_type = AT_OILRIG;
00644 } else {
00645 DeleteOilRig(t);
00646 }
00647 break;
00648 }
00649
00650 default: break;
00651 }
00652 break;
00653 }
00654
00655 default: break;
00656 }
00657 }
00658
00659
00660
00661 if (CheckSavegameVersionOldStyle(2, 2)) UpdateOldAircraft();
00662
00663
00664
00665
00666 if (CheckSavegameVersionOldStyle(6, 1)) {
00667 for (TileIndex t = 0; t < map_size; t++) {
00668 switch (GetTileType(t)) {
00669 case MP_HOUSE:
00670 _m[t].m4 = _m[t].m2;
00671 SetTownIndex(t, CalcClosestTownFromTile(t)->index);
00672 break;
00673
00674 case MP_ROAD:
00675 _m[t].m4 |= (_m[t].m2 << 4);
00676 if ((GB(_m[t].m5, 4, 2) == ROAD_TILE_CROSSING ? (Owner)_m[t].m3 : GetTileOwner(t)) == OWNER_TOWN) {
00677 SetTownIndex(t, CalcClosestTownFromTile(t)->index);
00678 } else {
00679 SetTownIndex(t, 0);
00680 }
00681 break;
00682
00683 default: break;
00684 }
00685 }
00686 }
00687
00688
00689 if (CheckSavegameVersion(111)) {
00690 _settings_game.construction.freeform_edges = false;
00691 }
00692
00693
00694
00695 if (CheckSavegameVersion(9)) {
00696 Town *t;
00697 FOR_ALL_TOWNS(t) UpdateTownMaxPass(t);
00698 }
00699
00700
00701
00702 if (CheckSavegameVersion(16)) {
00703 FOR_ALL_COMPANIES(c) {
00704 c->engine_renew_list = NULL;
00705 c->engine_renew = false;
00706 c->engine_renew_months = -6;
00707 c->engine_renew_money = 100000;
00708 }
00709
00710
00711
00712
00713
00714
00715
00716 if (!_network_dedicated && IsValidCompanyID(COMPANY_FIRST)) {
00717 c = GetCompany(COMPANY_FIRST);
00718 c->engine_renew = _settings_client.gui.autorenew;
00719 c->engine_renew_months = _settings_client.gui.autorenew_months;
00720 c->engine_renew_money = _settings_client.gui.autorenew_money;
00721 }
00722 }
00723
00724 if (CheckSavegameVersion(48)) {
00725 for (TileIndex t = 0; t < map_size; t++) {
00726 switch (GetTileType(t)) {
00727 case MP_RAILWAY:
00728 if (IsPlainRailTile(t)) {
00729
00730
00731 uint tmp = GB(_m[t].m4, 0, 4);
00732 SB(_m[t].m4, 0, 4, GB(_m[t].m2, 0, 4));
00733 SB(_m[t].m2, 0, 4, tmp);
00734 } else if (HasBit(_m[t].m5, 2)) {
00735
00736 ClrBit(_m[t].m5, 2);
00737 ClrBit(_m[t].m5, 6);
00738 }
00739 break;
00740
00741 case MP_ROAD:
00742
00743
00744 Swap(_m[t].m3, _m[t].m4);
00745 break;
00746
00747 default: break;
00748 }
00749 }
00750 }
00751
00752 if (CheckSavegameVersion(61)) {
00753
00754 bool old_bridge = CheckSavegameVersion(42);
00755 for (TileIndex t = 0; t < map_size; t++) {
00756 switch (GetTileType(t)) {
00757 case MP_ROAD:
00758 SB(_m[t].m5, 6, 2, GB(_m[t].m5, 4, 2));
00759 switch (GetRoadTileType(t)) {
00760 default: NOT_REACHED();
00761 case ROAD_TILE_NORMAL:
00762 SB(_m[t].m4, 0, 4, GB(_m[t].m5, 0, 4));
00763 SB(_m[t].m4, 4, 4, 0);
00764 SB(_m[t].m6, 2, 4, 0);
00765 break;
00766 case ROAD_TILE_CROSSING:
00767 SB(_m[t].m4, 5, 2, GB(_m[t].m5, 2, 2));
00768 break;
00769 case ROAD_TILE_DEPOT: break;
00770 }
00771 SetRoadTypes(t, ROADTYPES_ROAD);
00772 break;
00773
00774 case MP_STATION:
00775 if (IsRoadStop(t)) SetRoadTypes(t, ROADTYPES_ROAD);
00776 break;
00777
00778 case MP_TUNNELBRIDGE:
00779
00780 if (old_bridge && IsBridge(t) && HasBit(_m[t].m5, 6)) break;
00781 if (((old_bridge && IsBridge(t)) ? (TransportType)GB(_m[t].m5, 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) {
00782 SetRoadTypes(t, ROADTYPES_ROAD);
00783 }
00784 break;
00785
00786 default: break;
00787 }
00788 }
00789 }
00790
00791 if (CheckSavegameVersion(114)) {
00792 bool fix_roadtypes = !CheckSavegameVersion(61);
00793 bool old_bridge = CheckSavegameVersion(42);
00794
00795 for (TileIndex t = 0; t < map_size; t++) {
00796 switch (GetTileType(t)) {
00797 case MP_ROAD:
00798 if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_me[t].m7, 5, 3));
00799 SB(_me[t].m7, 5, 1, GB(_m[t].m3, 7, 1));
00800 switch (GetRoadTileType(t)) {
00801 default: NOT_REACHED();
00802 case ROAD_TILE_NORMAL:
00803 SB(_me[t].m7, 0, 4, GB(_m[t].m3, 0, 4));
00804 SB(_m[t].m6, 3, 3, GB(_m[t].m3, 4, 3));
00805 SB(_m[t].m3, 0, 4, GB(_m[t].m4, 4, 4));
00806 SB(_m[t].m3, 4, 4, GB(_m[t].m5, 0, 4));
00807 SB(_m[t].m5, 0, 4, GB(_m[t].m4, 0, 4));
00808 break;
00809
00810 case ROAD_TILE_CROSSING:
00811 SB(_me[t].m7, 0, 5, GB(_m[t].m4, 0, 5));
00812 SB(_m[t].m6, 3, 3, GB(_m[t].m3, 4, 3));
00813 SB(_m[t].m3, 4, 4, GB(_m[t].m5, 0, 4));
00814 SB(_m[t].m5, 0, 1, GB(_m[t].m4, 6, 1));
00815 SB(_m[t].m5, 5, 1, GB(_m[t].m4, 5, 1));
00816 break;
00817
00818 case ROAD_TILE_DEPOT:
00819 break;
00820 }
00821 if (!HasTownOwnedRoad(t)) {
00822 const Town *town = CalcClosestTownFromTile(t);
00823 if (town != NULL) SetTownIndex(t, town->index);
00824 }
00825 _m[t].m4 = 0;
00826 break;
00827
00828 case MP_STATION:
00829 if (!IsRoadStop(t)) break;
00830
00831 if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_m[t].m3, 0, 3));
00832 SB(_me[t].m7, 0, 5, HasBit(_m[t].m6, 2) ? OWNER_TOWN : GetTileOwner(t));
00833 SB(_m[t].m3, 4, 4, _m[t].m1);
00834 _m[t].m4 = 0;
00835 break;
00836
00837 case MP_TUNNELBRIDGE:
00838 if (old_bridge && IsBridge(t) && HasBit(_m[t].m5, 6)) break;
00839 if (((old_bridge && IsBridge(t)) ? (TransportType)GB(_m[t].m5, 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) {
00840 if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_m[t].m3, 0, 3));
00841
00842 Owner o = GetTileOwner(t);
00843 SB(_me[t].m7, 0, 5, o);
00844 SB(_m[t].m3, 4, 4, o == OWNER_NONE ? OWNER_TOWN : o);
00845 }
00846 SB(_m[t].m6, 2, 4, GB(_m[t].m2, 4, 4));
00847 SB(_me[t].m7, 5, 1, GB(_m[t].m4, 7, 1));
00848
00849 _m[t].m2 = 0;
00850 _m[t].m4 = 0;
00851 break;
00852
00853 default: break;
00854 }
00855 }
00856 }
00857
00858 if (CheckSavegameVersion(42)) {
00859 Vehicle *v;
00860
00861 for (TileIndex t = 0; t < map_size; t++) {
00862 if (MayHaveBridgeAbove(t)) ClearBridgeMiddle(t);
00863 if (IsBridgeTile(t)) {
00864 if (HasBit(_m[t].m5, 6)) {
00865 Axis axis = (Axis)GB(_m[t].m5, 0, 1);
00866
00867 if (HasBit(_m[t].m5, 5)) {
00868 if (GB(_m[t].m5, 3, 2) == TRANSPORT_RAIL) {
00869 MakeRailNormal(
00870 t,
00871 GetTileOwner(t),
00872 axis == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X,
00873 GetRailType(t)
00874 );
00875 } else {
00876 TownID town = IsTileOwner(t, OWNER_TOWN) ? ClosestTownFromTile(t, UINT_MAX)->index : 0;
00877
00878 MakeRoadNormal(
00879 t,
00880 axis == AXIS_X ? ROAD_Y : ROAD_X,
00881 ROADTYPES_ROAD,
00882 town,
00883 GetTileOwner(t), OWNER_NONE
00884 );
00885 }
00886 } else {
00887 if (GB(_m[t].m5, 3, 2) == 0) {
00888 MakeClear(t, CLEAR_GRASS, 3);
00889 } else {
00890 if (GetTileSlope(t, NULL) != SLOPE_FLAT) {
00891 MakeShore(t);
00892 } else {
00893 if (GetTileOwner(t) == OWNER_WATER) {
00894 MakeWater(t);
00895 } else {
00896 MakeCanal(t, GetTileOwner(t), Random());
00897 }
00898 }
00899 }
00900 }
00901 SetBridgeMiddle(t, axis);
00902 } else {
00903 Axis axis = (Axis)GB(_m[t].m5, 0, 1);
00904 uint north_south = GB(_m[t].m5, 5, 1);
00905 DiagDirection dir = ReverseDiagDir(XYNSToDiagDir(axis, north_south));
00906 TransportType type = (TransportType)GB(_m[t].m5, 1, 2);
00907
00908 _m[t].m5 = 1 << 7 | type << 2 | dir;
00909 }
00910 }
00911 }
00912
00913 FOR_ALL_VEHICLES(v) {
00914 if (v->type != VEH_TRAIN && v->type != VEH_ROAD) continue;
00915 if (IsBridgeTile(v->tile)) {
00916 DiagDirection dir = GetTunnelBridgeDirection(v->tile);
00917
00918 if (dir != DirToDiagDir(v->direction)) continue;
00919 switch (dir) {
00920 default: NOT_REACHED();
00921 case DIAGDIR_NE: if ((v->x_pos & 0xF) != 0) continue; break;
00922 case DIAGDIR_SE: if ((v->y_pos & 0xF) != TILE_SIZE - 1) continue; break;
00923 case DIAGDIR_SW: if ((v->x_pos & 0xF) != TILE_SIZE - 1) continue; break;
00924 case DIAGDIR_NW: if ((v->y_pos & 0xF) != 0) continue; break;
00925 }
00926 } else if (v->z_pos > GetSlopeZ(v->x_pos, v->y_pos)) {
00927 v->tile = GetNorthernBridgeEnd(v->tile);
00928 } else {
00929 continue;
00930 }
00931 if (v->type == VEH_TRAIN) {
00932 v->u.rail.track = TRACK_BIT_WORMHOLE;
00933 } else {
00934 v->u.road.state = RVSB_WORMHOLE;
00935 }
00936 }
00937 }
00938
00939
00940 if (CheckSavegameVersion(24)) {
00941 Vehicle *v;
00942 RailType min_rail = RAILTYPE_ELECTRIC;
00943
00944 FOR_ALL_VEHICLES(v) {
00945 if (v->type == VEH_TRAIN) {
00946 RailType rt = RailVehInfo(v->engine_type)->railtype;
00947
00948 v->u.rail.railtype = rt;
00949 if (rt == RAILTYPE_ELECTRIC) min_rail = RAILTYPE_RAIL;
00950 }
00951 }
00952
00953
00954 for (TileIndex t = 0; t < map_size; t++) {
00955 switch (GetTileType(t)) {
00956 case MP_RAILWAY:
00957 SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
00958 break;
00959
00960 case MP_ROAD:
00961 if (IsLevelCrossing(t)) {
00962 SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
00963 }
00964 break;
00965
00966 case MP_STATION:
00967 if (IsRailwayStation(t)) {
00968 SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
00969 }
00970 break;
00971
00972 case MP_TUNNELBRIDGE:
00973 if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) {
00974 SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
00975 }
00976 break;
00977
00978 default:
00979 break;
00980 }
00981 }
00982
00983 FOR_ALL_VEHICLES(v) {
00984 if (v->type == VEH_TRAIN && (IsFrontEngine(v) || IsFreeWagon(v))) TrainConsistChanged(v, true);
00985 }
00986
00987 }
00988
00989
00990
00991
00992 if (CheckSavegameVersionOldStyle(16, 1)) {
00993 FOR_ALL_COMPANIES(c) c->renew_keep_length = false;
00994 }
00995
00996
00997
00998
00999
01000 if (CheckSavegameVersion(17)) {
01001 Waypoint *wp;
01002
01003 FOR_ALL_WAYPOINTS(wp) {
01004 if (wp->deleted == 0) {
01005 const StationSpec *statspec = NULL;
01006
01007 if (HasBit(_m[wp->xy].m3, 4))
01008 statspec = GetCustomStationSpec(STAT_CLASS_WAYP, _m[wp->xy].m4 + 1);
01009
01010 if (statspec != NULL) {
01011 wp->stat_id = _m[wp->xy].m4 + 1;
01012 wp->grfid = statspec->grffile->grfid;
01013 wp->localidx = statspec->localidx;
01014 } else {
01015
01016 wp->stat_id = 0;
01017 wp->grfid = 0;
01018 wp->localidx = 0;
01019 }
01020
01021
01022 _m[wp->xy].m4 = GB(_m[wp->xy].m2, 0, 4);
01023
01024 _m[wp->xy].m2 = wp->index;
01025 }
01026 }
01027 } else {
01028
01029
01030 AfterLoadWaypoints();
01031 }
01032
01033
01034
01035 if (CheckSavegameVersion(21) && !CheckSavegameVersion(15)) {
01036 for (TileIndex t = 0; t < map_size; t++) {
01037 switch (GetTileType(t)) {
01038 case MP_RAILWAY:
01039 if (HasSignals(t)) {
01040
01041 if (HasBit(_m[t].m2, 2)) SetSignalType(t, TRACK_X, SIGTYPE_COMBO);
01042
01043
01044 SetSignalVariant(t, TRACK_X, HasBit(_m[t].m2, 3) ? SIG_SEMAPHORE : SIG_ELECTRIC);
01045 ClrBit(_m[t].m2, 3);
01046 }
01047
01048
01049 if (!IsRailDepotTile(t)) {
01050 SB(_m[t].m4, 4, 4, 0);
01051 } else {
01052 ClrBit(_m[t].m3, 6);
01053 }
01054 break;
01055
01056 case MP_STATION:
01057 ClrBit(_m[t].m3, 6);
01058 break;
01059
01060 default: break;
01061 }
01062 }
01063 }
01064
01065 if (CheckSavegameVersion(25)) {
01066 Vehicle *v;
01067 FOR_ALL_VEHICLES(v) {
01068 if (v->type == VEH_ROAD) {
01069 v->vehstatus &= ~0x40;
01070 v->u.road.slot = NULL;
01071 v->u.road.slot_age = 0;
01072 }
01073 }
01074 } else {
01075 Vehicle *v;
01076 FOR_ALL_VEHICLES(v) {
01077 if (v->type == VEH_ROAD && v->u.road.slot != NULL) v->u.road.slot->num_vehicles++;
01078 }
01079 }
01080
01081 if (CheckSavegameVersion(26)) {
01082 Station *st;
01083 FOR_ALL_STATIONS(st) {
01084 st->last_vehicle_type = VEH_INVALID;
01085 }
01086 }
01087
01088 YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK);
01089
01090 if (CheckSavegameVersion(34)) FOR_ALL_COMPANIES(c) ResetCompanyLivery(c);
01091
01092 FOR_ALL_COMPANIES(c) {
01093 c->avail_railtypes = GetCompanyRailtypes(c->index);
01094 c->avail_roadtypes = GetCompanyRoadtypes(c->index);
01095 }
01096
01097 if (!CheckSavegameVersion(27)) AfterLoadStations();
01098
01099
01100
01101 if (CheckSavegameVersion(31)) {
01102 Station *st;
01103 Waypoint *wp;
01104 Engine *e;
01105 Industry *i;
01106 Vehicle *v;
01107
01108 _date += DAYS_TILL_ORIGINAL_BASE_YEAR;
01109 _cur_year += ORIGINAL_BASE_YEAR;
01110
01111 FOR_ALL_STATIONS(st) st->build_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
01112 FOR_ALL_WAYPOINTS(wp) wp->build_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
01113 FOR_ALL_ENGINES(e) e->intro_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
01114 FOR_ALL_COMPANIES(c) c->inaugurated_year += ORIGINAL_BASE_YEAR;
01115 FOR_ALL_INDUSTRIES(i) i->last_prod_year += ORIGINAL_BASE_YEAR;
01116
01117 FOR_ALL_VEHICLES(v) {
01118 v->date_of_last_service += DAYS_TILL_ORIGINAL_BASE_YEAR;
01119 v->build_year += ORIGINAL_BASE_YEAR;
01120 }
01121 }
01122
01123
01124
01125
01126 if (CheckSavegameVersion(32)) {
01127 Industry *i;
01128
01129 for (TileIndex t = 0; t < map_size; t++) {
01130 if (IsTileType(t, MP_CLEAR) && IsClearGround(t, CLEAR_FIELDS)) {
01131
01132 MakeClear(t, CLEAR_GRASS, 3);
01133 } else if (IsTileType(t, MP_CLEAR) || IsTileType(t, MP_TREES)) {
01134
01135 SetFenceSE(t, 0);
01136 SetFenceSW(t, 0);
01137 }
01138 }
01139
01140 FOR_ALL_INDUSTRIES(i) {
01141 uint j;
01142
01143 if (GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_PLANT_ON_BUILT) {
01144 for (j = 0; j != 50; j++) PlantRandomFarmField(i);
01145 }
01146 }
01147 }
01148
01149
01150 if (CheckSavegameVersion(36)) {
01151 Order *order;
01152 Vehicle *v;
01153
01154 FOR_ALL_ORDERS(order) {
01155 order->SetRefit(CT_NO_REFIT);
01156 }
01157
01158 FOR_ALL_VEHICLES(v) {
01159 v->current_order.SetRefit(CT_NO_REFIT);
01160 }
01161 }
01162
01163
01164
01165 if (CheckSavegameVersion(38)) _settings_game.vehicle.disable_elrails = false;
01166
01167 SettingsDisableElrail(_settings_game.vehicle.disable_elrails);
01168 InitializeRailGUI();
01169
01170
01171
01172 if (CheckSavegameVersion(53)) {
01173 for (TileIndex t = 0; t < map_size; t++) {
01174 if (IsTileType(t, MP_HOUSE)) {
01175 if (GB(_m[t].m3, 6, 2) != TOWN_HOUSE_COMPLETED) {
01176
01177
01178 SB(_m[t].m5, 3, 2, GB(_m[t].m3, 6, 2));
01179 SB(_m[t].m3, 6, 2, 0);
01180
01181
01182 SetHouseCompleted(t, false);
01183 } else {
01184
01185
01186 SB(_me[t].m7, 0, 1, HasBit(_m[t].m5, 7));
01187 ClrBit(_m[t].m5, 7);
01188
01189
01190
01191 ClrBit(_m[t].m1, 7);
01192
01193
01194
01195
01196 SetLiftPosition(t, GB(_m[t].m1, 0, 6 ));
01197
01198 _m[t].m1 = 0;
01199 _m[t].m3 = 0;
01200 SetHouseCompleted(t, true);
01201 }
01202 }
01203 }
01204 }
01205
01206
01207 UpdateHousesAndTowns();
01208
01209 if (CheckSavegameVersion(43)) {
01210 for (TileIndex t = 0; t < map_size; t++) {
01211 if (IsTileType(t, MP_INDUSTRY)) {
01212 switch (GetIndustryGfx(t)) {
01213 case GFX_POWERPLANT_SPARKS:
01214 SetIndustryAnimationState(t, GB(_m[t].m1, 2, 5));
01215 break;
01216
01217 case GFX_OILWELL_ANIMATED_1:
01218 case GFX_OILWELL_ANIMATED_2:
01219 case GFX_OILWELL_ANIMATED_3:
01220 SetIndustryAnimationState(t, GB(_m[t].m1, 0, 2));
01221 break;
01222
01223 case GFX_COAL_MINE_TOWER_ANIMATED:
01224 case GFX_COPPER_MINE_TOWER_ANIMATED:
01225 case GFX_GOLD_MINE_TOWER_ANIMATED:
01226 SetIndustryAnimationState(t, _m[t].m1);
01227 break;
01228
01229 default:
01230 break;
01231 }
01232 }
01233 }
01234 }
01235
01236 if (CheckSavegameVersion(44)) {
01237 Vehicle *v;
01238
01239
01240
01241
01242
01243
01244 FOR_ALL_VEHICLES(v) {
01245 const CargoList::List *packets = v->cargo.Packets();
01246 for (CargoList::List::const_iterator it = packets->begin(); it != packets->end(); it++) {
01247 CargoPacket *cp = *it;
01248 cp->source_xy = IsValidStationID(cp->source) ? GetStation(cp->source)->xy : v->tile;
01249 cp->loaded_at_xy = cp->source_xy;
01250 }
01251 v->cargo.InvalidateCache();
01252 }
01253
01254
01255
01256
01257
01258
01259 Station *st;
01260 FOR_ALL_STATIONS(st) {
01261 for (CargoID c = 0; c < NUM_CARGO; c++) {
01262 GoodsEntry *ge = &st->goods[c];
01263
01264 const CargoList::List *packets = ge->cargo.Packets();
01265 for (CargoList::List::const_iterator it = packets->begin(); it != packets->end(); it++) {
01266 CargoPacket *cp = *it;
01267 cp->source_xy = IsValidStationID(cp->source) ? GetStation(cp->source)->xy : st->xy;
01268 cp->loaded_at_xy = cp->source_xy;
01269 }
01270 }
01271 }
01272 }
01273
01274 if (CheckSavegameVersion(45)) {
01275 Vehicle *v;
01276
01277
01278
01279
01280
01281 FOR_ALL_VEHICLES(v) {
01282 ClrBit(v->vehicle_flags, 2);
01283 v->cargo.InvalidateCache();
01284 }
01285 }
01286
01287
01288
01289 if (CheckSavegameVersion(46)) {
01290 Station *st;
01291 FOR_ALL_STATIONS(st) {
01292 if (st->IsBuoy() && IsTileOwner(st->xy, OWNER_NONE) && TileHeight(st->xy) == 0) SetTileOwner(st->xy, OWNER_WATER);
01293 }
01294 }
01295
01296 if (CheckSavegameVersion(50)) {
01297 Vehicle *v;
01298
01299 FOR_ALL_VEHICLES(v) {
01300 if (v->type == VEH_AIRCRAFT && v->subtype <= AIR_AIRCRAFT) {
01301 const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);
01302 v->cur_speed *= 129;
01303 v->cur_speed /= 10;
01304 v->max_speed = avi->max_speed;
01305 v->acceleration = avi->acceleration;
01306 }
01307 }
01308 }
01309
01310 if (CheckSavegameVersion(49)) FOR_ALL_COMPANIES(c) c->face = ConvertFromOldCompanyManagerFace(c->face);
01311
01312 if (CheckSavegameVersion(52)) {
01313 for (TileIndex t = 0; t < map_size; t++) {
01314 if (IsStatueTile(t)) {
01315 _m[t].m2 = CalcClosestTownFromTile(t)->index;
01316 }
01317 }
01318 }
01319
01320
01321
01322
01323 if (CheckSavegameVersion(56)) {
01324 Town *t;
01325
01326 FOR_ALL_TOWNS(t) {
01327 if (_settings_game.economy.larger_towns != 0 && (t->index % _settings_game.economy.larger_towns) == 0) {
01328 t->larger_town = true;
01329 }
01330 }
01331 }
01332
01333 if (CheckSavegameVersion(57)) {
01334 Vehicle *v;
01335
01336 FOR_ALL_VEHICLES(v) {
01337 if ((v->type != VEH_TRAIN || IsFrontEngine(v)) &&
01338 !(v->vehstatus & (VS_STOPPED | VS_CRASHED)) &&
01339 v->current_order.IsType(OT_LOADING)) {
01340 GetStation(v->last_station_visited)->loading_vehicles.push_back(v);
01341
01342
01343
01344 ClrBit(v->vehicle_flags, VF_LOADING_FINISHED);
01345 }
01346 }
01347 } else if (CheckSavegameVersion(59)) {
01348
01349
01350 Station *st;
01351 FOR_ALL_STATIONS(st) {
01352 std::list<Vehicle *>::iterator iter;
01353 for (iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end();) {
01354 Vehicle *v = *iter;
01355 iter++;
01356 if (!v->current_order.IsType(OT_LOADING)) st->loading_vehicles.remove(v);
01357 }
01358 }
01359 }
01360
01361 if (CheckSavegameVersion(58)) {
01362
01363
01364 if (_settings_game.difficulty.number_industries > 0) {
01365 _settings_game.difficulty.number_industries++;
01366 }
01367
01368
01369 _settings_game.difficulty.number_towns++;
01370 }
01371
01372 if (CheckSavegameVersion(64)) {
01373
01374 for (TileIndex t = 0; t < map_size; t++) {
01375 if (IsTileType(t, MP_RAILWAY) && HasSignals(t)) {
01376 SetSignalStates(t, GB(_m[t].m2, 4, 4));
01377 SetSignalVariant(t, INVALID_TRACK, GetSignalVariant(t, TRACK_X));
01378 SetSignalType(t, INVALID_TRACK, GetSignalType(t, TRACK_X));
01379 ClrBit(_m[t].m2, 7);
01380 }
01381 }
01382 }
01383
01384 if (CheckSavegameVersion(69)) {
01385
01386 Vehicle *v;
01387 FOR_ALL_VEHICLES(v) {
01388 if (v->type == VEH_ROAD && (v->u.road.state == 250 || v->u.road.state == 251)) {
01389 SetBit(v->u.road.state, RVS_IS_STOPPING);
01390 }
01391 }
01392 }
01393
01394 if (CheckSavegameVersion(70)) {
01395
01396 Industry *i;
01397 FOR_ALL_INDUSTRIES(i) i->founder = OWNER_NONE;
01398 }
01399
01400
01401
01402 if (CheckSavegameVersion(82)) {
01403 for (TileIndex t = 0; t < map_size; t++) {
01404 if (IsTileType(t, MP_WATER) &&
01405 GetWaterTileType(t) == WATER_TILE_CLEAR &&
01406 GetTileOwner(t) == OWNER_WATER &&
01407 TileHeight(t) != 0) {
01408 SetTileOwner(t, OWNER_NONE);
01409 }
01410 }
01411 }
01412
01413
01414
01415
01416
01417
01418
01419 if (CheckSavegameVersion(83)) {
01420 for (TileIndex t = 0; t < map_size; t++) {
01421 if (IsTileType(t, MP_WATER) && IsShipDepot(t)) {
01422 _m[t].m4 = (TileHeight(t) == 0) ? OWNER_WATER : OWNER_NONE;
01423 }
01424 }
01425 }
01426
01427 if (CheckSavegameVersion(74)) {
01428 Station *st;
01429 FOR_ALL_STATIONS(st) {
01430 for (CargoID c = 0; c < NUM_CARGO; c++) {
01431 st->goods[c].last_speed = 0;
01432 if (st->goods[c].cargo.Count() != 0) SetBit(st->goods[c].acceptance_pickup, GoodsEntry::PICKUP);
01433 }
01434 }
01435 }
01436
01437 if (CheckSavegameVersion(78)) {
01438 Industry *i;
01439 uint j;
01440 FOR_ALL_INDUSTRIES(i) {
01441 const IndustrySpec *indsp = GetIndustrySpec(i->type);
01442 for (j = 0; j < lengthof(i->produced_cargo); j++) {
01443 i->produced_cargo[j] = indsp->produced_cargo[j];
01444 }
01445 for (j = 0; j < lengthof(i->accepts_cargo); j++) {
01446 i->accepts_cargo[j] = indsp->accepts_cargo[j];
01447 }
01448 }
01449 }
01450
01451
01452
01453
01454
01455 if (CheckSavegameVersion(81)) {
01456 for (TileIndex t = 0; t < map_size; t++) {
01457 if (GetTileType(t) == MP_TREES) {
01458 TreeGround groundType = GetTreeGround(t);
01459 if (groundType != TREE_GROUND_SNOW_DESERT) SetTreeGroundDensity(t, groundType, 3);
01460 }
01461 }
01462 }
01463
01464
01465 if (CheckSavegameVersion(93)) {
01466
01467 Order *order;
01468 FOR_ALL_ORDERS(order) order->ConvertFromOldSavegame();
01469
01470 Vehicle *v;
01471 FOR_ALL_VEHICLES(v) {
01472 if (v->orders.list != NULL && v->orders.list->GetFirstOrder() != NULL && !v->orders.list->GetFirstOrder()->IsValid()) {
01473 v->orders.list->FreeChain();
01474 v->orders.list = NULL;
01475 }
01476
01477 v->current_order.ConvertFromOldSavegame();
01478 if (v->type == VEH_ROAD && v->IsPrimaryVehicle() && v->FirstShared() == v) {
01479 FOR_VEHICLE_ORDERS(v, order) order->SetNonStopType(ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS);
01480 }
01481 }
01482 } else if (CheckSavegameVersion(94)) {
01483
01484 Order *order;
01485 FOR_ALL_ORDERS(order) {
01486 if ((order->GetUnloadType() & (OUFB_UNLOAD | OUFB_TRANSFER)) == (OUFB_UNLOAD | OUFB_TRANSFER)) {
01487 order->SetUnloadType(OUFB_TRANSFER);
01488 order->SetLoadType(OLFB_NO_LOAD);
01489 }
01490 }
01491
01492 Vehicle *v;
01493 FOR_ALL_VEHICLES(v) {
01494 if ((v->current_order.GetUnloadType() & (OUFB_UNLOAD | OUFB_TRANSFER)) == (OUFB_UNLOAD | OUFB_TRANSFER)) {
01495 v->current_order.SetUnloadType(OUFB_TRANSFER);
01496 v->current_order.SetLoadType(OLFB_NO_LOAD);
01497 }
01498 }
01499 }
01500
01501 if (CheckSavegameVersion(84)) {
01502
01503 Order *order;
01504 FOR_ALL_ORDERS(order) {
01505 if (order->IsType(OT_GOTO_STATION) && GetStation(order->GetDestination())->IsBuoy()) {
01506 order->SetLoadType(OLF_LOAD_IF_POSSIBLE);
01507 order->SetUnloadType(OUF_UNLOAD_IF_POSSIBLE);
01508 }
01509 }
01510
01511
01512
01513
01514
01515
01516
01517 FOR_ALL_COMPANIES(c) {
01518 for (uint i = 0; i < 4; i++) {
01519 CompanyID company = c->share_owners[i];
01520 if (company == INVALID_COMPANY) continue;
01521 if (!IsValidCompanyID(company) || company == c->index) c->share_owners[i] = INVALID_COMPANY;
01522 }
01523 }
01524 }
01525
01526 if (CheckSavegameVersion(86)) {
01527 for (TileIndex t = 0; t < map_size; t++) {
01528
01529 if (IsTileType(t, MP_WATER)) {
01530 if (GetWaterClass(t) != WATER_CLASS_RIVER) {
01531 if (IsWater(t)) {
01532 Owner o = GetTileOwner(t);
01533 if (o == OWNER_WATER) {
01534 MakeWater(t);
01535 } else {
01536 MakeCanal(t, o, Random());
01537 }
01538 } else if (IsShipDepot(t)) {
01539 Owner o = (Owner)_m[t].m4;
01540 SetWaterClass(t, o == OWNER_WATER ? WATER_CLASS_SEA : WATER_CLASS_CANAL);
01541 }
01542 }
01543 }
01544 }
01545
01546
01547
01548
01549 for (TileIndex t = 0; t < map_size; t++) {
01550 if (GetTileSlope(t, NULL) != SLOPE_FLAT) continue;
01551
01552 if (IsTileType(t, MP_WATER) && IsLock(t)) SetWaterClassDependingOnSurroundings(t, false);
01553 if (IsTileType(t, MP_STATION) && (IsDock(t) || IsBuoy(t))) SetWaterClassDependingOnSurroundings(t, false);
01554 }
01555 }
01556
01557 if (CheckSavegameVersion(87)) {
01558 for (TileIndex t = 0; t < map_size; t++) {
01559
01560 if ((IsTileType(t, MP_WATER) || IsBuoyTile(t)) &&
01561 (TileX(t) == 0 || TileY(t) == 0 || TileX(t) == MapMaxX() - 1 || TileY(t) == MapMaxY() - 1)) {
01562
01563
01564 SetWaterClass(t, WATER_CLASS_SEA);
01565 }
01566
01567 if (IsBuoyTile(t) || IsDriveThroughStopTile(t) || IsTileType(t, MP_WATER)) {
01568 Owner o = GetTileOwner(t);
01569 if (o < MAX_COMPANIES && !IsValidCompanyID(o)) {
01570 _current_company = o;
01571 ChangeTileOwner(t, o, INVALID_OWNER);
01572 }
01573 if (IsBuoyTile(t)) {
01574
01575
01576 GetStationByTile(t)->owner = OWNER_NONE;
01577 }
01578 } else if (IsTileType(t, MP_ROAD)) {
01579
01580 for (RoadType rt = ROADTYPE_ROAD; rt < ROADTYPE_END; rt++) {
01581
01582 Owner o = GetRoadOwner(t, rt);
01583 if (o < MAX_COMPANIES && !IsValidCompanyID(o)) SetRoadOwner(t, rt, OWNER_NONE);
01584 }
01585 if (IsLevelCrossing(t)) {
01586 if (!IsValidCompanyID(GetTileOwner(t))) FixOwnerOfRailTrack(t);
01587 }
01588 } else if (IsTileType(t, MP_RAILWAY) && IsPlainRailTile(t)) {
01589 if (!IsValidCompanyID(GetTileOwner(t))) FixOwnerOfRailTrack(t);
01590 }
01591 }
01592
01593
01594 if (_settings_game.pf.yapf.rail_use_yapf || CheckSavegameVersion(28)) {
01595 _settings_game.pf.pathfinder_for_trains = VPF_YAPF;
01596 } else {
01597 _settings_game.pf.pathfinder_for_trains = (_settings_game.pf.new_pathfinding_all ? VPF_NPF : VPF_NTP);
01598 }
01599
01600 if (_settings_game.pf.yapf.road_use_yapf || CheckSavegameVersion(28)) {
01601 _settings_game.pf.pathfinder_for_roadvehs = VPF_YAPF;
01602 } else {
01603 _settings_game.pf.pathfinder_for_roadvehs = (_settings_game.pf.new_pathfinding_all ? VPF_NPF : VPF_OPF);
01604 }
01605
01606 if (_settings_game.pf.yapf.ship_use_yapf) {
01607 _settings_game.pf.pathfinder_for_ships = VPF_YAPF;
01608 } else {
01609 _settings_game.pf.pathfinder_for_ships = (_settings_game.pf.new_pathfinding_all ? VPF_NPF : VPF_OPF);
01610 }
01611 }
01612
01613 if (CheckSavegameVersion(88)) {
01614
01615 Vehicle *v;
01616 FOR_ALL_VEHICLES(v) {
01617 v->profit_this_year <<= 8;
01618 v->profit_last_year <<= 8;
01619 v->running_ticks = 0;
01620 }
01621 }
01622
01623 if (CheckSavegameVersion(91)) {
01624
01625 for (TileIndex t = 0; t < map_size; t++) {
01626 if (IsTileType(t, MP_HOUSE) && GetHouseType(t) >= NEW_HOUSE_OFFSET) {
01627 SetHouseAnimationFrame(t, GB(_m[t].m6, 3, 5));
01628 }
01629 }
01630 }
01631
01632 if (CheckSavegameVersion(62)) {
01633
01634
01635 Vehicle *v;
01636 FOR_ALL_VEHICLES(v) {
01637 if (v->type == VEH_ROAD && v->First() == v &&
01638 HasBit(EngInfo(v->engine_type)->misc_flags, EF_ROAD_TRAM)) {
01639 if (_switch_mode_errorstr == INVALID_STRING_ID || _switch_mode_errorstr == STR_NEWGRF_COMPATIBLE_LOAD_WARNING) {
01640 _switch_mode_errorstr = STR_LOADGAME_REMOVED_TRAMS;
01641 }
01642 delete v;
01643 }
01644 }
01645 }
01646
01647 if (CheckSavegameVersion(99)) {
01648 for (TileIndex t = 0; t < map_size; t++) {
01649
01650 if (IsTileType(t, MP_STATION) && IsOilRig(t)) {
01651 SetWaterClassDependingOnSurroundings(t, true);
01652 }
01653 if (IsTileType(t, MP_INDUSTRY)) {
01654 if ((GetIndustrySpec(GetIndustryType(t))->behaviour & INDUSTRYBEH_BUILT_ONWATER) != 0) {
01655 SetWaterClassDependingOnSurroundings(t, true);
01656 } else {
01657 SetWaterClass(t, WATER_CLASS_INVALID);
01658 }
01659 }
01660
01661
01662 if (IsTileType(t, MP_HOUSE) && IsHouseCompleted(t)) {
01663 _m[t].m5 = Clamp(_cur_year - (_m[t].m5 + ORIGINAL_BASE_YEAR), 0, 0xFF);
01664 }
01665 }
01666 }
01667
01668
01669
01670
01671 if (CheckSavegameVersion(100)) {
01672 for (TileIndex t = 0; t < map_size; t++) {
01673 switch (GetTileType(t)) {
01674 case MP_RAILWAY:
01675 if (HasSignals(t)) {
01676
01677 SetSignalVariant(t, TRACK_UPPER, HasBit(_m[t].m2, 2) ? SIG_SEMAPHORE : SIG_ELECTRIC);
01678 SetSignalVariant(t, TRACK_LOWER, HasBit(_m[t].m2, 6) ? SIG_SEMAPHORE : SIG_ELECTRIC);
01679 ClrBit(_m[t].m2, 2);
01680 ClrBit(_m[t].m2, 6);
01681 }
01682
01683
01684 if (IsRailDepot(t) ||IsRailWaypoint(t)) {
01685 SetDepotWaypointReservation(t, false);
01686 } else {
01687 SetTrackReservation(t, TRACK_BIT_NONE);
01688 }
01689 break;
01690
01691 case MP_ROAD:
01692 if (IsLevelCrossing(t)) SetCrossingReservation(t, false);
01693 break;
01694
01695 case MP_STATION:
01696 if (IsRailwayStation(t)) SetRailwayStationReservation(t, false);
01697 break;
01698
01699 case MP_TUNNELBRIDGE:
01700 if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) SetTunnelBridgeReservation(t, false);
01701 break;
01702
01703 default: break;
01704 }
01705 }
01706 }
01707
01708
01709 if (CheckSavegameVersion(101)) {
01710 Vehicle *v;
01711 FOR_ALL_VEHICLES(v) {
01712 if (v->type == VEH_TRAIN) {
01713 if ((v->u.rail.track & TRACK_BIT_WORMHOLE) == TRACK_BIT_WORMHOLE) {
01714 TryReserveRailTrack(v->tile, DiagDirToDiagTrack(GetTunnelBridgeDirection(v->tile)));
01715 } else if ((v->u.rail.track & TRACK_BIT_MASK) != TRACK_BIT_NONE) {
01716 TryReserveRailTrack(v->tile, TrackBitsToTrack(v->u.rail.track));
01717 }
01718 }
01719 }
01720 }
01721
01722 if (CheckSavegameVersion(102)) {
01723 for (TileIndex t = 0; t < map_size; t++) {
01724
01725 if (IsLevelCrossingTile(t)) UpdateLevelCrossing(t, false);
01726 }
01727 }
01728
01729 if (CheckSavegameVersion(103)) {
01730
01731 UpdateNearestTownForRoadTiles(false);
01732
01733
01734 Sign *si;
01735 FOR_ALL_SIGNS(si) {
01736 if (si->owner != OWNER_NONE && !IsValidCompanyID(si->owner)) si->owner = OWNER_NONE;
01737 }
01738
01739
01740
01741 Station *st;
01742 FOR_ALL_STATIONS(st) {
01743 st->indtype = IT_INVALID;
01744 }
01745 }
01746
01747 if (CheckSavegameVersion(104)) {
01748 Vehicle *v;
01749 FOR_ALL_VEHICLES(v) {
01750
01751 if (v->type == VEH_AIRCRAFT && !IsNormalAircraft(v)) {
01752 v->engine_type = v->First()->engine_type;
01753 }
01754 }
01755
01756
01757 Company *c;
01758 FOR_ALL_COMPANIES(c) {
01759 if (c->bankrupt_asked == 0xFF) c->bankrupt_asked = 0xFFFF;
01760 }
01761
01762 Engine *e;
01763 FOR_ALL_ENGINES(e) {
01764 if (e->company_avail == 0xFF) e->company_avail = 0xFFFF;
01765 }
01766
01767 Town *t;
01768 FOR_ALL_TOWNS(t) {
01769 if (t->have_ratings == 0xFF) t->have_ratings = 0xFFFF;
01770 for (uint i = 8; i != MAX_COMPANIES; i++) t->ratings[i] = RATING_INITIAL;
01771 }
01772 }
01773
01774 if (CheckSavegameVersion(112)) {
01775 for (TileIndex t = 0; t < map_size; t++) {
01776
01777
01778 if (IsTileType(t, MP_UNMOVABLE) && HasBit(_m[t].m5, 7)) {
01779
01780
01781 uint8 old_m5 = _m[t].m5;
01782 _m[t].m5 = UNMOVABLE_HQ;
01783 SetCompanyHQSize(t, GB(old_m5, 2, 3));
01784 SetCompanyHQSection(t, GB(old_m5, 0, 2));
01785 }
01786 }
01787 }
01788
01789 if (CheckSavegameVersion(113)) {
01790
01791 if (_settings_game.economy.town_layout == 0) {
01792 _settings_game.economy.allow_town_roads = false;
01793 _settings_game.economy.town_layout = TL_BETTER_ROADS;
01794 } else {
01795 _settings_game.economy.allow_town_roads = true;
01796 _settings_game.economy.town_layout = _settings_game.economy.town_layout - 1;
01797 }
01798
01799
01800
01801 Town *t;
01802 FOR_ALL_TOWNS(t) {
01803 if (_settings_game.economy.town_layout != TL_RANDOM) {
01804 t->layout = _settings_game.economy.town_layout;
01805 continue;
01806 }
01807
01808
01809 byte layout = TileHash(TileX(t->xy), TileY(t->xy)) % 6;
01810 switch (layout) {
01811 default: break;
01812 case 5: layout = 1; break;
01813 case 0: layout = 2; break;
01814 }
01815 t->layout = layout - 1;
01816 }
01817 }
01818
01819 if (CheckSavegameVersion(114)) {
01820
01821
01822
01823 Station *st;
01824 FOR_ALL_STATIONS(st) {
01825 if (!IsValidCompanyID(st->owner)) st->owner = OWNER_NONE;
01826 }
01827
01828
01829
01830
01831
01832 Waypoint *wp;
01833 FOR_ALL_WAYPOINTS(wp) {
01834 Owner owner = IsTileType(wp->xy, MP_RAILWAY) ? GetTileOwner(wp->xy) : OWNER_NONE;
01835 wp->owner = IsValidCompanyID(owner) ? owner : OWNER_NONE;
01836 }
01837 }
01838
01839 if (CheckSavegameVersion(121)) {
01840
01841 Vehicle *v;
01842 FOR_ALL_VEHICLES(v) {
01843 if (v->type == VEH_DISASTER && v->subtype == 2 && v->current_order.GetDestination() != 0) {
01844 const Vehicle *u = IsValidVehicleID(v->dest_tile) ? GetVehicle(v->dest_tile) : NULL;
01845 if (u == NULL || u->type != VEH_ROAD || !IsRoadVehFront(u)) {
01846 delete v;
01847 }
01848 }
01849 }
01850 }
01851
01852 if (!_cargo_payment_savegame) {
01853
01854
01855
01856
01857 Station *st;
01858 FOR_ALL_STATIONS(st) {
01859 std::list<Vehicle *>::iterator iter;
01860 for (iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end(); ++iter) {
01861 Vehicle *v = *iter;
01862 assert(v->cargo_payment == NULL);
01863 v->cargo_payment = new CargoPayment(v);
01864 }
01865 }
01866 }
01867
01868 if (CheckSavegameVersion(122)) {
01869
01870
01871
01872 extern TileIndex *_animated_tile_list;
01873 extern uint _animated_tile_count;
01874
01875 for (uint i = 0; i < _animated_tile_count; ) {
01876
01877 bool remove = _tile_type_procs[GetTileType(_animated_tile_list[i])]->animate_tile_proc == NULL;
01878
01879
01880 for (uint j = 0; !remove && j < i; j++) {
01881 remove = _animated_tile_list[i] == _animated_tile_list[j];
01882 }
01883
01884 if (remove) {
01885 DeleteAnimatedTile(_animated_tile_list[i]);
01886 } else {
01887 i++;
01888 }
01889 }
01890
01891
01892 for (Subsidy *s = _subsidies; s < endof(_subsidies); s++) {
01893 if (s->cargo_type == CT_INVALID) continue;
01894 if (s->age >= 12) {
01895
01896 const Station *from = IsValidStationID(s->from) ? GetStation(s->from) : NULL;
01897 const Station *to = IsValidStationID(s->to) ? GetStation(s->to) : NULL;
01898 if (from != NULL && to != NULL && from->owner == to->owner && IsValidCompanyID(from->owner)) continue;
01899 } else {
01900 const CargoSpec *cs = GetCargo(s->cargo_type);
01901 switch (cs->town_effect) {
01902 case TE_PASSENGERS:
01903 case TE_MAIL:
01904
01905 if (IsValidTownID(s->from) && IsValidTownID(s->to)) continue;
01906 break;
01907 case TE_GOODS:
01908 case TE_FOOD:
01909
01910 if (IsValidIndustryID(s->from) && IsValidTownID(s->to)) continue;
01911 break;
01912 default:
01913
01914 if (IsValidIndustryID(s->from) && IsValidIndustryID(s->to)) continue;
01915 break;
01916 }
01917 }
01918 s->cargo_type = CT_INVALID;
01919 }
01920 }
01921
01922 GamelogPrintDebug(1);
01923
01924 bool ret = InitializeWindowsAndCaches();
01925
01926 ResetSignalHandlers();
01927 return ret;
01928 }
01929
01936 void ReloadNewGRFData()
01937 {
01938
01939 GfxLoadSprites();
01940 LoadStringWidthTable();
01941 ResetEconomy();
01942
01943 ResetVehiclePosHash();
01944 AfterLoadVehicles(false);
01945 StartupEngines();
01946 SetCachedEngineCounts();
01947
01948
01949 AfterLoadWaypoints();
01950 AfterLoadStations();
01951
01952 UpdateHousesAndTowns();
01953
01954 for (CompanyID i = COMPANY_FIRST; i < MAX_COMPANIES; i++) InvalidateWindowData(WC_COMPANY_COLOUR, i);
01955
01956 MarkWholeScreenDirty();
01957 CheckTrainsLengths();
01958 }