src/saveload/order_sl.cpp

   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
   8 /** @file order_sl.cpp Code handling saving and loading of orders */
   9
  10 #include "../stdafx.h"
  11
  12 #include "saveload.h"
  13 #include "compat/order_sl_compat.h"
  14
  15 #include "saveload_internal.h"
  16 #include "../order_backup.h"
  17 #include "../settings_type.h"
  18 #include "../network/network.h"
  19
  20 #include "../safeguards.h"
  21
  22 /**
  23  * Converts this order from an old savegame's version;
  24  * it moves all bits to the new location.
  25  */
  26 void Order::ConvertFromOldSavegame()
  27 {
  28         uint8_t old_flags = this->flags;
  29         this->flags = 0;
  30
  31         /* First handle non-stop - use value from savegame if possible, else use value from config file */
  32         if (_settings_client.gui.sg_new_nonstop || (IsSavegameVersionBefore(SLV_22) && _savegame_type != SGT_TTO && _savegame_type != SGT_TTD && _settings_client.gui.new_nonstop)) {
  33                 /* OFB_NON_STOP */
  34                 this->SetNonStopType((old_flags & 8) ? ONSF_NO_STOP_AT_ANY_STATION : ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS);
  35         } else {
  36                 this->SetNonStopType((old_flags & 8) ? ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS : ONSF_STOP_EVERYWHERE);
  37         }
  38
  39         switch (this->GetType()) {
  40                 /* Only a few types need the other savegame conversions. */
  41                 case OT_GOTO_DEPOT: case OT_GOTO_STATION: case OT_LOADING: break;
  42                 default: return;
  43         }
  44
  45         if (this->GetType() != OT_GOTO_DEPOT) {
  46                 /* Then the load flags */
  47                 if ((old_flags & 2) != 0) { // OFB_UNLOAD
  48                         this->SetLoadType(OLFB_NO_LOAD);
  49                 } else if ((old_flags & 4) == 0) { // !OFB_FULL_LOAD
  50                         this->SetLoadType(OLF_LOAD_IF_POSSIBLE);
  51                 } else {
  52                         /* old OTTD versions stored full_load_any in config file - assume it was enabled when loading */
  53                         this->SetLoadType(_settings_client.gui.sg_full_load_any || IsSavegameVersionBefore(SLV_22) ? OLF_FULL_LOAD_ANY : OLFB_FULL_LOAD);
  54                 }
  55
  56                 if (this->IsType(OT_GOTO_STATION)) this->SetStopLocation(OSL_PLATFORM_FAR_END);
  57
  58                 /* Finally fix the unload flags */
  59                 if ((old_flags & 1) != 0) { // OFB_TRANSFER
  60                         this->SetUnloadType(OUFB_TRANSFER);
  61                 } else if ((old_flags & 2) != 0) { // OFB_UNLOAD
  62                         this->SetUnloadType(OUFB_UNLOAD);
  63                 } else {
  64                         this->SetUnloadType(OUF_UNLOAD_IF_POSSIBLE);
  65                 }
  66         } else {
  67                 /* Then the depot action flags */
  68                 this->SetDepotActionType(((old_flags & 6) == 4) ? ODATFB_HALT : ODATF_SERVICE_ONLY);
  69
  70                 /* Finally fix the depot type flags */
  71                 uint t = ((old_flags & 6) == 6) ? ODTFB_SERVICE : ODTF_MANUAL;
  72                 if ((old_flags & 2) != 0) t |= ODTFB_PART_OF_ORDERS;
  73                 this->SetDepotOrderType((OrderDepotTypeFlags)t);
  74         }
  75 }
  76
  77 /**
  78  * Unpacks a order from savegames with version 4 and lower
  79  * @param packed packed order
  80  * @return unpacked order
  81  */
  82 static Order UnpackVersion4Order(uint16_t packed)
  83 {
  84         return Order(GB(packed, 0, 4), GB(packed, 4, 4), GB(packed, 8, 8));
  85 }
  86
  87 /**
  88  * Unpacks a order from savegames made with TTD(Patch)
  89  * @param packed packed order
  90  * @return unpacked order
  91  */
  92 Order UnpackOldOrder(uint16_t packed)
  93 {
  94         Order order = UnpackVersion4Order(packed);
  95
  96         /*
  97          * Sanity check
  98          * TTD stores invalid orders as OT_NOTHING with non-zero flags/station
  99          */
 100         if (order.IsType(OT_NOTHING) && packed != 0) order.MakeDummy();
 101
 102         return order;
 103 }
 104
 105 SaveLoadTable GetOrderDescription()
 106 {
 107         static const SaveLoad _order_desc[] = {
 108                      SLE_VAR(Order, type,           SLE_UINT8),
 109                      SLE_VAR(Order, flags,          SLE_UINT8),
 110                      SLE_VAR(Order, dest,           SLE_UINT16),
 111                      SLE_REF(Order, next,           REF_ORDER),
 112                  SLE_CONDVAR(Order, refit_cargo,    SLE_UINT8,   SLV_36, SL_MAX_VERSION),
 113                  SLE_CONDVAR(Order, wait_time,      SLE_UINT16,  SLV_67, SL_MAX_VERSION),
 114                  SLE_CONDVAR(Order, travel_time,    SLE_UINT16,  SLV_67, SL_MAX_VERSION),
 115                  SLE_CONDVAR(Order, max_speed,      SLE_UINT16, SLV_172, SL_MAX_VERSION),
 116         };
 117
 118         return _order_desc;
 119 }
 120
 121 struct ORDRChunkHandler : ChunkHandler {
 122         ORDRChunkHandler() : ChunkHandler('ORDR', CH_TABLE) {}
 123
 124         void Save() const override
 125         {
 126                 const SaveLoadTable slt = GetOrderDescription();
 127                 SlTableHeader(slt);
 128
 129                 for (Order *order : Order::Iterate()) {
 130                         SlSetArrayIndex(order->index);
 131                         SlObject(order, slt);
 132                 }
 133         }
 134
 135         void Load() const override
 136         {
 137                 if (IsSavegameVersionBefore(SLV_5, 2)) {
 138                         /* Version older than 5.2 did not have a ->next pointer. Convert them
 139                          * (in the old days, the orderlist was 5000 items big) */
 140                         size_t len = SlGetFieldLength();
 141
 142                         if (IsSavegameVersionBefore(SLV_5)) {
 143                                 /* Pre-version 5 had another layout for orders
 144                                  * (uint16_t instead of uint32_t) */
 145                                 len /= sizeof(uint16_t);
 146                                 std::vector<uint16_t> orders(len);
 147
 148                                 SlCopy(&orders[0], len, SLE_UINT16);
 149
 150                                 for (size_t i = 0; i < len; ++i) {
 151                                         Order *o = new (i) Order();
 152                                         o->AssignOrder(UnpackVersion4Order(orders[i]));
 153                                 }
 154                         } else if (IsSavegameVersionBefore(SLV_5, 2)) {
 155                                 len /= sizeof(uint32_t);
 156                                 std::vector<uint32_t> orders(len);
 157
 158                                 SlCopy(&orders[0], len, SLE_UINT32);
 159
 160                                 for (size_t i = 0; i < len; ++i) {
 161                                         new (i) Order(GB(orders[i], 0, 8), GB(orders[i], 8, 8), GB(orders[i], 16, 16));
 162                                 }
 163                         }
 164
 165                         /* Update all the next pointer */
 166                         for (Order *o : Order::Iterate()) {
 167                                 size_t order_index = o->index;
 168                                 /* Delete invalid orders */
 169                                 if (o->IsType(OT_NOTHING)) {
 170                                         delete o;
 171                                         continue;
 172                                 }
 173                                 /* The orders were built like this:
 174                                  * While the order is valid, set the previous will get its next pointer set */
 175                                 Order *prev = Order::GetIfValid(order_index - 1);
 176                                 if (prev != nullptr) prev->next = o;
 177                         }
 178                 } else {
 179                         const std::vector<SaveLoad> slt = SlCompatTableHeader(GetOrderDescription(), _order_sl_compat);
 180
 181                         int index;
 182
 183                         while ((index = SlIterateArray()) != -1) {
 184                                 Order *order = new (index) Order();
 185                                 SlObject(order, slt);
 186                         }
 187                 }
 188         }
 189
 190         void FixPointers() const override
 191         {
 192                 /* Orders from old savegames have pointers corrected in Load_ORDR */
 193                 if (IsSavegameVersionBefore(SLV_5, 2)) return;
 194
 195                 for (Order *o : Order::Iterate()) {
 196                         SlObject(o, GetOrderDescription());
 197                 }
 198         }
 199 };
 200
 201 SaveLoadTable GetOrderListDescription()
 202 {
 203         static const SaveLoad _orderlist_desc[] = {
 204                 SLE_REF(OrderList, first,              REF_ORDER),
 205         };
 206
 207         return _orderlist_desc;
 208 }
 209
 210 struct ORDLChunkHandler : ChunkHandler {
 211         ORDLChunkHandler() : ChunkHandler('ORDL', CH_TABLE) {}
 212
 213         void Save() const override
 214         {
 215                 const SaveLoadTable slt = GetOrderListDescription();
 216                 SlTableHeader(slt);
 217
 218                 for (OrderList *list : OrderList::Iterate()) {
 219                         SlSetArrayIndex(list->index);
 220                         SlObject(list, slt);
 221                 }
 222         }
 223
 224         void Load() const override
 225         {
 226                 const std::vector<SaveLoad> slt = SlCompatTableHeader(GetOrderListDescription(), _orderlist_sl_compat);
 227
 228                 int index;
 229
 230                 while ((index = SlIterateArray()) != -1) {
 231                         /* set num_orders to 0 so it's a valid OrderList */
 232                         OrderList *list = new (index) OrderList(0);
 233                         SlObject(list, slt);
 234                 }
 235
 236         }
 237
 238         void FixPointers() const override
 239         {
 240                 for (OrderList *list : OrderList::Iterate()) {
 241                         SlObject(list, GetOrderListDescription());
 242                 }
 243         }
 244 };
 245
 246 SaveLoadTable GetOrderBackupDescription()
 247 {
 248         static const SaveLoad _order_backup_desc[] = {
 249                      SLE_VAR(OrderBackup, user,                     SLE_UINT32),
 250                      SLE_VAR(OrderBackup, tile,                     SLE_UINT32),
 251                      SLE_VAR(OrderBackup, group,                    SLE_UINT16),
 252                  SLE_CONDVAR(OrderBackup, service_interval,         SLE_FILE_U32 | SLE_VAR_U16,  SL_MIN_VERSION, SLV_192),
 253                  SLE_CONDVAR(OrderBackup, service_interval,         SLE_UINT16,                SLV_192, SL_MAX_VERSION),
 254                     SLE_SSTR(OrderBackup, name,                     SLE_STR),
 255                  SLE_CONDREF(OrderBackup, clone,                    REF_VEHICLE,               SLV_192, SL_MAX_VERSION),
 256                      SLE_VAR(OrderBackup, cur_real_order_index,     SLE_UINT8),
 257                  SLE_CONDVAR(OrderBackup, cur_implicit_order_index, SLE_UINT8,                 SLV_176, SL_MAX_VERSION),
 258                  SLE_CONDVAR(OrderBackup, current_order_time,       SLE_UINT32,                SLV_176, SL_MAX_VERSION),
 259                  SLE_CONDVAR(OrderBackup, lateness_counter,         SLE_INT32,                 SLV_176, SL_MAX_VERSION),
 260                  SLE_CONDVAR(OrderBackup, timetable_start,          SLE_FILE_I32 | SLE_VAR_U64, SLV_176, SLV_TIMETABLE_START_TICKS_FIX),
 261                  SLE_CONDVAR(OrderBackup, timetable_start,          SLE_UINT64,                 SLV_TIMETABLE_START_TICKS_FIX, SL_MAX_VERSION),
 262                  SLE_CONDVAR(OrderBackup, vehicle_flags,            SLE_FILE_U8 | SLE_VAR_U16, SLV_176, SLV_180),
 263                  SLE_CONDVAR(OrderBackup, vehicle_flags,            SLE_UINT16,                SLV_180, SL_MAX_VERSION),
 264                      SLE_REF(OrderBackup, orders,                   REF_ORDER),
 265         };
 266
 267         return _order_backup_desc;
 268 }
 269
 270 struct BKORChunkHandler : ChunkHandler {
 271         BKORChunkHandler() : ChunkHandler('BKOR', CH_TABLE) {}
 272
 273         void Save() const override
 274         {
 275                 const SaveLoadTable slt = GetOrderBackupDescription();
 276                 SlTableHeader(slt);
 277
 278                 /* We only save this when we're a network server
 279                  * as we want this information on our clients. For
 280                  * normal games this information isn't needed. */
 281                 if (!_networking || !_network_server) return;
 282
 283                 for (OrderBackup *ob : OrderBackup::Iterate()) {
 284                         SlSetArrayIndex(ob->index);
 285                         SlObject(ob, slt);
 286                 }
 287         }
 288
 289         void Load() const override
 290         {
 291                 const std::vector<SaveLoad> slt = SlCompatTableHeader(GetOrderBackupDescription(), _order_backup_sl_compat);
 292
 293                 int index;
 294
 295                 while ((index = SlIterateArray()) != -1) {
 296                         /* set num_orders to 0 so it's a valid OrderList */
 297                         OrderBackup *ob = new (index) OrderBackup();
 298                         SlObject(ob, slt);
 299                 }
 300         }
 301
 302         void FixPointers() const override
 303         {
 304                 for (OrderBackup *ob : OrderBackup::Iterate()) {
 305                         SlObject(ob, GetOrderBackupDescription());
 306                 }
 307         }
 308 };
 309
 310 static const BKORChunkHandler BKOR;
 311 static const ORDRChunkHandler ORDR;
 312 static const ORDLChunkHandler ORDL;
 313 static const ChunkHandlerRef order_chunk_handlers[] = {
 314         BKOR,
 315         ORDR,
 316         ORDL,
 317 };
 318
 319 extern const ChunkHandlerTable _order_chunk_handlers(order_chunk_handlers);