src/newgrf_config.h

   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_config.h Functions to find and configure NewGRFs. */
   9
  10 #ifndef NEWGRF_CONFIG_H
  11 #define NEWGRF_CONFIG_H
  12
  13 #include "strings_type.h"
  14 #include "core/alloc_type.hpp"
  15 #include "fileio_type.h"
  16 #include "textfile_type.h"
  17 #include "newgrf_text.h"
  18 #include "3rdparty/md5/md5.h"
  19
  20 /** GRF config bit flags */
  21 enum GCF_Flags {
  22         GCF_SYSTEM,     ///< GRF file is an openttd-internal system grf
  23         GCF_UNSAFE,     ///< GRF file is unsafe for static usage
  24         GCF_STATIC,     ///< GRF file is used statically (can be used in any MP game)
  25         GCF_COMPATIBLE, ///< GRF file does not exactly match the requested GRF (different MD5SUM), but grfid matches)
  26         GCF_COPY,       ///< The data is copied from a grf in _all_grfs
  27         GCF_INIT_ONLY,  ///< GRF file is processed up to GLS_INIT
  28         GCF_RESERVED,   ///< GRF file passed GLS_RESERVE stage
  29         GCF_INVALID,    ///< GRF is unusable with this version of OpenTTD
  30 };
  31
  32 /** Status of GRF */
  33 enum GRFStatus {
  34         GCS_UNKNOWN,      ///< The status of this grf file is unknown
  35         GCS_DISABLED,     ///< GRF file is disabled
  36         GCS_NOT_FOUND,    ///< GRF file was not found in the local cache
  37         GCS_INITIALISED,  ///< GRF file has been initialised
  38         GCS_ACTIVATED,    ///< GRF file has been activated
  39 };
  40
  41 /** Encountered GRF bugs */
  42 enum GRFBugs {
  43         GBUG_VEH_LENGTH,        ///< Length of rail vehicle changes when not inside a depot
  44         GBUG_VEH_REFIT,         ///< Articulated vehicles carry different cargoes resp. are differently refittable than specified in purchase list
  45         GBUG_VEH_POWERED_WAGON, ///< Powered wagon changed poweredness state when not inside a depot
  46         GBUG_UNKNOWN_CB_RESULT, ///< A callback returned an unknown/invalid result
  47         GBUG_VEH_CAPACITY,      ///< Capacity of vehicle changes when not refitting or arranging
  48 };
  49
  50 /** Status of post-gameload GRF compatibility check */
  51 enum GRFListCompatibility {
  52         GLC_ALL_GOOD,   ///< All GRF needed by game are present
  53         GLC_COMPATIBLE, ///< Compatible (eg. the same ID, but different checksum) GRF found in at least one case
  54         GLC_NOT_FOUND,  ///< At least one GRF couldn't be found (higher priority than GLC_COMPATIBLE)
  55 };
  56
  57 /** Information that can/has to be stored about a GRF's palette. */
  58 enum GRFPalette {
  59         GRFP_USE_BIT     = 0,   ///< The bit used for storing the palette to use.
  60         GRFP_GRF_OFFSET  = 2,   ///< The offset of the GRFP_GRF data.
  61         GRFP_GRF_SIZE    = 2,   ///< The size of the GRFP_GRF data.
  62         GRFP_BLT_OFFSET  = 4,   ///< The offset of the GRFP_BLT data.
  63         GRFP_BLT_SIZE    = 1,   ///< The size of the GRFP_BLT data.
  64
  65         GRFP_USE_DOS     = 0x0, ///< The palette state is set to use the DOS palette.
  66         GRFP_USE_WINDOWS = 0x1, ///< The palette state is set to use the Windows palette.
  67         GRFP_USE_MASK    = 0x1, ///< Bitmask to get only the use palette use states.
  68
  69         GRFP_GRF_UNSET   = 0x0 << GRFP_GRF_OFFSET,          ///< The NewGRF provided no information.
  70         GRFP_GRF_DOS     = 0x1 << GRFP_GRF_OFFSET,          ///< The NewGRF says the DOS palette can be used.
  71         GRFP_GRF_WINDOWS = 0x2 << GRFP_GRF_OFFSET,          ///< The NewGRF says the Windows palette can be used.
  72         GRFP_GRF_ANY     = GRFP_GRF_DOS | GRFP_GRF_WINDOWS, ///< The NewGRF says any palette can be used.
  73         GRFP_GRF_MASK    = GRFP_GRF_ANY,                    ///< Bitmask to get only the NewGRF supplied information.
  74
  75         GRFP_BLT_UNSET   = 0x0 << GRFP_BLT_OFFSET,          ///< The NewGRF provided no information or doesn't care about a 32 bpp blitter.
  76         GRFP_BLT_32BPP   = 0x1 << GRFP_BLT_OFFSET,          ///< The NewGRF prefers a 32 bpp blitter.
  77         GRFP_BLT_MASK    = GRFP_BLT_32BPP,                  ///< Bitmask to only get the blitter information.
  78 };
  79
  80
  81 /** Basic data to distinguish a GRF. Used in the server list window */
  82 struct GRFIdentifier {
  83         uint32_t grfid;     ///< GRF ID (defined by Action 0x08)
  84         MD5Hash md5sum;   ///< MD5 checksum of file to distinguish files with the same GRF ID (eg. newer version of GRF)
  85
  86         GRFIdentifier() = default;
  87         GRFIdentifier(const GRFIdentifier &other) = default;
  88         GRFIdentifier(GRFIdentifier &&other) = default;
  89         GRFIdentifier(uint32_t grfid, const MD5Hash &md5sum) : grfid(grfid), md5sum(md5sum) {}
  90
  91         GRFIdentifier& operator =(const GRFIdentifier &other) = default;
  92
  93         /**
  94          * Does the identification match the provided values?
  95          * @param grfid  Expected grfid.
  96          * @param md5sum Expected md5sum, may be \c nullptr (in which case, do not check it).
  97          * @return the object has the provided grfid and md5sum.
  98          */
  99         inline bool HasGrfIdentifier(uint32_t grfid, const MD5Hash *md5sum) const
 100         {
 101                 if (this->grfid != grfid) return false;
 102                 if (md5sum == nullptr) return true;
 103                 return *md5sum == this->md5sum;
 104         }
 105 };
 106
 107 /** Information about why GRF had problems during initialisation */
 108 struct GRFError {
 109         GRFError(StringID severity, StringID message = 0);
 110
 111         std::string custom_message{}; ///< Custom message (if present)
 112         std::string data{}; ///< Additional data for message and custom_message
 113         StringID message{}; ///< Default message
 114         StringID severity{}; ///< Info / Warning / Error / Fatal
 115         std::array<uint32_t, 2> param_value{}; ///< Values of GRF parameters to show for message and custom_message
 116 };
 117
 118 /** The possible types of a newgrf parameter. */
 119 enum GRFParameterType {
 120         PTYPE_UINT_ENUM, ///< The parameter allows a range of numbers, each of which can have a special name
 121         PTYPE_BOOL,      ///< The parameter is either 0 or 1
 122         PTYPE_END,       ///< Invalid parameter type
 123 };
 124
 125 /** Information about one grf parameter. */
 126 struct GRFParameterInfo {
 127         GRFParameterInfo(uint nr);
 128         GRFTextList name;      ///< The name of this parameter
 129         GRFTextList desc;      ///< The description of this parameter
 130         GRFParameterType type; ///< The type of this parameter
 131         uint32_t min_value;      ///< The minimal value this parameter can have
 132         uint32_t max_value;      ///< The maximal value of this parameter
 133         uint32_t def_value;      ///< Default value of this parameter
 134         uint8_t param_nr;         ///< GRF parameter to store content in
 135         uint8_t first_bit;        ///< First bit to use in the GRF parameter
 136         uint8_t num_bit;          ///< Number of bits to use for this parameter
 137         std::map<uint32_t, GRFTextList> value_names; ///< Names for each value.
 138         bool complete_labels;  ///< True if all values have a label.
 139
 140         uint32_t GetValue(struct GRFConfig *config) const;
 141         void SetValue(struct GRFConfig *config, uint32_t value);
 142         void Finalize();
 143 };
 144
 145 /** Information about GRF, used in the game and (part of it) in savegames */
 146 struct GRFConfig : ZeroedMemoryAllocator {
 147         GRFConfig(const std::string &filename = std::string{});
 148         GRFConfig(const GRFConfig &config);
 149
 150         /* Remove the copy assignment, as the default implementation will not do the right thing. */
 151         GRFConfig &operator=(GRFConfig &rhs) = delete;
 152
 153         GRFIdentifier ident; ///< grfid and md5sum to uniquely identify newgrfs
 154         MD5Hash original_md5sum; ///< MD5 checksum of original file if only a 'compatible' file was loaded
 155         std::string filename; ///< Filename - either with or without full path
 156         GRFTextWrapper name; ///< NOSAVE: GRF name (Action 0x08)
 157         GRFTextWrapper info; ///< NOSAVE: GRF info (author, copyright, ...) (Action 0x08)
 158         GRFTextWrapper url; ///< NOSAVE: URL belonging to this GRF.
 159         std::optional<GRFError> error; ///< NOSAVE: Error/Warning during GRF loading (Action 0x0B)
 160
 161         uint32_t version; ///< NOSAVE: Version a NewGRF can set so only the newest NewGRF is shown
 162         uint32_t min_loadable_version; ///< NOSAVE: Minimum compatible version a NewGRF can define
 163         uint8_t flags; ///< NOSAVE: GCF_Flags, bitset
 164         GRFStatus status; ///< NOSAVE: GRFStatus, enum
 165         uint32_t grf_bugs; ///< NOSAVE: bugs in this GRF in this run, @see enum GRFBugs
 166         std::array<uint32_t, 0x80> param; ///< GRF parameters
 167         uint8_t num_params; ///< Number of used parameters
 168         uint8_t num_valid_params; ///< NOSAVE: Number of valid parameters (action 0x14)
 169         uint8_t palette; ///< GRFPalette, bitset
 170         std::vector<std::optional<GRFParameterInfo>> param_info; ///< NOSAVE: extra information about the parameters
 171         bool has_param_defaults; ///< NOSAVE: did this newgrf specify any defaults for it's parameters
 172
 173         struct GRFConfig *next; ///< NOSAVE: Next item in the linked list
 174
 175         bool IsCompatible(uint32_t old_version) const;
 176         void SetParams(const std::vector<uint32_t> &pars);
 177         void CopyParams(const GRFConfig &src);
 178
 179         std::optional<std::string> GetTextfile(TextfileType type) const;
 180         const char *GetName() const;
 181         const char *GetDescription() const;
 182         const char *GetURL() const;
 183
 184         void SetParameterDefaults();
 185         void SetSuitablePalette();
 186         void FinalizeParameterInfo();
 187 };
 188
 189 /** Method to find GRFs using FindGRFConfig */
 190 enum FindGRFConfigMode {
 191         FGCM_EXACT,       ///< Only find Grfs matching md5sum
 192         FGCM_COMPATIBLE,  ///< Find best compatible Grf wrt. desired_version
 193         FGCM_NEWEST,      ///< Find newest Grf
 194         FGCM_NEWEST_VALID,///< Find newest Grf, ignoring Grfs with GCF_INVALID set
 195         FGCM_ANY,         ///< Use first found
 196 };
 197
 198 extern GRFConfig *_all_grfs;          ///< First item in list of all scanned NewGRFs
 199 extern GRFConfig *_grfconfig;         ///< First item in list of current GRF set up
 200 extern GRFConfig *_grfconfig_newgame; ///< First item in list of default GRF set up
 201 extern GRFConfig *_grfconfig_static;  ///< First item in list of static GRF set up
 202 extern uint _missing_extra_graphics;  ///< Number of sprites provided by the fallback extra GRF, i.e. missing in the baseset.
 203
 204 /** Callback for NewGRF scanning. */
 205 struct NewGRFScanCallback {
 206         /** Make sure the right destructor gets called. */
 207         virtual ~NewGRFScanCallback() = default;
 208         /** Called whenever the NewGRF scan completed. */
 209         virtual void OnNewGRFsScanned() = 0;
 210 };
 211
 212 size_t GRFGetSizeOfDataSection(FileHandle &f);
 213
 214 void ScanNewGRFFiles(NewGRFScanCallback *callback);
 215 const GRFConfig *FindGRFConfig(uint32_t grfid, FindGRFConfigMode mode, const MD5Hash *md5sum = nullptr, uint32_t desired_version = 0);
 216 GRFConfig *GetGRFConfig(uint32_t grfid, uint32_t mask = 0xFFFFFFFF);
 217 GRFConfig **CopyGRFConfigList(GRFConfig **dst, const GRFConfig *src, bool init_only);
 218 void AppendStaticGRFConfigs(GRFConfig **dst);
 219 void AppendToGRFConfigList(GRFConfig **dst, GRFConfig *el);
 220 void ClearGRFConfigList(GRFConfig **config);
 221 void ResetGRFConfig(bool defaults);
 222 GRFListCompatibility IsGoodGRFConfigList(GRFConfig *grfconfig);
 223 bool FillGRFDetails(GRFConfig *config, bool is_static, Subdirectory subdir = NEWGRF_DIR);
 224 std::string GRFBuildParamList(const GRFConfig *c);
 225
 226 /* In newgrf_gui.cpp */
 227 void ShowNewGRFSettings(bool editable, bool show_params, bool exec_changes, GRFConfig **config);
 228 void OpenGRFParameterWindow(bool is_baseset, GRFConfig *c, bool editable);
 229
 230 void UpdateNewGRFScanStatus(uint num, const char *name);
 231 void UpdateNewGRFConfigPalette(int32_t new_value = 0);
 232
 233 #endif /* NEWGRF_CONFIG_H */