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 "strings_type.h"
#include "landscape_type.h"
#include "core/bitmath_func.hpp"
#include "core/span_type.hpp"
#include <vector>
 
typedef uint32 CargoLabel;
 
enum TownEffect : byte {
  TE_BEGIN = 0,
  TE_NONE = TE_BEGIN, 
  TE_PASSENGERS,      
  TE_MAIL,            
  TE_GOODS,           
  TE_WATER,           
  TE_FOOD,            
  TE_END,             
  NUM_TE = TE_END,    
};
 
enum CargoClass {
  CC_NOAVAILABLE  = 0,       
  CC_PASSENGERS   = 1 <<  0, 
  CC_MAIL         = 1 <<  1, 
  CC_EXPRESS      = 1 <<  2, 
  CC_ARMOURED     = 1 <<  3, 
  CC_BULK         = 1 <<  4, 
  CC_PIECE_GOODS  = 1 <<  5, 
  CC_LIQUID       = 1 <<  6, 
  CC_REFRIGERATED = 1 <<  7, 
  CC_HAZARDOUS    = 1 <<  8, 
  CC_COVERED      = 1 <<  9, 
  CC_SPECIAL      = 1 << 15, 
};
 
static const byte INVALID_CARGO = 0xFF; 
 
struct CargoSpec {
  uint8 bitnum;                    
  CargoLabel label;                
  uint8 legend_colour;
  uint8 rating_colour;
  uint8 weight;                    
  uint16 multiplier;               
  int32 initial_payment;           
  uint8 transit_days[2];
 
  bool is_freight;                 
  TownEffect town_effect;          
  uint8 callback_mask;             
 
  StringID name;                   
  StringID name_single;            
  StringID units_volume;           
  StringID quantifier;             
  StringID abbrev;                 
 
  SpriteID sprite;                 
 
  uint16 classes;                  
  const struct GRFFile *grffile;   
  const struct SpriteGroup *group;
 
  Money current_payment;
 
  inline CargoID Index() const
  {
    return this - CargoSpec::array;
  }
 
  inline bool IsValid() const
  {
    return this->bitnum != INVALID_CARGO;
  }
 
  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 WeightOfNUnits(uint32 n) const
  {
    return n * this->weight / 16u;
  }
 
  uint64 WeightOfNUnitsInTrain(uint32 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; }
    bool operator!=(const Iterator &other) const { return !(*this == other); }
    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); }
 
private:
  static CargoSpec array[NUM_CARGO]; 
 
  friend void SetupCargoForClimate(LandscapeID l);
};
 
extern CargoTypes _cargo_mask;
extern CargoTypes _standard_cargo_mask;
 
void SetupCargoForClimate(LandscapeID l);
CargoID GetCargoIDByLabel(CargoLabel cl);
CargoID GetCargoIDByBitnum(uint8 bitnum);
CargoID GetDefaultCargoID(LandscapeID l, CargoType ct);
 
void InitializeSortedCargoSpecs();
extern std::vector<const CargoSpec *> _sorted_cargo_specs;
extern span<const CargoSpec *> _sorted_standard_cargo_specs;
 
static inline bool IsCargoInClass(CargoID c, CargoClass cc)
{
  return (CargoSpec::Get(c)->classes & cc) != 0;
}
 
using SetCargoBitIterator = SetBitIterator<CargoID, CargoTypes>;
 
#endif /* CARGOTYPE_H */