OpenTTD Source  20241108-master-g80f628063a
station_sl.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 
12 #include "saveload.h"
14 
15 #include "../station_base.h"
16 #include "../waypoint_base.h"
17 #include "../roadstop_base.h"
18 #include "../vehicle_base.h"
19 #include "../newgrf_station.h"
20 #include "../newgrf_roadstop.h"
21 #include "../timer/timer_game_calendar.h"
22 
23 #include "table/strings.h"
24 
25 #include "../safeguards.h"
26 
31 static void UpdateWaypointOrder(Order *o)
32 {
33  if (!o->IsType(OT_GOTO_STATION)) return;
34 
35  const Station *st = Station::Get(o->GetDestination());
36  if ((st->had_vehicle_of_type & HVOT_WAYPOINT) == 0) return;
37 
39 }
40 
46 {
47  /* Buoy orders become waypoint orders */
48  for (OrderList *ol : OrderList::Iterate()) {
49  VehicleType vt = ol->GetFirstSharedVehicle()->type;
50  if (vt != VEH_SHIP && vt != VEH_TRAIN) continue;
51 
52  for (Order *o = ol->GetFirstOrder(); o != nullptr; o = o->next) UpdateWaypointOrder(o);
53  }
54 
55  for (Vehicle *v : Vehicle::Iterate()) {
56  VehicleType vt = v->type;
57  if (vt != VEH_SHIP && vt != VEH_TRAIN) continue;
58 
59  UpdateWaypointOrder(&v->current_order);
60  }
61 
62  /* Now make the stations waypoints */
63  for (Station *st : Station::Iterate()) {
64  if ((st->had_vehicle_of_type & HVOT_WAYPOINT) == 0) continue;
65 
66  StationID index = st->index;
67  TileIndex xy = st->xy;
68  Town *town = st->town;
69  StringID string_id = st->string_id;
70  std::string name = st->name;
71  TimerGameCalendar::Date build_date = st->build_date;
72  /* TTDPatch could use "buoys with rail station" for rail waypoints */
73  bool train = st->train_station.tile != INVALID_TILE;
74  TileArea train_st = st->train_station;
75 
76  /* Delete the station, so we can make it a real waypoint. */
77  delete st;
78 
79  /* Stations and waypoints are in the same pool, so if a station
80  * is deleted there must be place for a Waypoint. */
81  assert(Waypoint::CanAllocateItem());
82  Waypoint *wp = new (index) Waypoint(xy);
83  wp->town = town;
84  wp->string_id = train ? STR_SV_STNAME_WAYPOINT : STR_SV_STNAME_BUOY;
85  wp->name = name;
86  wp->delete_ctr = 0; // Just reset delete counter for once.
87  wp->build_date = build_date;
88  wp->owner = train ? GetTileOwner(xy) : OWNER_NONE;
89 
90  if (IsInsideBS(string_id, STR_SV_STNAME_BUOY, 9)) wp->town_cn = string_id - STR_SV_STNAME_BUOY;
91 
92  if (train) {
93  /* When we make a rail waypoint of the station, convert the map as well. */
94  for (TileIndex t : train_st) {
95  Tile tile(t);
96  if (!IsTileType(tile, MP_STATION) || GetStationIndex(tile) != index) continue;
97 
98  SB(tile.m6(), 3, 3, STATION_WAYPOINT);
99  wp->rect.BeforeAddTile(t, StationRect::ADD_FORCE);
100  }
101 
102  wp->train_station = train_st;
103  wp->facilities |= FACIL_TRAIN;
104  } else if (IsBuoyTile(xy) && GetStationIndex(xy) == index) {
105  wp->rect.BeforeAddTile(xy, StationRect::ADD_FORCE);
106  wp->facilities |= FACIL_DOCK;
107  }
108  }
109 }
110 
111 void AfterLoadStations()
112 {
113  /* Update the speclists of all stations to point to the currently loaded custom stations. */
114  for (BaseStation *st : BaseStation::Iterate()) {
115  for (auto &sm : GetStationSpecList<StationSpec>(st)) {
116  if (sm.grfid == 0) continue;
117  sm.spec = StationClass::GetByGrf(sm.grfid, sm.localidx);
118  }
119  for (auto &sm : GetStationSpecList<RoadStopSpec>(st)) {
120  if (sm.grfid == 0) continue;
121  sm.spec = RoadStopClass::GetByGrf(sm.grfid, sm.localidx);
122  }
123 
124  if (Station::IsExpected(st)) {
125  Station *sta = Station::From(st);
126  for (const RoadStop *rs = sta->bus_stops; rs != nullptr; rs = rs->next) sta->bus_station.Add(rs->xy);
127  for (const RoadStop *rs = sta->truck_stops; rs != nullptr; rs = rs->next) sta->truck_station.Add(rs->xy);
128  }
129 
132  }
133 }
134 
139 {
140  /* First construct the drive through entries */
141  for (RoadStop *rs : RoadStop::Iterate()) {
142  if (IsDriveThroughStopTile(rs->xy)) rs->MakeDriveThrough();
143  }
144  /* And then rebuild the data in those entries */
145  for (RoadStop *rs : RoadStop::Iterate()) {
146  if (!HasBit(rs->status, RoadStop::RSSFB_BASE_ENTRY)) continue;
147 
148  rs->GetEntry(DIAGDIR_NE)->Rebuild(rs);
149  rs->GetEntry(DIAGDIR_NW)->Rebuild(rs);
150  }
151 }
152 
153 static const SaveLoad _roadstop_desc[] = {
154  SLE_VAR(RoadStop, xy, SLE_UINT32),
155  SLE_VAR(RoadStop, status, SLE_UINT8),
157 };
158 
159 static uint16_t _waiting_acceptance;
160 static uint32_t _old_num_flows;
161 static uint16_t _cargo_source;
162 static uint32_t _cargo_source_xy;
163 static uint8_t _cargo_periods;
164 static Money _cargo_feeder_share;
165 
166 std::list<CargoPacket *> _packets;
167 uint32_t _old_num_dests;
168 
169 struct FlowSaveLoad {
170  FlowSaveLoad() : source(0), via(0), share(0), restricted(false) {}
171  StationID source;
172  StationID via;
173  uint32_t share;
174  bool restricted;
175 };
176 
177 typedef std::pair<const StationID, std::list<CargoPacket *> > StationCargoPair;
178 
179 static OldPersistentStorage _old_st_persistent_storage;
180 
186 static void SwapPackets(GoodsEntry *ge)
187 {
188  StationCargoPacketMap &ge_packets = const_cast<StationCargoPacketMap &>(*ge->cargo.Packets());
189 
190  if (_packets.empty()) {
191  std::map<StationID, std::list<CargoPacket *> >::iterator it(ge_packets.find(INVALID_STATION));
192  if (it == ge_packets.end()) {
193  return;
194  } else {
195  it->second.swap(_packets);
196  }
197  } else {
198  assert(ge_packets[INVALID_STATION].empty());
199  ge_packets[INVALID_STATION].swap(_packets);
200  }
201 }
202 
203 template <typename T>
204 class SlStationSpecList : public DefaultSaveLoadHandler<SlStationSpecList<T>, BaseStation> {
205 public:
206  inline static const SaveLoad description[] = {
207  SLE_CONDVAR(SpecMapping<T>, grfid, SLE_UINT32, SLV_27, SL_MAX_VERSION),
208  SLE_CONDVAR(SpecMapping<T>, localidx, SLE_FILE_U8 | SLE_VAR_U16, SLV_27, SLV_EXTEND_ENTITY_MAPPING),
210  };
211  inline const static SaveLoadCompatTable compat_description = _station_spec_list_sl_compat;
212 
213  static inline uint8_t last_num_specs;
214 
215  void Save(BaseStation *bst) const override
216  {
217  auto &speclist = GetStationSpecList<T>(bst);
218  SlSetStructListLength(speclist.size());
219  for (auto &sm : speclist) {
220  SlObject(&sm, this->GetDescription());
221  }
222  }
223 
224  void Load(BaseStation *bst) const override
225  {
227 
228  auto &speclist = GetStationSpecList<T>(bst);
229  speclist.reserve(num_specs);
230  for (size_t index = 0; index < num_specs; ++index) {
231  auto &sm = speclist.emplace_back();
232  SlObject(&sm, this->GetLoadDescription());
233  }
234  }
235 };
236 
237 /* Instantiate SlStationSpecList classes. */
238 template class SlStationSpecList<StationSpec>;
239 template class SlStationSpecList<RoadStopSpec>;
240 
242 public:
243  inline static const SaveLoad description[] = {
244  SLE_VAR(StationCargoPair, first, SLE_UINT16),
245  SLE_REFLIST(StationCargoPair, second, REF_CARGO_PACKET),
246  };
247  inline const static SaveLoadCompatTable compat_description = _station_cargo_sl_compat;
248 
249  void Save(GoodsEntry *ge) const override
250  {
252  for (StationCargoPacketMap::ConstMapIterator it(ge->cargo.Packets()->begin()); it != ge->cargo.Packets()->end(); ++it) {
253  SlObject(const_cast<StationCargoPacketMap::value_type *>(&(*it)), this->GetDescription());
254  }
255  }
256 
257  void Load(GoodsEntry *ge) const override
258  {
259  size_t num_dests = IsSavegameVersionBefore(SLV_SAVELOAD_LIST_LENGTH) ? _old_num_dests : SlGetStructListLength(UINT32_MAX);
260 
261  StationCargoPair pair;
262  for (uint j = 0; j < num_dests; ++j) {
263  SlObject(&pair, this->GetLoadDescription());
264  const_cast<StationCargoPacketMap &>(*(ge->cargo.Packets()))[pair.first].swap(pair.second);
265  assert(pair.second.empty());
266  }
267  }
268 
269  void FixPointers(GoodsEntry *ge) const override
270  {
271  for (StationCargoPacketMap::ConstMapIterator it = ge->cargo.Packets()->begin(); it != ge->cargo.Packets()->end(); ++it) {
272  SlObject(const_cast<StationCargoPair *>(&(*it)), this->GetDescription());
273  }
274  }
275 };
276 
278 public:
279  inline static const SaveLoad description[] = {
280  SLE_VAR(FlowSaveLoad, source, SLE_UINT16),
281  SLE_VAR(FlowSaveLoad, via, SLE_UINT16),
282  SLE_VAR(FlowSaveLoad, share, SLE_UINT32),
283  SLE_CONDVAR(FlowSaveLoad, restricted, SLE_BOOL, SLV_187, SL_MAX_VERSION),
284  };
285  inline const static SaveLoadCompatTable compat_description = _station_flow_sl_compat;
286 
287  void Save(GoodsEntry *ge) const override
288  {
289  size_t num_flows = 0;
290  for (const auto &it : ge->flows) {
291  num_flows += it.second.GetShares()->size();
292  }
293  SlSetStructListLength(num_flows);
294 
295  for (const auto &outer_it : ge->flows) {
296  const FlowStat::SharesMap *shares = outer_it.second.GetShares();
297  uint32_t sum_shares = 0;
298  FlowSaveLoad flow;
299  flow.source = outer_it.first;
300  for (auto &inner_it : *shares) {
301  flow.via = inner_it.second;
302  flow.share = inner_it.first - sum_shares;
303  flow.restricted = inner_it.first > outer_it.second.GetUnrestricted();
304  sum_shares = inner_it.first;
305  assert(flow.share > 0);
306  SlObject(&flow, this->GetDescription());
307  }
308  }
309  }
310 
311  void Load(GoodsEntry *ge) const override
312  {
313  size_t num_flows = IsSavegameVersionBefore(SLV_SAVELOAD_LIST_LENGTH) ? _old_num_flows : SlGetStructListLength(UINT32_MAX);
314 
315  FlowSaveLoad flow;
316  FlowStat *fs = nullptr;
317  StationID prev_source = INVALID_STATION;
318  for (uint32_t j = 0; j < num_flows; ++j) {
319  SlObject(&flow, this->GetLoadDescription());
320  if (fs == nullptr || prev_source != flow.source) {
321  fs = &(ge->flows.emplace(flow.source, FlowStat(flow.via, flow.share, flow.restricted))).first->second;
322  } else {
323  fs->AppendShare(flow.via, flow.share, flow.restricted);
324  }
325  prev_source = flow.source;
326  }
327  }
328 };
329 
330 class SlStationGoods : public DefaultSaveLoadHandler<SlStationGoods, BaseStation> {
331 public:
332  inline static const SaveLoad description[] = {
333  SLEG_CONDVAR("waiting_acceptance", _waiting_acceptance, SLE_UINT16, SL_MIN_VERSION, SLV_68),
334  SLE_CONDVAR(GoodsEntry, status, SLE_UINT8, SLV_68, SL_MAX_VERSION),
335  SLE_VAR(GoodsEntry, time_since_pickup, SLE_UINT8),
336  SLE_VAR(GoodsEntry, rating, SLE_UINT8),
337  SLEG_CONDVAR("cargo_source", _cargo_source, SLE_FILE_U8 | SLE_VAR_U16, SL_MIN_VERSION, SLV_7),
338  SLEG_CONDVAR("cargo_source", _cargo_source, SLE_UINT16, SLV_7, SLV_68),
339  SLEG_CONDVAR("cargo_source_xy", _cargo_source_xy, SLE_UINT32, SLV_44, SLV_68),
340  SLEG_CONDVAR("cargo_days", _cargo_periods, SLE_UINT8, SL_MIN_VERSION, SLV_68),
341  SLE_VAR(GoodsEntry, last_speed, SLE_UINT8),
342  SLE_VAR(GoodsEntry, last_age, SLE_UINT8),
343  SLEG_CONDVAR("cargo_feeder_share", _cargo_feeder_share, SLE_FILE_U32 | SLE_VAR_I64, SLV_14, SLV_65),
344  SLEG_CONDVAR("cargo_feeder_share", _cargo_feeder_share, SLE_INT64, SLV_65, SLV_68),
345  SLE_CONDVAR(GoodsEntry, amount_fract, SLE_UINT8, SLV_150, SL_MAX_VERSION),
346  SLEG_CONDREFLIST("packets", _packets, REF_CARGO_PACKET, SLV_68, SLV_183),
347  SLEG_CONDVAR("old_num_dests", _old_num_dests, SLE_UINT32, SLV_183, SLV_SAVELOAD_LIST_LENGTH),
348  SLE_CONDVAR(GoodsEntry, cargo.reserved_count, SLE_UINT, SLV_181, SL_MAX_VERSION),
349  SLE_CONDVAR(GoodsEntry, link_graph, SLE_UINT16, SLV_183, SL_MAX_VERSION),
350  SLE_CONDVAR(GoodsEntry, node, SLE_UINT16, SLV_183, SL_MAX_VERSION),
351  SLEG_CONDVAR("old_num_flows", _old_num_flows, SLE_UINT32, SLV_183, SLV_SAVELOAD_LIST_LENGTH),
352  SLE_CONDVAR(GoodsEntry, max_waiting_cargo, SLE_UINT32, SLV_183, SL_MAX_VERSION),
355  };
356 
357  inline const static SaveLoadCompatTable compat_description = _station_goods_sl_compat;
358 
363  size_t GetNumCargo() const
364  {
365  if (IsSavegameVersionBefore(SLV_55)) return 12;
368  /* Read from the savegame how long the list is. */
370  }
371 
372  void Save(BaseStation *bst) const override
373  {
374  Station *st = Station::From(bst);
375 
377 
378  for (GoodsEntry &ge : st->goods) {
379  SlObject(&ge, this->GetDescription());
380  }
381  }
382 
383  void Load(BaseStation *bst) const override
384  {
385  Station *st = Station::From(bst);
386 
387  /* Before savegame version 161, persistent storages were not stored in a pool. */
389  /* Store the old persistent storage. The GRFID will be added later. */
391  st->airport.psa = new PersistentStorage(0, 0, 0);
392  std::copy(std::begin(_old_st_persistent_storage.storage), std::end(_old_st_persistent_storage.storage), std::begin(st->airport.psa->storage));
393  }
394 
395  auto end = std::next(std::begin(st->goods), std::min(this->GetNumCargo(), std::size(st->goods)));
396  for (auto it = std::begin(st->goods); it != end; ++it) {
397  GoodsEntry &ge = *it;
398  SlObject(&ge, this->GetLoadDescription());
400  SwapPackets(&ge);
401  }
403  AssignBit(ge.status, GoodsEntry::GES_ACCEPTANCE, HasBit(_waiting_acceptance, 15));
404  if (GB(_waiting_acceptance, 0, 12) != 0) {
405  /* In old versions, enroute_from used 0xFF as INVALID_STATION */
406  StationID source = (IsSavegameVersionBefore(SLV_7) && _cargo_source == 0xFF) ? INVALID_STATION : _cargo_source;
407 
408  /* Make sure we can allocate the CargoPacket. This is safe
409  * as there can only be ~64k stations and 32 cargoes in these
410  * savegame versions. As the CargoPacketPool has more than
411  * 16 million entries; it fits by an order of magnitude. */
413 
414  /* Don't construct the packet with station here, because that'll fail with old savegames */
415  CargoPacket *cp = new CargoPacket(GB(_waiting_acceptance, 0, 12), _cargo_periods, source, _cargo_source_xy, _cargo_feeder_share);
416  ge.cargo.Append(cp, INVALID_STATION);
418  }
419  }
420  }
421  }
422 
423  void FixPointers(BaseStation *bst) const override
424  {
425  Station *st = Station::From(bst);
426 
428  auto end = std::next(std::begin(st->goods), std::min(num_cargo, std::size(st->goods)));
429  for (auto it = std::begin(st->goods); it != end; ++it) {
430  GoodsEntry &ge = *it;
432  SwapPackets(&ge); // We have to swap back again to be in the format pre-183 expects.
433  SlObject(&ge, this->GetDescription());
434  SwapPackets(&ge);
435  } else {
436  SlObject(&ge, this->GetDescription());
437  }
438  }
439  }
440 };
441 
442 static const SaveLoad _old_station_desc[] = {
443  SLE_CONDVAR(Station, xy, SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_6),
444  SLE_CONDVAR(Station, xy, SLE_UINT32, SLV_6, SL_MAX_VERSION),
445  SLE_CONDVAR(Station, train_station.tile, SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_6),
446  SLE_CONDVAR(Station, train_station.tile, SLE_UINT32, SLV_6, SL_MAX_VERSION),
447  SLE_CONDVAR(Station, airport.tile, SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_6),
448  SLE_CONDVAR(Station, airport.tile, SLE_UINT32, SLV_6, SL_MAX_VERSION),
449  SLE_REF(Station, town, REF_TOWN),
450  SLE_VAR(Station, train_station.w, SLE_FILE_U8 | SLE_VAR_U16),
451  SLE_CONDVAR(Station, train_station.h, SLE_FILE_U8 | SLE_VAR_U16, SLV_2, SL_MAX_VERSION),
452 
453  SLE_VAR(Station, string_id, SLE_STRINGID),
455  SLE_CONDVAR(Station, indtype, SLE_UINT8, SLV_103, SL_MAX_VERSION),
456  SLE_CONDVAR(Station, had_vehicle_of_type, SLE_FILE_U16 | SLE_VAR_U8, SL_MIN_VERSION, SLV_122),
457  SLE_CONDVAR(Station, had_vehicle_of_type, SLE_UINT8, SLV_122, SL_MAX_VERSION),
458 
459  SLE_VAR(Station, time_since_load, SLE_UINT8),
460  SLE_VAR(Station, time_since_unload, SLE_UINT8),
461  SLE_VAR(Station, delete_ctr, SLE_UINT8),
462  SLE_VAR(Station, owner, SLE_UINT8),
463  SLE_VAR(Station, facilities, SLE_UINT8),
464  SLE_VAR(Station, airport.type, SLE_UINT8),
465  SLE_CONDVAR(Station, airport.flags, SLE_VAR_U64 | SLE_FILE_U16, SL_MIN_VERSION, SLV_3),
466  SLE_CONDVAR(Station, airport.flags, SLE_VAR_U64 | SLE_FILE_U32, SLV_3, SLV_46),
467  SLE_CONDVAR(Station, airport.flags, SLE_UINT64, SLV_46, SL_MAX_VERSION),
468 
469  SLE_CONDVAR(Station, last_vehicle_type, SLE_UINT8, SLV_26, SL_MAX_VERSION),
470 
471  SLE_CONDVAR(Station, build_date, SLE_FILE_U16 | SLE_VAR_I32, SLV_3, SLV_31),
472  SLE_CONDVAR(Station, build_date, SLE_INT32, SLV_31, SL_MAX_VERSION),
473 
476 
477  /* Used by newstations for graphic variations */
478  SLE_CONDVAR(Station, random_bits, SLE_UINT16, SLV_27, SL_MAX_VERSION),
479  SLE_CONDVAR(Station, waiting_triggers, SLE_UINT8, SLV_27, SL_MAX_VERSION),
481 
483 
486 };
487 
490 
491  void Load() const override
492  {
493  const std::vector<SaveLoad> slt = SlCompatTableHeader(_old_station_desc, _old_station_sl_compat);
494 
495  _cargo_source_xy = 0;
496  _cargo_periods = 0;
497  _cargo_feeder_share = 0;
498 
499  int index;
500  while ((index = SlIterateArray()) != -1) {
501  Station *st = new (index) Station();
502 
503  _waiting_acceptance = 0;
504  SlObject(st, slt);
505  }
506  }
507 
508  void FixPointers() const override
509  {
510  /* From SLV_123 we store stations in STNN; before that in STNS. So do not
511  * fix pointers when the version is SLV_123 or up, as that would fix
512  * pointers twice: once in STNN chunk and once here. */
513  if (!IsSavegameVersionBefore(SLV_123)) return;
514 
515  for (Station *st : Station::Iterate()) {
516  SlObject(st, _old_station_desc);
517  }
518  }
519 };
520 
521 class SlRoadStopTileData : public DefaultSaveLoadHandler<SlRoadStopTileData, BaseStation> {
522 public:
523  inline static const SaveLoad description[] = {
524  SLE_VAR(RoadStopTileData, tile, SLE_UINT32),
525  SLE_VAR(RoadStopTileData, random_bits, SLE_UINT8),
526  SLE_VAR(RoadStopTileData, animation_frame, SLE_UINT8),
527  };
528  inline const static SaveLoadCompatTable compat_description = {};
529 
530  void Save(BaseStation *bst) const override
531  {
533  for (uint i = 0; i < bst->custom_roadstop_tile_data.size(); i++) {
534  SlObject(&bst->custom_roadstop_tile_data[i], this->GetDescription());
535  }
536  }
537 
538  void Load(BaseStation *bst) const override
539  {
540  uint32_t num_tiles = (uint32_t)SlGetStructListLength(UINT32_MAX);
541  bst->custom_roadstop_tile_data.resize(num_tiles);
542  for (uint i = 0; i < num_tiles; i++) {
543  SlObject(&bst->custom_roadstop_tile_data[i], this->GetLoadDescription());
544  }
545  }
546 };
547 
552 class SlStationBase : public DefaultSaveLoadHandler<SlStationBase, BaseStation> {
553 public:
554  inline static const SaveLoad description[] = {
555  SLE_VAR(BaseStation, xy, SLE_UINT32),
556  SLE_REF(BaseStation, town, REF_TOWN),
557  SLE_VAR(BaseStation, string_id, SLE_STRINGID),
558  SLE_SSTR(BaseStation, name, SLE_STR | SLF_ALLOW_CONTROL),
559  SLE_VAR(BaseStation, delete_ctr, SLE_UINT8),
560  SLE_VAR(BaseStation, owner, SLE_UINT8),
561  SLE_VAR(BaseStation, facilities, SLE_UINT8),
562  SLE_VAR(BaseStation, build_date, SLE_INT32),
563 
564  /* Used by newstations for graphic variations */
565  SLE_VAR(BaseStation, random_bits, SLE_UINT16),
566  SLE_VAR(BaseStation, waiting_triggers, SLE_UINT8),
568  };
569  inline const static SaveLoadCompatTable compat_description = _station_base_sl_compat;
570 
571  void Save(BaseStation *bst) const override
572  {
573  SlObject(bst, this->GetDescription());
574  }
575 
576  void Load(BaseStation *bst) const override
577  {
578  SlObject(bst, this->GetLoadDescription());
579  }
580 
581  void FixPointers(BaseStation *bst) const override
582  {
583  SlObject(bst, this->GetDescription());
584  }
585 };
586 
590 class SlStationNormal : public DefaultSaveLoadHandler<SlStationNormal, BaseStation> {
591 public:
592  inline static const SaveLoad description[] = {
593  SLEG_STRUCT("base", SlStationBase),
594  SLE_VAR(Station, train_station.tile, SLE_UINT32),
595  SLE_VAR(Station, train_station.w, SLE_FILE_U8 | SLE_VAR_U16),
596  SLE_VAR(Station, train_station.h, SLE_FILE_U8 | SLE_VAR_U16),
597 
598  SLE_REF(Station, bus_stops, REF_ROADSTOPS),
599  SLE_REF(Station, truck_stops, REF_ROADSTOPS),
600  SLE_CONDVAR(Station, ship_station.tile, SLE_UINT32, SLV_MULTITILE_DOCKS, SL_MAX_VERSION),
601  SLE_CONDVAR(Station, ship_station.w, SLE_FILE_U8 | SLE_VAR_U16, SLV_MULTITILE_DOCKS, SL_MAX_VERSION),
602  SLE_CONDVAR(Station, ship_station.h, SLE_FILE_U8 | SLE_VAR_U16, SLV_MULTITILE_DOCKS, SL_MAX_VERSION),
603  SLE_CONDVAR(Station, docking_station.tile, SLE_UINT32, SLV_MULTITILE_DOCKS, SL_MAX_VERSION),
604  SLE_CONDVAR(Station, docking_station.w, SLE_FILE_U8 | SLE_VAR_U16, SLV_MULTITILE_DOCKS, SL_MAX_VERSION),
605  SLE_CONDVAR(Station, docking_station.h, SLE_FILE_U8 | SLE_VAR_U16, SLV_MULTITILE_DOCKS, SL_MAX_VERSION),
606  SLE_VAR(Station, airport.tile, SLE_UINT32),
607  SLE_CONDVAR(Station, airport.w, SLE_FILE_U8 | SLE_VAR_U16, SLV_140, SL_MAX_VERSION),
608  SLE_CONDVAR(Station, airport.h, SLE_FILE_U8 | SLE_VAR_U16, SLV_140, SL_MAX_VERSION),
609  SLE_VAR(Station, airport.type, SLE_UINT8),
610  SLE_CONDVAR(Station, airport.layout, SLE_UINT8, SLV_145, SL_MAX_VERSION),
611  SLE_VAR(Station, airport.flags, SLE_UINT64),
612  SLE_CONDVAR(Station, airport.rotation, SLE_UINT8, SLV_145, SL_MAX_VERSION),
613  SLEG_CONDARR("storage", _old_st_persistent_storage.storage, SLE_UINT32, 16, SLV_145, SLV_161),
615 
616  SLE_VAR(Station, indtype, SLE_UINT8),
617 
618  SLE_VAR(Station, time_since_load, SLE_UINT8),
619  SLE_VAR(Station, time_since_unload, SLE_UINT8),
620  SLE_VAR(Station, last_vehicle_type, SLE_UINT8),
621  SLE_VAR(Station, had_vehicle_of_type, SLE_UINT8),
622  SLE_REFLIST(Station, loading_vehicles, REF_VEHICLE),
623  SLE_CONDVAR(Station, always_accepted, SLE_FILE_U32 | SLE_VAR_U64, SLV_127, SLV_EXTEND_CARGOTYPES),
624  SLE_CONDVAR(Station, always_accepted, SLE_UINT64, SLV_EXTEND_CARGOTYPES, SL_MAX_VERSION),
627  };
628  inline const static SaveLoadCompatTable compat_description = _station_normal_sl_compat;
629 
630  void Save(BaseStation *bst) const override
631  {
632  if ((bst->facilities & FACIL_WAYPOINT) != 0) return;
633  SlObject(bst, this->GetDescription());
634  }
635 
636  void Load(BaseStation *bst) const override
637  {
638  if ((bst->facilities & FACIL_WAYPOINT) != 0) return;
639  SlObject(bst, this->GetLoadDescription());
640  }
641 
642  void FixPointers(BaseStation *bst) const override
643  {
644  if ((bst->facilities & FACIL_WAYPOINT) != 0) return;
645  SlObject(bst, this->GetDescription());
646  }
647 };
648 
649 class SlStationWaypoint : public DefaultSaveLoadHandler<SlStationWaypoint, BaseStation> {
650 public:
651  inline static const SaveLoad description[] = {
652  SLEG_STRUCT("base", SlStationBase),
653  SLE_VAR(Waypoint, town_cn, SLE_UINT16),
654 
655  SLE_CONDVAR(Waypoint, train_station.tile, SLE_UINT32, SLV_124, SL_MAX_VERSION),
656  SLE_CONDVAR(Waypoint, train_station.w, SLE_FILE_U8 | SLE_VAR_U16, SLV_124, SL_MAX_VERSION),
657  SLE_CONDVAR(Waypoint, train_station.h, SLE_FILE_U8 | SLE_VAR_U16, SLV_124, SL_MAX_VERSION),
658  SLE_CONDVAR(Waypoint, waypoint_flags, SLE_UINT16, SLV_ROAD_WAYPOINTS, SL_MAX_VERSION),
659  SLE_CONDVAR(Waypoint, road_waypoint_area.tile, SLE_UINT32, SLV_ROAD_WAYPOINTS, SL_MAX_VERSION),
660  SLE_CONDVAR(Waypoint, road_waypoint_area.w, SLE_FILE_U8 | SLE_VAR_U16, SLV_ROAD_WAYPOINTS, SL_MAX_VERSION),
661  SLE_CONDVAR(Waypoint, road_waypoint_area.h, SLE_FILE_U8 | SLE_VAR_U16, SLV_ROAD_WAYPOINTS, SL_MAX_VERSION),
662  };
663  inline const static SaveLoadCompatTable compat_description = _station_waypoint_sl_compat;
664 
665  void Save(BaseStation *bst) const override
666  {
667  if ((bst->facilities & FACIL_WAYPOINT) == 0) return;
668  SlObject(bst, this->GetDescription());
669  }
670 
671  void Load(BaseStation *bst) const override
672  {
673  if ((bst->facilities & FACIL_WAYPOINT) == 0) return;
674  SlObject(bst, this->GetLoadDescription());
675  }
676 
677  void FixPointers(BaseStation *bst) const override
678  {
679  if ((bst->facilities & FACIL_WAYPOINT) == 0) return;
680  SlObject(bst, this->GetDescription());
681  }
682 };
683 
684 static const SaveLoad _station_desc[] = {
685  SLE_SAVEBYTE(BaseStation, facilities),
686  SLEG_STRUCT("normal", SlStationNormal),
687  SLEG_STRUCT("waypoint", SlStationWaypoint),
691 };
692 
694  STNNChunkHandler() : ChunkHandler('STNN', CH_TABLE) {}
695 
696  void Save() const override
697  {
698  SlTableHeader(_station_desc);
699 
700  /* Write the stations */
701  for (BaseStation *st : BaseStation::Iterate()) {
702  SlSetArrayIndex(st->index);
703  SlObject(st, _station_desc);
704  }
705  }
706 
707 
708  void Load() const override
709  {
710  const std::vector<SaveLoad> slt = SlCompatTableHeader(_station_desc, _station_sl_compat);
711 
712  _old_num_flows = 0;
713 
714  int index;
715  while ((index = SlIterateArray()) != -1) {
716  bool waypoint = (SlReadByte() & FACIL_WAYPOINT) != 0;
717 
718  BaseStation *bst = waypoint ? (BaseStation *)new (index) Waypoint() : new (index) Station();
719  SlObject(bst, slt);
720  }
721  }
722 
723  void FixPointers() const override
724  {
725  /* From SLV_123 we store stations in STNN; before that in STNS. So do not
726  * fix pointers when the version is below SLV_123, as that would fix
727  * pointers twice: once in STNS chunk and once here. */
728  if (IsSavegameVersionBefore(SLV_123)) return;
729 
730  for (BaseStation *bst : BaseStation::Iterate()) {
731  SlObject(bst, _station_desc);
732  }
733  }
734 };
735 
737  ROADChunkHandler() : ChunkHandler('ROAD', CH_TABLE) {}
738 
739  void Save() const override
740  {
741  SlTableHeader(_roadstop_desc);
742 
743  for (RoadStop *rs : RoadStop::Iterate()) {
744  SlSetArrayIndex(rs->index);
745  SlObject(rs, _roadstop_desc);
746  }
747  }
748 
749  void Load() const override
750  {
751  const std::vector<SaveLoad> slt = SlCompatTableHeader(_roadstop_desc, _roadstop_sl_compat);
752 
753  int index;
754 
755  while ((index = SlIterateArray()) != -1) {
756  RoadStop *rs = new (index) RoadStop(INVALID_TILE);
757 
758  SlObject(rs, slt);
759  }
760  }
761 
762  void FixPointers() const override
763  {
764  for (RoadStop *rs : RoadStop::Iterate()) {
765  SlObject(rs, _roadstop_desc);
766  }
767  }
768 };
769 
770 static const STNSChunkHandler STNS;
771 static const STNNChunkHandler STNN;
772 static const ROADChunkHandler ROAD;
773 static const ChunkHandlerRef station_chunk_handlers[] = {
774  STNS,
775  STNN,
776  ROAD,
777 };
778 
779 extern const ChunkHandlerTable _station_chunk_handlers(station_chunk_handlers);
constexpr debug_inline bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr T AssignBit(T &x, const uint8_t y, bool value)
Assigns a bit in a variable.
constexpr T SB(T &x, const uint8_t s, const uint8_t n, const U d)
Set n bits in x starting at bit s to d.
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
constexpr static debug_inline uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
static const CargoID NUM_CARGO
Maximum number of cargo types in a game.
Definition: cargo_type.h:74
const Tcont * Packets() const
Returns a pointer to the cargo packet list (so you can iterate over it etc).
Definition: cargopacket.h:329
Default handler for saving/loading an object to/from disk.
Definition: saveload.h:577
Flow statistics telling how much flow should be sent along a link.
Definition: station_base.h:32
void AppendShare(StationID st, uint flow, bool restricted=false)
Add some flow to the end of the shares map.
Definition: station_base.h:66
Hand-rolled multimap as map of lists.
Definition: multimap.hpp:281
size_t MapSize() const
Count the number of ranges with equal keys in this MultiMap.
Definition: multimap.hpp:347
static const Tspec * GetByGrf(uint32_t grfid, uint16_t local_id)
Retrieve a spec by GRF location.
SaveLoadTable GetLoadDescription() const
Get the description for how to load the chunk.
Definition: saveload.cpp:3288
SaveLoad handler for the BaseStation, which all other stations / waypoints make use of.
Definition: station_sl.cpp:552
size_t GetNumCargo() const
Get the number of cargoes used by this savegame version.
Definition: station_sl.cpp:363
SaveLoad handler for a normal station (read: not a waypoint).
Definition: station_sl.cpp:590
static uint8_t last_num_specs
Number of specs of the last loaded station.
Definition: station_sl.cpp:213
void Append(CargoPacket *cp, StationID next)
Appends the given cargo packet to the range of packets with the same next station.
Wrapper class to abstract away the way the tiles are stored.
Definition: map_func.h:25
debug_inline uint8_t & m6()
General purpose.
Definition: map_func.h:173
@ OWNER_NONE
The tile has no ownership.
Definition: company_type.h:25
@ DIAGDIR_NE
Northeast, upper right on your monitor.
@ DIAGDIR_NW
Northwest.
constexpr bool IsInsideBS(const T x, const size_t base, const size_t size)
Checks if a value is between a window started at some base point.
Definition: math_func.hpp:252
void RoadStopUpdateCachedTriggers(BaseStation *st)
Update the cached animation trigger bitmask for a station.
void StationUpdateCachedTriggers(BaseStation *st)
Update the cached animation trigger bitmask for a station.
size_t SlGetStructListLength(size_t limit)
Get the length of this list; if it exceeds the limit, error out.
Definition: saveload.cpp:1684
int SlIterateArray()
Iterate through the elements of an array and read the whole thing.
Definition: saveload.cpp:658
std::vector< SaveLoad > SlCompatTableHeader(const SaveLoadTable &slt, const SaveLoadCompatTable &slct)
Load a table header in a savegame compatible way.
Definition: saveload.cpp:1888
std::vector< SaveLoad > SlTableHeader(const SaveLoadTable &slt)
Save or Load a table header.
Definition: saveload.cpp:1750
uint8_t SlReadByte()
Wrapper for reading a byte from the buffer.
Definition: saveload.cpp:392
void SlObject(void *object, const SaveLoadTable &slt)
Main SaveLoad function.
Definition: saveload.cpp:1697
void SlSetStructListLength(size_t length)
Set the length of this list.
Definition: saveload.cpp:1668
Functions/types related to saving and loading games.
#define SLEG_CONDARR(name, variable, type, length, from, to)
Storage of a global fixed-size array of SL_VAR elements in some savegame versions.
Definition: saveload.h:1095
#define SLEG_STRUCTLIST(name, handler)
Storage of a list of structs in every savegame version.
Definition: saveload.h:1205
@ SLF_ALLOW_CONTROL
Allow control codes in the strings.
Definition: saveload.h:684
#define SLEG_CONDVAR(name, variable, type, from, to)
Storage of a global variable in some savegame versions.
Definition: saveload.h:1074
@ CH_READONLY
Chunk is never saved.
Definition: saveload.h:455
std::reference_wrapper< const ChunkHandler > ChunkHandlerRef
A reference to ChunkHandler.
Definition: saveload.h:505
#define SLEG_CONDREFLIST(name, variable, type, from, to)
Storage of a global reference list in some savegame versions.
Definition: saveload.h:1124
std::span< const ChunkHandlerRef > ChunkHandlerTable
A table of ChunkHandler entries.
Definition: saveload.h:508
#define SLE_SAVEBYTE(base, variable)
Only write byte during saving; never read it during loading.
Definition: saveload.h:1048
#define SLE_REF(base, variable, type)
Storage of a reference in every version of a savegame.
Definition: saveload.h:992
#define SLE_CONDREFLIST(base, variable, type, from, to)
Storage of a list of SL_REF elements in some savegame versions.
Definition: saveload.h:947
#define SLE_REFLIST(base, variable, type)
Storage of a list of SL_REF elements in every savegame version.
Definition: saveload.h:1036
std::span< const struct SaveLoadCompat > SaveLoadCompatTable
A table of SaveLoadCompat entries.
Definition: saveload.h:514
#define SLEG_STRUCT(name, handler)
Storage of a structs in every savegame version.
Definition: saveload.h:1182
#define SLE_CONDSSTR(base, variable, type, from, to)
Storage of a std::string in some savegame versions.
Definition: saveload.h:926
#define SLE_CONDVAR(base, variable, type, from, to)
Storage of a variable in some savegame versions.
Definition: saveload.h:861
bool IsSavegameVersionBefore(SaveLoadVersion major, uint8_t minor=0)
Checks whether the savegame is below major.
Definition: saveload.h:1227
#define SLE_SSTR(base, variable, type)
Storage of a std::string in every savegame version.
Definition: saveload.h:1019
@ SLV_150
150 20857
Definition: saveload.h:223
@ SLV_84
84 11822
Definition: saveload.h:143
@ SLV_26
26 4466
Definition: saveload.h:74
@ SLV_ROAD_WAYPOINTS
338 PR#12572 Road waypoints
Definition: saveload.h:385
@ SLV_103
103 14598
Definition: saveload.h:166
@ SLV_44
44 8144
Definition: saveload.h:95
@ SLV_6
6.0 1721 6.1 1768
Definition: saveload.h:46
@ SLV_181
181 25012
Definition: saveload.h:260
@ SLV_EXTEND_CARGOTYPES
199 PR#6802 Extend cargotypes to 64
Definition: saveload.h:282
@ SLV_SAVELOAD_LIST_LENGTH
293 PR#9374 Consistency in list length with SL_STRUCT / SL_STRUCTLIST / SL_DEQUE / SL_REFLIST.
Definition: saveload.h:331
@ SLV_65
65 10210
Definition: saveload.h:121
@ SLV_123
123 16909
Definition: saveload.h:190
@ SLV_46
46 8705
Definition: saveload.h:98
@ SLV_122
122 16855
Definition: saveload.h:189
@ SLV_140
140 19382
Definition: saveload.h:211
@ SLV_MULTITILE_DOCKS
216 PR#7380 Multiple docks per station.
Definition: saveload.h:303
@ SL_MAX_VERSION
Highest possible saveload version.
Definition: saveload.h:395
@ SL_MIN_VERSION
First savegame version.
Definition: saveload.h:31
@ SLV_3
3.x lost
Definition: saveload.h:36
@ SLV_145
145 20376
Definition: saveload.h:217
@ SLV_57
57 9691
Definition: saveload.h:111
@ SLV_68
68 10266
Definition: saveload.h:124
@ SLV_NEWGRF_ROAD_STOPS
303 PR#10144 NewGRF road stops.
Definition: saveload.h:343
@ SLV_2
2.0 0.3.0 2.1 0.3.1, 0.3.2
Definition: saveload.h:34
@ SLV_187
187 25899 Linkgraph - restricted flows
Definition: saveload.h:267
@ SLV_27
27 4757
Definition: saveload.h:75
@ SLV_127
127 17439
Definition: saveload.h:195
@ SLV_14
14.0 2441
Definition: saveload.h:57
@ SLV_55
55 9638
Definition: saveload.h:109
@ SLV_161
161 22567
Definition: saveload.h:236
@ SLV_7
7.0 1770
Definition: saveload.h:48
@ SLV_124
124 16993
Definition: saveload.h:191
@ SLV_183
183 25363 Cargodist
Definition: saveload.h:262
@ SLV_31
31 5999
Definition: saveload.h:80
@ SLV_EXTEND_ENTITY_MAPPING
311 PR#10672 Extend entity mapping range.
Definition: saveload.h:353
@ SLV_ROAD_STOP_TILE_DATA
340 PR#12883 Move storage of road stop tile data, also save for road waypoints.
Definition: saveload.h:388
#define SLE_CONDREF(base, variable, type, from, to)
Storage of a reference in some savegame versions.
Definition: saveload.h:882
@ REF_TOWN
Load/save a reference to a town.
Definition: saveload.h:600
@ REF_CARGO_PACKET
Load/save a reference to a cargo packet.
Definition: saveload.h:604
@ REF_STORAGE
Load/save a reference to a persistent storage.
Definition: saveload.h:606
@ REF_VEHICLE
Load/save a reference to a vehicle.
Definition: saveload.h:598
@ REF_ROADSTOPS
Load/save a reference to a bus/truck stop.
Definition: saveload.h:602
#define SLEG_CONDSTRUCTLIST(name, handler, from, to)
Storage of a list of structs in some savegame versions.
Definition: saveload.h:1143
#define SLE_VAR(base, variable, type)
Storage of a variable in every version of a savegame.
Definition: saveload.h:975
bool IsDriveThroughStopTile(Tile t)
Is tile t a drive through road stop station or waypoint?
Definition: station_map.h:276
StationID GetStationIndex(Tile t)
Get StationID from a tile.
Definition: station_map.h:28
bool IsBuoyTile(Tile t)
Is tile t a buoy tile?
Definition: station_map.h:410
static void UpdateWaypointOrder(Order *o)
Update the buoy orders to be waypoint orders.
Definition: station_sl.cpp:31
void MoveBuoysToWaypoints()
Perform all steps to upgrade from the old station buoys to the new version that uses waypoints.
Definition: station_sl.cpp:45
void AfterLoadRoadStops()
(Re)building of road stop caches after loading a savegame.
Definition: station_sl.cpp:138
static void SwapPackets(GoodsEntry *ge)
Swap the temporary packets with the packets without specific destination in the given goods entry.
Definition: station_sl.cpp:186
Loading of station chunks before table headers were added.
const SaveLoadCompat _station_base_sl_compat[]
Original field order for SlStationBase.
const SaveLoadCompat _roadstop_sl_compat[]
Original field order for _roadstop_desc.
const SaveLoadCompat _station_sl_compat[]
Original field order for _station_desc.
const SaveLoadCompat _station_cargo_sl_compat[]
Original field order for SlStationCargo.
const SaveLoadCompat _station_goods_sl_compat[]
Original field order for SlStationGoods.
const SaveLoadCompat _station_flow_sl_compat[]
Original field order for SlStationFlow.
const SaveLoadCompat _station_waypoint_sl_compat[]
Original field order for SlStationWaypoint.
const SaveLoadCompat _station_normal_sl_compat[]
Original field order for SlStationNormal.
const SaveLoadCompat _old_station_sl_compat[]
Original field order for _old_station_desc.
const SaveLoadCompat _station_spec_list_sl_compat[]
Original field order for SlStationSpecList.
@ HVOT_WAYPOINT
Station is a waypoint (NewGRF only!)
Definition: station_type.h:72
@ FACIL_DOCK
Station with a dock.
Definition: station_type.h:58
@ FACIL_AIRPORT
Station with an airport.
Definition: station_type.h:57
@ FACIL_WAYPOINT
Station is a waypoint.
Definition: station_type.h:59
@ FACIL_TRAIN
Station with train station.
Definition: station_type.h:54
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
PersistentStorage * psa
Persistent storage for NewGRF airports.
Definition: station_base.h:298
Base class for all station-ish types.
StationFacility facilities
The facilities that this station has.
StringID string_id
Default name (town area) of station.
TileArea train_station
Tile area the train 'station' part covers.
Owner owner
The owner of this station.
uint8_t delete_ctr
Delete counter. If greater than 0 then it is decremented until it reaches 0; the waypoint is then is ...
StationRect rect
NOSAVE: Station spread out rectangle maintained by StationRect::xxx() functions.
Town * town
The town this station is associated with.
std::vector< RoadStopTileData > custom_roadstop_tile_data
List of custom road stop tile data.
TimerGameCalendar::Date build_date
Date of construction.
std::string name
Custom name.
Container for cargo from the same location and time.
Definition: cargopacket.h:40
Handlers and description of chunk.
Definition: saveload.h:459
Stores station stats for a single cargo.
Definition: station_base.h:166
FlowStatMap flows
Planned flows through this station.
Definition: station_base.h:211
@ GES_ACCEPTANCE
Set when the station accepts the cargo currently for final deliveries.
Definition: station_base.h:173
@ GES_RATING
This indicates whether a cargo has a rating at the station.
Definition: station_base.h:183
StationCargoList cargo
The cargo packets of cargo waiting in this station.
Definition: station_base.h:210
uint8_t status
Status of this cargo, see GoodsEntryStatus.
Definition: station_base.h:217
Shared order list linking together the linked list of orders and the list of vehicles sharing this or...
Definition: order_base.h:259
DestinationID GetDestination() const
Gets the destination of this order.
Definition: order_base.h:103
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition: order_base.h:70
void MakeGoToWaypoint(StationID destination)
Makes this order a Go To Waypoint order.
Definition: order_cmd.cpp:104
Order * next
Pointer to next order. If nullptr, end of list.
Definition: order_base.h:59
Represents the covered area of e.g.
Definition: tilearea_type.h:18
void Add(TileIndex to_add)
Add a single tile to a tile area; enlarge if needed.
Definition: tilearea.cpp:43
Class for persistent storage of data.
StorageType storage
Memory for the storage array.
Class for pooled persistent storage of data.
Tindex index
Index of this pool item.
Definition: pool_type.hpp:238
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition: pool_type.hpp:309
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:388
void FixPointers() const override
Fix the pointers.
Definition: station_sl.cpp:762
void Load() const override
Load the chunk.
Definition: station_sl.cpp:749
void Save() const override
Save the chunk.
Definition: station_sl.cpp:739
A Stop for a Road Vehicle.
Definition: roadstop_base.h:22
@ RSSFB_BASE_ENTRY
Non-zero when the entries on this road stop are the primary, i.e. the ones to delete.
Definition: roadstop_base.h:26
RoadStop * next
Next stop of the given type at this station.
Definition: roadstop_base.h:70
void FixPointers() const override
Fix the pointers.
Definition: station_sl.cpp:723
void Save() const override
Save the chunk.
Definition: station_sl.cpp:696
void Load() const override
Load the chunk.
Definition: station_sl.cpp:708
void Load() const override
Load the chunk.
Definition: station_sl.cpp:491
void FixPointers() const override
Fix the pointers.
Definition: station_sl.cpp:508
SaveLoad type struct.
Definition: saveload.h:711
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
static bool IsExpected(const BaseStation *st)
Helper for checking whether the given station is of this type.
static Station * Get(size_t index)
Gets station with given index.
static Station * From(BaseStation *st)
Converts a BaseStation to SpecializedStation with type checking.
Station data structure.
Definition: station_base.h:439
RoadStop * bus_stops
All the road stops.
Definition: station_base.h:448
GoodsEntry goods[NUM_CARGO]
Goods at this station.
Definition: station_base.h:468
TileArea bus_station
Tile area the bus 'station' part covers.
Definition: station_base.h:449
Airport airport
Tile area the airport covers.
Definition: station_base.h:453
TileArea truck_station
Tile area the truck 'station' part covers.
Definition: station_base.h:451
RoadStop * truck_stops
All the truck stops.
Definition: station_base.h:450
Town data structure.
Definition: town.h:54
std::string name
Custom town name. If empty, the town was not renamed and uses the generated name.
Definition: town.h:63
Vehicle data structure.
Definition: vehicle_base.h:244
Representation of a waypoint.
Definition: waypoint_base.h:23
uint16_t town_cn
The N-1th waypoint for this town (consecutive number)
Definition: waypoint_base.h:24
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition: tile_map.h:178
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:95
@ MP_STATION
A tile of a station.
Definition: tile_type.h:53
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
@ VEH_SHIP
Ship vehicle type.
Definition: vehicle_type.h:26
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24