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