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 "core/alloc_type.hpp"
#include "fileio_type.h"
#include "textfile_type.h"
#include "newgrf_text.h"
#include "3rdparty/md5/md5.h"
 
enum GCF_Flags {
  GCF_SYSTEM,     
  GCF_UNSAFE,     
  GCF_STATIC,     
  GCF_COMPATIBLE, 
  GCF_COPY,       
  GCF_INIT_ONLY,  
  GCF_RESERVED,   
  GCF_INVALID,    
};
 
enum GRFStatus {
  GCS_UNKNOWN,      
  GCS_DISABLED,     
  GCS_NOT_FOUND,    
  GCS_INITIALISED,  
  GCS_ACTIVATED,    
};
 
enum GRFBugs {
  GBUG_VEH_LENGTH,        
  GBUG_VEH_REFIT,         
  GBUG_VEH_POWERED_WAGON, 
  GBUG_UNKNOWN_CB_RESULT, 
  GBUG_VEH_CAPACITY,      
};
 
enum GRFListCompatibility {
  GLC_ALL_GOOD,   
  GLC_COMPATIBLE, 
  GLC_NOT_FOUND,  
};
 
enum GRFPalette {
  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 = 0);
 
  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; 
 
  std::map<uint32_t, GRFTextList> value_names = {}; 
 
  void Finalize();
};
 
struct GRFConfig : ZeroedMemoryAllocator {
  static constexpr uint8_t MAX_NUM_PARAMS = 0x80;
 
  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; 
  MD5Hash original_md5sum; 
  std::string filename; 
  GRFTextWrapper name; 
  GRFTextWrapper info; 
  GRFTextWrapper url; 
  std::optional<GRFError> error; 
 
  uint32_t version; 
  uint32_t min_loadable_version; 
  uint8_t flags; 
  GRFStatus status; 
  uint32_t grf_bugs; 
  uint8_t num_valid_params; 
  uint8_t palette; 
  bool has_param_defaults; 
  std::vector<std::optional<GRFParameterInfo>> param_info; 
  std::vector<uint32_t> param; 
 
  struct GRFConfig *next; 
 
  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();
};
 
enum FindGRFConfigMode {
  FGCM_EXACT,       
  FGCM_COMPATIBLE,  
  FGCM_NEWEST,      
  FGCM_NEWEST_VALID,
  FGCM_ANY,         
};
 
extern GRFConfig *_all_grfs;          
extern GRFConfig *_grfconfig;         
extern GRFConfig *_grfconfig_newgame; 
extern GRFConfig *_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);
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 */