newgrf_config.h

Go to the documentation of this file.

/*
 * 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/>.
 */
 
#ifndef NEWGRF_CONFIG_H
#define NEWGRF_CONFIG_H
 
#include "strings_type.h"
#include "fileio_type.h"
#include "textfile_type.h"
#include "newgrf_text.h"
#include "3rdparty/md5/md5.h"
 
enum GRFConfigFlag : uint8_t {
  System,     
  Unsafe,     
  Static,     
  Compatible, 
  Copy,       
  InitOnly,   
  Reserved,   
  Invalid,    
};
using GRFConfigFlags = EnumBitSet<GRFConfigFlag, uint8_t>;
 
enum GRFStatus : uint8_t {
  GCS_UNKNOWN,      
  GCS_DISABLED,     
  GCS_NOT_FOUND,    
  GCS_INITIALISED,  
  GCS_ACTIVATED,    
};
 
enum class GRFBug : uint8_t {
  VehLength       = 0, 
  VehRefit        = 1, 
  VehPoweredWagon = 2, 
  UnknownCbResult = 3, 
  VehCapacity     = 4, 
};
using GRFBugs = EnumBitSet<GRFBug, uint8_t>;
 
enum GRFListCompatibility : uint8_t {
  GLC_ALL_GOOD,   
  GLC_COMPATIBLE, 
  GLC_NOT_FOUND,  
};
 
enum GRFPalette : uint8_t {
  GRFP_USE_BIT     = 0,   
  GRFP_GRF_OFFSET  = 2,   
  GRFP_GRF_SIZE    = 2,   
  GRFP_BLT_OFFSET  = 4,   
  GRFP_BLT_SIZE    = 1,   
 
  GRFP_USE_DOS     = 0x0, 
  GRFP_USE_WINDOWS = 0x1, 
  GRFP_USE_MASK    = 0x1, 
 
  GRFP_GRF_UNSET   = 0x0 << GRFP_GRF_OFFSET,          
  GRFP_GRF_DOS     = 0x1 << GRFP_GRF_OFFSET,          
  GRFP_GRF_WINDOWS = 0x2 << GRFP_GRF_OFFSET,          
  GRFP_GRF_ANY     = GRFP_GRF_DOS | GRFP_GRF_WINDOWS, 
  GRFP_GRF_MASK    = GRFP_GRF_ANY,                    
 
  GRFP_BLT_UNSET   = 0x0 << GRFP_BLT_OFFSET,          
  GRFP_BLT_32BPP   = 0x1 << GRFP_BLT_OFFSET,          
  GRFP_BLT_MASK    = GRFP_BLT_32BPP,                  
};
 
 
struct GRFIdentifier {
  uint32_t grfid;     
  MD5Hash md5sum;   
 
  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;
 
  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;
  }
};
 
struct GRFError {
  GRFError(StringID severity, StringID message = {});
 
  std::string custom_message{}; 
  std::string data{}; 
  StringID message{}; 
  StringID severity{}; 
  std::array<uint32_t, 2> param_value{}; 
};
 
enum GRFParameterType : uint8_t {
  PTYPE_UINT_ENUM, 
  PTYPE_BOOL,      
  PTYPE_END,       
};
 
struct GRFParameterInfo {
  explicit GRFParameterInfo(uint nr) : param_nr(nr) {}
 
  GRFTextList name = {}; 
  GRFTextList desc = {}; 
 
  uint32_t min_value = 0; 
  uint32_t max_value = UINT32_MAX; 
  uint32_t def_value = 0; 
 
  GRFParameterType type = PTYPE_UINT_ENUM; 
 
  uint8_t param_nr; 
  uint8_t first_bit = 0; 
  uint8_t num_bit = 32; 
 
  bool complete_labels = false; 
 
  using ValueName = std::pair<uint32_t, GRFTextList>;
  std::vector<ValueName> value_names; 
 
  void Finalize();
};
 
struct GRFConfig {
  static constexpr uint8_t MAX_NUM_PARAMS = 0x80;
 
  GRFConfig() = default;
  GRFConfig(const std::string &filename) : filename(filename) {}
  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{}; 
  MD5Hash original_md5sum{}; 
  std::string filename{}; 
  GRFTextWrapper name{}; 
  GRFTextWrapper info{}; 
  GRFTextWrapper url{}; 
  std::optional<GRFError> error = std::nullopt; 
 
  uint32_t version = 0; 
  uint32_t min_loadable_version = 0; 
  GRFConfigFlags flags = {}; 
  GRFStatus status = GCS_UNKNOWN; 
  GRFBugs grf_bugs = {}; 
  uint8_t num_valid_params = MAX_NUM_PARAMS; 
  uint8_t palette = 0; 
  bool has_param_defaults = false; 
  std::vector<std::optional<GRFParameterInfo>> param_info; 
  std::vector<uint32_t> param; 
 
  bool IsCompatible(uint32_t old_version) const;
  void SetParams(std::span<const uint32_t> pars);
  void CopyParams(const GRFConfig &src);
 
  uint32_t GetValue(const GRFParameterInfo &info) const;
  void SetValue(const GRFParameterInfo &info, uint32_t value);
 
  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();
};
 
using GRFConfigList = std::vector<std::unique_ptr<GRFConfig>>;
 
enum FindGRFConfigMode : uint8_t {
  FGCM_EXACT,       
  FGCM_COMPATIBLE,  
  FGCM_NEWEST,      
  FGCM_NEWEST_VALID,
  FGCM_ANY,         
};
 
extern GRFConfigList _all_grfs;          
extern GRFConfigList _grfconfig;         
extern GRFConfigList _grfconfig_newgame; 
extern GRFConfigList _grfconfig_static;  
extern uint _missing_extra_graphics;  
 
struct NewGRFScanCallback {
  virtual ~NewGRFScanCallback() = default;
  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);
void CopyGRFConfigList(GRFConfigList &dst, const GRFConfigList &src, bool init_only);
void AppendStaticGRFConfigs(GRFConfigList &dst);
void AppendToGRFConfigList(GRFConfigList &dst, std::unique_ptr<GRFConfig> &&el);
void ClearGRFConfigList(GRFConfigList &config);
void ResetGRFConfig(bool defaults);
GRFListCompatibility IsGoodGRFConfigList(GRFConfigList &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, GRFConfigList &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 */