OpenTTD
station_sl.cpp
Go to the documentation of this file.
1 /* $Id: station_sl.cpp 26878 2014-09-21 11:23:33Z rubidium $ */
2 
3 /*
4  * This file is part of OpenTTD.
5  * 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.
6  * 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.
7  * 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/>.
8  */
9 
12 #include "../stdafx.h"
13 #include "../station_base.h"
14 #include "../waypoint_base.h"
15 #include "../roadstop_base.h"
16 #include "../vehicle_base.h"
17 #include "../newgrf_station.h"
18 
19 #include "saveload.h"
20 #include "table/strings.h"
21 
22 #include "../safeguards.h"
23 
28 static void UpdateWaypointOrder(Order *o)
29 {
30  if (!o->IsType(OT_GOTO_STATION)) return;
31 
32  const Station *st = Station::Get(o->GetDestination());
33  if ((st->had_vehicle_of_type & HVOT_WAYPOINT) == 0) return;
34 
36 }
37 
43 {
44  /* Buoy orders become waypoint orders */
45  OrderList *ol;
46  FOR_ALL_ORDER_LISTS(ol) {
48  if (vt != VEH_SHIP && vt != VEH_TRAIN) continue;
49 
50  for (Order *o = ol->GetFirstOrder(); o != NULL; o = o->next) UpdateWaypointOrder(o);
51  }
52 
53  Vehicle *v;
54  FOR_ALL_VEHICLES(v) {
55  VehicleType vt = v->type;
56  if (vt != VEH_SHIP && vt != VEH_TRAIN) continue;
57 
59  }
60 
61  /* Now make the stations waypoints */
62  Station *st;
63  FOR_ALL_STATIONS(st) {
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  char *name = st->name;
71  st->name = NULL;
72  Date build_date = st->build_date;
73  /* TTDPatch could use "buoys with rail station" for rail waypoints */
74  bool train = st->train_station.tile != INVALID_TILE;
75  TileArea train_st = st->train_station;
76 
77  /* Delete the station, so we can make it a real waypoint. */
78  delete st;
79 
80  /* Stations and waypoints are in the same pool, so if a station
81  * is deleted there must be place for a Waypoint. */
82  assert(Waypoint::CanAllocateItem());
83  Waypoint *wp = new (index) Waypoint(xy);
84  wp->town = town;
85  wp->string_id = train ? STR_SV_STNAME_WAYPOINT : STR_SV_STNAME_BUOY;
86  wp->name = name;
87  wp->delete_ctr = 0; // Just reset delete counter for once.
88  wp->build_date = build_date;
89  wp->owner = train ? GetTileOwner(xy) : OWNER_NONE;
90 
91  if (IsInsideBS(string_id, STR_SV_STNAME_BUOY, 9)) wp->town_cn = string_id - STR_SV_STNAME_BUOY;
92 
93  if (train) {
94  /* When we make a rail waypoint of the station, convert the map as well. */
95  TILE_AREA_LOOP(t, train_st) {
96  if (!IsTileType(t, MP_STATION) || GetStationIndex(t) != index) continue;
97 
98  SB(_me[t].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  BaseStation *st;
115  FOR_ALL_BASE_STATIONS(st) {
116  for (uint i = 0; i < st->num_specs; i++) {
117  if (st->speclist[i].grfid == 0) continue;
118 
119  st->speclist[i].spec = StationClass::GetByGrf(st->speclist[i].grfid, st->speclist[i].localidx, NULL);
120  }
121 
122  if (Station::IsExpected(st)) {
123  Station *sta = Station::From(st);
124  for (const RoadStop *rs = sta->bus_stops; rs != NULL; rs = rs->next) sta->bus_station.Add(rs->xy);
125  for (const RoadStop *rs = sta->truck_stops; rs != NULL; rs = rs->next) sta->truck_station.Add(rs->xy);
126  }
127 
129  }
130 }
131 
136 {
137  /* First construct the drive through entries */
138  RoadStop *rs;
139  FOR_ALL_ROADSTOPS(rs) {
141  }
142  /* And then rebuild the data in those entries */
143  FOR_ALL_ROADSTOPS(rs) {
144  if (!HasBit(rs->status, RoadStop::RSSFB_BASE_ENTRY)) continue;
145 
146  rs->GetEntry(DIAGDIR_NE)->Rebuild(rs);
147  rs->GetEntry(DIAGDIR_NW)->Rebuild(rs);
148  }
149 }
150 
151 static const SaveLoad _roadstop_desc[] = {
152  SLE_VAR(RoadStop, xy, SLE_UINT32),
153  SLE_CONDNULL(1, 0, 44),
154  SLE_VAR(RoadStop, status, SLE_UINT8),
155  /* Index was saved in some versions, but this is not needed */
156  SLE_CONDNULL(4, 0, 8),
157  SLE_CONDNULL(2, 0, 44),
158  SLE_CONDNULL(1, 0, 25),
159 
161  SLE_CONDNULL(2, 0, 44),
162 
163  SLE_CONDNULL(4, 0, 24),
164  SLE_CONDNULL(1, 25, 25),
165 
166  SLE_END()
167 };
168 
169 static const SaveLoad _old_station_desc[] = {
170  SLE_CONDVAR(Station, xy, SLE_FILE_U16 | SLE_VAR_U32, 0, 5),
171  SLE_CONDVAR(Station, xy, SLE_UINT32, 6, SL_MAX_VERSION),
172  SLE_CONDNULL(4, 0, 5),
173  SLE_CONDVAR(Station, train_station.tile, SLE_FILE_U16 | SLE_VAR_U32, 0, 5),
174  SLE_CONDVAR(Station, train_station.tile, SLE_UINT32, 6, SL_MAX_VERSION),
175  SLE_CONDVAR(Station, airport.tile, SLE_FILE_U16 | SLE_VAR_U32, 0, 5),
176  SLE_CONDVAR(Station, airport.tile, SLE_UINT32, 6, SL_MAX_VERSION),
177  SLE_CONDVAR(Station, dock_tile, SLE_FILE_U16 | SLE_VAR_U32, 0, 5),
178  SLE_CONDVAR(Station, dock_tile, SLE_UINT32, 6, SL_MAX_VERSION),
179  SLE_REF(Station, town, REF_TOWN),
180  SLE_VAR(Station, train_station.w, SLE_FILE_U8 | SLE_VAR_U16),
181  SLE_CONDVAR(Station, train_station.h, SLE_FILE_U8 | SLE_VAR_U16, 2, SL_MAX_VERSION),
182 
183  SLE_CONDNULL(1, 0, 3),
184 
185  SLE_VAR(Station, string_id, SLE_STRINGID),
187  SLE_CONDVAR(Station, indtype, SLE_UINT8, 103, SL_MAX_VERSION),
188  SLE_CONDVAR(Station, had_vehicle_of_type, SLE_FILE_U16 | SLE_VAR_U8, 0, 121),
189  SLE_CONDVAR(Station, had_vehicle_of_type, SLE_UINT8, 122, SL_MAX_VERSION),
190 
191  SLE_VAR(Station, time_since_load, SLE_UINT8),
192  SLE_VAR(Station, time_since_unload, SLE_UINT8),
193  SLE_VAR(Station, delete_ctr, SLE_UINT8),
194  SLE_VAR(Station, owner, SLE_UINT8),
195  SLE_VAR(Station, facilities, SLE_UINT8),
196  SLE_VAR(Station, airport.type, SLE_UINT8),
197 
198  SLE_CONDNULL(2, 0, 5),
199  SLE_CONDNULL(1, 0, 4),
200 
201  SLE_CONDVAR(Station, airport.flags, SLE_VAR_U64 | SLE_FILE_U16, 0, 2),
202  SLE_CONDVAR(Station, airport.flags, SLE_VAR_U64 | SLE_FILE_U32, 3, 45),
203  SLE_CONDVAR(Station, airport.flags, SLE_UINT64, 46, SL_MAX_VERSION),
204 
205  SLE_CONDNULL(2, 0, 25),
206  SLE_CONDVAR(Station, last_vehicle_type, SLE_UINT8, 26, SL_MAX_VERSION),
207 
208  SLE_CONDNULL(2, 3, 25),
209  SLE_CONDVAR(Station, build_date, SLE_FILE_U16 | SLE_VAR_I32, 3, 30),
210  SLE_CONDVAR(Station, build_date, SLE_INT32, 31, SL_MAX_VERSION),
211 
213  SLE_CONDREF(Station, truck_stops, REF_ROADSTOPS, 6, SL_MAX_VERSION),
214 
215  /* Used by newstations for graphic variations */
216  SLE_CONDVAR(Station, random_bits, SLE_UINT16, 27, SL_MAX_VERSION),
217  SLE_CONDVAR(Station, waiting_triggers, SLE_UINT8, 27, SL_MAX_VERSION),
218  SLE_CONDVAR(Station, num_specs, SLE_UINT8, 27, SL_MAX_VERSION),
219 
220  SLE_CONDLST(Station, loading_vehicles, REF_VEHICLE, 57, SL_MAX_VERSION),
221 
222  /* reserve extra space in savegame here. (currently 32 bytes) */
224 
225  SLE_END()
226 };
227 
228 static uint16 _waiting_acceptance;
229 static uint32 _num_flows;
230 static uint16 _cargo_source;
231 static uint32 _cargo_source_xy;
232 static uint8 _cargo_days;
233 static Money _cargo_feeder_share;
234 
235 static const SaveLoad _station_speclist_desc[] = {
236  SLE_CONDVAR(StationSpecList, grfid, SLE_UINT32, 27, SL_MAX_VERSION),
237  SLE_CONDVAR(StationSpecList, localidx, SLE_UINT8, 27, SL_MAX_VERSION),
238 
239  SLE_END()
240 };
241 
242 std::list<CargoPacket *> _packets;
243 uint32 _num_dests;
244 
245 struct FlowSaveLoad {
246  FlowSaveLoad() : source(0), via(0), share(0), restricted(false) {}
247  StationID source;
248  StationID via;
249  uint32 share;
250  bool restricted;
251 };
252 
253 static const SaveLoad _flow_desc[] = {
254  SLE_VAR(FlowSaveLoad, source, SLE_UINT16),
255  SLE_VAR(FlowSaveLoad, via, SLE_UINT16),
256  SLE_VAR(FlowSaveLoad, share, SLE_UINT32),
257  SLE_CONDVAR(FlowSaveLoad, restricted, SLE_BOOL, 187, SL_MAX_VERSION),
258  SLE_END()
259 };
260 
267 {
268  static const SaveLoad goods_desc[] = {
269  SLEG_CONDVAR( _waiting_acceptance, SLE_UINT16, 0, 67),
270  SLE_CONDVAR(GoodsEntry, status, SLE_UINT8, 68, SL_MAX_VERSION),
271  SLE_CONDNULL(2, 51, 67),
272  SLE_VAR(GoodsEntry, time_since_pickup, SLE_UINT8),
273  SLE_VAR(GoodsEntry, rating, SLE_UINT8),
274  SLEG_CONDVAR( _cargo_source, SLE_FILE_U8 | SLE_VAR_U16, 0, 6),
275  SLEG_CONDVAR( _cargo_source, SLE_UINT16, 7, 67),
276  SLEG_CONDVAR( _cargo_source_xy, SLE_UINT32, 44, 67),
277  SLEG_CONDVAR( _cargo_days, SLE_UINT8, 0, 67),
278  SLE_VAR(GoodsEntry, last_speed, SLE_UINT8),
279  SLE_VAR(GoodsEntry, last_age, SLE_UINT8),
280  SLEG_CONDVAR( _cargo_feeder_share, SLE_FILE_U32 | SLE_VAR_I64, 14, 64),
281  SLEG_CONDVAR( _cargo_feeder_share, SLE_INT64, 65, 67),
282  SLE_CONDVAR(GoodsEntry, amount_fract, SLE_UINT8, 150, SL_MAX_VERSION),
283  SLEG_CONDLST( _packets, REF_CARGO_PACKET, 68, 182),
284  SLEG_CONDVAR( _num_dests, SLE_UINT32, 183, SL_MAX_VERSION),
285  SLE_CONDVAR(GoodsEntry, cargo.reserved_count, SLE_UINT, 181, SL_MAX_VERSION),
286  SLE_CONDVAR(GoodsEntry, link_graph, SLE_UINT16, 183, SL_MAX_VERSION),
287  SLE_CONDVAR(GoodsEntry, node, SLE_UINT16, 183, SL_MAX_VERSION),
288  SLEG_CONDVAR( _num_flows, SLE_UINT32, 183, SL_MAX_VERSION),
289  SLE_CONDVAR(GoodsEntry, max_waiting_cargo, SLE_UINT32, 183, SL_MAX_VERSION),
290  SLE_END()
291  };
292 
293  return goods_desc;
294 }
295 
296 typedef std::pair<const StationID, std::list<CargoPacket *> > StationCargoPair;
297 
298 static const SaveLoad _cargo_list_desc[] = {
299  SLE_VAR(StationCargoPair, first, SLE_UINT16),
300  SLE_LST(StationCargoPair, second, REF_CARGO_PACKET),
301  SLE_END()
302 };
303 
309 static void SwapPackets(GoodsEntry *ge)
310 {
311  StationCargoPacketMap &ge_packets = const_cast<StationCargoPacketMap &>(*ge->cargo.Packets());
312 
313  if (_packets.empty()) {
314  std::map<StationID, std::list<CargoPacket *> >::iterator it(ge_packets.find(INVALID_STATION));
315  if (it == ge_packets.end()) {
316  return;
317  } else {
318  it->second.swap(_packets);
319  }
320  } else {
321  assert(ge_packets[INVALID_STATION].empty());
322  ge_packets[INVALID_STATION].swap(_packets);
323  }
324 }
325 
326 static void Load_STNS()
327 {
328  int index;
329  while ((index = SlIterateArray()) != -1) {
330  Station *st = new (index) Station();
331 
332  SlObject(st, _old_station_desc);
333 
334  _waiting_acceptance = 0;
335 
336  uint num_cargo = IsSavegameVersionBefore(55) ? 12 : NUM_CARGO;
337  for (CargoID i = 0; i < num_cargo; i++) {
338  GoodsEntry *ge = &st->goods[i];
339  SlObject(ge, GetGoodsDesc());
340  SwapPackets(ge);
341  if (IsSavegameVersionBefore(68)) {
342  SB(ge->status, GoodsEntry::GES_ACCEPTANCE, 1, HasBit(_waiting_acceptance, 15));
343  if (GB(_waiting_acceptance, 0, 12) != 0) {
344  /* In old versions, enroute_from used 0xFF as INVALID_STATION */
345  StationID source = (IsSavegameVersionBefore(7) && _cargo_source == 0xFF) ? INVALID_STATION : _cargo_source;
346 
347  /* Make sure we can allocate the CargoPacket. This is safe
348  * as there can only be ~64k stations and 32 cargoes in these
349  * savegame versions. As the CargoPacketPool has more than
350  * 16 million entries; it fits by an order of magnitude. */
352 
353  /* Don't construct the packet with station here, because that'll fail with old savegames */
354  CargoPacket *cp = new CargoPacket(GB(_waiting_acceptance, 0, 12), _cargo_days, source, _cargo_source_xy, _cargo_source_xy, _cargo_feeder_share);
355  ge->cargo.Append(cp, INVALID_STATION);
356  SB(ge->status, GoodsEntry::GES_RATING, 1, 1);
357  }
358  }
359  }
360 
361  if (st->num_specs != 0) {
362  /* Allocate speclist memory when loading a game */
363  st->speclist = CallocT<StationSpecList>(st->num_specs);
364  for (uint i = 0; i < st->num_specs; i++) {
365  SlObject(&st->speclist[i], _station_speclist_desc);
366  }
367  }
368  }
369 }
370 
371 static void Ptrs_STNS()
372 {
373  /* Don't run when savegame version is higher than or equal to 123. */
374  if (!IsSavegameVersionBefore(123)) return;
375 
376  Station *st;
377  FOR_ALL_STATIONS(st) {
378  if (!IsSavegameVersionBefore(68)) {
379  for (CargoID i = 0; i < NUM_CARGO; i++) {
380  GoodsEntry *ge = &st->goods[i];
381  SwapPackets(ge);
382  SlObject(ge, GetGoodsDesc());
383  SwapPackets(ge);
384  }
385  }
386  SlObject(st, _old_station_desc);
387  }
388 }
389 
390 
391 static const SaveLoad _base_station_desc[] = {
392  SLE_VAR(BaseStation, xy, SLE_UINT32),
393  SLE_REF(BaseStation, town, REF_TOWN),
394  SLE_VAR(BaseStation, string_id, SLE_STRINGID),
396  SLE_VAR(BaseStation, delete_ctr, SLE_UINT8),
397  SLE_VAR(BaseStation, owner, SLE_UINT8),
398  SLE_VAR(BaseStation, facilities, SLE_UINT8),
399  SLE_VAR(BaseStation, build_date, SLE_INT32),
400 
401  /* Used by newstations for graphic variations */
402  SLE_VAR(BaseStation, random_bits, SLE_UINT16),
403  SLE_VAR(BaseStation, waiting_triggers, SLE_UINT8),
404  SLE_VAR(BaseStation, num_specs, SLE_UINT8),
405 
406  SLE_END()
407 };
408 
409 static OldPersistentStorage _old_st_persistent_storage;
410 
411 static const SaveLoad _station_desc[] = {
412  SLE_WRITEBYTE(Station, facilities, FACIL_NONE),
413  SLE_ST_INCLUDE(),
414 
415  SLE_VAR(Station, train_station.tile, SLE_UINT32),
416  SLE_VAR(Station, train_station.w, SLE_FILE_U8 | SLE_VAR_U16),
417  SLE_VAR(Station, train_station.h, SLE_FILE_U8 | SLE_VAR_U16),
418 
419  SLE_REF(Station, bus_stops, REF_ROADSTOPS),
420  SLE_REF(Station, truck_stops, REF_ROADSTOPS),
421  SLE_VAR(Station, dock_tile, SLE_UINT32),
422  SLE_VAR(Station, airport.tile, SLE_UINT32),
423  SLE_CONDVAR(Station, airport.w, SLE_FILE_U8 | SLE_VAR_U16, 140, SL_MAX_VERSION),
424  SLE_CONDVAR(Station, airport.h, SLE_FILE_U8 | SLE_VAR_U16, 140, SL_MAX_VERSION),
425  SLE_VAR(Station, airport.type, SLE_UINT8),
426  SLE_CONDVAR(Station, airport.layout, SLE_UINT8, 145, SL_MAX_VERSION),
427  SLE_VAR(Station, airport.flags, SLE_UINT64),
428  SLE_CONDVAR(Station, airport.rotation, SLE_UINT8, 145, SL_MAX_VERSION),
429  SLEG_CONDARR(_old_st_persistent_storage.storage, SLE_UINT32, 16, 145, 160),
430  SLE_CONDREF(Station, airport.psa, REF_STORAGE, 161, SL_MAX_VERSION),
431 
432  SLE_VAR(Station, indtype, SLE_UINT8),
433 
434  SLE_VAR(Station, time_since_load, SLE_UINT8),
435  SLE_VAR(Station, time_since_unload, SLE_UINT8),
436  SLE_VAR(Station, last_vehicle_type, SLE_UINT8),
437  SLE_VAR(Station, had_vehicle_of_type, SLE_UINT8),
438  SLE_LST(Station, loading_vehicles, REF_VEHICLE),
439  SLE_CONDVAR(Station, always_accepted, SLE_UINT32, 127, SL_MAX_VERSION),
440 
441  SLE_END()
442 };
443 
444 static const SaveLoad _waypoint_desc[] = {
445  SLE_WRITEBYTE(Waypoint, facilities, FACIL_WAYPOINT),
446  SLE_ST_INCLUDE(),
447 
448  SLE_VAR(Waypoint, town_cn, SLE_UINT16),
449 
450  SLE_CONDVAR(Waypoint, train_station.tile, SLE_UINT32, 124, SL_MAX_VERSION),
451  SLE_CONDVAR(Waypoint, train_station.w, SLE_FILE_U8 | SLE_VAR_U16, 124, SL_MAX_VERSION),
452  SLE_CONDVAR(Waypoint, train_station.h, SLE_FILE_U8 | SLE_VAR_U16, 124, SL_MAX_VERSION),
453 
454  SLE_END()
455 };
456 
462 {
463  return _base_station_desc;
464 }
465 
466 static void RealSave_STNN(BaseStation *bst)
467 {
468  bool waypoint = (bst->facilities & FACIL_WAYPOINT) != 0;
469  SlObject(bst, waypoint ? _waypoint_desc : _station_desc);
470 
471  if (!waypoint) {
472  Station *st = Station::From(bst);
473  for (CargoID i = 0; i < NUM_CARGO; i++) {
474  _num_dests = (uint32)st->goods[i].cargo.Packets()->MapSize();
475  _num_flows = 0;
476  for (FlowStatMap::const_iterator it(st->goods[i].flows.begin()); it != st->goods[i].flows.end(); ++it) {
477  _num_flows += (uint32)it->second.GetShares()->size();
478  }
479  SlObject(&st->goods[i], GetGoodsDesc());
480  for (FlowStatMap::const_iterator outer_it(st->goods[i].flows.begin()); outer_it != st->goods[i].flows.end(); ++outer_it) {
481  const FlowStat::SharesMap *shares = outer_it->second.GetShares();
482  uint32 sum_shares = 0;
483  FlowSaveLoad flow;
484  flow.source = outer_it->first;
485  for (FlowStat::SharesMap::const_iterator inner_it(shares->begin()); inner_it != shares->end(); ++inner_it) {
486  flow.via = inner_it->second;
487  flow.share = inner_it->first - sum_shares;
488  flow.restricted = inner_it->first > outer_it->second.GetUnrestricted();
489  sum_shares = inner_it->first;
490  assert(flow.share > 0);
491  SlObject(&flow, _flow_desc);
492  }
493  }
494  for (StationCargoPacketMap::ConstMapIterator it(st->goods[i].cargo.Packets()->begin()); it != st->goods[i].cargo.Packets()->end(); ++it) {
495  SlObject(const_cast<StationCargoPacketMap::value_type *>(&(*it)), _cargo_list_desc);
496  }
497  }
498  }
499 
500  for (uint i = 0; i < bst->num_specs; i++) {
501  SlObject(&bst->speclist[i], _station_speclist_desc);
502  }
503 }
504 
505 static void Save_STNN()
506 {
507  BaseStation *st;
508  /* Write the stations */
509  FOR_ALL_BASE_STATIONS(st) {
510  SlSetArrayIndex(st->index);
511  SlAutolength((AutolengthProc*)RealSave_STNN, st);
512  }
513 }
514 
515 static void Load_STNN()
516 {
517  int index;
518 
519  while ((index = SlIterateArray()) != -1) {
520  bool waypoint = (SlReadByte() & FACIL_WAYPOINT) != 0;
521 
522  BaseStation *bst = waypoint ? (BaseStation *)new (index) Waypoint() : new (index) Station();
523  SlObject(bst, waypoint ? _waypoint_desc : _station_desc);
524 
525  if (!waypoint) {
526  Station *st = Station::From(bst);
527 
528  /* Before savegame version 161, persistent storages were not stored in a pool. */
530  /* Store the old persistent storage. The GRFID will be added later. */
532  st->airport.psa = new PersistentStorage(0, 0, 0);
533  memcpy(st->airport.psa->storage, _old_st_persistent_storage.storage, sizeof(st->airport.psa->storage));
534  }
535 
536  for (CargoID i = 0; i < NUM_CARGO; i++) {
537  SlObject(&st->goods[i], GetGoodsDesc());
538  FlowSaveLoad flow;
539  FlowStat *fs = NULL;
540  StationID prev_source = INVALID_STATION;
541  for (uint32 j = 0; j < _num_flows; ++j) {
542  SlObject(&flow, _flow_desc);
543  if (fs == NULL || prev_source != flow.source) {
544  fs = &(st->goods[i].flows.insert(std::make_pair(flow.source, FlowStat(flow.via, flow.share, flow.restricted))).first->second);
545  } else {
546  fs->AppendShare(flow.via, flow.share, flow.restricted);
547  }
548  prev_source = flow.source;
549  }
550  if (IsSavegameVersionBefore(183)) {
551  SwapPackets(&st->goods[i]);
552  } else {
553  StationCargoPair pair;
554  for (uint j = 0; j < _num_dests; ++j) {
555  SlObject(&pair, _cargo_list_desc);
556  const_cast<StationCargoPacketMap &>(*(st->goods[i].cargo.Packets()))[pair.first].swap(pair.second);
557  assert(pair.second.empty());
558  }
559  }
560  }
561  }
562 
563  if (bst->num_specs != 0) {
564  /* Allocate speclist memory when loading a game */
565  bst->speclist = CallocT<StationSpecList>(bst->num_specs);
566  for (uint i = 0; i < bst->num_specs; i++) {
567  SlObject(&bst->speclist[i], _station_speclist_desc);
568  }
569  }
570  }
571 }
572 
573 static void Ptrs_STNN()
574 {
575  /* Don't run when savegame version lower than 123. */
576  if (IsSavegameVersionBefore(123)) return;
577 
578  Station *st;
579  FOR_ALL_STATIONS(st) {
580  for (CargoID i = 0; i < NUM_CARGO; i++) {
581  GoodsEntry *ge = &st->goods[i];
582  if (IsSavegameVersionBefore(183)) {
583  SwapPackets(ge);
584  SlObject(ge, GetGoodsDesc());
585  SwapPackets(ge);
586  } else {
587  SlObject(ge, GetGoodsDesc());
588  for (StationCargoPacketMap::ConstMapIterator it = ge->cargo.Packets()->begin(); it != ge->cargo.Packets()->end(); ++it) {
589  SlObject(const_cast<StationCargoPair *>(&(*it)), _cargo_list_desc);
590  }
591  }
592  }
593  SlObject(st, _station_desc);
594  }
595 
596  Waypoint *wp;
597  FOR_ALL_WAYPOINTS(wp) {
598  SlObject(wp, _waypoint_desc);
599  }
600 }
601 
602 static void Save_ROADSTOP()
603 {
604  RoadStop *rs;
605 
606  FOR_ALL_ROADSTOPS(rs) {
607  SlSetArrayIndex(rs->index);
608  SlObject(rs, _roadstop_desc);
609  }
610 }
611 
612 static void Load_ROADSTOP()
613 {
614  int index;
615 
616  while ((index = SlIterateArray()) != -1) {
617  RoadStop *rs = new (index) RoadStop(INVALID_TILE);
618 
619  SlObject(rs, _roadstop_desc);
620  }
621 }
622 
623 static void Ptrs_ROADSTOP()
624 {
625  RoadStop *rs;
626  FOR_ALL_ROADSTOPS(rs) {
627  SlObject(rs, _roadstop_desc);
628  }
629 }
630 
631 extern const ChunkHandler _station_chunk_handlers[] = {
632  { 'STNS', NULL, Load_STNS, Ptrs_STNS, NULL, CH_ARRAY },
633  { 'STNN', Save_STNN, Load_STNN, Ptrs_STNN, NULL, CH_ARRAY },
634  { 'ROAD', Save_ROADSTOP, Load_ROADSTOP, Ptrs_ROADSTOP, NULL, CH_ARRAY | CH_LAST},
635 };