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

 
#ifndef INDUSTRY_H
#define INDUSTRY_H
 
#include "core/flatset_type.hpp"
#include "misc/history_type.hpp"
#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> 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 class IndustryControlFlag : uint8_t {
  NoProductionDecrease = 0,
  NoProductionIncrease = 1,
  NoClosure = 2,
  ExternalProdLevel = 3,
  End, 
};

using IndustryControlFlags = EnumBitSet<IndustryControlFlag, uint8_t, IndustryControlFlag::End>;

struct Industry : IndustryPool::PoolItem<&_industry_pool> {
  struct ProducedHistory {
    uint16_t production = 0; 
    uint16_t transported = 0; 
 
    uint8_t PctTransported() const
    {
      if (this->production == 0) return 0;
      return ClampTo<uint8_t>(this->transported * 256 / this->production);
    }
  };
  struct ProducedCargo {
    CargoType cargo = INVALID_CARGO; 
    uint16_t waiting = 0; 
    uint8_t rate = 0; 
    HistoryData<ProducedHistory> history{}; 
  };
 
  struct AcceptedHistory {
    uint16_t accepted = 0; 
    uint16_t waiting = 0; 
  };
 
  struct AcceptedCargo {
    CargoType cargo = INVALID_CARGO; 
    uint16_t waiting = 0; 
    uint32_t accumulated_waiting = 0; 
    TimerGameEconomy::Date last_accepted{}; 
    std::unique_ptr<HistoryData<AcceptedHistory>> history{}; 

    inline HistoryData<AcceptedHistory> &GetOrCreateHistory()
    {
      if (this->history == nullptr) this->history = std::make_unique<HistoryData<AcceptedHistory>>();
      return *this->history;
    }
  };
 
  using ProducedCargoes = std::vector<ProducedCargo>;
  using AcceptedCargoes = std::vector<AcceptedCargo>;
 
  TileArea location{INVALID_TILE, 0, 0}; 
  Town *town = nullptr; 
  Station *neutral_station = nullptr; 
  ValidHistoryMask valid_history = 0; 
  ProducedCargoes produced{}; 
  AcceptedCargoes accepted{}; 
  uint8_t prod_level = 0; 
  uint16_t counter = 0; 
 
  IndustryType type = 0; 
  Owner owner = INVALID_OWNER; 
  Colours random_colour = Colours::Begin; 
  TimerGameEconomy::Year last_prod_year{}; 
  uint8_t was_cargo_delivered = 0; 
  IndustryControlFlags ctlflags{}; 
 
  PartsOfSubsidy part_of_subsidy{}; 
  StationList stations_near{}; 
  mutable std::string cached_name{}; 
 
  Owner founder = INVALID_OWNER; 
  TimerGameCalendar::Date construction_date{}; 
  IndustryConstructionType construction_type{}; 
  uint8_t selected_layout = 0; 
  Owner exclusive_supplier = INVALID_OWNER; 
  Owner exclusive_consumer = INVALID_OWNER; 
  EncodedString text{}; 
 
  uint16_t random = 0; 
 
  PersistentStorage *psa = nullptr; 
 
  Industry(IndustryID index, TileIndex tile = INVALID_TILE) : IndustryPool::PoolItem<&_industry_pool>(index), location(tile, 0, 0) {}
  ~Industry();
 
  void RecomputeProductionMultipliers();

  inline bool TileBelongsToIndustry(TileIndex tile) const
  {
    return IsTileType(tile, TileType::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, 0, {}, {}};
    return slot < this->accepted.size() ? this->accepted[slot] : empty;
  }

  inline ProducedCargoes::iterator GetCargoProduced(CargoType cargo)
  {
    if (!IsValidCargoType(cargo)) return std::end(this->produced);
    return std::ranges::find(this->produced, cargo, &ProducedCargo::cargo);
  }

  inline ProducedCargoes::const_iterator GetCargoProduced(CargoType cargo) const
  {
    if (!IsValidCargoType(cargo)) return std::end(this->produced);
    return std::ranges::find(this->produced, cargo, &ProducedCargo::cargo);
  }

  inline AcceptedCargoes::iterator GetCargoAccepted(CargoType cargo)
  {
    if (!IsValidCargoType(cargo)) return std::end(this->accepted);
    return std::ranges::find(this->accepted, cargo, &AcceptedCargo::cargo);
  }

  inline AcceptedCargoes::const_iterator GetCargoAccepted(CargoType cargo) const
  {
    if (!IsValidCargoType(cargo)) return std::end(this->accepted);
    return std::ranges::find(this->accepted, cargo, &AcceptedCargo::cargo);
  }

  bool IsCargoAccepted() const { return std::any_of(std::begin(this->accepted), std::end(this->accepted), [](const auto &a) { return IsValidCargoType(a.cargo); }); }

  bool IsCargoProduced() const { return std::any_of(std::begin(this->produced), std::end(this->produced), [](const auto &p) { return IsValidCargoType(p.cargo); }); }

  bool IsCargoAccepted(CargoType cargo) const { return std::any_of(std::begin(this->accepted), std::end(this->accepted), [&cargo](const auto &a) { return a.cargo == cargo; }); }

  bool IsCargoProduced(CargoType 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 uint16_t GetIndustryTypeCount(IndustryType type)
  {
    assert(type < NUM_INDUSTRYTYPES);
    return static_cast<uint16_t>(std::size(industries[type]));
  }
 
  inline const std::string &GetCachedName() const
  {
    if (this->cached_name.empty()) this->FillCachedName();
    return this->cached_name;
  }
 
  static std::array<FlatSet<IndustryID>, NUM_INDUSTRYTYPES> industries; 
 
private:
  void FillCachedName() const;
};
 
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 : uint8_t {
  IDIWD_FORCE_REBUILD,
  IDIWD_PRODUCTION_CHANGE,
  IDIWD_FORCE_RESORT,
};
 
void TrimIndustryAcceptedProduced(Industry *ind);
 
#endif /* INDUSTRY_H */