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