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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#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 class GRFConfigFlag : uint8_t {
  System, 
  Unsafe, 
  Static, 
  Compatible, 
  Copy, 
  InitOnly, 
  Reserved, 
  Invalid, 
};
using GRFConfigFlags = EnumBitSet<GRFConfigFlag, uint8_t>;

enum class GRFStatus : uint8_t {
  Unknown, 
  Disabled, 
  NotFound, 
  Initialised, 
  Activated, 
};

enum class GRFBug : uint8_t {
  VehLength       = 0, 
  VehRefit        = 1, 
  VehPoweredWagon = 2, 
  UnknownCbResult = 3, 
  VehCapacity     = 4, 
};
using GRFBugs = EnumBitSet<GRFBug, uint8_t>;

enum class GRFListCompatibility : uint8_t {
  AllGood, 
  Compatible, 
  NotFound, 
};

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, uint32_t nfo_line, StringID message = {})
    : message(message), severity(severity), nfo_line(nfo_line) {}
 
  std::string custom_message{}; 
  std::string data{}; 
  StringID message{}; 
  StringID severity{}; 
  uint32_t nfo_line; 
  std::array<uint32_t, 2> param_value{}; 
};

enum class GRFParameterType : uint8_t {
  UintEnum, 
  Bool, 
};

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 = GRFParameterType::UintEnum; 
 
  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::vector<GRFError> errors; 
 
  uint32_t version = 0; 
  uint32_t min_loadable_version = 0; 
  GRFConfigFlags flags = {}; 
  GRFStatus status = GRFStatus::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;
  std::string GetName() const;
  std::optional<std::string> GetDescription() const;
  std::optional<std::string> GetURL() const;
 
  void SetParameterDefaults();
  void SetSuitablePalette();
  void FinalizeParameterInfo();
};
 
using GRFConfigList = std::vector<std::unique_ptr<GRFConfig>>;

enum class FindGRFConfigMode : uint8_t {
  Exact, 
  Compatible, 
  Newest, 
  NewestValid, 
  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 = Subdirectory::NewGrf);
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, std::string &&name);
void UpdateNewGRFConfigPalette();
 
#endif /* NEWGRF_CONFIG_H */