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

 
#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>;
 
class Engine;

enum class RailVehicleType : uint8_t {
  Singlehead, 
  Multihead, 
  Wagon, 
};

enum class EngineClass : uint8_t {
  Steam, 
  Diesel, 
  Electric, 
  Monorail, 
  Maglev, 
};

enum class VehicleAccelerationModel : uint8_t {
  Normal,   
  Monorail, 
  Maglev,   
};

enum VisualEffect : uint8_t {
  VE_OFFSET_START        = 0, 
  VE_OFFSET_COUNT        = 4, 
  VE_OFFSET_CENTRE       = 8, 
 
  VE_TYPE_START          = 4, 
  VE_TYPE_COUNT          = 2, 
  VE_TYPE_DEFAULT        = 0, 
  VE_TYPE_STEAM          = 1, 
  VE_TYPE_DIESEL         = 2, 
  VE_TYPE_ELECTRIC       = 3, 
 
  VE_DISABLE_EFFECT      = 6, 
  VE_ADVANCED_EFFECT     = VE_DISABLE_EFFECT, 
  VE_DISABLE_WAGON_POWER = 7, 
 
  VE_DEFAULT = 0xFF,          
};

struct RailVehicleInfo {
  uint8_t image_index = 0;
  RailVehicleType railveh_type = RailVehicleType::Wagon; 
  uint8_t cost_factor = 0; 
  RailTypes railtypes{RAILTYPE_RAIL}; 
  RailTypes intended_railtypes{RAILTYPE_RAIL}; 
  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 = VE_DEFAULT; 
  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 ShipVehicleInfo {
  uint8_t image_index = 0;
  uint8_t cost_factor = 0;
  uint8_t running_cost = 0;
  uint8_t acceleration = 1; 
  uint16_t max_speed = 0; 
  uint16_t capacity = 0;
  SoundID sfx{};
  bool old_refittable = 0; 
  uint8_t visual_effect = VE_DEFAULT; 
  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;
  }
};

enum AircraftSubTypeBits : uint8_t {
  AIR_HELI = 0,
  AIR_CTOL = 1, 
  AIR_FAST = 2
};

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 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 = 0x4C; 
  uint8_t air_drag = 0; 
  uint8_t visual_effect = VE_DEFAULT; 
  uint8_t shorten_factor = 0; 
  RoadType roadtype{}; 
};

enum class ExtraEngineFlag : uint8_t {
  NoNews          = 0, 
  NoPreview       = 1, 
  JoinPreview     = 2, 
  SyncReliability = 3, 
  HasCab          = 4, 
};

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, 
};

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{}; 
};

enum class EngineFlag : uint8_t {
  Available        = 0, 
  ExclusivePreview = 1, 
};

using EngineFlags = EnumBitSet<EngineFlag, uint8_t>;

enum class EngineNameContext : uint8_t {
  Generic                 = 0x00, 
  VehicleDetails          = 0x11, 
  PurchaseList            = 0x20, 
  PreviewNews             = 0x21, 
  AutoreplaceVehicleInUse = 0x22, 
};

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);
}
 
static const uint MAX_LENGTH_ENGINE_NAME_CHARS = 32; 
 
#endif /* ENGINE_TYPE_H */