cargotype.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 CARGOTYPE_H
#define CARGOTYPE_H
 
#include "economy_type.h"
#include "cargo_type.h"
#include "gfx_type.h"
#include "newgrf_callbacks.h"
#include "strings_type.h"
#include "landscape_type.h"
#include "core/bitmath_func.hpp"
 
enum TownAcceptanceEffect : uint8_t {
  TAE_BEGIN = 0,
  TAE_NONE = TAE_BEGIN, 
  TAE_PASSENGERS, 
  TAE_MAIL, 
  TAE_GOODS, 
  TAE_WATER, 
  TAE_FOOD, 
  TAE_END, 
  NUM_TAE = TAE_END, 
};
 
enum TownProductionEffect : uint8_t {
  TPE_NONE, 
  TPE_PASSENGERS, 
  TPE_MAIL, 
  NUM_TPE,
 
  INVALID_TPE,
};
 
enum class CargoClass : uint8_t {
  Passengers   =  0, 
  Mail         =  1, 
  Express      =  2, 
  Armoured     =  3, 
  Bulk         =  4, 
  PieceGoods   =  5, 
  Liquid       =  6, 
  Refrigerated =  7, 
  Hazardous    =  8, 
  Covered      =  9, 
  Oversized    = 10, 
  Powderized   = 11, 
  NotPourable  = 12, 
  Potable      = 13, 
  NonPotable   = 14, 
  Special      = 15, 
};
using CargoClasses = EnumBitSet<CargoClass, uint16_t>;
 
static const uint8_t INVALID_CARGO_BITNUM = 0xFF; 
 
static const uint TOWN_PRODUCTION_DIVISOR = 256;
 
struct CargoSpec {
  CargoLabel label;                
  uint8_t bitnum = INVALID_CARGO_BITNUM; 
  uint8_t legend_colour;
  uint8_t rating_colour;
  uint8_t weight;                    
  uint16_t multiplier = 0x100; 
  CargoClasses classes; 
  int32_t initial_payment;           
  uint8_t transit_periods[2];
 
  bool is_freight;                 
  TownAcceptanceEffect town_acceptance_effect; 
  TownProductionEffect town_production_effect = INVALID_TPE; 
  uint16_t town_production_multiplier = TOWN_PRODUCTION_DIVISOR; 
  CargoCallbackMasks callback_mask;             
 
  StringID name;                   
  StringID name_single;            
  StringID units_volume;           
  StringID quantifier;             
  StringID abbrev;                 
 
  SpriteID sprite;                 
 
  const struct GRFFile *grffile;   
  const struct SpriteGroup *group;
 
  Money current_payment;
 
  inline CargoType Index() const
  {
    return this - CargoSpec::array;
  }
 
  inline bool IsValid() const
  {
    return this->bitnum != INVALID_CARGO_BITNUM;
  }
 
  static inline size_t GetArraySize()
  {
    return lengthof(CargoSpec::array);
  }
 
  static inline CargoSpec *Get(size_t index)
  {
    assert(index < lengthof(CargoSpec::array));
    return &CargoSpec::array[index];
  }
 
  SpriteID GetCargoIcon() const;
 
  inline uint64_t WeightOfNUnits(uint32_t n) const
  {
    return n * this->weight / 16u;
  }
 
  uint64_t WeightOfNUnitsInTrain(uint32_t n) const;
 
  struct Iterator {
    typedef CargoSpec value_type;
    typedef CargoSpec *pointer;
    typedef CargoSpec &reference;
    typedef size_t difference_type;
    typedef std::forward_iterator_tag iterator_category;
 
    explicit Iterator(size_t index) : index(index)
    {
      this->ValidateIndex();
    };
 
    bool operator==(const Iterator &other) const { return this->index == other.index; }
    CargoSpec * operator*() const { return CargoSpec::Get(this->index); }
    Iterator & operator++() { this->index++; this->ValidateIndex(); return *this; }
 
  private:
    size_t index;
    void ValidateIndex() { while (this->index < CargoSpec::GetArraySize() && !(CargoSpec::Get(this->index)->IsValid())) this->index++; }
  };
 
  /*
   * Iterable ensemble of all valid CargoSpec
   */
  struct IterateWrapper {
    size_t from;
    IterateWrapper(size_t from = 0) : from(from) {}
    Iterator begin() { return Iterator(this->from); }
    Iterator end() { return Iterator(CargoSpec::GetArraySize()); }
    bool empty() { return this->begin() == this->end(); }
  };
 
  static IterateWrapper Iterate(size_t from = 0) { return IterateWrapper(from); }
 
  static std::array<std::vector<const CargoSpec *>, NUM_TPE> town_production_cargoes;
 
private:
  static CargoSpec array[NUM_CARGO]; 
  static inline std::map<CargoLabel, CargoType> label_map{}; 
 
  friend void SetupCargoForClimate(LandscapeType l);
  friend void BuildCargoLabelMap();
  friend inline CargoType GetCargoTypeByLabel(CargoLabel ct);
  friend void FinaliseCargoArray();
};
 
extern CargoTypes _cargo_mask;
extern CargoTypes _standard_cargo_mask;
 
void SetupCargoForClimate(LandscapeType l);
bool IsDefaultCargo(CargoType cargo_type);
void BuildCargoLabelMap();
 
std::optional<std::string> BuildCargoAcceptanceString(const CargoArray &acceptance, StringID label);
 
inline CargoType GetCargoTypeByLabel(CargoLabel label)
{
  auto found = CargoSpec::label_map.find(label);
  if (found != std::end(CargoSpec::label_map)) return found->second;
  return INVALID_CARGO;
}
 
Dimension GetLargestCargoIconSize();
 
void InitializeSortedCargoSpecs();
extern std::array<uint8_t, NUM_CARGO> _sorted_cargo_types;
extern std::vector<const CargoSpec *> _sorted_cargo_specs;
extern std::span<const CargoSpec *> _sorted_standard_cargo_specs;
 
inline bool IsCargoInClass(CargoType c, CargoClasses cc)
{
  return CargoSpec::Get(c)->classes.Any(cc);
}
 
using SetCargoBitIterator = SetBitIterator<CargoType, CargoTypes>;
 
struct CargoTypeComparator {
  bool operator() (const CargoType &lhs, const CargoType &rhs) const { return _sorted_cargo_types[lhs] < _sorted_cargo_types[rhs]; }
};
 
#endif /* CARGOTYPE_H */