1 /* 2 * This file is part of OpenTTD. 3 * 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. 4 * 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. 5 * 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/>. 6 */ 7 8 /** @file engine_type.h Types related to engines. */ 9 10 #ifndef ENGINE_TYPE_H 11 #define ENGINE_TYPE_H 12 13 #include "economy_type.h" 14 #include "rail_type.h" 15 #include "road_type.h" 16 #include "cargo_type.h" 17 #include "date_type.h" 18 #include "sound_type.h" 19 #include "strings_type.h" 20 21 typedef uint16 EngineID; ///< Unique identification number of an engine. 22 23 struct Engine; 24 25 /** Available types of rail vehicles. */ 26 enum RailVehicleTypes { 27 RAILVEH_SINGLEHEAD, ///< indicates a "standalone" locomotive 28 RAILVEH_MULTIHEAD, ///< indicates a combination of two locomotives 29 RAILVEH_WAGON, ///< simple wagon, not motorized 30 }; 31 32 /** Type of rail engine. */ 33 enum EngineClass { 34 EC_STEAM, ///< Steam rail engine. 35 EC_DIESEL, ///< Diesel rail engine. 36 EC_ELECTRIC, ///< Electric rail engine. 37 EC_MONORAIL, ///< Mono rail engine. 38 EC_MAGLEV, ///< Maglev engine. 39 }; 40 41 /** Information about a rail vehicle. */ 42 struct RailVehicleInfo { 43 byte image_index; 44 RailVehicleTypes railveh_type; 45 byte cost_factor; ///< Purchase cost factor; For multiheaded engines the sum of both engine prices. 46 RailType railtype; 47 uint16 max_speed; ///< Maximum speed (1 unit = 1/1.6 mph = 1 km-ish/h) 48 uint16 power; ///< Power of engine (hp); For multiheaded engines the sum of both engine powers. 49 uint16 weight; ///< Weight of vehicle (tons); For multiheaded engines the weight of each single engine. 50 byte running_cost; ///< Running cost of engine; For multiheaded engines the sum of both running costs. 51 Price running_cost_class; 52 EngineClass engclass; ///< Class of engine for this vehicle 53 byte capacity; ///< Cargo capacity of vehicle; For multiheaded engines the capacity of each single engine. 54 byte ai_passenger_only; ///< Bit value to tell AI that this engine is for passenger use only 55 uint16 pow_wag_power; ///< Extra power applied to consist if wagon should be powered 56 byte pow_wag_weight; ///< Extra weight applied to consist if wagon should be powered 57 byte visual_effect; ///< Bitstuffed NewGRF visual effect data 58 byte shorten_factor; ///< length on main map for this type is 8 - shorten_factor 59 byte tractive_effort; ///< Tractive effort coefficient 60 byte air_drag; ///< Coefficient of air drag 61 byte user_def_data; ///< Property 0x25: "User-defined bit mask" Used only for (very few) NewGRF vehicles 62 int16 curve_speed_mod; ///< Modifier to maximum speed in curves (fixed-point binary with 8 fractional bits) 63 }; 64 65 /** Information about a ship vehicle. */ 66 struct ShipVehicleInfo { 67 byte image_index; 68 byte cost_factor; 69 uint16 max_speed; ///< Maximum speed (1 unit = 1/3.2 mph = 0.5 km-ish/h) 70 uint16 capacity; 71 byte running_cost; 72 SoundID sfx; 73 bool old_refittable; ///< Is ship refittable; only used during initialisation. Later use EngineInfo::refit_mask. 74 byte visual_effect; ///< Bitstuffed NewGRF visual effect data 75 byte ocean_speed_frac; ///< Fraction of maximum speed for ocean tiles. 76 byte canal_speed_frac; ///< Fraction of maximum speed for canal/river tiles. 77 78 /** Apply ocean/canal speed fraction to a velocity */ ApplyWaterClassSpeedFracShipVehicleInfo79 uint ApplyWaterClassSpeedFrac(uint raw_speed, bool is_ocean) const 80 { 81 /* speed_frac == 0 means no reduction while 0xFF means reduction to 1/256. */ 82 return raw_speed * (256 - (is_ocean ? this->ocean_speed_frac : this->canal_speed_frac)) / 256; 83 } 84 }; 85 86 /** 87 * AircraftVehicleInfo subtypes, bitmask type. 88 * If bit 0 is 0 then it is a helicopter, otherwise it is a plane 89 * in which case bit 1 tells us whether it's a big(fast) plane or not. 90 */ 91 enum AircraftSubTypeBits { 92 AIR_HELI = 0, 93 AIR_CTOL = 1, ///< Conventional Take Off and Landing, i.e. planes 94 AIR_FAST = 2 95 }; 96 97 /** Information about a aircraft vehicle. */ 98 struct AircraftVehicleInfo { 99 byte image_index; 100 byte cost_factor; 101 byte running_cost; 102 byte subtype; ///< Type of aircraft. @see AircraftSubTypeBits 103 SoundID sfx; 104 byte acceleration; 105 uint16 max_speed; ///< Maximum speed (1 unit = 8 mph = 12.8 km-ish/h) 106 byte mail_capacity; ///< Mail capacity (bags). 107 uint16 passenger_capacity; ///< Passenger capacity (persons). 108 uint16 max_range; ///< Maximum range of this aircraft. 109 }; 110 111 /** Information about a road vehicle. */ 112 struct RoadVehicleInfo { 113 byte image_index; 114 byte cost_factor; 115 byte running_cost; 116 Price running_cost_class; 117 SoundID sfx; 118 uint16 max_speed; ///< Maximum speed (1 unit = 1/3.2 mph = 0.5 km-ish/h) 119 byte capacity; 120 uint8 weight; ///< Weight in 1/4t units 121 uint8 power; ///< Power in 10hp units 122 uint8 tractive_effort; ///< Coefficient of tractive effort 123 uint8 air_drag; ///< Coefficient of air drag 124 byte visual_effect; ///< Bitstuffed NewGRF visual effect data 125 byte shorten_factor; ///< length on main map for this type is 8 - shorten_factor 126 RoadType roadtype; ///< Road type 127 }; 128 129 /** 130 * Information about a vehicle 131 * @see table/engines.h 132 */ 133 struct EngineInfo { 134 Date base_intro; ///< Basic date of engine introduction (without random parts). 135 Year lifelength; ///< Lifetime of a single vehicle 136 Year base_life; ///< Basic duration of engine availability (without random parts). \c 0xFF means infinite life. 137 byte decay_speed; 138 byte load_amount; 139 byte climates; ///< Climates supported by the engine. 140 CargoID cargo_type; 141 CargoTypes refit_mask; 142 byte refit_cost; 143 byte misc_flags; ///< Miscellaneous flags. @see EngineMiscFlags 144 byte callback_mask; ///< Bitmask of vehicle callbacks that have to be called 145 int8 retire_early; ///< Number of years early to retire vehicle 146 StringID string_id; ///< Default name of engine 147 uint16 cargo_age_period; ///< Number of ticks before carried cargo is aged. 148 }; 149 150 /** 151 * EngineInfo.misc_flags is a bitmask, with the following values 152 */ 153 enum EngineMiscFlags { 154 EF_RAIL_TILTS = 0, ///< Rail vehicle tilts in curves 155 EF_ROAD_TRAM = 0, ///< Road vehicle is a tram/light rail vehicle 156 EF_USES_2CC = 1, ///< Vehicle uses two company colours 157 EF_RAIL_IS_MU = 2, ///< Rail vehicle is a multiple-unit (DMU/EMU) 158 EF_RAIL_FLIPS = 3, ///< Rail vehicle can be flipped in the depot 159 EF_AUTO_REFIT = 4, ///< Automatic refitting is allowed 160 EF_NO_DEFAULT_CARGO_MULTIPLIER = 5, ///< Use the new capacity algorithm. The default cargotype of the vehicle does not affect capacity multipliers. CB 15 is also called in purchase list. 161 EF_NO_BREAKDOWN_SMOKE = 6, ///< Do not show black smoke during a breakdown. 162 EF_SPRITE_STACK = 7, ///< Draw vehicle by stacking multiple sprites. 163 }; 164 165 /** 166 * Engine.flags is a bitmask, with the following values. 167 */ 168 enum EngineFlags { 169 ENGINE_AVAILABLE = 1, ///< This vehicle is available to everyone. 170 ENGINE_EXCLUSIVE_PREVIEW = 2, ///< This vehicle is in the exclusive preview stage, either being used or being offered to a company. 171 }; 172 173 static const uint MAX_LENGTH_ENGINE_NAME_CHARS = 32; ///< The maximum length of an engine name in characters including '\0' 174 175 static const EngineID INVALID_ENGINE = 0xFFFF; ///< Constant denoting an invalid engine. 176 177 #endif /* ENGINE_TYPE_H */ 178