src/saveload/waypoint_sl.cpp

   1 /* $Id$ */
   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
  10 /** @file waypoint_sl.cpp Code handling saving and loading of waypoints */
  11
  12 #include "../stdafx.h"
  13 #include "../waypoint_base.h"
  14 #include "../newgrf_station.h"
  15 #include "../vehicle_base.h"
  16 #include "../town.h"
  17 #include "../newgrf.h"
  18
  19 #include "table/strings.h"
  20
  21 #include "saveload_internal.h"
  22
  23 #include "../safeguards.h"
  24
  25 /** Helper structure to convert from the old waypoint system. */
  26 struct OldWaypoint {
  27         size_t index;
  28         TileIndex xy;
  29         TownID town_index;
  30         Town *town;
  31         uint16 town_cn;
  32         StringID string_id;
  33         char *name;
  34         uint8 delete_ctr;
  35         Date build_date;
  36         uint8 localidx;
  37         uint32 grfid;
  38         const StationSpec *spec;
  39         OwnerByte owner;
  40
  41         size_t new_index;
  42 };
  43
  44 /** Temporary array with old waypoints. */
  45 static SmallVector<OldWaypoint, 16> _old_waypoints;
  46
  47 /**
  48  * Update the waypoint orders to get the new waypoint ID.
  49  * @param o the order 'list' to check.
  50  */
  51 static void UpdateWaypointOrder(Order *o)
  52 {
  53         if (!o->IsType(OT_GOTO_WAYPOINT)) return;
  54
  55         for (OldWaypoint *wp = _old_waypoints.Begin(); wp != _old_waypoints.End(); wp++) {
  56                 if (wp->index != o->GetDestination()) continue;
  57
  58                 o->SetDestination((DestinationID)wp->new_index);
  59                 return;
  60         }
  61 }
  62
  63 /**
  64  * Perform all steps to upgrade from the old waypoints to the new version
  65  * that uses station. This includes some old saveload mechanics.
  66  */
  67 void MoveWaypointsToBaseStations()
  68 {
  69         /* In version 17, ground type is moved from m2 to m4 for depots and
  70          * waypoints to make way for storing the index in m2. The custom graphics
  71          * id which was stored in m4 is now saved as a grf/id reference in the
  72          * waypoint struct. */
  73         if (IsSavegameVersionBefore(17)) {
  74                 for (OldWaypoint *wp = _old_waypoints.Begin(); wp != _old_waypoints.End(); wp++) {
  75                         if (wp->delete_ctr != 0) continue; // The waypoint was deleted
  76
  77                         /* Waypoint indices were not added to the map prior to this. */
  78                         _m[wp->xy].m2 = (StationID)wp->index;
  79
  80                         if (HasBit(_m[wp->xy].m3, 4)) {
  81                                 wp->spec = StationClass::Get(STAT_CLASS_WAYP)->GetSpec(_m[wp->xy].m4 + 1);
  82                         }
  83                 }
  84         } else {
  85                 /* As of version 17, we recalculate the custom graphic ID of waypoints
  86                  * from the GRF ID / station index. */
  87                 for (OldWaypoint *wp = _old_waypoints.Begin(); wp != _old_waypoints.End(); wp++) {
  88                         StationClass* stclass = StationClass::Get(STAT_CLASS_WAYP);
  89                         for (uint i = 0; i < stclass->GetSpecCount(); i++) {
  90                                 const StationSpec *statspec = stclass->GetSpec(i);
  91                                 if (statspec != NULL && statspec->grf_prop.grffile->grfid == wp->grfid && statspec->grf_prop.local_id == wp->localidx) {
  92                                         wp->spec = statspec;
  93                                         break;
  94                                 }
  95                         }
  96                 }
  97         }
  98
  99         if (!Waypoint::CanAllocateItem(_old_waypoints.Length())) SlError(STR_ERROR_TOO_MANY_STATIONS_LOADING);
 100
 101         /* All saveload conversions have been done. Create the new waypoints! */
 102         for (OldWaypoint *wp = _old_waypoints.Begin(); wp != _old_waypoints.End(); wp++) {
 103                 Waypoint *new_wp = new Waypoint(wp->xy);
 104                 new_wp->town       = wp->town;
 105                 new_wp->town_cn    = wp->town_cn;
 106                 new_wp->name       = wp->name;
 107                 new_wp->delete_ctr = 0; // Just reset delete counter for once.
 108                 new_wp->build_date = wp->build_date;
 109                 new_wp->owner      = wp->owner;
 110
 111                 new_wp->string_id = STR_SV_STNAME_WAYPOINT;
 112
 113                 TileIndex t = wp->xy;
 114                 if (IsTileType(t, MP_RAILWAY) && GetRailTileType(t) == 2 /* RAIL_TILE_WAYPOINT */ && _m[t].m2 == wp->index) {
 115                         /* The tile might've been reserved! */
 116                         bool reserved = !IsSavegameVersionBefore(100) && HasBit(_m[t].m5, 4);
 117
 118                         /* The tile really has our waypoint, so reassign the map array */
 119                         MakeRailWaypoint(t, GetTileOwner(t), new_wp->index, (Axis)GB(_m[t].m5, 0, 1), 0, GetRailType(t));
 120                         new_wp->facilities |= FACIL_TRAIN;
 121                         new_wp->owner = GetTileOwner(t);
 122
 123                         SetRailStationReservation(t, reserved);
 124
 125                         if (wp->spec != NULL) {
 126                                 SetCustomStationSpecIndex(t, AllocateSpecToStation(wp->spec, new_wp, true));
 127                         }
 128                         new_wp->rect.BeforeAddTile(t, StationRect::ADD_FORCE);
 129                 }
 130
 131                 wp->new_index = new_wp->index;
 132         }
 133
 134         /* Update the orders of vehicles */
 135         OrderList *ol;
 136         FOR_ALL_ORDER_LISTS(ol) {
 137                 if (ol->GetFirstSharedVehicle()->type != VEH_TRAIN) continue;
 138
 139                 for (Order *o = ol->GetFirstOrder(); o != NULL; o = o->next) UpdateWaypointOrder(o);
 140         }
 141
 142         Vehicle *v;
 143         FOR_ALL_VEHICLES(v) {
 144                 if (v->type != VEH_TRAIN) continue;
 145
 146                 UpdateWaypointOrder(&v->current_order);
 147         }
 148
 149         _old_waypoints.Reset();
 150 }
 151
 152 static const SaveLoad _old_waypoint_desc[] = {
 153         SLE_CONDVAR(OldWaypoint, xy,         SLE_FILE_U16 | SLE_VAR_U32,  0, 5),
 154         SLE_CONDVAR(OldWaypoint, xy,         SLE_UINT32,                  6, SL_MAX_VERSION),
 155         SLE_CONDVAR(OldWaypoint, town_index, SLE_UINT16,                 12, 121),
 156         SLE_CONDREF(OldWaypoint, town,       REF_TOWN,                  122, SL_MAX_VERSION),
 157         SLE_CONDVAR(OldWaypoint, town_cn,    SLE_FILE_U8 | SLE_VAR_U16,  12, 88),
 158         SLE_CONDVAR(OldWaypoint, town_cn,    SLE_UINT16,                 89, SL_MAX_VERSION),
 159         SLE_CONDVAR(OldWaypoint, string_id,  SLE_STRINGID,                0, 83),
 160         SLE_CONDSTR(OldWaypoint, name,       SLE_STR, 0,                 84, SL_MAX_VERSION),
 161             SLE_VAR(OldWaypoint, delete_ctr, SLE_UINT8),
 162
 163         SLE_CONDVAR(OldWaypoint, build_date, SLE_FILE_U16 | SLE_VAR_I32,  3, 30),
 164         SLE_CONDVAR(OldWaypoint, build_date, SLE_INT32,                  31, SL_MAX_VERSION),
 165         SLE_CONDVAR(OldWaypoint, localidx,   SLE_UINT8,                   3, SL_MAX_VERSION),
 166         SLE_CONDVAR(OldWaypoint, grfid,      SLE_UINT32,                 17, SL_MAX_VERSION),
 167         SLE_CONDVAR(OldWaypoint, owner,      SLE_UINT8,                 101, SL_MAX_VERSION),
 168
 169         SLE_END()
 170 };
 171
 172 static void Load_WAYP()
 173 {
 174         /* Precaution for when loading failed and it didn't get cleared */
 175         _old_waypoints.Clear();
 176
 177         int index;
 178
 179         while ((index = SlIterateArray()) != -1) {
 180                 OldWaypoint *wp = _old_waypoints.Append();
 181                 memset(wp, 0, sizeof(*wp));
 182
 183                 wp->index = index;
 184                 SlObject(wp, _old_waypoint_desc);
 185         }
 186 }
 187
 188 static void Ptrs_WAYP()
 189 {
 190         for (OldWaypoint *wp = _old_waypoints.Begin(); wp != _old_waypoints.End(); wp++) {
 191                 SlObject(wp, _old_waypoint_desc);
 192
 193                 if (IsSavegameVersionBefore(12)) {
 194                         wp->town_cn = (wp->string_id & 0xC000) == 0xC000 ? (wp->string_id >> 8) & 0x3F : 0;
 195                         wp->town = ClosestTownFromTile(wp->xy, UINT_MAX);
 196                 } else if (IsSavegameVersionBefore(122)) {
 197                         /* Only for versions 12 .. 122 */
 198                         if (!Town::IsValidID(wp->town_index)) {
 199                                 /* Upon a corrupted waypoint we'll likely get here. The next step will be to
 200                                  * loop over all Ptrs procs to NULL the pointers. However, we don't know
 201                                  * whether we're in the NULL or "normal" Ptrs proc. So just clear the list
 202                                  * of old waypoints we constructed and then this waypoint (and the other
 203                                  * possibly corrupt ones) will not be queried in the NULL Ptrs proc run. */
 204                                 _old_waypoints.Clear();
 205                                 SlErrorCorrupt("Referencing invalid Town");
 206                         }
 207                         wp->town = Town::Get(wp->town_index);
 208                 }
 209                 if (IsSavegameVersionBefore(84)) {
 210                         wp->name = CopyFromOldName(wp->string_id);
 211                 }
 212         }
 213 }
 214
 215 extern const ChunkHandler _waypoint_chunk_handlers[] = {
 216         { 'CHKP', NULL, Load_WAYP, Ptrs_WAYP, NULL, CH_ARRAY | CH_LAST},
 217 };