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

 
#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 class TownAcceptanceEffect : uint8_t {
  Begin = 0, 
  None = TownAcceptanceEffect::Begin, 
  Passengers, 
  Mail, 
  Goods, 
  Water, 
  Food, 
  End, 
};
 
DECLARE_INCREMENT_DECREMENT_OPERATORS(TownAcceptanceEffect)
 

enum class TownProductionEffect : uint8_t {
  None, 
  Passengers, 
  Mail, 
  End, 

  Invalid,
};

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; 
  PixelColour legend_colour;
  PixelColour 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 = TownProductionEffect::Invalid; 
  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 static_cast<CargoType>(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++; }
  };

  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 inline EnumIndexArray<std::vector<const CargoSpec *>, TownProductionEffect, TownProductionEffect::End> 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 cargo, CargoClasses cc)
{
  return CargoSpec::Get(cargo)->classes.Any(cc);
}

struct CargoTypeComparator {
  bool operator() (const CargoType &lhs, const CargoType &rhs) const { return _sorted_cargo_types[lhs] < _sorted_cargo_types[rhs]; }
};
 
#endif /* CARGOTYPE_H */