newgrf_internal.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_INTERNAL_H
#define NEWGRF_INTERNAL_H
 
#include "../newgrf.h"
#include "../newgrf_commons.h"
#include "../newgrf_config.h"
#include "../spriteloader/sprite_file_type.hpp"
#include "newgrf_bytereader.h"
 
enum ChangeInfoResult : uint8_t {
  CIR_SUCCESS,    
  CIR_DISABLED,   
  CIR_UNHANDLED,  
  CIR_UNKNOWN,    
  CIR_INVALID_ID, 
};
 
template <GrfSpecFeature TFeature>
struct GrfChangeInfoHandler {
  static ChangeInfoResult Reserve(uint first, uint last, int prop, ByteReader &buf);
  static ChangeInfoResult Activation(uint first, uint last, int prop, ByteReader &buf);
};
 
template <uint8_t TAction>
struct GrfActionHandler {
  static void FileScan(ByteReader &buf);
  static void SafetyScan(ByteReader &buf);
  static void LabelScan(ByteReader &buf);
  static void Init(ByteReader &buf);
  static void Reserve(ByteReader &buf);
  static void Activation(ByteReader &buf);
};
 
static constexpr uint MAX_SPRITEGROUP = UINT8_MAX; 
 
struct GrfProcessingState {
private:
  struct SpriteSet {
    SpriteID sprite;  
    uint num_sprites; 
  };
 
  std::map<uint, SpriteSet> spritesets[GSF_END];
 
public:
  /* Global state */
  GrfLoadingStage stage;    
  SpriteID spriteid;        
 
  /* Local state in the file */
  SpriteFile *file;         
  GRFFile *grffile;         
  GRFConfig *grfconfig;     
  uint32_t nfo_line;          
 
  /* Kind of return values when processing certain actions */
  int skip_sprites;         
 
  /* Currently referenceable spritegroups */
  std::array<const SpriteGroup *, MAX_SPRITEGROUP + 1> spritegroups{};
 
  void ClearDataForNextFile()
  {
    this->nfo_line = 0;
    this->skip_sprites = 0;
 
    for (uint i = 0; i < GSF_END; i++) {
      this->spritesets[i].clear();
    }
 
    this->spritegroups = {};
  }
 
  void AddSpriteSets(uint8_t feature, SpriteID first_sprite, uint first_set, uint numsets, uint numents)
  {
    assert(feature < GSF_END);
    for (uint i = 0; i < numsets; i++) {
      SpriteSet &set = this->spritesets[feature][first_set + i];
      set.sprite = first_sprite + i * numents;
      set.num_sprites = numents;
    }
  }
 
  bool HasValidSpriteSets(uint8_t feature) const
  {
    assert(feature < GSF_END);
    return !this->spritesets[feature].empty();
  }
 
  bool IsValidSpriteSet(uint8_t feature, uint set) const
  {
    assert(feature < GSF_END);
    return this->spritesets[feature].find(set) != this->spritesets[feature].end();
  }
 
  SpriteID GetSprite(uint8_t feature, uint set) const
  {
    assert(IsValidSpriteSet(feature, set));
    return this->spritesets[feature].find(set)->second.sprite;
  }
 
  uint GetNumEnts(uint8_t feature, uint set) const
  {
    assert(IsValidSpriteSet(feature, set));
    return this->spritesets[feature].find(set)->second.num_sprites;
  }
};
 
extern GrfProcessingState _cur;
 
struct GRFLocation {
  uint32_t grfid;
  uint32_t nfoline;
 
  GRFLocation(uint32_t grfid, uint32_t nfoline) : grfid(grfid), nfoline(nfoline) { }
 
  bool operator <(const GRFLocation &other) const
  {
    return this->grfid < other.grfid || (this->grfid == other.grfid && this->nfoline < other.nfoline);
  }
 
  bool operator ==(const GRFLocation &other) const
  {
    return this->grfid == other.grfid && this->nfoline == other.nfoline;
  }
};
 
using GRFLineToSpriteOverride = std::map<GRFLocation, std::vector<uint8_t>>;
 
extern std::map<GRFLocation, std::pair<SpriteID, uint16_t>> _grm_sprites;
extern GRFLineToSpriteOverride _grf_line_to_action6_sprite_override;
 
extern GrfMiscBits _misc_grf_features;
 
void SetNewGRFOverride(uint32_t source_grfid, uint32_t target_grfid);
GRFFile *GetCurrentGRFOverride();
 
std::span<const CargoLabel> GetCargoTranslationTable(const GRFFile &grffile);
CargoTypes TranslateRefitMask(uint32_t refit_mask);
 
void SkipBadgeList(ByteReader &buf);
 
std::vector<BadgeID> ReadBadgeList(ByteReader &buf, GrfSpecFeature feature);
 
void MapSpriteMappingRecolour(PalSpriteID *grf_sprite);
TileLayoutFlags ReadSpriteLayoutSprite(ByteReader &buf, bool read_flags, bool invert_action1_flag, bool use_cur_spritesets, int feature, PalSpriteID *grf_sprite, uint16_t *max_sprite_offset = nullptr, uint16_t *max_palette_offset = nullptr);
bool ReadSpriteLayout(ByteReader &buf, uint num_building_sprites, bool use_cur_spritesets, uint8_t feature, bool allow_var10, bool no_z_position, NewGRFSpriteLayout *dts);
 
GRFFile *GetFileByGRFID(uint32_t grfid);
GRFError *DisableGrf(StringID message = {}, GRFConfig *config = nullptr);
void DisableStaticNewGRFInfluencingNonStaticNewGRFs(GRFConfig &c);
bool HandleChangeInfoResult(const char *caller, ChangeInfoResult cir, uint8_t feature, uint8_t property);
uint32_t GetParamVal(uint8_t param, uint32_t *cond_val);
void GRFUnsafe(ByteReader &);
 
void InitializePatchFlags();
 
#endif /* NEWGRF_INTERNAL_H */