OpenTTD Source  1.10.0-RC1
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  RebuildViewportKdtree();
223 }
224 
225 void ClearAllCachedNames()
226 {
227  ClearAllStationCachedNames();
228  ClearAllTownCachedNames();
229  ClearAllIndustryCachedNames();
230 }
231 
242 {
243  /* Initialize windows */
246 
247  /* Update coordinates of the signs. */
248  ClearAllCachedNames();
250  ResetViewportAfterLoadGame();
251 
252  for (Company *c : Company::Iterate()) {
253  /* For each company, verify (while loading a scenario) that the inauguration date is the current year and set it
254  * accordingly if it is not the case. No need to set it on companies that are not been used already,
255  * thus the MIN_YEAR (which is really nothing more than Zero, initialized value) test */
256  if (_file_to_saveload.abstract_ftype == FT_SCENARIO && c->inaugurated_year != MIN_YEAR) {
257  c->inaugurated_year = _cur_year;
258  }
259  }
260 
261  /* Count number of objects per type */
262  for (Object *o : Object::Iterate()) {
263  Object::IncTypeCount(o->type);
264  }
265 
266  /* Identify owners of persistent storage arrays */
267  for (Industry *i : Industry::Iterate()) {
268  if (i->psa != nullptr) {
269  i->psa->feature = GSF_INDUSTRIES;
270  i->psa->tile = i->location.tile;
271  }
272  }
273  for (Station *s : Station::Iterate()) {
274  if (s->airport.psa != nullptr) {
275  s->airport.psa->feature = GSF_AIRPORTS;
276  s->airport.psa->tile = s->airport.tile;
277  }
278  }
279  for (Town *t : Town::Iterate()) {
280  for (std::list<PersistentStorage *>::iterator it = t->psa_list.begin(); it != t->psa_list.end(); ++it) {
281  (*it)->feature = GSF_FAKE_TOWNS;
282  (*it)->tile = t->xy;
283  }
284  }
285  for (RoadVehicle *rv : RoadVehicle::Iterate()) {
286  if (rv->IsFrontEngine()) {
287  rv->CargoChanged();
288  }
289  }
290 
291  RecomputePrices();
292 
294 
296 
297  /* Towns have a noise controlled number of airports system
298  * So each airport's noise value must be added to the town->noise_reached value
299  * Reset each town's noise_reached value to '0' before. */
301 
303  ShowNewGRFError();
305 
306  /* Rebuild the smallmap list of owners. */
308 }
309 
310 typedef void (CDECL *SignalHandlerPointer)(int);
311 static SignalHandlerPointer _prev_segfault = nullptr;
312 static SignalHandlerPointer _prev_abort = nullptr;
313 static SignalHandlerPointer _prev_fpe = nullptr;
314 
315 static void CDECL HandleSavegameLoadCrash(int signum);
316 
321 static void SetSignalHandlers()
322 {
323  _prev_segfault = signal(SIGSEGV, HandleSavegameLoadCrash);
324  _prev_abort = signal(SIGABRT, HandleSavegameLoadCrash);
325  _prev_fpe = signal(SIGFPE, HandleSavegameLoadCrash);
326 }
327 
331 static void ResetSignalHandlers()
332 {
333  signal(SIGSEGV, _prev_segfault);
334  signal(SIGABRT, _prev_abort);
335  signal(SIGFPE, _prev_fpe);
336 }
337 
344 {
346  if (la->at != GLAT_LOAD) return &c->ident;
347 
348  const LoggedChange *lcend = &la->change[la->changes];
349  for (const LoggedChange *lc = la->change; lc != lcend; lc++) {
350  if (lc->ct == GLCT_GRFCOMPAT && lc->grfcompat.grfid == c->ident.grfid) return &lc->grfcompat;
351  }
352 
353  return &c->ident;
354 }
355 
358 
365 {
367 }
368 
375 static void CDECL HandleSavegameLoadCrash(int signum)
376 {
378 
379  char buffer[8192];
380  char *p = buffer;
381  p += seprintf(p, lastof(buffer), "Loading your savegame caused OpenTTD to crash.\n");
382 
383  for (const GRFConfig *c = _grfconfig; !_saveload_crash_with_missing_newgrfs && c != nullptr; c = c->next) {
385  }
386 
388  p += seprintf(p, lastof(buffer),
389  "This is most likely caused by a missing NewGRF or a NewGRF that\n"
390  "has been loaded as replacement for a missing NewGRF. OpenTTD\n"
391  "cannot easily determine whether a replacement NewGRF is of a newer\n"
392  "or older version.\n"
393  "It will load a NewGRF with the same GRF ID as the missing NewGRF.\n"
394  "This means that if the author makes incompatible NewGRFs with the\n"
395  "same GRF ID OpenTTD cannot magically do the right thing. In most\n"
396  "cases OpenTTD will load the savegame and not crash, but this is an\n"
397  "exception.\n"
398  "Please load the savegame with the appropriate NewGRFs installed.\n"
399  "The missing/compatible NewGRFs are:\n");
400 
401  for (const GRFConfig *c = _grfconfig; c != nullptr; c = c->next) {
402  if (HasBit(c->flags, GCF_COMPATIBLE)) {
403  const GRFIdentifier *replaced = GetOverriddenIdentifier(c);
404  char buf[40];
405  md5sumToString(buf, lastof(buf), replaced->md5sum);
406  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);
407  }
408  if (c->status == GCS_NOT_FOUND) {
409  char buf[40];
410  md5sumToString(buf, lastof(buf), c->ident.md5sum);
411  p += seprintf(p, lastof(buffer), "NewGRF %08X (%s) not found; checksum %s.\n", BSWAP32(c->ident.grfid), c->filename, buf);
412  }
413  }
414  } else {
415  p += seprintf(p, lastof(buffer),
416  "This is probably caused by a corruption in the savegame.\n"
417  "Please file a bug report and attach this savegame.\n");
418  }
419 
420  ShowInfo(buffer);
421 
422  SignalHandlerPointer call = nullptr;
423  switch (signum) {
424  case SIGSEGV: call = _prev_segfault; break;
425  case SIGABRT: call = _prev_abort; break;
426  case SIGFPE: call = _prev_fpe; break;
427  default: NOT_REACHED();
428  }
429  if (call != nullptr) call(signum);
430 }
431 
438 {
440 
441  /* remove leftover rail piece from crossing (from very old savegames) */
442  Train *v = nullptr;
443  for (Train *w : Train::Iterate()) {
444  if (w->tile == t) {
445  v = w;
446  break;
447  }
448  }
449 
450  if (v != nullptr) {
451  /* when there is a train on crossing (it could happen in TTD), set owner of crossing to train owner */
452  SetTileOwner(t, v->owner);
453  return;
454  }
455 
456  /* try to find any connected rail */
457  for (DiagDirection dd = DIAGDIR_BEGIN; dd < DIAGDIR_END; dd++) {
458  TileIndex tt = t + TileOffsByDiagDir(dd);
459  if (GetTileTrackStatus(t, TRANSPORT_RAIL, 0, dd) != 0 &&
462  SetTileOwner(t, GetTileOwner(tt));
463  return;
464  }
465  }
466 
467  if (IsLevelCrossingTile(t)) {
468  /* else change the crossing to normal road (road vehicles won't care) */
469  Owner road = GetRoadOwner(t, RTT_ROAD);
470  Owner tram = GetRoadOwner(t, RTT_TRAM);
471  RoadBits bits = GetCrossingRoadBits(t);
472  bool hasroad = HasBit(_me[t].m7, 6);
473  bool hastram = HasBit(_me[t].m7, 7);
474 
475  /* MakeRoadNormal */
476  SetTileType(t, MP_ROAD);
477  SetTileOwner(t, road);
478  _m[t].m3 = (hasroad ? bits : 0);
479  _m[t].m5 = (hastram ? bits : 0) | ROAD_TILE_NORMAL << 6;
480  SB(_me[t].m6, 2, 4, 0);
481  SetRoadOwner(t, RTT_TRAM, tram);
482  return;
483  }
484 
485  /* if it's not a crossing, make it clean land */
486  MakeClear(t, CLEAR_GRASS, 0);
487 }
488 
496 {
497  /* Compute place where this vehicle entered the tile */
498  int entry_x = v->x_pos;
499  int entry_y = v->y_pos;
500  switch (dir) {
501  case DIR_NE: entry_x |= TILE_UNIT_MASK; break;
502  case DIR_NW: entry_y |= TILE_UNIT_MASK; break;
503  case DIR_SW: entry_x &= ~TILE_UNIT_MASK; break;
504  case DIR_SE: entry_y &= ~TILE_UNIT_MASK; break;
505  case INVALID_DIR: break;
506  default: NOT_REACHED();
507  }
508  byte entry_z = GetSlopePixelZ(entry_x, entry_y);
509 
510  /* Compute middle of the tile. */
511  int middle_x = (v->x_pos & ~TILE_UNIT_MASK) + TILE_SIZE / 2;
512  int middle_y = (v->y_pos & ~TILE_UNIT_MASK) + TILE_SIZE / 2;
513  byte middle_z = GetSlopePixelZ(middle_x, middle_y);
514 
515  /* middle_z == entry_z, no height change. */
516  if (middle_z == entry_z) return 0;
517 
518  /* middle_z < entry_z, we are going downwards. */
519  if (middle_z < entry_z) return 1U << GVF_GOINGDOWN_BIT;
520 
521  /* middle_z > entry_z, we are going upwards. */
522  return 1U << GVF_GOINGUP_BIT;
523 }
524 
531 static inline bool MayHaveBridgeAbove(TileIndex t)
532 {
533  return IsTileType(t, MP_CLEAR) || IsTileType(t, MP_RAILWAY) || IsTileType(t, MP_ROAD) ||
535 }
536 
543 {
545 
546  TileIndex map_size = MapSize();
547 
548  extern TileIndex _cur_tileloop_tile; // From landscape.cpp.
549  /* The LFSR used in RunTileLoop iteration cannot have a zeroed state, make it non-zeroed. */
550  if (_cur_tileloop_tile == 0) _cur_tileloop_tile = 1;
551 
553 
555  GamelogTestMode();
556 
557  RebuildTownKdtree();
558  RebuildStationKdtree();
559  /* This needs to be done even before conversion, because some conversions will destroy objects
560  * that otherwise won't exist in the tree. */
561  RebuildViewportKdtree();
562 
564 
567  } else if (_network_dedicated && (_pause_mode & PM_PAUSED_ERROR) != 0) {
568  DEBUG(net, 0, "The loading savegame was paused due to an error state.");
569  DEBUG(net, 0, " The savegame cannot be used for multiplayer!");
570  /* Restore the signals */
572  return false;
573  } else if (!_networking || _network_server) {
574  /* If we are in single player, i.e. not networking, and loading the
575  * savegame or we are loading the savegame as network server we do
576  * not want to be bothered by being paused because of the automatic
577  * reason of a network server, e.g. joining clients or too few
578  * active clients. Note that resetting these values for a network
579  * client are very bad because then the client is going to execute
580  * the game loop when the server is not, i.e. it desyncs. */
582  }
583 
584  /* In very old versions, size of train stations was stored differently.
585  * They had swapped width and height if station was built along the Y axis.
586  * TTO and TTD used 3 bits for width/height, while OpenTTD used 4.
587  * Because the data stored by TTDPatch are unusable for rail stations > 7x7,
588  * recompute the width and height. Doing this unconditionally for all old
589  * savegames simplifies the code. */
591  for (Station *st : Station::Iterate()) {
592  st->train_station.w = st->train_station.h = 0;
593  }
594  for (TileIndex t = 0; t < map_size; t++) {
595  if (!IsTileType(t, MP_STATION)) continue;
596  if (_m[t].m5 > 7) continue; // is it a rail station tile?
597  Station *st = Station::Get(_m[t].m2);
598  assert(st->train_station.tile != 0);
599  int dx = TileX(t) - TileX(st->train_station.tile);
600  int dy = TileY(t) - TileY(st->train_station.tile);
601  assert(dx >= 0 && dy >= 0);
602  st->train_station.w = max<uint>(st->train_station.w, dx + 1);
603  st->train_station.h = max<uint>(st->train_station.h, dy + 1);
604  }
605  }
606 
609 
610  /* In old savegame versions, the heightlevel was coded in bits 0..3 of the type field */
611  for (TileIndex t = 0; t < map_size; t++) {
612  _m[t].height = GB(_m[t].type, 0, 4);
613  SB(_m[t].type, 0, 2, GB(_me[t].m6, 0, 2));
614  SB(_me[t].m6, 0, 2, 0);
615  if (MayHaveBridgeAbove(t)) {
616  SB(_m[t].type, 2, 2, GB(_me[t].m6, 6, 2));
617  SB(_me[t].m6, 6, 2, 0);
618  } else {
619  SB(_m[t].type, 2, 2, 0);
620  }
621  }
622  }
623 
624  /* in version 2.1 of the savegame, town owner was unified. */
625  if (IsSavegameVersionBefore(SLV_2, 1)) ConvertTownOwner();
626 
627  /* from version 4.1 of the savegame, exclusive rights are stored at towns */
628  if (IsSavegameVersionBefore(SLV_4, 1)) UpdateExclusiveRights();
629 
630  /* from version 4.2 of the savegame, currencies are in a different order */
631  if (IsSavegameVersionBefore(SLV_4, 2)) UpdateCurrencies();
632 
633  /* In old version there seems to be a problem that water is owned by
634  * OWNER_NONE, not OWNER_WATER.. I can't replicate it for the current
635  * (4.3) version, so I just check when versions are older, and then
636  * walk through the whole map.. */
637  if (IsSavegameVersionBefore(SLV_4, 3)) {
638  for (TileIndex t = 0; t < map_size; t++) {
639  if (IsTileType(t, MP_WATER) && GetTileOwner(t) >= MAX_COMPANIES) {
641  }
642  }
643  }
644 
646  for (Company *c : Company::Iterate()) {
647  c->name = CopyFromOldName(c->name_1);
648  if (c->name != nullptr) c->name_1 = STR_SV_UNNAMED;
649  c->president_name = CopyFromOldName(c->president_name_1);
650  if (c->president_name != nullptr) c->president_name_1 = SPECSTR_PRESIDENT_NAME;
651  }
652 
653  for (Station *st : Station::Iterate()) {
654  st->name = CopyFromOldName(st->string_id);
655  /* generating new name would be too much work for little effect, use the station name fallback */
656  if (st->name != nullptr) st->string_id = STR_SV_STNAME_FALLBACK;
657  }
658 
659  for (Town *t : Town::Iterate()) {
660  t->name = CopyFromOldName(t->townnametype);
661  if (t->name != nullptr) t->townnametype = SPECSTR_TOWNNAME_START + _settings_game.game_creation.town_name;
662  }
663  }
664 
665  /* From this point the old names array is cleared. */
666  ResetOldNames();
667 
669  /* no station is determined by 'tile == INVALID_TILE' now (instead of '0') */
670  for (Station *st : Station::Iterate()) {
671  if (st->airport.tile == 0) st->airport.tile = INVALID_TILE;
672  if (st->train_station.tile == 0) st->train_station.tile = INVALID_TILE;
673  }
674 
675  /* the same applies to Company::location_of_HQ */
676  for (Company *c : Company::Iterate()) {
677  if (c->location_of_HQ == 0 || (IsSavegameVersionBefore(SLV_4) && c->location_of_HQ == 0xFFFF)) {
678  c->location_of_HQ = INVALID_TILE;
679  }
680  }
681  }
682 
683  /* convert road side to my format. */
685 
686  /* Check if all NewGRFs are present, we are very strict in MP mode */
688  for (GRFConfig *c = _grfconfig; c != nullptr; c = c->next) {
689  if (c->status == GCS_NOT_FOUND) {
690  GamelogGRFRemove(c->ident.grfid);
691  } else if (HasBit(c->flags, GCF_COMPATIBLE)) {
692  GamelogGRFCompatible(&c->ident);
693  }
694  }
695 
696  if (_networking && gcf_res != GLC_ALL_GOOD) {
697  SetSaveLoadError(STR_NETWORK_ERROR_CLIENT_NEWGRF_MISMATCH);
698  /* Restore the signals */
700  return false;
701  }
702 
703  switch (gcf_res) {
704  case GLC_COMPATIBLE: ShowErrorMessage(STR_NEWGRF_COMPATIBLE_LOAD_WARNING, INVALID_STRING_ID, WL_CRITICAL); break;
705  case GLC_NOT_FOUND: ShowErrorMessage(STR_NEWGRF_DISABLED_WARNING, INVALID_STRING_ID, WL_CRITICAL); _pause_mode = PM_PAUSED_ERROR; break;
706  default: break;
707  }
708 
709  /* The value of _date_fract got divided, so make sure that old games are converted correctly. */
711 
712  /* Update current year
713  * must be done before loading sprites as some newgrfs check it */
715 
716  /*
717  * Force the old behaviour for compatibility reasons with old savegames. As new
718  * settings can only be loaded from new savegames loading old savegames with new
719  * versions of OpenTTD will normally initialize settings newer than the savegame
720  * version with "new game" defaults which the player can define to their liking.
721  * For some settings we override that to keep the behaviour the same as when the
722  * game was saved.
723  *
724  * Note that there is no non-stop in here. This is because the setting could have
725  * either value in TTDPatch. To convert it properly the user has to make sure the
726  * right value has been chosen in the settings. Otherwise we will be converting
727  * it incorrectly in half of the times without a means to correct that.
728  */
737  }
743  }
749  }
756  }
757 
759  extern int32 _old_ending_year_slv_105; // in date.cpp
760  _settings_game.game_creation.ending_year = _old_ending_year_slv_105 - 1;
762  /* Ending year was a GUI setting before SLV_105, was removed in revision 683b65ee1 (svn r14755). */
763  /* This also converts scenarios, both when loading them into the editor, and when starting a new game. */
765  }
766 
767  /* Load the sprites */
768  GfxLoadSprites();
770 
771  /* Copy temporary data to Engine pool */
773 
774  /* Connect front and rear engines of multiheaded trains and converts
775  * subtype to the new format */
777 
778  /* Connect front and rear engines of multiheaded trains */
780 
781  /* Fix the CargoPackets *and* fix the caches of CargoLists.
782  * If this isn't done before Stations and especially Vehicles are
783  * running their AfterLoad we might get in trouble. In the case of
784  * vehicles we could give the wrong (cached) count of items in a
785  * vehicle which causes different results when getting their caches
786  * filled; and that could eventually lead to desyncs. */
788 
789  /* Oilrig was moved from id 15 to 9. We have to do this conversion
790  * here as AfterLoadVehicles can check it indirectly via the newgrf
791  * code. */
793  for (Station *st : Station::Iterate()) {
794  if (st->airport.tile != INVALID_TILE && st->airport.type == 15) {
795  st->airport.type = AT_OILRIG;
796  }
797  }
798  }
799 
800  /* Update all vehicles */
801  AfterLoadVehicles(true);
802 
803  /* Make sure there is an AI attached to an AI company */
804  {
805  for (const Company *c : Company::Iterate()) {
806  if (c->is_ai && c->ai_instance == nullptr) AI::StartNew(c->index);
807  }
808  }
809 
810  /* make sure there is a town in the game */
811  if (_game_mode == GM_NORMAL && Town::GetNumItems() == 0) {
812  SetSaveLoadError(STR_ERROR_NO_TOWN_IN_SCENARIO);
813  /* Restore the signals */
815  return false;
816  }
817 
818  /* The void tiles on the southern border used to belong to a wrong class (pre 4.3).
819  * This problem appears in savegame version 21 too, see r3455. But after loading the
820  * savegame and saving again, the buggy map array could be converted to new savegame
821  * version. It didn't show up before r12070. */
822  if (IsSavegameVersionBefore(SLV_87)) UpdateVoidTiles();
823 
824  /* If Load Scenario / New (Scenario) Game is used,
825  * a company does not exist yet. So create one here.
826  * 1 exception: network-games. Those can have 0 companies
827  * But this exception is not true for non-dedicated network servers! */
829  DoStartupNewCompany(false);
832  }
833 
834  /* Fix the cache for cargo payments. */
835  for (CargoPayment *cp : CargoPayment::Iterate()) {
836  cp->front->cargo_payment = cp;
837  cp->current_station = cp->front->last_station_visited;
838  }
839 
841  /* Locks in very old savegames had OWNER_WATER as owner */
842  for (TileIndex t = 0; t < MapSize(); t++) {
843  switch (GetTileType(t)) {
844  default: break;
845 
846  case MP_WATER:
848  break;
849 
850  case MP_STATION: {
851  if (HasBit(_me[t].m6, 3)) SetBit(_me[t].m6, 2);
852  StationGfx gfx = GetStationGfx(t);
853  StationType st;
854  if ( IsInsideMM(gfx, 0, 8)) { // Rail station
855  st = STATION_RAIL;
856  SetStationGfx(t, gfx - 0);
857  } else if (IsInsideMM(gfx, 8, 67)) { // Airport
858  st = STATION_AIRPORT;
859  SetStationGfx(t, gfx - 8);
860  } else if (IsInsideMM(gfx, 67, 71)) { // Truck
861  st = STATION_TRUCK;
862  SetStationGfx(t, gfx - 67);
863  } else if (IsInsideMM(gfx, 71, 75)) { // Bus
864  st = STATION_BUS;
865  SetStationGfx(t, gfx - 71);
866  } else if (gfx == 75) { // Oil rig
867  st = STATION_OILRIG;
868  SetStationGfx(t, gfx - 75);
869  } else if (IsInsideMM(gfx, 76, 82)) { // Dock
870  st = STATION_DOCK;
871  SetStationGfx(t, gfx - 76);
872  } else if (gfx == 82) { // Buoy
873  st = STATION_BUOY;
874  SetStationGfx(t, gfx - 82);
875  } else if (IsInsideMM(gfx, 83, 168)) { // Extended airport
876  st = STATION_AIRPORT;
877  SetStationGfx(t, gfx - 83 + 67 - 8);
878  } else if (IsInsideMM(gfx, 168, 170)) { // Drive through truck
879  st = STATION_TRUCK;
881  } else if (IsInsideMM(gfx, 170, 172)) { // Drive through bus
882  st = STATION_BUS;
884  } else {
885  /* Restore the signals */
887  return false;
888  }
889  SB(_me[t].m6, 3, 3, st);
890  break;
891  }
892  }
893  }
894  }
895 
896  for (TileIndex t = 0; t < map_size; t++) {
897  switch (GetTileType(t)) {
898  case MP_STATION: {
900 
901  /* Set up station spread */
902  bst->rect.BeforeAddTile(t, StationRect::ADD_FORCE);
903 
904  /* Waypoints don't have road stops/oil rigs in the old format */
905  if (!Station::IsExpected(bst)) break;
906  Station *st = Station::From(bst);
907 
908  switch (GetStationType(t)) {
909  case STATION_TRUCK:
910  case STATION_BUS:
912  /* Before version 5 you could not have more than 250 stations.
913  * Version 6 adds large maps, so you could only place 253*253
914  * road stops on a map (no freeform edges) = 64009. So, yes
915  * someone could in theory create such a full map to trigger
916  * this assertion, it's safe to assume that's only something
917  * theoretical and does not happen in normal games. */
918  assert(RoadStop::CanAllocateItem());
919 
920  /* From this version on there can be multiple road stops of the
921  * same type per station. Convert the existing stops to the new
922  * internal data structure. */
923  RoadStop *rs = new RoadStop(t);
924 
925  RoadStop **head =
926  IsTruckStop(t) ? &st->truck_stops : &st->bus_stops;
927  *head = rs;
928  }
929  break;
930 
931  case STATION_OILRIG: {
932  /* Very old savegames sometimes have phantom oil rigs, i.e.
933  * an oil rig which got shut down, but not completely removed from
934  * the map
935  */
936  TileIndex t1 = TILE_ADDXY(t, 0, 1);
937  if (IsTileType(t1, MP_INDUSTRY) &&
938  GetIndustryGfx(t1) == GFX_OILRIG_1) {
939  /* The internal encoding of oil rigs was changed twice.
940  * It was 3 (till 2.2) and later 5 (till 5.1).
941  * Setting it unconditionally does not hurt.
942  */
944  } else {
945  DeleteOilRig(t);
946  }
947  break;
948  }
949 
950  default: break;
951  }
952  break;
953  }
954 
955  default: break;
956  }
957  }
958 
959  /* In version 2.2 of the savegame, we have new airports, so status of all aircraft is reset.
960  * This has to be called after the oilrig airport_type update above ^^^ ! */
962 
963  /* In version 6.1 we put the town index in the map-array. To do this, we need
964  * to use m2 (16bit big), so we need to clean m2, and that is where this is
965  * all about ;) */
966  if (IsSavegameVersionBefore(SLV_6, 1)) {
967  for (TileIndex t = 0; t < map_size; t++) {
968  switch (GetTileType(t)) {
969  case MP_HOUSE:
970  _m[t].m4 = _m[t].m2;
972  break;
973 
974  case MP_ROAD:
975  _m[t].m4 |= (_m[t].m2 << 4);
976  if ((GB(_m[t].m5, 4, 2) == ROAD_TILE_CROSSING ? (Owner)_m[t].m3 : GetTileOwner(t)) == OWNER_TOWN) {
978  } else {
979  SetTownIndex(t, 0);
980  }
981  break;
982 
983  default: break;
984  }
985  }
986  }
987 
988  /* Force the freeform edges to false for old savegames. */
991  }
992 
993  /* From version 9.0, we update the max passengers of a town (was sometimes negative
994  * before that. */
996  for (Town *t : Town::Iterate()) UpdateTownMaxPass(t);
997  }
998 
999  /* From version 16.0, we included autorenew on engines, which are now saved, but
1000  * of course, we do need to initialize them for older savegames. */
1002  for (Company *c : Company::Iterate()) {
1003  c->engine_renew_list = nullptr;
1004  c->settings.engine_renew = false;
1005  c->settings.engine_renew_months = 6;
1006  c->settings.engine_renew_money = 100000;
1007  }
1008 
1009  /* When loading a game, _local_company is not yet set to the correct value.
1010  * However, in a dedicated server we are a spectator, so nothing needs to
1011  * happen. In case we are not a dedicated server, the local company always
1012  * becomes company 0, unless we are in the scenario editor where all the
1013  * companies are 'invalid'.
1014  */
1016  if (!_network_dedicated && c != nullptr) {
1018  }
1019  }
1020 
1022  for (TileIndex t = 0; t < map_size; t++) {
1023  switch (GetTileType(t)) {
1024  case MP_RAILWAY:
1025  if (IsPlainRail(t)) {
1026  /* Swap ground type and signal type for plain rail tiles, so the
1027  * ground type uses the same bits as for depots and waypoints. */
1028  uint tmp = GB(_m[t].m4, 0, 4);
1029  SB(_m[t].m4, 0, 4, GB(_m[t].m2, 0, 4));
1030  SB(_m[t].m2, 0, 4, tmp);
1031  } else if (HasBit(_m[t].m5, 2)) {
1032  /* Split waypoint and depot rail type and remove the subtype. */
1033  ClrBit(_m[t].m5, 2);
1034  ClrBit(_m[t].m5, 6);
1035  }
1036  break;
1037 
1038  case MP_ROAD:
1039  /* Swap m3 and m4, so the track type for rail crossings is the
1040  * same as for normal rail. */
1041  Swap(_m[t].m3, _m[t].m4);
1042  break;
1043 
1044  default: break;
1045  }
1046  }
1047  }
1048 
1050  /* Added the RoadType */
1051  bool old_bridge = IsSavegameVersionBefore(SLV_42);
1052  for (TileIndex t = 0; t < map_size; t++) {
1053  switch (GetTileType(t)) {
1054  case MP_ROAD:
1055  SB(_m[t].m5, 6, 2, GB(_m[t].m5, 4, 2));
1056  switch (GetRoadTileType(t)) {
1057  default: SlErrorCorrupt("Invalid road tile type");
1058  case ROAD_TILE_NORMAL:
1059  SB(_m[t].m4, 0, 4, GB(_m[t].m5, 0, 4));
1060  SB(_m[t].m4, 4, 4, 0);
1061  SB(_me[t].m6, 2, 4, 0);
1062  break;
1063  case ROAD_TILE_CROSSING:
1064  SB(_m[t].m4, 5, 2, GB(_m[t].m5, 2, 2));
1065  break;
1066  case ROAD_TILE_DEPOT: break;
1067  }
1068  SB(_me[t].m7, 6, 2, 1); // Set pre-NRT road type bits for conversion later.
1069  break;
1070 
1071  case MP_STATION:
1072  if (IsRoadStop(t)) SB(_me[t].m7, 6, 2, 1);
1073  break;
1074 
1075  case MP_TUNNELBRIDGE:
1076  /* Middle part of "old" bridges */
1077  if (old_bridge && IsBridge(t) && HasBit(_m[t].m5, 6)) break;
1078  if (((old_bridge && IsBridge(t)) ? (TransportType)GB(_m[t].m5, 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) {
1079  SB(_me[t].m7, 6, 2, 1); // Set pre-NRT road type bits for conversion later.
1080  }
1081  break;
1082 
1083  default: break;
1084  }
1085  }
1086  }
1087 
1089  bool fix_roadtypes = !IsSavegameVersionBefore(SLV_61);
1090  bool old_bridge = IsSavegameVersionBefore(SLV_42);
1091 
1092  for (TileIndex t = 0; t < map_size; t++) {
1093  switch (GetTileType(t)) {
1094  case MP_ROAD:
1095  if (fix_roadtypes) SB(_me[t].m7, 6, 2, (RoadTypes)GB(_me[t].m7, 5, 3));
1096  SB(_me[t].m7, 5, 1, GB(_m[t].m3, 7, 1)); // snow/desert
1097  switch (GetRoadTileType(t)) {
1098  default: SlErrorCorrupt("Invalid road tile type");
1099  case ROAD_TILE_NORMAL:
1100  SB(_me[t].m7, 0, 4, GB(_m[t].m3, 0, 4)); // road works
1101  SB(_me[t].m6, 3, 3, GB(_m[t].m3, 4, 3)); // ground
1102  SB(_m[t].m3, 0, 4, GB(_m[t].m4, 4, 4)); // tram bits
1103  SB(_m[t].m3, 4, 4, GB(_m[t].m5, 0, 4)); // tram owner
1104  SB(_m[t].m5, 0, 4, GB(_m[t].m4, 0, 4)); // road bits
1105  break;
1106 
1107  case ROAD_TILE_CROSSING:
1108  SB(_me[t].m7, 0, 5, GB(_m[t].m4, 0, 5)); // road owner
1109  SB(_me[t].m6, 3, 3, GB(_m[t].m3, 4, 3)); // ground
1110  SB(_m[t].m3, 4, 4, GB(_m[t].m5, 0, 4)); // tram owner
1111  SB(_m[t].m5, 0, 1, GB(_m[t].m4, 6, 1)); // road axis
1112  SB(_m[t].m5, 5, 1, GB(_m[t].m4, 5, 1)); // crossing state
1113  break;
1114 
1115  case ROAD_TILE_DEPOT:
1116  break;
1117  }
1118  if (!IsRoadDepot(t) && !HasTownOwnedRoad(t)) {
1119  const Town *town = CalcClosestTownFromTile(t);
1120  if (town != nullptr) SetTownIndex(t, town->index);
1121  }
1122  _m[t].m4 = 0;
1123  break;
1124 
1125  case MP_STATION:
1126  if (!IsRoadStop(t)) break;
1127 
1128  if (fix_roadtypes) SB(_me[t].m7, 6, 2, (RoadTypes)GB(_m[t].m3, 0, 3));
1129  SB(_me[t].m7, 0, 5, HasBit(_me[t].m6, 2) ? OWNER_TOWN : GetTileOwner(t));
1130  SB(_m[t].m3, 4, 4, _m[t].m1);
1131  _m[t].m4 = 0;
1132  break;
1133 
1134  case MP_TUNNELBRIDGE:
1135  if (old_bridge && IsBridge(t) && HasBit(_m[t].m5, 6)) break;
1136  if (((old_bridge && IsBridge(t)) ? (TransportType)GB(_m[t].m5, 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) {
1137  if (fix_roadtypes) SB(_me[t].m7, 6, 2, (RoadTypes)GB(_m[t].m3, 0, 3));
1138 
1139  Owner o = GetTileOwner(t);
1140  SB(_me[t].m7, 0, 5, o); // road owner
1141  SB(_m[t].m3, 4, 4, o == OWNER_NONE ? OWNER_TOWN : o); // tram owner
1142  }
1143  SB(_me[t].m6, 2, 4, GB(_m[t].m2, 4, 4)); // bridge type
1144  SB(_me[t].m7, 5, 1, GB(_m[t].m4, 7, 1)); // snow/desert
1145 
1146  _m[t].m2 = 0;
1147  _m[t].m4 = 0;
1148  break;
1149 
1150  default: break;
1151  }
1152  }
1153  }
1154 
1155  /* Railtype moved from m3 to m8 in version SLV_EXTEND_RAILTYPES. */
1157  for (TileIndex t = 0; t < map_size; t++) {
1158  switch (GetTileType(t)) {
1159  case MP_RAILWAY:
1160  SetRailType(t, (RailType)GB(_m[t].m3, 0, 4));
1161  break;
1162 
1163  case MP_ROAD:
1164  if (IsLevelCrossing(t)) {
1165  SetRailType(t, (RailType)GB(_m[t].m3, 0, 4));
1166  }
1167  break;
1168 
1169  case MP_STATION:
1170  if (HasStationRail(t)) {
1171  SetRailType(t, (RailType)GB(_m[t].m3, 0, 4));
1172  }
1173  break;
1174 
1175  case MP_TUNNELBRIDGE:
1177  SetRailType(t, (RailType)GB(_m[t].m3, 0, 4));
1178  }
1179  break;
1180 
1181  default:
1182  break;
1183  }
1184  }
1185  }
1186 
1188  for (TileIndex t = 0; t < map_size; t++) {
1190  if (IsBridgeTile(t)) {
1191  if (HasBit(_m[t].m5, 6)) { // middle part
1192  Axis axis = (Axis)GB(_m[t].m5, 0, 1);
1193 
1194  if (HasBit(_m[t].m5, 5)) { // transport route under bridge?
1195  if (GB(_m[t].m5, 3, 2) == TRANSPORT_RAIL) {
1196  MakeRailNormal(
1197  t,
1198  GetTileOwner(t),
1199  axis == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X,
1200  GetRailType(t)
1201  );
1202  } else {
1203  TownID town = IsTileOwner(t, OWNER_TOWN) ? ClosestTownFromTile(t, UINT_MAX)->index : 0;
1204 
1205  /* MakeRoadNormal */
1206  SetTileType(t, MP_ROAD);
1207  _m[t].m2 = town;
1208  _m[t].m3 = 0;
1209  _m[t].m5 = (axis == AXIS_X ? ROAD_Y : ROAD_X) | ROAD_TILE_NORMAL << 6;
1210  SB(_me[t].m6, 2, 4, 0);
1211  _me[t].m7 = 1 << 6;
1212  SetRoadOwner(t, RTT_TRAM, OWNER_NONE);
1213  }
1214  } else {
1215  if (GB(_m[t].m5, 3, 2) == 0) {
1216  MakeClear(t, CLEAR_GRASS, 3);
1217  } else {
1218  if (!IsTileFlat(t)) {
1219  MakeShore(t);
1220  } else {
1221  if (GetTileOwner(t) == OWNER_WATER) {
1222  MakeSea(t);
1223  } else {
1224  MakeCanal(t, GetTileOwner(t), Random());
1225  }
1226  }
1227  }
1228  }
1229  SetBridgeMiddle(t, axis);
1230  } else { // ramp
1231  Axis axis = (Axis)GB(_m[t].m5, 0, 1);
1232  uint north_south = GB(_m[t].m5, 5, 1);
1233  DiagDirection dir = ReverseDiagDir(XYNSToDiagDir(axis, north_south));
1234  TransportType type = (TransportType)GB(_m[t].m5, 1, 2);
1235 
1236  _m[t].m5 = 1 << 7 | type << 2 | dir;
1237  }
1238  }
1239  }
1240 
1241  for (Vehicle* v : Vehicle::Iterate()) {
1242  if (!v->IsGroundVehicle()) continue;
1243  if (IsBridgeTile(v->tile)) {
1244  DiagDirection dir = GetTunnelBridgeDirection(v->tile);
1245 
1246  if (dir != DirToDiagDir(v->direction)) continue;
1247  switch (dir) {
1248  default: SlErrorCorrupt("Invalid vehicle direction");
1249  case DIAGDIR_NE: if ((v->x_pos & 0xF) != 0) continue; break;
1250  case DIAGDIR_SE: if ((v->y_pos & 0xF) != TILE_SIZE - 1) continue; break;
1251  case DIAGDIR_SW: if ((v->x_pos & 0xF) != TILE_SIZE - 1) continue; break;
1252  case DIAGDIR_NW: if ((v->y_pos & 0xF) != 0) continue; break;
1253  }
1254  } else if (v->z_pos > GetSlopePixelZ(v->x_pos, v->y_pos)) {
1255  v->tile = GetNorthernBridgeEnd(v->tile);
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  Order* order;
1733  FOR_VEHICLE_ORDERS(v, order) order->SetNonStopType(ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS);
1734  }
1735  }
1736  } else if (IsSavegameVersionBefore(SLV_94)) {
1737  /* Unload and transfer are now mutual exclusive. */
1738  for (Order *order : Order::Iterate()) {
1739  if ((order->GetUnloadType() & (OUFB_UNLOAD | OUFB_TRANSFER)) == (OUFB_UNLOAD | OUFB_TRANSFER)) {
1740  order->SetUnloadType(OUFB_TRANSFER);
1741  order->SetLoadType(OLFB_NO_LOAD);
1742  }
1743  }
1744 
1745  for (Vehicle *v : Vehicle::Iterate()) {
1746  if ((v->current_order.GetUnloadType() & (OUFB_UNLOAD | OUFB_TRANSFER)) == (OUFB_UNLOAD | OUFB_TRANSFER)) {
1747  v->current_order.SetUnloadType(OUFB_TRANSFER);
1748  v->current_order.SetLoadType(OLFB_NO_LOAD);
1749  }
1750  }
1751  }
1752 
1754  /* Set all share owners to INVALID_COMPANY for
1755  * 1) all inactive companies
1756  * (when inactive companies were stored in the savegame - TTD, TTDP and some
1757  * *really* old revisions of OTTD; else it is already set in InitializeCompanies())
1758  * 2) shares that are owned by inactive companies or self
1759  * (caused by cheating clients in earlier revisions) */
1760  for (Company *c : Company::Iterate()) {
1761  for (uint i = 0; i < 4; i++) {
1762  CompanyID company = c->share_owners[i];
1763  if (company == INVALID_COMPANY) continue;
1764  if (!Company::IsValidID(company) || company == c->index) c->share_owners[i] = INVALID_COMPANY;
1765  }
1766  }
1767  }
1768 
1769  /* The water class was moved/unified. */
1771  for (TileIndex t = 0; t < map_size; t++) {
1772  switch (GetTileType(t)) {
1773  case MP_STATION:
1774  switch (GetStationType(t)) {
1775  case STATION_OILRIG:
1776  case STATION_DOCK:
1777  case STATION_BUOY:
1778  SetWaterClass(t, (WaterClass)GB(_m[t].m3, 0, 2));
1779  SB(_m[t].m3, 0, 2, 0);
1780  break;
1781 
1782  default:
1784  break;
1785  }
1786  break;
1787 
1788  case MP_WATER:
1789  SetWaterClass(t, (WaterClass)GB(_m[t].m3, 0, 2));
1790  SB(_m[t].m3, 0, 2, 0);
1791  break;
1792 
1793  case MP_OBJECT:
1795  break;
1796 
1797  default:
1798  /* No water class. */
1799  break;
1800  }
1801  }
1802  }
1803 
1805  for (TileIndex t = 0; t < map_size; t++) {
1806  /* Move river flag and update canals to use water class */
1807  if (IsTileType(t, MP_WATER)) {
1808  if (GetWaterClass(t) != WATER_CLASS_RIVER) {
1809  if (IsWater(t)) {
1810  Owner o = GetTileOwner(t);
1811  if (o == OWNER_WATER) {
1812  MakeSea(t);
1813  } else {
1814  MakeCanal(t, o, Random());
1815  }
1816  } else if (IsShipDepot(t)) {
1817  Owner o = (Owner)_m[t].m4; // Original water owner
1819  }
1820  }
1821  }
1822  }
1823 
1824  /* Update locks, depots, docks and buoys to have a water class based
1825  * on its neighbouring tiles. Done after river and canal updates to
1826  * ensure neighbours are correct. */
1827  for (TileIndex t = 0; t < map_size; t++) {
1828  if (!IsTileFlat(t)) continue;
1829 
1831  if (IsTileType(t, MP_STATION) && (IsDock(t) || IsBuoy(t))) SetWaterClassDependingOnSurroundings(t, false);
1832  }
1833  }
1834 
1836  for (TileIndex t = 0; t < map_size; t++) {
1837  /* skip oil rigs at borders! */
1838  if ((IsTileType(t, MP_WATER) || IsBuoyTile(t)) &&
1839  (TileX(t) == 0 || TileY(t) == 0 || TileX(t) == MapMaxX() - 1 || TileY(t) == MapMaxY() - 1)) {
1840  /* Some version 86 savegames have wrong water class at map borders (under buoy, or after removing buoy).
1841  * This conversion has to be done before buoys with invalid owner are removed. */
1843  }
1844 
1845  if (IsBuoyTile(t) || IsDriveThroughStopTile(t) || IsTileType(t, MP_WATER)) {
1846  Owner o = GetTileOwner(t);
1847  if (o < MAX_COMPANIES && !Company::IsValidID(o)) {
1848  Backup<CompanyID> cur_company(_current_company, o, FILE_LINE);
1850  cur_company.Restore();
1851  }
1852  if (IsBuoyTile(t)) {
1853  /* reset buoy owner to OWNER_NONE in the station struct
1854  * (even if it is owned by active company) */
1856  }
1857  } else if (IsTileType(t, MP_ROAD)) {
1858  /* works for all RoadTileType */
1859  FOR_ALL_ROADTRAMTYPES(rtt) {
1860  /* update even non-existing road types to update tile owner too */
1861  Owner o = GetRoadOwner(t, rtt);
1862  if (o < MAX_COMPANIES && !Company::IsValidID(o)) SetRoadOwner(t, rtt, OWNER_NONE);
1863  }
1864  if (IsLevelCrossing(t)) {
1866  }
1867  } else if (IsPlainRailTile(t)) {
1869  }
1870  }
1871 
1872  /* Convert old PF settings to new */
1875  } else {
1877  }
1878 
1881  } else {
1883  }
1884 
1887  } else {
1889  }
1890  }
1891 
1893  /* Profits are now with 8 bit fract */
1894  for (Vehicle *v : Vehicle::Iterate()) {
1895  v->profit_this_year <<= 8;
1896  v->profit_last_year <<= 8;
1897  v->running_ticks = 0;
1898  }
1899  }
1900 
1902  /* Increase HouseAnimationFrame from 5 to 7 bits */
1903  for (TileIndex t = 0; t < map_size; t++) {
1904  if (IsTileType(t, MP_HOUSE) && GetHouseType(t) >= NEW_HOUSE_OFFSET) {
1905  SB(_me[t].m6, 2, 6, GB(_me[t].m6, 3, 5));
1906  SB(_m[t].m3, 5, 1, 0);
1907  }
1908  }
1909  }
1910 
1912  GroupStatistics::UpdateAfterLoad(); // Ensure statistics pool is initialised before trying to delete vehicles
1913  /* Remove all trams from savegames without tram support.
1914  * There would be trams without tram track under causing crashes sooner or later. */
1915  for (RoadVehicle *v : RoadVehicle::Iterate()) {
1916  if (v->First() == v && HasBit(EngInfo(v->engine_type)->misc_flags, EF_ROAD_TRAM)) {
1917  ShowErrorMessage(STR_WARNING_LOADGAME_REMOVED_TRAMS, INVALID_STRING_ID, WL_CRITICAL);
1918  delete v;
1919  }
1920  }
1921  }
1922 
1924  for (TileIndex t = 0; t < map_size; t++) {
1925  /* Set newly introduced WaterClass of industry tiles */
1926  if (IsTileType(t, MP_STATION) && IsOilRig(t)) {
1928  }
1929  if (IsTileType(t, MP_INDUSTRY)) {
1930  if ((GetIndustrySpec(GetIndustryType(t))->behaviour & INDUSTRYBEH_BUILT_ONWATER) != 0) {
1932  } else {
1934  }
1935  }
1936 
1937  /* Replace "house construction year" with "house age" */
1938  if (IsTileType(t, MP_HOUSE) && IsHouseCompleted(t)) {
1939  _m[t].m5 = Clamp(_cur_year - (_m[t].m5 + ORIGINAL_BASE_YEAR), 0, 0xFF);
1940  }
1941  }
1942  }
1943 
1944  /* Move the signal variant back up one bit for PBS. We don't convert the old PBS
1945  * format here, as an old layout wouldn't work properly anyway. To be safe, we
1946  * clear any possible PBS reservations as well. */
1948  for (TileIndex t = 0; t < map_size; t++) {
1949  switch (GetTileType(t)) {
1950  case MP_RAILWAY:
1951  if (HasSignals(t)) {
1952  /* move the signal variant */
1953  SetSignalVariant(t, TRACK_UPPER, HasBit(_m[t].m2, 2) ? SIG_SEMAPHORE : SIG_ELECTRIC);
1954  SetSignalVariant(t, TRACK_LOWER, HasBit(_m[t].m2, 6) ? SIG_SEMAPHORE : SIG_ELECTRIC);
1955  ClrBit(_m[t].m2, 2);
1956  ClrBit(_m[t].m2, 6);
1957  }
1958 
1959  /* Clear PBS reservation on track */
1960  if (IsRailDepot(t)) {
1961  SetDepotReservation(t, false);
1962  } else {
1964  }
1965  break;
1966 
1967  case MP_ROAD: // Clear PBS reservation on crossing
1968  if (IsLevelCrossing(t)) SetCrossingReservation(t, false);
1969  break;
1970 
1971  case MP_STATION: // Clear PBS reservation on station
1972  if (HasStationRail(t)) SetRailStationReservation(t, false);
1973  break;
1974 
1975  case MP_TUNNELBRIDGE: // Clear PBS reservation on tunnels/bridges
1977  break;
1978 
1979  default: break;
1980  }
1981  }
1982  }
1983 
1984  /* Reserve all tracks trains are currently on. */
1986  for (const Train *t : Train::Iterate()) {
1987  if (t->First() == t) t->ReserveTrackUnderConsist();
1988  }
1989  }
1990 
1992  for (TileIndex t = 0; t < map_size; t++) {
1993  /* Now all crossings should be in correct state */
1994  if (IsLevelCrossingTile(t)) UpdateLevelCrossing(t, false);
1995  }
1996  }
1997 
1999  /* Non-town-owned roads now store the closest town */
2001 
2002  /* signs with invalid owner left from older savegames */
2003  for (Sign *si : Sign::Iterate()) {
2004  if (si->owner != OWNER_NONE && !Company::IsValidID(si->owner)) si->owner = OWNER_NONE;
2005  }
2006 
2007  /* Station can get named based on an industry type, but the current ones
2008  * are not, so mark them as if they are not named by an industry. */
2009  for (Station *st : Station::Iterate()) {
2010  st->indtype = IT_INVALID;
2011  }
2012  }
2013 
2015  for (Aircraft *a : Aircraft::Iterate()) {
2016  /* Set engine_type of shadow and rotor */
2017  if (!a->IsNormalAircraft()) {
2018  a->engine_type = a->First()->engine_type;
2019  }
2020  }
2021 
2022  /* More companies ... */
2023  for (Company *c : Company::Iterate()) {
2024  if (c->bankrupt_asked == 0xFF) c->bankrupt_asked = 0xFFFF;
2025  }
2026 
2027  for (Engine *e : Engine::Iterate()) {
2028  if (e->company_avail == 0xFF) e->company_avail = 0xFFFF;
2029  }
2030 
2031  for (Town *t : Town::Iterate()) {
2032  if (t->have_ratings == 0xFF) t->have_ratings = 0xFFFF;
2033  for (uint i = 8; i != MAX_COMPANIES; i++) t->ratings[i] = RATING_INITIAL;
2034  }
2035  }
2036 
2038  for (TileIndex t = 0; t < map_size; t++) {
2039  /* Check for HQ bit being set, instead of using map accessor,
2040  * since we've already changed it code-wise */
2041  if (IsTileType(t, MP_OBJECT) && HasBit(_m[t].m5, 7)) {
2042  /* Move size and part identification of HQ out of the m5 attribute,
2043  * on new locations */
2044  _m[t].m3 = GB(_m[t].m5, 0, 5);
2045  _m[t].m5 = OBJECT_HQ;
2046  }
2047  }
2048  }
2050  for (TileIndex t = 0; t < map_size; t++) {
2051  if (!IsTileType(t, MP_OBJECT)) continue;
2052 
2053  /* Reordering/generalisation of the object bits. */
2054  ObjectType type = _m[t].m5;
2055  SB(_me[t].m6, 2, 4, type == OBJECT_HQ ? GB(_m[t].m3, 2, 3) : 0);
2056  _m[t].m3 = type == OBJECT_HQ ? GB(_m[t].m3, 1, 1) | GB(_m[t].m3, 0, 1) << 4 : 0;
2057 
2058  /* Make sure those bits are clear as well! */
2059  _m[t].m4 = 0;
2060  _me[t].m7 = 0;
2061  }
2062  }
2063 
2065  /* Make real objects for object tiles. */
2066  for (TileIndex t = 0; t < map_size; t++) {
2067  if (!IsTileType(t, MP_OBJECT)) continue;
2068 
2069  if (Town::GetNumItems() == 0) {
2070  /* No towns, so remove all objects! */
2071  DoClearSquare(t);
2072  } else {
2073  uint offset = _m[t].m3;
2074 
2075  /* Also move the animation state. */
2076  _m[t].m3 = GB(_me[t].m6, 2, 4);
2077  SB(_me[t].m6, 2, 4, 0);
2078 
2079  if (offset == 0) {
2080  /* No offset, so make the object. */
2081  ObjectType type = _m[t].m5;
2082  int size = type == OBJECT_HQ ? 2 : 1;
2083 
2084  if (!Object::CanAllocateItem()) {
2085  /* Nice... you managed to place 64k lighthouses and
2086  * antennae on the map... boohoo. */
2087  SlError(STR_ERROR_TOO_MANY_OBJECTS);
2088  }
2089 
2090  Object *o = new Object();
2091  o->location.tile = t;
2092  o->location.w = size;
2093  o->location.h = size;
2094  o->build_date = _date;
2095  o->town = type == OBJECT_STATUE ? Town::Get(_m[t].m2) : CalcClosestTownFromTile(t, UINT_MAX);
2096  _m[t].m2 = o->index;
2097  Object::IncTypeCount(type);
2098  } else {
2099  /* We're at an offset, so get the ID from our "root". */
2100  TileIndex northern_tile = t - TileXY(GB(offset, 0, 4), GB(offset, 4, 4));
2101  assert(IsTileType(northern_tile, MP_OBJECT));
2102  _m[t].m2 = _m[northern_tile].m2;
2103  }
2104  }
2105  }
2106  }
2107 
2109  /* allow_town_roads is added, set it if town_layout wasn't TL_NO_ROADS */
2110  if (_settings_game.economy.town_layout == 0) { // was TL_NO_ROADS
2113  } else {
2116  }
2117 
2118  /* Initialize layout of all towns. Older versions were using different
2119  * generator for random town layout, use it if needed. */
2120  for (Town *t : Town::Iterate()) {
2122  t->layout = _settings_game.economy.town_layout;
2123  continue;
2124  }
2125 
2126  /* Use old layout randomizer code */
2127  byte layout = TileHash(TileX(t->xy), TileY(t->xy)) % 6;
2128  switch (layout) {
2129  default: break;
2130  case 5: layout = 1; break;
2131  case 0: layout = 2; break;
2132  }
2133  t->layout = static_cast<TownLayout>(layout - 1);
2134  }
2135  }
2136 
2138  /* There could be (deleted) stations with invalid owner, set owner to OWNER NONE.
2139  * The conversion affects oil rigs and buoys too, but it doesn't matter as
2140  * they have st->owner == OWNER_NONE already. */
2141  for (Station *st : Station::Iterate()) {
2142  if (!Company::IsValidID(st->owner)) st->owner = OWNER_NONE;
2143  }
2144  }
2145 
2146  /* Trains could now stop in a specific location. */
2148  for (Order *o : Order::Iterate()) {
2149  if (o->IsType(OT_GOTO_STATION)) o->SetStopLocation(OSL_PLATFORM_FAR_END);
2150  }
2151  }
2152 
2155  for (Company *c : Company::Iterate()) {
2156  c->settings.vehicle = _old_vds;
2157  }
2158  }
2159 
2161  /* Delete small ufos heading for non-existing vehicles */
2162  for (Vehicle *v : DisasterVehicle::Iterate()) {
2163  if (v->subtype == 2 /* ST_SMALL_UFO */ && v->current_order.GetDestination() != 0) {
2164  const Vehicle *u = Vehicle::GetIfValid(v->dest_tile);
2165  if (u == nullptr || u->type != VEH_ROAD || !RoadVehicle::From(u)->IsFrontEngine()) {
2166  delete v;
2167  }
2168  }
2169  }
2170 
2171  /* We didn't store cargo payment yet, so make them for vehicles that are
2172  * currently at a station and loading/unloading. If they don't get any
2173  * payment anymore they just removed in the next load/unload cycle.
2174  * However, some 0.7 versions might have cargo payment. For those we just
2175  * add cargopayment for the vehicles that don't have it.
2176  */
2177  for (Station *st : Station::Iterate()) {
2178  std::list<Vehicle *>::iterator iter;
2179  for (iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end(); ++iter) {
2180  /* There are always as many CargoPayments as Vehicles. We need to make the
2181  * assert() in Pool::GetNew() happy by calling CanAllocateItem(). */
2184  Vehicle *v = *iter;
2185  if (v->cargo_payment == nullptr) v->cargo_payment = new CargoPayment(v);
2186  }
2187  }
2188  }
2189 
2191  /* Animated tiles would sometimes not be actually animated or
2192  * in case of old savegames duplicate. */
2193 
2194  extern std::vector<TileIndex> _animated_tiles;
2195 
2196  for (auto tile = _animated_tiles.begin(); tile < _animated_tiles.end(); /* Nothing */) {
2197  /* Remove if tile is not animated */
2198  bool remove = _tile_type_procs[GetTileType(*tile)]->animate_tile_proc == nullptr;
2199 
2200  /* and remove if duplicate */
2201  for (auto j = _animated_tiles.begin(); !remove && j < tile; j++) {
2202  remove = *tile == *j;
2203  }
2204 
2205  if (remove) {
2206  DeleteAnimatedTile(*tile);
2207  } else {
2208  tile++;
2209  }
2210  }
2211  }
2212 
2214  /* The train station tile area was added, but for really old (TTDPatch) it's already valid. */
2215  for (Waypoint *wp : Waypoint::Iterate()) {
2216  if (wp->facilities & FACIL_TRAIN) {
2217  wp->train_station.tile = wp->xy;
2218  wp->train_station.w = 1;
2219  wp->train_station.h = 1;
2220  } else {
2221  wp->train_station.tile = INVALID_TILE;
2222  wp->train_station.w = 0;
2223  wp->train_station.h = 0;
2224  }
2225  }
2226  }
2227 
2229  /* Convert old subsidies */
2230  for (Subsidy *s : Subsidy::Iterate()) {
2231  if (s->remaining < 12) {
2232  /* Converting nonawarded subsidy */
2233  s->remaining = 12 - s->remaining; // convert "age" to "remaining"
2234  s->awarded = INVALID_COMPANY; // not awarded to anyone
2235  const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
2236  switch (cs->town_effect) {
2237  case TE_PASSENGERS:
2238  case TE_MAIL:
2239  /* Town -> Town */
2240  s->src_type = s->dst_type = ST_TOWN;
2241  if (Town::IsValidID(s->src) && Town::IsValidID(s->dst)) continue;
2242  break;
2243  case TE_GOODS:
2244  case TE_FOOD:
2245  /* Industry -> Town */
2246  s->src_type = ST_INDUSTRY;
2247  s->dst_type = ST_TOWN;
2248  if (Industry::IsValidID(s->src) && Town::IsValidID(s->dst)) continue;
2249  break;
2250  default:
2251  /* Industry -> Industry */
2252  s->src_type = s->dst_type = ST_INDUSTRY;
2253  if (Industry::IsValidID(s->src) && Industry::IsValidID(s->dst)) continue;
2254  break;
2255  }
2256  } else {
2257  /* Do our best for awarded subsidies. The original source or destination industry
2258  * can't be determined anymore for awarded subsidies, so invalidate them.
2259  * Town -> Town subsidies are converted using simple heuristic */
2260  s->remaining = 24 - s->remaining; // convert "age of awarded subsidy" to "remaining"
2261  const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
2262  switch (cs->town_effect) {
2263  case TE_PASSENGERS:
2264  case TE_MAIL: {
2265  /* Town -> Town */
2266  const Station *ss = Station::GetIfValid(s->src);
2267  const Station *sd = Station::GetIfValid(s->dst);
2268  if (ss != nullptr && sd != nullptr && ss->owner == sd->owner &&
2269  Company::IsValidID(ss->owner)) {
2270  s->src_type = s->dst_type = ST_TOWN;
2271  s->src = ss->town->index;
2272  s->dst = sd->town->index;
2273  s->awarded = ss->owner;
2274  continue;
2275  }
2276  break;
2277  }
2278  default:
2279  break;
2280  }
2281  }
2282  /* Awarded non-town subsidy or invalid source/destination, invalidate */
2283  delete s;
2284  }
2285  }
2286 
2288  /* Recompute inflation based on old unround loan limit
2289  * Note: Max loan is 500000. With an inflation of 4% across 170 years
2290  * that results in a max loan of about 0.7 * 2^31.
2291  * So taking the 16 bit fractional part into account there are plenty of bits left
2292  * for unmodified savegames ...
2293  */
2294  uint64 aimed_inflation = (_economy.old_max_loan_unround << 16 | _economy.old_max_loan_unround_fract) / _settings_game.difficulty.max_loan;
2295 
2296  /* ... well, just clamp it then. */
2297  if (aimed_inflation > MAX_INFLATION) aimed_inflation = MAX_INFLATION;
2298 
2299  /* Simulate the inflation, so we also get the payment inflation */
2300  while (_economy.inflation_prices < aimed_inflation) {
2301  if (AddInflation(false)) break;
2302  }
2303  }
2304 
2306  for (const Depot *d : Depot::Iterate()) {
2307  /* At some point, invalid depots were saved into the game (possibly those removed in the past?)
2308  * Remove them here, so they don't cause issues further down the line */
2309  if (!IsDepotTile(d->xy)) {
2310  DEBUG(sl, 0, "Removing invalid depot %d at %d, %d", d->index, TileX(d->xy), TileY(d->xy));
2311  delete d;
2312  d = nullptr;
2313  continue;
2314  }
2315  _m[d->xy].m2 = d->index;
2316  if (IsTileType(d->xy, MP_WATER)) _m[GetOtherShipDepotTile(d->xy)].m2 = d->index;
2317  }
2318  }
2319 
2320  /* The behaviour of force_proceed has been changed. Now
2321  * it counts signals instead of some random time out. */
2323  for (Train *t : Train::Iterate()) {
2324  if (t->force_proceed != TFP_NONE) {
2325  t->force_proceed = TFP_STUCK;
2326  }
2327  }
2328  }
2329 
2330  /* The bits for the tree ground and tree density have
2331  * been swapped (m2 bits 7..6 and 5..4. */
2333  for (TileIndex t = 0; t < map_size; t++) {
2334  if (IsTileType(t, MP_CLEAR)) {
2335  if (GetRawClearGround(t) == CLEAR_SNOW) {
2337  SetBit(_m[t].m3, 4);
2338  } else {
2339  ClrBit(_m[t].m3, 4);
2340  }
2341  }
2342  if (IsTileType(t, MP_TREES)) {
2343  uint density = GB(_m[t].m2, 6, 2);
2344  uint ground = GB(_m[t].m2, 4, 2);
2345  uint counter = GB(_m[t].m2, 0, 4);
2346  _m[t].m2 = ground << 6 | density << 4 | counter;
2347  }
2348  }
2349  }
2350 
2351  /* Wait counter and load/unload ticks got split. */
2353  for (Aircraft *a : Aircraft::Iterate()) {
2354  a->turn_counter = a->current_order.IsType(OT_LOADING) ? 0 : a->load_unload_ticks;
2355  }
2356 
2357  for (Train *t : Train::Iterate()) {
2358  t->wait_counter = t->current_order.IsType(OT_LOADING) ? 0 : t->load_unload_ticks;
2359  }
2360  }
2361 
2362  /* Airport tile animation uses animation frame instead of other graphics id */
2364  struct AirportTileConversion {
2365  byte old_start;
2366  byte num_frames;
2367  };
2368  static const AirportTileConversion atc[] = {
2369  {31, 12}, // APT_RADAR_GRASS_FENCE_SW
2370  {50, 4}, // APT_GRASS_FENCE_NE_FLAG
2371  {62, 2}, // 1 unused tile
2372  {66, 12}, // APT_RADAR_FENCE_SW
2373  {78, 12}, // APT_RADAR_FENCE_NE
2374  {101, 10}, // 9 unused tiles
2375  {111, 8}, // 7 unused tiles
2376  {119, 15}, // 14 unused tiles (radar)
2377  {140, 4}, // APT_GRASS_FENCE_NE_FLAG_2
2378  };
2379  for (TileIndex t = 0; t < map_size; t++) {
2380  if (IsAirportTile(t)) {
2381  StationGfx old_gfx = GetStationGfx(t);
2382  byte offset = 0;
2383  for (uint i = 0; i < lengthof(atc); i++) {
2384  if (old_gfx < atc[i].old_start) {
2385  SetStationGfx(t, old_gfx - offset);
2386  break;
2387  }
2388  if (old_gfx < atc[i].old_start + atc[i].num_frames) {
2389  SetAnimationFrame(t, old_gfx - atc[i].old_start);
2390  SetStationGfx(t, atc[i].old_start - offset);
2391  break;
2392  }
2393  offset += atc[i].num_frames - 1;
2394  }
2395  }
2396  }
2397  }
2398 
2400  for (Station *st : Station::Iterate()) {
2401  if (st->airport.tile != INVALID_TILE) {
2402  st->airport.w = st->airport.GetSpec()->size_x;
2403  st->airport.h = st->airport.GetSpec()->size_y;
2404  }
2405  }
2406  }
2407 
2409  for (TileIndex t = 0; t < map_size; t++) {
2410  /* Reset tropic zone for VOID tiles, they shall not have any. */
2412  }
2413 
2414  /* We need to properly number/name the depots.
2415  * The first step is making sure none of the depots uses the
2416  * 'default' names, after that we can assign the names. */
2417  for (Depot *d : Depot::Iterate()) d->town_cn = UINT16_MAX;
2418 
2419  for (Depot* d : Depot::Iterate()) MakeDefaultName(d);
2420  }
2421 
2423  for (Depot *d : Depot::Iterate()) d->build_date = _date;
2424  }
2425 
2426  /* In old versions it was possible to remove an airport while a plane was
2427  * taking off or landing. This gives all kind of problems when building
2428  * another airport in the same station so we don't allow that anymore.
2429  * For old savegames with such aircraft we just throw them in the air and
2430  * treat the aircraft like they were flying already. */
2432  for (Aircraft *v : Aircraft::Iterate()) {
2433  if (!v->IsNormalAircraft()) continue;
2435  if (st == nullptr && v->state != FLYING) {
2436  v->state = FLYING;
2439  /* get aircraft back on running altitude */
2440  if ((v->vehstatus & VS_CRASHED) == 0) {
2441  GetAircraftFlightLevelBounds(v, &v->z_pos, nullptr);
2442  SetAircraftPosition(v, v->x_pos, v->y_pos, GetAircraftFlightLevel(v));
2443  }
2444  }
2445  }
2446  }
2447 
2448  /* Move the animation frame to the same location (m7) for all objects. */
2450  for (TileIndex t = 0; t < map_size; t++) {
2451  switch (GetTileType(t)) {
2452  case MP_HOUSE:
2453  if (GetHouseType(t) >= NEW_HOUSE_OFFSET) {
2454  uint per_proc = _me[t].m7;
2455  _me[t].m7 = GB(_me[t].m6, 2, 6) | (GB(_m[t].m3, 5, 1) << 6);
2456  SB(_m[t].m3, 5, 1, 0);
2457  SB(_me[t].m6, 2, 6, min(per_proc, 63));
2458  }
2459  break;
2460 
2461  case MP_INDUSTRY: {
2462  uint rand = _me[t].m7;
2463  _me[t].m7 = _m[t].m3;
2464  _m[t].m3 = rand;
2465  break;
2466  }
2467 
2468  case MP_OBJECT:
2469  _me[t].m7 = _m[t].m3;
2470  _m[t].m3 = 0;
2471  break;
2472 
2473  default:
2474  /* For stations/airports it's already at m7 */
2475  break;
2476  }
2477  }
2478  }
2479 
2480  /* Add (random) colour to all objects. */
2482  for (Object *o : Object::Iterate()) {
2483  Owner owner = GetTileOwner(o->location.tile);
2484  o->colour = (owner == OWNER_NONE) ? Random() & 0xF : Company::Get(owner)->livery->colour1;
2485  }
2486  }
2487 
2489  for (TileIndex t = 0; t < map_size; t++) {
2490  if (!IsTileType(t, MP_STATION)) continue;
2491  if (!IsBuoy(t) && !IsOilRig(t) && !(IsDock(t) && IsTileFlat(t))) {
2493  }
2494  }
2495 
2496  /* Waypoints with custom name may have a non-unique town_cn,
2497  * renumber those. First set all affected waypoints to the
2498  * highest possible number to get them numbered in the
2499  * order they have in the pool. */
2500  for (Waypoint *wp : Waypoint::Iterate()) {
2501  if (wp->name != nullptr) wp->town_cn = UINT16_MAX;
2502  }
2503 
2504  for (Waypoint* wp : Waypoint::Iterate()) {
2505  if (wp->name != nullptr) MakeDefaultName(wp);
2506  }
2507  }
2508 
2510  _industry_builder.Reset(); // Initialize industry build data.
2511 
2512  /* The moment vehicles go from hidden to visible changed. This means
2513  * that vehicles don't always get visible anymore causing things to
2514  * get messed up just after loading the savegame. This fixes that. */
2515  for (Vehicle *v : Vehicle::Iterate()) {
2516  /* Not all vehicle types can be inside a tunnel. Furthermore,
2517  * testing IsTunnelTile() for invalid tiles causes a crash. */
2518  if (!v->IsGroundVehicle()) continue;
2519 
2520  /* Is the vehicle in a tunnel? */
2521  if (!IsTunnelTile(v->tile)) continue;
2522 
2523  /* Is the vehicle actually at a tunnel entrance/exit? */
2524  TileIndex vtile = TileVirtXY(v->x_pos, v->y_pos);
2525  if (!IsTunnelTile(vtile)) continue;
2526 
2527  /* Are we actually in this tunnel? Or maybe a lower tunnel? */
2528  if (GetSlopePixelZ(v->x_pos, v->y_pos) != v->z_pos) continue;
2529 
2530  /* What way are we going? */
2531  const DiagDirection dir = GetTunnelBridgeDirection(vtile);
2532  const DiagDirection vdir = DirToDiagDir(v->direction);
2533 
2534  /* Have we passed the visibility "switch" state already? */
2535  byte pos = (DiagDirToAxis(vdir) == AXIS_X ? v->x_pos : v->y_pos) & TILE_UNIT_MASK;
2536  byte frame = (vdir == DIAGDIR_NE || vdir == DIAGDIR_NW) ? TILE_SIZE - 1 - pos : pos;
2537  extern const byte _tunnel_visibility_frame[DIAGDIR_END];
2538 
2539  /* Should the vehicle be hidden or not? */
2540  bool hidden;
2541  if (dir == vdir) { // Entering tunnel
2542  hidden = frame >= _tunnel_visibility_frame[dir];
2543  v->tile = vtile;
2544  } else if (dir == ReverseDiagDir(vdir)) { // Leaving tunnel
2545  hidden = frame < TILE_SIZE - _tunnel_visibility_frame[dir];
2546  /* v->tile changes at the moment when the vehicle leaves the tunnel. */
2547  v->tile = hidden ? GetOtherTunnelBridgeEnd(vtile) : vtile;
2548  } else {
2549  /* We could get here in two cases:
2550  * - for road vehicles, it is reversing at the end of the tunnel
2551  * - it is crashed in the tunnel entry (both train or RV destroyed by UFO)
2552  * Whatever case it is, do not change anything and use the old values.
2553  * Especially changing RV's state would break its reversing in the middle. */
2554  continue;
2555  }
2556 
2557  if (hidden) {
2558  v->vehstatus |= VS_HIDDEN;
2559 
2560  switch (v->type) {
2561  case VEH_TRAIN: Train::From(v)->track = TRACK_BIT_WORMHOLE; break;
2562  case VEH_ROAD: RoadVehicle::From(v)->state = RVSB_WORMHOLE; break;
2563  default: NOT_REACHED();
2564  }
2565  } else {
2566  v->vehstatus &= ~VS_HIDDEN;
2567 
2568  switch (v->type) {
2569  case VEH_TRAIN: Train::From(v)->track = DiagDirToDiagTrackBits(vdir); break;
2570  case VEH_ROAD: RoadVehicle::From(v)->state = DiagDirToDiagTrackdir(vdir); RoadVehicle::From(v)->frame = frame; break;
2571  default: NOT_REACHED();
2572  }
2573  }
2574  }
2575  }
2576 
2578  for (RoadVehicle *rv : RoadVehicle::Iterate()) {
2579  if (rv->state == RVSB_IN_DEPOT || rv->state == RVSB_WORMHOLE) continue;
2580 
2581  bool loading = rv->current_order.IsType(OT_LOADING) || rv->current_order.IsType(OT_LEAVESTATION);
2582  if (HasBit(rv->state, RVS_IN_ROAD_STOP)) {
2583  extern const byte _road_stop_stop_frame[];
2584  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)]);
2585  } else if (HasBit(rv->state, RVS_IN_DT_ROAD_STOP)) {
2586  SB(rv->state, RVS_ENTERED_STOP, 1, loading || rv->frame > RVC_DRIVE_THROUGH_STOP_FRAME);
2587  }
2588  }
2589  }
2590 
2592  /* The train's pathfinder lost flag got moved. */
2593  for (Train *t : Train::Iterate()) {
2594  if (!HasBit(t->flags, 5)) continue;
2595 
2596  ClrBit(t->flags, 5);
2597  SetBit(t->vehicle_flags, VF_PATHFINDER_LOST);
2598  }
2599 
2600  /* Introduced terraform/clear limits. */
2601  for (Company *c : Company::Iterate()) {
2602  c->terraform_limit = _settings_game.construction.terraform_frame_burst << 16;
2603  c->clear_limit = _settings_game.construction.clear_frame_burst << 16;
2604  }
2605  }
2606 
2608  for (Vehicle *v : Vehicle::Iterate()) {
2609  switch (v->type) {
2610  case VEH_TRAIN: {
2611  Train *t = Train::From(v);
2612 
2613  /* Clear old GOINGUP / GOINGDOWN flags.
2614  * It was changed in savegame version 139, but savegame
2615  * version 158 doesn't use these bits, so it doesn't hurt
2616  * to clear them unconditionally. */
2617  ClrBit(t->flags, 1);
2618  ClrBit(t->flags, 2);
2619 
2620  /* Clear both bits first. */
2623 
2624  /* Crashed vehicles can't be going up/down. */
2625  if (t->vehstatus & VS_CRASHED) break;
2626 
2627  /* Only X/Y tracks can be sloped. */
2628  if (t->track != TRACK_BIT_X && t->track != TRACK_BIT_Y) break;
2629 
2631  break;
2632  }
2633  case VEH_ROAD: {
2634  RoadVehicle *rv = RoadVehicle::From(v);
2637 
2638  /* Crashed vehicles can't be going up/down. */
2639  if (rv->vehstatus & VS_CRASHED) break;
2640 
2641  if (rv->state == RVSB_IN_DEPOT || rv->state == RVSB_WORMHOLE) break;
2642 
2643  TrackStatus ts = GetTileTrackStatus(rv->tile, TRANSPORT_ROAD, GetRoadTramType(rv->roadtype));
2644  TrackBits trackbits = TrackStatusToTrackBits(ts);
2645 
2646  /* Only X/Y tracks can be sloped. */
2647  if (trackbits != TRACK_BIT_X && trackbits != TRACK_BIT_Y) break;
2648 
2649  Direction dir = rv->direction;
2650 
2651  /* Test if we are reversing. */
2652  Axis a = trackbits == TRACK_BIT_X ? AXIS_X : AXIS_Y;
2653  if (AxisToDirection(a) != dir &&
2654  AxisToDirection(a) != ReverseDir(dir)) {
2655  /* When reversing, the road vehicle is on the edge of the tile,
2656  * so it can be safely compared to the middle of the tile. */
2657  dir = INVALID_DIR;
2658  }
2659 
2660  rv->gv_flags |= FixVehicleInclination(rv, dir);
2661  break;
2662  }
2663  case VEH_SHIP:
2664  break;
2665 
2666  default:
2667  continue;
2668  }
2669 
2670  if (IsBridgeTile(v->tile) && TileVirtXY(v->x_pos, v->y_pos) == v->tile) {
2671  /* In old versions, z_pos was 1 unit lower on bridge heads.
2672  * However, this invalid state could be converted to new savegames
2673  * by loading and saving the game in a new version. */
2674  v->z_pos = GetSlopePixelZ(v->x_pos, v->y_pos);
2675  DiagDirection dir = GetTunnelBridgeDirection(v->tile);
2676  if (v->type == VEH_TRAIN && !(v->vehstatus & VS_CRASHED) &&
2677  v->direction != DiagDirToDir(dir)) {
2678  /* If the train has left the bridge, it shouldn't have
2679  * track == TRACK_BIT_WORMHOLE - this could happen
2680  * when the train was reversed while on the last "tick"
2681  * on the ramp before leaving the ramp to the bridge. */
2682  Train::From(v)->track = DiagDirToDiagTrackBits(dir);
2683  }
2684  }
2685 
2686  /* If the vehicle is really above v->tile (not in a wormhole),
2687  * it should have set v->z_pos correctly. */
2688  assert(v->tile != TileVirtXY(v->x_pos, v->y_pos) || v->z_pos == GetSlopePixelZ(v->x_pos, v->y_pos));
2689  }
2690 
2691  /* Fill Vehicle::cur_real_order_index */
2692  for (Vehicle *v : Vehicle::Iterate()) {
2693  if (!v->IsPrimaryVehicle()) continue;
2694 
2695  /* Older versions are less strict with indices being in range and fix them on the fly */
2696  if (v->cur_implicit_order_index >= v->GetNumOrders()) v->cur_implicit_order_index = 0;
2697 
2698  v->cur_real_order_index = v->cur_implicit_order_index;
2699  v->UpdateRealOrderIndex();
2700  }
2701  }
2702 
2704  /* If the savegame is old (before version 100), then the value of 255
2705  * for these settings did not mean "disabled". As such everything
2706  * before then did reverse.
2707  * To simplify stuff we disable all turning around or we do not
2708  * disable anything at all. So, if some reversing was disabled we
2709  * will keep reversing disabled, otherwise it'll be turned on. */
2711 
2712  for (Train *t : Train::Iterate()) {
2713  _settings_game.vehicle.max_train_length = max<uint8>(_settings_game.vehicle.max_train_length, CeilDiv(t->gcache.cached_total_length, TILE_SIZE));
2714  }
2715  }
2716 
2718  /* Setting difficulty industry_density other than zero get bumped to +1
2719  * since a new option (minimal at position 1) has been added */
2722  }
2723  }
2724 
2726  /* Before savegame version 161, persistent storages were not stored in a pool. */
2727 
2729  for (Industry *ind : Industry::Iterate()) {
2730  assert(ind->psa != nullptr);
2731 
2732  /* Check if the old storage was empty. */
2733  bool is_empty = true;
2734  for (uint i = 0; i < sizeof(ind->psa->storage); i++) {
2735  if (ind->psa->GetValue(i) != 0) {
2736  is_empty = false;
2737  break;
2738  }
2739  }
2740 
2741  if (!is_empty) {
2742  ind->psa->grfid = _industry_mngr.GetGRFID(ind->type);
2743  } else {
2744  delete ind->psa;
2745  ind->psa = nullptr;
2746  }
2747  }
2748  }
2749 
2751  for (Station *st : Station::Iterate()) {
2752  if (!(st->facilities & FACIL_AIRPORT)) continue;
2753  assert(st->airport.psa != nullptr);
2754 
2755  /* Check if the old storage was empty. */
2756  bool is_empty = true;
2757  for (uint i = 0; i < sizeof(st->airport.psa->storage); i++) {
2758  if (st->airport.psa->GetValue(i) != 0) {
2759  is_empty = false;
2760  break;
2761  }
2762  }
2763 
2764  if (!is_empty) {
2765  st->airport.psa->grfid = _airport_mngr.GetGRFID(st->airport.type);
2766  } else {
2767  delete st->airport.psa;
2768  st->airport.psa = nullptr;
2769 
2770  }
2771  }
2772  }
2773  }
2774 
2775  /* This triggers only when old snow_lines were copied into the snow_line_height. */
2778  }
2779 
2781  /* We store 4 fences in the field tiles instead of only SE and SW. */
2782  for (TileIndex t = 0; t < map_size; t++) {
2783  if (!IsTileType(t, MP_CLEAR) && !IsTileType(t, MP_TREES)) continue;
2784  if (IsTileType(t, MP_CLEAR) && IsClearGround(t, CLEAR_FIELDS)) continue;
2785  uint fence = GB(_m[t].m4, 5, 3);
2786  if (fence != 0 && IsTileType(TILE_ADDXY(t, 1, 0), MP_CLEAR) && IsClearGround(TILE_ADDXY(t, 1, 0), CLEAR_FIELDS)) {
2787  SetFence(TILE_ADDXY(t, 1, 0), DIAGDIR_NE, fence);
2788  }
2789  fence = GB(_m[t].m4, 2, 3);
2790  if (fence != 0 && IsTileType(TILE_ADDXY(t, 0, 1), MP_CLEAR) && IsClearGround(TILE_ADDXY(t, 0, 1), CLEAR_FIELDS)) {
2791  SetFence(TILE_ADDXY(t, 0, 1), DIAGDIR_NW, fence);
2792  }
2793  SB(_m[t].m4, 2, 3, 0);
2794  SB(_m[t].m4, 5, 3, 0);
2795  }
2796  }
2797 
2798  /* The center of train vehicles was changed, fix up spacing. */
2800 
2802  for (Town *t : Town::Iterate()) {
2803  /* Set the default cargo requirement for town growth */
2805  case LT_ARCTIC:
2806  if (FindFirstCargoWithTownEffect(TE_FOOD) != nullptr) t->goal[TE_FOOD] = TOWN_GROWTH_WINTER;
2807  break;
2808 
2809  case LT_TROPIC:
2810  if (FindFirstCargoWithTownEffect(TE_FOOD) != nullptr) t->goal[TE_FOOD] = TOWN_GROWTH_DESERT;
2812  break;
2813  }
2814  }
2815  }
2816 
2818  /* Adjust zoom level to account for new levels */
2819  _saved_scrollpos_zoom = static_cast<ZoomLevel>(_saved_scrollpos_zoom + ZOOM_LVL_SHIFT);
2820  _saved_scrollpos_x *= ZOOM_LVL_BASE;
2821  _saved_scrollpos_y *= ZOOM_LVL_BASE;
2822  }
2823 
2824  /* When any NewGRF has been changed the availability of some vehicles might
2825  * have been changed too. e->company_avail must be set to 0 in that case
2826  * which is done by StartupEngines(). */
2827  if (gcf_res != GLC_ALL_GOOD) StartupEngines();
2828 
2830  /* Update cargo acceptance map of towns. */
2831  for (TileIndex t = 0; t < map_size; t++) {
2832  if (!IsTileType(t, MP_HOUSE)) continue;
2833  Town::Get(GetTownIndex(t))->cargo_accepted.Add(t);
2834  }
2835 
2836  for (Town *town : Town::Iterate()) {
2837  UpdateTownCargoes(town);
2838  }
2839  }
2840 
2841  /* The road owner of standard road stops was not properly accounted for. */
2843  for (TileIndex t = 0; t < map_size; t++) {
2844  if (!IsStandardRoadStopTile(t)) continue;
2845  Owner o = GetTileOwner(t);
2846  SetRoadOwner(t, RTT_ROAD, o);
2847  SetRoadOwner(t, RTT_TRAM, o);
2848  }
2849  }
2850 
2852  /* Introduced tree planting limit. */
2853  for (Company *c : Company::Iterate()) c->tree_limit = _settings_game.construction.tree_frame_burst << 16;
2854  }
2855 
2857  /* Fix too high inflation rates */
2858  if (_economy.inflation_prices > MAX_INFLATION) _economy.inflation_prices = MAX_INFLATION;
2860 
2861  /* We have to convert the quarters of bankruptcy into months of bankruptcy */
2862  for (Company *c : Company::Iterate()) {
2863  c->months_of_bankruptcy = 3 * c->months_of_bankruptcy;
2864  }
2865  }
2866 
2868  extern uint8 _old_diff_level;
2869  /* Initialise script settings profile */
2870  _settings_game.script.settings_profile = IsInsideMM(_old_diff_level, SP_BEGIN, SP_END) ? _old_diff_level : (uint)SP_MEDIUM;
2871  }
2872 
2874  /* Aircraft acceleration variable was bonkers */
2875  for (Aircraft *v : Aircraft::Iterate()) {
2876  if (v->subtype <= AIR_AIRCRAFT) {
2877  const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);
2878  v->acceleration = avi->acceleration;
2879  }
2880  }
2881 
2882  /* Blocked tiles could be reserved due to a bug, which causes
2883  * other places to assert upon e.g. station reconstruction. */
2884  for (TileIndex t = 0; t < map_size; t++) {
2886  SetRailStationReservation(t, false);
2887  }
2888  }
2889  }
2890 
2892  /* The global units configuration is split up in multiple configurations. */
2893  extern uint8 _old_units;
2894  _settings_game.locale.units_velocity = Clamp(_old_units, 0, 2);
2895  _settings_game.locale.units_power = Clamp(_old_units, 0, 2);
2896  _settings_game.locale.units_weight = Clamp(_old_units, 1, 2);
2897  _settings_game.locale.units_volume = Clamp(_old_units, 1, 2);
2899  _settings_game.locale.units_height = Clamp(_old_units, 0, 2);
2900  }
2901 
2903  /* Move ObjectType from map to pool */
2904  for (TileIndex t = 0; t < map_size; t++) {
2905  if (IsTileType(t, MP_OBJECT)) {
2906  Object *o = Object::Get(_m[t].m2);
2907  o->type = _m[t].m5;
2908  _m[t].m5 = 0; // zero upper bits of (now bigger) ObjectID
2909  }
2910  }
2911  }
2912 
2914  /* Fix articulated road vehicles.
2915  * Some curves were shorter than other curves.
2916  * Now they have the same length, but that means that trailing articulated parts will
2917  * take longer to go through the curve than the parts in front which already left the courve.
2918  * So, make articulated parts catch up. */
2919  bool roadside = _settings_game.vehicle.road_side == 1;
2920  std::vector<uint> skip_frames;
2921  for (RoadVehicle *v : RoadVehicle::Iterate()) {
2922  if (!v->IsFrontEngine()) continue;
2923  skip_frames.clear();
2924  TileIndex prev_tile = v->tile;
2925  uint prev_tile_skip = 0;
2926  uint cur_skip = 0;
2927  for (RoadVehicle *u = v; u != nullptr; u = u->Next()) {
2928  if (u->tile != prev_tile) {
2929  prev_tile_skip = cur_skip;
2930  prev_tile = u->tile;
2931  } else {
2932  cur_skip = prev_tile_skip;
2933  }
2934 
2935  /*C++17: uint &this_skip = */ skip_frames.push_back(prev_tile_skip);
2936  uint &this_skip = skip_frames.back();
2937 
2938  /* The following 3 curves now take longer than before */
2939  switch (u->state) {
2940  case 2:
2941  cur_skip++;
2942  if (u->frame <= (roadside ? 9 : 5)) this_skip = cur_skip;
2943  break;
2944 
2945  case 4:
2946  cur_skip++;
2947  if (u->frame <= (roadside ? 5 : 9)) this_skip = cur_skip;
2948  break;
2949 
2950  case 5:
2951  cur_skip++;
2952  if (u->frame <= (roadside ? 4 : 2)) this_skip = cur_skip;
2953  break;
2954 
2955  default:
2956  break;
2957  }
2958  }
2959  while (cur_skip > skip_frames[0]) {
2960  RoadVehicle *u = v;
2961  RoadVehicle *prev = nullptr;
2962  for (uint sf : skip_frames) {
2963  extern bool IndividualRoadVehicleController(RoadVehicle *v, const RoadVehicle *prev);
2964  if (sf >= cur_skip) IndividualRoadVehicleController(u, prev);
2965 
2966  prev = u;
2967  u = u->Next();
2968  }
2969  cur_skip--;
2970  }
2971  }
2972  }
2973 
2975  for (Order *order : Order::Iterate()) {
2976  order->SetTravelTimetabled(order->GetTravelTime() > 0);
2977  order->SetWaitTimetabled(order->GetWaitTime() > 0);
2978  }
2979  for (OrderList *orderlist : OrderList::Iterate()) {
2980  orderlist->RecalculateTimetableDuration();
2981  }
2982  }
2983 
2984  /*
2985  * Only keep order-backups for network clients (and when replaying).
2986  * If we are a network server or not networking, then we just loaded a previously
2987  * saved-by-server savegame. There are no clients with a backup, so clear it.
2988  * Furthermore before savegame version SLV_192 the actual content was always corrupt.
2989  */
2991 #ifndef DEBUG_DUMP_COMMANDS
2992  /* Note: We cannot use CleanPool since that skips part of the destructor
2993  * and then leaks un-reachable Orders in the order pool. */
2994  for (OrderBackup *ob : OrderBackup::Iterate()) {
2995  delete ob;
2996  }
2997 #endif
2998  }
2999 
3001  /* Convert towns growth_rate and grow_counter to ticks */
3002  for (Town *t : Town::Iterate()) {
3003  /* 0x8000 = TOWN_GROWTH_RATE_CUSTOM previously */
3004  if (t->growth_rate & 0x8000) SetBit(t->flags, TOWN_CUSTOM_GROWTH);
3005  if (t->growth_rate != TOWN_GROWTH_RATE_NONE) {
3006  t->growth_rate = TownTicksToGameTicks(t->growth_rate & ~0x8000);
3007  }
3008  /* Add t->index % TOWN_GROWTH_TICKS to spread growth across ticks. */
3009  t->grow_counter = TownTicksToGameTicks(t->grow_counter) + t->index % TOWN_GROWTH_TICKS;
3010  }
3011  }
3012 
3014  /* Make sure added industry cargo slots are cleared */
3015  for (Industry *i : Industry::Iterate()) {
3016  for (size_t ci = 2; ci < lengthof(i->produced_cargo); ci++) {
3017  i->produced_cargo[ci] = CT_INVALID;
3018  i->produced_cargo_waiting[ci] = 0;
3019  i->production_rate[ci] = 0;
3020  i->last_month_production[ci] = 0;
3021  i->last_month_transported[ci] = 0;
3022  i->last_month_pct_transported[ci] = 0;
3023  i->this_month_production[ci] = 0;
3024  i->this_month_transported[ci] = 0;
3025  }
3026  for (size_t ci = 3; ci < lengthof(i->accepts_cargo); ci++) {
3027  i->accepts_cargo[ci] = CT_INVALID;
3028  i->incoming_cargo_waiting[ci] = 0;
3029  }
3030  /* Make sure last_cargo_accepted_at is copied to elements for every valid input cargo.
3031  * The loading routine should put the original singular value into the first array element. */
3032  for (size_t ci = 0; ci < lengthof(i->accepts_cargo); ci++) {
3033  if (i->accepts_cargo[ci] != CT_INVALID) {
3034  i->last_cargo_accepted_at[ci] = i->last_cargo_accepted_at[0];
3035  } else {
3036  i->last_cargo_accepted_at[ci] = 0;
3037  }
3038  }
3039  }
3040  }
3041 
3043  /* Move ships from lock slope to upper or lower position. */
3044  for (Ship *s : Ship::Iterate()) {
3045  /* Suitable tile? */
3046  if (!IsTileType(s->tile, MP_WATER) || !IsLock(s->tile) || GetLockPart(s->tile) != LOCK_PART_MIDDLE) continue;
3047 
3048  /* We don't need to adjust position when at the tile centre */
3049  int x = s->x_pos & 0xF;
3050  int y = s->y_pos & 0xF;
3051  if (x == 8 && y == 8) continue;
3052 
3053  /* Test if ship is on the second half of the tile */
3054  bool second_half;
3055  DiagDirection shipdiagdir = DirToDiagDir(s->direction);
3056  switch (shipdiagdir) {
3057  default: NOT_REACHED();
3058  case DIAGDIR_NE: second_half = x < 8; break;
3059  case DIAGDIR_NW: second_half = y < 8; break;
3060  case DIAGDIR_SW: second_half = x > 8; break;
3061  case DIAGDIR_SE: second_half = y > 8; break;
3062  }
3063 
3064  DiagDirection slopediagdir = GetInclinedSlopeDirection(GetTileSlope(s->tile));
3065 
3066  /* Heading up slope == passed half way */
3067  if ((shipdiagdir == slopediagdir) == second_half) {
3068  /* On top half of lock */
3069  s->z_pos = GetTileMaxZ(s->tile) * (int)TILE_HEIGHT;
3070  } else {
3071  /* On lower half of lock */
3072  s->z_pos = GetTileZ(s->tile) * (int)TILE_HEIGHT;
3073  }
3074  }
3075  }
3076 
3078  /* Ensure the original cargo generation mode is used */
3080  }
3081 
3083  /* Ensure the original neutral industry/station behaviour is used */
3085 
3086  /* Link oil rigs to their industry and back. */
3087  for (Station *st : Station::Iterate()) {
3088  if (IsTileType(st->xy, MP_STATION) && IsOilRig(st->xy)) {
3089  /* Industry tile is always adjacent during construction by TileDiffXY(0, 1) */
3090  st->industry = Industry::GetByTile(st->xy + TileDiffXY(0, 1));
3091  st->industry->neutral_station = st;
3092  }
3093  }
3094  } else {
3095  /* Link neutral station back to industry, as this is not saved. */
3096  for (Industry *ind : Industry::Iterate()) if (ind->neutral_station != nullptr) ind->neutral_station->industry = ind;
3097  }
3098 
3100  /* Update water class for trees. */
3101  for (TileIndex t = 0; t < map_size; t++) {
3103  }
3104  }
3105 
3106  /* Update structures for multitile docks */
3108  for (TileIndex t = 0; t < map_size; t++) {
3109  /* Clear docking tile flag from relevant tiles as it
3110  * was not previously cleared. */
3112  SetDockingTile(t, false);
3113  }
3114  /* Add docks and oilrigs to Station::ship_station. */
3115  if (IsTileType(t, MP_STATION)) {
3116  if (IsDock(t) || IsOilRig(t)) Station::GetByTile(t)->ship_station.Add(t);
3117  }
3118  }
3119 
3120  /* Scan for docking tiles */
3121  for (Station *st : Station::Iterate()) {
3122  if (st->ship_station.tile != INVALID_TILE) UpdateStationDockingTiles(st);
3123  }
3124  }
3125 
3126  /* Compute station catchment areas. This is needed here in case UpdateStationAcceptance is called below. */
3128 
3129  /* Station acceptance is some kind of cache */
3131  for (Station *st : Station::Iterate()) UpdateStationAcceptance(st, false);
3132  }
3133 
3134  /* Road stops is 'only' updating some caches */
3136  AfterLoadLabelMaps();
3139 
3140  GamelogPrintDebug(1);
3141 
3143  /* Restore the signals */
3145 
3147  return true;
3148 }
3149 
3159 {
3160  /* reload grf data */
3161  GfxLoadSprites();
3163  RecomputePrices();
3164  /* reload vehicles */
3165  ResetVehicleHash();
3166  AfterLoadVehicles(false);
3167  StartupEngines();
3169  /* update station graphics */
3170  AfterLoadStations();
3171  /* Update company statistics. */
3173  /* Check and update house and town values */
3175  /* Delete news referring to no longer existing entities */
3177  /* Update livery selection windows */
3179  /* Update company infrastructure counts. */
3181  /* redraw the whole screen */
3184 }
CargoID accepts_cargo[INDUSTRY_NUM_INPUTS]
16 accepted cargoes.
Definition: industrytype.h:120
bool disable_elrails
when true, the elrails are disabled
void SetupColoursAndInitialWindow()
Initialise the default colours (remaps and the likes), and load the main windows. ...
Definition: main_gui.cpp:552
static TileType GetTileType(TileIndex tile)
Get the tiletype of a given tile.
Definition: tile_map.h:96
Owner
Enum for all companies/owners.
Definition: company_type.h:18
static const uint TOWN_GROWTH_WINTER
The town only needs this cargo in the winter (any amount)
Definition: town.h:34
static void UpdateAfterLoad()
Update all caches after loading a game, changing NewGRF, etc.
Definition: group_cmd.cpp:101
Normal operation.
Definition: train.h:38
VehicleSettings vehicle
options for vehicles
void ChangeTileOwner(TileIndex tile, Owner old_owner, Owner new_owner)
Change the owner of a tile.
Definition: landscape.cpp:600
static void Swap(T &a, T &b)
Type safe swap operation.
Definition: math_func.hpp:275
byte type
Type of this airport,.
Definition: station_base.h:309
Source/destination is a town.
Definition: cargo_type.h:148
presignal inter-block
Definition: signal_type.h:27
Vehicle is stopped by the player.
Definition: vehicle_base.h:31
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
141 19799
Definition: saveload.h:211
uint8 max_heightlevel
maximum allowed heightlevel
static void ResetSignalHandlers()
Resets signal handlers back to original handlers.
Definition: afterload.cpp:331
static void ClearBridgeMiddle(TileIndex t)
Removes bridges from the given, that is bridges along the X and Y axis.
Definition: bridge_map.h:103
byte state
Definition: roadveh.h:109
static uint MapSizeX()
Get the size of the map along the X.
Definition: map_func.h:72
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:80
127 17439
Definition: saveload.h:194
106 14919
Definition: saveload.h:169
static void StartNew(CompanyID company, bool rerandomise_ai=true)
Start a new AI company.
Definition: ai_core.cpp:36
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:340
void UpdateNearestTownForRoadTiles(bool invalidate)
Updates cached nearest town for all road tiles.
Definition: road_cmd.cpp:1823
bool _networking
are we in networking mode?
Definition: network.cpp:52
149 20832
Definition: saveload.h:220
Default settings for vehicles.
void CopyTempEngineData()
Copy data from temporary engine array into the real engine pool.
Definition: engine_sl.cpp:118
static TransportType GetTunnelBridgeTransportType(TileIndex t)
Tunnel: Get the transport type of the tunnel (road or rail) Bridge: Get the transport type of the bri...
void UpdateOldAircraft()
need to be called to load aircraft from old version
Definition: vehicle_sl.cpp:162
static void SetAnimationFrame(TileIndex t, byte frame)
Set a new animation frame.
Definition: tile_map.h:262
static uint MapSizeY()
Get the size of the map along the Y.
Definition: map_func.h:82
static bool IsSavegameVersionBefore(SaveLoadVersion major, byte minor=0)
Checks whether the savegame is below major.
Definition: saveload.h:765
Direction direction
facing
Definition: vehicle_base.h:269
Normal tropiczone.
Definition: tile_type.h:70
Non-existing type of vehicle.
Definition: vehicle_type.h:35
void UpdateTownCargoes(Town *t)
Update cargo acceptance for the complete town.
Definition: town_cmd.cpp:835
static void SetTunnelBridgeReservation(TileIndex t, bool b)
Set the reservation state of the rail tunnel/bridge.
Money old_max_loan_unround
Old: Unrounded max loan.
Definition: economy_type.h:31
static byte GetLockPart(TileIndex t)
Get the part of a lock.
Definition: water_map.h:320
static void SetTileOwner(TileIndex tile, Owner owner)
Sets the owner of a tile.
Definition: tile_map.h:198
static const byte TOWN_HOUSE_COMPLETED
Simple value that indicates the house has reached the final stage of construction.
Definition: house.h:23
Flag for an invalid track.
Definition: track_type.h:28
static void FixOwnerOfRailTrack(TileIndex t)
Tries to change owner of this rail tile to a valid owner.
Definition: afterload.cpp:437
static void MakeVoid(TileIndex t)
Make a nice void tile ;)
Definition: void_map.h:19
117 16037
Definition: saveload.h:182
70 10541
Definition: saveload.h:126
Level crossing.
Definition: road_map.h:23
GRFConfig * _grfconfig
First item in list of current GRF set up.
TileArea ship_station
Tile area the ship &#39;station&#39; part covers.
Definition: station_base.h:465
static DiagDirection DirToDiagDir(Direction dir)
Convert a Direction to a DiagDirection.
byte landscape
the landscape we&#39;re currently in
IndustryBuildData _industry_builder
In-game manager of industries.
76 11139
Definition: saveload.h:133
void BuildOwnerLegend()
Completes the array for the owned property legend.
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:375
Yet Another PathFinder.
Definition: vehicle_type.h:61
135 18719
Definition: saveload.h:204
52 9066
Definition: saveload.h:104
An invalid owner.
Definition: company_type.h:29
static bool IsAirportTile(TileIndex t)
Is this tile a station tile and an airport tile?
Definition: station_map.h:167
2.0 0.3.0 2.1 0.3.1, 0.3.2
Definition: saveload.h:33
61 9892
Definition: saveload.h:115
102 14332
Definition: saveload.h:164
All GRF needed by game are present.
Definition: newgrf_config.h:52
Part of an industry.
Definition: tile_type.h:49
Track in the lower corner of the tile (south)
Definition: track_type.h:24
EconomySettings economy
settings to change the economy
Vehicle has finished loading.
Definition: vehicle_base.h:42
void AfterLoadCompanyStats()
Rebuilding of company statistics after loading a savegame.
Definition: company_sl.cpp:94
#define DAYS_TILL_ORIGINAL_BASE_YEAR
The offset in days from the &#39;_date == 0&#39; till &#39;ConvertYMDToDate(ORIGINAL_BASE_YEAR, 0, 1)&#39;.
Definition: date_type.h:80
Compatible (eg. the same ID, but different checksum) GRF found in at least one case.
Definition: newgrf_config.h:53
static bool IsWater(TileIndex t)
Is it a plain water tile?
Definition: water_map.h:141
void NORETURN SlErrorCorrupt(const char *msg)
Error handler for corrupt savegames.
Definition: saveload.cpp:354
Train vehicle type.
Definition: vehicle_type.h:24
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:329
static bool IsBridgeTile(TileIndex t)
checks if there is a bridge on this tile
Definition: bridge_map.h:35
static WaterClass GetWaterClass(TileIndex t)
Get the water class at a tile.
Definition: water_map.h:106
Town * town
Town the object is built in.
Definition: object_base.h:25
RoadTypes
The different roadtypes we support, but then a bitmask of them.
Definition: road_type.h:36
byte units_weight
unit system for weight
Northwest.
void SetWaterClassDependingOnSurroundings(TileIndex t, bool include_invalid_water_class)
Makes a tile canal or water depending on the surroundings.
Definition: afterload.cpp:79
Basic road type.
Definition: road_type.h:24
int CDECL seprintf(char *str, const char *last, const char *format,...)
Safer implementation of snprintf; same as snprintf except:
Definition: string.cpp:407
Random town layout.
Definition: town_type.h:85
98 13375
Definition: saveload.h:159
The vehicle is in a drive-through road stop.
Definition: roadveh.h:47
byte m7
Primarily used for newgrf support.
Definition: map_type.h:35
void CheckTrainsLengths()
Checks if lengths of all rail vehicles are valid.
Definition: train_cmd.cpp:72
uint16 m2
Primarily used for indices to towns, industries and stations.
Definition: map_type.h:20
Used for iterations.
static T SetBit(T &x, const uint8 y)
Set a bit in a variable.
uint16 old_max_loan_unround_fract
Old: Fraction of the unrounded max loan.
Definition: economy_type.h:32
static void MakeShore(TileIndex t)
Helper function to make a coast tile.
Definition: water_map.h:375
87 12129
Definition: saveload.h:146
A tile with road (or tram tracks)
Definition: tile_type.h:43
bool road_use_yapf
use YAPF for road
26 4466
Definition: saveload.h:73
uint32 GetGRFID(uint16 entity_id) const
Gives the GRFID of the file the entity belongs to.
Ship vehicle type.
Definition: vehicle_type.h:26
static const ObjectType OBJECT_STATUE
Statue in towns.
Definition: object_type.h:18
static IndustryGfx GetIndustryGfx(TileIndex t)
Get the industry graphics ID for the given industry tile.
Definition: industry_map.h:137
Maximal number of cargo types in a game.
Definition: cargo_type.h:64
120 16439
Definition: saveload.h:186
Full road along the x-axis (south-west + north-east)
Definition: road_type.h:56
uint64 inflation_prices
Cumulated inflation of prices since game start; 16 bit fractional part.
Definition: economy_type.h:27
210 PR#7234 Company stations can serve industries with attached neutral stations. ...
Definition: saveload.h:295
A town owns the tile, or a town is expanding.
Definition: company_type.h:24
Tile * _m
Tiles of the map.
Definition: map.cpp:30
void NORETURN SlError(StringID string, const char *extra_msg)
Error handler.
Definition: saveload.cpp:326
an airplane
Definition: aircraft.h:32
FileToSaveLoad _file_to_saveload
File to save or load in the openttd loop.
Definition: saveload.cpp:58
RoadTypes GetCompanyRoadTypes(CompanyID company, bool introduces)
Get the road types the given company can build.
Definition: road.cpp:188
Specification of a cargo type.
Definition: cargotype.h:55
static TileIndex GetOtherShipDepotTile(TileIndex t)
Get the other tile of the ship depot.
Definition: water_map.h:272
103 14598
Definition: saveload.h:165
static bool IsRoadStop(TileIndex t)
Is the station at t a road station?
Definition: station_map.h:202
char * CopyFromOldName(StringID id)
Copy and convert old custom names to UTF-8.
Definition: strings_sl.cpp:59
145 20376
Definition: saveload.h:216
16.0 2817 16.1 3155
Definition: saveload.h:59
X-axis track.
Definition: track_type.h:40
Proceed till next signal, but ignore being stuck till then. This includes force leaving depots...
Definition: train.h:39
static TrackBits DiagDirToDiagTrackBits(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal track bits incidating with that diagdir. ...
Definition: track_func.h:532
Aircraft, helicopters, rotors and their shadows belong to this class.
Definition: aircraft.h:74
104 14735
Definition: saveload.h:166
Medium difficulty.
Definition: settings_type.h:28
char * md5sumToString(char *buf, const char *last, const uint8 md5sum[16])
Convert the md5sum to a hexadecimal string representation.
Definition: string.cpp:425
25 4259
Definition: saveload.h:72
Date build_date
Date of construction.
Definition: object_base.h:27
TownLayout
Town Layouts.
Definition: town_type.h:78
121 16694
Definition: saveload.h:187
void ReloadNewGRFData()
Reload all NewGRF files during a running game.
Definition: afterload.cpp:3158
188 26169 v1.4 FS#5831 Unify RV travel time
Definition: saveload.h:267
uint32 changes
Number of changes in this action.
218 PR#7747 Configurable ending year.
Definition: saveload.h:304
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:205
void AfterLoadStoryBook()
Called after load to trash broken pages.
Definition: story_sl.cpp:18
125 17113
Definition: saveload.h:192
113 15340
Definition: saveload.h:177
PathfinderSettings pf
settings for all pathfinders
TileArea train_station
Tile area the train &#39;station&#39; part covers.
Only used when retrieving move data.
Definition: roadveh.h:45
static TileIndex TileAddByDiagDir(TileIndex tile, DiagDirection dir)
Adds a DiagDir to a tile.
Definition: map_func.h:382
Vehicle data structure.
Definition: vehicle_base.h:210
GRFListCompatibility IsGoodGRFConfigList(GRFConfig *grfconfig)
Check if all GRFs in the GRF config from a savegame can be loaded.
void UpdateAllTownVirtCoords()
Update the virtual coords needed to draw the town sign for all towns.
Definition: town_cmd.cpp:415
static bool IsExpected(const BaseStation *st)
Helper for checking whether the given station is of this type.
static void AfterLoad()
Savegame conversion for cargopackets.
StationRect rect
NOSAVE: Station spread out rectangle maintained by StationRect::xxx() functions.
175 24136
Definition: saveload.h:252
byte units_velocity
unit system for velocity
Defines the internal data of a functional industry.
Definition: industry.h:40
DifficultySettings difficulty
settings related to the difficulty
Tindex index
Index of this pool item.
Definition: pool_type.hpp:227
Vehicle is flying in the air.
Definition: airport.h:75
flag for invalid roadtype
Definition: road_type.h:27
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:380
Manual distribution. No link graph calculations are run.
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
42 7573
Definition: saveload.h:92
82 11410
Definition: saveload.h:140
101 14233
Definition: saveload.h:163
119 16242
Definition: saveload.h:184
114 15601
Definition: saveload.h:178
bool forbid_90_deg
forbid trains to make 90 deg turns
Cargo behaves water-like.
Definition: cargotype.h:30
28 4987
Definition: saveload.h:75
DistributionType distribution_default
distribution type for all other goods
Representation of a waypoint.
Definition: waypoint_base.h:16
TownLayout town_layout
select town layout,
static void SetRailStationReservation(TileIndex t, bool b)
Set the reservation state of the rail station.
Definition: station_map.h:405
#define lastof(x)
Get the last element of an fixed size array.
Definition: depend.cpp:48
105 14803
Definition: saveload.h:168
const byte _tunnel_visibility_frame[DIAGDIR_END]
Frame when a vehicle should be hidden in a tunnel with a certain direction.
165 23304
Definition: saveload.h:240
void GamelogPrintDebug(int level)
Prints gamelog to debug output.
Definition: gamelog.cpp:364
A railway.
Definition: tile_type.h:42
uint16 tree_frame_burst
how many trees may, over a short period, be planted?
GRF file was not found in the local cache.
Definition: newgrf_config.h:36
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
initial rating
Definition: town_type.h:44
Loading compatible GRF.
Cargo behaves goods/candy-like.
Definition: cargotype.h:29
void AircraftNextAirportPos_and_Order(Aircraft *v)
set the right pos when heading to other airports after takeoff
void GamelogOldver()
Logs loading from savegame without gamelog.
Definition: gamelog.cpp:464
Contains objects such as transmitters and owned land.
Definition: tile_type.h:51
static uint FixVehicleInclination(Vehicle *v, Direction dir)
Fixes inclination of a vehicle.
Definition: afterload.cpp:495
static void InitializeWindowsAndCaches()
Initialization of the windows and several kinds of caches.
Definition: afterload.cpp:241
void ShowAIDebugWindowIfAIError()
Open the AI debug window if one of the AI scripts has crashed.
Definition: ai_gui.cpp:1558
11.0 2033 11.1 2041
Definition: saveload.h:52
134 18703
Definition: saveload.h:202
static bool IsStandardRoadStopTile(TileIndex t)
Is tile t a standard (non-drive through) road stop station?
Definition: station_map.h:223
GRFIdentifier ident
grfid and md5sum to uniquely identify newgrfs
void GetAircraftFlightLevelBounds(const Vehicle *v, int *min, int *max)
Get the &#39;flight level&#39; bounds, in pixels from &#39;z_pos&#39; 0 for a particular vehicle for normal flight si...
static bool IsLevelCrossing(TileIndex t)
Return whether a tile is a level crossing.
Definition: road_map.h:84
static void SetWaterClass(TileIndex t, WaterClass wc)
Set the water class at a tile.
Definition: water_map.h:118
RoadType
The different roadtypes we support.
Definition: road_type.h:22
byte units_force
unit system for force
static bool IsDriveThroughStopTile(TileIndex t)
Is tile t a drive through road stop station?
Definition: station_map.h:233
bool allow_town_roads
towns are allowed to build roads (always allowed when generating world / in SE)
Town * town
The town this station is associated with.
GRFIdentifier grfcompat
ID and new md5sum of changed GRF.
byte vehstatus
Status.
Definition: vehicle_base.h:315
byte units_height
unit system for height
static bool IsClearGround(TileIndex t, ClearGround ct)
Set the type of clear tile.
Definition: clear_map.h:71
uint32 max_loan
the maximum initial loan
Definition: settings_type.h:57
Year _cur_year
Current year, starting at 0.
Definition: date.cpp:25
uint16 w
The width of the area.
Definition: tilearea_type.h:18
17.0 3212 17.1 3218
Definition: saveload.h:61
bool infrastructure_maintenance
enable monthly maintenance fee for owner infrastructure
137 18912
Definition: saveload.h:206
Basic data to distinguish a GRF.
Definition: newgrf_config.h:82
59 9779
Definition: saveload.h:112
static Train * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
bool IsTileFlat(TileIndex tile, int *h)
Check if a given tile is flat.
Definition: tile_map.cpp:100
uint _gamelog_actions
number of actions
Definition: gamelog.cpp:36
206 PR#7150 Ship/lock movement changes.
Definition: saveload.h:290
CompanySettings settings
settings specific for each company
Definition: company_base.h:127
static void SetRoadTypes(TileIndex t, RoadType road_rt, RoadType tram_rt)
Set the present road types of a tile.
Definition: road_map.h:619
bool AfterLoadGame()
Perform a (large) amount of savegame conversion magic in order to load older savegames and to fill th...
Definition: afterload.cpp:542
static StationType GetStationType(TileIndex t)
Get the station type of this tile.
Definition: station_map.h:44
StationSettings station
settings related to station management
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:13
struct GRFConfig * next
NOSAVE: Next item in the linked list.
Southwest.
Do not refit cargo of a vehicle (used in vehicle orders and auto-replace/auto-new).
Definition: cargo_type.h:67
void UpdateStationAcceptance(Station *st, bool show_msg)
Update the acceptance for a station.
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.
48 8935
Definition: saveload.h:99
96 13226
Definition: saveload.h:157
58 9762
Definition: saveload.h:111
TileIndex GetNorthernBridgeEnd(TileIndex t)
Finds the northern end of a bridge starting at a middle tile.
Definition: bridge_map.cpp:39
15.0 2499
Definition: saveload.h:58
void YapfNotifyTrackLayoutChange(TileIndex tile, Track track)
Use this function to notify YAPF that track layout (or signal configuration) has change.
Definition: yapf_rail.cpp:642
static Station * From(BaseStation *st)
Converts a BaseStation to SpecializedStation with type checking.
24 4150
Definition: saveload.h:70
57 9691
Definition: saveload.h:110
byte m1
Primarily used for ownership information.
Definition: map_type.h:21
static bool IsLock(TileIndex t)
Is there a lock on a given water tile?
Definition: water_map.h:297
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:55
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:21
int GetTileZ(TileIndex tile)
Get bottom height of the tile.
Definition: tile_map.cpp:121
Normal road.
Definition: road_map.h:22
72 10601
Definition: saveload.h:128
21 3472 0.4.x
Definition: saveload.h:67
int32 _old_ending_year_slv_105
Old ending year for savegames before SLV_105.
Definition: date.cpp:31
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
std::vector< TileIndex > _animated_tiles
The table/list with animated tiles.
bool freeform_edges
allow terraforming the tiles at the map edges
Invalid cargo type.
Definition: cargo_type.h:68
Plain water.
Definition: water_map.h:40
static bool IsHouseCompleted(TileIndex t)
Get the completion of this house.
Definition: town_map.h:145
177 24619
Definition: saveload.h:254
Stop at the far end of the platform.
Definition: order_type.h:86
Slope GetTileSlope(TileIndex tile, int *h)
Return the slope of a given tile inside the map.
Definition: tile_map.cpp:59
static const size_t MAX_SIZE
Make template parameter accessible from outside.
Definition: pool_type.hpp:85
old or new scenario
Definition: fileio_type.h:19
122 16855
Definition: saveload.h:188
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:264
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:3337
bool reverse_at_signals
whether to reverse at signals at all
Buses, trucks and trams belong to this class.
Definition: roadveh.h:107
Fake town GrfSpecFeature for NewGRF debugging (parent scope)
Definition: newgrf.h:89
Critical errors, the MessageBox is shown in all cases.
Definition: error.h:24
RoadType roadtype
Roadtype of this vehicle.
Definition: roadveh.h:117
static bool IsTileOwner(TileIndex tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition: tile_map.h:214
void UpdateAirportsNoise()
Recalculate the noise generated by the airports of each town.
Shared order list linking together the linked list of orders and the list of vehicles sharing this or...
Definition: order_base.h:250
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:3534
static void SetCrossingReservation(TileIndex t, bool b)
Set the reservation state of the rail crossing.
Definition: road_map.h:393
void SetDate(Date date, DateFract fract)
Set the date.
Definition: date.cpp:38
static void MakeSea(TileIndex t)
Make a sea tile.
Definition: water_map.h:414
Vehicle is crashed.
Definition: vehicle_base.h:37
88 12134
Definition: saveload.h:147
Electric rails.
Definition: rail_type.h:30
The tile has no ownership.
Definition: company_type.h:25
static TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition: map_func.h:341
DistributionType distribution_mail
distribution type for mail
static bool IsBuoy(TileIndex t)
Is tile t a buoy tile?
Definition: station_map.h:306
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
void MakeDefaultName(T *obj)
Set the default name for a depot/waypoint.
Definition: town.h:249
Southeast.
static bool _saveload_crash_with_missing_newgrfs
Was the saveload crash because of missing NewGRFs?
Definition: afterload.cpp:357
The vehicle is in a road stop.
Definition: roadveh.h:46
94 12816
Definition: saveload.h:154
void SetNonStopType(OrderNonStopFlags non_stop_type)
Set whether we must stop at stations or not.
Definition: order_base.h:152
The y axis.
static bool IsCoast(TileIndex t)
Is it a coast tile?
Definition: water_map.h:195
RoadStop * truck_stops
All the truck stops.
Definition: station_base.h:461
Contains information about one logged action that caused at least one logged change.
This indicates whether a cargo has a rating at the station.
Definition: station_base.h:187
void Add(TileIndex to_add)
Add a single tile to a tile area; enlarge if needed.
Definition: tilearea.cpp:43
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
43 7642
Definition: saveload.h:93
DateFract _date_fract
Fractional part of the day.
Definition: date.cpp:28
bool serve_neutral_industries
company stations can serve industries with attached neutral stations
void UpdateAircraftCache(Aircraft *v, bool update_range=false)
Update cached values of an aircraft.
A normal unpaused game.
Definition: openttd.h:56
CompanySettings company
default values for per-company settings
Information about GRF, used in the game and (part of it) in savegames.
Original algorithm (quadratic cargo by population)
Definition: town_type.h:103
YAPFSettings yapf
pathfinder settings for the yet another pathfinder
62 9905
Definition: saveload.h:116
static void SetStationGfx(TileIndex t, StationGfx gfx)
Set the station graphics of this tile.
Definition: station_map.h:80
38 7195
Definition: saveload.h:87
byte road_side
the side of the road vehicles drive on
WaterClass
classes of water (for WATER_TILE_CLEAR water tile type).
Definition: water_map.h:47
static bool IsTruckStop(TileIndex t)
Is the station at t a truck stop?
Definition: station_map.h:180
void MoveBuoysToWaypoints()
Perform all steps to upgrade from the old station buoys to the new version that uses waypoints...
Definition: station_sl.cpp:40
static bool HasTownOwnedRoad(TileIndex t)
Checks if given tile has town owned road.
Definition: road_map.h:279
34 6455
Definition: saveload.h:82
Do not load anything.
Definition: order_type.h:66
byte units_volume
unit system for volume
static TownID GetTownIndex(TileIndex t)
Get the index of which town this house/street is attached to.
Definition: town_map.h:22
194 26881 v1.5
Definition: saveload.h:275
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition: order_base.h:61
The vehicle is in a tunnel and/or bridge.
Definition: roadveh.h:40
static Owner GetTileOwner(TileIndex tile)
Returns the owner of a tile.
Definition: tile_map.h:178
Southeast.
static DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
void UpdateAllVirtCoords()
Update the viewport coordinates of all signs.
Definition: afterload.cpp:217
T * Next() const
Get next vehicle in the chain.
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:79
Standard non-electric rails.
Definition: rail_type.h:29
byte snow_line_height
the configured snow line height
143 20048
Definition: saveload.h:213
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
const IndustrySpec * GetIndustrySpec(IndustryType thistype)
Accessor for array _industry_specs.
void DeleteAnimatedTile(TileIndex tile)
Removes the given tile from the animated tile table.
void LoadStringWidthTable(bool monospace)
Initialize _stringwidth_table cache.
Definition: gfx.cpp:1271
111 15190
Definition: saveload.h:175
static const int GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET
The offset for the drive through parts.
Definition: station_map.h:36
#define TILE_ADDXY(tile, x, y)
Adds a given offset to a tile.
Definition: map_func.h:258
Trams.
Definition: road_type.h:25
IndustryType GetIndustryType(TileIndex tile)
Retrieve the type for this industry.
Game loaded.
Definition: gamelog.h:18
202 PR#6867 Increase industry cargo slots to 16 in, 16 out
Definition: saveload.h:285
Direction
Defines the 8 directions on the map.
Water tile.
Definition: tile_type.h:47
TileExtended * _me
Extended Tiles of the map.
Definition: map.cpp:31
static uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
Definition: math_func.hpp:314
bool dynamic_engines
enable dynamic allocation of engine data
Station * GetTargetAirportIfValid(const Aircraft *v)
Returns aircraft&#39;s target station if v->target_airport is a valid station with airport.
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
byte m5
General purpose.
Definition: map_type.h:24
RoadBits
Enumeration for the road parts on a tile.
Definition: road_type.h:50
158 21933
Definition: saveload.h:231
An object, such as transmitter, on the map.
Definition: object_base.h:23
The vehicle is in a depot.
Definition: roadveh.h:39
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
static bool IsBuoyTile(TileIndex t)
Is tile t a buoy tile?
Definition: station_map.h:316
TrackBits
Bitfield corresponding to Track.
Definition: track_type.h:38
const CargoSpec * FindFirstCargoWithTownEffect(TownEffect effect)
Determines the first cargo with a certain town effect.
Definition: town_cmd.cpp:2716
Extended original algorithm (min. 2 distance between roads)
Definition: town_type.h:81
void GamelogGRFAddList(const GRFConfig *newg)
Logs adding of list of GRFs.
Definition: gamelog.cpp:676
static void SetSignalStates(TileIndex tile, uint state)
Set the states of the signals (Along/AgainstTrackDir)
Definition: rail_map.h:352
Company colour selection; Window numbers:
Definition: window_type.h:223
uint16 max_bridge_length
maximum length of bridges
bool IsFrontEngine() const
Check if the vehicle is a front engine.
Definition: vehicle_base.h:881
static WaterTileType GetWaterTileType(TileIndex t)
Get the water tile type at a tile.
Definition: water_map.h:77
TileIndex tile
Current tile index.
Definition: vehicle_base.h:228
Defines the data structure for constructing industry.
Definition: industrytype.h:106
CompanyManagerFace ConvertFromOldCompanyManagerFace(uint32 face)
Converts an old company manager&#39;s face format to the new company manager&#39;s face format.
Definition: company_sl.cpp:43
New PathFinder.
Definition: vehicle_type.h:60
Grass with a fence and shore or water on the free halftile.
Definition: rail_map.h:499
void SetSaveLoadError(StringID str)
Set the error message from outside of the actual loading/saving of the game (AfterLoadGame and friend...
Definition: saveload.cpp:2434
static void SetHouseCompleted(TileIndex t, bool status)
Mark this house as been completed.
Definition: town_map.h:156
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:1938
static Trackdir DiagDirToDiagTrackdir(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal trackdir that runs in that direction.
Definition: track_func.h:545
A game normally paused.
Definition: openttd.h:57
const byte _road_stop_stop_frame[]
Table of road stop stop frames, when to stop at a road stop.
void UpdateAllSignVirtCoords()
Update the coordinates of all signs.
Definition: signs.cpp:60
void GamelogGRFCompatible(const GRFIdentifier *newg)
Logs loading compatible GRF (the same ID, but different MD5 hash)
Definition: gamelog.cpp:630
void AfterLoadLinkGraphs()
Spawn the threads for running link graph calculations.
146 20446
Definition: saveload.h:217
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:271
uint16 clear_frame_burst
how many tiles may, over a short period, be cleared?
#define lengthof(x)
Return the length of an fixed size array.
Definition: depend.cpp:40
84 11822
Definition: saveload.h:142
Company * DoStartupNewCompany(bool is_ai, CompanyID company=INVALID_COMPANY)
Create a new company and sets all company variables default values.
IndustryBehaviour behaviour
How this industry will behave, and how others entities can use it.
Definition: industrytype.h:124
static uint TileHash(uint x, uint y)
Calculate a hash value from a tile position.
Definition: tile_map.h:316
void UpdateHousesAndTowns()
Check and update town and house values.
Definition: town_sl.cpp:64
static T min(const T a, const T b)
Returns the minimum of two values.
Definition: math_func.hpp:40
void GamelogTestRevision()
Finds out if current revision is different than last revision stored in the savegame.
Definition: gamelog.cpp:498
static bool IsShipDepotTile(TileIndex t)
Is it a ship depot tile?
Definition: water_map.h:226
Helper class to perform the cargo payment.
Definition: economy_base.h:24
PauseMode _pause_mode
The current pause mode.
Definition: gfx.cpp:47
uint16 ObjectType
Types of objects.
Definition: object_type.h:14
183 25363 Cargodist
Definition: saveload.h:261
uint8 plane_speed
divisor for speed of aircraft
static DiagDirection GetInclinedSlopeDirection(Slope s)
Returns the direction of an inclined slope.
Definition: slope_func.h:239
53 9316
Definition: saveload.h:105
static void SetBridgeMiddle(TileIndex t, Axis a)
Set that there is a bridge over the given axis.
Definition: bridge_map.h:114
static const Year ORIGINAL_BASE_YEAR
The minimum starting year/base year of the original TTD.
Definition: date_type.h:49
static DiagDirection GetTunnelBridgeDirection(TileIndex t)
Get the direction pointing to the other end.
static bool IsPlainRailTile(TileIndex t)
Checks whether the tile is a rail tile or rail tile with signals.
Definition: rail_map.h:60
byte number_towns
the amount of towns
Definition: settings_type.h:55
Vehicle is currently going uphill. (Cached track information for acceleration)
a desert or snow tile, depend on landscape
Definition: tree_map.h:55
Vehicle&#39;s pathfinder is lost.
Definition: vehicle_base.h:49
6.0 1721 6.1 1768
Definition: saveload.h:45
123 16909
Definition: saveload.h:189
static void RecomputeCatchmentForAll()
Recomputes catchment of all stations.
Definition: station.cpp:476
148 20659
Definition: saveload.h:219
83 11589
Definition: saveload.h:141
164 23290
Definition: saveload.h:238
static StationGfx GetStationGfx(TileIndex t)
Get the station graphics of this tile.
Definition: station_map.h:68
void UpdateLevelCrossing(TileIndex tile, bool sound=true)
Sets correct crossing state.
Definition: train_cmd.cpp:1672
Bitflag for a wormhole (used for tunnels)
Definition: track_type.h:55
uint8 plane_crashes
number of plane crashes, 0 = none, 1 = reduced, 2 = normal
All ships have this type.
Definition: ship.h:26
124 16993
Definition: saveload.h:190
RoadStop * bus_stops
All the road stops.
Definition: station_base.h:459
Transfer all cargo onto the platform.
Definition: order_type.h:55
DistributionType distribution_armoured
distribution type for armoured cargo class
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition: landscape.cpp:589
static void SetRoadOwner(TileIndex t, RoadTramType rtt, Owner o)
Set the owner of a specific road type.
Definition: road_map.h:250
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:137
static bool HasSignals(TileIndex t)
Checks if a rail tile has signals.
Definition: rail_map.h:72
91 12347
Definition: saveload.h:151
Flag for an invalid direction.
ScriptSettings script
settings for scripts
void MoveWaypointsToBaseStations()
Perform all steps to upgrade from the old waypoints to the new version that uses station.
Definition: waypoint_sl.cpp:66
#define DEBUG(name, level,...)
Output a line of debugging information.
Definition: debug.h:35
Struct about subsidies, offered and awarded.
Definition: subsidy_base.h:22
&#39;Train&#39; is either a loco or a wagon.
Definition: train.h:85
LoggedAction * _gamelog_action
first logged action
Definition: gamelog.cpp:35
Water lock.
Definition: water_map.h:42
End of setting profiles.
Definition: settings_type.h:31
byte units_power
unit system for power
1.0 0.1.x, 0.2.x
Definition: saveload.h:32
static RoadBits GetCrossingRoadBits(TileIndex tile)
Get the road bits of a level crossing.
Definition: road_map.h:348
TileIndex tile
The base tile of the area.
Definition: tilearea_type.h:17
static uint GetClearDensity(TileIndex t)
Get the density of a non-field clear tile.
Definition: clear_map.h:83
void StartupEngines()
Start/initialise all our engines.
Definition: engine.cpp:693
void ResetOldNames()
Free the memory of the old names array.
Definition: strings_sl.cpp:107
159 21962
Definition: saveload.h:232
uint8 train_slope_steepness
Steepness of hills for trains when using realistic acceleration.
void ShowNewGRFError()
Show the first NewGRF error we can find.
Definition: newgrf_gui.cpp:44
void UpdateAllStationVirtCoords()
Update the virtual coords needed to draw the station sign for all stations.
The X axis.
static Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
Cargo behaves passenger-like.
Definition: cargotype.h:27
Town * CalcClosestTownFromTile(TileIndex tile, uint threshold=UINT_MAX)
Return the town closest to the given tile within threshold.
Definition: town_cmd.cpp:3516
153 21263
Definition: saveload.h:225
static TileIndex GetOtherTunnelBridgeEnd(TileIndex t)
Determines type of the wormhole and returns its other end.
byte StationGfx
Copy from station_map.h.
Transport by train.
Company infrastructure overview; Window numbers:
Definition: window_type.h:570
Station with an airport.
Definition: station_type.h:55
Cargo behaves mail-like.
Definition: cargotype.h:28
static BaseStation * GetByTile(TileIndex tile)
Get the base station belonging to a specific tile.
static const uint TOWN_GROWTH_DESERT
The town needs the cargo for growth when on desert (any amount)
Definition: town.h:35
The tile/execution is done by "water".
Definition: company_type.h:26
static const uint MIN_SNOWLINE_HEIGHT
Minimum snowline height.
Definition: tile_type.h:28
112 15290
Definition: saveload.h:176
9.0 1909
Definition: saveload.h:49
void ConnectMultiheadedTrains()
Link front and rear multiheaded engines to each other This is done when loading a savegame...
Definition: vehicle_sl.cpp:32
Station with a dock.
Definition: station_type.h:56
static TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
Definition: map_func.h:194
Vehicle is currently going downhill. (Cached track information for acceleration)
An invalid company.
Definition: company_type.h:30
Tile got trees.
Definition: tile_type.h:45
No track.
Definition: track_type.h:39
160 21974 1.1.x
Definition: saveload.h:234
static uint MapSize()
Get the size of the map.
Definition: map_func.h:92
TownEffect town_effect
The effect that delivering this cargo type has on towns. Also affects destination of subsidies...
Definition: cargotype.h:66
StationType
Station types.
Definition: station_type.h:32
GamelogActionType at
Type of action.
static Owner GetRoadOwner(TileIndex t, RoadTramType rtt)
Get the owner of a specific road type.
Definition: road_map.h:233
void SetAircraftPosition(Aircraft *v, int x, int y, int z)
Set aircraft position.
static T ClrBit(T &x, const uint8 y)
Clears a bit in a variable.
RailType
Enumeration for all possible railtypes.
Definition: rail_type.h:27
static RoadTileType GetRoadTileType(TileIndex t)
Get the type of the road tile.
Definition: road_map.h:51
139 19346
Definition: saveload.h:208
static bool IsRailDepot(TileIndex t)
Is this rail tile a rail depot?
Definition: rail_map.h:95
bool IsStationTileBlocked(TileIndex tile)
Check whether a rail station tile is NOT traversable.
Tunnel entry/exit and bridge heads.
Definition: tile_type.h:50
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:378
186 25833 Objects storage
Definition: saveload.h:265
56 9667
Definition: saveload.h:109
144 20334
Definition: saveload.h:214
is built on water (oil rig)
Definition: industrytype.h:65
DistributionType distribution_pax
distribution type for passengers
static bool IsRailDepotTile(TileIndex t)
Is this tile rail tile and a rail depot?
Definition: rail_map.h:105
Invisible tiles at the SW and SE border.
Definition: tile_type.h:48
bool station_noise_level
build new airports when the town noise level is still within accepted limits
static DiagDirection XYNSToDiagDir(Axis xy, uint ns)
Convert an axis and a flag for north/south into a DiagDirection.
void RecomputePrices()
Computes all prices, payments and maximum loan.
Definition: economy.cpp:746
int GetTileMaxZ(TileIndex t)
Get top height of the tile inside the map.
Definition: tile_map.cpp:141
static void SetLiftPosition(TileIndex t, byte pos)
Set the position of the lift on this animated house.
Definition: town_map.h:135
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo ID.
Definition: cargotype.h:117
static bool IsShipDepot(TileIndex t)
Is it a water tile with a ship depot on it?
Definition: water_map.h:216
Oilrig airport.
Definition: airport.h:38
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:78
Used for iterations.
Middle part of a lock.
Definition: water_map.h:65
void FixupTrainLengths()
Fixup old train spacing.
Definition: vehicle_sl.cpp:483
190 26547 Separate order travel and wait times
Definition: saveload.h:270
GRFListCompatibility
Status of post-gameload GRF compatibility check.
Definition: newgrf_config.h:51
static size_t GetNumItems()
Returns number of valid items in the pool.
Definition: pool_type.hpp:359
147 20621
Definition: saveload.h:218
static const uint64 MAX_INFLATION
Maximum inflation (including fractional part) without causing overflows in int64 price computations...
Definition: economy_type.h:199
static void IncTypeCount(ObjectType type)
Increment the count of objects for this type.
Definition: object_base.h:43
First company, same as owner.
Definition: company_type.h:22
bool ship_use_yapf
use YAPF for ships
Information about a aircraft vehicle.
Definition: engine_type.h:97
static TreeGround GetTreeGround(TileIndex t)
Returns the groundtype for tree tiles.
Definition: tree_map.h:88
bool modified_catchment
different-size catchment areas
At least one GRF couldn&#39;t be found (higher priority than GLC_COMPATIBLE)
Definition: newgrf_config.h:54
CargoPayment * cargo_payment
The cargo payment we&#39;re currently in.
Definition: vehicle_base.h:241
LoggedChange * change
First logged change in this action.
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
static bool IsLevelCrossingTile(TileIndex t)
Return whether a tile is a level crossing tile.
Definition: road_map.h:94
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:215
Only set when a vehicle has entered the stop.
Definition: roadveh.h:44
static Direction AxisToDirection(Axis a)
Converts an Axis to a Direction.
void AfterLoadRoadStops()
(Re)building of road stop caches after loading a savegame.
Definition: station_sl.cpp:129
static void MakeClear(TileIndex t, ClearGround g, uint density)
Make a clear tile.
Definition: clear_map.h:259
Contains information about one logged change.
uint8 pathfinder_for_trains
the pathfinder to use for trains
uint16 terraform_frame_burst
how many tile heights may, over a short period, be terraformed?
Old-fashioned semaphore signal.
Definition: signal_type.h:18
138 18942 1.0.x
Definition: saveload.h:207
byte height
The height of the northern corner.
Definition: map_type.h:19
208 PR#6965 New algorithms for town building cargo generation.
Definition: saveload.h:292
TileArea location
Location of the object.
Definition: object_base.h:26
void RebuildSubsidisedSourceAndDestinationCache()
Perform a full rebuild of the subsidies cache.
Definition: subsidy.cpp:131
TransportType
Available types of transport.
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
byte wait_twoway_signal
waitingtime in days before a twoway signal
93 12648
Definition: saveload.h:153
static ClearGround GetRawClearGround(TileIndex t)
Get the type of clear tile but never return CLEAR_SNOW.
Definition: clear_map.h:47
static bool IsOilRig(TileIndex t)
Is tile t part of an oilrig?
Definition: station_map.h:274
ObjectType type
Type of the object.
Definition: object_base.h:24
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:52
static void SetTileType(TileIndex tile, TileType type)
Set the type of a tile.
Definition: tile_map.h:131
void AfterLoadVehicles(bool part_of_load)
Called after load to update coordinates.
Definition: vehicle_sl.cpp:240
Growth rate is controlled by GS.
Definition: town.h:191
A tile of a station.
Definition: tile_type.h:46
0-3
Definition: clear_map.h:24
const TileTypeProcs *const _tile_type_procs[16]
Tile callback functions for each type of tile.
Definition: landscape.cpp:60
VehicleDefaultSettings _old_vds
Used for loading default vehicles settings from old savegames.
Definition: settings.cpp:82
uint8 larger_towns
the number of cities to build. These start off larger and grow twice as fast
static const HouseID NEW_HOUSE_OFFSET
Offset for new houses.
Definition: house.h:28
Maximum number of companies.
Definition: company_type.h:23
static uint MapMaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
Definition: map_func.h:111
Town data structure.
Definition: town.h:53
static Station * GetByTile(TileIndex tile)
Get the station belonging to a specific tile.
static TrackBits TrackStatusToTrackBits(TrackStatus ts)
Returns the present-track-information of a TrackStatus.
Definition: track_func.h:371
Northwest.
static void MakeCanal(TileIndex t, Owner o, uint8 random_bits)
Make a canal tile.
Definition: water_map.h:435
uint64 inflation_payment
Cumulated inflation of cargo paypent since game start; 16 bit fractional part.
Definition: economy_type.h:28
50 8973
Definition: saveload.h:102
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
Transport by road vehicle.
static const uint16 TOWN_GROWTH_RATE_NONE
Special value for Town::growth_rate to disable town growth.
Definition: town.h:36
The vehicle will not stop at any stations it passes except the destination.
Definition: order_type.h:74
static const uint TILE_UNIT_MASK
For masking in/out the inner-tile world coordinate units.
Definition: tile_type.h:14
LocaleSettings locale
settings related to used currency/unit system in the current game
The vehicle is in a road stop.
Definition: roadveh.h:50
184 25508 Unit localisation split
Definition: saveload.h:262
Vehicle is not visible.
Definition: vehicle_base.h:30
byte town_name
the town name generator used for town names
198 PR#6763 Switch town growth rate and counter to actual game ticks
Definition: saveload.h:280
Pause mode bits when paused for network reasons.
Definition: openttd.h:65
bool _network_server
network-server is active
Definition: network.cpp:53
214 PR#6811 NewGRF road types.
Definition: saveload.h:299
A Stop for a Road Vehicle.
Definition: roadstop_base.h:22
void GamelogGRFRemove(uint32 grfid)
Logs removal of a GRF.
Definition: gamelog.cpp:599
Northeast.
49 8969
Definition: saveload.h:100
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:45
Owner owner
The owner of this station.
void InitializeRailGUI()
Resets the rail GUI - sets default railtype to build and resets the signal GUI.
Definition: rail_gui.cpp:1979
TownCargoGenMode town_cargogen_mode
algorithm for generating cargo from houses,
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:318
static uint TileHeight(TileIndex tile)
Returns the height of a tile.
Definition: tile_map.h:29
AbstractFileType abstract_ftype
Abstract type of file (scenario, heightmap, etc).
Definition: saveload.h:320
uint8 train_acceleration_model
realistic acceleration for trains
Fields are planted around when built (all farms)
Definition: industrytype.h:69
Cargo behaves food/fizzy-drinks-like.
Definition: cargotype.h:31
ConstructionSettings construction
construction of things in-game
static const Year MIN_YEAR
The absolute minimum & maximum years in OTTD.
Definition: date_type.h:83
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Definition: strings_type.h:17
static TileIndexDiff TileDiffXY(int x, int y)
Calculates an offset for the given coordinate(-offset).
Definition: map_func.h:179
static Pool::IterateWrapper< RoadVehicle > Iterate(size_t from=0)
Returns an iterable ensemble of all valid vehicles of type T.
192 26700 FS#6066 Fix saving of order backups
Definition: saveload.h:273
uint32 grfid
GRF ID (defined by Action 0x08)
Definition: newgrf_config.h:83
156 21728
Definition: saveload.h:229
static bool IsTunnelTile(TileIndex t)
Is this a tunnel (entrance)?
Definition: tunnel_map.h:33
Airport airport
Tile area the airport covers.
Definition: station_base.h:464
uint8 roadveh_acceleration_model
realistic acceleration for road vehicles
140 19382
Definition: saveload.h:210
69 10319
Definition: saveload.h:124
uint8 settings_profile
difficulty profile to set initial settings of scripts, esp. random AIs
32 6001
Definition: saveload.h:80
int32 x_pos
x coordinate.
Definition: vehicle_base.h:266
45 8501
Definition: saveload.h:96
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
void Restore()
Restore the variable.
DiagDirection
Enumeration for diagonal directions.
Light signal.
Definition: signal_type.h:17
static const TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:83
ZoomLevel
All zoom levels we know.
Definition: zoom_type.h:19
78 11176
Definition: saveload.h:135
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:531
bool AddInflation(bool check_year)
Add monthly inflation.
Definition: economy.cpp:708
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
178 24789
Definition: saveload.h:255
Northeast, upper right on your monitor.
GRF file does not exactly match the requested GRF (different MD5SUM), but grfid matches) ...
Definition: newgrf_config.h:25
216 PR#7380 Multiple docks per station.
Definition: saveload.h:302
GameCreationSettings game_creation
settings used during the creation of a game (map)
static bool IsPlainRail(TileIndex t)
Returns whether this is plain rails, with or without signals.
Definition: rail_map.h:49
A tile without any structures, i.e. grass, rocks, farm fields etc.
Definition: tile_type.h:41
void GamelogTestMode()
Finds last stored game mode or landscape.
Definition: gamelog.cpp:521
142 20003
Definition: saveload.h:212
99 13838
Definition: saveload.h:160
A house by a town.
Definition: tile_type.h:44
Full road along the y-axis (north-west + south-east)
Definition: road_type.h:57
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
182 25115 FS#5492, r25259, r25296 Goal status
Definition: saveload.h:260
uint8 roadveh_slope_steepness
Steepness of hills for road vehicles when using realistic acceleration.
int32 y_pos
y coordinate.
Definition: vehicle_base.h:267
74 11030
Definition: saveload.h:130
static const Year DEF_END_YEAR
The default scoring end year.
Definition: date_type.h:88
static uint MapMaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition: map_func.h:102
TreeGround
Enumeration for ground types of tiles with trees.
Definition: tree_map.h:52
136 18764
Definition: saveload.h:205
152 21171
Definition: saveload.h:224
static Industry * GetByTile(TileIndex tile)
Get the industry of the given tile.
Definition: industry.h:114
Road vehicle is a tram/light rail vehicle.
Definition: engine_type.h:154
161 22567
Definition: saveload.h:235
byte wait_for_pbs_path
how long to wait for a path reservation.
RailTypes GetCompanyRailtypes(CompanyID company, bool introduces)
Get the rail types the given company can build.
Definition: rail.cpp:251
128 18281
Definition: saveload.h:195
95 12924
Definition: saveload.h:156
static uint32 BSWAP32(uint32 x)
Perform a 32 bits endianness bitswap on x.
void ResetWindowSystem()
Reset the windowing system, by means of shutting it down followed by re-initialization.
Definition: window.cpp:1937
static bool IsDepotTile(TileIndex tile)
Is the given tile a tile with a depot on it?
Definition: depot_map.h:41
Station with train station.
Definition: station_type.h:52
bool SaveloadCrashWithMissingNewGRFs()
Did loading the savegame cause a crash? If so, were NewGRFs missing?
Definition: afterload.cpp:364
uint8 md5sum[16]
MD5 checksum of file to distinguish files with the same GRF ID (eg. newer version of GRF) ...
Definition: newgrf_config.h:84
void DeleteInvalidEngineNews()
Remove engine announcements for invalid engines.
Definition: news_gui.cpp:949
Force unloading all cargo onto the platform, possibly not getting paid.
Definition: order_type.h:54
byte industry_density
The industry density.
Definition: settings_type.h:56
uint8 pathfinder_for_ships
the pathfinder to use for ships
bool rail_use_yapf
use YAPF for rail
static void SetTrackReservation(TileIndex t, TrackBits b)
Sets the reserved track bits of the tile.
Definition: rail_map.h:209
126 17433
Definition: saveload.h:193
213 PR#7405 WaterClass update for tree tiles.
Definition: saveload.h:298
36 6624
Definition: saveload.h:85
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
172 23947
Definition: saveload.h:248
static void SetTownIndex(TileIndex t, TownID index)
Set the town index for a road or house tile.
Definition: town_map.h:34
31 5999
Definition: saveload.h:79
static bool IsDock(TileIndex t)
Is tile t a dock tile?
Definition: station_map.h:285
static Station * Get(size_t index)
Gets station with given index.
133 18674
Definition: saveload.h:201
Date _date
Current date in days (day counter)
Definition: date.cpp:27
void ResetCompanyLivery(Company *c)
Reset the livery schemes to the company&#39;s primary colour.
200 PR#6805 Extend railtypes to 64, adding uint16 to map array.
Definition: saveload.h:283
81 11244
Definition: saveload.h:139
uint16 h
The height of the area.
Definition: tilearea_type.h:19
static Direction ReverseDir(Direction d)
Return the reverse of a direction.
byte wait_oneway_signal
waitingtime in days before a oneway signal
static void SetDockingTile(TileIndex t, bool b)
Set the docking tile state of a tile.
Definition: water_map.h:355
64 10006
Definition: saveload.h:118
46 8705
Definition: saveload.h:97
bool allow_town_level_crossings
towns are allowed to build level crossings
byte m3
General purpose.
Definition: map_type.h:22
100 13952
Definition: saveload.h:162
Declaration of functions used in more save/load files.
27 4757
Definition: saveload.h:74
Depot (one entrance)
Definition: road_map.h:24
uint8 feeder_payment_share
percentage of leg payment to virtually pay in feeder systems
Y-axis track.
Definition: track_type.h:41
Valid changes while vehicle is driving, and possibly changing tracks.
Definition: train.h:48
Base class for all station-ish types.
Station data structure.
Definition: station_base.h:450
Axis
Allow incrementing of DiagDirDiff variables.
static const GRFIdentifier * GetOverriddenIdentifier(const GRFConfig *c)
Try to find the overridden GRF identifier of the given GRF.
Definition: afterload.cpp:343
static bool IsRoadDepot(TileIndex t)
Return whether a tile is a road depot.
Definition: road_map.h:105
static const ObjectType OBJECT_HQ
HeadQuarter of a player.
Definition: object_type.h:20
LinkGraphSettings linkgraph
settings for link graph calculations
Used for industry tiles on land (also for oilrig if newgrf says so).
Definition: water_map.h:51
Road vehicle type.
Definition: vehicle_type.h:25
A game paused because a (critical) error.
Definition: openttd.h:60
static TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition: map_func.h:163
131 18481
Definition: saveload.h:199
static RailType GetRailType(TileIndex t)
Gets the rail type of the given tile.
Definition: rail_map.h:115
Order current_order
The current order (+ status, like: loading)
Definition: vehicle_base.h:316
static bool IsBridge(TileIndex t)
Checks if this is a bridge, instead of a tunnel.
Definition: bridge_map.h:24
static Direction DiagDirToDir(DiagDirection dir)
Convert a DiagDirection to a Direction.
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:3319
static void SetTropicZone(TileIndex tile, TropicZone type)
Set the tropic zone.
Definition: tile_map.h:225
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:36
Track in the upper corner of the tile (north)
Definition: track_type.h:23
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition: gfx.cpp:1600
Source/destination is an industry.
Definition: cargo_type.h:147
static void SetSignalHandlers()
Replaces signal handlers of SIGSEGV and SIGABRT and stores pointers to original handlers in memory...
Definition: afterload.cpp:321
static void SetRailType(TileIndex t, RailType r)
Sets the rail type of the given tile.
Definition: rail_map.h:125
Southwest.
166 23415
Definition: saveload.h:241
90 12293
Definition: saveload.h:150
void GfxLoadSprites()
Initialise and load all the sprites.
Definition: gfxinit.cpp:338
86 12042
Definition: saveload.h:145
uint16 max_tunnel_length
maximum length of tunnels
void Reset()
Completely reset the industry build data.
uint8 pathfinder_for_roadvehs
the pathfinder to use for roadvehicles
byte currency
currency we currently use
bool SettingsDisableElrail(int32 p1)
_settings_game.disable_elrail callback
Definition: elrail.cpp:592
uint8 max_train_length
maximum length for trains
Year ending_year
scoring end date
static void SetDepotReservation(TileIndex t, bool b)
Set the reservation state of the depot.
Definition: rail_map.h:270
byte m4
General purpose.
Definition: map_type.h:23
static Station * GetIfValid(size_t index)
Returns station if the index is a valid index for this station type.