engine_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 <http://www.gnu.org/licenses/>.
 */
 
#ifndef ENGINE_TYPE_H
#define ENGINE_TYPE_H
 
#include "core/pool_type.hpp"
#include "economy_type.h"
#include "landscape_type.h"
#include "newgrf_callbacks.h"
#include "rail_type.h"
#include "road_type.h"
#include "cargo_type.h"
#include "timer/timer_game_calendar.h"
#include "sound_type.h"
#include "strings_type.h"
#include "newgrf_badge_type.h"
 
using EngineID = PoolID<uint16_t, struct EngineIDTag, 64000, 0xFFFF>;
 
struct Engine;
 
enum RailVehicleTypes : uint8_t {
  RAILVEH_SINGLEHEAD,  
  RAILVEH_MULTIHEAD,   
  RAILVEH_WAGON,       
};
enum RailVehicleTypes : uint8_t {…};
 
enum EngineClass : uint8_t {
  EC_STEAM,    
  EC_DIESEL,   
  EC_ELECTRIC, 
  EC_MONORAIL, 
  EC_MAGLEV,   
};
enum EngineClass : uint8_t {…};
 
struct RailVehicleInfo {
  uint8_t image_index = 0;
  RailVehicleTypes railveh_type{};
  uint8_t cost_factor = 0; 
  RailType railtype{}; 
  RailType intended_railtype{}; 
  uint8_t ai_passenger_only = 0; 
  uint16_t max_speed = 0; 
  uint16_t power = 0; 
  uint16_t weight = 0; 
  uint8_t running_cost = 0; 
  Price running_cost_class{};
  EngineClass engclass{}; 
  uint8_t capacity = 0; 
  uint16_t pow_wag_power = 0; 
  uint8_t pow_wag_weight = 0; 
  uint8_t visual_effect = 0; 
  uint8_t shorten_factor = 0; 
  uint8_t tractive_effort = 0; 
  uint8_t air_drag = 0; 
  uint8_t user_def_data = 0; 
  int16_t curve_speed_mod = 0; 
};
struct RailVehicleInfo {…};
 
struct ShipVehicleInfo {
  uint8_t image_index = 0;
  uint8_t cost_factor = 0;
  uint8_t running_cost = 0;
  uint8_t acceleration = 0; 
  uint16_t max_speed = 0; 
  uint16_t capacity = 0;
  SoundID sfx{};
  bool old_refittable = 0; 
  uint8_t visual_effect = 0; 
  uint8_t ocean_speed_frac = 0; 
  uint8_t canal_speed_frac = 0; 
 
  uint ApplyWaterClassSpeedFrac(uint raw_speed, bool is_ocean) const
  {
    /* speed_frac == 0 means no reduction while 0xFF means reduction to 1/256. */
    return raw_speed * (256 - (is_ocean ? this->ocean_speed_frac : this->canal_speed_frac)) / 256;
  }
  uint ApplyWaterClassSpeedFrac(uint raw_speed, bool is_ocean) const {…}
};
struct ShipVehicleInfo {…};
 
enum AircraftSubTypeBits : uint8_t {
  AIR_HELI = 0,
  AIR_CTOL = 1, 
  AIR_FAST = 2
};
enum AircraftSubTypeBits : uint8_t {…};
 
struct AircraftVehicleInfo {
  uint8_t image_index = 0;
  uint8_t cost_factor = 0;
  uint8_t running_cost = 0;
  uint8_t subtype = 0; 
  SoundID sfx{};
  uint16_t max_speed = 0; 
  uint8_t acceleration = 0;
  uint8_t mail_capacity = 0; 
  uint16_t passenger_capacity = 0; 
  uint16_t max_range = 0; 
};
struct AircraftVehicleInfo {…};
 
struct RoadVehicleInfo {
  uint8_t image_index = 0;
  uint8_t cost_factor = 0;
  uint8_t running_cost = 0;
  Price running_cost_class{};
  SoundID sfx{};
  uint16_t max_speed = 0; 
  uint8_t capacity = 0;
  uint8_t weight = 0; 
  uint8_t power = 0; 
  uint8_t tractive_effort = 0; 
  uint8_t air_drag = 0; 
  uint8_t visual_effect = 0; 
  uint8_t shorten_factor = 0; 
  RoadType roadtype{}; 
};
struct RoadVehicleInfo {…};
 
enum class ExtraEngineFlag : uint8_t {
  NoNews          = 0, 
  NoPreview       = 1, 
  JoinPreview     = 2, 
  SyncReliability = 3, 
};
enum class ExtraEngineFlag : uint8_t {…};
using ExtraEngineFlags = EnumBitSet<ExtraEngineFlag, uint8_t>;
 
enum class EngineMiscFlag : uint8_t {
  RailTilts  = 0, 
  RoadIsTram = 0, 
 
  Uses2CC    = 1, 
 
  RailIsMU   = 2, 
  RailFlips  = 3, 
 
  AutoRefit                = 4, 
  NoDefaultCargoMultiplier = 5, 
  NoBreakdownSmoke         = 6, 
  SpriteStack              = 7, 
};
enum class EngineMiscFlag : uint8_t {…};
using EngineMiscFlags = EnumBitSet<EngineMiscFlag, uint8_t>;
 
struct EngineInfo {
  TimerGameCalendar::Date base_intro{}; 
  TimerGameCalendar::Year lifelength{}; 
  TimerGameCalendar::Year base_life{}; 
  uint8_t decay_speed = 0;
  uint8_t load_amount = 0;
  LandscapeTypes climates{}; 
  CargoType cargo_type{};
  std::variant<CargoLabel, MixedCargoType> cargo_label{};
  CargoTypes refit_mask{};
  uint8_t refit_cost = 0;
  EngineMiscFlags misc_flags{}; 
  VehicleCallbackMasks callback_mask{}; 
  int8_t retire_early = 0; 
  ExtraEngineFlags extra_flags{};
  StringID string_id = INVALID_STRING_ID; 
  uint16_t cargo_age_period = 0; 
  EngineID variant_id{}; 
};
struct EngineInfo {…};
 
enum class EngineFlag : uint8_t {
  Available        = 0, 
  ExclusivePreview = 1, 
};
enum class EngineFlag : uint8_t {…};
using EngineFlags = EnumBitSet<EngineFlag, uint8_t>;
 
enum class EngineNameContext : uint8_t {
  Generic                 = 0x00, 
  VehicleDetails          = 0x11, 
  PurchaseList            = 0x20, 
  PreviewNews             = 0x21, 
  AutoreplaceVehicleInUse = 0x22, 
};
enum class EngineNameContext : uint8_t {…};
 
inline uint64_t PackEngineNameDParam(EngineID engine_id, EngineNameContext context, uint32_t extra_data = 0)
{
  return engine_id.base() | (static_cast<uint64_t>(context) << 32) | (static_cast<uint64_t>(extra_data) << 40);
}
inline uint64_t PackEngineNameDParam(EngineID engine_id, EngineNameContext context, uint32_t extra_data = 0) {…}
 
static const uint MAX_LENGTH_ENGINE_NAME_CHARS = 32; 
 
#endif /* ENGINE_TYPE_H */