OpenTTD Source: src/saveload/afterload.cpp Source File

OpenTTD Source 15.3

afterload.cpp
Go to the documentation of this file.
1/*
2 * This file is part of OpenTTD.
3 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
6 */
7
10#include "../stdafx.h"
11#include "../void_map.h"
12#include "../signs_base.h"
13#include "../depot_base.h"
14#include "../fios.h"
15#include "../gamelog_internal.h"
16#include "../network/network.h"
17#include "../network/network_func.h"
18#include "../gfxinit.h"
19#include "../viewport_func.h"
20#include "../viewport_kdtree.h"
21#include "../industry.h"
22#include "../clear_map.h"
23#include "../vehicle_func.h"
24#include "../string_func.h"
25#include "../strings_func.h"
26#include "../window_func.h"
27#include "../roadveh.h"
28#include "../roadveh_cmd.h"
29#include "../train.h"
30#include "../station_base.h"
31#include "../waypoint_base.h"
32#include "../roadstop_base.h"
33#include "../tunnelbridge_map.h"
34#include "../pathfinder/yapf/yapf_cache.h"
35#include "../elrail_func.h"
36#include "../signs_func.h"
37#include "../aircraft.h"
38#include "../object_map.h"
39#include "../object_base.h"
40#include "../tree_map.h"
41#include "../company_func.h"
42#include "../road_cmd.h"
43#include "../ai/ai.hpp"
44#include "../script/script_gui.h"
45#include "../game/game.hpp"
46#include "../town.h"
47#include "../economy_base.h"
48#include "../animated_tile_map.h"
49#include "../animated_tile_func.h"
50#include "../subsidy_base.h"
51#include "../subsidy_func.h"
52#include "../newgrf.h"
53#include "../newgrf_station.h"
54#include "../engine_func.h"
55#include "../rail_gui.h"
56#include "../core/backup_type.hpp"
57#include "../smallmap_gui.h"
58#include "../news_func.h"
59#include "../order_backup.h"
60#include "../error.h"
61#include "../disaster_vehicle.h"
62#include "../ship.h"
63#include "../water.h"
64#include "../timer/timer.h"
65#include "../timer/timer_game_calendar.h"
66#include "../timer/timer_game_economy.h"
67#include "../timer/timer_game_tick.h"
68#include "../picker_func.h"
69
70#include "saveload_internal.h"
71
72#include <signal.h>
73
74#include "table/strings.h"
75
76#include "../safeguards.h"
77
78extern Company *DoStartupNewCompany(bool is_ai, CompanyID company = CompanyID::Invalid());
79extern void ClearOldOrders();
80
91 void SetWaterClassDependingOnSurroundings(Tile t, bool include_invalid_water_class)
92{
93 /* If the slope is not flat, we always assume 'land' (if allowed). Also for one-corner-raised-shores.
94 * Note: Wrt. autosloping under industry tiles this is the most fool-proof behaviour. */
95 if (!IsTileFlat(t)) {
96 if (include_invalid_water_class) {
97 SetWaterClass(t, WaterClass::Invalid);
98 return;
99 } else {
100 SlErrorCorrupt("Invalid water class for dry tile");
101 }
102 }
103
104 /* Mark tile dirty in all cases */
105 MarkTileDirtyByTile(t);
106
107 if (TileX(t) == 0 || TileY(t) == 0 || TileX(t) == Map::MaxX() - 1 || TileY(t) == Map::MaxY() - 1) {
108 /* tiles at map borders are always WaterClass::Sea */
109 SetWaterClass(t, WaterClass::Sea);
110 return;
111 }
112
113 bool has_water = false;
114 bool has_canal = false;
115 bool has_river = false;
116
117 for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
118 Tile neighbour = TileAddByDiagDir(t, dir);
119 switch (GetTileType(neighbour)) {
120 case MP_WATER:
121 /* clear water and shipdepots have already a WaterClass associated */
122 if (IsCoast(neighbour)) {
123 has_water = true;
124 } else if (!IsLock(neighbour)) {
125 switch (GetWaterClass(neighbour)) {
126 case WaterClass::Sea: has_water = true; break;
127 case WaterClass::Canal: has_canal = true; break;
128 case WaterClass::River: has_river = true; break;
129 default: SlErrorCorrupt("Invalid water class for tile");
130 }
131 }
132 break;
133
134 case MP_RAILWAY:
135 /* Shore or flooded halftile */
136 has_water |= (GetRailGroundType(neighbour) == RailGroundType::HalfTileWater);
137 break;
138
139 case MP_TREES:
140 /* trees on shore */
141 has_water |= (GB(neighbour.m2(), 4, 2) == TREE_GROUND_SHORE);
142 break;
143
144 default: break;
145 }
146 }
147
148 if (!has_water && !has_canal && !has_river && include_invalid_water_class) {
149 SetWaterClass(t, WaterClass::Invalid);
150 return;
151 }
152
153 if (has_river && !has_canal) {
154 SetWaterClass(t, WaterClass::River);
155 } else if (has_canal || !has_water) {
156 SetWaterClass(t, WaterClass::Canal);
157 } else {
158 SetWaterClass(t, WaterClass::Sea);
159 }
160}
161
162static void ConvertTownOwner()
163{
164 for (auto tile : Map::Iterate()) {
165 switch (GetTileType(tile)) {
166 case MP_ROAD:
167 if (GB(tile.m5(), 4, 2) == to_underlying(RoadTileType::Crossing) && HasBit(tile.m3(), 7)) {
168 tile.m3() = OWNER_TOWN.base();
169 }
170 [[fallthrough]];
171
172 case MP_TUNNELBRIDGE:
173 if (tile.m1() & 0x80) SetTileOwner(tile, OWNER_TOWN);
174 break;
175
176 default: break;
177 }
178 }
179}
180
181/* since savegame version 4.1, exclusive transport rights are stored at towns */
182static void UpdateExclusiveRights()
183{
184 for (Town *t : Town::Iterate()) {
185 t->exclusivity = CompanyID::Invalid();
186 }
187}
188
189static const uint8_t convert_currency[] = {
190 0, 1, 12, 8, 3,
191 10, 14, 19, 4, 5,
192 9, 11, 13, 6, 17,
193 16, 22, 21, 7, 15,
194 18, 2, 20,
195};
196
197/* since savegame version 4.2 the currencies are arranged differently */
198static void UpdateCurrencies()
199{
200 _settings_game.locale.currency = convert_currency[_settings_game.locale.currency];
201}
202
203/* Up to revision 1413 the invisible tiles at the southern border have not been
204 * MP_VOID, even though they should have. This is fixed by this function
205 */
206static void UpdateVoidTiles()
207{
208 for (uint x = 0; x < Map::SizeX(); x++) MakeVoid(TileXY(x, Map::MaxY()));
209 for (uint y = 0; y < Map::SizeY(); y++) MakeVoid(TileXY(Map::MaxX(), y));
210}
211
212static inline RailType UpdateRailType(RailType rt, RailType min)
213{
214 return rt >= min ? (RailType)(rt + 1): rt;
215}
216
220 void UpdateAllVirtCoords()
221{
222 UpdateAllStationVirtCoords();
223 UpdateAllSignVirtCoords();
224 UpdateAllTownVirtCoords();
225 UpdateAllTextEffectVirtCoords();
226 RebuildViewportKdtree();
227}
228
229void ClearAllCachedNames()
230{
231 ClearAllStationCachedNames();
232 ClearAllTownCachedNames();
233 ClearAllIndustryCachedNames();
234}
235
245 static void InitializeWindowsAndCaches()
246{
247 /* Initialize windows */
248 ResetWindowSystem();
249 SetupColoursAndInitialWindow();
250
251 /* Update coordinates of the signs. */
252 ClearAllCachedNames();
253 UpdateAllVirtCoords();
254 ResetViewportAfterLoadGame();
255
256 for (Company *c : Company::Iterate()) {
257 /* For each company, verify (while loading a scenario) that the inauguration date is the current year and set it
258 * accordingly if it is not the case. No need to set it on companies that are not been used already,
259 * thus the MIN_YEAR (which is really nothing more than Zero, initialized value) test */
260 if (_file_to_saveload.ftype.abstract == FT_SCENARIO && c->inaugurated_year != EconomyTime::MIN_YEAR) {
261 c->inaugurated_year = TimerGameEconomy::year;
262 }
263 }
264
265 /* Count number of objects per type */
266 for (Object *o : Object::Iterate()) {
267 Object::IncTypeCount(o->type);
268 }
269
270 /* Identify owners of persistent storage arrays */
271 for (Industry *i : Industry::Iterate()) {
272 if (i->psa != nullptr) {
273 i->psa->feature = GSF_INDUSTRIES;
274 i->psa->tile = i->location.tile;
275 }
276 }
277 for (Station *s : Station::Iterate()) {
278 if (s->airport.psa != nullptr) {
279 s->airport.psa->feature = GSF_AIRPORTS;
280 s->airport.psa->tile = s->airport.tile;
281 }
282 }
283 for (Town *t : Town::Iterate()) {
284 for (auto &it : t->psa_list) {
285 it->feature = GSF_FAKE_TOWNS;
286 it->tile = t->xy;
287 }
288 }
289 for (RoadVehicle *rv : RoadVehicle::Iterate()) {
290 if (rv->IsFrontEngine()) {
291 rv->CargoChanged();
292 }
293 }
294
295 RecomputePrices();
296
297 GroupStatistics::UpdateAfterLoad();
298
299 RebuildSubsidisedSourceAndDestinationCache();
300
301 /* Towns have a noise controlled number of airports system
302 * So each airport's noise value must be added to the town->noise_reached value
303 * Reset each town's noise_reached value to '0' before. */
304 UpdateAirportsNoise();
305
306 CheckTrainsLengths();
307 ShowNewGRFError();
308
309 /* Rebuild the smallmap list of owners. */
310 BuildOwnerLegend();
311}
312
313typedef void (CDECL *SignalHandlerPointer)(int);
314static SignalHandlerPointer _prev_segfault = nullptr;
315static SignalHandlerPointer _prev_abort = nullptr;
316static SignalHandlerPointer _prev_fpe = nullptr;
317
318static void CDECL HandleSavegameLoadCrash(int signum);
319
324 static void SetSignalHandlers()
325{
326 _prev_segfault = signal(SIGSEGV, HandleSavegameLoadCrash);
327 _prev_abort = signal(SIGABRT, HandleSavegameLoadCrash);
328 _prev_fpe = signal(SIGFPE, HandleSavegameLoadCrash);
329}
330
334 static void ResetSignalHandlers()
335{
336 signal(SIGSEGV, _prev_segfault);
337 signal(SIGABRT, _prev_abort);
338 signal(SIGFPE, _prev_fpe);
339}
340
342 static bool _saveload_crash_with_missing_newgrfs = false;
343
349 bool SaveloadCrashWithMissingNewGRFs()
350{
351 return _saveload_crash_with_missing_newgrfs;
352}
353
360 static void CDECL HandleSavegameLoadCrash(int signum)
361{
362 ResetSignalHandlers();
363
364 std::string message;
365 message.reserve(1024);
366 message += "Loading your savegame caused OpenTTD to crash.\n";
367
368 _saveload_crash_with_missing_newgrfs = std::ranges::any_of(_grfconfig, [](const auto &c) { return c->flags.Test(GRFConfigFlag::Compatible) || c->status == GCS_NOT_FOUND; });
369
370 if (_saveload_crash_with_missing_newgrfs) {
371 message +=
372 "This is most likely caused by a missing NewGRF or a NewGRF that\n"
373 "has been loaded as replacement for a missing NewGRF. OpenTTD\n"
374 "cannot easily determine whether a replacement NewGRF is of a newer\n"
375 "or older version.\n"
376 "It will load a NewGRF with the same GRF ID as the missing NewGRF.\n"
377 "This means that if the author makes incompatible NewGRFs with the\n"
378 "same GRF ID, OpenTTD cannot magically do the right thing. In most\n"
379 "cases, OpenTTD will load the savegame and not crash, but this is an\n"
380 "exception.\n"
381 "Please load the savegame with the appropriate NewGRFs installed.\n"
382 "The missing/compatible NewGRFs are:\n";
383
384 for (const auto &c : _grfconfig) {
385 if (c->flags.Test(GRFConfigFlag::Compatible)) {
386 const GRFIdentifier &replaced = _gamelog.GetOverriddenIdentifier(*c);
387 format_append(message, "NewGRF {:08X} (checksum {}) not found.\n Loaded NewGRF \"{}\" (checksum {}) with same GRF ID instead.\n",
388 std::byteswap(c->ident.grfid), FormatArrayAsHex(c->original_md5sum), c->filename, FormatArrayAsHex(replaced.md5sum));
389 }
390 if (c->status == GCS_NOT_FOUND) {
391 format_append(message, "NewGRF {:08X} ({}) not found; checksum {}.\n",
392 std::byteswap(c->ident.grfid), c->filename, FormatArrayAsHex(c->ident.md5sum));
393 }
394 }
395 } else {
396 message +=
397 "This is probably caused by a corruption in the savegame.\n"
398 "Please file a bug report and attach this savegame.\n";
399 }
400
401 ShowInfoI(message);
402
403 SignalHandlerPointer call = nullptr;
404 switch (signum) {
405 case SIGSEGV: call = _prev_segfault; break;
406 case SIGABRT: call = _prev_abort; break;
407 case SIGFPE: call = _prev_fpe; break;
408 default: NOT_REACHED();
409 }
410 if (call != nullptr) call(signum);
411}
412
418 static void FixOwnerOfRailTrack(Tile t)
419{
420 assert(!Company::IsValidID(GetTileOwner(t)) && (IsLevelCrossingTile(t) || IsPlainRailTile(t)));
421
422 /* remove leftover rail piece from crossing (from very old savegames) */
423 Train *v = nullptr;
424 for (Train *w : Train::Iterate()) {
425 if (w->tile == TileIndex(t)) {
426 v = w;
427 break;
428 }
429 }
430
431 if (v != nullptr) {
432 /* when there is a train on crossing (it could happen in TTD), set owner of crossing to train owner */
433 SetTileOwner(t, v->owner);
434 return;
435 }
436
437 /* try to find any connected rail */
438 for (DiagDirection dd = DIAGDIR_BEGIN; dd < DIAGDIR_END; dd++) {
439 TileIndex tt{t + TileOffsByDiagDir(dd)};
440 if (GetTileTrackStatus(t, TRANSPORT_RAIL, 0, dd) != 0 &&
441 GetTileTrackStatus(tt, TRANSPORT_RAIL, 0, ReverseDiagDir(dd)) != 0 &&
442 Company::IsValidID(GetTileOwner(tt))) {
443 SetTileOwner(t, GetTileOwner(tt));
444 return;
445 }
446 }
447
448 if (IsLevelCrossingTile(t)) {
449 /* else change the crossing to normal road (road vehicles won't care) */
450 Owner road = GetRoadOwner(t, RTT_ROAD);
451 Owner tram = GetRoadOwner(t, RTT_TRAM);
452 RoadBits bits = GetCrossingRoadBits(t);
453 bool hasroad = HasBit(t.m7(), 6);
454 bool hastram = HasBit(t.m7(), 7);
455
456 /* MakeRoadNormal */
457 SetTileType(t, MP_ROAD);
458 SetTileOwner(t, road);
459 t.m3() = (hasroad ? bits : 0);
460 t.m5() = (hastram ? bits : 0) | to_underlying(RoadTileType::Normal) << 6;
461 SB(t.m6(), 2, 4, 0);
462 SetRoadOwner(t, RTT_TRAM, tram);
463 return;
464 }
465
466 /* if it's not a crossing, make it clean land */
467 MakeClear(t, CLEAR_GRASS, 0);
468}
469
476 static uint FixVehicleInclination(Vehicle *v, Direction dir)
477{
478 /* Compute place where this vehicle entered the tile */
479 int entry_x = v->x_pos;
480 int entry_y = v->y_pos;
481 switch (dir) {
482 case DIR_NE: entry_x |= TILE_UNIT_MASK; break;
483 case DIR_NW: entry_y |= TILE_UNIT_MASK; break;
484 case DIR_SW: entry_x &= ~TILE_UNIT_MASK; break;
485 case DIR_SE: entry_y &= ~TILE_UNIT_MASK; break;
486 case INVALID_DIR: break;
487 default: NOT_REACHED();
488 }
489 uint8_t entry_z = GetSlopePixelZ(entry_x, entry_y, true);
490
491 /* Compute middle of the tile. */
492 int middle_x = (v->x_pos & ~TILE_UNIT_MASK) + TILE_SIZE / 2;
493 int middle_y = (v->y_pos & ~TILE_UNIT_MASK) + TILE_SIZE / 2;
494 uint8_t middle_z = GetSlopePixelZ(middle_x, middle_y, true);
495
496 /* middle_z == entry_z, no height change. */
497 if (middle_z == entry_z) return 0;
498
499 /* middle_z < entry_z, we are going downwards. */
500 if (middle_z < entry_z) return 1U << GVF_GOINGDOWN_BIT;
501
502 /* middle_z > entry_z, we are going upwards. */
503 return 1U << GVF_GOINGUP_BIT;
504}
505
511 static void CheckGroundVehiclesAtCorrectZ()
512{
513 for (Vehicle *v : Vehicle::Iterate()) {
514 if (v->IsGroundVehicle()) {
515 /*
516 * Either the vehicle is not actually on the given tile, i.e. it is
517 * in the wormhole of a bridge or a tunnel, or the Z-coordinate must
518 * be the same as when it would be recalculated right now.
519 */
520 assert(v->tile != TileVirtXY(v->x_pos, v->y_pos) || v->z_pos == GetSlopePixelZ(v->x_pos, v->y_pos, true));
521 }
522 }
523}
524
531 static inline bool MayHaveBridgeAbove(Tile t)
532{
533 return IsTileType(t, MP_CLEAR) || IsTileType(t, MP_RAILWAY) || IsTileType(t, MP_ROAD) ||
534 IsTileType(t, MP_WATER) || IsTileType(t, MP_TUNNELBRIDGE) || IsTileType(t, MP_OBJECT);
535}
536
540 static void StartScripts()
541{
542 /* Script debug window requires AIs to be started before trying to start GameScript. */
543
544 /* Start the AIs. */
545 for (const Company *c : Company::Iterate()) {
546 if (Company::IsValidAiID(c->index)) AI::StartNew(c->index);
547 }
548
549 /* Start the GameScript. */
550 Game::StartNew();
551
552 ShowScriptDebugWindowIfScriptError();
553}
554
560 bool AfterLoadGame()
561{
562 SetSignalHandlers();
563
564 extern TileIndex _cur_tileloop_tile; // From landscape.cpp.
565 /* The LFSR used in RunTileLoop iteration cannot have a zeroed state, make it non-zeroed. */
566 if (_cur_tileloop_tile == 0) _cur_tileloop_tile = TileIndex{1};
567
568 if (IsSavegameVersionBefore(SLV_98)) _gamelog.Oldver();
569
570 _gamelog.TestRevision();
571 _gamelog.TestMode();
572
573 RebuildTownKdtree();
574 RebuildStationKdtree();
575 /* This needs to be done even before conversion, because some conversions will destroy objects
576 * that otherwise won't exist in the tree. */
577 RebuildViewportKdtree();
578
579 /* Group hierarchy may be evaluated during conversion, so ensure its correct early on. */
580 UpdateGroupChildren();
581
582 if (IsSavegameVersionBefore(SLV_98)) _gamelog.GRFAddList(_grfconfig);
583
584 if (IsSavegameVersionBefore(SLV_119)) {
585 _pause_mode = (_pause_mode.base() == 2) ? PauseMode::Normal : PauseModes{};
586 } else if (_network_dedicated && _pause_mode.Test(PauseMode::Error)) {
587 Debug(net, 0, "The loading savegame was paused due to an error state");
588 Debug(net, 0, " This savegame cannot be used for multiplayer");
589 /* Restore the signals */
590 ResetSignalHandlers();
591 return false;
592 } else if (!_networking || _network_server) {
593 /* If we are in singleplayer mode, i.e. not networking, and loading the
594 * savegame or we are loading the savegame as network server we do
595 * not want to be bothered by being paused because of the automatic
596 * reason of a network server, e.g. joining clients or too few
597 * active clients. Note that resetting these values for a network
598 * client are very bad because then the client is going to execute
599 * the game loop when the server is not, i.e. it desyncs. */
600 _pause_mode.Reset({PauseMode::ActiveClients, PauseMode::Join});
601 }
602
603 /* In very old versions, size of train stations was stored differently.
604 * They had swapped width and height if station was built along the Y axis.
605 * TTO and TTD used 3 bits for width/height, while OpenTTD used 4.
606 * Because the data stored by TTDPatch are unusable for rail stations > 7x7,
607 * recompute the width and height. Doing this unconditionally for all old
608 * savegames simplifies the code. */
609 if (IsSavegameVersionBefore(SLV_2)) {
610 for (Station *st : Station::Iterate()) {
611 st->train_station.w = st->train_station.h = 0;
612 }
613 for (auto t : Map::Iterate()) {
614 if (!IsTileType(t, MP_STATION)) continue;
615 if (t.m5() > 7) continue; // is it a rail station tile?
616 Station *st = Station::Get(t.m2());
617 assert(st->train_station.tile != 0);
618 int dx = TileX(t) - TileX(st->train_station.tile);
619 int dy = TileY(t) - TileY(st->train_station.tile);
620 assert(dx >= 0 && dy >= 0);
621 st->train_station.w = std::max<uint>(st->train_station.w, dx + 1);
622 st->train_station.h = std::max<uint>(st->train_station.h, dy + 1);
623 }
624 }
625
626 if (IsSavegameVersionBefore(SLV_194)) {
627 _settings_game.construction.map_height_limit = 15;
628
629 /* In old savegame versions, the heightlevel was coded in bits 0..3 of the type field */
630 for (auto t : Map::Iterate()) {
631 t.height() = GB(t.type(), 0, 4);
632 SB(t.type(), 0, 2, GB(t.m6(), 0, 2));
633 SB(t.m6(), 0, 2, 0);
634 if (MayHaveBridgeAbove(t)) {
635 SB(t.type(), 2, 2, GB(t.m6(), 6, 2));
636 SB(t.m6(), 6, 2, 0);
637 } else {
638 SB(t.type(), 2, 2, 0);
639 }
640 }
641 }
642
643 /* in version 2.1 of the savegame, town owner was unified. */
644 if (IsSavegameVersionBefore(SLV_2, 1)) ConvertTownOwner();
645
646 /* from version 4.1 of the savegame, exclusive rights are stored at towns */
647 if (IsSavegameVersionBefore(SLV_4, 1)) UpdateExclusiveRights();
648
649 /* from version 4.2 of the savegame, currencies are in a different order */
650 if (IsSavegameVersionBefore(SLV_4, 2)) UpdateCurrencies();
651
652 /* In old version there seems to be a problem that water is owned by
653 * OWNER_NONE, not OWNER_WATER.. I can't replicate it for the current
654 * (4.3) version, so I just check when versions are older, and then
655 * walk through the whole map.. */
656 if (IsSavegameVersionBefore(SLV_4, 3)) {
657 for (const auto t : Map::Iterate()) {
658 if (IsTileType(t, MP_WATER) && GetTileOwner(t) >= MAX_COMPANIES) {
659 SetTileOwner(t, OWNER_WATER);
660 }
661 }
662 }
663
664 if (IsSavegameVersionBefore(SLV_84)) {
665 for (Company *c : Company::Iterate()) {
666 c->name = CopyFromOldName(c->name_1);
667 if (!c->name.empty()) c->name_1 = STR_SV_UNNAMED;
668 c->president_name = CopyFromOldName(c->president_name_1);
669 if (!c->president_name.empty()) c->president_name_1 = SPECSTR_PRESIDENT_NAME;
670 }
671
672 for (Station *st : Station::Iterate()) {
673 st->name = CopyFromOldName(st->string_id);
674 /* generating new name would be too much work for little effect, use the station name fallback */
675 if (!st->name.empty()) st->string_id = STR_SV_STNAME_FALLBACK;
676 }
677
678 for (Town *t : Town::Iterate()) {
679 t->name = CopyFromOldName(t->townnametype);
680 if (!t->name.empty()) t->townnametype = SPECSTR_TOWNNAME_START + _settings_game.game_creation.town_name;
681 }
682 }
683
684 /* From this point the old names array is cleared. */
685 ResetOldNames();
686
687 if (IsSavegameVersionBefore(SLV_106)) {
688 /* no station is determined by 'tile == INVALID_TILE' now (instead of '0') */
689 for (Station *st : Station::Iterate()) {
690 if (st->airport.tile == 0) st->airport.tile = INVALID_TILE;
691 if (st->train_station.tile == 0) st->train_station.tile = INVALID_TILE;
692 }
693
694 /* the same applies to Company::location_of_HQ */
695 for (Company *c : Company::Iterate()) {
696 if (c->location_of_HQ == 0 || (IsSavegameVersionBefore(SLV_4) && c->location_of_HQ == 0xFFFF)) {
697 c->location_of_HQ = INVALID_TILE;
698 }
699 }
700 }
701
702 /* convert road side to my format. */
703 if (_settings_game.vehicle.road_side) _settings_game.vehicle.road_side = 1;
704
705 /* Check if all NewGRFs are present, we are very strict in MP mode */
706 GRFListCompatibility gcf_res = IsGoodGRFConfigList(_grfconfig);
707 for (const auto &c : _grfconfig) {
708 if (c->status == GCS_NOT_FOUND) {
709 _gamelog.GRFRemove(c->ident.grfid);
710 } else if (c->flags.Test(GRFConfigFlag::Compatible)) {
711 _gamelog.GRFCompatible(c->ident);
712 }
713 }
714
715 if (_networking && gcf_res != GLC_ALL_GOOD) {
716 SetSaveLoadError(STR_NETWORK_ERROR_CLIENT_NEWGRF_MISMATCH);
717 /* Restore the signals */
718 ResetSignalHandlers();
719 return false;
720 }
721
722 switch (gcf_res) {
723 case GLC_COMPATIBLE: ShowErrorMessage(GetEncodedString(STR_NEWGRF_COMPATIBLE_LOAD_WARNING), {}, WL_CRITICAL); break;
724 case GLC_NOT_FOUND: ShowErrorMessage(GetEncodedString(STR_NEWGRF_DISABLED_WARNING), {}, WL_CRITICAL); _pause_mode = PauseMode::Error; break;
725 default: break;
726 }
727
728 /* The value of TimerGameCalendar::date_fract got divided, so make sure that old games are converted correctly. */
729 if (IsSavegameVersionBefore(SLV_11, 1) || (IsSavegameVersionBefore(SLV_147) && TimerGameCalendar::date_fract > Ticks::DAY_TICKS)) TimerGameCalendar::date_fract /= 885;
730
731 /* Update current year
732 * must be done before loading sprites as some newgrfs check it */
733 TimerGameCalendar::SetDate(TimerGameCalendar::date, TimerGameCalendar::date_fract);
734
735 /* Only new games can use wallclock units. */
736 if (IsSavegameVersionBefore(SLV_ECONOMY_MODE_TIMEKEEPING_UNITS)) _settings_game.economy.timekeeping_units = TKU_CALENDAR;
737
738 /* Set the correct default for 'minutes per year' if the savegame was created before the setting existed. */
739 if (IsSavegameVersionBefore(SLV_CALENDAR_SUB_DATE_FRACT)) _settings_game.economy.minutes_per_calendar_year = CalendarTime::DEF_MINUTES_PER_YEAR;
740
741 /* Update economy year. If we don't have a separate economy date saved, follow the calendar date. */
742 if (IsSavegameVersionBefore(SLV_ECONOMY_DATE)) {
743 TimerGameEconomy::SetDate(TimerGameEconomy::Date{TimerGameCalendar::date.base()}, TimerGameCalendar::date_fract);
744 } else {
745 TimerGameEconomy::SetDate(TimerGameEconomy::date, TimerGameEconomy::date_fract);
746 }
747
748 /*
749 * Force the old behaviour for compatibility reasons with old savegames. As new
750 * settings can only be loaded from new savegames loading old savegames with new
751 * versions of OpenTTD will normally initialize settings newer than the savegame
752 * version with "new game" defaults which the player can define to their liking.
753 * For some settings we override that to keep the behaviour the same as when the
754 * game was saved.
755 *
756 * Note that there is no non-stop in here. This is because the setting could have
757 * either value in TTDPatch. To convert it properly the user has to make sure the
758 * right value has been chosen in the settings. Otherwise we will be converting
759 * it incorrectly in half of the times without a means to correct that.
760 */
761 if (IsSavegameVersionBefore(SLV_4, 2)) _settings_game.station.modified_catchment = false;
762 if (IsSavegameVersionBefore(SLV_6, 1)) _settings_game.pf.forbid_90_deg = false;
763 if (IsSavegameVersionBefore(SLV_21)) _settings_game.vehicle.train_acceleration_model = 0;
764 if (IsSavegameVersionBefore(SLV_90)) _settings_game.vehicle.plane_speed = 4;
765 if (IsSavegameVersionBefore(SLV_95)) _settings_game.vehicle.dynamic_engines = false;
766 if (IsSavegameVersionBefore(SLV_96)) _settings_game.economy.station_noise_level = false;
767 if (IsSavegameVersionBefore(SLV_133)) {
768 _settings_game.vehicle.train_slope_steepness = 3;
769 }
770 if (IsSavegameVersionBefore(SLV_134)) _settings_game.economy.feeder_payment_share = 75;
771 if (IsSavegameVersionBefore(SLV_138)) _settings_game.vehicle.plane_crashes = 2;
772 if (IsSavegameVersionBefore(SLV_139)) {
773 _settings_game.vehicle.roadveh_acceleration_model = 0;
774 _settings_game.vehicle.roadveh_slope_steepness = 7;
775 }
776 if (IsSavegameVersionBefore(SLV_143)) _settings_game.economy.allow_town_level_crossings = true;
777 if (IsSavegameVersionBefore(SLV_159)) {
778 _settings_game.vehicle.max_train_length = 50;
779 _settings_game.construction.max_bridge_length = 64;
780 _settings_game.construction.max_tunnel_length = 64;
781 }
782 if (IsSavegameVersionBefore(SLV_166)) _settings_game.economy.infrastructure_maintenance = false;
783 if (IsSavegameVersionBefore(SLV_183)) {
784 _settings_game.linkgraph.distribution_pax = DT_MANUAL;
785 _settings_game.linkgraph.distribution_mail = DT_MANUAL;
786 _settings_game.linkgraph.distribution_armoured = DT_MANUAL;
787 _settings_game.linkgraph.distribution_default = DT_MANUAL;
788 }
789
790 if (IsSavegameVersionBefore(SLV_ENDING_YEAR)) {
791 _settings_game.game_creation.ending_year = CalendarTime::DEF_END_YEAR;
792 }
793
794 /* Convert linkgraph update settings from days to seconds. */
795 if (IsSavegameVersionBefore(SLV_LINKGRAPH_SECONDS)) {
796 _settings_game.linkgraph.recalc_interval *= CalendarTime::SECONDS_PER_DAY;
797 _settings_game.linkgraph.recalc_time *= CalendarTime::SECONDS_PER_DAY;
798 }
799
800 /* Load the sprites */
801 GfxLoadSprites();
802 LoadStringWidthTable();
803
804 /* Copy temporary data to Engine pool */
805 CopyTempEngineData();
806
807 /* Connect front and rear engines of multiheaded trains and converts
808 * subtype to the new format */
809 if (IsSavegameVersionBefore(SLV_17, 1)) ConvertOldMultiheadToNew();
810
811 /* Connect front and rear engines of multiheaded trains */
812 ConnectMultiheadedTrains();
813
814 /* Fix the CargoPackets *and* fix the caches of CargoLists.
815 * If this isn't done before Stations and especially Vehicles are
816 * running their AfterLoad we might get in trouble. In the case of
817 * vehicles we could give the wrong (cached) count of items in a
818 * vehicle which causes different results when getting their caches
819 * filled; and that could eventually lead to desyncs. */
820 CargoPacket::AfterLoad();
821
822 /* Update all vehicles: Phase 1 */
823 AfterLoadVehiclesPhase1(true);
824
825 /* Old orders are no longer needed. */
826 ClearOldOrders();
827
828 /* make sure there is a town in the game */
829 if (_game_mode == GM_NORMAL && Town::GetNumItems() == 0) {
830 SetSaveLoadError(STR_ERROR_NO_TOWN_IN_SCENARIO);
831 /* Restore the signals */
832 ResetSignalHandlers();
833 return false;
834 }
835
836 /* The void tiles on the southern border used to belong to a wrong class (pre 4.3).
837 * This problem appears in savegame version 21 too, see r3455. But after loading the
838 * savegame and saving again, the buggy map array could be converted to new savegame
839 * version. It didn't show up before r12070. */
840 if (IsSavegameVersionBefore(SLV_87)) UpdateVoidTiles();
841
842 /* Fix the cache for cargo payments. */
843 for (CargoPayment *cp : CargoPayment::Iterate()) {
844 cp->front->cargo_payment = cp;
845 cp->current_station = cp->front->last_station_visited;
846 }
847
848
849 if (IsSavegameVersionBefore(SLV_WATER_TILE_TYPE)) {
850 /* Prior to SLV_WATER_TILE_TYPE, the water tile type was stored differently from the enumeration. This has to be
851 * converted before SLV_72 and SLV_82 conversions which use GetWaterTileType. */
852 static constexpr uint8_t WBL_COAST_FLAG = 0;
853
854 for (auto t : Map::Iterate()) {
855 if (!IsTileType(t, MP_WATER)) continue;
856
857 switch (GB(t.m5(), 4, 4)) {
858 case 0x0: /* Previously WBL_TYPE_NORMAL, Clear water or coast. */
859 SetWaterTileType(t, HasBit(t.m5(), WBL_COAST_FLAG) ? WaterTileType::Coast : WaterTileType::Clear);
860 break;
861
862 case 0x1: SetWaterTileType(t, WaterTileType::Lock); break; /* Previously WBL_TYPE_LOCK */
863 case 0x8: SetWaterTileType(t, WaterTileType::Depot); break; /* Previously WBL_TYPE_DEPOT */
864 default: SetWaterTileType(t, WaterTileType::Clear); break; /* Shouldn't happen... */
865 }
866 }
867 }
868
869 if (IsSavegameVersionBefore(SLV_72)) {
870 /* Locks in very old savegames had OWNER_WATER as owner */
871 for (auto t : Map::Iterate()) {
872 switch (GetTileType(t)) {
873 default: break;
874
875 case MP_WATER:
876 if (GetWaterTileType(t) == WaterTileType::Lock && GetTileOwner(t) == OWNER_WATER) SetTileOwner(t, OWNER_NONE);
877 break;
878
879 case MP_STATION: {
880 if (HasBit(t.m6(), 3)) SetBit(t.m6(), 2);
881 StationGfx gfx = GetStationGfx(t);
882 StationType st;
883 if ( IsInsideMM(gfx, 0, 8)) { // Rail station
884 st = StationType::Rail;
885 SetStationGfx(t, gfx - 0);
886 } else if (IsInsideMM(gfx, 8, 67)) { // Airport
887 st = StationType::Airport;
888 SetStationGfx(t, gfx - 8);
889 } else if (IsInsideMM(gfx, 67, 71)) { // Truck
890 st = StationType::Truck;
891 SetStationGfx(t, gfx - 67);
892 } else if (IsInsideMM(gfx, 71, 75)) { // Bus
893 st = StationType::Bus;
894 SetStationGfx(t, gfx - 71);
895 } else if (gfx == 75) { // Oil rig
896 st = StationType::Oilrig;
897 SetStationGfx(t, gfx - 75);
898 } else if (IsInsideMM(gfx, 76, 82)) { // Dock
899 st = StationType::Dock;
900 SetStationGfx(t, gfx - 76);
901 } else if (gfx == 82) { // Buoy
902 st = StationType::Buoy;
903 SetStationGfx(t, gfx - 82);
904 } else if (IsInsideMM(gfx, 83, 168)) { // Extended airport
905 st = StationType::Airport;
906 SetStationGfx(t, gfx - 83 + 67 - 8);
907 } else if (IsInsideMM(gfx, 168, 170)) { // Drive through truck
908 st = StationType::Truck;
909 SetStationGfx(t, gfx - 168 + GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);
910 } else if (IsInsideMM(gfx, 170, 172)) { // Drive through bus
911 st = StationType::Bus;
912 SetStationGfx(t, gfx - 170 + GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);
913 } else {
914 /* Restore the signals */
915 ResetSignalHandlers();
916 return false;
917 }
918 SB(t.m6(), 3, 3, to_underlying(st));
919 break;
920 }
921 }
922 }
923 }
924
925 if (IsSavegameVersionBefore(SLV_INCREASE_STATION_TYPE_FIELD_SIZE)) {
926 /* Expansion of station type field in m6 */
927 for (auto t : Map::Iterate()) {
928 if (IsTileType(t, MP_STATION)) {
929 ClrBit(t.m6(), 6);
930 }
931 }
932 }
933
934 for (const auto t : Map::Iterate()) {
935 switch (GetTileType(t)) {
936 case MP_STATION: {
937 BaseStation *bst = BaseStation::GetByTile(t);
938
939 /* Sanity check */
940 if (!IsBuoy(t) && bst->owner != GetTileOwner(t)) SlErrorCorrupt("Wrong owner for station tile");
941
942 /* Set up station spread */
943 bst->rect.BeforeAddTile(t, StationRect::ADD_FORCE);
944
945 /* Waypoints don't have road stops/oil rigs in the old format */
946 if (!Station::IsExpected(bst)) break;
947 Station *st = Station::From(bst);
948
949 switch (GetStationType(t)) {
950 case StationType::Truck:
951 case StationType::Bus:
952 if (IsSavegameVersionBefore(SLV_6)) {
953 /* Before version 5 you could not have more than 250 stations.
954 * Version 6 adds large maps, so you could only place 253*253
955 * road stops on a map (no freeform edges) = 64009. So, yes
956 * someone could in theory create such a full map to trigger
957 * this assertion, it's safe to assume that's only something
958 * theoretical and does not happen in normal games. */
959 assert(RoadStop::CanAllocateItem());
960
961 /* From this version on there can be multiple road stops of the
962 * same type per station. Convert the existing stops to the new
963 * internal data structure. */
964 RoadStop *rs = new RoadStop(t);
965
966 RoadStop **head =
967 IsTruckStop(t) ? &st->truck_stops : &st->bus_stops;
968 *head = rs;
969 }
970 break;
971
972 case StationType::Oilrig: {
973 /* The internal encoding of oil rigs was changed twice.
974 * It was 3 (till 2.2) and later 5 (till 5.1).
975 * DeleteOilRig asserts on the correct type, and
976 * setting it unconditionally does not hurt.
977 */
978 Station::GetByTile(t)->airport.type = AT_OILRIG;
979
980 /* Very old savegames sometimes have phantom oil rigs, i.e.
981 * an oil rig which got shut down, but not completely removed from
982 * the map
983 */
984 TileIndex t1 = TileAddXY(t, 0, 1);
985 if (!IsTileType(t1, MP_INDUSTRY) || GetIndustryGfx(t1) != GFX_OILRIG_1) {
986 DeleteOilRig(t);
987 }
988 break;
989 }
990
991 default: break;
992 }
993 break;
994 }
995
996 default: break;
997 }
998 }
999
1000 /* In version 6.1 we put the town index in the map-array. To do this, we need
1001 * to use m2 (16bit big), so we need to clean m2, and that is where this is
1002 * all about ;) */
1003 if (IsSavegameVersionBefore(SLV_6, 1)) {
1004 for (auto t : Map::Iterate()) {
1005 switch (GetTileType(t)) {
1006 case MP_HOUSE:
1007 t.m4() = t.m2();
1008 SetTownIndex(t, CalcClosestTownFromTile(t)->index);
1009 break;
1010
1011 case MP_ROAD:
1012 t.m4() |= (t.m2() << 4);
1013 if (GB(t.m5(), 4, 2) == to_underlying(RoadTileType::Depot)) break;
1014 if ((GB(t.m5(), 4, 2) == to_underlying(RoadTileType::Crossing) ? (Owner)t.m3() : GetTileOwner(t)) == OWNER_TOWN) {
1015 SetTownIndex(t, CalcClosestTownFromTile(t)->index);
1016 } else {
1017 SetTownIndex(t, TownID::Begin());
1018 }
1019 break;
1020
1021 default: break;
1022 }
1023 }
1024 }
1025
1026 /* Force the freeform edges to false for old savegames. */
1027 if (IsSavegameVersionBefore(SLV_111)) {
1028 _settings_game.construction.freeform_edges = false;
1029 }
1030
1031 /* From version 9.0, we update the max passengers of a town (was sometimes negative
1032 * before that. */
1033 if (IsSavegameVersionBefore(SLV_9)) {
1034 for (Town *t : Town::Iterate()) UpdateTownMaxPass(t);
1035 }
1036
1037 /* From version 16.0, we included autorenew on engines, which are now saved, but
1038 * of course, we do need to initialize them for older savegames. */
1039 if (IsSavegameVersionBefore(SLV_16)) {
1040 for (Company *c : Company::Iterate()) {
1041 c->engine_renew_list = nullptr;
1042 c->settings.engine_renew = false;
1043 c->settings.engine_renew_months = 6;
1044 c->settings.engine_renew_money = 100000;
1045 }
1046
1047 /* When loading a game, _local_company is not yet set to the correct value.
1048 * However, in a dedicated server we are a spectator, so nothing needs to
1049 * happen. In case we are not a dedicated server, the local company always
1050 * becomes the first available company, unless we are in the scenario editor
1051 * where all the companies are 'invalid'.
1052 */
1053 Company *c = Company::GetIfValid(GetFirstPlayableCompanyID());
1054 if (!_network_dedicated && c != nullptr) {
1055 c->settings = _settings_client.company;
1056 }
1057 }
1058
1059 if (IsSavegameVersionBefore(SLV_48)) {
1060 for (auto t : Map::Iterate()) {
1061 switch (GetTileType(t)) {
1062 case MP_RAILWAY:
1063 if (IsPlainRail(t)) {
1064 /* Swap ground type and signal type for plain rail tiles, so the
1065 * ground type uses the same bits as for depots and waypoints. */
1066 uint tmp = GB(t.m4(), 0, 4);
1067 SB(t.m4(), 0, 4, GB(t.m2(), 0, 4));
1068 SB(t.m2(), 0, 4, tmp);
1069 } else if (HasBit(t.m5(), 2)) {
1070 /* Split waypoint and depot rail type and remove the subtype. */
1071 ClrBit(t.m5(), 2);
1072 ClrBit(t.m5(), 6);
1073 }
1074 break;
1075
1076 case MP_ROAD:
1077 /* Swap m3 and m4, so the track type for rail crossings is the
1078 * same as for normal rail. */
1079 std::swap(t.m3(), t.m4());
1080 break;
1081
1082 default: break;
1083 }
1084 }
1085 }
1086
1087 if (IsSavegameVersionBefore(SLV_61)) {
1088 /* Added the RoadType */
1089 bool old_bridge = IsSavegameVersionBefore(SLV_42);
1090 for (auto t : Map::Iterate()) {
1091 switch (GetTileType(t)) {
1092 case MP_ROAD:
1093 SB(t.m5(), 6, 2, GB(t.m5(), 4, 2));
1094 switch (GetRoadTileType(t)) {
1095 default: SlErrorCorrupt("Invalid road tile type");
1096 case RoadTileType::Normal:
1097 SB(t.m4(), 0, 4, GB(t.m5(), 0, 4));
1098 SB(t.m4(), 4, 4, 0);
1099 SB(t.m6(), 2, 4, 0);
1100 break;
1101 case RoadTileType::Crossing:
1102 SB(t.m4(), 5, 2, GB(t.m5(), 2, 2));
1103 break;
1104 case RoadTileType::Depot: break;
1105 }
1106 SB(t.m7(), 6, 2, 1); // Set pre-NRT road type bits for conversion later.
1107 break;
1108
1109 case MP_STATION:
1110 if (IsStationRoadStop(t)) SB(t.m7(), 6, 2, 1);
1111 break;
1112
1113 case MP_TUNNELBRIDGE:
1114 /* Middle part of "old" bridges */
1115 if (old_bridge && IsBridge(t) && HasBit(t.m5(), 6)) break;
1116 if (((old_bridge && IsBridge(t)) ? (TransportType)GB(t.m5(), 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) {
1117 SB(t.m7(), 6, 2, 1); // Set pre-NRT road type bits for conversion later.
1118 }
1119 break;
1120
1121 default: break;
1122 }
1123 }
1124 }
1125
1126 if (IsSavegameVersionBefore(SLV_114)) {
1127 bool fix_roadtypes = !IsSavegameVersionBefore(SLV_61);
1128 bool old_bridge = IsSavegameVersionBefore(SLV_42);
1129
1130 for (auto t : Map::Iterate()) {
1131 switch (GetTileType(t)) {
1132 case MP_ROAD:
1133 if (fix_roadtypes) SB(t.m7(), 6, 2, GB(t.m7(), 5, 3));
1134 SB(t.m7(), 5, 1, GB(t.m3(), 7, 1)); // snow/desert
1135 switch (GetRoadTileType(t)) {
1136 default: SlErrorCorrupt("Invalid road tile type");
1137 case RoadTileType::Normal:
1138 SB(t.m7(), 0, 4, GB(t.m3(), 0, 4)); // road works
1139 SB(t.m6(), 3, 3, GB(t.m3(), 4, 3)); // ground
1140 SB(t.m3(), 0, 4, GB(t.m4(), 4, 4)); // tram bits
1141 SB(t.m3(), 4, 4, GB(t.m5(), 0, 4)); // tram owner
1142 SB(t.m5(), 0, 4, GB(t.m4(), 0, 4)); // road bits
1143 break;
1144
1145 case RoadTileType::Crossing:
1146 SB(t.m7(), 0, 5, GB(t.m4(), 0, 5)); // road owner
1147 SB(t.m6(), 3, 3, GB(t.m3(), 4, 3)); // ground
1148 SB(t.m3(), 4, 4, GB(t.m5(), 0, 4)); // tram owner
1149 SB(t.m5(), 0, 1, GB(t.m4(), 6, 1)); // road axis
1150 SB(t.m5(), 5, 1, GB(t.m4(), 5, 1)); // crossing state
1151 break;
1152
1153 case RoadTileType::Depot:
1154 break;
1155 }
1156 if (!IsRoadDepot(t) && !HasTownOwnedRoad(t)) {
1157 const Town *town = CalcClosestTownFromTile(t);
1158 if (town != nullptr) SetTownIndex(t, town->index);
1159 }
1160 t.m4() = 0;
1161 break;
1162
1163 case MP_STATION:
1164 if (!IsStationRoadStop(t)) break;
1165
1166 if (fix_roadtypes) SB(t.m7(), 6, 2, GB(t.m3(), 0, 3));
1167 SB(t.m7(), 0, 5, (HasBit(t.m6(), 2) ? OWNER_TOWN : GetTileOwner(t)).base());
1168 SB(t.m3(), 4, 4, t.m1());
1169 t.m4() = 0;
1170 break;
1171
1172 case MP_TUNNELBRIDGE:
1173 if (old_bridge && IsBridge(t) && HasBit(t.m5(), 6)) break;
1174 if (((old_bridge && IsBridge(t)) ? (TransportType)GB(t.m5(), 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) {
1175 if (fix_roadtypes) SB(t.m7(), 6, 2, GB(t.m3(), 0, 3));
1176
1177 Owner o = GetTileOwner(t);
1178 SB(t.m7(), 0, 5, o.base()); // road owner
1179 SB(t.m3(), 4, 4, (o == OWNER_NONE ? OWNER_TOWN : o).base()); // tram owner
1180 }
1181 SB(t.m6(), 2, 4, GB(t.m2(), 4, 4)); // bridge type
1182 SB(t.m7(), 5, 1, GB(t.m4(), 7, 1)); // snow/desert
1183
1184 t.m2() = 0;
1185 t.m4() = 0;
1186 break;
1187
1188 default: break;
1189 }
1190 }
1191 }
1192
1193 /* Railtype moved from m3 to m8 in version SLV_EXTEND_RAILTYPES. */
1194 if (IsSavegameVersionBefore(SLV_EXTEND_RAILTYPES)) {
1195 for (auto t : Map::Iterate()) {
1196 switch (GetTileType(t)) {
1197 case MP_RAILWAY:
1198 SetRailType(t, (RailType)GB(t.m3(), 0, 4));
1199 break;
1200
1201 case MP_ROAD:
1202 if (IsLevelCrossing(t)) {
1203 SetRailType(t, (RailType)GB(t.m3(), 0, 4));
1204 }
1205 break;
1206
1207 case MP_STATION:
1208 if (HasStationRail(t)) {
1209 SetRailType(t, (RailType)GB(t.m3(), 0, 4));
1210 }
1211 break;
1212
1213 case MP_TUNNELBRIDGE:
1214 if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) {
1215 SetRailType(t, (RailType)GB(t.m3(), 0, 4));
1216 }
1217 break;
1218
1219 default:
1220 break;
1221 }
1222 }
1223 }
1224
1225 if (IsSavegameVersionBefore(SLV_42)) {
1226 for (auto t : Map::Iterate()) {
1227 if (MayHaveBridgeAbove(t)) ClearBridgeMiddle(t);
1228 if (IsBridgeTile(t)) {
1229 if (HasBit(t.m5(), 6)) { // middle part
1230 Axis axis = (Axis)GB(t.m5(), 0, 1);
1231
1232 if (HasBit(t.m5(), 5)) { // transport route under bridge?
1233 if (GB(t.m5(), 3, 2) == TRANSPORT_RAIL) {
1234 MakeRailNormal(
1235 t,
1236 GetTileOwner(t),
1237 axis == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X,
1238 GetRailType(t)
1239 );
1240 } else {
1241 TownID town = IsTileOwner(t, OWNER_TOWN) ? ClosestTownFromTile(t, UINT_MAX)->index : TownID::Begin();
1242
1243 /* MakeRoadNormal */
1244 SetTileType(t, MP_ROAD);
1245 t.m2() = town.base();
1246 t.m3() = 0;
1247 t.m5() = (axis == AXIS_X ? ROAD_Y : ROAD_X) | to_underlying(RoadTileType::Normal) << 6;
1248 SB(t.m6(), 2, 4, 0);
1249 t.m7() = 1 << 6;
1250 SetRoadOwner(t, RTT_TRAM, OWNER_NONE);
1251 }
1252 } else {
1253 if (GB(t.m5(), 3, 2) == 0) {
1254 MakeClear(t, CLEAR_GRASS, 3);
1255 } else {
1256 if (!IsTileFlat(t)) {
1257 MakeShore(t);
1258 } else {
1259 if (GetTileOwner(t) == OWNER_WATER) {
1260 MakeSea(t);
1261 } else {
1262 MakeCanal(t, GetTileOwner(t), Random());
1263 }
1264 }
1265 }
1266 }
1267 SetBridgeMiddle(t, axis);
1268 } else { // ramp
1269 Axis axis = (Axis)GB(t.m5(), 0, 1);
1270 uint north_south = GB(t.m5(), 5, 1);
1271 DiagDirection dir = ReverseDiagDir(XYNSToDiagDir(axis, north_south));
1272 TransportType type = (TransportType)GB(t.m5(), 1, 2);
1273
1274 t.m5() = 1 << 7 | type << 2 | dir;
1275 }
1276 }
1277 }
1278
1279 for (Vehicle *v : Vehicle::Iterate()) {
1280 if (!v->IsGroundVehicle()) continue;
1281 if (IsBridgeTile(v->tile)) {
1282 DiagDirection dir = GetTunnelBridgeDirection(v->tile);
1283
1284 if (dir != DirToDiagDir(v->direction)) continue;
1285 switch (dir) {
1286 default: SlErrorCorrupt("Invalid vehicle direction");
1287 case DIAGDIR_NE: if ((v->x_pos & 0xF) != 0) continue; break;
1288 case DIAGDIR_SE: if ((v->y_pos & 0xF) != TILE_SIZE - 1) continue; break;
1289 case DIAGDIR_SW: if ((v->x_pos & 0xF) != TILE_SIZE - 1) continue; break;
1290 case DIAGDIR_NW: if ((v->y_pos & 0xF) != 0) continue; break;
1291 }
1292 } else if (v->z_pos > GetTileMaxPixelZ(TileVirtXY(v->x_pos, v->y_pos))) {
1293 v->tile = GetNorthernBridgeEnd(v->tile);
1294 v->UpdatePosition();
1295 } else {
1296 continue;
1297 }
1298 if (v->type == VEH_TRAIN) {
1299 Train::From(v)->track = TRACK_BIT_WORMHOLE;
1300 } else {
1301 RoadVehicle::From(v)->state = RVSB_WORMHOLE;
1302 }
1303 }
1304 }
1305
1306 if (IsSavegameVersionBefore(SLV_ROAD_TYPES)) {
1307 /* Add road subtypes */
1308 for (auto t : Map::Iterate()) {
1309 bool has_road = false;
1310 switch (GetTileType(t)) {
1311 case MP_ROAD:
1312 has_road = true;
1313 break;
1314 case MP_STATION:
1315 has_road = IsAnyRoadStop(t);
1316 break;
1317 case MP_TUNNELBRIDGE:
1318 has_road = GetTunnelBridgeTransportType(t) == TRANSPORT_ROAD;
1319 break;
1320 default:
1321 break;
1322 }
1323
1324 if (has_road) {
1325 RoadType road_rt = HasBit(t.m7(), 6) ? ROADTYPE_ROAD : INVALID_ROADTYPE;
1326 RoadType tram_rt = HasBit(t.m7(), 7) ? ROADTYPE_TRAM : INVALID_ROADTYPE;
1327
1328 assert(road_rt != INVALID_ROADTYPE || tram_rt != INVALID_ROADTYPE);
1329 SetRoadTypes(t, road_rt, tram_rt);
1330 SB(t.m7(), 6, 2, 0); // Clear pre-NRT road type bits.
1331 }
1332 }
1333 }
1334
1335 /* Elrails got added in rev 24 */
1336 if (IsSavegameVersionBefore(SLV_24)) {
1337 RailType min_rail = RAILTYPE_ELECTRIC;
1338
1339 for (Train *v : Train::Iterate()) {
1340 RailTypes rts = RailVehInfo(v->engine_type)->railtypes;
1341
1342 v->railtypes = rts;
1343 if (rts.Test(RAILTYPE_ELECTRIC)) min_rail = RAILTYPE_RAIL;
1344 }
1345
1346 /* .. so we convert the entire map from normal to elrail (so maintain "fairness") */
1347 for (const auto t : Map::Iterate()) {
1348 switch (GetTileType(t)) {
1349 case MP_RAILWAY:
1350 SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
1351 break;
1352
1353 case MP_ROAD:
1354 if (IsLevelCrossing(t)) {
1355 SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
1356 }
1357 break;
1358
1359 case MP_STATION:
1360 if (HasStationRail(t)) {
1361 SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
1362 }
1363 break;
1364
1365 case MP_TUNNELBRIDGE:
1366 if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) {
1367 SetRailType(t, UpdateRailType(GetRailType(t), min_rail));
1368 }
1369 break;
1370
1371 default:
1372 break;
1373 }
1374 }
1375 }
1376
1377 /* In version 16.1 of the savegame a company can decide if trains, which get
1378 * replaced, shall keep their old length. In all prior versions, just default
1379 * to false */
1380 if (IsSavegameVersionBefore(SLV_16, 1)) {
1381 for (Company *c : Company::Iterate()) c->settings.renew_keep_length = false;
1382 }
1383
1384 if (IsSavegameVersionBefore(SLV_123)) {
1385 /* Waypoints became subclasses of stations ... */
1386 MoveWaypointsToBaseStations();
1387 /* ... and buoys were moved to waypoints. */
1388 MoveBuoysToWaypoints();
1389 }
1390
1391 /* From version 15, we moved a semaphore bit from bit 2 to bit 3 in m4, making
1392 * room for PBS. Now in version 21 move it back :P. */
1393 if (IsSavegameVersionBefore(SLV_21) && !IsSavegameVersionBefore(SLV_15)) {
1394 for (auto t : Map::Iterate()) {
1395 switch (GetTileType(t)) {
1396 case MP_RAILWAY:
1397 if (HasSignals(t)) {
1398 /* Original signal type/variant was stored in m4 but since saveload
1399 * version 48 they are in m2. The bits has been already moved to m2
1400 * (see the code somewhere above) so don't use m4, use m2 instead. */
1401
1402 /* convert PBS signals to combo-signals */
1403 if (HasBit(t.m2(), 2)) SB(t.m2(), 0, 2, SIGTYPE_COMBO);
1404
1405 /* move the signal variant back */
1406 SB(t.m2(), 2, 1, HasBit(t.m2(), 3) ? SIG_SEMAPHORE : SIG_ELECTRIC);
1407 ClrBit(t.m2(), 3);
1408 }
1409
1410 /* Clear PBS reservation on track */
1411 if (!IsRailDepotTile(t)) {
1412 SB(t.m4(), 4, 4, 0);
1413 } else {
1414 ClrBit(t.m3(), 6);
1415 }
1416 break;
1417
1418 case MP_STATION: // Clear PBS reservation on station
1419 ClrBit(t.m3(), 6);
1420 break;
1421
1422 default: break;
1423 }
1424 }
1425 }
1426
1427 if (IsSavegameVersionBefore(SLV_25)) {
1428 /* Remove obsolete VS_WAIT_FOR_SLOT state from road vehicles. */
1429 static constexpr VehStates OLD_VS_WAIT_FOR_SLOT{0x40};
1430 for (RoadVehicle *rv : RoadVehicle::Iterate()) {
1431 rv->vehstatus.Reset(OLD_VS_WAIT_FOR_SLOT);
1432 }
1433 }
1434
1435 if (IsSavegameVersionBefore(SLV_26)) {
1436 for (Station *st : Station::Iterate()) {
1437 st->last_vehicle_type = VEH_INVALID;
1438 }
1439 }
1440
1441 YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK);
1442
1443 if (IsSavegameVersionBefore(SLV_34)) {
1444 for (Company *c : Company::Iterate()) ResetCompanyLivery(c);
1445 }
1446
1447 for (Company *c : Company::Iterate()) {
1448 c->avail_railtypes = GetCompanyRailTypes(c->index);
1449 c->avail_roadtypes = GetCompanyRoadTypes(c->index);
1450 }
1451
1452 AfterLoadStations();
1453
1454 /* Time starts at 0 instead of 1920.
1455 * Account for this in older games by adding an offset */
1456 if (IsSavegameVersionBefore(SLV_31)) {
1457 TimerGameCalendar::date += CalendarTime::DAYS_TILL_ORIGINAL_BASE_YEAR;
1458 TimerGameCalendar::year += CalendarTime::ORIGINAL_BASE_YEAR;
1459 TimerGameEconomy::date += EconomyTime::DAYS_TILL_ORIGINAL_BASE_YEAR;
1460 TimerGameEconomy::year += EconomyTime::ORIGINAL_BASE_YEAR;
1461
1462 for (Station *st : Station::Iterate()) st->build_date += CalendarTime::DAYS_TILL_ORIGINAL_BASE_YEAR;
1463 for (Waypoint *wp : Waypoint::Iterate()) wp->build_date += CalendarTime::DAYS_TILL_ORIGINAL_BASE_YEAR;
1464 for (Engine *e : Engine::Iterate()) e->intro_date += CalendarTime::DAYS_TILL_ORIGINAL_BASE_YEAR;
1465 for (Company *c : Company::Iterate()) c->inaugurated_year += EconomyTime::ORIGINAL_BASE_YEAR;
1466 for (Industry *i : Industry::Iterate()) i->last_prod_year += EconomyTime::ORIGINAL_BASE_YEAR;
1467
1468 for (Vehicle *v : Vehicle::Iterate()) {
1469 v->date_of_last_service += EconomyTime::DAYS_TILL_ORIGINAL_BASE_YEAR;
1470 v->build_year += CalendarTime::ORIGINAL_BASE_YEAR;
1471 }
1472 }
1473
1474 /* From 32 on we save the industry who made the farmland.
1475 * To give this prettiness to old savegames, we remove all farmfields and
1476 * plant new ones. */
1477 if (IsSavegameVersionBefore(SLV_32)) {
1478 for (const auto t : Map::Iterate()) {
1479 if (IsTileType(t, MP_CLEAR) && IsClearGround(t, CLEAR_FIELDS)) {
1480 /* remove fields */
1481 MakeClear(t, CLEAR_GRASS, 3);
1482 }
1483 }
1484
1485 for (Industry *i : Industry::Iterate()) {
1486 uint j;
1487
1488 if (GetIndustrySpec(i->type)->behaviour.Test(IndustryBehaviour::PlantOnBuild)) {
1489 for (j = 0; j != 50; j++) PlantRandomFarmField(i);
1490 }
1491 }
1492 }
1493
1494 /* Setting no refit flags to all orders in savegames from before refit in orders were added */
1495 if (IsSavegameVersionBefore(SLV_36)) {
1496 for (OrderList *orderlist : OrderList::Iterate()) {
1497 for (Order &order : orderlist->GetOrders()) {
1498 order.SetRefit(CARGO_NO_REFIT);
1499 }
1500 }
1501
1502 for (Vehicle *v : Vehicle::Iterate()) {
1503 v->current_order.SetRefit(CARGO_NO_REFIT);
1504 }
1505 }
1506
1507 /* from version 38 we have optional elrails, since we cannot know the
1508 * preference of a user, let elrails enabled; it can be disabled manually */
1509 if (IsSavegameVersionBefore(SLV_38)) _settings_game.vehicle.disable_elrails = false;
1510 /* do the same as when elrails were enabled/disabled manually just now */
1511 UpdateDisableElrailSettingState(_settings_game.vehicle.disable_elrails, false);
1512 InitializeRailGUI();
1513
1514 /* From version 53, the map array was changed for house tiles to allow
1515 * space for newhouses grf features. A new byte, m7, was also added. */
1516 if (IsSavegameVersionBefore(SLV_53)) {
1517 for (auto t : Map::Iterate()) {
1518 if (IsTileType(t, MP_HOUSE)) {
1519 if (GB(t.m3(), 6, 2) != TOWN_HOUSE_COMPLETED) {
1520 /* Move the construction stage from m3[7..6] to m5[5..4].
1521 * The construction counter does not have to move. */
1522 SB(t.m5(), 3, 2, GB(t.m3(), 6, 2));
1523 SB(t.m3(), 6, 2, 0);
1524
1525 /* The "house is completed" bit is now in m6[2]. */
1526 SetHouseCompleted(t, false);
1527 } else {
1528 /* The "lift has destination" bit has been moved from
1529 * m5[7] to m7[0]. */
1530 AssignBit(t.m7(), 0, HasBit(t.m5(), 7));
1531 ClrBit(t.m5(), 7);
1532
1533 /* The "lift is moving" bit has been removed, as it does
1534 * the same job as the "lift has destination" bit. */
1535 ClrBit(t.m1(), 7);
1536
1537 /* The position of the lift goes from m1[7..0] to m6[7..2],
1538 * making m1 totally free, now. The lift position does not
1539 * have to be a full byte since the maximum value is 36. */
1540 SetLiftPosition(t, GB(t.m1(), 0, 6 ));
1541
1542 t.m1() = 0;
1543 t.m3() = 0;
1544 SetHouseCompleted(t, true);
1545 }
1546 }
1547 }
1548 }
1549
1550 if (IsSavegameVersionBefore(SLV_INCREASE_HOUSE_LIMIT)) {
1551 for (auto t : Map::Iterate()) {
1552 if (IsTileType(t, MP_HOUSE)) {
1553 /* House type is moved from m4 + m3[6] to m8. */
1554 SetHouseType(t, t.m4() | (GB(t.m3(), 6, 1) << 8));
1555 t.m4() = 0;
1556 ClrBit(t.m3(), 6);
1557 }
1558 }
1559 }
1560
1561 if (IsSavegameVersionBefore(SLV_PROTECT_PLACED_HOUSES)) {
1562 for (auto t : Map::Iterate()) {
1563 if (IsTileType(t, MP_HOUSE)) {
1564 /* We now store house protection status in the map. Set this based on the house spec flags. */
1565 const HouseSpec *hs = HouseSpec::Get(GetHouseType(t));
1566 SetHouseProtected(t, hs->extra_flags.Test(HouseExtraFlag::BuildingIsProtected));
1567 }
1568 }
1569 }
1570
1571 /* Check and update house and town values */
1572 UpdateHousesAndTowns();
1573
1574 if (IsSavegameVersionBefore(SLV_43)) {
1575 for (auto t : Map::Iterate()) {
1576 if (IsTileType(t, MP_INDUSTRY)) {
1577 switch (GetIndustryGfx(t)) {
1578 case GFX_POWERPLANT_SPARKS:
1579 t.m3() = GB(t.m1(), 2, 5);
1580 break;
1581
1582 case GFX_OILWELL_ANIMATED_1:
1583 case GFX_OILWELL_ANIMATED_2:
1584 case GFX_OILWELL_ANIMATED_3:
1585 t.m3() = GB(t.m1(), 0, 2);
1586 break;
1587
1588 case GFX_COAL_MINE_TOWER_ANIMATED:
1589 case GFX_COPPER_MINE_TOWER_ANIMATED:
1590 case GFX_GOLD_MINE_TOWER_ANIMATED:
1591 t.m3() = t.m1();
1592 break;
1593
1594 default: // No animation states to change
1595 break;
1596 }
1597 }
1598 }
1599 }
1600
1601 if (IsSavegameVersionBefore(SLV_45)) {
1602 /* Originally just the fact that some cargo had been paid for was
1603 * stored to stop people cheating and cashing in several times. This
1604 * wasn't enough though as it was cleared when the vehicle started
1605 * loading again, even if it didn't actually load anything, so now the
1606 * amount that has been paid is stored. */
1607 for (Vehicle *v : Vehicle::Iterate()) {
1608 v->vehicle_flags.Reset(VehicleFlag{2});
1609 }
1610 }
1611
1612 /* Buoys do now store the owner of the previous water tile, which can never
1613 * be OWNER_NONE. So replace OWNER_NONE with OWNER_WATER. */
1614 if (IsSavegameVersionBefore(SLV_46)) {
1615 for (Waypoint *wp : Waypoint::Iterate()) {
1616 if (wp->facilities.Test(StationFacility::Dock) && IsTileOwner(wp->xy, OWNER_NONE) && TileHeight(wp->xy) == 0) SetTileOwner(wp->xy, OWNER_WATER);
1617 }
1618 }
1619
1620 if (IsSavegameVersionBefore(SLV_50)) {
1621 /* Aircraft units changed from 8 mph to 1 km-ish/h */
1622 for (Aircraft *v : Aircraft::Iterate()) {
1623 if (v->subtype <= AIR_AIRCRAFT) {
1624 const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);
1625 v->cur_speed *= 128;
1626 v->cur_speed /= 10;
1627 v->acceleration = avi->acceleration;
1628 }
1629 }
1630 }
1631
1632 if (IsSavegameVersionBefore(SLV_49)) {
1633 /* Perform conversion of very old face bits. */
1634 for (Company *c : Company::Iterate()) {
1635 c->face = ConvertFromOldCompanyManagerFace(c->face.bits);
1636 }
1637 } else if (IsSavegameVersionBefore(SLV_FACE_STYLES)) {
1638 /* Convert old gender and ethnicity bits to face style. */
1639 for (Company *c : Company::Iterate()) {
1640 SetCompanyManagerFaceStyle(c->face, GB(c->face.bits, 0, 2));
1641 }
1642 } else {
1643 /* Look up each company face style by its label. */
1644 for (Company *c : Company::Iterate()) {
1645 auto style = FindCompanyManagerFaceLabel(c->face.style_label);
1646 if (style.has_value()) {
1647 SetCompanyManagerFaceStyle(c->face, *style);
1648 } else {
1649 /* Style no longer exists, pick an entirely new face. */
1650 RandomiseCompanyManagerFace(c->face, _random);
1651 }
1652 }
1653 }
1654
1655 if (IsSavegameVersionBefore(SLV_52)) {
1656 for (auto t : Map::Iterate()) {
1657 if (IsTileType(t, MP_OBJECT) && t.m5() == OBJECT_STATUE) {
1658 t.m2() = CalcClosestTownFromTile(t)->index.base();
1659 }
1660 }
1661 }
1662
1663 /* A setting containing the proportion of towns that grow twice as
1664 * fast was added in version 54. From version 56 this is now saved in the
1665 * town as cities can be built specifically in the scenario editor. */
1666 if (IsSavegameVersionBefore(SLV_56)) {
1667 for (Town *t : Town::Iterate()) {
1668 if (_settings_game.economy.larger_towns != 0 && (t->index % _settings_game.economy.larger_towns) == 0) {
1669 t->larger_town = true;
1670 }
1671 }
1672 }
1673
1674 if (IsSavegameVersionBefore(SLV_57)) {
1675 /* Added a FIFO queue of vehicles loading at stations */
1676 for (Vehicle *v : Vehicle::Iterate()) {
1677 if ((v->type != VEH_TRAIN || Train::From(v)->IsFrontEngine()) && // for all locs
1678 !v->vehstatus.Any({VehState::Stopped, VehState::Crashed}) && // not stopped or crashed
1679 v->current_order.IsType(OT_LOADING)) { // loading
1680 Station::Get(v->last_station_visited)->loading_vehicles.push_back(v);
1681
1682 /* The loading finished flag is *only* set when actually completely
1683 * finished. Because the vehicle is loading, it is not finished. */
1684 v->vehicle_flags.Reset(VehicleFlag::LoadingFinished);
1685 }
1686 }
1687 } else if (IsSavegameVersionBefore(SLV_59)) {
1688 /* For some reason non-loading vehicles could be in the station's loading vehicle list */
1689
1690 for (Station *st : Station::Iterate()) {
1691 for (auto iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end(); /* nothing */) {
1692 Vehicle *v = *iter;
1693 if (!v->current_order.IsType(OT_LOADING)) {
1694 iter = st->loading_vehicles.erase(iter);
1695 } else {
1696 ++iter;
1697 }
1698 }
1699 }
1700 }
1701
1702 if (IsSavegameVersionBefore(SLV_58)) {
1703 /* Setting difficulty industry_density other than zero get bumped to +1
1704 * since a new option (very low at position 1) has been added */
1705 if (_settings_game.difficulty.industry_density > 0) {
1706 _settings_game.difficulty.industry_density++;
1707 }
1708
1709 /* Same goes for number of towns, although no test is needed, just an increment */
1710 _settings_game.difficulty.number_towns++;
1711 }
1712
1713 if (IsSavegameVersionBefore(SLV_64)) {
1714 /* Since now we allow different signal types and variants on a single tile.
1715 * Move signal states to m4 to make room and clone the signal type/variant. */
1716 for (auto t : Map::Iterate()) {
1717 if (IsTileType(t, MP_RAILWAY) && HasSignals(t)) {
1718 /* move signal states */
1719 SetSignalStates(t, GB(t.m2(), 4, 4));
1720 SB(t.m2(), 4, 4, 0);
1721 /* clone signal type and variant */
1722 SB(t.m2(), 4, 3, GB(t.m2(), 0, 3));
1723 }
1724 }
1725 }
1726
1727 if (IsSavegameVersionBefore(SLV_69)) {
1728 /* In some old savegames a bit was cleared when it should not be cleared */
1729 for (RoadVehicle *rv : RoadVehicle::Iterate()) {
1730 if (rv->state == 250 || rv->state == 251) {
1731 SetBit(rv->state, 2);
1732 }
1733 }
1734 }
1735
1736 if (IsSavegameVersionBefore(SLV_70)) {
1737 /* Added variables to support newindustries */
1738 for (Industry *i : Industry::Iterate()) i->founder = OWNER_NONE;
1739 }
1740
1741 /* From version 82, old style canals (above sealevel (0), WATER owner) are no longer supported.
1742 Replace the owner for those by OWNER_NONE. */
1743 if (IsSavegameVersionBefore(SLV_82)) {
1744 for (const auto t : Map::Iterate()) {
1745 if (IsTileType(t, MP_WATER) &&
1746 GetWaterTileType(t) == WaterTileType::Clear &&
1747 GetTileOwner(t) == OWNER_WATER &&
1748 TileHeight(t) != 0) {
1749 SetTileOwner(t, OWNER_NONE);
1750 }
1751 }
1752 }
1753
1754 /*
1755 * Add the 'previous' owner to the ship depots so we can reset it with
1756 * the correct values when it gets destroyed. This prevents that
1757 * someone can remove canals owned by somebody else and it prevents
1758 * making floods using the removal of ship depots.
1759 */
1760 if (IsSavegameVersionBefore(SLV_83)) {
1761 for (auto t : Map::Iterate()) {
1762 if (IsShipDepotTile(t)) {
1763 t.m4() = (TileHeight(t) == 0 ? OWNER_WATER : OWNER_NONE).base();
1764 }
1765 }
1766 }
1767
1768 if (IsSavegameVersionBefore(SLV_74)) {
1769 for (Station *st : Station::Iterate()) {
1770 for (GoodsEntry &ge : st->goods) {
1771 ge.last_speed = 0;
1772 if (ge.AvailableCount() != 0) ge.status.Set(GoodsEntry::State::Rating);
1773 }
1774 }
1775 }
1776
1777 /* At version 78, industry cargo types can be changed, and are stored with the industry. For older save versions
1778 * copy the IndustrySpec's cargo types over to the Industry. */
1779 if (IsSavegameVersionBefore(SLV_78)) {
1780 for (Industry *i : Industry::Iterate()) {
1781 const IndustrySpec *indsp = GetIndustrySpec(i->type);
1782 for (uint j = 0; j < std::size(i->produced); j++) {
1783 i->produced[j].cargo = indsp->produced_cargo[j];
1784 }
1785 for (uint j = 0; j < std::size(i->accepted); j++) {
1786 i->accepted[j].cargo = indsp->accepts_cargo[j];
1787 }
1788 }
1789 }
1790
1791 /* Industry cargo slots were fixed size before (and including) SLV_VEHICLE_ECONOMY_AGE (either 2/3 or 16/16),
1792 * after this they are dynamic. Trim excess slots. */
1793 if (IsSavegameVersionBeforeOrAt(SLV_VEHICLE_ECONOMY_AGE)) {
1794 for (Industry *i : Industry::Iterate()) {
1795 TrimIndustryAcceptedProduced(i);
1796 }
1797 }
1798
1799 /* Before version 81, the density of grass was always stored as zero, and
1800 * grassy trees were always drawn fully grassy. Furthermore, trees on rough
1801 * land used to have zero density, now they have full density. Therefore,
1802 * make all grassy/rough land trees have a density of 3. */
1803 if (IsSavegameVersionBefore(SLV_81)) {
1804 for (auto t : Map::Iterate()) {
1805 if (GetTileType(t) == MP_TREES) {
1806 TreeGround ground_type = (TreeGround)GB(t.m2(), 4, 2);
1807 if (ground_type != TREE_GROUND_SNOW_DESERT) SB(t.m2(), 6, 2, 3);
1808 }
1809 }
1810 }
1811
1812
1813 if (IsSavegameVersionBefore(SLV_93)) {
1814 /* Rework of orders. */
1815 for (OrderList *orderlist : OrderList::Iterate()) {
1816 for (Order &o : orderlist->GetOrders()) {
1817 o.ConvertFromOldSavegame();
1818 }
1819 }
1820
1821 for (Vehicle *v : Vehicle::Iterate()) {
1822 if (v->orders != nullptr && v->GetFirstOrder() != nullptr && v->GetFirstOrder()->IsType(OT_NOTHING)) {
1823 v->orders->FreeChain();
1824 v->orders = nullptr;
1825 }
1826
1827 v->current_order.ConvertFromOldSavegame();
1828 if (v->type == VEH_ROAD && v->IsPrimaryVehicle() && v->FirstShared() == v) {
1829 for (Order &order : v->Orders()) order.SetNonStopType(OrderNonStopFlag::NoIntermediate);
1830 }
1831 }
1832 } else if (IsSavegameVersionBefore(SLV_94)) {
1833 /* Unload and transfer are now mutual exclusive. */
1834 for (OrderList *orderlist : OrderList::Iterate()) {
1835 for (Order &order : orderlist->GetOrders()) {
1836 if (order.GetUnloadType() == OrderUnloadType{3}) { // 3 used to mean transfer and don't load.
1837 order.SetUnloadType(OrderUnloadType::Transfer);
1838 order.SetLoadType(OrderLoadType::NoLoad);
1839 }
1840 }
1841 }
1842
1843 for (Vehicle *v : Vehicle::Iterate()) {
1844 if (v->current_order.GetUnloadType() == OrderUnloadType{3}) { // 3 used to mean transfer and don't load.
1845 v->current_order.SetUnloadType(OrderUnloadType::Transfer);
1846 v->current_order.SetLoadType(OrderLoadType::NoLoad);
1847 }
1848 }
1849 } else if (IsSavegameVersionBefore(SLV_DEPOT_UNBUNCHING)) {
1850 /* OrderDepotActionFlags were moved, instead of starting at bit 4 they now start at bit 3. */
1851 for (OrderList *orderlist : OrderList::Iterate()) {
1852 for (Order &order : orderlist->GetOrders()) {
1853 if (!order.IsType(OT_GOTO_DEPOT)) continue;
1854 order.SetDepotActionType(static_cast<OrderDepotActionFlags>(order.GetDepotActionType().base() >> 1));
1855 }
1856 }
1857
1858 for (Vehicle *v : Vehicle::Iterate()) {
1859 if (!v->current_order.IsType(OT_GOTO_DEPOT)) continue;
1860 v->current_order.SetDepotActionType(static_cast<OrderDepotActionFlags>(v->current_order.GetDepotActionType().base() >> 1));
1861 }
1862 }
1863
1864 /* The water class was moved/unified. */
1865 if (IsSavegameVersionBefore(SLV_146)) {
1866 for (auto t : Map::Iterate()) {
1867 switch (GetTileType(t)) {
1868 case MP_STATION:
1869 switch (GetStationType(t)) {
1870 case StationType::Oilrig:
1871 case StationType::Dock:
1872 case StationType::Buoy:
1873 SetWaterClass(t, (WaterClass)GB(t.m3(), 0, 2));
1874 SB(t.m3(), 0, 2, 0);
1875 break;
1876
1877 default:
1878 SetWaterClass(t, WaterClass::Invalid);
1879 break;
1880 }
1881 break;
1882
1883 case MP_WATER:
1884 SetWaterClass(t, (WaterClass)GB(t.m3(), 0, 2));
1885 SB(t.m3(), 0, 2, 0);
1886 break;
1887
1888 case MP_OBJECT:
1889 SetWaterClass(t, WaterClass::Invalid);
1890 break;
1891
1892 default:
1893 /* No water class. */
1894 break;
1895 }
1896 }
1897 }
1898
1899 if (IsSavegameVersionBefore(SLV_86)) {
1900 for (auto t : Map::Iterate()) {
1901 /* Move river flag and update canals to use water class */
1902 if (IsTileType(t, MP_WATER)) {
1903 if (GetWaterClass(t) != WaterClass::River) {
1904 if (IsWater(t)) {
1905 Owner o = GetTileOwner(t);
1906 if (o == OWNER_WATER) {
1907 MakeSea(t);
1908 } else {
1909 MakeCanal(t, o, Random());
1910 }
1911 } else if (IsShipDepot(t)) {
1912 Owner o = (Owner)t.m4(); // Original water owner
1913 SetWaterClass(t, o == OWNER_WATER ? WaterClass::Sea : WaterClass::Canal);
1914 }
1915 }
1916 }
1917 }
1918
1919 /* Update locks, depots, docks and buoys to have a water class based
1920 * on its neighbouring tiles. Done after river and canal updates to
1921 * ensure neighbours are correct. */
1922 for (const auto t : Map::Iterate()) {
1923 if (!IsTileFlat(t)) continue;
1924
1925 if (IsTileType(t, MP_WATER) && IsLock(t)) SetWaterClassDependingOnSurroundings(t, false);
1926 if (IsTileType(t, MP_STATION) && (IsDock(t) || IsBuoy(t))) SetWaterClassDependingOnSurroundings(t, false);
1927 }
1928 }
1929
1930 if (IsSavegameVersionBefore(SLV_87)) {
1931 for (const auto t : Map::Iterate()) {
1932 /* skip oil rigs at borders! */
1933 if ((IsTileType(t, MP_WATER) || IsBuoyTile(t)) &&
1934 (TileX(t) == 0 || TileY(t) == 0 || TileX(t) == Map::MaxX() - 1 || TileY(t) == Map::MaxY() - 1)) {
1935 /* Some version 86 savegames have wrong water class at map borders (under buoy, or after removing buoy).
1936 * This conversion has to be done before buoys with invalid owner are removed. */
1937 SetWaterClass(t, WaterClass::Sea);
1938 }
1939
1940 if (IsBuoyTile(t) || IsDriveThroughStopTile(t) || IsTileType(t, MP_WATER)) {
1941 Owner o = GetTileOwner(t);
1942 if (o < MAX_COMPANIES && !Company::IsValidID(o)) {
1943 Backup<CompanyID> cur_company(_current_company, o);
1944 ChangeTileOwner(t, o, INVALID_OWNER);
1945 cur_company.Restore();
1946 }
1947 if (IsBuoyTile(t)) {
1948 /* reset buoy owner to OWNER_NONE in the station struct
1949 * (even if it is owned by active company) */
1950 Waypoint::GetByTile(t)->owner = OWNER_NONE;
1951 }
1952 } else if (IsTileType(t, MP_ROAD)) {
1953 /* works for all RoadTileType */
1954 for (RoadTramType rtt : _roadtramtypes) {
1955 /* update even non-existing road types to update tile owner too */
1956 Owner o = GetRoadOwner(t, rtt);
1957 if (o < MAX_COMPANIES && !Company::IsValidID(o)) SetRoadOwner(t, rtt, OWNER_NONE);
1958 }
1959 if (IsLevelCrossing(t)) {
1960 if (!Company::IsValidID(GetTileOwner(t))) FixOwnerOfRailTrack(t);
1961 }
1962 } else if (IsPlainRailTile(t)) {
1963 if (!Company::IsValidID(GetTileOwner(t))) FixOwnerOfRailTrack(t);
1964 }
1965 }
1966 }
1967
1968 if (IsSavegameVersionBefore(SLV_88)) {
1969 /* Profits are now with 8 bit fract */
1970 for (Vehicle *v : Vehicle::Iterate()) {
1971 v->profit_this_year <<= 8;
1972 v->profit_last_year <<= 8;
1973 v->running_ticks = 0;
1974 }
1975 }
1976
1977 if (IsSavegameVersionBefore(SLV_91)) {
1978 /* Increase HouseAnimationFrame from 5 to 7 bits */
1979 for (auto t : Map::Iterate()) {
1980 if (IsTileType(t, MP_HOUSE) && GetHouseType(t) >= NEW_HOUSE_OFFSET) {
1981 SB(t.m6(), 2, 6, GB(t.m6(), 3, 5));
1982 SB(t.m3(), 5, 1, 0);
1983 }
1984 }
1985 }
1986
1987 if (IsSavegameVersionBefore(SLV_62)) {
1988 GroupStatistics::UpdateAfterLoad(); // Ensure statistics pool is initialised before trying to delete vehicles
1989 /* Remove all trams from savegames without tram support.
1990 * There would be trams without tram track under causing crashes sooner or later. */
1991 for (RoadVehicle *v : RoadVehicle::Iterate()) {
1992 if (v->First() == v && EngInfo(v->engine_type)->misc_flags.Test(EngineMiscFlag::RoadIsTram)) {
1993 ShowErrorMessage(GetEncodedString(STR_WARNING_LOADGAME_REMOVED_TRAMS), {}, WL_CRITICAL);
1994 delete v;
1995 }
1996 }
1997 }
1998
1999 if (IsSavegameVersionBefore(SLV_99)) {
2000 for (auto t : Map::Iterate()) {
2001 /* Set newly introduced WaterClass of industry tiles */
2002 if (IsTileType(t, MP_STATION) && IsOilRig(t)) {
2003 SetWaterClassDependingOnSurroundings(t, true);
2004 }
2005 if (IsTileType(t, MP_INDUSTRY)) {
2006 if (GetIndustrySpec(GetIndustryType(t))->behaviour.Test(IndustryBehaviour::BuiltOnWater)) {
2007 SetWaterClassDependingOnSurroundings(t, true);
2008 } else {
2009 SetWaterClass(t, WaterClass::Invalid);
2010 }
2011 }
2012
2013 /* Replace "house construction year" with "house age" */
2014 if (IsTileType(t, MP_HOUSE) && IsHouseCompleted(t)) {
2015 t.m5() = ClampTo<uint8_t>(TimerGameCalendar::year - (CalendarTime::ORIGINAL_BASE_YEAR + t.m5()));
2016 }
2017 }
2018 }
2019
2020 /* Move the signal variant back up one bit for PBS. We don't convert the old PBS
2021 * format here, as an old layout wouldn't work properly anyway. To be safe, we
2022 * clear any possible PBS reservations as well. */
2023 if (IsSavegameVersionBefore(SLV_100)) {
2024 for (auto t : Map::Iterate()) {
2025 switch (GetTileType(t)) {
2026 case MP_RAILWAY:
2027 if (HasSignals(t)) {
2028 /* move the signal variant */
2029 SetSignalVariant(t, TRACK_UPPER, HasBit(t.m2(), 2) ? SIG_SEMAPHORE : SIG_ELECTRIC);
2030 SetSignalVariant(t, TRACK_LOWER, HasBit(t.m2(), 6) ? SIG_SEMAPHORE : SIG_ELECTRIC);
2031 ClrBit(t.m2(), 2);
2032 ClrBit(t.m2(), 6);
2033 }
2034
2035 /* Clear PBS reservation on track */
2036 if (IsRailDepot(t)) {
2037 SetDepotReservation(t, false);
2038 } else {
2039 SetTrackReservation(t, TRACK_BIT_NONE);
2040 }
2041 break;
2042
2043 case MP_ROAD: // Clear PBS reservation on crossing
2044 if (IsLevelCrossing(t)) SetCrossingReservation(t, false);
2045 break;
2046
2047 case MP_STATION: // Clear PBS reservation on station
2048 if (HasStationRail(t)) SetRailStationReservation(t, false);
2049 break;
2050
2051 case MP_TUNNELBRIDGE: // Clear PBS reservation on tunnels/bridges
2052 if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) SetTunnelBridgeReservation(t, false);
2053 break;
2054
2055 default: break;
2056 }
2057 }
2058 }
2059
2060 /* Reserve all tracks trains are currently on. */
2061 if (IsSavegameVersionBefore(SLV_101)) {
2062 for (const Train *t : Train::Iterate()) {
2063 if (t->First() == t) t->ReserveTrackUnderConsist();
2064 }
2065 }
2066
2067 if (IsSavegameVersionBefore(SLV_103)) {
2068 /* Non-town-owned roads now store the closest town */
2069 UpdateNearestTownForRoadTiles(false);
2070
2071 /* signs with invalid owner left from older savegames */
2072 for (Sign *si : Sign::Iterate()) {
2073 if (si->owner != OWNER_NONE && !Company::IsValidID(si->owner)) si->owner = OWNER_NONE;
2074 }
2075
2076 /* Station can get named based on an industry type, but the current ones
2077 * are not, so mark them as if they are not named by an industry. */
2078 for (Station *st : Station::Iterate()) {
2079 st->indtype = IT_INVALID;
2080 }
2081 }
2082
2083 if (IsSavegameVersionBefore(SLV_104)) {
2084 for (Aircraft *a : Aircraft::Iterate()) {
2085 /* Set engine_type of shadow and rotor */
2086 if (!a->IsNormalAircraft()) {
2087 a->engine_type = a->First()->engine_type;
2088 }
2089 }
2090
2091 /* More companies ... */
2092 for (Company *c : Company::Iterate()) {
2093 if (c->bankrupt_asked.base() == 0xFF) c->bankrupt_asked.Set();
2094 }
2095
2096 for (Engine *e : Engine::Iterate()) {
2097 if (e->company_avail.base() == 0xFF) e->company_avail.Set();
2098 }
2099
2100 for (Town *t : Town::Iterate()) {
2101 if (t->have_ratings.base() == 0xFF) t->have_ratings.Set();
2102 for (uint i = 8; i != MAX_COMPANIES; i++) t->ratings[i] = RATING_INITIAL;
2103 }
2104 }
2105
2106 if (IsSavegameVersionBefore(SLV_112)) {
2107 for (auto t : Map::Iterate()) {
2108 /* Check for HQ bit being set, instead of using map accessor,
2109 * since we've already changed it code-wise */
2110 if (IsTileType(t, MP_OBJECT) && HasBit(t.m5(), 7)) {
2111 /* Move size and part identification of HQ out of the m5 attribute,
2112 * on new locations */
2113 t.m3() = GB(t.m5(), 0, 5);
2114 t.m5() = OBJECT_HQ;
2115 }
2116 }
2117 }
2118 if (IsSavegameVersionBefore(SLV_144)) {
2119 for (auto t : Map::Iterate()) {
2120 if (!IsTileType(t, MP_OBJECT)) continue;
2121
2122 /* Reordering/generalisation of the object bits. */
2123 ObjectType type = t.m5();
2124 SB(t.m6(), 2, 4, type == OBJECT_HQ ? GB(t.m3(), 2, 3) : 0);
2125 t.m3() = type == OBJECT_HQ ? GB(t.m3(), 1, 1) | GB(t.m3(), 0, 1) << 4 : 0;
2126
2127 /* Make sure those bits are clear as well! */
2128 t.m4() = 0;
2129 t.m7() = 0;
2130 }
2131 }
2132
2133 if (IsSavegameVersionBefore(SLV_147) && Object::GetNumItems() == 0) {
2134 /* Make real objects for object tiles. */
2135 for (auto t : Map::Iterate()) {
2136 if (!IsTileType(t, MP_OBJECT)) continue;
2137
2138 if (Town::GetNumItems() == 0) {
2139 /* No towns, so remove all objects! */
2140 DoClearSquare(t);
2141 } else {
2142 uint offset = t.m3();
2143
2144 /* Also move the animation state. */
2145 t.m3() = GB(t.m6(), 2, 4);
2146 SB(t.m6(), 2, 4, 0);
2147
2148 if (offset == 0) {
2149 /* No offset, so make the object. */
2150 ObjectType type = t.m5();
2151 int size = type == OBJECT_HQ ? 2 : 1;
2152
2153 if (!Object::CanAllocateItem()) {
2154 /* Nice... you managed to place 64k lighthouses and
2155 * antennae on the map... boohoo. */
2156 SlError(STR_ERROR_TOO_MANY_OBJECTS);
2157 }
2158
2159 Object *o = new Object();
2160 o->location.tile = (TileIndex)t;
2161 o->location.w = size;
2162 o->location.h = size;
2163 o->build_date = TimerGameCalendar::date;
2164 o->town = type == OBJECT_STATUE ? Town::Get(t.m2()) : CalcClosestTownFromTile(t, UINT_MAX);
2165 t.m2() = o->index.base();
2166 Object::IncTypeCount(type);
2167 } else {
2168 /* We're at an offset, so get the ID from our "root". */
2169 Tile northern_tile = t - TileXY(GB(offset, 0, 4), GB(offset, 4, 4));
2170 assert(IsTileType(northern_tile, MP_OBJECT));
2171 t.m2() = northern_tile.m2();
2172 }
2173 }
2174 }
2175 }
2176
2177 if (IsSavegameVersionBefore(SLV_113)) {
2178 /* allow_town_roads is added, set it if town_layout wasn't TL_NO_ROADS */
2179 if (_settings_game.economy.town_layout == 0) { // was TL_NO_ROADS
2180 _settings_game.economy.allow_town_roads = false;
2181 _settings_game.economy.town_layout = TL_BETTER_ROADS;
2182 } else {
2183 _settings_game.economy.allow_town_roads = true;
2184 _settings_game.economy.town_layout = static_cast<TownLayout>(_settings_game.economy.town_layout - 1);
2185 }
2186
2187 /* Initialize layout of all towns. Older versions were using different
2188 * generator for random town layout, use it if needed. */
2189 for (Town *t : Town::Iterate()) {
2190 if (_settings_game.economy.town_layout != TL_RANDOM) {
2191 t->layout = _settings_game.economy.town_layout;
2192 continue;
2193 }
2194
2195 /* Use old layout randomizer code */
2196 uint8_t layout = TileHash(TileX(t->xy), TileY(t->xy)) % 6;
2197 switch (layout) {
2198 default: break;
2199 case 5: layout = 1; break;
2200 case 0: layout = 2; break;
2201 }
2202 t->layout = static_cast<TownLayout>(layout - 1);
2203 }
2204 }
2205
2206 if (IsSavegameVersionBefore(SLV_114)) {
2207 /* There could be (deleted) stations with invalid owner, set owner to OWNER NONE.
2208 * The conversion affects oil rigs and buoys too, but it doesn't matter as
2209 * they have st->owner == OWNER_NONE already. */
2210 for (Station *st : Station::Iterate()) {
2211 if (!Company::IsValidID(st->owner)) st->owner = OWNER_NONE;
2212 }
2213 }
2214
2215 /* Trains could now stop in a specific location. */
2216 if (IsSavegameVersionBefore(SLV_117)) {
2217 for (OrderList *orderlist : OrderList::Iterate()) {
2218 for (Order &o : orderlist->GetOrders()) {
2219 if (o.IsType(OT_GOTO_STATION)) o.SetStopLocation(OrderStopLocation::FarEnd);
2220 }
2221 }
2222 }
2223
2224 if (IsSavegameVersionBefore(SLV_120)) {
2225 extern VehicleDefaultSettings _old_vds;
2226 for (Company *c : Company::Iterate()) {
2227 c->settings.vehicle = _old_vds;
2228 }
2229 }
2230
2231 if (IsSavegameVersionBefore(SLV_121)) {
2232 /* Delete small ufos heading for non-existing vehicles */
2233 for (DisasterVehicle *v : DisasterVehicle::Iterate()) {
2234 if (v->subtype == 2 /* ST_SMALL_UFO */ && v->state != 0) {
2235 const Vehicle *u = Vehicle::GetIfValid(v->dest_tile.base());
2236 if (u == nullptr || u->type != VEH_ROAD || !RoadVehicle::From(u)->IsFrontEngine()) {
2237 delete v;
2238 }
2239 }
2240 }
2241
2242 /* We didn't store cargo payment yet, so make them for vehicles that are
2243 * currently at a station and loading/unloading. If they don't get any
2244 * payment anymore they just removed in the next load/unload cycle.
2245 * However, some 0.7 versions might have cargo payment. For those we just
2246 * add cargopayment for the vehicles that don't have it.
2247 */
2248 for (Station *st : Station::Iterate()) {
2249 for (Vehicle *v : st->loading_vehicles) {
2250 /* There are always as many CargoPayments as Vehicles. We need to make the
2251 * assert() in Pool::GetNew() happy by calling CanAllocateItem(). */
2252 static_assert(CargoPaymentPool::MAX_SIZE == VehiclePool::MAX_SIZE);
2253 assert(CargoPayment::CanAllocateItem());
2254 if (v->cargo_payment == nullptr) v->cargo_payment = new CargoPayment(v);
2255 }
2256 }
2257 }
2258
2259 if (IsSavegameVersionBefore(SLV_122)) {
2260 /* Animated tiles would sometimes not be actually animated or
2261 * in case of old savegames duplicate. */
2262
2263 extern std::vector<TileIndex> _animated_tiles;
2264
2265 for (auto tile = _animated_tiles.begin(); tile < _animated_tiles.end(); /* Nothing */) {
2266 /* Remove if tile is not animated */
2267 bool remove = !MayAnimateTile(*tile);
2268
2269 /* and remove if duplicate */
2270 for (auto j = _animated_tiles.begin(); !remove && j < tile; j++) {
2271 remove = *tile == *j;
2272 }
2273
2274 if (remove) {
2275 tile = _animated_tiles.erase(tile);
2276 } else {
2277 tile++;
2278 }
2279 }
2280 }
2281
2282 if (IsSavegameVersionBefore(SLV_NONFLOODING_WATER_TILES)) {
2283 for (auto t : Map::Iterate()) {
2284 if (!IsTileType(t, MP_WATER)) continue;
2285 SetNonFloodingWaterTile(t, false);
2286 }
2287 }
2288
2289 if (IsSavegameVersionBefore(SLV_ANIMATED_TILE_STATE_IN_MAP)) {
2290 /* Animated tile state is stored in the map array, allowing
2291 * quicker addition and deletion of animated tiles. */
2292
2293 extern std::vector<TileIndex> _animated_tiles;
2294
2295 for (auto t : Map::Iterate()) {
2296 /* Ensure there is no spurious animated tile state. */
2297 if (MayAnimateTile(t)) SetAnimatedTileState(t, AnimatedTileState::None);
2298 }
2299
2300 /* Set animated flag for all valid animated tiles. */
2301 for (const TileIndex &tile : _animated_tiles) {
2302 if (tile != INVALID_TILE) SetAnimatedTileState(tile, AnimatedTileState::Animated);
2303 }
2304 }
2305
2306 if (IsSavegameVersionBefore(SLV_124) && !IsSavegameVersionBefore(SLV_1)) {
2307 /* The train station tile area was added, but for really old (TTDPatch) it's already valid. */
2308 for (Waypoint *wp : Waypoint::Iterate()) {
2309 if (wp->facilities.Test(StationFacility::Train)) {
2310 wp->train_station.tile = wp->xy;
2311 wp->train_station.w = 1;
2312 wp->train_station.h = 1;
2313 } else {
2314 wp->train_station.tile = INVALID_TILE;
2315 wp->train_station.w = 0;
2316 wp->train_station.h = 0;
2317 }
2318 }
2319 }
2320
2321 if (IsSavegameVersionBefore(SLV_125)) {
2322 /* Convert old subsidies */
2323 for (Subsidy *s : Subsidy::Iterate()) {
2324 if (s->remaining < 12) {
2325 /* Converting nonawarded subsidy */
2326 s->remaining = 12 - s->remaining; // convert "age" to "remaining"
2327 s->awarded = CompanyID::Invalid(); // not awarded to anyone
2328 const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
2329 switch (cs->town_acceptance_effect) {
2330 case TAE_PASSENGERS:
2331 case TAE_MAIL:
2332 /* Town -> Town */
2333 s->src.type = s->dst.type = SourceType::Town;
2334 if (Town::IsValidID(s->src.ToTownID()) && Town::IsValidID(s->dst.ToTownID())) continue;
2335 break;
2336 case TAE_GOODS:
2337 case TAE_FOOD:
2338 /* Industry -> Town */
2339 s->src.type = SourceType::Industry;
2340 s->dst.type = SourceType::Town;
2341 if (Industry::IsValidID(s->src.ToIndustryID()) && Town::IsValidID(s->dst.ToTownID())) continue;
2342 break;
2343 default:
2344 /* Industry -> Industry */
2345 s->src.type = s->dst.type = SourceType::Industry;
2346 if (Industry::IsValidID(s->src.ToIndustryID()) && Industry::IsValidID(s->dst.ToIndustryID())) continue;
2347 break;
2348 }
2349 } else {
2350 /* Do our best for awarded subsidies. The original source or destination industry
2351 * can't be determined anymore for awarded subsidies, so invalidate them.
2352 * Town -> Town subsidies are converted using simple heuristic */
2353 s->remaining = 24 - s->remaining; // convert "age of awarded subsidy" to "remaining"
2354 const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
2355 switch (cs->town_acceptance_effect) {
2356 case TAE_PASSENGERS:
2357 case TAE_MAIL: {
2358 /* Town -> Town */
2359 const Station *ss = Station::GetIfValid(s->src.id);
2360 const Station *sd = Station::GetIfValid(s->dst.id);
2361 if (ss != nullptr && sd != nullptr && ss->owner == sd->owner &&
2362 Company::IsValidID(ss->owner)) {
2363 s->src.type = s->dst.type = SourceType::Town;
2364 s->src.SetIndex(ss->town->index);
2365 s->dst.SetIndex(sd->town->index);
2366 s->awarded = ss->owner;
2367 continue;
2368 }
2369 break;
2370 }
2371 default:
2372 break;
2373 }
2374 }
2375 /* Awarded non-town subsidy or invalid source/destination, invalidate */
2376 delete s;
2377 }
2378 }
2379
2380 if (IsSavegameVersionBefore(SLV_126)) {
2381 /* Recompute inflation based on old unround loan limit
2382 * Note: Max loan is 500000. With an inflation of 4% across 170 years
2383 * that results in a max loan of about 0.7 * 2^31.
2384 * So taking the 16 bit fractional part into account there are plenty of bits left
2385 * for unmodified savegames ...
2386 */
2387 uint64_t aimed_inflation = (_economy.old_max_loan_unround << 16 | _economy.old_max_loan_unround_fract) / _settings_game.difficulty.max_loan;
2388
2389 /* ... well, just clamp it then. */
2390 if (aimed_inflation > MAX_INFLATION) aimed_inflation = MAX_INFLATION;
2391
2392 /* Simulate the inflation, so we also get the payment inflation */
2393 while (_economy.inflation_prices < aimed_inflation) {
2394 if (AddInflation(false)) break;
2395 }
2396 }
2397
2398 if (IsSavegameVersionBefore(SLV_128)) {
2399 for (const Depot *d : Depot::Iterate()) {
2400 Tile tile = d->xy;
2401 /* At some point, invalid depots were saved into the game (possibly those removed in the past?)
2402 * Remove them here, so they don't cause issues further down the line */
2403 if (!IsDepotTile(tile)) {
2404 Debug(sl, 0, "Removing invalid depot {} at {}, {}", d->index, TileX(d->xy), TileY(d->xy));
2405 delete d;
2406 d = nullptr;
2407 continue;
2408 }
2409 tile.m2() = d->index.base();
2410 if (IsTileType(tile, MP_WATER)) Tile(GetOtherShipDepotTile(tile)).m2() = d->index.base();
2411 }
2412 }
2413
2414 /* The behaviour of force_proceed has been changed. Now
2415 * it counts signals instead of some random time out. */
2416 if (IsSavegameVersionBefore(SLV_131)) {
2417 for (Train *t : Train::Iterate()) {
2418 if (t->force_proceed != TFP_NONE) {
2419 t->force_proceed = TFP_STUCK;
2420 }
2421 }
2422 }
2423
2424 /* The bits for the tree ground and tree density have
2425 * been swapped (m2 bits 7..6 and 5..4. */
2426 if (IsSavegameVersionBefore(SLV_135)) {
2427 for (auto t : Map::Iterate()) {
2428 if (IsTileType(t, MP_CLEAR)) {
2429 if (GetClearGround(t) == CLEAR_SNOW) { // CLEAR_SNOW becomes CLEAR_GRASS with IsSnowTile() set.
2430 SetClearGroundDensity(t, CLEAR_GRASS, GetClearDensity(t));
2431 SetBit(t.m3(), 4);
2432 } else {
2433 ClrBit(t.m3(), 4);
2434 }
2435 }
2436 if (IsTileType(t, MP_TREES)) {
2437 uint density = GB(t.m2(), 6, 2);
2438 uint ground = GB(t.m2(), 4, 2);
2439 t.m2() = ground << 6 | density << 4;
2440 }
2441 }
2442 }
2443
2444 /* Wait counter and load/unload ticks got split. */
2445 if (IsSavegameVersionBefore(SLV_136)) {
2446 for (Aircraft *a : Aircraft::Iterate()) {
2447 a->turn_counter = a->current_order.IsType(OT_LOADING) ? 0 : a->load_unload_ticks;
2448 }
2449
2450 for (Train *t : Train::Iterate()) {
2451 t->wait_counter = t->current_order.IsType(OT_LOADING) ? 0 : t->load_unload_ticks;
2452 }
2453 }
2454
2455 /* Airport tile animation uses animation frame instead of other graphics id */
2456 if (IsSavegameVersionBefore(SLV_137)) {
2457 struct AirportTileConversion {
2458 uint8_t old_start;
2459 uint8_t num_frames;
2460 };
2461 static const AirportTileConversion atcs[] = {
2462 {31, 12}, // APT_RADAR_GRASS_FENCE_SW
2463 {50, 4}, // APT_GRASS_FENCE_NE_FLAG
2464 {62, 2}, // 1 unused tile
2465 {66, 12}, // APT_RADAR_FENCE_SW
2466 {78, 12}, // APT_RADAR_FENCE_NE
2467 {101, 10}, // 9 unused tiles
2468 {111, 8}, // 7 unused tiles
2469 {119, 15}, // 14 unused tiles (radar)
2470 {140, 4}, // APT_GRASS_FENCE_NE_FLAG_2
2471 };
2472 for (const auto t : Map::Iterate()) {
2473 if (IsAirportTile(t)) {
2474 StationGfx old_gfx = GetStationGfx(t);
2475 uint8_t offset = 0;
2476 for (const auto &atc : atcs) {
2477 if (old_gfx < atc.old_start) {
2478 SetStationGfx(t, old_gfx - offset);
2479 break;
2480 }
2481 if (old_gfx < atc.old_start + atc.num_frames) {
2482 SetAnimationFrame(t, old_gfx - atc.old_start);
2483 SetStationGfx(t, atc.old_start - offset);
2484 break;
2485 }
2486 offset += atc.num_frames - 1;
2487 }
2488 }
2489 }
2490 }
2491
2492 /* Oilrig was moved from id 15 to 9. */
2493 if (IsSavegameVersionBefore(SLV_139)) {
2494 for (Station *st : Station::Iterate()) {
2495 if (st->airport.tile != INVALID_TILE && st->airport.type == 15) {
2496 st->airport.type = AT_OILRIG;
2497 }
2498 }
2499 }
2500
2501 if (IsSavegameVersionBefore(SLV_140)) {
2502 for (Station *st : Station::Iterate()) {
2503 if (st->airport.tile != INVALID_TILE) {
2504 st->airport.w = st->airport.GetSpec()->size_x;
2505 st->airport.h = st->airport.GetSpec()->size_y;
2506 }
2507 }
2508 }
2509
2510 if (IsSavegameVersionBefore(SLV_141)) {
2511 for (const auto t : Map::Iterate()) {
2512 /* Reset tropic zone for VOID tiles, they shall not have any. */
2513 if (IsTileType(t, MP_VOID)) SetTropicZone(t, TROPICZONE_NORMAL);
2514 }
2515
2516 /* We need to properly number/name the depots.
2517 * The first step is making sure none of the depots uses the
2518 * 'default' names, after that we can assign the names. */
2519 for (Depot *d : Depot::Iterate()) d->town_cn = UINT16_MAX;
2520
2521 for (Depot *d : Depot::Iterate()) MakeDefaultName(d);
2522 }
2523
2524 if (IsSavegameVersionBefore(SLV_142)) {
2525 for (Depot *d : Depot::Iterate()) d->build_date = TimerGameCalendar::date;
2526 }
2527
2528 if (IsSavegameVersionBefore(SLV_145)) {
2529 for (Station *st : Station::Iterate()) {
2530 if (st->facilities.Test(StationFacility::Airport)) st->airport.rotation = DIR_N;
2531 }
2532 }
2533
2534 /* In old versions it was possible to remove an airport while a plane was
2535 * taking off or landing. This gives all kind of problems when building
2536 * another airport in the same station so we don't allow that anymore.
2537 * For old savegames with such aircraft we just throw them in the air and
2538 * treat the aircraft like they were flying already. */
2539 if (IsSavegameVersionBefore(SLV_146)) {
2540 for (Aircraft *v : Aircraft::Iterate()) {
2541 if (!v->IsNormalAircraft()) continue;
2542 Station *st = GetTargetAirportIfValid(v);
2543 if (st == nullptr && v->state != FLYING) {
2544 v->state = FLYING;
2545 UpdateAircraftCache(v);
2546 AircraftNextAirportPos_and_Order(v);
2547 /* get aircraft back on running altitude */
2548 if (!v->vehstatus.Test(VehState::Crashed)) {
2549 GetAircraftFlightLevelBounds(v, &v->z_pos, nullptr);
2550 SetAircraftPosition(v, v->x_pos, v->y_pos, GetAircraftFlightLevel(v));
2551 }
2552 }
2553 }
2554 }
2555
2556 /* Move the animation frame to the same location (m7) for all objects. */
2557 if (IsSavegameVersionBefore(SLV_147)) {
2558 for (auto t : Map::Iterate()) {
2559 switch (GetTileType(t)) {
2560 case MP_HOUSE:
2561 if (GetHouseType(t) >= NEW_HOUSE_OFFSET) {
2562 uint per_proc = t.m7();
2563 t.m7() = GB(t.m6(), 2, 6) | (GB(t.m3(), 5, 1) << 6);
2564 SB(t.m3(), 5, 1, 0);
2565 SB(t.m6(), 2, 6, std::min(per_proc, 63U));
2566 }
2567 break;
2568
2569 case MP_INDUSTRY: {
2570 uint rand = t.m7();
2571 t.m7() = t.m3();
2572 t.m3() = rand;
2573 break;
2574 }
2575
2576 case MP_OBJECT:
2577 t.m7() = t.m3();
2578 t.m3() = 0;
2579 break;
2580
2581 default:
2582 /* For stations/airports it's already at m7 */
2583 break;
2584 }
2585 }
2586 }
2587
2588 /* Add (random) colour to all objects. */
2589 if (IsSavegameVersionBefore(SLV_148)) {
2590 for (Object *o : Object::Iterate()) {
2591 Owner owner = GetTileOwner(o->location.tile);
2592 o->colour = (owner == OWNER_NONE) ? static_cast<Colours>(GB(Random(), 0, 4)) : Company::Get(owner)->livery[0].colour1;
2593 }
2594 }
2595
2596 if (IsSavegameVersionBefore(SLV_149)) {
2597 for (const auto t : Map::Iterate()) {
2598 if (!IsTileType(t, MP_STATION)) continue;
2599 if (!IsBuoy(t) && !IsOilRig(t) && !(IsDock(t) && IsTileFlat(t))) {
2600 SetWaterClass(t, WaterClass::Invalid);
2601 }
2602 }
2603
2604 /* Waypoints with custom name may have a non-unique town_cn,
2605 * renumber those. First set all affected waypoints to the
2606 * highest possible number to get them numbered in the
2607 * order they have in the pool. */
2608 for (Waypoint *wp : Waypoint::Iterate()) {
2609 if (!wp->name.empty()) wp->town_cn = UINT16_MAX;
2610 }
2611
2612 for (Waypoint *wp : Waypoint::Iterate()) {
2613 if (!wp->name.empty()) MakeDefaultName(wp);
2614 }
2615 }
2616
2617 if (IsSavegameVersionBefore(SLV_152)) {
2618 _industry_builder.Reset(); // Initialize industry build data.
2619
2620 /* The moment vehicles go from hidden to visible changed. This means
2621 * that vehicles don't always get visible anymore causing things to
2622 * get messed up just after loading the savegame. This fixes that. */
2623 for (Vehicle *v : Vehicle::Iterate()) {
2624 /* Not all vehicle types can be inside a tunnel. Furthermore,
2625 * testing IsTunnelTile() for invalid tiles causes a crash. */
2626 if (!v->IsGroundVehicle()) continue;
2627
2628 /* Is the vehicle in a tunnel? */
2629 if (!IsTunnelTile(v->tile)) continue;
2630
2631 /* Is the vehicle actually at a tunnel entrance/exit? */
2632 TileIndex vtile = TileVirtXY(v->x_pos, v->y_pos);
2633 if (!IsTunnelTile(vtile)) continue;
2634
2635 /* Are we actually in this tunnel? Or maybe a lower tunnel? */
2636 if (GetSlopePixelZ(v->x_pos, v->y_pos, true) != v->z_pos) continue;
2637
2638 /* What way are we going? */
2639 const DiagDirection dir = GetTunnelBridgeDirection(vtile);
2640 const DiagDirection vdir = DirToDiagDir(v->direction);
2641
2642 /* Have we passed the visibility "switch" state already? */
2643 uint8_t pos = (DiagDirToAxis(vdir) == AXIS_X ? v->x_pos : v->y_pos) & TILE_UNIT_MASK;
2644 uint8_t frame = (vdir == DIAGDIR_NE || vdir == DIAGDIR_NW) ? TILE_SIZE - 1 - pos : pos;
2645 extern const uint8_t _tunnel_visibility_frame[DIAGDIR_END];
2646
2647 /* Should the vehicle be hidden or not? */
2648 bool hidden;
2649 if (dir == vdir) { // Entering tunnel
2650 hidden = frame >= _tunnel_visibility_frame[dir];
2651 v->tile = vtile;
2652 } else if (dir == ReverseDiagDir(vdir)) { // Leaving tunnel
2653 hidden = frame < TILE_SIZE - _tunnel_visibility_frame[dir];
2654 /* v->tile changes at the moment when the vehicle leaves the tunnel. */
2655 v->tile = hidden ? GetOtherTunnelBridgeEnd(vtile) : vtile;
2656 } else {
2657 /* We could get here in two cases:
2658 * - for road vehicles, it is reversing at the end of the tunnel
2659 * - it is crashed in the tunnel entry (both train or RV destroyed by UFO)
2660 * Whatever case it is, do not change anything and use the old values.
2661 * Especially changing RV's state would break its reversing in the middle. */
2662 continue;
2663 }
2664
2665 if (hidden) {
2666 v->vehstatus.Set(VehState::Hidden);
2667
2668 switch (v->type) {
2669 case VEH_TRAIN: Train::From(v)->track = TRACK_BIT_WORMHOLE; break;
2670 case VEH_ROAD: RoadVehicle::From(v)->state = RVSB_WORMHOLE; break;
2671 default: NOT_REACHED();
2672 }
2673 } else {
2674 v->vehstatus.Reset(VehState::Hidden);
2675
2676 switch (v->type) {
2677 case VEH_TRAIN: Train::From(v)->track = DiagDirToDiagTrackBits(vdir); break;
2678 case VEH_ROAD: RoadVehicle::From(v)->state = DiagDirToDiagTrackdir(vdir); RoadVehicle::From(v)->frame = frame; break;
2679 default: NOT_REACHED();
2680 }
2681 }
2682 }
2683 }
2684
2685 if (IsSavegameVersionBefore(SLV_153)) {
2686 for (RoadVehicle *rv : RoadVehicle::Iterate()) {
2687 if (rv->state == RVSB_IN_DEPOT || rv->state == RVSB_WORMHOLE) continue;
2688
2689 bool loading = rv->current_order.IsType(OT_LOADING) || rv->current_order.IsType(OT_LEAVESTATION);
2690 if (HasBit(rv->state, RVS_IN_ROAD_STOP)) {
2691 extern const uint8_t _road_stop_stop_frame[];
2692 SB(rv->state, RVS_ENTERED_STOP, 1, loading || rv->frame > _road_stop_stop_frame[rv->state - RVSB_IN_ROAD_STOP + (_settings_game.vehicle.road_side << RVS_DRIVE_SIDE)]);
2693 } else if (HasBit(rv->state, RVS_IN_DT_ROAD_STOP)) {
2694 SB(rv->state, RVS_ENTERED_STOP, 1, loading || rv->frame > RVC_DRIVE_THROUGH_STOP_FRAME);
2695 }
2696 }
2697 }
2698
2699 if (IsSavegameVersionBefore(SLV_156)) {
2700 /* The train's pathfinder lost flag got moved. */
2701 for (Train *t : Train::Iterate()) {
2702 if (!t->flags.Test(VehicleRailFlag{5})) continue;
2703
2704 t->flags.Reset(VehicleRailFlag{5});
2705 t->vehicle_flags.Set(VehicleFlag::PathfinderLost);
2706 }
2707
2708 /* Introduced terraform/clear limits. */
2709 for (Company *c : Company::Iterate()) {
2710 c->terraform_limit = _settings_game.construction.terraform_frame_burst << 16;
2711 c->clear_limit = _settings_game.construction.clear_frame_burst << 16;
2712 }
2713 }
2714
2715
2716 if (IsSavegameVersionBefore(SLV_CONSISTENT_PARTIAL_Z)) {
2717 /*
2718 * The logic of GetPartialPixelZ has been changed, so the resulting Zs on
2719 * the map are consistent. This requires that the Z position of some
2720 * vehicles is updated to reflect this new situation.
2721 *
2722 * This needs to be before SLV_158, because that performs asserts using
2723 * GetSlopePixelZ which internally uses GetPartialPixelZ.
2724 */
2725 for (Vehicle *v : Vehicle::Iterate()) {
2726 if (v->IsGroundVehicle() && TileVirtXY(v->x_pos, v->y_pos) == v->tile) {
2727 /* Vehicle is on the ground, and not in a wormhole. */
2728 v->z_pos = GetSlopePixelZ(v->x_pos, v->y_pos, true);
2729 }
2730 }
2731 }
2732
2733 if (IsSavegameVersionBefore(SLV_158)) {
2734 for (Vehicle *v : Vehicle::Iterate()) {
2735 switch (v->type) {
2736 case VEH_TRAIN: {
2737 Train *t = Train::From(v);
2738
2739 /* Clear old GOINGUP / GOINGDOWN flags.
2740 * It was changed in savegame version 139, but savegame
2741 * version 158 doesn't use these bits, so it doesn't hurt
2742 * to clear them unconditionally. */
2743 t->flags.Reset(VehicleRailFlag{1});
2744 t->flags.Reset(VehicleRailFlag{2});
2745
2746 /* Clear both bits first. */
2747 ClrBit(t->gv_flags, GVF_GOINGUP_BIT);
2748 ClrBit(t->gv_flags, GVF_GOINGDOWN_BIT);
2749
2750 /* Crashed vehicles can't be going up/down. */
2751 if (t->vehstatus.Test(VehState::Crashed)) break;
2752
2753 /* Only X/Y tracks can be sloped. */
2754 if (t->track != TRACK_BIT_X && t->track != TRACK_BIT_Y) break;
2755
2756 t->gv_flags |= FixVehicleInclination(t, t->direction);
2757 break;
2758 }
2759 case VEH_ROAD: {
2760 RoadVehicle *rv = RoadVehicle::From(v);
2761 ClrBit(rv->gv_flags, GVF_GOINGUP_BIT);
2762 ClrBit(rv->gv_flags, GVF_GOINGDOWN_BIT);
2763
2764 /* Crashed vehicles can't be going up/down. */
2765 if (rv->vehstatus.Test(VehState::Crashed)) break;
2766
2767 if (rv->state == RVSB_IN_DEPOT || rv->state == RVSB_WORMHOLE) break;
2768
2769 TrackStatus ts = GetTileTrackStatus(rv->tile, TRANSPORT_ROAD, GetRoadTramType(rv->roadtype));
2770 TrackBits trackbits = TrackStatusToTrackBits(ts);
2771
2772 /* Only X/Y tracks can be sloped. */
2773 if (trackbits != TRACK_BIT_X && trackbits != TRACK_BIT_Y) break;
2774
2775 Direction dir = rv->direction;
2776
2777 /* Test if we are reversing. */
2778 Axis a = trackbits == TRACK_BIT_X ? AXIS_X : AXIS_Y;
2779 if (AxisToDirection(a) != dir &&
2780 AxisToDirection(a) != ReverseDir(dir)) {
2781 /* When reversing, the road vehicle is on the edge of the tile,
2782 * so it can be safely compared to the middle of the tile. */
2783 dir = INVALID_DIR;
2784 }
2785
2786 rv->gv_flags |= FixVehicleInclination(rv, dir);
2787 break;
2788 }
2789 case VEH_SHIP:
2790 break;
2791
2792 default:
2793 continue;
2794 }
2795
2796 if (IsBridgeTile(v->tile) && TileVirtXY(v->x_pos, v->y_pos) == v->tile) {
2797 /* In old versions, z_pos was 1 unit lower on bridge heads.
2798 * However, this invalid state could be converted to new savegames
2799 * by loading and saving the game in a new version. */
2800 v->z_pos = GetSlopePixelZ(v->x_pos, v->y_pos, true);
2801 DiagDirection dir = GetTunnelBridgeDirection(v->tile);
2802 if (v->type == VEH_TRAIN && !v->vehstatus.Test(VehState::Crashed) &&
2803 v->direction != DiagDirToDir(dir)) {
2804 /* If the train has left the bridge, it shouldn't have
2805 * track == TRACK_BIT_WORMHOLE - this could happen
2806 * when the train was reversed while on the last "tick"
2807 * on the ramp before leaving the ramp to the bridge. */
2808 Train::From(v)->track = DiagDirToDiagTrackBits(dir);
2809 }
2810 }
2811
2812 /* If the vehicle is really above v->tile (not in a wormhole),
2813 * it should have set v->z_pos correctly. */
2814 assert(v->tile != TileVirtXY(v->x_pos, v->y_pos) || v->z_pos == GetSlopePixelZ(v->x_pos, v->y_pos, true));
2815 }
2816
2817 /* Fill Vehicle::cur_real_order_index */
2818 for (Vehicle *v : Vehicle::Iterate()) {
2819 if (!v->IsPrimaryVehicle()) continue;
2820
2821 /* Older versions are less strict with indices being in range and fix them on the fly */
2822 if (v->cur_implicit_order_index >= v->GetNumOrders()) v->cur_implicit_order_index = 0;
2823
2824 v->cur_real_order_index = v->cur_implicit_order_index;
2825 v->UpdateRealOrderIndex();
2826 }
2827 }
2828
2829 if (IsSavegameVersionBefore(SLV_159)) {
2830 /* If the savegame is old (before version 100), then the value of 255
2831 * for these settings did not mean "disabled". As such everything
2832 * before then did reverse.
2833 * To simplify stuff we disable all turning around or we do not
2834 * disable anything at all. So, if some reversing was disabled we
2835 * will keep reversing disabled, otherwise it'll be turned on. */
2836 _settings_game.pf.reverse_at_signals = IsSavegameVersionBefore(SLV_100) || (_settings_game.pf.wait_oneway_signal != 255 && _settings_game.pf.wait_twoway_signal != 255 && _settings_game.pf.wait_for_pbs_path != 255);
2837
2838 for (Train *t : Train::Iterate()) {
2839 _settings_game.vehicle.max_train_length = std::max<uint8_t>(_settings_game.vehicle.max_train_length, CeilDiv(t->gcache.cached_total_length, TILE_SIZE));
2840 }
2841 }
2842
2843 if (IsSavegameVersionBefore(SLV_160)) {
2844 /* Setting difficulty industry_density other than zero get bumped to +1
2845 * since a new option (minimal at position 1) has been added */
2846 if (_settings_game.difficulty.industry_density > 0) {
2847 _settings_game.difficulty.industry_density++;
2848 }
2849 }
2850
2851 if (IsSavegameVersionBefore(SLV_161)) {
2852 /* Before savegame version 161, persistent storages were not stored in a pool. */
2853
2854 if (!IsSavegameVersionBefore(SLV_76)) {
2855 for (Industry *ind : Industry::Iterate()) {
2856 assert(ind->psa != nullptr);
2857
2858 /* Check if the old storage was empty. */
2859 bool is_empty = true;
2860 for (uint i = 0; i < sizeof(ind->psa->storage); i++) {
2861 if (ind->psa->GetValue(i) != 0) {
2862 is_empty = false;
2863 break;
2864 }
2865 }
2866
2867 if (!is_empty) {
2868 ind->psa->grfid = _industry_mngr.GetGRFID(ind->type);
2869 } else {
2870 delete ind->psa;
2871 ind->psa = nullptr;
2872 }
2873 }
2874 }
2875
2876 if (!IsSavegameVersionBefore(SLV_145)) {
2877 for (Station *st : Station::Iterate()) {
2878 if (!st->facilities.Test(StationFacility::Airport)) continue;
2879 assert(st->airport.psa != nullptr);
2880
2881 /* Check if the old storage was empty. */
2882 bool is_empty = true;
2883 for (uint i = 0; i < sizeof(st->airport.psa->storage); i++) {
2884 if (st->airport.psa->GetValue(i) != 0) {
2885 is_empty = false;
2886 break;
2887 }
2888 }
2889
2890 if (!is_empty) {
2891 st->airport.psa->grfid = _airport_mngr.GetGRFID(st->airport.type);
2892 } else {
2893 delete st->airport.psa;
2894 st->airport.psa = nullptr;
2895
2896 }
2897 }
2898 }
2899 }
2900
2901 /* This triggers only when old snow_lines were copied into the snow_line_height. */
2902 if (IsSavegameVersionBefore(SLV_164) && _settings_game.game_creation.snow_line_height >= MIN_SNOWLINE_HEIGHT * TILE_HEIGHT) {
2903 _settings_game.game_creation.snow_line_height /= TILE_HEIGHT;
2904 }
2905
2906 if (IsSavegameVersionBefore(SLV_164) && !IsSavegameVersionBefore(SLV_32)) {
2907 /* We store 4 fences in the field tiles instead of only SE and SW. */
2908 for (auto t : Map::Iterate()) {
2909 if (!IsTileType(t, MP_CLEAR) && !IsTileType(t, MP_TREES)) continue;
2910 if (IsTileType(t, MP_CLEAR) && IsClearGround(t, CLEAR_FIELDS)) continue;
2911 uint fence = GB(t.m4(), 5, 3);
2912 if (fence != 0 && IsTileType(TileAddXY(t, 1, 0), MP_CLEAR) && IsClearGround(TileAddXY(t, 1, 0), CLEAR_FIELDS)) {
2913 SetFence(TileAddXY(t, 1, 0), DIAGDIR_NE, fence);
2914 }
2915 fence = GB(t.m4(), 2, 3);
2916 if (fence != 0 && IsTileType(TileAddXY(t, 0, 1), MP_CLEAR) && IsClearGround(TileAddXY(t, 0, 1), CLEAR_FIELDS)) {
2917 SetFence(TileAddXY(t, 0, 1), DIAGDIR_NW, fence);
2918 }
2919 SB(t.m4(), 2, 3, 0);
2920 SB(t.m4(), 5, 3, 0);
2921 }
2922 }
2923
2924 if (IsSavegameVersionBefore(SLV_165)) {
2925 for (Town *t : Town::Iterate()) {
2926 /* Set the default cargo requirement for town growth */
2927 switch (_settings_game.game_creation.landscape) {
2928 case LandscapeType::Arctic:
2929 if (FindFirstCargoWithTownAcceptanceEffect(TAE_FOOD) != nullptr) t->goal[TAE_FOOD] = TOWN_GROWTH_WINTER;
2930 break;
2931
2932 case LandscapeType::Tropic:
2933 if (FindFirstCargoWithTownAcceptanceEffect(TAE_FOOD) != nullptr) t->goal[TAE_FOOD] = TOWN_GROWTH_DESERT;
2934 if (FindFirstCargoWithTownAcceptanceEffect(TAE_WATER) != nullptr) t->goal[TAE_WATER] = TOWN_GROWTH_DESERT;
2935 break;
2936
2937 default:
2938 break;
2939 }
2940 }
2941 }
2942
2943 if (IsSavegameVersionBefore(SLV_165)) {
2944 /* Adjust zoom level to account for new levels */
2945 _saved_scrollpos_zoom += ZOOM_BASE_SHIFT;
2946 _saved_scrollpos_x *= ZOOM_BASE;
2947 _saved_scrollpos_y *= ZOOM_BASE;
2948 }
2949
2950 /* When any NewGRF has been changed the availability of some vehicles might
2951 * have been changed too. e->company_avail must be set to 0 in that case
2952 * which is done by StartupEngines(). */
2953 if (gcf_res != GLC_ALL_GOOD) StartupEngines();
2954
2955 /* The road owner of standard road stops was not properly accounted for. */
2956 if (IsSavegameVersionBefore(SLV_172)) {
2957 for (const auto t : Map::Iterate()) {
2958 if (!IsBayRoadStopTile(t)) continue;
2959 Owner o = GetTileOwner(t);
2960 SetRoadOwner(t, RTT_ROAD, o);
2961 SetRoadOwner(t, RTT_TRAM, o);
2962 }
2963 }
2964
2965 if (IsSavegameVersionBefore(SLV_175)) {
2966 /* Introduced tree planting limit. */
2967 for (Company *c : Company::Iterate()) c->tree_limit = _settings_game.construction.tree_frame_burst << 16;
2968 }
2969
2970 if (IsSavegameVersionBefore(SLV_177)) {
2971 /* Fix too high inflation rates */
2972 if (_economy.inflation_prices > MAX_INFLATION) _economy.inflation_prices = MAX_INFLATION;
2973 if (_economy.inflation_payment > MAX_INFLATION) _economy.inflation_payment = MAX_INFLATION;
2974
2975 /* We have to convert the quarters of bankruptcy into months of bankruptcy */
2976 for (Company *c : Company::Iterate()) {
2977 c->months_of_bankruptcy = 3 * c->months_of_bankruptcy;
2978 }
2979 }
2980
2981 if (IsSavegameVersionBefore(SLV_182)) {
2982 /* Aircraft acceleration variable was bonkers */
2983 for (Aircraft *v : Aircraft::Iterate()) {
2984 if (v->subtype <= AIR_AIRCRAFT) {
2985 const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);
2986 v->acceleration = avi->acceleration;
2987 }
2988 }
2989
2990 /* Blocked tiles could be reserved due to a bug, which causes
2991 * other places to assert upon e.g. station reconstruction. */
2992 for (const auto t : Map::Iterate()) {
2993 if (HasStationTileRail(t) && IsStationTileBlocked(t)) {
2994 SetRailStationReservation(t, false);
2995 }
2996 }
2997 }
2998
2999 if (IsSavegameVersionBefore(SLV_184)) {
3000 /* The global units configuration is split up in multiple configurations. */
3001 extern uint8_t _old_units;
3002 _settings_game.locale.units_velocity = Clamp(_old_units, 0, 2);
3003 _settings_game.locale.units_power = Clamp(_old_units, 0, 2);
3004 _settings_game.locale.units_weight = Clamp(_old_units, 1, 2);
3005 _settings_game.locale.units_volume = Clamp(_old_units, 1, 2);
3006 _settings_game.locale.units_force = 2;
3007 _settings_game.locale.units_height = Clamp(_old_units, 0, 2);
3008 }
3009
3010 if (IsSavegameVersionBefore(SLV_VELOCITY_NAUTICAL)) {
3011 /* Match nautical velocity with land velocity units. */
3012 _settings_game.locale.units_velocity_nautical = _settings_game.locale.units_velocity;
3013 }
3014
3015 if (IsSavegameVersionBefore(SLV_186)) {
3016 /* Move ObjectType from map to pool */
3017 for (auto t : Map::Iterate()) {
3018 if (IsTileType(t, MP_OBJECT)) {
3019 Object *o = Object::Get(t.m2());
3020 o->type = t.m5();
3021 t.m5() = 0; // zero upper bits of (now bigger) ObjectID
3022 }
3023 }
3024 }
3025
3026 /* Beyond this point, tile types which can be accessed by vehicles must be in a valid state. */
3027
3028 /* Update all vehicles: Phase 2 */
3029 AfterLoadVehiclesPhase2(true);
3030
3031 /* The center of train vehicles was changed, fix up spacing. */
3032 if (IsSavegameVersionBefore(SLV_164)) FixupTrainLengths();
3033
3034 /* In version 2.2 of the savegame, we have new airports, so status of all aircraft is reset.
3035 * This has to be called after all map array updates */
3036 if (IsSavegameVersionBefore(SLV_2, 2)) UpdateOldAircraft();
3037
3038 if (IsSavegameVersionBefore(SLV_188)) {
3039 /* Fix articulated road vehicles.
3040 * Some curves were shorter than other curves.
3041 * Now they have the same length, but that means that trailing articulated parts will
3042 * take longer to go through the curve than the parts in front which already left the curve.
3043 * So, make articulated parts catch up. */
3044 bool roadside = _settings_game.vehicle.road_side == 1;
3045 std::vector<uint> skip_frames;
3046 for (RoadVehicle *v : RoadVehicle::Iterate()) {
3047 if (!v->IsFrontEngine()) continue;
3048 skip_frames.clear();
3049 TileIndex prev_tile = v->tile;
3050 uint prev_tile_skip = 0;
3051 uint cur_skip = 0;
3052 for (RoadVehicle *u = v; u != nullptr; u = u->Next()) {
3053 if (u->tile != prev_tile) {
3054 prev_tile_skip = cur_skip;
3055 prev_tile = u->tile;
3056 } else {
3057 cur_skip = prev_tile_skip;
3058 }
3059
3060 uint &this_skip = skip_frames.emplace_back(prev_tile_skip);
3061
3062 /* The following 3 curves now take longer than before */
3063 switch (u->state) {
3064 case 2:
3065 cur_skip++;
3066 if (u->frame <= (roadside ? 9 : 5)) this_skip = cur_skip;
3067 break;
3068
3069 case 4:
3070 cur_skip++;
3071 if (u->frame <= (roadside ? 5 : 9)) this_skip = cur_skip;
3072 break;
3073
3074 case 5:
3075 cur_skip++;
3076 if (u->frame <= (roadside ? 4 : 2)) this_skip = cur_skip;
3077 break;
3078
3079 default:
3080 break;
3081 }
3082 }
3083 while (cur_skip > skip_frames[0]) {
3084 RoadVehicle *u = v;
3085 RoadVehicle *prev = nullptr;
3086 for (uint sf : skip_frames) {
3087 if (sf >= cur_skip) IndividualRoadVehicleController(u, prev);
3088
3089 prev = u;
3090 u = u->Next();
3091 }
3092 cur_skip--;
3093 }
3094 }
3095 }
3096
3097 if (IsSavegameVersionBefore(SLV_190)) {
3098 for (OrderList *orderlist : OrderList::Iterate()) {
3099 for (Order &order : orderlist->GetOrders()) {
3100 order.SetTravelTimetabled(order.GetTravelTime() > 0);
3101 order.SetWaitTimetabled(order.GetWaitTime() > 0);
3102 }
3103 orderlist->RecalculateTimetableDuration();
3104 }
3105 }
3106
3107 /*
3108 * Only keep order-backups for network clients (and when replaying).
3109 * If we are a network server or not networking, then we just loaded a previously
3110 * saved-by-server savegame. There are no clients with a backup, so clear it.
3111 * Furthermore before savegame version SLV_192 the actual content was always corrupt.
3112 */
3113 if (!_networking || _network_server || IsSavegameVersionBefore(SLV_192)) {
3114#ifndef DEBUG_DUMP_COMMANDS
3115 /* Note: We cannot use CleanPool since that skips part of the destructor
3116 * and then leaks un-reachable Orders in the order pool. */
3117 for (OrderBackup *ob : OrderBackup::Iterate()) {
3118 delete ob;
3119 }
3120#endif
3121 }
3122
3123 if (IsSavegameVersionBefore(SLV_198)) {
3124 /* Convert towns growth_rate and grow_counter to ticks */
3125 for (Town *t : Town::Iterate()) {
3126 /* 0x8000 = TOWN_GROWTH_RATE_CUSTOM previously */
3127 if (t->growth_rate & 0x8000) t->flags.Set(TownFlag::CustomGrowth);
3128 if (t->growth_rate != TOWN_GROWTH_RATE_NONE) {
3129 t->growth_rate = TownTicksToGameTicks(t->growth_rate & ~0x8000);
3130 }
3131 /* Add t->index % TOWN_GROWTH_TICKS to spread growth across ticks. */
3132 t->grow_counter = TownTicksToGameTicks(t->grow_counter) + t->index % Ticks::TOWN_GROWTH_TICKS;
3133 }
3134 }
3135
3136 if (IsSavegameVersionBefore(SLV_EXTEND_INDUSTRY_CARGO_SLOTS)) {
3137 /* Make sure added industry cargo slots are cleared */
3138 for (Industry *i : Industry::Iterate()) {
3139 /* Make sure last_cargo_accepted_at is copied to elements for every valid input cargo.
3140 * The loading routine should put the original singular value into the first array element. */
3141 for (auto &a : i->accepted) {
3142 if (IsValidCargoType(a.cargo)) {
3143 a.last_accepted = i->GetAccepted(0).last_accepted;
3144 } else {
3145 a.last_accepted = EconomyTime::MIN_DATE;
3146 }
3147 }
3148 }
3149 }
3150
3151 if (IsSavegameVersionBefore(SLV_SHIPS_STOP_IN_LOCKS)) {
3152 /* Move ships from lock slope to upper or lower position. */
3153 for (Ship *s : Ship::Iterate()) {
3154 /* Suitable tile? */
3155 if (!IsTileType(s->tile, MP_WATER) || !IsLock(s->tile) || GetLockPart(s->tile) != LockPart::Middle) continue;
3156
3157 /* We don't need to adjust position when at the tile centre */
3158 int x = s->x_pos & 0xF;
3159 int y = s->y_pos & 0xF;
3160 if (x == 8 && y == 8) continue;
3161
3162 /* Test if ship is on the second half of the tile */
3163 bool second_half;
3164 DiagDirection shipdiagdir = DirToDiagDir(s->direction);
3165 switch (shipdiagdir) {
3166 default: NOT_REACHED();
3167 case DIAGDIR_NE: second_half = x < 8; break;
3168 case DIAGDIR_NW: second_half = y < 8; break;
3169 case DIAGDIR_SW: second_half = x > 8; break;
3170 case DIAGDIR_SE: second_half = y > 8; break;
3171 }
3172
3173 DiagDirection slopediagdir = GetInclinedSlopeDirection(GetTileSlope(s->tile));
3174
3175 /* Heading up slope == passed half way */
3176 if ((shipdiagdir == slopediagdir) == second_half) {
3177 /* On top half of lock */
3178 s->z_pos = GetTileMaxZ(s->tile) * (int)TILE_HEIGHT;
3179 } else {
3180 /* On lower half of lock */
3181 s->z_pos = GetTileZ(s->tile) * (int)TILE_HEIGHT;
3182 }
3183 }
3184 }
3185
3186 if (IsSavegameVersionBefore(SLV_TOWN_CARGOGEN)) {
3187 /* Ensure the original cargo generation mode is used */
3188 _settings_game.economy.town_cargogen_mode = TCGM_ORIGINAL;
3189 }
3190
3191 if (IsSavegameVersionBefore(SLV_SERVE_NEUTRAL_INDUSTRIES)) {
3192 /* Ensure the original neutral industry/station behaviour is used */
3193 _settings_game.station.serve_neutral_industries = true;
3194
3195 /* Link oil rigs to their industry and back. */
3196 for (Station *st : Station::Iterate()) {
3197 if (IsTileType(st->xy, MP_STATION) && IsOilRig(st->xy)) {
3198 /* Industry tile is always adjacent during construction by TileDiffXY(0, 1) */
3199 st->industry = Industry::GetByTile(st->xy + TileDiffXY(0, 1));
3200 st->industry->neutral_station = st;
3201 }
3202 }
3203 } else {
3204 /* Link neutral station back to industry, as this is not saved. */
3205 for (Industry *ind : Industry::Iterate()) if (ind->neutral_station != nullptr) ind->neutral_station->industry = ind;
3206 }
3207
3208 if (IsSavegameVersionBefore(SLV_TREES_WATER_CLASS)) {
3209 /* Update water class for trees. */
3210 for (const auto t : Map::Iterate()) {
3211 if (IsTileType(t, MP_TREES)) SetWaterClass(t, GetTreeGround(t) == TREE_GROUND_SHORE ? WaterClass::Sea : WaterClass::Invalid);
3212 }
3213 }
3214
3215 /* Update structures for multitile docks */
3216 if (IsSavegameVersionBefore(SLV_MULTITILE_DOCKS)) {
3217 for (const auto t : Map::Iterate()) {
3218 /* Clear docking tile flag from relevant tiles as it
3219 * was not previously cleared. */
3220 if (IsTileType(t, MP_WATER) || IsTileType(t, MP_RAILWAY) || IsTileType(t, MP_STATION) || IsTileType(t, MP_TUNNELBRIDGE)) {
3221 SetDockingTile(t, false);
3222 }
3223 /* Add docks and oilrigs to Station::ship_station. */
3224 if (IsTileType(t, MP_STATION)) {
3225 if (IsDock(t) || IsOilRig(t)) Station::GetByTile(t)->ship_station.Add(t);
3226 }
3227 }
3228 }
3229
3230 if (IsSavegameVersionBefore(SLV_REPAIR_OBJECT_DOCKING_TILES)) {
3231 /* Placing objects on docking tiles was not updating adjacent station's docking tiles. */
3232 for (Station *st : Station::Iterate()) {
3233 if (st->ship_station.tile != INVALID_TILE) UpdateStationDockingTiles(st);
3234 }
3235 }
3236
3237 /* Make sure all industries exclusive supplier/consumer set correctly. */
3238 if (IsSavegameVersionBefore(SLV_GS_INDUSTRY_CONTROL)) {
3239 for (Industry *i : Industry::Iterate()) {
3240 i->exclusive_supplier = INVALID_OWNER;
3241 i->exclusive_consumer = INVALID_OWNER;
3242 }
3243 }
3244
3245 if (IsSavegameVersionBefore(SLV_GROUP_REPLACE_WAGON_REMOVAL)) {
3246 /* Propagate wagon removal flag for compatibility */
3247 /* Temporary bitmask of company wagon removal setting */
3248 CompanyMask wagon_removal{};
3249 for (const Company *c : Company::Iterate()) {
3250 if (c->settings.renew_keep_length) wagon_removal.Set(c->index);
3251 }
3252 for (Group *g : Group::Iterate()) {
3253 if (g->flags.Any()) {
3254 /* Convert old replace_protection value to flag. */
3255 g->flags = GroupFlag::ReplaceProtection;
3256 }
3257 if (wagon_removal.Test(g->owner)) g->flags.Set(GroupFlag::ReplaceWagonRemoval);
3258 }
3259 }
3260
3261 /* Use current order time to approximate last loading time */
3262 if (IsSavegameVersionBefore(SLV_LAST_LOADING_TICK)) {
3263 for (Vehicle *v : Vehicle::Iterate()) {
3264 v->last_loading_tick = std::max(TimerGameTick::counter, static_cast<uint64_t>(v->current_order_time)) - v->current_order_time;
3265 }
3266 }
3267
3268 /* Road stops is 'only' updating some caches, but they are needed for PF calls in SLV_MULTITRACK_LEVEL_CROSSINGS teleporting. */
3269 AfterLoadRoadStops();
3270
3271 /* Road vehicles stopped on multitrack level crossings need teleporting to a depot
3272 * to avoid crashing into the side of the train they're waiting for. */
3273 if (IsSavegameVersionBefore(SLV_MULTITRACK_LEVEL_CROSSINGS)) {
3274 /* Teleport road vehicles to the nearest depot. */
3275 for (RoadVehicle *rv : RoadVehicle::Iterate()) {
3276 /* Ignore trailers of articulated vehicles. */
3277 if (rv->IsArticulatedPart()) continue;
3278
3279 /* Ignore moving vehicles. */
3280 if (rv->cur_speed > 0) continue;
3281
3282 /* Ignore crashed vehicles. */
3283 if (rv->vehstatus.Test(VehState::Crashed)) continue;
3284
3285 /* Ignore vehicles not on level crossings. */
3286 TileIndex cur_tile = rv->tile;
3287 if (!IsLevelCrossingTile(cur_tile)) continue;
3288
3289 ClosestDepot closest_depot = rv->FindClosestDepot();
3290
3291 /* Try to find a depot with a distance limit of 512 tiles (Manhattan distance). */
3292 if (closest_depot.found && DistanceManhattan(rv->tile, closest_depot.location) < 512u) {
3293 /* Teleport all parts of articulated vehicles. */
3294 for (RoadVehicle *u = rv; u != nullptr; u = u->Next()) {
3295 u->tile = closest_depot.location;
3296 int x = TileX(closest_depot.location) * TILE_SIZE + TILE_SIZE / 2;
3297 int y = TileY(closest_depot.location) * TILE_SIZE + TILE_SIZE / 2;
3298 u->x_pos = x;
3299 u->y_pos = y;
3300 u->z_pos = GetSlopePixelZ(x, y, true);
3301
3302 u->vehstatus.Set(VehState::Hidden);
3303 u->state = RVSB_IN_DEPOT;
3304 u->UpdatePosition();
3305 }
3306 RoadVehLeaveDepot(rv, false);
3307 }
3308 }
3309
3310 if (IsSavegameVersionBeforeOrAt(SLV_MULTITRACK_LEVEL_CROSSINGS)) {
3311 /* Reset unused tree counters to reduce the savegame size. */
3312 for (auto t : Map::Iterate()) {
3313 if (IsTileType(t, MP_TREES)) {
3314 SB(t.m2(), 0, 4, 0);
3315 }
3316 }
3317 }
3318
3319 /* Refresh all level crossings to bar adjacent crossing tiles, if needed. */
3320 for (const auto tile : Map::Iterate()) {
3321 if (IsLevelCrossingTile(tile)) UpdateLevelCrossing(tile, false);
3322 }
3323 }
3324
3325 /* Compute station catchment areas. This is needed here in case UpdateStationAcceptance is called below. */
3326 Station::RecomputeCatchmentForAll();
3327
3328 /* Station acceptance is some kind of cache */
3329 if (IsSavegameVersionBefore(SLV_127)) {
3330 for (Station *st : Station::Iterate()) UpdateStationAcceptance(st, false);
3331 }
3332
3333 if (IsSavegameVersionBefore(SLV_SAVEGAME_ID)) {
3334 GenerateSavegameId();
3335 }
3336
3337 if (IsSavegameVersionBefore(SLV_AI_START_DATE)) {
3338 /* For older savegames, we don't now the actual interval; so set it to the newgame value. */
3339 _settings_game.difficulty.competitors_interval = _settings_newgame.difficulty.competitors_interval;
3340
3341 /* We did load the "period" of the timer, but not the fired/elapsed. We can deduce that here. */
3342 extern TimeoutTimer<TimerGameTick> _new_competitor_timeout;
3343 _new_competitor_timeout.storage.elapsed = 0;
3344 _new_competitor_timeout.fired = _new_competitor_timeout.period.value == 0;
3345 }
3346
3347 if (IsSavegameVersionBefore(SLV_NEWGRF_LAST_SERVICE)) {
3348 /* Set service date provided to NewGRF. */
3349 for (Vehicle *v : Vehicle::Iterate()) {
3350 v->date_of_last_service_newgrf = TimerGameCalendar::Date{v->date_of_last_service.base()};
3351 }
3352 }
3353
3354 if (IsSavegameVersionBefore(SLV_SHIP_ACCELERATION)) {
3355 /* NewGRF acceleration information was added to ships. */
3356 for (Ship *s : Ship::Iterate()) {
3357 if (s->acceleration == 0) s->acceleration = ShipVehInfo(s->engine_type)->acceleration;
3358 }
3359 }
3360
3361 if (IsSavegameVersionBefore(SLV_MAX_LOAN_FOR_COMPANY)) {
3362 for (Company *c : Company::Iterate()) {
3363 c->max_loan = COMPANY_MAX_LOAN_DEFAULT;
3364 }
3365 }
3366
3367 if (IsSavegameVersionBefore(SLV_SCRIPT_RANDOMIZER)) {
3368 ScriptObject::InitializeRandomizers();
3369 }
3370
3371 if (IsSavegameVersionBefore(SLV_COMPANY_INAUGURATED_PERIOD_V2)) {
3372 for (Company *c : Company::Iterate()) {
3373 c->inaugurated_year_calendar = _settings_game.game_creation.starting_year;
3374 }
3375 }
3376
3377 if (!IsSavegameVersionBefore(SLV_INCREASE_HOUSE_LIMIT) && IsSavegameVersionBeforeOrAt(SLV_SCRIPT_SAVE_INSTANCES)) {
3378 /* Between these two versions (actually from f8b1e303 to 77236258) EngineFlags had an off-by-one. Depending
3379 * on when the save was started, this may or may not affect existing engines. Here we try to detect invalid flags
3380 * and reset them to what they should be. */
3381 for (Engine *e : Engine::Iterate()) {
3382 if (e->flags.Test(EngineFlag::Available)) continue;
3383 if (e->flags.Test(EngineFlag{2}) || (e->flags.Test(EngineFlag::ExclusivePreview) && e->preview_asked.None())) {
3384 e->flags = EngineFlags(e->flags.base() >> 1U);
3385 }
3386 }
3387 }
3388
3389 for (Company *c : Company::Iterate()) {
3390 UpdateCompanyLiveries(c);
3391 }
3392
3393 /* Update free group numbers data for each company, required regardless of savegame version. */
3394 for (Group *g : Group::Iterate()) {
3395 Company *c = Company::Get(g->owner);
3396 if (IsSavegameVersionBefore(SLV_GROUP_NUMBERS)) {
3397 /* Use the index as group number when converting old savegames. */
3398 g->number = c->freegroups.UseID(g->index.base());
3399 } else {
3400 c->freegroups.UseID(g->number);
3401 }
3402 }
3403
3404 AfterLoadLabelMaps();
3405 AfterLoadCompanyStats();
3406 AfterLoadStoryBook();
3407
3408 _gamelog.PrintDebug(1);
3409
3410 InitializeWindowsAndCaches();
3411 /* Restore the signals */
3412 ResetSignalHandlers();
3413
3414 AfterLoadLinkGraphs();
3415
3416 CheckGroundVehiclesAtCorrectZ();
3417
3418 /* Start the scripts. This MUST happen after everything else except
3419 * starting a new company. */
3420 StartScripts();
3421
3422 /* If Load Scenario / New (Scenario) Game is used,
3423 * a company does not exist yet. So create one here.
3424 * 1 exception: network-games. Those can have 0 companies
3425 * But this exception is not true for non-dedicated network servers! */
3426 if (!_networking || (_networking && _network_server && !_network_dedicated)) {
3427 CompanyID first_human_company = GetFirstPlayableCompanyID();
3428 if (!Company::IsValidID(first_human_company)) {
3429 Company *c = DoStartupNewCompany(false, first_human_company);
3430 c->settings = _settings_client.company;
3431 }
3432 }
3433
3434 return true;
3435}
3436
3445 void ReloadNewGRFData()
3446{
3447 /* reload grf data */
3448 GfxLoadSprites();
3449 LoadStringWidthTable();
3450 RecomputePrices();
3451 /* reload vehicles */
3452 ResetVehicleHash();
3453 AfterLoadLabelMaps();
3454 AfterLoadVehiclesPhase1(false);
3455 AfterLoadVehiclesPhase2(false);
3456 StartupEngines();
3457 GroupStatistics::UpdateAfterLoad();
3458 /* update station graphics */
3459 AfterLoadStations();
3460 /* Update company statistics. */
3461 AfterLoadCompanyStats();
3462 /* Check and update house and town values */
3463 UpdateHousesAndTowns();
3464 /* Delete news referring to no longer existing entities */
3465 DeleteInvalidEngineNews();
3466 /* Update livery selection windows */
3467 for (CompanyID i = CompanyID::Begin(); i < MAX_COMPANIES; ++i) InvalidateWindowData(WC_COMPANY_COLOUR, i);
3468 /* Update company infrastructure counts. */
3469 InvalidateWindowClassesData(WC_COMPANY_INFRASTRUCTURE);
3470 InvalidateWindowClassesData(WC_BUILD_TOOLBAR);
3471 InvalidateAllPickerWindows();
3472 /* redraw the whole screen */
3473 MarkWholeScreenDirty();
3474 CheckTrainsLengths();
3475}
SetSignalHandlers
static void SetSignalHandlers()
Replaces signal handlers of SIGSEGV and SIGABRT and stores pointers to original handlers in memory.
Definition afterload.cpp:324
FixVehicleInclination
static uint FixVehicleInclination(Vehicle *v, Direction dir)
Fixes inclination of a vehicle.
Definition afterload.cpp:476
DoStartupNewCompany
Company * DoStartupNewCompany(bool is_ai, CompanyID company=CompanyID::Invalid())
Create a new company and sets all company variables default values.
Definition company_cmd.cpp:598
InitializeWindowsAndCaches
static void InitializeWindowsAndCaches()
Initialization of the windows and several kinds of caches.
Definition afterload.cpp:245
CheckGroundVehiclesAtCorrectZ
static void CheckGroundVehiclesAtCorrectZ()
Check whether the ground vehicles are at the correct Z-coordinate.
Definition afterload.cpp:511
_saveload_crash_with_missing_newgrfs
static bool _saveload_crash_with_missing_newgrfs
Was the saveload crash because of missing NewGRFs?
Definition afterload.cpp:342
FixOwnerOfRailTrack
static void FixOwnerOfRailTrack(Tile t)
Tries to change owner of this rail tile to a valid owner.
Definition afterload.cpp:418
HandleSavegameLoadCrash
static void CDECL HandleSavegameLoadCrash(int signum)
Signal handler used to give a user a more useful report for crashes during the savegame loading proce...
Definition afterload.cpp:360
MayHaveBridgeAbove
static bool MayHaveBridgeAbove(Tile t)
Checks for the possibility that a bridge may be on this tile These are in fact all the tile types on ...
Definition afterload.cpp:531
SetWaterClassDependingOnSurroundings
void SetWaterClassDependingOnSurroundings(Tile t, bool include_invalid_water_class)
Makes a tile canal or water depending on the surroundings.
Definition afterload.cpp:91
StartScripts
static void StartScripts()
Start the scripts.
Definition afterload.cpp:540
SaveloadCrashWithMissingNewGRFs
bool SaveloadCrashWithMissingNewGRFs()
Did loading the savegame cause a crash? If so, were NewGRFs missing?
Definition afterload.cpp:349
UpdateAllVirtCoords
void UpdateAllVirtCoords()
Update the viewport coordinates of all signs.
Definition afterload.cpp:220
ClearOldOrders
void ClearOldOrders()
Clear all old orders.
Definition order_sl.cpp:114
AfterLoadGame
bool AfterLoadGame()
Perform a (large) amount of savegame conversion magic in order to load older savegames and to fill th...
Definition afterload.cpp:560
ReloadNewGRFData
void ReloadNewGRFData()
Reload all NewGRF files during a running game.
Definition afterload.cpp:3445
ResetSignalHandlers
static void ResetSignalHandlers()
Resets signal handlers back to original handlers.
Definition afterload.cpp:334
GetAircraftFlightLevelBounds
void GetAircraftFlightLevelBounds(const Vehicle *v, int *min, int *max)
Get the 'flight level' bounds, in pixels from 'z_pos' 0 for a particular vehicle for normal flight si...
Definition aircraft_cmd.cpp:726
AircraftNextAirportPos_and_Order
void AircraftNextAirportPos_and_Order(Aircraft *v)
set the right pos when heading to other airports after takeoff
Definition aircraft_cmd.cpp:1460
GetTargetAirportIfValid
Station * GetTargetAirportIfValid(const Aircraft *v)
Returns aircraft's target station if v->target_airport is a valid station with airport.
Definition aircraft_cmd.cpp:2163
SetAircraftPosition
void SetAircraftPosition(Aircraft *v, int x, int y, int z)
Set aircraft position.
Definition aircraft_cmd.cpp:532
AIR_AIRCRAFT
@ AIR_AIRCRAFT
an airplane
Definition aircraft.h:30
UpdateAircraftCache
void UpdateAircraftCache(Aircraft *v, bool update_range=false)
Update cached values of an aircraft.
Definition aircraft_cmd.cpp:601
FLYING
@ FLYING
Vehicle is flying in the air.
Definition airport.h:77
AT_OILRIG
@ AT_OILRIG
Oilrig airport.
Definition airport.h:38
_animated_tiles
std::vector< TileIndex > _animated_tiles
The table/list with animated tiles.
Definition animated_tile.cpp:20
AnimatedTileState::Animated
@ Animated
Tile is animated.
AnimatedTileState::None
@ None
Tile is not animated.
SetAnimatedTileState
void SetAnimatedTileState(Tile t, AnimatedTileState state)
Set the animated state of a tile.
Definition animated_tile_map.h:39
VehicleFlag
VehicleFlag
Bit numbers in Vehicle::vehicle_flags.
Definition base_consist.h:18
VehicleFlag::PathfinderLost
@ PathfinderLost
Vehicle's pathfinder is lost.
VehicleFlag::LoadingFinished
@ LoadingFinished
Vehicle has finished loading.
AssignBit
constexpr T AssignBit(T &x, const uint8_t y, bool value)
Assigns a bit in a variable.
Definition bitmath_func.hpp:176
SB
constexpr T SB(T &x, const uint8_t s, const uint8_t n, const U d)
Set n bits in x starting at bit s to d.
Definition bitmath_func.hpp:58
GB
static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
Definition bitmath_func.hpp:32
SetBit
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
Definition bitmath_func.hpp:121
HasBit
constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
Definition bitmath_func.hpp:103
ClrBit
constexpr T ClrBit(T &x, const uint8_t y)
Clears a bit in a variable.
Definition bitmath_func.hpp:139
GetNorthernBridgeEnd
TileIndex GetNorthernBridgeEnd(TileIndex t)
Finds the northern end of a bridge starting at a middle tile.
Definition bridge_map.cpp:39
SetBridgeMiddle
void SetBridgeMiddle(Tile t, Axis a)
Set that there is a bridge over the given axis.
Definition bridge_map.h:114
IsBridgeTile
bool IsBridgeTile(Tile t)
checks if there is a bridge on this tile
Definition bridge_map.h:35
ClearBridgeMiddle
void ClearBridgeMiddle(Tile t)
Removes bridges from the given, that is bridges along the X and Y axis.
Definition bridge_map.h:103
IsBridge
bool IsBridge(Tile t)
Checks if this is a bridge, instead of a tunnel.
Definition bridge_map.h:24
AfterLoadCompanyStats
void AfterLoadCompanyStats()
Rebuilding of company statistics after loading a savegame.
Definition company_sl.cpp:126
IsValidCargoType
bool IsValidCargoType(CargoType cargo)
Test whether cargo type is not INVALID_CARGO.
Definition cargo_type.h:104
CARGO_NO_REFIT
static const CargoType CARGO_NO_REFIT
Do not refit cargo of a vehicle (used in vehicle orders and auto-replace/auto-renew).
Definition cargo_type.h:77
TAE_GOODS
@ TAE_GOODS
Cargo behaves goods/candy-like.
Definition cargotype.h:27
TAE_PASSENGERS
@ TAE_PASSENGERS
Cargo behaves passenger-like.
Definition cargotype.h:25
TAE_MAIL
@ TAE_MAIL
Cargo behaves mail-like.
Definition cargotype.h:26
TAE_FOOD
@ TAE_FOOD
Cargo behaves food/fizzy-drinks-like.
Definition cargotype.h:29
TAE_WATER
@ TAE_WATER
Cargo behaves water-like.
Definition cargotype.h:28
AI::StartNew
static void StartNew(CompanyID company)
Start a new AI company.
Definition ai_core.cpp:36
BaseBitSet::Test
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
Definition base_bitset_type.hpp:141
BaseBitSet::base
constexpr Tstorage base() const noexcept
Retrieve the raw value behind this bit set.
Definition base_bitset_type.hpp:219
BaseBitSet::Reset
constexpr Timpl & Reset()
Reset all bits.
Definition base_bitset_type.hpp:83
BaseBitSet::Set
constexpr Timpl & Set()
Set all bits.
Definition base_bitset_type.hpp:40
BaseTimer::storage
TStorage storage
The storage of the timer.
Definition timer.h:50
CompanyMask
Definition company_type.h:43
Engine
Definition engine_base.h:38
EnumBitSet
Enum-as-bit-set wrapper.
Definition enum_type.hpp:177
FreeUnitIDGenerator::UseID
UnitID UseID(UnitID index)
Use a unit number.
Definition vehicle.cpp:1844
Game::StartNew
static void StartNew()
Start up a new GameScript.
Definition game_core.cpp:72
Gamelog::TestRevision
void TestRevision()
Finds out if current revision is different than last revision stored in the savegame.
Definition gamelog.cpp:425
Gamelog::GetOverriddenIdentifier
const GRFIdentifier & GetOverriddenIdentifier(const GRFConfig &c)
Try to find the overridden GRF identifier of the given GRF.
Definition gamelog.cpp:712
Gamelog::PrintDebug
void PrintDebug(int level)
Prints gamelog to debug output.
Definition gamelog.cpp:323
Gamelog::GRFRemove
void GRFRemove(uint32_t grfid)
Logs removal of a GRF.
Definition gamelog.cpp:517
Gamelog::GRFAddList
void GRFAddList(const GRFConfigList &newg)
Logs adding of list of GRFs.
Definition gamelog.cpp:578
Gamelog::GRFCompatible
void GRFCompatible(const GRFIdentifier &newg)
Logs loading compatible GRF (the same ID, but different MD5 hash)
Definition gamelog.cpp:542
Gamelog::Oldver
void Oldver()
Logs loading from savegame without gamelog.
Definition gamelog.cpp:399
Gamelog::TestMode
void TestMode()
Finds last stored game mode or landscape.
Definition gamelog.cpp:446
OverrideManagerBase::GetGRFID
uint32_t GetGRFID(uint16_t entity_id) const
Gives the GRFID of the file the entity belongs to.
Definition newgrf_commons.cpp:140
Ticks::DAY_TICKS
static constexpr TimerGameTick::Ticks DAY_TICKS
1 day is 74 ticks; TimerGameCalendar::date_fract used to be uint16_t and incremented by 885.
Definition timer_game_tick.h:75
Ticks::TOWN_GROWTH_TICKS
static constexpr TimerGameTick::Ticks TOWN_GROWTH_TICKS
Cycle duration for towns trying to grow (this originates from the size of the town array in TTD).
Definition timer_game_tick.h:83
Tile
Wrapper class to abstract away the way the tiles are stored.
Definition map_func.h:25
Tile::m5
uint8_t & m5()
General purpose.
Definition map_func.h:161
Tile::m6
uint8_t & m6()
General purpose.
Definition map_func.h:173
Tile::m7
uint8_t & m7()
Primarily used for newgrf support.
Definition map_func.h:185
Tile::m3
uint8_t & m3()
General purpose.
Definition map_func.h:137
Tile::m2
uint16_t & m2()
Primarily used for indices to towns, industries and stations.
Definition map_func.h:125
TimeoutTimer
A timeout timer will fire once after the interval.
Definition timer.h:116
TimerGameCalendar::SetDate
static void SetDate(Date date, DateFract fract)
Set the date.
Definition timer_game_calendar.cpp:66
TimerGameCalendar::date
static Date date
Current date in days (day counter).
Definition timer_game_calendar.h:33
TimerGameCalendar::year
static Year year
Current year, starting at 0.
Definition timer_game_calendar.h:31
TimerGameCalendar::date_fract
static DateFract date_fract
Fractional part of the day.
Definition timer_game_calendar.h:34
TimerGameConst< struct Economy >::MIN_DATE
static constexpr TimerGame< struct Economy >::Date MIN_DATE
The date on January 1, year 0.
Definition timer_game_common.h:190
TimerGameConst< struct Calendar >::DEF_END_YEAR
static constexpr TimerGame< struct Calendar >::Year DEF_END_YEAR
The default scoring end year.
Definition timer_game_common.h:181
TimerGameConst< struct Economy >::MIN_YEAR
static constexpr TimerGame< struct Economy >::Year MIN_YEAR
The absolute minimum year in OTTD.
Definition timer_game_common.h:176
TimerGameConst< struct Calendar >::SECONDS_PER_DAY
static constexpr int SECONDS_PER_DAY
approximate seconds per day, not for precise calculations
Definition timer_game_common.h:153
TimerGameConst< struct Calendar >::ORIGINAL_BASE_YEAR
static constexpr TimerGame< struct Calendar >::Year ORIGINAL_BASE_YEAR
The minimum starting year/base year of the original TTD.
Definition timer_game_common.h:163
TimerGameConst< struct Calendar >::DAYS_TILL_ORIGINAL_BASE_YEAR
static constexpr TimerGame< struct Calendar >::Date DAYS_TILL_ORIGINAL_BASE_YEAR
The date of the first day of the original base year.
Definition timer_game_common.h:184
TimerGameEconomy::date
static Date date
Current date in days (day counter).
Definition timer_game_economy.h:38
TimerGameEconomy::year
static Year year
Current year, starting at 0.
Definition timer_game_economy.h:36
TimerGameEconomy::date_fract
static DateFract date_fract
Fractional part of the day.
Definition timer_game_economy.h:39
TimerGameEconomy::SetDate
static void SetDate(Date date, DateFract fract)
Set the date.
Definition timer_game_economy.cpp:82
TimerGameTick::counter
static TickCounter counter
Monotonic counter, in ticks, since start of game.
Definition timer_game_tick.h:60
IsClearGround
bool IsClearGround(Tile t, ClearGround ct)
Set the type of clear tile.
Definition clear_map.h:59
SetFence
void SetFence(Tile t, DiagDirection side, uint h)
Sets the type of fence (and whether there is one) for the given border.
Definition clear_map.h:228
CLEAR_GRASS
@ CLEAR_GRASS
0-3
Definition clear_map.h:20
CLEAR_FIELDS
@ CLEAR_FIELDS
3
Definition clear_map.h:23
CLEAR_SNOW
@ CLEAR_SNOW
0-3 (Not stored in map.)
Definition clear_map.h:24
MakeClear
void MakeClear(Tile t, ClearGround g, uint density)
Make a clear tile.
Definition clear_map.h:247
GetClearGround
ClearGround GetClearGround(Tile t)
Get the type of clear tile.
Definition clear_map.h:47
SetClearGroundDensity
void SetClearGroundDensity(Tile t, ClearGround type, uint density)
Sets ground type and density in one go, also sets the counter to 0.
Definition clear_map.h:146
GetClearDensity
uint GetClearDensity(Tile t)
Get the density of a non-field clear tile.
Definition clear_map.h:71
_new_competitor_timeout
TimeoutTimer< TimerGameTick > _new_competitor_timeout({ TimerGameTick::Priority::COMPETITOR_TIMEOUT, 0 }, []() { if(_game_mode==GM_MENU||!AI::CanStartNew()) return;if(_networking &&Company::GetNumItems() >=_settings_client.network.max_companies) return;if(_settings_game.difficulty.competitors_interval==0) return;uint8_t n=0;for(const Company *c :Company::Iterate()) { if(c->is_ai) n++;} if(n >=_settings_game.difficulty.max_no_competitors) return;Command< CMD_COMPANY_CTRL >::Post(CCA_NEW_AI, CompanyID::Invalid(), CRR_NONE, INVALID_CLIENT_ID);})
Start a new competitor company if possible.
RandomiseCompanyManagerFace
void RandomiseCompanyManagerFace(CompanyManagerFace &cmf, Randomizer &randomizer)
Completely randomise a company manager face, including style.
Definition company_cmd.cpp:1450
ResetCompanyLivery
void ResetCompanyLivery(Company *c)
Reset the livery schemes to the company's primary colour.
Definition company_cmd.cpp:574
UpdateCompanyLiveries
void UpdateCompanyLiveries(Company *c)
Update liveries for a company.
Definition company_cmd.cpp:1077
SetCompanyManagerFaceStyle
void SetCompanyManagerFaceStyle(CompanyManagerFace &cmf, uint style)
Set a company face style.
Definition company_cmd.cpp:1435
GetFirstPlayableCompanyID
CompanyID GetFirstPlayableCompanyID()
Get the index of the first available company.
Definition company_cmd.cpp:1354
FindCompanyManagerFaceLabel
std::optional< uint > FindCompanyManagerFaceLabel(std::string_view label)
Find a company manager face style by label.
Definition company_cmd.cpp:1409
_current_company
CompanyID _current_company
Company currently doing an action.
Definition company_cmd.cpp:56
ConvertFromOldCompanyManagerFace
CompanyManagerFace ConvertFromOldCompanyManagerFace(uint32_t face)
Converts an old company manager's face format to the new company manager's face format.
Definition company_sl.cpp:59
OWNER_TOWN
static constexpr Owner OWNER_TOWN
A town owns the tile, or a town is expanding.
Definition company_type.h:25
OWNER_NONE
static constexpr Owner OWNER_NONE
The tile has no ownership.
Definition company_type.h:26
INVALID_OWNER
static constexpr Owner INVALID_OWNER
An invalid owner.
Definition company_type.h:30
OWNER_WATER
static constexpr Owner OWNER_WATER
The tile/execution is done by "water".
Definition company_type.h:27
Debug
#define Debug(category, level, format_string,...)
Output a line of debugging information.
Definition debug.h:37
IsDepotTile
bool IsDepotTile(Tile tile)
Is the given tile a tile with a depot on it?
Definition depot_map.h:42
DiagDirToDir
Direction DiagDirToDir(DiagDirection dir)
Convert a DiagDirection to a Direction.
Definition direction_func.h:182
ReverseDiagDir
DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
Definition direction_func.h:118
ReverseDir
Direction ReverseDir(Direction d)
Return the reverse of a direction.
Definition direction_func.h:54
AxisToDirection
Direction AxisToDirection(Axis a)
Converts an Axis to a Direction.
Definition direction_func.h:266
DiagDirToAxis
Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
Definition direction_func.h:214
XYNSToDiagDir
DiagDirection XYNSToDiagDir(Axis xy, uint ns)
Convert an axis and a flag for north/south into a DiagDirection.
Definition direction_func.h:278
DirToDiagDir
DiagDirection DirToDiagDir(Direction dir)
Convert a Direction to a DiagDirection.
Definition direction_func.h:166
Direction
Direction
Defines the 8 directions on the map.
Definition direction_type.h:24
DIR_SW
@ DIR_SW
Southwest.
Definition direction_type.h:31
DIR_NW
@ DIR_NW
Northwest.
Definition direction_type.h:33
INVALID_DIR
@ INVALID_DIR
Flag for an invalid direction.
Definition direction_type.h:35
DIR_N
@ DIR_N
North.
Definition direction_type.h:26
DIR_SE
@ DIR_SE
Southeast.
Definition direction_type.h:29
DIR_NE
@ DIR_NE
Northeast.
Definition direction_type.h:27
Axis
Axis
Allow incrementing of DiagDirDiff variables.
Definition direction_type.h:123
AXIS_X
@ AXIS_X
The X axis.
Definition direction_type.h:124
AXIS_Y
@ AXIS_Y
The y axis.
Definition direction_type.h:125
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition direction_type.h:78
DIAGDIR_NE
@ DIAGDIR_NE
Northeast, upper right on your monitor.
Definition direction_type.h:80
DIAGDIR_NW
@ DIAGDIR_NW
Northwest.
Definition direction_type.h:83
DIAGDIR_SE
@ DIAGDIR_SE
Southeast.
Definition direction_type.h:81
DIAGDIR_END
@ DIAGDIR_END
Used for iterations.
Definition direction_type.h:84
DIAGDIR_BEGIN
@ DIAGDIR_BEGIN
Used for iterations.
Definition direction_type.h:79
DIAGDIR_SW
@ DIAGDIR_SW
Southwest.
Definition direction_type.h:82
RecomputePrices
void RecomputePrices()
Computes all prices, payments and maximum loan.
Definition economy.cpp:742
AddInflation
bool AddInflation(bool check_year)
Add monthly inflation.
Definition economy.cpp:704
MAX_INFLATION
static const uint64_t MAX_INFLATION
Maximum inflation (including fractional part) without causing overflows in int64_t price computations...
Definition economy_type.h:225
StartupEngines
void StartupEngines()
Start/initialise all our engines.
Definition engine.cpp:798
CopyTempEngineData
void CopyTempEngineData()
Copy data from temporary engine array into the real engine pool.
Definition engine_sl.cpp:96
EngineMiscFlag::RoadIsTram
@ RoadIsTram
Road vehicle is a tram/light rail vehicle.
EngineFlag
EngineFlag
Engine.flags is a bitmask, with the following values.
Definition engine_type.h:221
EngineFlag::Available
@ Available
This vehicle is available to everyone.
EngineFlag::ExclusivePreview
@ ExclusivePreview
This vehicle is in the exclusive preview stage, either being used or being offered to a company.
to_underlying
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23)
Definition enum_type.hpp:17
WL_CRITICAL
@ WL_CRITICAL
Critical errors, the MessageBox is shown in all cases.
Definition error.h:27
ShowErrorMessage
void ShowErrorMessage(EncodedString &&summary_msg, int x, int y, CommandCost &cc)
Display an error message in a window.
Definition error_gui.cpp:296
FT_SCENARIO
@ FT_SCENARIO
old or new scenario
Definition fileio_type.h:20
_gamelog
Gamelog _gamelog
Gamelog instance.
Definition gamelog.cpp:31
LoadStringWidthTable
void LoadStringWidthTable(FontSizes fontsizes)
Initialize _stringwidth_table cache for the specified font sizes.
Definition gfx.cpp:1256
_pause_mode
PauseModes _pause_mode
The current pause mode.
Definition gfx.cpp:50
GfxLoadSprites
void GfxLoadSprites()
Initialise and load all the sprites.
Definition gfxinit.cpp:335
GVF_GOINGDOWN_BIT
@ GVF_GOINGDOWN_BIT
Vehicle is currently going downhill. (Cached track information for acceleration)
Definition ground_vehicle.hpp:56
GVF_GOINGUP_BIT
@ GVF_GOINGUP_BIT
Vehicle is currently going uphill. (Cached track information for acceleration)
Definition ground_vehicle.hpp:55
UpdateGroupChildren
void UpdateGroupChildren()
Update children list for each group.
Definition group_cmd.cpp:47
GroupFlag::ReplaceProtection
@ ReplaceProtection
If set, the global autoreplace has no effect on the group.
GroupFlag::ReplaceWagonRemoval
@ ReplaceWagonRemoval
If set, autoreplace will perform wagon removal on vehicles in this group.
MarkWholeScreenDirty
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition gfx.cpp:1549
MarkTileDirtyByTile
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
Definition viewport.cpp:2128
HouseExtraFlag::BuildingIsProtected
@ BuildingIsProtected
towns and AI will not remove this house, while human players will be able to
NEW_HOUSE_OFFSET
static const HouseID NEW_HOUSE_OFFSET
Offset for new houses.
Definition house.h:28
TOWN_HOUSE_COMPLETED
static const uint8_t TOWN_HOUSE_COMPLETED
Simple value that indicates the house has reached the final stage of construction.
Definition house.h:25
_industry_builder
IndustryBuildData _industry_builder
In-game manager of industries.
Definition industry_cmd.cpp:73
TrimIndustryAcceptedProduced
void TrimIndustryAcceptedProduced(Industry *ind)
Remove unused industry accepted/produced slots – entries after the last slot with valid cargo.
Definition industry_cmd.cpp:3293
GetIndustrySpec
const IndustrySpec * GetIndustrySpec(IndustryType thistype)
Accessor for array _industry_specs.
Definition industry_cmd.cpp:126
GetIndustryType
IndustryType GetIndustryType(Tile tile)
Retrieve the type for this industry.
Definition industry_cmd.cpp:109
GetIndustryGfx
IndustryGfx GetIndustryGfx(Tile t)
Get the industry graphics ID for the given industry tile.
Definition industry_map.h:137
IndustryBehaviour::PlantOnBuild
@ PlantOnBuild
Fields are planted around when built (all farms)
IndustryBehaviour::BuiltOnWater
@ BuiltOnWater
is built on water (oil rig)
AfterLoadLabelMaps
void AfterLoadLabelMaps()
Perform rail type and road type conversion if necessary.
Definition labelmaps_sl.cpp:27
GetTileTrackStatus
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition landscape.cpp:560
ChangeTileOwner
void ChangeTileOwner(TileIndex tile, Owner old_owner, Owner new_owner)
Change the owner of a tile.
Definition landscape.cpp:571
GetSlopePixelZ
int GetSlopePixelZ(int x, int y, bool ground_vehicle)
Return world Z coordinate of a given point of a tile.
Definition landscape.cpp:307
BorderFlag::Random
@ Random
Randomise borders.
AfterLoadLinkGraphs
void AfterLoadLinkGraphs()
Spawn the threads for running link graph calculations.
Definition linkgraph_sl.cpp:232
DT_MANUAL
@ DT_MANUAL
Manual distribution. No link graph calculations are run.
Definition linkgraph_type.h:24
SetupColoursAndInitialWindow
void SetupColoursAndInitialWindow()
Initialise the default colours (remaps and the likes), and load the main windows.
Definition main_gui.cpp:553
DistanceManhattan
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
Definition map.cpp:169
TileAddXY
TileIndex TileAddXY(TileIndex tile, int x, int y)
Adds a given offset to a tile.
Definition map_func.h:483
TileVirtXY
static TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
Definition map_func.h:416
TileAddByDiagDir
TileIndex TileAddByDiagDir(TileIndex tile, DiagDirection dir)
Adds a DiagDir to a tile.
Definition map_func.h:624
TileDiffXY
TileIndexDiff TileDiffXY(int x, int y)
Calculates an offset for the given coordinate(-offset).
Definition map_func.h:401
TileXY
static TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition map_func.h:385
TileY
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition map_func.h:438
TileX
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition map_func.h:428
TileOffsByDiagDir
TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition map_func.h:583
IsInsideMM
constexpr bool IsInsideMM(const size_t x, const size_t min, const size_t max) noexcept
Checks if a value is in an interval.
Definition math_func.hpp:267
CeilDiv
constexpr uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
Definition math_func.hpp:310
Clamp
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition math_func.hpp:79
GenerateSavegameId
void GenerateSavegameId()
Generate an unique savegame ID.
Definition misc.cpp:87
_networking
bool _networking
are we in networking mode?
Definition network.cpp:67
_network_dedicated
bool _network_dedicated
are we a dedicated server?
Definition network.cpp:70
_network_server
bool _network_server
network-server is active
Definition network.cpp:68
GSF_FAKE_TOWNS
@ GSF_FAKE_TOWNS
Fake town GrfSpecFeature for NewGRF debugging (parent scope)
Definition newgrf.h:94
ShowNewGRFError
void ShowNewGRFError()
Show the first NewGRF error we can find.
Definition newgrf_gui.cpp:47
StationGfx
uint8_t StationGfx
Copy from station_map.h.
Definition newgrf_airport.h:23
_grfconfig
GRFConfigList _grfconfig
First item in list of current GRF set up.
Definition newgrf_config.cpp:154
IsGoodGRFConfigList
GRFListCompatibility IsGoodGRFConfigList(GRFConfigList &grfconfig)
Check if all GRFs in the GRF config from a savegame can be loaded.
Definition newgrf_config.cpp:425
GRFListCompatibility
GRFListCompatibility
Status of post-gameload GRF compatibility check.
Definition newgrf_config.h:52
GLC_COMPATIBLE
@ GLC_COMPATIBLE
Compatible (eg. the same ID, but different checksum) GRF found in at least one case.
Definition newgrf_config.h:54
GLC_ALL_GOOD
@ GLC_ALL_GOOD
All GRF needed by game are present.
Definition newgrf_config.h:53
GLC_NOT_FOUND
@ GLC_NOT_FOUND
At least one GRF couldn't be found (higher priority than GLC_COMPATIBLE)
Definition newgrf_config.h:55
GCS_NOT_FOUND
@ GCS_NOT_FOUND
GRF file was not found in the local cache.
Definition newgrf_config.h:36
Compatible
@ Compatible
GRF file does not exactly match the requested GRF (different MD5SUM), but grfid matches)
Definition newgrf_config.h:24
DeleteInvalidEngineNews
void DeleteInvalidEngineNews()
Remove engine announcements for invalid engines.
Definition news_gui.cpp:1056
ObjectType
uint16_t ObjectType
Types of objects.
Definition object_type.h:16
OBJECT_STATUE
static const ObjectType OBJECT_STATUE
Statue in towns.
Definition object_type.h:20
OBJECT_HQ
static const ObjectType OBJECT_HQ
HeadQuarter of a player.
Definition object_type.h:22
PauseMode::Error
@ Error
A game paused because a (critical) error.
PauseMode::ActiveClients
@ ActiveClients
A game paused for 'min_active_clients'.
PauseMode::Normal
@ Normal
A game normally paused.
PauseMode::Join
@ Join
A game paused for 'pause_on_join'.
OrderUnloadType
OrderUnloadType
Unloading order types.
Definition order_type.h:67
OrderUnloadType::Transfer
@ Transfer
Transfer all cargo onto the platform.
OrderStopLocation::FarEnd
@ FarEnd
Stop at the far end of the platform.
OrderNonStopFlag::NoIntermediate
@ NoIntermediate
The vehicle will not stop at any stations it passes except the destination, aka non-stop.
OrderLoadType::NoLoad
@ NoLoad
Do not load anything.
GetCompanyRailTypes
RailTypes GetCompanyRailTypes(CompanyID company, bool introduces)
Get the rail types the given company can build.
Definition rail.cpp:135
InitializeRailGUI
void InitializeRailGUI()
Resets the rail GUI - sets default railtype to build and resets the signal GUI.
Definition rail_gui.cpp:2015
IsPlainRail
static bool IsPlainRail(Tile t)
Returns whether this is plain rails, with or without signals.
Definition rail_map.h:49
GetRailType
RailType GetRailType(Tile t)
Gets the rail type of the given tile.
Definition rail_map.h:115
IsRailDepot
static bool IsRailDepot(Tile t)
Is this rail tile a rail depot?
Definition rail_map.h:95
IsPlainRailTile
static bool IsPlainRailTile(Tile t)
Checks whether the tile is a rail tile or rail tile with signals.
Definition rail_map.h:60
SetTrackReservation
void SetTrackReservation(Tile t, TrackBits b)
Sets the reserved track bits of the tile.
Definition rail_map.h:209
RailGroundType::HalfTileWater
@ HalfTileWater
Grass with a fence and shore or water on the free halftile.
SetDepotReservation
void SetDepotReservation(Tile t, bool b)
Set the reservation state of the depot.
Definition rail_map.h:269
HasSignals
bool HasSignals(Tile t)
Checks if a rail tile has signals.
Definition rail_map.h:72
IsRailDepotTile
static bool IsRailDepotTile(Tile t)
Is this tile rail tile and a rail depot?
Definition rail_map.h:105
SetSignalStates
void SetSignalStates(Tile tile, uint state)
Set the states of the signals (Along/AgainstTrackDir)
Definition rail_map.h:351
SetRailType
void SetRailType(Tile t, RailType r)
Sets the rail type of the given tile.
Definition rail_map.h:125
RailType
RailType
Enumeration for all possible railtypes.
Definition rail_type.h:25
RAILTYPE_ELECTRIC
@ RAILTYPE_ELECTRIC
Electric rails.
Definition rail_type.h:28
RAILTYPE_RAIL
@ RAILTYPE_RAIL
Standard non-electric rails.
Definition rail_type.h:27
_random
Randomizer _random
Random used in the game state calculations.
Definition random_func.cpp:36
GetCompanyRoadTypes
RoadTypes GetCompanyRoadTypes(CompanyID company, bool introduces)
Get the road types the given company can build.
Definition road.cpp:210
UpdateNearestTownForRoadTiles
void UpdateNearestTownForRoadTiles(bool invalidate)
Updates cached nearest town for all road tiles.
Definition road_cmd.cpp:1944
UpdateLevelCrossing
void UpdateLevelCrossing(TileIndex tile, bool sound=true, bool force_bar=false)
Update a level crossing to barred or open (crossing may include multiple adjacent tiles).
Definition train_cmd.cpp:1791
SetRoadOwner
void SetRoadOwner(Tile t, RoadTramType rtt, Owner o)
Set the owner of a specific road type.
Definition road_map.h:235
GetRoadTileType
static RoadTileType GetRoadTileType(Tile t)
Get the type of the road tile.
Definition road_map.h:36
HasTownOwnedRoad
bool HasTownOwnedRoad(Tile t)
Checks if given tile has town owned road.
Definition road_map.h:264
IsLevelCrossingTile
bool IsLevelCrossingTile(Tile t)
Return whether a tile is a level crossing tile.
Definition road_map.h:79
SetRoadTypes
void SetRoadTypes(Tile t, RoadType road_rt, RoadType tram_rt)
Set the present road types of a tile.
Definition road_map.h:604
IsRoadDepot
static bool IsRoadDepot(Tile t)
Return whether a tile is a road depot.
Definition road_map.h:90
RoadTileType::Normal
@ Normal
Normal road.
RoadTileType::Depot
@ Depot
Depot (one entrance)
RoadTileType::Crossing
@ Crossing
Level crossing.
GetCrossingRoadBits
RoadBits GetCrossingRoadBits(Tile tile)
Get the road bits of a level crossing.
Definition road_map.h:332
GetRoadOwner
Owner GetRoadOwner(Tile t, RoadTramType rtt)
Get the owner of a specific road type.
Definition road_map.h:218
SetCrossingReservation
void SetCrossingReservation(Tile t, bool b)
Set the reservation state of the rail crossing.
Definition road_map.h:377
IsLevelCrossing
bool IsLevelCrossing(Tile t)
Return whether a tile is a level crossing.
Definition road_map.h:69
RoadBits
RoadBits
Enumeration for the road parts on a tile.
Definition road_type.h:56
ROAD_Y
@ ROAD_Y
Full road along the y-axis (north-west + south-east)
Definition road_type.h:63
ROAD_X
@ ROAD_X
Full road along the x-axis (south-west + north-east)
Definition road_type.h:62
RoadTramType
RoadTramType
The different types of road type.
Definition road_type.h:37
RTT_ROAD
@ RTT_ROAD
Road road type.
Definition road_type.h:38
RTT_TRAM
@ RTT_TRAM
Tram road type.
Definition road_type.h:39
RoadType
RoadType
The different roadtypes we support.
Definition road_type.h:23
INVALID_ROADTYPE
@ INVALID_ROADTYPE
flag for invalid roadtype
Definition road_type.h:28
ROADTYPE_TRAM
@ ROADTYPE_TRAM
Trams.
Definition road_type.h:26
ROADTYPE_ROAD
@ ROADTYPE_ROAD
Basic road type.
Definition road_type.h:25
RVS_ENTERED_STOP
@ RVS_ENTERED_STOP
Only set when a vehicle has entered the stop.
Definition roadveh.h:43
RVSB_IN_ROAD_STOP
@ RVSB_IN_ROAD_STOP
The vehicle is in a road stop.
Definition roadveh.h:49
RVS_IN_DT_ROAD_STOP
@ RVS_IN_DT_ROAD_STOP
The vehicle is in a drive-through road stop.
Definition roadveh.h:46
RVS_IN_ROAD_STOP
@ RVS_IN_ROAD_STOP
The vehicle is in a road stop.
Definition roadveh.h:45
RVSB_IN_DEPOT
@ RVSB_IN_DEPOT
The vehicle is in a depot.
Definition roadveh.h:38
RVSB_WORMHOLE
@ RVSB_WORMHOLE
The vehicle is in a tunnel and/or bridge.
Definition roadveh.h:39
RVS_DRIVE_SIDE
@ RVS_DRIVE_SIDE
Only used when retrieving move data.
Definition roadveh.h:44
_road_stop_stop_frame
const uint8_t _road_stop_stop_frame[]
Table of road stop stop frames, when to stop at a road stop.
SlError
void SlError(StringID string, const std::string &extra_msg)
Error handler.
Definition saveload.cpp:339
SetSaveLoadError
void SetSaveLoadError(StringID str)
Set the error message from outside of the actual loading/saving of the game (AfterLoadGame and friend...
Definition saveload.cpp:2961
SlErrorCorrupt
void SlErrorCorrupt(const std::string &msg)
Error handler for corrupt savegames.
Definition saveload.cpp:369
_file_to_saveload
FileToSaveLoad _file_to_saveload
File to save or load in the openttd loop.
Definition saveload.cpp:78
IsSavegameVersionBefore
bool IsSavegameVersionBefore(SaveLoadVersion major, uint8_t minor=0)
Checks whether the savegame is below major.
Definition saveload.h:1278
SLV_AI_START_DATE
@ SLV_AI_START_DATE
309 PR#10653 Removal of individual AI start dates and added a generic one.
Definition saveload.h:350
SLV_190
@ SLV_190
190 26547 Separate order travel and wait times
Definition saveload.h:271
SLV_91
@ SLV_91
91 12347
Definition saveload.h:152
SLV_49
@ SLV_49
49 8969
Definition saveload.h:101
SLV_90
@ SLV_90
90 12293
Definition saveload.h:151
SLV_64
@ SLV_64
64 10006
Definition saveload.h:119
SLV_69
@ SLV_69
69 10319
Definition saveload.h:125
SLV_ECONOMY_MODE_TIMEKEEPING_UNITS
@ SLV_ECONOMY_MODE_TIMEKEEPING_UNITS
327 PR#11341 Mode to display economy measurements in wallclock units.
Definition saveload.h:372
SLV_PROTECT_PLACED_HOUSES
@ SLV_PROTECT_PLACED_HOUSES
351 PR#13270 Houses individually placed by players can be protected from town/AI removal.
Definition saveload.h:401
SLV_172
@ SLV_172
172 23947
Definition saveload.h:249
SLV_COMPANY_INAUGURATED_PERIOD_V2
@ SLV_COMPANY_INAUGURATED_PERIOD_V2
349 PR#13448 Fix savegame storage for company inaugurated year in wallclock mode.
Definition saveload.h:398
SLV_182
@ SLV_182
182 25115 FS#5492, r25259, r25296 Goal status
Definition saveload.h:261
SLV_186
@ SLV_186
186 25833 Objects storage
Definition saveload.h:266
SLV_175
@ SLV_175
175 24136
Definition saveload.h:253
SLV_16
@ SLV_16
16.0 2817 16.1 3155
Definition saveload.h:60
SLV_87
@ SLV_87
87 12129
Definition saveload.h:147
SLV_SERVE_NEUTRAL_INDUSTRIES
@ SLV_SERVE_NEUTRAL_INDUSTRIES
210 PR#7234 Company stations can serve industries with attached neutral stations.
Definition saveload.h:296
SLV_147
@ SLV_147
147 20621
Definition saveload.h:219
SLV_188
@ SLV_188
188 26169 v1.4 FS#5831 Unify RV travel time
Definition saveload.h:268
SLV_61
@ SLV_61
61 9892
Definition saveload.h:116
SLV_84
@ SLV_84
84 11822
Definition saveload.h:143
SLV_25
@ SLV_25
25 4259
Definition saveload.h:73
SLV_15
@ SLV_15
15.0 2499
Definition saveload.h:59
SLV_198
@ SLV_198
198 PR#6763 Switch town growth rate and counter to actual game ticks
Definition saveload.h:281
SLV_36
@ SLV_36
36 6624
Definition saveload.h:86
SLV_26
@ SLV_26
26 4466
Definition saveload.h:74
SLV_96
@ SLV_96
96 13226
Definition saveload.h:158
SLV_EXTEND_RAILTYPES
@ SLV_EXTEND_RAILTYPES
200 PR#6805 Extend railtypes to 64, adding uint16_t to map array.
Definition saveload.h:284
SLV_17
@ SLV_17
17.0 3212 17.1 3218
Definition saveload.h:62
SLV_42
@ SLV_42
42 7573
Definition saveload.h:93
SLV_177
@ SLV_177
177 24619
Definition saveload.h:255
SLV_EXTEND_INDUSTRY_CARGO_SLOTS
@ SLV_EXTEND_INDUSTRY_CARGO_SLOTS
202 PR#6867 Increase industry cargo slots to 16 in, 16 out
Definition saveload.h:286
SLV_103
@ SLV_103
103 14598
Definition saveload.h:166
SLV_100
@ SLV_100
100 13952
Definition saveload.h:163
SLV_GROUP_REPLACE_WAGON_REMOVAL
@ SLV_GROUP_REPLACE_WAGON_REMOVAL
291 PR#7441 Per-group wagon removal flag.
Definition saveload.h:329
SLV_VELOCITY_NAUTICAL
@ SLV_VELOCITY_NAUTICAL
305 PR#10594 Separation of land and nautical velocity (knots!)
Definition saveload.h:346
SLV_VEHICLE_ECONOMY_AGE
@ SLV_VEHICLE_ECONOMY_AGE
334 PR#12141 v14.0 Add vehicle age in economy year, for profit stats minimum age
Definition saveload.h:380
SLV_4
@ SLV_4
4.0 1 4.1 122 0.3.3, 0.3.4 4.2 1222 0.3.5 4.3 1417 4.4 1426
Definition saveload.h:37
SLV_TOWN_CARGOGEN
@ SLV_TOWN_CARGOGEN
208 PR#6965 New algorithms for town building cargo generation.
Definition saveload.h:293
SLV_149
@ SLV_149
149 20832
Definition saveload.h:221
SLV_83
@ SLV_83
83 11589
Definition saveload.h:142
SLV_6
@ SLV_6
6.0 1721 6.1 1768
Definition saveload.h:46
SLV_34
@ SLV_34
34 6455
Definition saveload.h:83
SLV_LINKGRAPH_SECONDS
@ SLV_LINKGRAPH_SECONDS
308 PR#10610 Store linkgraph update intervals in seconds instead of days.
Definition saveload.h:349
SLV_114
@ SLV_114
114 15601
Definition saveload.h:179
SLV_137
@ SLV_137
137 18912
Definition saveload.h:207
SLV_SAVEGAME_ID
@ SLV_SAVEGAME_ID
313 PR#10719 Add an unique ID to every savegame (used to deduplicate surveys).
Definition saveload.h:355
SLV_131
@ SLV_131
131 18481
Definition saveload.h:200
SLV_11
@ SLV_11
11.0 2033 11.1 2041
Definition saveload.h:53
SLV_CALENDAR_SUB_DATE_FRACT
@ SLV_CALENDAR_SUB_DATE_FRACT
328 PR#11428 Add sub_date_fract to measure calendar days.
Definition saveload.h:373
SLV_120
@ SLV_120
120 16439
Definition saveload.h:187
SLV_99
@ SLV_99
99 13838
Definition saveload.h:161
SLV_123
@ SLV_123
123 16909
Definition saveload.h:190
SLV_46
@ SLV_46
46 8705
Definition saveload.h:98
SLV_122
@ SLV_122
122 16855
Definition saveload.h:189
SLV_FACE_STYLES
@ SLV_FACE_STYLES
355 PR#14319 Addition of face styles, replacing gender and ethnicity.
Definition saveload.h:406
SLV_ENDING_YEAR
@ SLV_ENDING_YEAR
218 PR#7747 v1.10 Configurable ending year.
Definition saveload.h:305
SLV_141
@ SLV_141
141 19799
Definition saveload.h:212
SLV_112
@ SLV_112
112 15290
Definition saveload.h:177
SLV_125
@ SLV_125
125 17113
Definition saveload.h:193
SLV_166
@ SLV_166
166 23415
Definition saveload.h:242
SLV_98
@ SLV_98
98 13375
Definition saveload.h:160
SLV_WATER_TILE_TYPE
@ SLV_WATER_TILE_TYPE
342 PR#13030 Simplify water tile type.
Definition saveload.h:390
SLV_117
@ SLV_117
117 16037
Definition saveload.h:183
SLV_140
@ SLV_140
140 19382
Definition saveload.h:211
SLV_126
@ SLV_126
126 17433
Definition saveload.h:194
SLV_138
@ SLV_138
138 18942 1.0.x
Definition saveload.h:208
SLV_ANIMATED_TILE_STATE_IN_MAP
@ SLV_ANIMATED_TILE_STATE_IN_MAP
347 PR#13082 Animated tile state saved for improved performance.
Definition saveload.h:396
SLV_MULTITILE_DOCKS
@ SLV_MULTITILE_DOCKS
216 PR#7380 Multiple docks per station.
Definition saveload.h:303
SLV_86
@ SLV_86
86 12042
Definition saveload.h:146
SLV_ROAD_TYPES
@ SLV_ROAD_TYPES
214 PR#6811 NewGRF road types.
Definition saveload.h:300
SLV_1
@ SLV_1
1.0 0.1.x, 0.2.x
Definition saveload.h:33
SLV_GS_INDUSTRY_CONTROL
@ SLV_GS_INDUSTRY_CONTROL
287 PR#7912 and PR#8115 GS industry control.
Definition saveload.h:324
SLV_164
@ SLV_164
164 23290
Definition saveload.h:239
SLV_160
@ SLV_160
160 21974 1.1.x
Definition saveload.h:235
SLV_38
@ SLV_38
38 7195
Definition saveload.h:88
SLV_145
@ SLV_145
145 20376
Definition saveload.h:217
SLV_48
@ SLV_48
48 8935
Definition saveload.h:100
SLV_57
@ SLV_57
57 9691
Definition saveload.h:111
SLV_104
@ SLV_104
104 14735
Definition saveload.h:167
SLV_52
@ SLV_52
52 9066
Definition saveload.h:105
SLV_134
@ SLV_134
134 18703
Definition saveload.h:203
SLV_165
@ SLV_165
165 23304
Definition saveload.h:241
SLV_144
@ SLV_144
144 20334
Definition saveload.h:215
SLV_2
@ SLV_2
2.0 0.3.0 2.1 0.3.1, 0.3.2
Definition saveload.h:34
SLV_INCREASE_HOUSE_LIMIT
@ SLV_INCREASE_HOUSE_LIMIT
348 PR#12288 Increase house limit to 4096.
Definition saveload.h:397
SLV_143
@ SLV_143
143 20048
Definition saveload.h:214
SLV_127
@ SLV_127
127 17439
Definition saveload.h:195
SLV_152
@ SLV_152
152 21171
Definition saveload.h:225
SLV_LAST_LOADING_TICK
@ SLV_LAST_LOADING_TICK
301 PR#9693 Store tick of last loading for vehicles.
Definition saveload.h:341
SLV_76
@ SLV_76
76 11139
Definition saveload.h:134
SLV_SCRIPT_RANDOMIZER
@ SLV_SCRIPT_RANDOMIZER
333 PR#12063 v14.0-RC1 Save script randomizers.
Definition saveload.h:379
SLV_78
@ SLV_78
78 11176
Definition saveload.h:136
SLV_106
@ SLV_106
106 14919
Definition saveload.h:170
SLV_DEPOT_UNBUNCHING
@ SLV_DEPOT_UNBUNCHING
331 PR#11945 Allow unbunching shared order vehicles at a depot.
Definition saveload.h:377
SLV_119
@ SLV_119
119 16242
Definition saveload.h:185
SLV_139
@ SLV_139
139 19346
Definition saveload.h:209
SLV_SHIP_ACCELERATION
@ SLV_SHIP_ACCELERATION
329 PR#10734 Start using Vehicle's acceleration field for ships too.
Definition saveload.h:374
SLV_135
@ SLV_135
135 18719
Definition saveload.h:205
SLV_MULTITRACK_LEVEL_CROSSINGS
@ SLV_MULTITRACK_LEVEL_CROSSINGS
302 PR#9931 v13.0 Multi-track level crossings.
Definition saveload.h:342
SLV_121
@ SLV_121
121 16694
Definition saveload.h:188
SLV_192
@ SLV_192
192 26700 FS#6066 Fix saving of order backups
Definition saveload.h:274
SLV_58
@ SLV_58
58 9762
Definition saveload.h:112
SLV_94
@ SLV_94
94 12816
Definition saveload.h:155
SLV_153
@ SLV_153
153 21263
Definition saveload.h:226
SLV_101
@ SLV_101
101 14233
Definition saveload.h:164
SLV_95
@ SLV_95
95 12924
Definition saveload.h:157
SLV_158
@ SLV_158
158 21933
Definition saveload.h:232
SLV_133
@ SLV_133
133 18674
Definition saveload.h:202
SLV_93
@ SLV_93
93 12648
Definition saveload.h:154
SLV_81
@ SLV_81
81 11244
Definition saveload.h:140
SLV_72
@ SLV_72
72 10601
Definition saveload.h:129
SLV_43
@ SLV_43
43 7642
Definition saveload.h:94
SLV_113
@ SLV_113
113 15340
Definition saveload.h:178
SLV_ECONOMY_DATE
@ SLV_ECONOMY_DATE
326 PR#10700 Split calendar and economy timers and dates.
Definition saveload.h:371
SLV_45
@ SLV_45
45 8501
Definition saveload.h:97
SLV_128
@ SLV_128
128 18281
Definition saveload.h:196
SLV_GROUP_NUMBERS
@ SLV_GROUP_NUMBERS
336 PR#12297 Add per-company group numbers.
Definition saveload.h:383
SLV_NEWGRF_LAST_SERVICE
@ SLV_NEWGRF_LAST_SERVICE
317 PR#11124 Added stable date_of_last_service to avoid NewGRF trouble.
Definition saveload.h:360
SLV_53
@ SLV_53
53 9316
Definition saveload.h:106
SLV_161
@ SLV_161
161 22567
Definition saveload.h:236
SLV_74
@ SLV_74
74 11030
Definition saveload.h:131
SLV_184
@ SLV_184
184 25508 Unit localisation split
Definition saveload.h:263
SLV_INCREASE_STATION_TYPE_FIELD_SIZE
@ SLV_INCREASE_STATION_TYPE_FIELD_SIZE
337 PR#12572 Increase size of StationType field in map array
Definition saveload.h:384
SLV_88
@ SLV_88
88 12134
Definition saveload.h:148
SLV_156
@ SLV_156
156 21728
Definition saveload.h:230
SLV_NONFLOODING_WATER_TILES
@ SLV_NONFLOODING_WATER_TILES
345 PR#13013 Store water tile non-flooding state.
Definition saveload.h:394
SLV_62
@ SLV_62
62 9905
Definition saveload.h:117
SLV_59
@ SLV_59
59 9779
Definition saveload.h:113
SLV_82
@ SLV_82
82 11410
Definition saveload.h:141
SLV_194
@ SLV_194
194 26881 v1.5
Definition saveload.h:276
SLV_TREES_WATER_CLASS
@ SLV_TREES_WATER_CLASS
213 PR#7405 WaterClass update for tree tiles.
Definition saveload.h:299
SLV_124
@ SLV_124
124 16993
Definition saveload.h:191
SLV_159
@ SLV_159
159 21962
Definition saveload.h:233
SLV_32
@ SLV_32
32 6001
Definition saveload.h:81
SLV_56
@ SLV_56
56 9667
Definition saveload.h:110
SLV_SHIPS_STOP_IN_LOCKS
@ SLV_SHIPS_STOP_IN_LOCKS
206 PR#7150 Ship/lock movement changes.
Definition saveload.h:291
SLV_111
@ SLV_111
111 15190
Definition saveload.h:176
SLV_70
@ SLV_70
70 10541
Definition saveload.h:127
SLV_183
@ SLV_183
183 25363 Cargodist
Definition saveload.h:262
SLV_31
@ SLV_31
31 5999
Definition saveload.h:80
SLV_148
@ SLV_148
148 20659
Definition saveload.h:220
SLV_50
@ SLV_50
50 8973
Definition saveload.h:103
SLV_REPAIR_OBJECT_DOCKING_TILES
@ SLV_REPAIR_OBJECT_DOCKING_TILES
299 PR#9594 v12.0 Fixing issue with docking tiles overlapping objects.
Definition saveload.h:338
SLV_CONSISTENT_PARTIAL_Z
@ SLV_CONSISTENT_PARTIAL_Z
306 PR#10570 Conversion from an inconsistent partial Z calculation for slopes, to one that is (more) ...
Definition saveload.h:347
SLV_142
@ SLV_142
142 20003
Definition saveload.h:213
SLV_21
@ SLV_21
21 3472 0.4.x
Definition saveload.h:68
SLV_136
@ SLV_136
136 18764
Definition saveload.h:206
SLV_146
@ SLV_146
146 20446
Definition saveload.h:218
SLV_SCRIPT_SAVE_INSTANCES
@ SLV_SCRIPT_SAVE_INSTANCES
352 PR#13556 Scripts are allowed to save instances.
Definition saveload.h:402
SLV_MAX_LOAN_FOR_COMPANY
@ SLV_MAX_LOAN_FOR_COMPANY
330 PR#11224 Separate max loan for each company.
Definition saveload.h:376
SLV_24
@ SLV_24
24 4150
Definition saveload.h:71
SLV_9
@ SLV_9
9.0 1909
Definition saveload.h:50
IsSavegameVersionBeforeOrAt
bool IsSavegameVersionBeforeOrAt(SaveLoadVersion major)
Checks whether the savegame is below or at major.
Definition saveload.h:1292
saveload_internal.h
Declaration of functions used in more save/load files.
AfterLoadVehiclesPhase1
void AfterLoadVehiclesPhase1(bool part_of_load)
Called after load for phase 1 of vehicle initialisation.
Definition vehicle_sl.cpp:256
ResetOldNames
void ResetOldNames()
Free the memory of the old names array.
Definition strings_sl.cpp:100
FixupTrainLengths
void FixupTrainLengths()
Fixup old train spacing.
Definition vehicle_sl.cpp:554
MoveBuoysToWaypoints
void MoveBuoysToWaypoints()
Perform all steps to upgrade from the old station buoys to the new version that uses waypoints.
Definition station_sl.cpp:45
UpdateOldAircraft
void UpdateOldAircraft()
need to be called to load aircraft from old version
Definition vehicle_sl.cpp:165
ConvertOldMultiheadToNew
void ConvertOldMultiheadToNew()
Converts all trains to the new subtype format introduced in savegame 16.2 It also links multiheaded e...
Definition vehicle_sl.cpp:113
ConnectMultiheadedTrains
void ConnectMultiheadedTrains()
Link front and rear multiheaded engines to each other This is done when loading a savegame.
Definition vehicle_sl.cpp:35
AfterLoadRoadStops
void AfterLoadRoadStops()
(Re)building of road stop caches after loading a savegame.
Definition station_sl.cpp:144
MoveWaypointsToBaseStations
void MoveWaypointsToBaseStations()
Perform all steps to upgrade from the old waypoints to the new version that uses station.
Definition waypoint_sl.cpp:68
AfterLoadVehiclesPhase2
void AfterLoadVehiclesPhase2(bool part_of_load)
Called after load for phase 2 of vehicle initialisation.
Definition vehicle_sl.cpp:420
UpdateHousesAndTowns
void UpdateHousesAndTowns()
Check and update town and house values.
Definition town_sl.cpp:65
CopyFromOldName
std::string CopyFromOldName(StringID id)
Copy and convert old custom names to UTF-8.
Definition strings_sl.cpp:59
AfterLoadStoryBook
void AfterLoadStoryBook()
Called after load to trash broken pages.
Definition story_sl.cpp:20
ShowScriptDebugWindowIfScriptError
void ShowScriptDebugWindowIfScriptError()
Open the AI debug window if one of the AI scripts has crashed.
Definition script_gui.cpp:1304
_old_vds
VehicleDefaultSettings _old_vds
Used for loading default vehicles settings from old savegames.
Definition settings.cpp:63
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:61
_settings_newgame
GameSettings _settings_newgame
Game settings for new games (updated from the intro screen).
Definition settings.cpp:62
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:60
SIGTYPE_COMBO
@ SIGTYPE_COMBO
presignal inter-block
Definition signal_type.h:27
SIG_SEMAPHORE
@ SIG_SEMAPHORE
Old-fashioned semaphore signal.
Definition signal_type.h:18
SIG_ELECTRIC
@ SIG_ELECTRIC
Light signal.
Definition signal_type.h:17
UpdateAllSignVirtCoords
void UpdateAllSignVirtCoords()
Update the coordinates of all signs.
Definition signs.cpp:50
GetInclinedSlopeDirection
DiagDirection GetInclinedSlopeDirection(Slope s)
Returns the direction of an inclined slope.
Definition slope_func.h:239
BuildOwnerLegend
void BuildOwnerLegend()
Completes the array for the owned property legend.
Definition smallmap_gui.cpp:341
SourceType::Industry
@ Industry
Source/destination is an industry.
SourceType::Town
@ Town
Source/destination is a town.
UpdateAllStationVirtCoords
void UpdateAllStationVirtCoords()
Update the virtual coords needed to draw the station sign for all stations.
Definition station_cmd.cpp:464
UpdateAirportsNoise
void UpdateAirportsNoise()
Recalculate the noise generated by the airports of each town.
Definition station_cmd.cpp:2604
UpdateStationAcceptance
void UpdateStationAcceptance(Station *st, bool show_msg)
Update the acceptance for a station.
Definition station_cmd.cpp:611
GetStationType
StationType GetStationType(Tile t)
Get the station type of this tile.
Definition station_map.h:44
GetStationGfx
StationGfx GetStationGfx(Tile t)
Get the station graphics of this tile.
Definition station_map.h:68
SetStationGfx
void SetStationGfx(Tile t, StationGfx gfx)
Set the station graphics of this tile.
Definition station_map.h:80
IsAirportTile
bool IsAirportTile(Tile t)
Is this tile a station tile and an airport tile?
Definition station_map.h:167
IsBayRoadStopTile
bool IsBayRoadStopTile(Tile t)
Is tile t a bay (non-drive through) road stop station?
Definition station_map.h:266
IsBuoy
bool IsBuoy(Tile t)
Is tile t a buoy tile?
Definition station_map.h:400
IsDriveThroughStopTile
bool IsDriveThroughStopTile(Tile t)
Is tile t a drive through road stop station or waypoint?
Definition station_map.h:276
HasStationTileRail
bool HasStationTileRail(Tile t)
Has this station tile a rail? In other words, is this station tile a rail station or rail waypoint?
Definition station_map.h:146
SetRailStationReservation
void SetRailStationReservation(Tile t, bool b)
Set the reservation state of the rail station.
Definition station_map.h:571
IsAnyRoadStop
bool IsAnyRoadStop(Tile t)
Is the station at t a road station?
Definition station_map.h:245
IsStationTileBlocked
bool IsStationTileBlocked(Tile t)
Is tile t a blocked tile?
Definition station_map.h:431
IsTruckStop
bool IsTruckStop(Tile t)
Is the station at t a truck stop?
Definition station_map.h:180
IsStationRoadStop
bool IsStationRoadStop(Tile t)
Is the station at t a road station?
Definition station_map.h:223
HasStationRail
bool HasStationRail(Tile t)
Has this station tile a rail? In other words, is this station tile a rail station or rail waypoint?
Definition station_map.h:135
GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET
static const int GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET
The offset for the drive through parts.
Definition station_map.h:36
IsOilRig
bool IsOilRig(Tile t)
Is tile t part of an oilrig?
Definition station_map.h:368
IsBuoyTile
bool IsBuoyTile(Tile t)
Is tile t a buoy tile?
Definition station_map.h:410
IsDock
bool IsDock(Tile t)
Is tile t a dock tile?
Definition station_map.h:379
StationFacility::Dock
@ Dock
Station with a dock.
StationFacility::Train
@ Train
Station with train station.
StationFacility::Airport
@ Airport
Station with an airport.
StationType
StationType
Station types.
Definition station_type.h:29
FormatArrayAsHex
std::string FormatArrayAsHex(std::span< const uint8_t > data)
Format a byte array into a continuous hex string.
Definition string.cpp:77
GetEncodedString
EncodedString GetEncodedString(StringID str)
Encode a string with no parameters into an encoded string.
Definition strings.cpp:90
SPECSTR_PRESIDENT_NAME
static constexpr StringID SPECSTR_PRESIDENT_NAME
Special string for the president's name.
Definition strings_type.h:73
SPECSTR_TOWNNAME_START
static constexpr StringID SPECSTR_TOWNNAME_START
Special strings for town names.
Definition strings_type.h:64
AircraftVehicleInfo
Information about a aircraft vehicle.
Definition engine_type.h:132
Aircraft
Aircraft, helicopters, rotors and their shadows belong to this class.
Definition aircraft.h:72
Backup
Class to backup a specific variable and restore it later.
Definition backup_type.hpp:21
Backup::Restore
void Restore()
Restore the variable.
Definition backup_type.hpp:110
BaseStation
Base class for all station-ish types.
Definition base_station_base.h:58
BaseStation::train_station
TileArea train_station
Tile area the train 'station' part covers.
Definition base_station_base.h:83
BaseStation::owner
Owner owner
The owner of this station.
Definition base_station_base.h:68
BaseStation::rect
StationRect rect
NOSAVE: Station spread out rectangle maintained by StationRect::xxx() functions.
Definition base_station_base.h:84
BaseStation::town
Town * town
The town this station is associated with.
Definition base_station_base.h:67
BaseStation::GetByTile
static BaseStation * GetByTile(TileIndex tile)
Get the base station belonging to a specific tile.
Definition base_station_base.h:160
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition vehicle_type.h:51
CargoPacket::AfterLoad
static void AfterLoad()
Savegame conversion for cargopackets.
Definition cargopacket_sl.cpp:23
CargoPayment
Helper class to perform the cargo payment.
Definition economy_base.h:23
CargoSpec
Specification of a cargo type.
Definition cargotype.h:74
CargoSpec::Get
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo type.
Definition cargotype.h:137
CargoSpec::town_acceptance_effect
TownAcceptanceEffect town_acceptance_effect
The effect that delivering this cargo type has on towns. Also affects destination of subsidies.
Definition cargotype.h:86
ClientSettings::company
CompanySettings company
default values for per-company settings
Definition settings_type.h:652
ClosestDepot
Structure to return information about the closest depot location, and whether it could be found.
Definition vehicle_base.h:192
CompanyProperties::settings
CompanySettings settings
settings specific for each company
Definition company_base.h:124
Company
Definition company_base.h:127
Company::IsValidAiID
static bool IsValidAiID(auto index)
Is this company a valid company, controlled by the computer (a NoAI program)?
Definition company_base.h:153
ConstructionSettings::freeform_edges
bool freeform_edges
allow terraforming the tiles at the map edges
Definition settings_type.h:423
ConstructionSettings::max_bridge_length
uint16_t max_bridge_length
maximum length of bridges
Definition settings_type.h:413
ConstructionSettings::terraform_frame_burst
uint16_t terraform_frame_burst
how many tile heights may, over a short period, be terraformed?
Definition settings_type.h:428
ConstructionSettings::max_tunnel_length
uint16_t max_tunnel_length
maximum length of tunnels
Definition settings_type.h:415
ConstructionSettings::tree_frame_burst
uint16_t tree_frame_burst
how many trees may, over a short period, be planted?
Definition settings_type.h:432
ConstructionSettings::map_height_limit
uint8_t map_height_limit
the maximum allowed heightlevel
Definition settings_type.h:410
ConstructionSettings::clear_frame_burst
uint16_t clear_frame_burst
how many tiles may, over a short period, be cleared?
Definition settings_type.h:430
Depot
Definition depot_base.h:20
DifficultySettings::number_towns
uint8_t number_towns
the amount of towns
Definition settings_type.h:127
DifficultySettings::max_loan
uint32_t max_loan
the maximum initial loan
Definition settings_type.h:129
DifficultySettings::competitors_interval
uint16_t competitors_interval
the interval (in minutes) between adding competitors
Definition settings_type.h:126
DifficultySettings::industry_density
uint8_t industry_density
The industry density.
Definition settings_type.h:128
DisasterVehicle
Disasters, like submarines, skyrangers and their shadows, belong to this class.
Definition disaster_vehicle.h:37
EconomySettings::town_layout
TownLayout town_layout
select town layout,
Definition settings_type.h:555
EconomySettings::timekeeping_units
TimekeepingUnits timekeeping_units
time units to use for the game economy, either calendar or wallclock
Definition settings_type.h:564
EconomySettings::allow_town_level_crossings
bool allow_town_level_crossings
towns are allowed to build level crossings
Definition settings_type.h:562
EconomySettings::allow_town_roads
bool allow_town_roads
towns are allowed to build roads (always allowed when generating world / in SE)
Definition settings_type.h:557
EconomySettings::station_noise_level
bool station_noise_level
build new airports when the town noise level is still within accepted limits
Definition settings_type.h:560
EconomySettings::infrastructure_maintenance
bool infrastructure_maintenance
enable monthly maintenance fee for owner infrastructure
Definition settings_type.h:563
EconomySettings::minutes_per_calendar_year
uint16_t minutes_per_calendar_year
minutes per calendar year. Special value 0 means that calendar time is frozen.
Definition settings_type.h:565
EconomySettings::feeder_payment_share
uint8_t feeder_payment_share
percentage of leg payment to virtually pay in feeder systems
Definition settings_type.h:544
EconomySettings::town_cargogen_mode
TownCargoGenMode town_cargogen_mode
algorithm for generating cargo from houses,
Definition settings_type.h:556
EconomySettings::larger_towns
uint8_t larger_towns
the number of cities to build. These start off larger and grow twice as fast
Definition settings_type.h:553
Economy::inflation_payment
uint64_t inflation_payment
Cumulated inflation of cargo payment since game start; 16 bit fractional part.
Definition economy_type.h:53
Economy::inflation_prices
uint64_t inflation_prices
Cumulated inflation of prices since game start; 16 bit fractional part.
Definition economy_type.h:52
Economy::old_max_loan_unround
Money old_max_loan_unround
Old: Unrounded max loan.
Definition economy_type.h:56
Economy::old_max_loan_unround_fract
uint16_t old_max_loan_unround_fract
Old: Fraction of the unrounded max loan.
Definition economy_type.h:57
EngineInfo::misc_flags
EngineMiscFlags misc_flags
Miscellaneous flags.
Definition engine_type.h:209
FileToSaveLoad::ftype
FiosType ftype
File type.
Definition saveload.h:429
FiosType::abstract
AbstractFileType abstract
Abstract file type.
Definition fileio_type.h:64
GRFIdentifier
Basic data to distinguish a GRF.
Definition newgrf_config.h:83
GRFIdentifier::md5sum
MD5Hash md5sum
MD5 checksum of file to distinguish files with the same GRF ID (eg. newer version of GRF)
Definition newgrf_config.h:85
GameCreationSettings::ending_year
TimerGameCalendar::Year ending_year
scoring end date
Definition settings_type.h:381
GameCreationSettings::landscape
LandscapeType landscape
the landscape we're currently in
Definition settings_type.h:395
GameCreationSettings::snow_line_height
uint8_t snow_line_height
the configured snow line height (deduced from "snow_coverage")
Definition settings_type.h:386
GameCreationSettings::town_name
uint8_t town_name
the town name generator used for town names
Definition settings_type.h:394
GameCreationSettings::starting_year
TimerGameCalendar::Year starting_year
starting date
Definition settings_type.h:380
GameSettings::locale
LocaleSettings locale
settings related to used currency/unit system in the current game
Definition settings_type.h:645
GameSettings::pf
PathfinderSettings pf
settings for all pathfinders
Definition settings_type.h:639
GameSettings::economy
EconomySettings economy
settings to change the economy
Definition settings_type.h:642
GameSettings::construction
ConstructionSettings construction
construction of things in-game
Definition settings_type.h:635
GameSettings::difficulty
DifficultySettings difficulty
settings related to the difficulty
Definition settings_type.h:633
GameSettings::game_creation
GameCreationSettings game_creation
settings used during the creation of a game (map)
Definition settings_type.h:634
GameSettings::station
StationSettings station
settings related to station management
Definition settings_type.h:644
GameSettings::vehicle
VehicleSettings vehicle
options for vehicles
Definition settings_type.h:641
GameSettings::linkgraph
LinkGraphSettings linkgraph
settings for link graph calculations
Definition settings_type.h:643
GoodsEntry
Stores station stats for a single cargo.
Definition station_base.h:167
GoodsEntry::State::Rating
@ Rating
This indicates whether a cargo has a rating at the station.
GroundVehicle::gv_flags
uint16_t gv_flags
Definition ground_vehicle.hpp:84
GroupStatistics::UpdateAfterLoad
static void UpdateAfterLoad()
Update all caches after loading a game, changing NewGRF, etc.
Definition group_cmd.cpp:120
Group
Group data.
Definition group.h:73
HouseSpec
Definition house.h:98
HouseSpec::Get
static HouseSpec * Get(size_t house_id)
Get the spec for a house ID.
Definition newgrf_house.cpp:70
HouseSpec::extra_flags
HouseExtraFlags extra_flags
some more flags
Definition house.h:118
IndustryBuildData::Reset
void Reset()
Completely reset the industry build data.
Definition industry_cmd.cpp:2436
IndustrySpec
Defines the data structure for constructing industry.
Definition industrytype.h:103
IndustrySpec::accepts_cargo
std::array< CargoType, INDUSTRY_NUM_INPUTS > accepts_cargo
16 accepted cargoes.
Definition industrytype.h:117
IndustrySpec::behaviour
IndustryBehaviours behaviour
How this industry will behave, and how others entities can use it.
Definition industrytype.h:121
Industry
Defines the internal data of a functional industry.
Definition industry.h:62
Industry::GetByTile
static Industry * GetByTile(TileIndex tile)
Get the industry of the given tile.
Definition industry.h:251
LinkGraphSettings::recalc_time
uint16_t recalc_time
time (in days) for recalculating each link graph component.
Definition settings_type.h:571
LinkGraphSettings::distribution_mail
DistributionType distribution_mail
distribution type for mail
Definition settings_type.h:574
LinkGraphSettings::distribution_default
DistributionType distribution_default
distribution type for all other goods
Definition settings_type.h:576
LinkGraphSettings::distribution_pax
DistributionType distribution_pax
distribution type for passengers
Definition settings_type.h:573
LinkGraphSettings::distribution_armoured
DistributionType distribution_armoured
distribution type for armoured cargo class
Definition settings_type.h:575
LinkGraphSettings::recalc_interval
uint16_t recalc_interval
time (in days) between subsequent checks for link graphs to be calculated.
Definition settings_type.h:572
LocaleSettings::units_velocity_nautical
uint8_t units_velocity_nautical
unit system for velocity of ships and aircraft
Definition settings_type.h:297
LocaleSettings::currency
uint8_t currency
currency we currently use
Definition settings_type.h:295
LocaleSettings::units_velocity
uint8_t units_velocity
unit system for velocity of trains and road vehicles
Definition settings_type.h:296
LocaleSettings::units_power
uint8_t units_power
unit system for power
Definition settings_type.h:298
LocaleSettings::units_height
uint8_t units_height
unit system for height
Definition settings_type.h:302
LocaleSettings::units_force
uint8_t units_force
unit system for force
Definition settings_type.h:301
LocaleSettings::units_volume
uint8_t units_volume
unit system for volume
Definition settings_type.h:300
LocaleSettings::units_weight
uint8_t units_weight
unit system for weight
Definition settings_type.h:299
Map
Size related data of the map.
Definition map_func.h:206
Map::SizeX
static uint SizeX()
Get the size of the map along the X.
Definition map_func.h:272
Map::SizeY
static uint SizeY()
Get the size of the map along the Y.
Definition map_func.h:281
Map::Iterate
static IterateWrapper Iterate()
Returns an iterable ensemble of all Tiles.
Definition map_func.h:375
Map::MaxY
static uint MaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
Definition map_func.h:308
Map::MaxX
static uint MaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition map_func.h:299
Object
An object, such as transmitter, on the map.
Definition object_base.h:23
Object::type
ObjectType type
Type of the object.
Definition object_base.h:24
Object::town
Town * town
Town the object is built in.
Definition object_base.h:25
Object::IncTypeCount
static void IncTypeCount(ObjectType type)
Increment the count of objects for this type.
Definition object_base.h:45
Object::build_date
TimerGameCalendar::Date build_date
Date of construction.
Definition object_base.h:27
Object::location
TileArea location
Location of the object.
Definition object_base.h:26
OrderBackup
Data for backing up an order of a vehicle so it can be restored after a vehicle is rebuilt in the sam...
Definition order_backup.h:33
OrderList
Shared order list linking together the linked list of orders and the list of vehicles sharing this or...
Definition order_base.h:274
Order
Definition order_base.h:33
Order::IsType
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition order_base.h:66
OrthogonalTileArea::w
uint16_t w
The width of the area.
Definition tilearea_type.h:20
OrthogonalTileArea::tile
TileIndex tile
The base tile of the area.
Definition tilearea_type.h:19
OrthogonalTileArea::h
uint16_t h
The height of the area.
Definition tilearea_type.h:21
PathfinderSettings::wait_for_pbs_path
uint8_t wait_for_pbs_path
how long to wait for a path reservation.
Definition settings_type.h:500
PathfinderSettings::wait_oneway_signal
uint8_t wait_oneway_signal
waitingtime in days before a oneway signal
Definition settings_type.h:496
PathfinderSettings::reverse_at_signals
bool reverse_at_signals
whether to reverse at signals at all
Definition settings_type.h:495
PathfinderSettings::forbid_90_deg
bool forbid_90_deg
forbid trains to make 90 deg turns
Definition settings_type.h:493
PathfinderSettings::wait_twoway_signal
uint8_t wait_twoway_signal
waitingtime in days before a twoway signal
Definition settings_type.h:497
PoolID< uint8_t, struct CompanyIDTag, 0xF, 0xFF >
Pool::PoolItem<&_company_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition pool_type.hpp:436
Pool::PoolItem<&_town_pool >::Get
static Titem * Get(auto index)
Returns Titem with given index.
Definition pool_type.hpp:387
Pool::PoolItem<&_town_pool >::GetNumItems
static size_t GetNumItems()
Returns number of valid items in the pool.
Definition pool_type.hpp:417
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition pool_type.hpp:286
Pool::PoolItem<&_roadstop_pool >::CanAllocateItem
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition pool_type.hpp:357
Pool::PoolItem<&_company_pool >::IsValidID
static bool IsValidID(auto index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition pool_type.hpp:376
Pool::PoolItem<&_company_pool >::GetIfValid
static Titem * GetIfValid(auto index)
Returns Titem with given index.
Definition pool_type.hpp:398
Pool::MAX_SIZE
static constexpr size_t MAX_SIZE
Make template parameter accessible from outside.
Definition pool_type.hpp:135
RailVehicleInfo::railtypes
RailTypes railtypes
Railtypes, mangled if elrail is disabled.
Definition engine_type.h:78
RoadStop
A Stop for a Road Vehicle.
Definition roadstop_base.h:21
RoadVehicle
Buses, trucks and trams belong to this class.
Definition roadveh.h:98
RoadVehicle::state
uint8_t state
Definition roadveh.h:100
RoadVehicle::roadtype
RoadType roadtype
NOSAVE: Roadtype of this vehicle.
Definition roadveh.h:108
ShipVehicleInfo::acceleration
uint8_t acceleration
Acceleration (1 unit = 1/3.2 mph per tick = 0.5 km-ish/h per tick)
Definition engine_type.h:103
Ship
All ships have this type.
Definition ship.h:32
Sign
Definition signs_base.h:21
SpecializedStation< Station, false >::IsExpected
static bool IsExpected(const BaseStation *st)
Helper for checking whether the given station is of this type.
Definition base_station_base.h:229
SpecializedStation< Station, false >::Iterate
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
Definition base_station_base.h:299
SpecializedStation< Station, false >::Get
static Station * Get(auto index)
Gets station with given index.
Definition base_station_base.h:248
SpecializedStation< Station, false >::GetIfValid
static Station * GetIfValid(auto index)
Returns station if the index is a valid index for this station type.
Definition base_station_base.h:257
SpecializedStation< Station, false >::From
static Station * From(BaseStation *st)
Converts a BaseStation to SpecializedStation with type checking.
Definition base_station_base.h:277
SpecializedVehicle::Next
T * Next() const
Get next vehicle in the chain.
Definition vehicle_base.h:1049
SpecializedVehicle::Iterate
static Pool::IterateWrapper< T > Iterate(size_t from=0)
Returns an iterable ensemble of all valid vehicles of type T.
Definition vehicle_base.h:1203
SpecializedVehicle::From
static T * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Definition vehicle_base.h:1134
StationSettings::modified_catchment
bool modified_catchment
different-size catchment areas
Definition settings_type.h:593
StationSettings::serve_neutral_industries
bool serve_neutral_industries
company stations can serve industries with attached neutral stations
Definition settings_type.h:594
Station
Station data structure.
Definition station_base.h:520
Station::bus_stops
RoadStop * bus_stops
All the road stops.
Definition station_base.h:529
Station::RecomputeCatchmentForAll
static void RecomputeCatchmentForAll()
Recomputes catchment of all stations.
Definition station.cpp:534
Station::truck_stops
RoadStop * truck_stops
All the truck stops.
Definition station_base.h:531
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
Subsidy
Struct about subsidies, offered and awarded.
Definition subsidy_base.h:23
Town
Town data structure.
Definition town.h:63
Train
'Train' is either a loco or a wagon.
Definition train.h:91
VehicleDefaultSettings
Default settings for vehicles.
Definition settings_type.h:601
VehicleSettings::plane_crashes
uint8_t plane_crashes
number of plane crashes, 0 = none, 1 = reduced, 2 = normal
Definition settings_type.h:536
VehicleSettings::roadveh_acceleration_model
uint8_t roadveh_acceleration_model
realistic acceleration for road vehicles
Definition settings_type.h:521
VehicleSettings::roadveh_slope_steepness
uint8_t roadveh_slope_steepness
Steepness of hills for road vehicles when using realistic acceleration.
Definition settings_type.h:523
VehicleSettings::train_acceleration_model
uint8_t train_acceleration_model
realistic acceleration for trains
Definition settings_type.h:520
VehicleSettings::train_slope_steepness
uint8_t train_slope_steepness
Steepness of hills for trains when using realistic acceleration.
Definition settings_type.h:522
VehicleSettings::road_side
uint8_t road_side
the side of the road vehicles drive on
Definition settings_type.h:535
VehicleSettings::dynamic_engines
bool dynamic_engines
enable dynamic allocation of engine data
Definition settings_type.h:532
VehicleSettings::max_train_length
uint8_t max_train_length
maximum length for trains
Definition settings_type.h:518
VehicleSettings::plane_speed
uint8_t plane_speed
divisor for speed of aircraft
Definition settings_type.h:530
VehicleSettings::disable_elrails
bool disable_elrails
when true, the elrails are disabled
Definition settings_type.h:525
Vehicle
Vehicle data structure.
Definition vehicle_base.h:205
Vehicle::direction
Direction direction
facing
Definition vehicle_base.h:268
Vehicle::vehstatus
VehStates vehstatus
Status.
Definition vehicle_base.h:309
Vehicle::current_order
Order current_order
The current order (+ status, like: loading)
Definition vehicle_base.h:311
Vehicle::y_pos
int32_t y_pos
y coordinate.
Definition vehicle_base.h:266
Vehicle::x_pos
int32_t x_pos
x coordinate.
Definition vehicle_base.h:265
Vehicle::tile
TileIndex tile
Current tile index.
Definition vehicle_base.h:225
Vehicle::owner
Owner owner
Which company owns the vehicle?
Definition vehicle_base.h:270
Waypoint
Representation of a waypoint.
Definition waypoint_base.h:23
RebuildSubsidisedSourceAndDestinationCache
void RebuildSubsidisedSourceAndDestinationCache()
Perform a full rebuild of the subsidies cache.
Definition subsidy.cpp:103
MayAnimateTile
bool MayAnimateTile(TileIndex tile)
Test if a tile may be animated.
Definition tile_cmd.h:197
IsTileFlat
bool IsTileFlat(TileIndex tile, int *h)
Check if a given tile is flat.
Definition tile_map.cpp:95
GetTileMaxZ
int GetTileMaxZ(TileIndex t)
Get top height of the tile inside the map.
Definition tile_map.cpp:136
GetTileZ
int GetTileZ(TileIndex tile)
Get bottom height of the tile.
Definition tile_map.cpp:116
IsTileType
static bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
TileHash
uint TileHash(uint x, uint y)
Calculate a hash value from a tile position.
Definition tile_map.h:324
TileHeight
static uint TileHeight(Tile tile)
Returns the height of a tile.
Definition tile_map.h:29
IsTileOwner
bool IsTileOwner(Tile tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition tile_map.h:214
SetTileType
void SetTileType(Tile tile, TileType type)
Set the type of a tile.
Definition tile_map.h:131
GetTileOwner
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition tile_map.h:178
SetTileOwner
void SetTileOwner(Tile tile, Owner owner)
Sets the owner of a tile.
Definition tile_map.h:198
GetTileMaxPixelZ
int GetTileMaxPixelZ(TileIndex tile)
Get top height of the tile.
Definition tile_map.h:312
SetAnimationFrame
void SetAnimationFrame(Tile t, uint8_t frame)
Set a new animation frame.
Definition tile_map.h:262
GetTileSlope
Slope GetTileSlope(TileIndex tile)
Return the slope of a given tile inside the map.
Definition tile_map.h:279
SetTropicZone
void SetTropicZone(Tile tile, TropicZone type)
Set the tropic zone.
Definition tile_map.h:225
GetTileType
static TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
Definition tile_map.h:96
TILE_UNIT_MASK
static constexpr uint TILE_UNIT_MASK
For masking in/out the inner-tile world coordinate units.
Definition tile_type.h:16
TROPICZONE_NORMAL
@ TROPICZONE_NORMAL
Normal tropiczone.
Definition tile_type.h:77
INVALID_TILE
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition tile_type.h:95
TileIndex
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > > TileIndex
The index/ID of a Tile.
Definition tile_type.h:87
TILE_SIZE
static constexpr uint TILE_SIZE
Tile size in world coordinates.
Definition tile_type.h:15
MIN_SNOWLINE_HEIGHT
static constexpr uint MIN_SNOWLINE_HEIGHT
Minimum snowline height.
Definition tile_type.h:32
TILE_HEIGHT
static constexpr uint TILE_HEIGHT
Height of a height level in world coordinate AND in pixels in ZOOM_BASE.
Definition tile_type.h:18
MP_TREES
@ MP_TREES
Tile got trees.
Definition tile_type.h:52
MP_ROAD
@ MP_ROAD
A tile with road (or tram tracks)
Definition tile_type.h:50
MP_STATION
@ MP_STATION
A tile of a station.
Definition tile_type.h:53
MP_TUNNELBRIDGE
@ MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
Definition tile_type.h:57
MP_CLEAR
@ MP_CLEAR
A tile without any structures, i.e. grass, rocks, farm fields etc.
Definition tile_type.h:48
MP_HOUSE
@ MP_HOUSE
A house by a town.
Definition tile_type.h:51
MP_WATER
@ MP_WATER
Water tile.
Definition tile_type.h:54
MP_RAILWAY
@ MP_RAILWAY
A railway.
Definition tile_type.h:49
MP_INDUSTRY
@ MP_INDUSTRY
Part of an industry.
Definition tile_type.h:56
MP_VOID
@ MP_VOID
Invisible tiles at the SW and SE border.
Definition tile_type.h:55
MP_OBJECT
@ MP_OBJECT
Contains objects such as transmitters and owned land.
Definition tile_type.h:58
TOWN_GROWTH_WINTER
static const uint TOWN_GROWTH_WINTER
The town only needs this cargo in the winter (any amount)
Definition town.h:32
FindFirstCargoWithTownAcceptanceEffect
const CargoSpec * FindFirstCargoWithTownAcceptanceEffect(TownAcceptanceEffect effect)
Determines the first cargo with a certain town effect.
Definition town_cmd.cpp:3127
ClosestTownFromTile
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold.
Definition town_cmd.cpp:3961
TOWN_GROWTH_DESERT
static const uint TOWN_GROWTH_DESERT
The town needs the cargo for growth when on desert (any amount)
Definition town.h:33
UpdateTownMaxPass
void UpdateTownMaxPass(Town *t)
Update the maximum amount of monthly passengers and mail for a town, based on its population.
Definition town_cmd.cpp:2003
ClearAllTownCachedNames
void ClearAllTownCachedNames()
Clear the cached_name of all towns.
Definition town_cmd.cpp:430
CalcClosestTownFromTile
Town * CalcClosestTownFromTile(TileIndex tile, uint threshold=UINT_MAX)
Return the town closest to the given tile within threshold.
Definition town_cmd.cpp:3943
TownFlag::CustomGrowth
@ CustomGrowth
Growth rate is controlled by GS.
TOWN_GROWTH_RATE_NONE
static const uint16_t TOWN_GROWTH_RATE_NONE
Special value for Town::growth_rate to disable town growth.
Definition town.h:34
MakeDefaultName
void MakeDefaultName(T *obj)
Set the default name for a depot/waypoint.
Definition town.h:284
UpdateAllTownVirtCoords
void UpdateAllTownVirtCoords()
Update the virtual coords needed to draw the town sign for all towns.
Definition town_cmd.cpp:422
GetHouseType
HouseID GetHouseType(Tile t)
Get the type of this house, which is an index into the house spec array.
Definition town_map.h:60
SetHouseType
void SetHouseType(Tile t, HouseID house_id)
Set the house type.
Definition town_map.h:71
SetLiftPosition
void SetLiftPosition(Tile t, uint8_t pos)
Set the position of the lift on this animated house.
Definition town_map.h:157
SetHouseCompleted
void SetHouseCompleted(Tile t, bool status)
Mark this house as been completed.
Definition town_map.h:178
SetHouseProtected
void SetHouseProtected(Tile t, bool house_protected)
Set a house as protected from removal by towns.
Definition town_map.h:93
SetTownIndex
void SetTownIndex(Tile t, TownID index)
Set the town index for a road or house tile.
Definition town_map.h:35
IsHouseCompleted
bool IsHouseCompleted(Tile t)
Get the completion of this house.
Definition town_map.h:167
RATING_INITIAL
static constexpr int RATING_INITIAL
initial rating
Definition town_type.h:45
TCGM_ORIGINAL
@ TCGM_ORIGINAL
Original algorithm (quadratic cargo by population)
Definition town_type.h:114
TownLayout
TownLayout
Town Layouts.
Definition town_type.h:81
TL_RANDOM
@ TL_RANDOM
Random town layout.
Definition town_type.h:88
TL_BETTER_ROADS
@ TL_BETTER_ROADS
Extended original algorithm (min. 2 distance between roads)
Definition town_type.h:84
DiagDirToDiagTrackBits
TrackBits DiagDirToDiagTrackBits(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal track bits incidating with that diagdir.
Definition track_func.h:524
DiagDirToDiagTrackdir
Trackdir DiagDirToDiagTrackdir(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal trackdir that runs in that direction.
Definition track_func.h:537
TrackStatusToTrackBits
TrackBits TrackStatusToTrackBits(TrackStatus ts)
Returns the present-track-information of a TrackStatus.
Definition track_func.h:363
TrackBits
TrackBits
Allow incrementing of Track variables.
Definition track_type.h:35
TRACK_BIT_WORMHOLE
@ TRACK_BIT_WORMHOLE
Bitflag for a wormhole (used for tunnels)
Definition track_type.h:52
TRACK_BIT_Y
@ TRACK_BIT_Y
Y-axis track.
Definition track_type.h:38
TRACK_BIT_NONE
@ TRACK_BIT_NONE
No track.
Definition track_type.h:36
TRACK_BIT_X
@ TRACK_BIT_X
X-axis track.
Definition track_type.h:37
INVALID_TRACK
@ INVALID_TRACK
Flag for an invalid track.
Definition track_type.h:28
TRACK_LOWER
@ TRACK_LOWER
Track in the lower corner of the tile (south)
Definition track_type.h:24
TRACK_UPPER
@ TRACK_UPPER
Track in the upper corner of the tile (north)
Definition track_type.h:23
CheckTrainsLengths
void CheckTrainsLengths()
Checks if lengths of all rail vehicles are valid.
Definition train_cmd.cpp:75
VehicleRailFlag
VehicleRailFlag
Rail vehicle flags.
Definition train.h:25
TFP_NONE
@ TFP_NONE
Normal operation.
Definition train.h:39
TFP_STUCK
@ TFP_STUCK
Proceed till next signal, but ignore being stuck till then. This includes force leaving depots.
Definition train.h:40
TransportType
TransportType
Available types of transport.
Definition transport_type.h:17
TRANSPORT_RAIL
@ TRANSPORT_RAIL
Transport by train.
Definition transport_type.h:25
TRANSPORT_ROAD
@ TRANSPORT_ROAD
Transport by road vehicle.
Definition transport_type.h:26
GetTreeGround
TreeGround GetTreeGround(Tile t)
Returns the groundtype for tree tiles.
Definition tree_map.h:102
TreeGround
TreeGround
Enumeration for ground types of tiles with trees.
Definition tree_map.h:52
TREE_GROUND_SHORE
@ TREE_GROUND_SHORE
shore
Definition tree_map.h:56
TREE_GROUND_SNOW_DESERT
@ TREE_GROUND_SNOW_DESERT
a desert or snow tile, depend on landscape
Definition tree_map.h:55
IsTunnelTile
bool IsTunnelTile(Tile t)
Is this a tunnel (entrance)?
Definition tunnel_map.h:34
_tunnel_visibility_frame
const uint8_t _tunnel_visibility_frame[DIAGDIR_END]
Frame when a vehicle should be hidden in a tunnel with a certain direction.
GetTunnelBridgeDirection
DiagDirection GetTunnelBridgeDirection(Tile t)
Get the direction pointing to the other end.
Definition tunnelbridge_map.h:26
GetTunnelBridgeTransportType
TransportType GetTunnelBridgeTransportType(Tile t)
Tunnel: Get the transport type of the tunnel (road or rail) Bridge: Get the transport type of the bri...
Definition tunnelbridge_map.h:39
GetOtherTunnelBridgeEnd
TileIndex GetOtherTunnelBridgeEnd(Tile t)
Determines type of the wormhole and returns its other end.
Definition tunnelbridge_map.h:78
SetTunnelBridgeReservation
void SetTunnelBridgeReservation(Tile t, bool b)
Set the reservation state of the rail tunnel/bridge.
Definition tunnelbridge_map.h:104
VehState::Crashed
@ Crashed
Vehicle is crashed.
VehState::Hidden
@ Hidden
Vehicle is not visible.
VehState::Stopped
@ Stopped
Vehicle is stopped by the player.
VEH_INVALID
@ VEH_INVALID
Non-existing type of vehicle.
Definition vehicle_type.h:36
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition vehicle_type.h:26
VEH_SHIP
@ VEH_SHIP
Ship vehicle type.
Definition vehicle_type.h:27
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition vehicle_type.h:25
MakeVoid
void MakeVoid(Tile t)
Make a nice void tile ;)
Definition void_map.h:19
MakeShore
void MakeShore(Tile t)
Helper function to make a coast tile.
Definition water_map.h:383
SetWaterClass
void SetWaterClass(Tile t, WaterClass wc)
Set the water class at a tile.
Definition water_map.h:126
IsShipDepot
bool IsShipDepot(Tile t)
Is it a water tile with a ship depot on it?
Definition water_map.h:224
WaterClass
WaterClass
classes of water (for WaterTileType::Clear water tile type).
Definition water_map.h:39
WaterClass::River
@ River
River.
WaterClass::Invalid
@ Invalid
Used for industry tiles on land (also for oilrig if newgrf says so).
WaterClass::Canal
@ Canal
Canal.
WaterClass::Sea
@ Sea
Sea.
IsShipDepotTile
bool IsShipDepotTile(Tile t)
Is it a ship depot tile?
Definition water_map.h:234
IsCoast
bool IsCoast(Tile t)
Is it a coast tile?
Definition water_map.h:203
GetWaterTileType
WaterTileType GetWaterTileType(Tile t)
Get the water tile type of a tile.
Definition water_map.h:80
SetNonFloodingWaterTile
void SetNonFloodingWaterTile(Tile t, bool b)
Set the non-flooding water tile state of a tile.
Definition water_map.h:530
SetWaterTileType
void SetWaterTileType(Tile t, WaterTileType type)
Set the water tile type of a tile.
Definition water_map.h:91
GetWaterClass
WaterClass GetWaterClass(Tile t)
Get the water class at a tile.
Definition water_map.h:114
MakeCanal
void MakeCanal(Tile t, Owner o, uint8_t random_bits)
Make a canal tile.
Definition water_map.h:447
GetOtherShipDepotTile
TileIndex GetOtherShipDepotTile(Tile t)
Get the other tile of the ship depot.
Definition water_map.h:280
WaterTileType::Coast
@ Coast
Coast.
WaterTileType::Depot
@ Depot
Water Depot.
WaterTileType::Lock
@ Lock
Water lock.
WaterTileType::Clear
@ Clear
Plain water.
SetDockingTile
void SetDockingTile(Tile t, bool b)
Set the docking tile state of a tile.
Definition water_map.h:363
LockPart::Middle
@ Middle
Middle part of a lock.
IsWater
bool IsWater(Tile t)
Is it a plain water tile?
Definition water_map.h:149
IsLock
bool IsLock(Tile t)
Is there a lock on a given water tile?
Definition water_map.h:305
MakeSea
void MakeSea(Tile t)
Make a sea tile.
Definition water_map.h:426
GetLockPart
LockPart GetLockPart(Tile t)
Get the part of a lock.
Definition water_map.h:328
ResetWindowSystem
void ResetWindowSystem()
Reset the windowing system, by means of shutting it down followed by re-initialization.
Definition window.cpp:1895
InvalidateWindowData
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
Definition window.cpp:3297
InvalidateWindowClassesData
void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope)
Mark window data of all windows of a given class as invalid (in need of re-computing) Note that by de...
Definition window.cpp:3314
WC_COMPANY_INFRASTRUCTURE
@ WC_COMPANY_INFRASTRUCTURE
Company infrastructure overview; Window numbers:
Definition window_type.h:598
WC_COMPANY_COLOUR
@ WC_COMPANY_COLOUR
Company colour selection; Window numbers:
Definition window_type.h:235
WC_BUILD_TOOLBAR
@ WC_BUILD_TOOLBAR
Build toolbar; Window numbers:
Definition window_type.h:78
YapfNotifyTrackLayoutChange
void YapfNotifyTrackLayoutChange(TileIndex tile, Track track)
Use this function to notify YAPF that track layout (or signal configuration) has change.
Definition yapf_rail.cpp:665