economy_type.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 ECONOMY_TYPE_H
#define ECONOMY_TYPE_H
 
#include "core/overflowsafe_type.hpp"
#include "core/enum_type.hpp"
#include "core/pool_type.hpp"
 
typedef OverflowSafeInt64 Money;
 
enum class EconomyType : uint8_t {
  Begin, 
  Original = EconomyType::Begin, 
  Smooth, 
  Frozen, 
  End, 
};
 
static const int MIN_CARGO_SCALE = 15;
static const int MAX_CARGO_SCALE = 300;
static const int DEF_CARGO_SCALE = 100;
 
struct Economy {
  Money max_loan;                       
  int16_t fluct;                          
  uint8_t interest_rate;                   
  uint8_t infl_amount;                     
  uint8_t infl_amount_pr;                  
  uint32_t industry_daily_change_counter; 
  uint32_t industry_daily_increment;      
  uint64_t inflation_prices;              
  uint64_t inflation_payment;             
 
  /* Old stuff for savegame conversion only */
  Money old_max_loan_unround;           
  uint16_t old_max_loan_unround_fract;    
};
 
enum class ScoreID : uint8_t {
  Begin, 
  Vehicles = ScoreID::Begin, 
  Stations, 
  MinProfit, 
  MinIncome, 
  MaxIncome, 
  Delivered, 
  Cargo, 
  Money, 
  Loan, 
  Total, 
  End, 
};
DECLARE_INCREMENT_DECREMENT_OPERATORS(ScoreID)
 
 
static constexpr int SCORE_MAX = 1000;
 
struct ScoreInfo {
  int score;  
  int needed; 
};
 
enum class Price : uint8_t {
  Begin, 
  StationValue = Price::Begin, 
  BuildRail, 
  BuildRoad, 
  BuildSignals, 
  BuildBridge, 
  BuildDepotTrain, 
  BuildDepotRoad, 
  BuildDepotShip, 
  BuildTunnel, 
  BuildStationRail, 
  BuildStationRailLength, 
  BuildStationAirport, 
  BuildStationBus, 
  BuildStationTruck, 
  BuildStationDock, 
  BuildVehicleTrain, 
  BuildVehicleWagon, 
  BuildVehicleAircraft, 
  BuildVehicleRoad, 
  BuildVehicleShip, 
  BuildTrees, 
  Terraform, 
  ClearGrass, 
  ClearRough, 
  ClearRocks, 
  ClearFields, 
  ClearTrees, 
  ClearRail, 
  ClearSignals, 
  ClearBridge, 
  ClearDepotTrain, 
  ClearDepotRoad, 
  ClearDepotShip, 
  ClearTunnel, 
  ClearWater, 
  ClearStationRail, 
  ClearStationAirport, 
  ClearStationBus, 
  ClearStationTruck, 
  ClearStationDock, 
  ClearHouse, 
  ClearRoad, 
  RunningTrainSteam, 
  RunningTrainDiesel, 
  RunningTrainElectric, 
  RunningAircraft, 
  RunningRoadveh, 
  RunningShip, 
  BuildIndustry, 
  ClearIndustry, 
  BuildObject, 
  ClearObject, 
  BuildWaypointRail, 
  ClearWaypointRail, 
  BuildWaypointBuoy, 
  ClearWaypointBuoy, 
  TownAction, 
  BuildFoundation, 
  BuildIndustryRaw, 
  BuildTown, 
  BuildCanal, 
  ClearCanal, 
  BuildAqueduct, 
  ClearAqueduct, 
  BuildLock, 
  ClearLock, 
  InfrastructureRail, 
  InfrastructureRoad, 
  InfrastructureWater, 
  InfrastructureStation, 
  InfrastructureAirport, 
  End, 
  Invalid = 0xFF 
};
DECLARE_INCREMENT_DECREMENT_OPERATORS(Price)
 
using Prices = EnumClassIndexContainer<std::array<Money,to_underlying(Price::End)>, Price>; 
using PriceMultipliers = EnumClassIndexContainer<std::array<int8_t, to_underlying(Price::End)>, Price>;
 
enum ExpensesType : uint8_t {
  EXPENSES_CONSTRUCTION =  0,   
  EXPENSES_NEW_VEHICLES,        
  EXPENSES_TRAIN_RUN,           
  EXPENSES_ROADVEH_RUN,         
  EXPENSES_AIRCRAFT_RUN,        
  EXPENSES_SHIP_RUN,            
  EXPENSES_PROPERTY,            
  EXPENSES_TRAIN_REVENUE,       
  EXPENSES_ROADVEH_REVENUE,     
  EXPENSES_AIRCRAFT_REVENUE,    
  EXPENSES_SHIP_REVENUE,        
  EXPENSES_LOAN_INTEREST,       
  EXPENSES_OTHER,               
  EXPENSES_END,                 
  INVALID_EXPENSES      = 0xFF, 
};
 
using Expenses = std::array<Money, EXPENSES_END>;
 
enum PriceCategory : uint8_t {
  PCAT_NONE,         
  PCAT_RUNNING,      
  PCAT_CONSTRUCTION, 
};
 
static const int LOAN_INTERVAL = 10000;
static const int64_t INITIAL_LOAN = 100000;
static const int64_t MAX_LOAN_LIMIT = 2000000000;
 
static const uint64_t MAX_INFLATION = (1ull << (63 - 32)) - 1;
 
static const int MIN_PRICE_MODIFIER = -8;
static const int MAX_PRICE_MODIFIER = 16;
static const int INVALID_PRICE_MODIFIER = MIN_PRICE_MODIFIER - 1;
 
static const uint TUNNELBRIDGE_TRACKBIT_FACTOR = 4;
static const uint LEVELCROSSING_TRACKBIT_FACTOR = 2;
static const uint ROAD_DEPOT_TRACKBIT_FACTOR = 2;
static const uint ROAD_STOP_TRACKBIT_FACTOR = 2;
static const uint LOCK_DEPOT_TILE_FACTOR = 2;
 
struct CargoPayment;
using CargoPaymentID = PoolID<uint32_t, struct CargoPaymentIDTag, 0xFF000, 0xFFFFF>;
 
#endif /* ECONOMY_TYPE_H */