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

OpenTTD Source 15.0-beta1

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