company_base.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 COMPANY_BASE_H
#define COMPANY_BASE_H
 
#include "road_type.h"
#include "livery.h"
#include "autoreplace_type.h"
#include "tile_type.h"
#include "timer/timer_game_economy.h"
#include "settings_type.h"
#include "group.h"
 
static const Money COMPANY_MAX_LOAN_DEFAULT = INT64_MIN;
 
struct CompanyEconomyEntry {
  Money income = 0; 
  Money expenses = 0; 
  CargoArray delivered_cargo{}; 
  int32_t performance_history = 0; 
  Money company_value = 0; 
};
 
struct CompanyInfrastructure {
  std::array<uint32_t, RAILTYPE_END> rail{}; 
  std::array<uint32_t, ROADTYPE_END> road{}; 
  uint32_t signal = 0; 
  uint32_t water = 0; 
  uint32_t station = 0; 
  uint32_t airport = 0; 
 
  auto operator<=>(const CompanyInfrastructure &) const = default;
 
  uint32_t GetRailTotal() const
  {
    return std::accumulate(std::begin(this->rail), std::end(this->rail), 0U);
  }
 
  uint32_t GetRoadTotal() const;
  uint32_t GetTramTotal() const;
};
 
class FreeUnitIDGenerator {
public:
  UnitID NextID() const;
  UnitID UseID(UnitID index);
  void ReleaseID(UnitID index);
 
private:
  using BitmapStorage = size_t;
  static constexpr size_t BITMAP_SIZE = std::numeric_limits<BitmapStorage>::digits;
 
  std::vector<BitmapStorage> used_bitmap{};
};
 
typedef Pool<Company, CompanyID, 1> CompanyPool;
extern CompanyPool _company_pool;
 
struct CompanyProperties {
  uint32_t name_2 = 0; 
  StringID name_1 = INVALID_STRING_ID; 
  std::string name{}; 
 
  StringID president_name_1 = INVALID_STRING_ID; 
  uint32_t president_name_2 = 0; 
  std::string president_name{}; 
 
  NetworkAuthorizedKeys allow_list{}; 
 
  CompanyManagerFace face{}; 
 
  Money money = 0; 
  uint8_t money_fraction = 0; 
  Money current_loan = 0; 
  Money max_loan = COMPANY_MAX_LOAN_DEFAULT; 
 
  Colours colour = COLOUR_BEGIN; 
 
  uint8_t block_preview = 0; 
 
  TileIndex location_of_HQ = INVALID_TILE; 
  TileIndex last_build_coordinate{}; 
 
  TimerGameEconomy::Year inaugurated_year{}; 
  TimerGameCalendar::Year inaugurated_year_calendar{}; 
 
  uint8_t months_empty = 0; 
  uint8_t months_of_bankruptcy = 0; 
  CompanyMask bankrupt_asked{}; 
  int16_t bankrupt_timeout = 0; 
  Money bankrupt_value = 0;
 
  uint32_t terraform_limit = 0; 
  uint32_t clear_limit = 0; 
  uint32_t tree_limit = 0; 
  uint32_t build_object_limit = 0; 
 
  bool is_ai = false;
 
  std::array<Expenses, 3> yearly_expenses{}; 
  CompanyEconomyEntry cur_economy{}; 
  std::array<CompanyEconomyEntry, MAX_HISTORY_QUARTERS> old_economy{}; 
  uint8_t num_valid_stat_ent = 0; 
 
  std::array<Livery, LS_END> livery{};
 
  EngineRenewList engine_renew_list = nullptr; 
  CompanySettings settings{}; 
};
 
struct Company : CompanyProperties, CompanyPool::PoolItem<&_company_pool> {
  Company(StringID name_1 = STR_NULL, bool is_ai = false);
  ~Company();
 
  RailTypes avail_railtypes{}; 
  RoadTypes avail_roadtypes{}; 
 
  std::unique_ptr<class AIInstance> ai_instance{};
  class AIInfo *ai_info = nullptr;
  std::unique_ptr<class AIConfig> ai_config{};
 
  std::array<GroupStatistics, VEH_COMPANY_END> group_all{}; 
  std::array<GroupStatistics, VEH_COMPANY_END> group_default{};  
 
  CompanyInfrastructure infrastructure{}; 
 
  std::array<FreeUnitIDGenerator, VEH_COMPANY_END> freeunits{};
  FreeUnitIDGenerator freegroups{};
 
  Money GetMaxLoan() const;
 
  static inline bool IsValidAiID(auto index)
  {
    const Company *c = Company::GetIfValid(index);
    return c != nullptr && c->is_ai;
  }
 
  static inline bool IsValidHumanID(auto index)
  {
    const Company *c = Company::GetIfValid(index);
    return c != nullptr && !c->is_ai;
  }
 
  static inline bool IsHumanID(auto index)
  {
    return !Company::Get(index)->is_ai;
  }
 
  static void PostDestructor(size_t index);
};
 
Money CalculateCompanyValue(const Company *c, bool including_loan = true);
Money CalculateHostileTakeoverValue(const Company *c);
 
extern uint _cur_company_tick_index;
 
#endif /* COMPANY_BASE_H */