OpenTTD

- Main Page
- Related Pages
- Modules
- Namespaces
- Data Structures
- Files

- File List
- Globals

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
35 o->MakeGoToWaypoint(o->GetDestination());
36 }
37
42 void MoveBuoysToWaypoints()
43 {
44 /* Buoy orders become waypoint orders */
45 OrderList *ol;
46 FOR_ALL_ORDER_LISTS(ol) {
47 VehicleType vt = ol->GetFirstSharedVehicle()->type;
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
58 UpdateWaypointOrder(&v->current_order);
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
128 StationUpdateCachedTriggers(st);
129 }
130 }
131
135 void AfterLoadRoadStops()
136 {
137 /* First construct the drive through entries */
138 RoadStop *rs;
139 FOR_ALL_ROADSTOPS(rs) {
140 if (IsDriveThroughStopTile(rs->xy)) rs->MakeDriveThrough();
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
160 SLE_REF(RoadStop, next, REF_ROADSTOPS),
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),
186 SLE_CONDSTR(Station, name, SLE_STR | SLF_ALLOW_CONTROL, 0, 84, SL_MAX_VERSION),
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
212 SLE_CONDREF(Station, bus_stops, REF_ROADSTOPS, 6, SL_MAX_VERSION),
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) */
223 SLE_CONDNULL(32, 2, SL_MAX_VERSION),
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
266 const SaveLoad *GetGoodsDesc()
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. */
351 assert(CargoPacket::CanAllocateItem());
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),
395 SLE_STR(BaseStation, name, SLE_STR | SLF_ALLOW_CONTROL, 0),
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
461 const SaveLoad *GetBaseStationDescription()
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. */
529 if (IsSavegameVersionBefore(161) && !IsSavegameVersionBefore(145) && st->facilities & FACIL_AIRPORT) {
530 /* Store the old persistent storage. The GRFID will be added later. */
531 assert(PersistentStorage::CanAllocateItem());
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 };