mirror of
https://github.com/OpenTTD/OpenTTD.git
synced 2025-07-31 16:28:34 +01:00
8360fab18a
This was originally generic and used by YAPF, but now it is used only by script objects. CCountedPtr provided much more (untested) functionality than used. ScriptObjectRef already exists for script objects and does the same thing, so use this instead.
234 lines
11 KiB
C++
234 lines
11 KiB
C++
/*
|
|
* This file is part of OpenTTD.
|
|
* 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.
|
|
* 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.
|
|
* 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/>.
|
|
*/
|
|
|
|
/** @file newgrf_config.h Functions to find and configure NewGRFs. */
|
|
|
|
#ifndef NEWGRF_CONFIG_H
|
|
#define NEWGRF_CONFIG_H
|
|
|
|
#include "strings_type.h"
|
|
#include "core/alloc_type.hpp"
|
|
#include "fileio_type.h"
|
|
#include "textfile_type.h"
|
|
#include "newgrf_text.h"
|
|
#include "3rdparty/md5/md5.h"
|
|
|
|
/** GRF config bit flags */
|
|
enum GCF_Flags {
|
|
GCF_SYSTEM, ///< GRF file is an openttd-internal system grf
|
|
GCF_UNSAFE, ///< GRF file is unsafe for static usage
|
|
GCF_STATIC, ///< GRF file is used statically (can be used in any MP game)
|
|
GCF_COMPATIBLE, ///< GRF file does not exactly match the requested GRF (different MD5SUM), but grfid matches)
|
|
GCF_COPY, ///< The data is copied from a grf in _all_grfs
|
|
GCF_INIT_ONLY, ///< GRF file is processed up to GLS_INIT
|
|
GCF_RESERVED, ///< GRF file passed GLS_RESERVE stage
|
|
GCF_INVALID, ///< GRF is unusable with this version of OpenTTD
|
|
};
|
|
|
|
/** Status of GRF */
|
|
enum GRFStatus {
|
|
GCS_UNKNOWN, ///< The status of this grf file is unknown
|
|
GCS_DISABLED, ///< GRF file is disabled
|
|
GCS_NOT_FOUND, ///< GRF file was not found in the local cache
|
|
GCS_INITIALISED, ///< GRF file has been initialised
|
|
GCS_ACTIVATED, ///< GRF file has been activated
|
|
};
|
|
|
|
/** Encountered GRF bugs */
|
|
enum GRFBugs {
|
|
GBUG_VEH_LENGTH, ///< Length of rail vehicle changes when not inside a depot
|
|
GBUG_VEH_REFIT, ///< Articulated vehicles carry different cargoes resp. are differently refittable than specified in purchase list
|
|
GBUG_VEH_POWERED_WAGON, ///< Powered wagon changed poweredness state when not inside a depot
|
|
GBUG_UNKNOWN_CB_RESULT, ///< A callback returned an unknown/invalid result
|
|
GBUG_VEH_CAPACITY, ///< Capacity of vehicle changes when not refitting or arranging
|
|
};
|
|
|
|
/** Status of post-gameload GRF compatibility check */
|
|
enum GRFListCompatibility {
|
|
GLC_ALL_GOOD, ///< All GRF needed by game are present
|
|
GLC_COMPATIBLE, ///< Compatible (eg. the same ID, but different checksum) GRF found in at least one case
|
|
GLC_NOT_FOUND, ///< At least one GRF couldn't be found (higher priority than GLC_COMPATIBLE)
|
|
};
|
|
|
|
/** Information that can/has to be stored about a GRF's palette. */
|
|
enum GRFPalette {
|
|
GRFP_USE_BIT = 0, ///< The bit used for storing the palette to use.
|
|
GRFP_GRF_OFFSET = 2, ///< The offset of the GRFP_GRF data.
|
|
GRFP_GRF_SIZE = 2, ///< The size of the GRFP_GRF data.
|
|
GRFP_BLT_OFFSET = 4, ///< The offset of the GRFP_BLT data.
|
|
GRFP_BLT_SIZE = 1, ///< The size of the GRFP_BLT data.
|
|
|
|
GRFP_USE_DOS = 0x0, ///< The palette state is set to use the DOS palette.
|
|
GRFP_USE_WINDOWS = 0x1, ///< The palette state is set to use the Windows palette.
|
|
GRFP_USE_MASK = 0x1, ///< Bitmask to get only the use palette use states.
|
|
|
|
GRFP_GRF_UNSET = 0x0 << GRFP_GRF_OFFSET, ///< The NewGRF provided no information.
|
|
GRFP_GRF_DOS = 0x1 << GRFP_GRF_OFFSET, ///< The NewGRF says the DOS palette can be used.
|
|
GRFP_GRF_WINDOWS = 0x2 << GRFP_GRF_OFFSET, ///< The NewGRF says the Windows palette can be used.
|
|
GRFP_GRF_ANY = GRFP_GRF_DOS | GRFP_GRF_WINDOWS, ///< The NewGRF says any palette can be used.
|
|
GRFP_GRF_MASK = GRFP_GRF_ANY, ///< Bitmask to get only the NewGRF supplied information.
|
|
|
|
GRFP_BLT_UNSET = 0x0 << GRFP_BLT_OFFSET, ///< The NewGRF provided no information or doesn't care about a 32 bpp blitter.
|
|
GRFP_BLT_32BPP = 0x1 << GRFP_BLT_OFFSET, ///< The NewGRF prefers a 32 bpp blitter.
|
|
GRFP_BLT_MASK = GRFP_BLT_32BPP, ///< Bitmask to only get the blitter information.
|
|
};
|
|
|
|
|
|
/** Basic data to distinguish a GRF. Used in the server list window */
|
|
struct GRFIdentifier {
|
|
uint32_t grfid; ///< GRF ID (defined by Action 0x08)
|
|
MD5Hash md5sum; ///< MD5 checksum of file to distinguish files with the same GRF ID (eg. newer version of GRF)
|
|
|
|
GRFIdentifier() = default;
|
|
GRFIdentifier(const GRFIdentifier &other) = default;
|
|
GRFIdentifier(GRFIdentifier &&other) = default;
|
|
GRFIdentifier(uint32_t grfid, const MD5Hash &md5sum) : grfid(grfid), md5sum(md5sum) {}
|
|
|
|
GRFIdentifier& operator =(const GRFIdentifier &other) = default;
|
|
|
|
/**
|
|
* Does the identification match the provided values?
|
|
* @param grfid Expected grfid.
|
|
* @param md5sum Expected md5sum, may be \c nullptr (in which case, do not check it).
|
|
* @return the object has the provided grfid and md5sum.
|
|
*/
|
|
inline bool HasGrfIdentifier(uint32_t grfid, const MD5Hash *md5sum) const
|
|
{
|
|
if (this->grfid != grfid) return false;
|
|
if (md5sum == nullptr) return true;
|
|
return *md5sum == this->md5sum;
|
|
}
|
|
};
|
|
|
|
/** Information about why GRF had problems during initialisation */
|
|
struct GRFError {
|
|
GRFError(StringID severity, StringID message = 0);
|
|
|
|
std::string custom_message{}; ///< Custom message (if present)
|
|
std::string data{}; ///< Additional data for message and custom_message
|
|
StringID message{}; ///< Default message
|
|
StringID severity{}; ///< Info / Warning / Error / Fatal
|
|
std::array<uint32_t, 2> param_value{}; ///< Values of GRF parameters to show for message and custom_message
|
|
};
|
|
|
|
/** The possible types of a newgrf parameter. */
|
|
enum GRFParameterType {
|
|
PTYPE_UINT_ENUM, ///< The parameter allows a range of numbers, each of which can have a special name
|
|
PTYPE_BOOL, ///< The parameter is either 0 or 1
|
|
PTYPE_END, ///< Invalid parameter type
|
|
};
|
|
|
|
/** Information about one grf parameter. */
|
|
struct GRFParameterInfo {
|
|
GRFParameterInfo(uint nr);
|
|
GRFTextList name; ///< The name of this parameter
|
|
GRFTextList desc; ///< The description of this parameter
|
|
GRFParameterType type; ///< The type of this parameter
|
|
uint32_t min_value; ///< The minimal value this parameter can have
|
|
uint32_t max_value; ///< The maximal value of this parameter
|
|
uint32_t def_value; ///< Default value of this parameter
|
|
uint8_t param_nr; ///< GRF parameter to store content in
|
|
uint8_t first_bit; ///< First bit to use in the GRF parameter
|
|
uint8_t num_bit; ///< Number of bits to use for this parameter
|
|
std::map<uint32_t, GRFTextList> value_names; ///< Names for each value.
|
|
bool complete_labels; ///< True if all values have a label.
|
|
|
|
uint32_t GetValue(struct GRFConfig *config) const;
|
|
void SetValue(struct GRFConfig *config, uint32_t value);
|
|
void Finalize();
|
|
};
|
|
|
|
/** Information about GRF, used in the game and (part of it) in savegames */
|
|
struct GRFConfig : ZeroedMemoryAllocator {
|
|
GRFConfig(const std::string &filename = std::string{});
|
|
GRFConfig(const GRFConfig &config);
|
|
|
|
/* Remove the copy assignment, as the default implementation will not do the right thing. */
|
|
GRFConfig &operator=(GRFConfig &rhs) = delete;
|
|
|
|
GRFIdentifier ident; ///< grfid and md5sum to uniquely identify newgrfs
|
|
MD5Hash original_md5sum; ///< MD5 checksum of original file if only a 'compatible' file was loaded
|
|
std::string filename; ///< Filename - either with or without full path
|
|
GRFTextWrapper name; ///< NOSAVE: GRF name (Action 0x08)
|
|
GRFTextWrapper info; ///< NOSAVE: GRF info (author, copyright, ...) (Action 0x08)
|
|
GRFTextWrapper url; ///< NOSAVE: URL belonging to this GRF.
|
|
std::optional<GRFError> error; ///< NOSAVE: Error/Warning during GRF loading (Action 0x0B)
|
|
|
|
uint32_t version; ///< NOSAVE: Version a NewGRF can set so only the newest NewGRF is shown
|
|
uint32_t min_loadable_version; ///< NOSAVE: Minimum compatible version a NewGRF can define
|
|
uint8_t flags; ///< NOSAVE: GCF_Flags, bitset
|
|
GRFStatus status; ///< NOSAVE: GRFStatus, enum
|
|
uint32_t grf_bugs; ///< NOSAVE: bugs in this GRF in this run, @see enum GRFBugs
|
|
std::array<uint32_t, 0x80> param; ///< GRF parameters
|
|
uint8_t num_params; ///< Number of used parameters
|
|
uint8_t num_valid_params; ///< NOSAVE: Number of valid parameters (action 0x14)
|
|
uint8_t palette; ///< GRFPalette, bitset
|
|
std::vector<std::optional<GRFParameterInfo>> param_info; ///< NOSAVE: extra information about the parameters
|
|
bool has_param_defaults; ///< NOSAVE: did this newgrf specify any defaults for it's parameters
|
|
|
|
struct GRFConfig *next; ///< NOSAVE: Next item in the linked list
|
|
|
|
bool IsCompatible(uint32_t old_version) const;
|
|
void SetParams(const std::vector<uint32_t> &pars);
|
|
void CopyParams(const GRFConfig &src);
|
|
|
|
std::optional<std::string> GetTextfile(TextfileType type) const;
|
|
const char *GetName() const;
|
|
const char *GetDescription() const;
|
|
const char *GetURL() const;
|
|
|
|
void SetParameterDefaults();
|
|
void SetSuitablePalette();
|
|
void FinalizeParameterInfo();
|
|
};
|
|
|
|
/** Method to find GRFs using FindGRFConfig */
|
|
enum FindGRFConfigMode {
|
|
FGCM_EXACT, ///< Only find Grfs matching md5sum
|
|
FGCM_COMPATIBLE, ///< Find best compatible Grf wrt. desired_version
|
|
FGCM_NEWEST, ///< Find newest Grf
|
|
FGCM_NEWEST_VALID,///< Find newest Grf, ignoring Grfs with GCF_INVALID set
|
|
FGCM_ANY, ///< Use first found
|
|
};
|
|
|
|
extern GRFConfig *_all_grfs; ///< First item in list of all scanned NewGRFs
|
|
extern GRFConfig *_grfconfig; ///< First item in list of current GRF set up
|
|
extern GRFConfig *_grfconfig_newgame; ///< First item in list of default GRF set up
|
|
extern GRFConfig *_grfconfig_static; ///< First item in list of static GRF set up
|
|
extern uint _missing_extra_graphics; ///< Number of sprites provided by the fallback extra GRF, i.e. missing in the baseset.
|
|
|
|
/** Callback for NewGRF scanning. */
|
|
struct NewGRFScanCallback {
|
|
/** Make sure the right destructor gets called. */
|
|
virtual ~NewGRFScanCallback() = default;
|
|
/** Called whenever the NewGRF scan completed. */
|
|
virtual void OnNewGRFsScanned() = 0;
|
|
};
|
|
|
|
size_t GRFGetSizeOfDataSection(FileHandle &f);
|
|
|
|
void ScanNewGRFFiles(NewGRFScanCallback *callback);
|
|
const GRFConfig *FindGRFConfig(uint32_t grfid, FindGRFConfigMode mode, const MD5Hash *md5sum = nullptr, uint32_t desired_version = 0);
|
|
GRFConfig *GetGRFConfig(uint32_t grfid, uint32_t mask = 0xFFFFFFFF);
|
|
GRFConfig **CopyGRFConfigList(GRFConfig **dst, const GRFConfig *src, bool init_only);
|
|
void AppendStaticGRFConfigs(GRFConfig **dst);
|
|
void AppendToGRFConfigList(GRFConfig **dst, GRFConfig *el);
|
|
void ClearGRFConfigList(GRFConfig **config);
|
|
void ResetGRFConfig(bool defaults);
|
|
GRFListCompatibility IsGoodGRFConfigList(GRFConfig *grfconfig);
|
|
bool FillGRFDetails(GRFConfig *config, bool is_static, Subdirectory subdir = NEWGRF_DIR);
|
|
std::string GRFBuildParamList(const GRFConfig *c);
|
|
|
|
/* In newgrf_gui.cpp */
|
|
void ShowNewGRFSettings(bool editable, bool show_params, bool exec_changes, GRFConfig **config);
|
|
void OpenGRFParameterWindow(bool is_baseset, GRFConfig *c, bool editable);
|
|
|
|
void UpdateNewGRFScanStatus(uint num, const char *name);
|
|
void UpdateNewGRFConfigPalette(int32_t new_value = 0);
|
|
|
|
#endif /* NEWGRF_CONFIG_H */
|