industry.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 INDUSTRY_H
#define INDUSTRY_H
 
#include "newgrf_storage.h"
#include "subsidy_type.h"
#include "industry_map.h"
#include "industrytype.h"
#include "tilearea_type.h"
#include "station_base.h"
#include "timer/timer_game_calendar.h"
#include "timer/timer_game_economy.h"
 
 
typedef Pool<Industry, IndustryID, 64, 64000> IndustryPool;
extern IndustryPool _industry_pool;
 
static const TimerGameEconomy::Year PROCESSING_INDUSTRY_ABANDONMENT_YEARS = 5; 
 
/*
 * Production level maximum, minimum and default values.
 * It is not a value been really used in order to change, but rather an indicator
 * of how the industry is behaving.
 */
static constexpr uint8_t PRODLEVEL_CLOSURE = 0x00; 
static constexpr uint8_t PRODLEVEL_MINIMUM = 0x04; 
static constexpr uint8_t PRODLEVEL_DEFAULT = 0x10; 
static constexpr uint8_t PRODLEVEL_MAXIMUM = 0x80; 
 
enum IndustryControlFlags : uint8_t {
  INDCTL_NONE                   = 0,
  INDCTL_NO_PRODUCTION_DECREASE = 1 << 0,
  INDCTL_NO_PRODUCTION_INCREASE = 1 << 1,
  INDCTL_NO_CLOSURE             = 1 << 2,
  INDCTL_EXTERNAL_PROD_LEVEL    = 1 << 3,
  INDCTL_MASK = INDCTL_NO_PRODUCTION_DECREASE | INDCTL_NO_PRODUCTION_INCREASE | INDCTL_NO_CLOSURE | INDCTL_EXTERNAL_PROD_LEVEL,
};
DECLARE_ENUM_AS_BIT_SET(IndustryControlFlags);
 
static const int THIS_MONTH = 0;
static const int LAST_MONTH = 1;
 
struct Industry : IndustryPool::PoolItem<&_industry_pool> {
  struct ProducedHistory {
    uint16_t production; 
    uint16_t transported; 
 
    uint8_t PctTransported() const
    {
      if (this->production == 0) return 0;
      return ClampTo<uint8_t>(this->transported * 256 / this->production);
    }
  };
 
  struct ProducedCargo {
    CargoID cargo; 
    uint16_t waiting; 
    uint8_t rate; 
    std::array<ProducedHistory, 25> history; 
  };
 
  struct AcceptedCargo {
    CargoID cargo; 
    uint16_t waiting; 
    TimerGameEconomy::Date last_accepted; 
  };
 
  using ProducedCargoes = std::vector<ProducedCargo>;
  using AcceptedCargoes = std::vector<AcceptedCargo>;
 
  TileArea location;                                     
  Town *town;                                            
  Station *neutral_station;                              
  ProducedCargoes produced; 
  AcceptedCargoes accepted; 
  uint8_t prod_level;                                       
  uint16_t counter;                                        
 
  IndustryType type;             
  Owner owner;                   
  Colours random_colour;         
  TimerGameEconomy::Year last_prod_year; 
  uint8_t was_cargo_delivered;      
  IndustryControlFlags ctlflags; 
 
  PartOfSubsidy part_of_subsidy; 
  StationList stations_near;     
  mutable std::string cached_name; 
 
  Owner founder;                 
  TimerGameCalendar::Date construction_date; 
  uint8_t construction_type;       
  uint8_t selected_layout;          
  Owner exclusive_supplier;      
  Owner exclusive_consumer;      
  std::string text;              
 
  uint16_t random;                 
 
  PersistentStorage *psa;        
 
  Industry(TileIndex tile = INVALID_TILE) : location(tile, 0, 0) {}
  ~Industry();
 
  void RecomputeProductionMultipliers();
 
  inline bool TileBelongsToIndustry(TileIndex tile) const
  {
    return IsTileType(tile, MP_INDUSTRY) && GetIndustryIndex(tile) == this->index;
  }
 
  inline const ProducedCargo &GetProduced(size_t slot) const
  {
    static const ProducedCargo empty{INVALID_CARGO, 0, 0, {}};
    return slot < this->produced.size() ? this->produced[slot] : empty;
  }
 
  inline const AcceptedCargo &GetAccepted(size_t slot) const
  {
    static const AcceptedCargo empty{INVALID_CARGO, 0, {}};
    return slot < this->accepted.size() ? this->accepted[slot] : empty;
  }
 
  inline ProducedCargoes::iterator GetCargoProduced(CargoID cargo)
  {
    if (!IsValidCargoID(cargo)) return std::end(this->produced);
    return std::find_if(std::begin(this->produced), std::end(this->produced), [&cargo](const auto &p) { return p.cargo == cargo; });
  }
 
  inline ProducedCargoes::const_iterator GetCargoProduced(CargoID cargo) const
  {
    if (!IsValidCargoID(cargo)) return std::end(this->produced);
    return std::find_if(std::begin(this->produced), std::end(this->produced), [&cargo](const auto &p) { return p.cargo == cargo; });
  }
 
  inline AcceptedCargoes::iterator GetCargoAccepted(CargoID cargo)
  {
    if (!IsValidCargoID(cargo)) return std::end(this->accepted);
    return std::find_if(std::begin(this->accepted), std::end(this->accepted), [&cargo](const auto &a) { return a.cargo == cargo; });
  }
 
  inline AcceptedCargoes::const_iterator GetCargoAccepted(CargoID cargo) const
  {
    if (!IsValidCargoID(cargo)) return std::end(this->accepted);
    return std::find_if(std::begin(this->accepted), std::end(this->accepted), [&cargo](const auto &a) { return a.cargo == cargo; });
  }
 
  bool IsCargoAccepted() const { return std::any_of(std::begin(this->accepted), std::end(this->accepted), [](const auto &a) { return IsValidCargoID(a.cargo); }); }
 
  bool IsCargoProduced() const { return std::any_of(std::begin(this->produced), std::end(this->produced), [](const auto &p) { return IsValidCargoID(p.cargo); }); }
 
  bool IsCargoAccepted(CargoID cargo) const { return std::any_of(std::begin(this->accepted), std::end(this->accepted), [&cargo](const auto &a) { return a.cargo == cargo; }); }
 
  bool IsCargoProduced(CargoID cargo) const { return std::any_of(std::begin(this->produced), std::end(this->produced), [&cargo](const auto &p) { return p.cargo == cargo; }); }
 
  static inline Industry *GetByTile(TileIndex tile)
  {
    return Industry::Get(GetIndustryIndex(tile));
  }
 
  static Industry *GetRandom();
  static void PostDestructor(size_t index);
 
  static inline void IncIndustryTypeCount(IndustryType type)
  {
    assert(type < NUM_INDUSTRYTYPES);
    counts[type]++;
  }
 
  static inline void DecIndustryTypeCount(IndustryType type)
  {
    assert(type < NUM_INDUSTRYTYPES);
    counts[type]--;
  }
 
  static inline uint16_t GetIndustryTypeCount(IndustryType type)
  {
    assert(type < NUM_INDUSTRYTYPES);
    return counts[type];
  }
 
  static inline void ResetIndustryCounts()
  {
    memset(&counts, 0, sizeof(counts));
  }
 
  inline const std::string &GetCachedName() const
  {
    if (this->cached_name.empty()) this->FillCachedName();
    return this->cached_name;
  }
 
private:
  void FillCachedName() const;
 
protected:
  static uint16_t counts[NUM_INDUSTRYTYPES]; 
};
 
void ClearAllIndustryCachedNames();
 
void PlantRandomFarmField(const Industry *i);
 
void ReleaseDisastersTargetingIndustry(IndustryID);
 
bool IsTileForestIndustry(TileIndex tile);
 
struct IndustryTypeBuildData {
  uint32_t probability;  
  uint8_t   min_number;   
  uint16_t target_count; 
  uint16_t max_wait;     
  uint16_t wait_count;   
 
  void Reset();
 
  bool GetIndustryTypeData(IndustryType it);
};
 
struct IndustryBuildData {
  IndustryTypeBuildData builddata[NUM_INDUSTRYTYPES]; 
  uint32_t wanted_inds; 
 
  void Reset();
 
  void SetupTargetCount();
  void TryBuildNewIndustry();
 
  void EconomyMonthlyLoop();
};
 
extern IndustryBuildData _industry_builder;
 
 
enum IndustryDirectoryInvalidateWindowData {
  IDIWD_FORCE_REBUILD,
  IDIWD_PRODUCTION_CHANGE,
  IDIWD_FORCE_RESORT,
};
 
void TrimIndustryAcceptedProduced(Industry *ind);
 
#endif /* INDUSTRY_H */