OpenTTD Source  1.10.1
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 #include "../station_base.h"
12 #include "../waypoint_base.h"
13 #include "../roadstop_base.h"
14 #include "../vehicle_base.h"
15 #include "../newgrf_station.h"
16 
17 #include "saveload.h"
18 #include "table/strings.h"
19 
20 #include "../safeguards.h"
21 
26 static void UpdateWaypointOrder(Order *o)
27 {
28  if (!o->IsType(OT_GOTO_STATION)) return;
29 
30  const Station *st = Station::Get(o->GetDestination());
31  if ((st->had_vehicle_of_type & HVOT_WAYPOINT) == 0) return;
32 
34 }
35 
41 {
42  /* Buoy orders become waypoint orders */
43  for (OrderList *ol : OrderList::Iterate()) {
44  VehicleType vt = ol->GetFirstSharedVehicle()->type;
45  if (vt != VEH_SHIP && vt != VEH_TRAIN) continue;
46 
47  for (Order *o = ol->GetFirstOrder(); o != nullptr; o = o->next) UpdateWaypointOrder(o);
48  }
49 
50  for (Vehicle *v : Vehicle::Iterate()) {
51  VehicleType vt = v->type;
52  if (vt != VEH_SHIP && vt != VEH_TRAIN) continue;
53 
54  UpdateWaypointOrder(&v->current_order);
55  }
56 
57  /* Now make the stations waypoints */
58  for (Station *st : Station::Iterate()) {
59  if ((st->had_vehicle_of_type & HVOT_WAYPOINT) == 0) continue;
60 
61  StationID index = st->index;
62  TileIndex xy = st->xy;
63  Town *town = st->town;
64  StringID string_id = st->string_id;
65  char *name = st->name;
66  st->name = nullptr;
67  Date build_date = st->build_date;
68  /* TTDPatch could use "buoys with rail station" for rail waypoints */
69  bool train = st->train_station.tile != INVALID_TILE;
70  TileArea train_st = st->train_station;
71 
72  /* Delete the station, so we can make it a real waypoint. */
73  delete st;
74 
75  /* Stations and waypoints are in the same pool, so if a station
76  * is deleted there must be place for a Waypoint. */
77  assert(Waypoint::CanAllocateItem());
78  Waypoint *wp = new (index) Waypoint(xy);
79  wp->town = town;
80  wp->string_id = train ? STR_SV_STNAME_WAYPOINT : STR_SV_STNAME_BUOY;
81  wp->name = name;
82  wp->delete_ctr = 0; // Just reset delete counter for once.
83  wp->build_date = build_date;
84  wp->owner = train ? GetTileOwner(xy) : OWNER_NONE;
85 
86  if (IsInsideBS(string_id, STR_SV_STNAME_BUOY, 9)) wp->town_cn = string_id - STR_SV_STNAME_BUOY;
87 
88  if (train) {
89  /* When we make a rail waypoint of the station, convert the map as well. */
90  TILE_AREA_LOOP(t, train_st) {
91  if (!IsTileType(t, MP_STATION) || GetStationIndex(t) != index) continue;
92 
93  SB(_me[t].m6, 3, 3, STATION_WAYPOINT);
94  wp->rect.BeforeAddTile(t, StationRect::ADD_FORCE);
95  }
96 
97  wp->train_station = train_st;
98  wp->facilities |= FACIL_TRAIN;
99  } else if (IsBuoyTile(xy) && GetStationIndex(xy) == index) {
100  wp->rect.BeforeAddTile(xy, StationRect::ADD_FORCE);
101  wp->facilities |= FACIL_DOCK;
102  }
103  }
104 }
105 
106 void AfterLoadStations()
107 {
108  /* Update the speclists of all stations to point to the currently loaded custom stations. */
109  for (BaseStation *st : BaseStation::Iterate()) {
110  for (uint i = 0; i < st->num_specs; i++) {
111  if (st->speclist[i].grfid == 0) continue;
112 
113  st->speclist[i].spec = StationClass::GetByGrf(st->speclist[i].grfid, st->speclist[i].localidx, nullptr);
114  }
115 
116  if (Station::IsExpected(st)) {
117  Station *sta = Station::From(st);
118  for (const RoadStop *rs = sta->bus_stops; rs != nullptr; rs = rs->next) sta->bus_station.Add(rs->xy);
119  for (const RoadStop *rs = sta->truck_stops; rs != nullptr; rs = rs->next) sta->truck_station.Add(rs->xy);
120  }
121 
123  }
124 }
125 
130 {
131  /* First construct the drive through entries */
132  for (RoadStop *rs : RoadStop::Iterate()) {
133  if (IsDriveThroughStopTile(rs->xy)) rs->MakeDriveThrough();
134  }
135  /* And then rebuild the data in those entries */
136  for (RoadStop *rs : RoadStop::Iterate()) {
137  if (!HasBit(rs->status, RoadStop::RSSFB_BASE_ENTRY)) continue;
138 
139  rs->GetEntry(DIAGDIR_NE)->Rebuild(rs);
140  rs->GetEntry(DIAGDIR_NW)->Rebuild(rs);
141  }
142 }
143 
148 {
149  /* Scan for docking tiles */
150  for (Station *st : Station::Iterate()) {
151  if (st->ship_station.tile != INVALID_TILE) UpdateStationDockingTiles(st);
152  }
153 }
154 
155 static const SaveLoad _roadstop_desc[] = {
156  SLE_VAR(RoadStop, xy, SLE_UINT32),
158  SLE_VAR(RoadStop, status, SLE_UINT8),
159  /* Index was saved in some versions, but this is not needed */
163 
166 
169 
170  SLE_END()
171 };
172 
173 static const SaveLoad _old_station_desc[] = {
174  SLE_CONDVAR(Station, xy, SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_6),
175  SLE_CONDVAR(Station, xy, SLE_UINT32, SLV_6, SL_MAX_VERSION),
177  SLE_CONDVAR(Station, train_station.tile, SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_6),
178  SLE_CONDVAR(Station, train_station.tile, SLE_UINT32, SLV_6, SL_MAX_VERSION),
179  SLE_CONDVAR(Station, airport.tile, SLE_FILE_U16 | SLE_VAR_U32, SL_MIN_VERSION, SLV_6),
180  SLE_CONDVAR(Station, airport.tile, SLE_UINT32, SLV_6, SL_MAX_VERSION),
183  SLE_REF(Station, town, REF_TOWN),
184  SLE_VAR(Station, train_station.w, SLE_FILE_U8 | SLE_VAR_U16),
185  SLE_CONDVAR(Station, train_station.h, SLE_FILE_U8 | SLE_VAR_U16, SLV_2, SL_MAX_VERSION),
186 
188 
189  SLE_VAR(Station, string_id, SLE_STRINGID),
191  SLE_CONDVAR(Station, indtype, SLE_UINT8, SLV_103, SL_MAX_VERSION),
192  SLE_CONDVAR(Station, had_vehicle_of_type, SLE_FILE_U16 | SLE_VAR_U8, SL_MIN_VERSION, SLV_122),
193  SLE_CONDVAR(Station, had_vehicle_of_type, SLE_UINT8, SLV_122, SL_MAX_VERSION),
194 
195  SLE_VAR(Station, time_since_load, SLE_UINT8),
196  SLE_VAR(Station, time_since_unload, SLE_UINT8),
197  SLE_VAR(Station, delete_ctr, SLE_UINT8),
198  SLE_VAR(Station, owner, SLE_UINT8),
199  SLE_VAR(Station, facilities, SLE_UINT8),
200  SLE_VAR(Station, airport.type, SLE_UINT8),
201 
204 
205  SLE_CONDVAR(Station, airport.flags, SLE_VAR_U64 | SLE_FILE_U16, SL_MIN_VERSION, SLV_3),
206  SLE_CONDVAR(Station, airport.flags, SLE_VAR_U64 | SLE_FILE_U32, SLV_3, SLV_46),
207  SLE_CONDVAR(Station, airport.flags, SLE_UINT64, SLV_46, SL_MAX_VERSION),
208 
210  SLE_CONDVAR(Station, last_vehicle_type, SLE_UINT8, SLV_26, SL_MAX_VERSION),
211 
212  SLE_CONDNULL(2, SLV_3, SLV_26),
213  SLE_CONDVAR(Station, build_date, SLE_FILE_U16 | SLE_VAR_I32, SLV_3, SLV_31),
214  SLE_CONDVAR(Station, build_date, SLE_INT32, SLV_31, SL_MAX_VERSION),
215 
218 
219  /* Used by newstations for graphic variations */
220  SLE_CONDVAR(Station, random_bits, SLE_UINT16, SLV_27, SL_MAX_VERSION),
221  SLE_CONDVAR(Station, waiting_triggers, SLE_UINT8, SLV_27, SL_MAX_VERSION),
222  SLE_CONDVAR(Station, num_specs, SLE_UINT8, SLV_27, SL_MAX_VERSION),
223 
224  SLE_CONDLST(Station, loading_vehicles, REF_VEHICLE, SLV_57, SL_MAX_VERSION),
225 
226  /* reserve extra space in savegame here. (currently 32 bytes) */
228 
229  SLE_END()
230 };
231 
232 static uint16 _waiting_acceptance;
233 static uint32 _num_flows;
234 static uint16 _cargo_source;
235 static uint32 _cargo_source_xy;
236 static uint8 _cargo_days;
237 static Money _cargo_feeder_share;
238 
239 static const SaveLoad _station_speclist_desc[] = {
240  SLE_CONDVAR(StationSpecList, grfid, SLE_UINT32, SLV_27, SL_MAX_VERSION),
241  SLE_CONDVAR(StationSpecList, localidx, SLE_UINT8, SLV_27, SL_MAX_VERSION),
242 
243  SLE_END()
244 };
245 
246 std::list<CargoPacket *> _packets;
247 uint32 _num_dests;
248 
249 struct FlowSaveLoad {
250  FlowSaveLoad() : source(0), via(0), share(0), restricted(false) {}
251  StationID source;
252  StationID via;
253  uint32 share;
254  bool restricted;
255 };
256 
257 static const SaveLoad _flow_desc[] = {
258  SLE_VAR(FlowSaveLoad, source, SLE_UINT16),
259  SLE_VAR(FlowSaveLoad, via, SLE_UINT16),
260  SLE_VAR(FlowSaveLoad, share, SLE_UINT32),
261  SLE_CONDVAR(FlowSaveLoad, restricted, SLE_BOOL, SLV_187, SL_MAX_VERSION),
262  SLE_END()
263 };
264 
271 {
272  static const SaveLoad goods_desc[] = {
273  SLEG_CONDVAR( _waiting_acceptance, SLE_UINT16, SL_MIN_VERSION, SLV_68),
274  SLE_CONDVAR(GoodsEntry, status, SLE_UINT8, SLV_68, SL_MAX_VERSION),
276  SLE_VAR(GoodsEntry, time_since_pickup, SLE_UINT8),
277  SLE_VAR(GoodsEntry, rating, SLE_UINT8),
278  SLEG_CONDVAR( _cargo_source, SLE_FILE_U8 | SLE_VAR_U16, SL_MIN_VERSION, SLV_7),
279  SLEG_CONDVAR( _cargo_source, SLE_UINT16, SLV_7, SLV_68),
280  SLEG_CONDVAR( _cargo_source_xy, SLE_UINT32, SLV_44, SLV_68),
281  SLEG_CONDVAR( _cargo_days, SLE_UINT8, SL_MIN_VERSION, SLV_68),
282  SLE_VAR(GoodsEntry, last_speed, SLE_UINT8),
283  SLE_VAR(GoodsEntry, last_age, SLE_UINT8),
284  SLEG_CONDVAR( _cargo_feeder_share, SLE_FILE_U32 | SLE_VAR_I64, SLV_14, SLV_65),
285  SLEG_CONDVAR( _cargo_feeder_share, SLE_INT64, SLV_65, SLV_68),
286  SLE_CONDVAR(GoodsEntry, amount_fract, SLE_UINT8, SLV_150, SL_MAX_VERSION),
288  SLEG_CONDVAR( _num_dests, SLE_UINT32, SLV_183, SL_MAX_VERSION),
289  SLE_CONDVAR(GoodsEntry, cargo.reserved_count, SLE_UINT, SLV_181, SL_MAX_VERSION),
290  SLE_CONDVAR(GoodsEntry, link_graph, SLE_UINT16, SLV_183, SL_MAX_VERSION),
291  SLE_CONDVAR(GoodsEntry, node, SLE_UINT16, SLV_183, SL_MAX_VERSION),
292  SLEG_CONDVAR( _num_flows, SLE_UINT32, SLV_183, SL_MAX_VERSION),
293  SLE_CONDVAR(GoodsEntry, max_waiting_cargo, SLE_UINT32, SLV_183, SL_MAX_VERSION),
294  SLE_END()
295  };
296 
297  return goods_desc;
298 }
299 
300 typedef std::pair<const StationID, std::list<CargoPacket *> > StationCargoPair;
301 
302 static const SaveLoad _cargo_list_desc[] = {
303  SLE_VAR(StationCargoPair, first, SLE_UINT16),
304  SLE_LST(StationCargoPair, second, REF_CARGO_PACKET),
305  SLE_END()
306 };
307 
313 static void SwapPackets(GoodsEntry *ge)
314 {
315  StationCargoPacketMap &ge_packets = const_cast<StationCargoPacketMap &>(*ge->cargo.Packets());
316 
317  if (_packets.empty()) {
318  std::map<StationID, std::list<CargoPacket *> >::iterator it(ge_packets.find(INVALID_STATION));
319  if (it == ge_packets.end()) {
320  return;
321  } else {
322  it->second.swap(_packets);
323  }
324  } else {
325  assert(ge_packets[INVALID_STATION].empty());
326  ge_packets[INVALID_STATION].swap(_packets);
327  }
328 }
329 
330 static void Load_STNS()
331 {
332  _cargo_source_xy = 0;
333  _cargo_days = 0;
334  _cargo_feeder_share = 0;
335 
337  int index;
338  while ((index = SlIterateArray()) != -1) {
339  Station *st = new (index) Station();
340 
341  SlObject(st, _old_station_desc);
342 
343  _waiting_acceptance = 0;
344 
345  for (CargoID i = 0; i < num_cargo; i++) {
346  GoodsEntry *ge = &st->goods[i];
347  SlObject(ge, GetGoodsDesc());
348  SwapPackets(ge);
350  SB(ge->status, GoodsEntry::GES_ACCEPTANCE, 1, HasBit(_waiting_acceptance, 15));
351  if (GB(_waiting_acceptance, 0, 12) != 0) {
352  /* In old versions, enroute_from used 0xFF as INVALID_STATION */
353  StationID source = (IsSavegameVersionBefore(SLV_7) && _cargo_source == 0xFF) ? INVALID_STATION : _cargo_source;
354 
355  /* Make sure we can allocate the CargoPacket. This is safe
356  * as there can only be ~64k stations and 32 cargoes in these
357  * savegame versions. As the CargoPacketPool has more than
358  * 16 million entries; it fits by an order of magnitude. */
360 
361  /* Don't construct the packet with station here, because that'll fail with old savegames */
362  CargoPacket *cp = new CargoPacket(GB(_waiting_acceptance, 0, 12), _cargo_days, source, _cargo_source_xy, _cargo_source_xy, _cargo_feeder_share);
363  ge->cargo.Append(cp, INVALID_STATION);
364  SB(ge->status, GoodsEntry::GES_RATING, 1, 1);
365  }
366  }
367  }
368 
369  if (st->num_specs != 0) {
370  /* Allocate speclist memory when loading a game */
371  st->speclist = CallocT<StationSpecList>(st->num_specs);
372  for (uint i = 0; i < st->num_specs; i++) {
373  SlObject(&st->speclist[i], _station_speclist_desc);
374  }
375  }
376  }
377 }
378 
379 static void Ptrs_STNS()
380 {
381  /* Don't run when savegame version is higher than or equal to 123. */
382  if (!IsSavegameVersionBefore(SLV_123)) return;
383 
385  for (Station *st : Station::Iterate()) {
387  for (CargoID i = 0; i < num_cargo; i++) {
388  GoodsEntry *ge = &st->goods[i];
389  SwapPackets(ge);
390  SlObject(ge, GetGoodsDesc());
391  SwapPackets(ge);
392  }
393  }
394  SlObject(st, _old_station_desc);
395  }
396 }
397 
398 
399 static const SaveLoad _base_station_desc[] = {
400  SLE_VAR(BaseStation, xy, SLE_UINT32),
401  SLE_REF(BaseStation, town, REF_TOWN),
402  SLE_VAR(BaseStation, string_id, SLE_STRINGID),
404  SLE_VAR(BaseStation, delete_ctr, SLE_UINT8),
405  SLE_VAR(BaseStation, owner, SLE_UINT8),
406  SLE_VAR(BaseStation, facilities, SLE_UINT8),
407  SLE_VAR(BaseStation, build_date, SLE_INT32),
408 
409  /* Used by newstations for graphic variations */
410  SLE_VAR(BaseStation, random_bits, SLE_UINT16),
411  SLE_VAR(BaseStation, waiting_triggers, SLE_UINT8),
412  SLE_VAR(BaseStation, num_specs, SLE_UINT8),
413 
414  SLE_END()
415 };
416 
417 static OldPersistentStorage _old_st_persistent_storage;
418 
419 static const SaveLoad _station_desc[] = {
420  SLE_WRITEBYTE(Station, facilities),
421  SLE_ST_INCLUDE(),
422 
423  SLE_VAR(Station, train_station.tile, SLE_UINT32),
424  SLE_VAR(Station, train_station.w, SLE_FILE_U8 | SLE_VAR_U16),
425  SLE_VAR(Station, train_station.h, SLE_FILE_U8 | SLE_VAR_U16),
426 
427  SLE_REF(Station, bus_stops, REF_ROADSTOPS),
428  SLE_REF(Station, truck_stops, REF_ROADSTOPS),
430  SLE_CONDVAR(Station, ship_station.tile, SLE_UINT32, SLV_MULTITILE_DOCKS, SL_MAX_VERSION),
431  SLE_CONDVAR(Station, ship_station.w, SLE_FILE_U8 | SLE_VAR_U16, SLV_MULTITILE_DOCKS, SL_MAX_VERSION),
432  SLE_CONDVAR(Station, ship_station.h, SLE_FILE_U8 | SLE_VAR_U16, SLV_MULTITILE_DOCKS, SL_MAX_VERSION),
433  SLE_CONDVAR(Station, docking_station.tile, SLE_UINT32, SLV_MULTITILE_DOCKS, SL_MAX_VERSION),
434  SLE_CONDVAR(Station, docking_station.w, SLE_FILE_U8 | SLE_VAR_U16, SLV_MULTITILE_DOCKS, SL_MAX_VERSION),
435  SLE_CONDVAR(Station, docking_station.h, SLE_FILE_U8 | SLE_VAR_U16, SLV_MULTITILE_DOCKS, SL_MAX_VERSION),
436  SLE_VAR(Station, airport.tile, SLE_UINT32),
437  SLE_CONDVAR(Station, airport.w, SLE_FILE_U8 | SLE_VAR_U16, SLV_140, SL_MAX_VERSION),
438  SLE_CONDVAR(Station, airport.h, SLE_FILE_U8 | SLE_VAR_U16, SLV_140, SL_MAX_VERSION),
439  SLE_VAR(Station, airport.type, SLE_UINT8),
440  SLE_CONDVAR(Station, airport.layout, SLE_UINT8, SLV_145, SL_MAX_VERSION),
441  SLE_VAR(Station, airport.flags, SLE_UINT64),
442  SLE_CONDVAR(Station, airport.rotation, SLE_UINT8, SLV_145, SL_MAX_VERSION),
443  SLEG_CONDARR(_old_st_persistent_storage.storage, SLE_UINT32, 16, SLV_145, SLV_161),
445 
446  SLE_VAR(Station, indtype, SLE_UINT8),
447 
448  SLE_VAR(Station, time_since_load, SLE_UINT8),
449  SLE_VAR(Station, time_since_unload, SLE_UINT8),
450  SLE_VAR(Station, last_vehicle_type, SLE_UINT8),
451  SLE_VAR(Station, had_vehicle_of_type, SLE_UINT8),
452  SLE_LST(Station, loading_vehicles, REF_VEHICLE),
453  SLE_CONDVAR(Station, always_accepted, SLE_FILE_U32 | SLE_VAR_U64, SLV_127, SLV_EXTEND_CARGOTYPES),
454  SLE_CONDVAR(Station, always_accepted, SLE_UINT64, SLV_EXTEND_CARGOTYPES, SL_MAX_VERSION),
455 
456  SLE_END()
457 };
458 
459 static const SaveLoad _waypoint_desc[] = {
460  SLE_WRITEBYTE(Waypoint, facilities),
461  SLE_ST_INCLUDE(),
462 
463  SLE_VAR(Waypoint, town_cn, SLE_UINT16),
464 
465  SLE_CONDVAR(Waypoint, train_station.tile, SLE_UINT32, SLV_124, SL_MAX_VERSION),
466  SLE_CONDVAR(Waypoint, train_station.w, SLE_FILE_U8 | SLE_VAR_U16, SLV_124, SL_MAX_VERSION),
467  SLE_CONDVAR(Waypoint, train_station.h, SLE_FILE_U8 | SLE_VAR_U16, SLV_124, SL_MAX_VERSION),
468 
469  SLE_END()
470 };
471 
477 {
478  return _base_station_desc;
479 }
480 
481 static void RealSave_STNN(BaseStation *bst)
482 {
483  bool waypoint = (bst->facilities & FACIL_WAYPOINT) != 0;
484  SlObject(bst, waypoint ? _waypoint_desc : _station_desc);
485 
486  if (!waypoint) {
487  Station *st = Station::From(bst);
488  for (CargoID i = 0; i < NUM_CARGO; i++) {
489  _num_dests = (uint32)st->goods[i].cargo.Packets()->MapSize();
490  _num_flows = 0;
491  for (FlowStatMap::const_iterator it(st->goods[i].flows.begin()); it != st->goods[i].flows.end(); ++it) {
492  _num_flows += (uint32)it->second.GetShares()->size();
493  }
494  SlObject(&st->goods[i], GetGoodsDesc());
495  for (FlowStatMap::const_iterator outer_it(st->goods[i].flows.begin()); outer_it != st->goods[i].flows.end(); ++outer_it) {
496  const FlowStat::SharesMap *shares = outer_it->second.GetShares();
497  uint32 sum_shares = 0;
498  FlowSaveLoad flow;
499  flow.source = outer_it->first;
500  for (FlowStat::SharesMap::const_iterator inner_it(shares->begin()); inner_it != shares->end(); ++inner_it) {
501  flow.via = inner_it->second;
502  flow.share = inner_it->first - sum_shares;
503  flow.restricted = inner_it->first > outer_it->second.GetUnrestricted();
504  sum_shares = inner_it->first;
505  assert(flow.share > 0);
506  SlObject(&flow, _flow_desc);
507  }
508  }
509  for (StationCargoPacketMap::ConstMapIterator it(st->goods[i].cargo.Packets()->begin()); it != st->goods[i].cargo.Packets()->end(); ++it) {
510  SlObject(const_cast<StationCargoPacketMap::value_type *>(&(*it)), _cargo_list_desc);
511  }
512  }
513  }
514 
515  for (uint i = 0; i < bst->num_specs; i++) {
516  SlObject(&bst->speclist[i], _station_speclist_desc);
517  }
518 }
519 
520 static void Save_STNN()
521 {
522  /* Write the stations */
523  for (BaseStation *st : BaseStation::Iterate()) {
524  SlSetArrayIndex(st->index);
525  SlAutolength((AutolengthProc*)RealSave_STNN, st);
526  }
527 }
528 
529 static void Load_STNN()
530 {
531  _num_flows = 0;
532 
534  int index;
535  while ((index = SlIterateArray()) != -1) {
536  bool waypoint = (SlReadByte() & FACIL_WAYPOINT) != 0;
537 
538  BaseStation *bst = waypoint ? (BaseStation *)new (index) Waypoint() : new (index) Station();
539  SlObject(bst, waypoint ? _waypoint_desc : _station_desc);
540 
541  if (!waypoint) {
542  Station *st = Station::From(bst);
543 
544  /* Before savegame version 161, persistent storages were not stored in a pool. */
546  /* Store the old persistent storage. The GRFID will be added later. */
548  st->airport.psa = new PersistentStorage(0, 0, 0);
549  memcpy(st->airport.psa->storage, _old_st_persistent_storage.storage, sizeof(_old_st_persistent_storage.storage));
550  }
551 
552  for (CargoID i = 0; i < num_cargo; i++) {
553  SlObject(&st->goods[i], GetGoodsDesc());
554  FlowSaveLoad flow;
555  FlowStat *fs = nullptr;
556  StationID prev_source = INVALID_STATION;
557  for (uint32 j = 0; j < _num_flows; ++j) {
558  SlObject(&flow, _flow_desc);
559  if (fs == nullptr || prev_source != flow.source) {
560  fs = &(st->goods[i].flows.insert(std::make_pair(flow.source, FlowStat(flow.via, flow.share, flow.restricted))).first->second);
561  } else {
562  fs->AppendShare(flow.via, flow.share, flow.restricted);
563  }
564  prev_source = flow.source;
565  }
567  SwapPackets(&st->goods[i]);
568  } else {
569  StationCargoPair pair;
570  for (uint j = 0; j < _num_dests; ++j) {
571  SlObject(&pair, _cargo_list_desc);
572  const_cast<StationCargoPacketMap &>(*(st->goods[i].cargo.Packets()))[pair.first].swap(pair.second);
573  assert(pair.second.empty());
574  }
575  }
576  }
577  }
578 
579  if (bst->num_specs != 0) {
580  /* Allocate speclist memory when loading a game */
581  bst->speclist = CallocT<StationSpecList>(bst->num_specs);
582  for (uint i = 0; i < bst->num_specs; i++) {
583  SlObject(&bst->speclist[i], _station_speclist_desc);
584  }
585  }
586  }
587 }
588 
589 static void Ptrs_STNN()
590 {
591  /* Don't run when savegame version lower than 123. */
592  if (IsSavegameVersionBefore(SLV_123)) return;
593 
595  for (Station *st : Station::Iterate()) {
596  for (CargoID i = 0; i < num_cargo; i++) {
597  GoodsEntry *ge = &st->goods[i];
599  SwapPackets(ge);
600  SlObject(ge, GetGoodsDesc());
601  SwapPackets(ge);
602  } else {
603  SlObject(ge, GetGoodsDesc());
604  for (StationCargoPacketMap::ConstMapIterator it = ge->cargo.Packets()->begin(); it != ge->cargo.Packets()->end(); ++it) {
605  SlObject(const_cast<StationCargoPair *>(&(*it)), _cargo_list_desc);
606  }
607  }
608  }
609  SlObject(st, _station_desc);
610  }
611 
612  for (Waypoint *wp : Waypoint::Iterate()) {
613  SlObject(wp, _waypoint_desc);
614  }
615 }
616 
617 static void Save_ROADSTOP()
618 {
619  for (RoadStop *rs : RoadStop::Iterate()) {
620  SlSetArrayIndex(rs->index);
621  SlObject(rs, _roadstop_desc);
622  }
623 }
624 
625 static void Load_ROADSTOP()
626 {
627  int index;
628 
629  while ((index = SlIterateArray()) != -1) {
630  RoadStop *rs = new (index) RoadStop(INVALID_TILE);
631 
632  SlObject(rs, _roadstop_desc);
633  }
634 }
635 
636 static void Ptrs_ROADSTOP()
637 {
638  for (RoadStop *rs : RoadStop::Iterate()) {
639  SlObject(rs, _roadstop_desc);
640  }
641 }
642 
643 extern const ChunkHandler _station_chunk_handlers[] = {
644  { 'STNS', nullptr, Load_STNS, Ptrs_STNS, nullptr, CH_ARRAY },
645  { 'STNN', Save_STNN, Load_STNN, Ptrs_STNN, nullptr, CH_ARRAY },
646  { 'ROAD', Save_ROADSTOP, Load_ROADSTOP, Ptrs_ROADSTOP, nullptr, CH_ARRAY | CH_LAST},
647 };
#define SLE_CONDNULL(length, from, to)
Empty space in some savegame versions.
Definition: saveload.h:644
StationFacility facilities
The facilities that this station has.
127 17439
Definition: saveload.h:194
44 8144
Definition: saveload.h:94
uint16 town_cn
The N-1th waypoint for this town (consecutive number)
Definition: waypoint_base.h:17
static bool IsSavegameVersionBefore(SaveLoadVersion major, byte minor=0)
Checks whether the savegame is below major.
Definition: saveload.h:765
TileArea bus_station
Tile area the bus &#39;station&#39; part covers.
Definition: station_base.h:460
2.0 0.3.0 2.1 0.3.1, 0.3.2
Definition: saveload.h:33
#define SLE_CONDSTR(base, variable, type, length, from, to)
Storage of a string in some savegame versions.
Definition: saveload.h:568
#define SLE_CONDREF(base, variable, type, from, to)
Storage of a reference in some savegame versions.
Definition: saveload.h:546
uint8 num_specs
Number of specs in the speclist.
Train vehicle type.
Definition: vehicle_type.h:24
Northwest.
#define SLE_LST(base, variable, type)
Storage of a list in every savegame version.
Definition: saveload.h:630
51 8978
Definition: saveload.h:103
26 4466
Definition: saveload.h:73
Ship vehicle type.
Definition: vehicle_type.h:26
#define SLE_REF(base, variable, type)
Storage of a reference in every version of a savegame.
Definition: saveload.h:604
Maximal number of cargo types in a game.
Definition: cargo_type.h:64
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
103 14598
Definition: saveload.h:165
145 20376
Definition: saveload.h:216
static void UpdateWaypointOrder(Order *o)
Update the buoy orders to be waypoint orders.
Definition: station_sl.cpp:26
25 4259
Definition: saveload.h:72
TileArea train_station
Tile area the train &#39;station&#39; part covers.
Vehicle data structure.
Definition: vehicle_base.h:210
static bool IsExpected(const BaseStation *st)
Helper for checking whether the given station is of this type.
StationRect rect
NOSAVE: Station spread out rectangle maintained by StationRect::xxx() functions.
Stores station stats for a single cargo.
Definition: station_base.h:170
Load/save a reference to a town.
Definition: saveload.h:375
Representation of a waypoint.
Definition: waypoint_base.h:16
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
const SaveLoad * GetBaseStationDescription()
Get the base station description to be used for SL_ST_INCLUDE.
Definition: station_sl.cpp:476
StationCargoList cargo
The cargo packets of cargo waiting in this station.
Definition: station_base.h:255
static bool IsDriveThroughStopTile(TileIndex t)
Is tile t a drive through road stop station?
Definition: station_map.h:233
Town * town
The town this station is associated with.
void MoveBuoysToWaypoints()
Perform all steps to upgrade from the old station buoys to the new version that uses waypoints...
Definition: station_sl.cpp:40
#define SLE_CONDLST(base, variable, type, from, to)
Storage of a list in some savegame versions.
Definition: saveload.h:578
void StationUpdateCachedTriggers(BaseStation *st)
Update the cached animation trigger bitmask for a station.
#define SLEG_CONDARR(variable, type, length, from, to)
Storage of a global array in some savegame versions.
Definition: saveload.h:692
GoodsEntry goods[NUM_CARGO]
Goods at this station.
Definition: station_base.h:479
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.
static Station * From(BaseStation *st)
Converts a BaseStation to SpecializedStation with type checking.
static 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:248
57 9691
Definition: saveload.h:110
byte delete_ctr
Delete counter. If greater than 0 then it is decremented until it reaches 0; the waypoint is then is ...
Order * next
Pointer to next order. If nullptr, end of list.
Definition: order_base.h:49
Class for persistent storage of data.
Station is a waypoint (NewGRF only!)
Definition: station_type.h:70
150 20857
Definition: saveload.h:222
Load/save a reference to a bus/truck stop.
Definition: saveload.h:377
122 16855
Definition: saveload.h:188
Shared order list linking together the linked list of orders and the list of vehicles sharing this or...
Definition: order_base.h:250
Hand-rolled multimap as map of lists.
Definition: multimap.hpp:17
The tile has no ownership.
Definition: company_type.h:25
Functions/types related to saving and loading games.
#define SLE_CONDVAR(base, variable, type, from, to)
Storage of a variable in some savegame versions.
Definition: saveload.h:536
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
68 10266
Definition: saveload.h:123
RoadStop * truck_stops
All the truck stops.
Definition: station_base.h:461
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
const SaveLoad * GetGoodsDesc()
Wrapper function to get the GoodsEntry&#39;s internal structure while some of the variables itself are pr...
Definition: station_sl.cpp:270
Highest possible saveload version.
Definition: saveload.h:306
allow control codes in the strings
Definition: saveload.h:472
5.0 1429 5.1 1440 5.2 1525 0.3.6
Definition: saveload.h:42
First savegame version.
Definition: saveload.h:30
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition: order_base.h:61
TileArea truck_station
Tile area the truck &#39;station&#39; part covers.
Definition: station_base.h:462
static Owner GetTileOwner(TileIndex tile)
Returns the owner of a tile.
Definition: tile_map.h:178
void AfterLoadScanDockingTiles()
(Re)scan for station docking tiles after loading a savegame.
Definition: station_sl.cpp:147
byte status
Status of this cargo, see GoodsEntryStatus.
Definition: station_base.h:226
Container for cargo from the same location and time.
Definition: cargopacket.h:42
#define TILE_AREA_LOOP(var, ta)
A loop which iterates over the tiles of a TileArea.
#define SLE_WRITEBYTE(base, variable)
Translate values ingame to different values in the savegame and vv.
Definition: saveload.h:647
TileExtended * _me
Extended Tiles of the map.
Definition: map.cpp:31
struct RoadStop * next
Next stop of the given type at this station.
Definition: roadstop_base.h:69
TYPE storage[SIZE]
Memory to for the storage array.
static bool IsBuoyTile(TileIndex t)
Is tile t a buoy tile?
Definition: station_map.h:316
Represents the covered area of e.g.
Definition: tilearea_type.h:16
Class for pooled persistent storage of data.
StationSpecList * speclist
List of station specs of this station.
55 9638
Definition: saveload.h:108
PersistentStorage * psa
Persistent storage for NewGRF airports.
Definition: station_base.h:313
84 11822
Definition: saveload.h:142
183 25363 Cargodist
Definition: saveload.h:261
byte SlReadByte()
Wrapper for reading a byte from the buffer.
Definition: saveload.cpp:414
uint32 StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
6.0 1721 6.1 1768
Definition: saveload.h:45
123 16909
Definition: saveload.h:189
int SlIterateArray()
Iterate through the elements of an array and read the whole thing.
Definition: saveload.cpp:637
Load/save a reference to a vehicle.
Definition: saveload.h:373
124 16993
Definition: saveload.h:190
RoadStop * bus_stops
All the road stops.
Definition: station_base.h:459
Handlers and description of chunk.
Definition: saveload.h:357
static void SwapPackets(GoodsEntry *ge)
Swap the temporary packets with the packets without specific destination in the given goods entry...
Definition: station_sl.cpp:313
FlowStatMap flows
Planned flows through this station.
Definition: station_base.h:259
#define SLEG_CONDVAR(variable, type, from, to)
Storage of a global variable in some savegame versions.
Definition: saveload.h:673
#define SLE_END()
End marker of a struct/class save or load.
Definition: saveload.h:653
Station with an airport.
Definition: station_type.h:55
9.0 1909
Definition: saveload.h:49
Station with a dock.
Definition: station_type.h:56
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
Definition: station_map.h:28
3.x lost
Definition: saveload.h:35
7.0 1770
Definition: saveload.h:47
Load/save a reference to a cargo packet.
Definition: saveload.h:379
DestinationID GetDestination() const
Gets the destination of this order.
Definition: order_base.h:94
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:378
181 25012
Definition: saveload.h:259
size_t MapSize() const
Count the number of ranges with equal keys in this MultiMap.
Definition: multimap.hpp:350
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:78
14.0 2441
Definition: saveload.h:56
Station is a waypoint.
Definition: station_type.h:57
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
void AppendShare(StationID st, uint flow, bool restricted=false)
Add some flow to the end of the shares map.
Definition: station_base.h:70
A tile of a station.
Definition: tile_type.h:46
void SlObject(void *object, const SaveLoad *sld)
Main SaveLoad function.
Definition: saveload.cpp:1546
Town data structure.
Definition: town.h:53
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
Flow statistics telling how much flow should be sent along a link.
Definition: station_base.h:36
char * name
Custom town name. If nullptr, the town was not renamed and uses the generated name.
Definition: town.h:62
A Stop for a Road Vehicle.
Definition: roadstop_base.h:22
65 10210
Definition: saveload.h:120
Owner owner
The owner of this station.
void SlAutolength(AutolengthProc *proc, void *arg)
Do something of which I have no idea what it is :P.
Definition: saveload.cpp:1574
int32 Date
The type to store our dates in.
Definition: date_type.h:14
Airport airport
Tile area the airport covers.
Definition: station_base.h:464
140 19382
Definition: saveload.h:210
void MakeGoToWaypoint(StationID destination)
Makes this order a Go To Waypoint order.
Definition: order_cmd.cpp:103
SaveLoad type struct.
Definition: saveload.h:498
#define SLE_VAR(base, variable, type)
Storage of a variable in every version of a savegame.
Definition: saveload.h:596
45 8501
Definition: saveload.h:96
const Tcont * Packets() const
Returns a pointer to the cargo packet list (so you can iterate over it etc).
Definition: cargopacket.h:246
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
static const TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:83
#define SLE_STR(base, variable, type, length)
Storage of a string in every savegame version.
Definition: saveload.h:622
Northeast, upper right on your monitor.
216 PR#7380 Multiple docks per station.
Definition: saveload.h:302
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
161 22567
Definition: saveload.h:235
Station with train station.
Definition: station_type.h:52
Non-zero when the entries on this road stop are the primary, i.e. the ones to delete.
Definition: roadstop_base.h:27
199 PR#6802 Extend cargotypes to 64
Definition: saveload.h:281
187 25899 Linkgraph - restricted flows
Definition: saveload.h:266
31 5999
Definition: saveload.h:79
static Station * Get(size_t index)
Gets station with given index.
char * name
Custom name.
46 8705
Definition: saveload.h:97
StringID string_id
Default name (town area) of station.
27 4757
Definition: saveload.h:74
void Append(CargoPacket *cp, StationID next)
Appends the given cargo packet to the range of packets with the same next station.
Base class for all station-ish types.
Station data structure.
Definition: station_base.h:450
Set when the station accepts the cargo currently for final deliveries.
Definition: station_base.h:177
#define SLEG_CONDLST(variable, type, from, to)
Storage of a global list in some savegame versions.
Definition: saveload.h:711
Date build_date
Date of construction.
void AfterLoadRoadStops()
(Re)building of road stop caches after loading a savegame.
Definition: station_sl.cpp:129
Last chunk in this array.
Definition: saveload.h:392
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
Load/save a reference to a persistent storage.
Definition: saveload.h:381