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

 
#ifndef NEWGRF_COMMONS_H
#define NEWGRF_COMMONS_H
 
#include "newgrf_type.h"
#include "sprite.h"
#include "command_type.h"
#include "direction_type.h"
#include "company_type.h"
#include "cargo_type.h"
#include "core/bitmath_func.hpp"

enum class TileContext : uint8_t {
  Normal, 
  UpperHalftile, 
  OnBridge, 
};

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();
  }
 
  std::span<const DrawTileSeqStruct> GetSequence() const override { return {this->seq.begin(), this->seq.end()}; }
};

class SpriteLayoutProcessor {
  const NewGRFSpriteLayout *raw_layout = nullptr;
  std::vector<DrawTileSeqStruct> result_seq;
  uint32_t var10_values = 0;
  bool separate_ground = false;
public:
  SpriteLayoutProcessor() = default;

  SpriteLayoutProcessor(const NewGRFSpriteLayout &raw_layout) : raw_layout(&raw_layout) {}
 
  SpriteLayoutProcessor(const NewGRFSpriteLayout &raw_layout, uint32_t orig_offset, uint32_t newgrf_ground_offset, uint32_t newgrf_offset, uint constr_stage, bool separate_ground);

  SetBitIterator<uint8_t, uint32_t> Var10Values() const { return this->var10_values; }
 
  void ProcessRegisters(const struct ResolverObject &object, uint8_t resolved_var10, uint32_t resolved_sprite);

  DrawTileSpriteSpan GetLayout() const
  {
    assert(this->raw_layout != nullptr);
    if (this->result_seq.empty()) {
      /* Simple layout without preprocessing. */
      return {this->raw_layout->ground, this->raw_layout->seq};
    } else {
      /* Dynamic layout with preprocessing. */
      return {this->result_seq[0].image, {++this->result_seq.begin(), this->result_seq.end()}};
    }
  }
};

struct EntityIDMapping {
  GrfID grfid; 
  uint16_t entity_id; 
  uint16_t substitute_id; 
};
 
class OverrideManagerBase {
protected:
  std::vector<uint16_t> entity_overrides;
  std::vector<GrfID> 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, GrfID grfid, uint entity_type);
  virtual uint16_t AddEntityID(uint16_t grf_local_id, GrfID grfid, uint16_t substitute_id);
 
  GrfID GetGRFID(uint16_t entity_id) const;
  uint16_t GetSubstituteID(uint16_t entity_id) const;
  virtual uint16_t GetID(uint16_t grf_local_id, GrfID 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(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, GrfID grfid, uint16_t substitute_id) override;
  uint16_t GetID(uint16_t grf_local_id, GrfID 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(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(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 = TileContext::Normal);
TileIndex GetNearbyTile(uint8_t parameter, TileIndex tile, bool signed_offsets = true, Axis axis = Axis::Invalid);
uint32_t GetNearbyTileInformation(TileIndex tile, bool grf_version8);
uint32_t GetCompanyInfo(CompanyID owner, const struct Livery *l = nullptr);
CommandCost GetErrorMessageFromLocationCallbackResult(uint16_t cb_res, std::span<const int32_t> textstack, const GRFFile *grffile, StringID default_error);
 
void ErrorUnknownCallbackResult(GrfID 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; 
  GrfID grfid{}; 
  const struct GRFFile *grffile = nullptr; 
 
  void SetGRFFile(const struct GRFFile *grffile);

  inline bool HasGrfFile() const { return this->grffile != nullptr; }
};

template <class Tkey, size_t Tcount>
struct FixedGRFFileProps : GRFFilePropsBase {
  std::array<const struct SpriteGroup *, Tcount> spritegroups{}; 

  const struct SpriteGroup *GetSpriteGroup(Tkey index) const { return this->spritegroups[static_cast<size_t>(index)]; }

  const struct SpriteGroup *GetFirstSpriteGroupOf(std::initializer_list<Tkey> indices) const
  {
    for (auto key : indices) {
      auto *result = GetSpriteGroup(key);
      if (result != nullptr) return result;
    }
    return nullptr;
  }

  void SetSpriteGroup(Tkey index, const struct SpriteGroup *spritegroup) { this->spritegroups[static_cast<size_t>(index)] = spritegroup; }
};

enum class StandardSpriteGroup {
  Default, 
  Purchase, 
  End, 
};

struct StandardGRFFileProps : FixedGRFFileProps<StandardSpriteGroup, static_cast<size_t>(StandardSpriteGroup::End)> {
  using FixedGRFFileProps<StandardSpriteGroup, static_cast<size_t>(StandardSpriteGroup::End)>::GetSpriteGroup;

  bool HasSpriteGroups() const
  {
    return GetSpriteGroup(StandardSpriteGroup::Default) != nullptr;
  }

  const struct SpriteGroup *GetSpriteGroup(bool entity_exists) const
  {
    auto *res = entity_exists ? nullptr : GetSpriteGroup(StandardSpriteGroup::Purchase);
    return res ? res : GetSpriteGroup(StandardSpriteGroup::Default);
  }
};

template <class Tkey>
struct VariableGRFFileProps : GRFFilePropsBase {
  using ValueType = std::pair<Tkey, const struct SpriteGroup *>;
  std::vector<ValueType> spritegroups; 

  const SpriteGroup *GetSpriteGroup(Tkey index) const
  {
    auto it = std::ranges::lower_bound(this->spritegroups, index, std::less{}, &ValueType::first);
    if (it == std::end(this->spritegroups) || it->first != index) return nullptr;
    return it->second;
  }

  const struct SpriteGroup *GetFirstSpriteGroupOf(std::initializer_list<Tkey> indices) const
  {
    for (auto key : indices) {
      auto *result = GetSpriteGroup(key);
      if (result != nullptr) return result;
    }
    return nullptr;
  }

  void SetSpriteGroup(Tkey index, const SpriteGroup *spritegroup)
  {
    auto it = std::ranges::lower_bound(this->spritegroups, index, std::less{}, &ValueType::first);
    if (it == std::end(this->spritegroups) || it->first != index) {
      this->spritegroups.emplace(it, index, spritegroup);
    } else {
      it->second = spritegroup;
    }
  }
};

struct CargoGRFFileProps : VariableGRFFileProps<CargoType> {
  static constexpr CargoType SG_DEFAULT{NUM_CARGO}; 
  static constexpr CargoType SG_PURCHASE{NUM_CARGO + 1}; 
  static constexpr CargoType SG_DEFAULT_NA{NUM_CARGO + 2}; 
};

struct SubstituteGRFFileProps : StandardGRFFileProps {
  constexpr SubstituteGRFFileProps(uint16_t subst_id = 0) : subst_id(subst_id), override_id(subst_id) {}
 
  uint16_t subst_id; 
  uint16_t override_id; 
};

template <typename T>
struct LabelObject {
  T label = {}; 
  uint8_t subtype = 0; 
};
 
#endif /* NEWGRF_COMMONS_H */