src/saveload/newgrf_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 newgrf_sl.cpp Code handling saving and loading of newgrf config */
   9
  10 #include "../stdafx.h"
  11
  12 #include "saveload.h"
  13 #include "compat/newgrf_sl_compat.h"
  14
  15 #include "newgrf_sl.h"
  16 #include "../fios.h"
  17
  18 #include "../safeguards.h"
  19
  20 /** Save and load the mapping between a spec and the NewGRF it came from. */
  21 static const SaveLoad _newgrf_mapping_desc[] = {
  22         SLE_VAR(EntityIDMapping, grfid,         SLE_UINT32),
  23         SLE_CONDVAR(EntityIDMapping, entity_id,     SLE_FILE_U8 | SLE_VAR_U16, SL_MIN_VERSION,            SLV_EXTEND_ENTITY_MAPPING),
  24         SLE_CONDVAR(EntityIDMapping, entity_id,     SLE_UINT16,                SLV_EXTEND_ENTITY_MAPPING, SL_MAX_VERSION),
  25         SLE_CONDVAR(EntityIDMapping, substitute_id, SLE_FILE_U8 | SLE_VAR_U16, SL_MIN_VERSION,            SLV_EXTEND_ENTITY_MAPPING),
  26         SLE_CONDVAR(EntityIDMapping, substitute_id, SLE_UINT16,                SLV_EXTEND_ENTITY_MAPPING, SL_MAX_VERSION),
  27 };
  28
  29 /**
  30  * Save a GRF ID + local id -> OpenTTD's id mapping.
  31  */
  32 void NewGRFMappingChunkHandler::Save() const
  33 {
  34         SlTableHeader(_newgrf_mapping_desc);
  35
  36         for (uint i = 0; i < this->mapping.GetMaxMapping(); i++) {
  37                 if (this->mapping.mappings[i].grfid == 0 &&
  38                         this->mapping.mappings[i].entity_id == 0) continue;
  39                 SlSetArrayIndex(i);
  40                 SlObject(&this->mapping.mappings[i], _newgrf_mapping_desc);
  41         }
  42 }
  43
  44 /**
  45  * Load a GRF ID + local id -> OpenTTD's id mapping.
  46  */
  47 void NewGRFMappingChunkHandler::Load() const
  48 {
  49         const std::vector<SaveLoad> slt = SlCompatTableHeader(_newgrf_mapping_desc, _newgrf_mapping_sl_compat);
  50
  51         /* Clear the current mapping stored.
  52          * This will create the manager if ever it is not yet done */
  53         this->mapping.ResetMapping();
  54
  55         uint max_id = this->mapping.GetMaxMapping();
  56
  57         int index;
  58         while ((index = SlIterateArray()) != -1) {
  59                 if ((uint)index >= max_id) SlErrorCorrupt("Too many NewGRF entity mappings");
  60                 SlObject(&this->mapping.mappings[index], slt);
  61         }
  62 }
  63
  64
  65 static const SaveLoad _grfconfig_desc[] = {
  66            SLE_SSTR(GRFConfig, filename,         SLE_STR),
  67             SLE_VAR(GRFConfig, ident.grfid,      SLE_UINT32),
  68             SLE_ARR(GRFConfig, ident.md5sum,     SLE_UINT8,  16),
  69         SLE_CONDVAR(GRFConfig, version,          SLE_UINT32, SLV_151, SL_MAX_VERSION),
  70             SLE_ARR(GRFConfig, param,            SLE_UINT32, 0x80),
  71             SLE_VAR(GRFConfig, num_params,       SLE_UINT8),
  72         SLE_CONDVAR(GRFConfig, palette,          SLE_UINT8,  SLV_101, SL_MAX_VERSION),
  73 };
  74
  75
  76 struct NGRFChunkHandler : ChunkHandler {
  77         NGRFChunkHandler() : ChunkHandler('NGRF', CH_TABLE) {}
  78
  79         void Save() const override
  80         {
  81                 SlTableHeader(_grfconfig_desc);
  82
  83                 int index = 0;
  84
  85                 for (GRFConfig *c = _grfconfig; c != nullptr; c = c->next) {
  86                         if (HasBit(c->flags, GCF_STATIC) || HasBit(c->flags, GCF_INIT_ONLY)) continue;
  87                         SlSetArrayIndex(index++);
  88                         SlObject(c, _grfconfig_desc);
  89                 }
  90         }
  91
  92
  93         void LoadCommon(GRFConfig *&grfconfig) const
  94         {
  95                 const std::vector<SaveLoad> slt = SlCompatTableHeader(_grfconfig_desc, _grfconfig_sl_compat);
  96
  97                 ClearGRFConfigList(&grfconfig);
  98                 while (SlIterateArray() != -1) {
  99                         GRFConfig *c = new GRFConfig();
 100                         SlObject(c, slt);
 101                         if (IsSavegameVersionBefore(SLV_101)) c->SetSuitablePalette();
 102                         AppendToGRFConfigList(&grfconfig, c);
 103                 }
 104         }
 105
 106         void Load() const override
 107         {
 108                 this->LoadCommon(_grfconfig);
 109
 110                 if (_game_mode == GM_MENU) {
 111                         /* Intro game must not have NewGRF. */
 112                         if (_grfconfig != nullptr) SlErrorCorrupt("The intro game must not use NewGRF");
 113
 114                         /* Activate intro NewGRFs (townnames) */
 115                         ResetGRFConfig(false);
 116                 } else {
 117                         /* Append static NewGRF configuration */
 118                         AppendStaticGRFConfigs(&_grfconfig);
 119                 }
 120         }
 121
 122         void LoadCheck(size_t) const override
 123         {
 124                 this->LoadCommon(_load_check_data.grfconfig);
 125         }
 126 };
 127
 128 static const NGRFChunkHandler NGRF;
 129 static const ChunkHandlerRef newgrf_chunk_handlers[] = {
 130         NGRF,
 131 };
 132
 133 extern const ChunkHandlerTable _newgrf_chunk_handlers(newgrf_chunk_handlers);