d8/def/newgrf__config_8h_source.html

/*

 * 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 "misc/countedptr.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 {

  PTYPE_UINT_ENUM,

  PTYPE_BOOL,

  PTYPE_END,

};


struct GRFParameterInfo {

  GRFParameterInfo(uint nr);

  GRFTextList name;

  GRFTextList desc;

  GRFParameterType type;

  uint32_t min_value;

  uint32_t max_value;

  uint32_t def_value;

  uint8_t param_nr;

  uint8_t first_bit;

  uint8_t num_bit;

  std::map<uint32_t, GRFTextList> value_names;

  bool complete_labels;


  uint32_t GetValue(struct GRFConfig *config) const;

  void SetValue(struct GRFConfig *config, uint32_t value);

  void Finalize();

};


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;

  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;

  std::array<uint32_t, 0x80> param;

  uint8_t num_params;

  uint8_t num_valid_params;

  uint8_t palette;

  std::vector<std::optional<GRFParameterInfo>> param_info;

  bool has_param_defaults;


  struct GRFConfig *next;


  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();

};


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 */