newgrf_commons.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_COMMONS_H
#define NEWGRF_COMMONS_H
 
#include "sprite.h"
#include "core/alloc_type.hpp"
#include "command_type.h"
#include "direction_type.h"
#include "company_type.h"
 
enum TileContext : uint8_t {
  TCX_NORMAL,         
  TCX_UPPER_HALFTILE, 
  TCX_ON_BRIDGE,      
};
 
enum TileLayoutFlags : uint8_t {
  TLF_NOTHING           = 0x00,
 
  TLF_DODRAW            = 0x01,   
  TLF_SPRITE            = 0x02,   
  TLF_PALETTE           = 0x04,   
  TLF_CUSTOM_PALETTE    = 0x08,   
 
  TLF_BB_XY_OFFSET      = 0x10,   
  TLF_BB_Z_OFFSET       = 0x20,   
 
  TLF_CHILD_X_OFFSET    = 0x10,   
  TLF_CHILD_Y_OFFSET    = 0x20,   
 
  TLF_SPRITE_VAR10      = 0x40,   
  TLF_PALETTE_VAR10     = 0x80,   
 
  TLF_KNOWN_FLAGS       = 0xFF,   
 
  TLF_DRAWING_FLAGS     = TLF_KNOWN_FLAGS & ~TLF_CUSTOM_PALETTE,
 
  TLF_NON_GROUND_FLAGS  = TLF_BB_XY_OFFSET | TLF_BB_Z_OFFSET | TLF_CHILD_X_OFFSET | TLF_CHILD_Y_OFFSET,
 
  TLF_VAR10_FLAGS       = TLF_SPRITE_VAR10 | TLF_PALETTE_VAR10,
 
  TLF_SPRITE_REG_FLAGS  = TLF_DODRAW | TLF_SPRITE | TLF_BB_XY_OFFSET | TLF_BB_Z_OFFSET | TLF_CHILD_X_OFFSET | TLF_CHILD_Y_OFFSET,
 
  TLF_PALETTE_REG_FLAGS = TLF_PALETTE,
};
DECLARE_ENUM_AS_BIT_SET(TileLayoutFlags)
 
 
inline uint GetConstructionStageOffset(uint construction_stage, uint num_sprites)
{
  assert(num_sprites > 0);
  if (num_sprites > 4) num_sprites = 4;
  switch (construction_stage) {
    case 0: return 0;
    case 1: return num_sprites > 2 ? 1 : 0;
    case 2: return num_sprites > 2 ? num_sprites - 2 : 0;
    case 3: return num_sprites - 1;
    default: NOT_REACHED();
  }
}
 
struct TileLayoutRegisters {
  TileLayoutFlags flags; 
  uint8_t dodraw;          
  uint8_t sprite;          
  uint8_t palette;         
  uint16_t max_sprite_offset;  
  uint16_t max_palette_offset; 
  union {
    uint8_t parent[3];   
    uint8_t child[2];    
  } delta;
  uint8_t sprite_var10;    
  uint8_t palette_var10;   
};
 
static const uint TLR_MAX_VAR10 = 7; 
 
struct NewGRFSpriteLayout : DrawTileSprites {
  std::vector<DrawTileSeqStruct> seq{};
  std::vector<TileLayoutRegisters> registers{};
 
  uint consistent_max_offset = 0;
 
  void Allocate(uint num_sprites);
  void AllocateRegisters();
 
  bool NeedsPreprocessing() const
  {
    return !this->registers.empty();
  }
 
  uint32_t PrepareLayout(uint32_t orig_offset, uint32_t newgrf_ground_offset, uint32_t newgrf_offset, uint constr_stage, bool separate_ground) const;
  void ProcessRegisters(uint8_t resolved_var10, uint32_t resolved_sprite, bool separate_ground) const;
 
  std::span<DrawTileSeqStruct> GetLayout(PalSpriteID *ground) const
  {
    *ground = result_seq[0].image;
    return {++result_seq.begin(), result_seq.end()};
  }
 
  std::span<const DrawTileSeqStruct> GetSequence() const override { return {this->seq.begin(), this->seq.end()}; }
 
 
private:
  static std::vector<DrawTileSeqStruct> result_seq; 
};
 
struct EntityIDMapping {
  uint32_t grfid;          
  uint16_t entity_id; 
  uint16_t substitute_id; 
};
 
class OverrideManagerBase {
protected:
  std::vector<uint16_t> entity_overrides;
  std::vector<uint32_t> grfid_overrides;
 
  uint16_t max_offset;   
  uint16_t max_entities; 
 
  uint16_t invalid_id;   
  virtual bool CheckValidNewID([[maybe_unused]] uint16_t testid) { return true; }
 
public:
  std::vector<EntityIDMapping> mappings; 
 
  OverrideManagerBase(uint16_t offset, uint16_t maximum, uint16_t invalid);
  virtual ~OverrideManagerBase() = default;
 
  void ResetOverride();
  void ResetMapping();
 
  void Add(uint16_t local_id, uint32_t grfid, uint entity_type);
  virtual uint16_t AddEntityID(uint16_t grf_local_id, uint32_t grfid, uint16_t substitute_id);
 
  uint32_t GetGRFID(uint16_t entity_id) const;
  uint16_t GetSubstituteID(uint16_t entity_id) const;
  virtual uint16_t GetID(uint16_t grf_local_id, uint32_t grfid) const;
 
  inline uint16_t GetMaxMapping() const { return this->max_entities; }
  inline uint16_t GetMaxOffset() const { return this->max_offset; }
};
 
 
struct HouseSpec;
class HouseOverrideManager : public OverrideManagerBase {
public:
  HouseOverrideManager(uint16_t offset, uint16_t maximum, uint16_t invalid) :
      OverrideManagerBase(offset, maximum, invalid) {}
 
  void SetEntitySpec(const HouseSpec *hs);
};
 
 
struct IndustrySpec;
class IndustryOverrideManager : public OverrideManagerBase {
public:
  IndustryOverrideManager(uint16_t offset, uint16_t maximum, uint16_t invalid) :
      OverrideManagerBase(offset, maximum, invalid) {}
 
  uint16_t AddEntityID(uint16_t grf_local_id, uint32_t grfid, uint16_t substitute_id) override;
  uint16_t GetID(uint16_t grf_local_id, uint32_t grfid) const override;
 
  void SetEntitySpec(IndustrySpec *inds);
};
 
 
struct IndustryTileSpec;
class IndustryTileOverrideManager : public OverrideManagerBase {
protected:
  bool CheckValidNewID(uint16_t testid) override { return testid != 0xFF; }
public:
  IndustryTileOverrideManager(uint16_t offset, uint16_t maximum, uint16_t invalid) :
      OverrideManagerBase(offset, maximum, invalid) {}
 
  void SetEntitySpec(const IndustryTileSpec *indts);
};
 
struct AirportSpec;
class AirportOverrideManager : public OverrideManagerBase {
public:
  AirportOverrideManager(uint16_t offset, uint16_t maximum, uint16_t invalid) :
      OverrideManagerBase(offset, maximum, invalid) {}
 
  void SetEntitySpec(AirportSpec *inds);
};
 
struct AirportTileSpec;
class AirportTileOverrideManager : public OverrideManagerBase {
protected:
  bool CheckValidNewID(uint16_t testid) override { return testid != 0xFF; }
public:
  AirportTileOverrideManager(uint16_t offset, uint16_t maximum, uint16_t invalid) :
      OverrideManagerBase(offset, maximum, invalid) {}
 
  void SetEntitySpec(const AirportTileSpec *ats);
};
 
struct ObjectSpec;
class ObjectOverrideManager : public OverrideManagerBase {
protected:
  bool CheckValidNewID(uint16_t testid) override { return testid != 0xFF; }
public:
  ObjectOverrideManager(uint16_t offset, uint16_t maximum, uint16_t invalid) :
      OverrideManagerBase(offset, maximum, invalid) {}
 
  void SetEntitySpec(ObjectSpec *spec);
};
 
extern HouseOverrideManager _house_mngr;
extern IndustryOverrideManager _industry_mngr;
extern IndustryTileOverrideManager _industile_mngr;
extern AirportOverrideManager _airport_mngr;
extern AirportTileOverrideManager _airporttile_mngr;
extern ObjectOverrideManager _object_mngr;
 
uint32_t GetTerrainType(TileIndex tile, TileContext context = TCX_NORMAL);
TileIndex GetNearbyTile(uint8_t parameter, TileIndex tile, bool signed_offsets = true, Axis axis = INVALID_AXIS);
uint32_t GetNearbyTileInformation(TileIndex tile, bool grf_version8);
uint32_t GetCompanyInfo(CompanyID owner, const struct Livery *l = nullptr);
CommandCost GetErrorMessageFromLocationCallbackResult(uint16_t cb_res, const GRFFile *grffile, StringID default_error);
 
void ErrorUnknownCallbackResult(uint32_t grfid, uint16_t cbid, uint16_t cb_res);
bool ConvertBooleanCallback(const struct GRFFile *grffile, uint16_t cbid, uint16_t cb_res);
bool Convert8bitBooleanCallback(const struct GRFFile *grffile, uint16_t cbid, uint16_t cb_res);
 
struct GRFFilePropsBase {
  uint16_t local_id = 0; 
  uint32_t grfid = 0; 
  const struct GRFFile *grffile = nullptr; 
 
  void SetGRFFile(const struct GRFFile *grffile);
 
  inline bool HasGrfFile() const { return this->grffile != nullptr; }
};
 
template <size_t Tcount>
struct FixedGRFFileProps : GRFFilePropsBase {
  std::array<const struct SpriteGroup *, Tcount> spritegroups{}; 
 
  const struct SpriteGroup *GetSpriteGroup(size_t index = 0) const { return this->spritegroups[index]; }
 
  void SetSpriteGroup(size_t index, const struct SpriteGroup *spritegroup) { this->spritegroups[index] = spritegroup; }
};
 
struct VariableGRFFileProps : GRFFilePropsBase {
  using CargoSpriteGroup = std::pair<size_t, const struct SpriteGroup *>;
  std::vector<CargoSpriteGroup> spritegroups; 
 
  const struct SpriteGroup *GetSpriteGroup(size_t index) const;
  void SetSpriteGroup(size_t index, const struct SpriteGroup *spritegroup);
};
 
struct GRFFileProps : FixedGRFFileProps<1> {
  constexpr GRFFileProps(uint16_t subst_id = 0) : subst_id(subst_id), override(subst_id) {}
 
  uint16_t subst_id;
  uint16_t override; 
};
 
template <typename T>
struct LabelObject {
  T label = {}; 
  uint8_t subtype = 0; 
};
 
#endif /* NEWGRF_COMMONS_H */