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

 
#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 class ChangeInfoResult : uint8_t {
  Success, 
  Disabled, 
  Unhandled, 
  Unknown, 
  InvalidId, 
};

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::array<std::map<uint, SpriteSet>, to_underlying(GrfSpecFeature::End)> spritesets{};
 
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;         

  std::array<const SpriteGroup *, MAX_SPRITEGROUP + 1> spritegroups{};

  void ClearDataForNextFile()
  {
    this->nfo_line = 0;
    this->skip_sprites = 0;
 
    for (auto &s : this->spritesets) {
      s.clear();
    }
 
    this->spritegroups = {};
  }

  void AddSpriteSets(GrfSpecFeature feature, SpriteID first_sprite, uint first_set, uint numsets, uint numents)
  {
    assert(feature < GrfSpecFeature::End);
    for (uint i = 0; i < numsets; i++) {
      SpriteSet &set = this->spritesets[to_underlying(feature)][first_set + i];
      set.sprite = first_sprite + i * numents;
      set.num_sprites = numents;
    }
  }

  bool HasValidSpriteSets(GrfSpecFeature feature) const
  {
    assert(feature < GrfSpecFeature::End);
    return !this->spritesets[to_underlying(feature)].empty();
  }

  bool IsValidSpriteSet(GrfSpecFeature feature, uint set) const
  {
    assert(feature < GrfSpecFeature::End);
    return this->spritesets[to_underlying(feature)].find(set) != this->spritesets[to_underlying(feature)].end();
  }

  SpriteID GetSprite(GrfSpecFeature feature, uint set) const
  {
    assert(IsValidSpriteSet(feature, set));
    return this->spritesets[to_underlying(feature)].find(set)->second.sprite;
  }

  uint GetNumEnts(GrfSpecFeature feature, uint set) const
  {
    assert(IsValidSpriteSet(feature, set));
    return this->spritesets[to_underlying(feature)].find(set)->second.num_sprites;
  }
};
 
extern GrfProcessingState _cur_gps;
 
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, GrfSpecFeature 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, GrfSpecFeature 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(std::string_view caller, ChangeInfoResult cir, GrfSpecFeature feature, uint8_t property);
uint32_t GetParamVal(uint8_t param, uint32_t *cond_val);
void GRFUnsafe(ByteReader &);
 
void InitializePatchFlags();
 
#endif /* NEWGRF_INTERNAL_H */