src/saveload/cargomonitor_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 cargomonitor_sl.cpp Code handling saving and loading of Cargo monitoring. */
   9
  10 #include "../stdafx.h"
  11
  12 #include "saveload.h"
  13 #include "compat/cargomonitor_sl_compat.h"
  14
  15 #include "../cargomonitor.h"
  16
  17 #include "../safeguards.h"
  18
  19 /** Temporary storage of cargo monitoring data for loading or saving it. */
  20 struct TempStorage {
  21         CargoMonitorID number;
  22         uint32_t amount;
  23 };
  24
  25 /** Description of the #TempStorage structure for the purpose of load and save. */
  26 static const SaveLoad _cargomonitor_pair_desc[] = {
  27         SLE_VAR(TempStorage, number, SLE_UINT32),
  28         SLE_VAR(TempStorage, amount, SLE_UINT32),
  29 };
  30
  31 static CargoMonitorID FixupCargoMonitor(CargoMonitorID number)
  32 {
  33         /* Between SLV_EXTEND_CARGOTYPES and SLV_FIX_CARGO_MONITOR, the
  34          * CargoMonitorID structure had insufficient packing for more
  35          * than 32 cargo types. Here we have to shuffle bits to account
  36          * for the change.
  37          * Company moved from bits 24-31 to 25-28.
  38          * Cargo type increased from bits 19-23 to 19-24.
  39          */
  40         SB(number, 25, 4, GB(number, 24, 4));
  41         SB(number, 29, 3, 0);
  42         ClrBit(number, 24);
  43         return number;
  44 }
  45
  46 /** #_cargo_deliveries monitoring map. */
  47 struct CMDLChunkHandler : ChunkHandler {
  48         CMDLChunkHandler() : ChunkHandler('CMDL', CH_TABLE) {}
  49
  50         void Save() const override
  51         {
  52                 SlTableHeader(_cargomonitor_pair_desc);
  53
  54                 TempStorage storage;
  55
  56                 int i = 0;
  57                 CargoMonitorMap::const_iterator iter = _cargo_deliveries.begin();
  58                 while (iter != _cargo_deliveries.end()) {
  59                         storage.number = iter->first;
  60                         storage.amount = iter->second;
  61
  62                         SlSetArrayIndex(i);
  63                         SlObject(&storage, _cargomonitor_pair_desc);
  64
  65                         i++;
  66                         iter++;
  67                 }
  68         }
  69
  70         void Load() const override
  71         {
  72                 const std::vector<SaveLoad> slt = SlCompatTableHeader(_cargomonitor_pair_desc, _cargomonitor_pair_sl_compat);
  73
  74                 TempStorage storage;
  75                 bool fix = IsSavegameVersionBefore(SLV_FIX_CARGO_MONITOR);
  76
  77                 ClearCargoDeliveryMonitoring();
  78                 for (;;) {
  79                         if (SlIterateArray() < 0) break;
  80                         SlObject(&storage, slt);
  81
  82                         if (fix) storage.number = FixupCargoMonitor(storage.number);
  83
  84                         _cargo_deliveries.emplace(storage.number, storage.amount);
  85                 }
  86         }
  87 };
  88
  89 /** #_cargo_pickups monitoring map. */
  90 struct CMPUChunkHandler : ChunkHandler {
  91         CMPUChunkHandler() : ChunkHandler('CMPU', CH_TABLE) {}
  92
  93         void Save() const override
  94         {
  95                 SlTableHeader(_cargomonitor_pair_desc);
  96
  97                 TempStorage storage;
  98
  99                 int i = 0;
 100                 CargoMonitorMap::const_iterator iter = _cargo_pickups.begin();
 101                 while (iter != _cargo_pickups.end()) {
 102                         storage.number = iter->first;
 103                         storage.amount = iter->second;
 104
 105                         SlSetArrayIndex(i);
 106                         SlObject(&storage, _cargomonitor_pair_desc);
 107
 108                         i++;
 109                         iter++;
 110                 }
 111         }
 112
 113         void Load() const override
 114         {
 115                 const std::vector<SaveLoad> slt = SlCompatTableHeader(_cargomonitor_pair_desc, _cargomonitor_pair_sl_compat);
 116
 117                 TempStorage storage;
 118                 bool fix = IsSavegameVersionBefore(SLV_FIX_CARGO_MONITOR);
 119
 120                 ClearCargoPickupMonitoring();
 121                 for (;;) {
 122                         if (SlIterateArray() < 0) break;
 123                         SlObject(&storage, slt);
 124
 125                         if (fix) storage.number = FixupCargoMonitor(storage.number);
 126
 127                         _cargo_pickups.emplace(storage.number, storage.amount);
 128                 }
 129         }
 130 };
 131
 132 /** Chunk definition of the cargomonitoring maps. */
 133 static const CMDLChunkHandler CMDL;
 134 static const CMPUChunkHandler CMPU;
 135 static const ChunkHandlerRef cargomonitor_chunk_handlers[] = {
 136         CMDL,
 137         CMPU,
 138 };
 139
 140 extern const ChunkHandlerTable _cargomonitor_chunk_handlers(cargomonitor_chunk_handlers);