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

OpenTTD Source 14.0-RC3

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