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