4 * This file is part of OpenTTD.
5 * 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.
6 * 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.
7 * 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/>.
10 /** @file engine_base.h Base class for engines. */
15 #include "engine_type.h"
16 #include "vehicle_type.h"
17 #include "core/pool_type.hpp"
18 #include "newgrf_commons.h"
20 /** Variable part of an engine. */
22 char *name
; ///< Custom name of engine.
23 Date intro_date
; ///< Date of introduction of the engine.
25 uint16 reliability
; ///< Current reliability of the engine.
26 uint16 reliability_spd_dec
; ///< Speed of reliability decay between services (per day).
27 uint16 reliability_start
; ///< Initial reliability of the engine.
28 uint16 reliability_max
; ///< Maximal reliability of the engine.
29 uint16 reliability_final
; ///< Final reliability of the engine.
30 uint16 duration_phase_1
; ///< First reliability phase in months, increasing reliability from #reliability_start to #reliability_max.
31 uint16 duration_phase_2
; ///< Second reliability phase in months, keeping #reliability_max.
32 uint16 duration_phase_3
; ///< Third reliability phase on months, decaying to #reliability_final.
33 byte flags
; ///< Flags of the engine. @see EngineFlags
34 CompanyMask preview_asked
; ///< Bit for each company which has already been offered a preview.
35 CompanyByte preview_company
;///< Company which is currently being offered a preview \c INVALID_COMPANY means no company.
36 byte preview_wait
; ///< Daily countdown timer for timeout of offering the engine to the #preview_company company.
37 CompanyMask company_avail
; ///< Bit for each company whether the engine is available for that company.
38 CompanyMask company_hidden
; ///< Bit for each company whether the engine is normally hidden in the build gui for that company.
40 EngineState() : name(NULL
) { }
42 EngineState (const EngineState
&es
)
43 : name (es
.name
!= NULL
? xstrdup (es
.name
) : NULL
),
44 intro_date (es
.intro_date
),
46 reliability (es
.reliability
),
47 reliability_spd_dec (es
.reliability_spd_dec
),
48 reliability_start (es
.reliability_start
),
49 reliability_max (es
.reliability_max
),
50 reliability_final (es
.reliability_final
),
51 duration_phase_1 (es
.duration_phase_1
),
52 duration_phase_2 (es
.duration_phase_2
),
53 duration_phase_3 (es
.duration_phase_3
),
55 preview_asked (es
.preview_asked
),
56 preview_company (es
.preview_company
),
57 preview_wait (es
.preview_wait
),
58 company_avail (es
.company_avail
),
59 company_hidden (es
.company_hidden
)
68 void reset (const EngineInfo
*ei
, Date aging_date
);
71 /** An engine, as used in the game. */
72 struct Engine
: PooledItem
<Engine
, EngineID
, 64, 64000>, EngineState
{
73 uint8 original_image_index
; ///< Original vehicle image index, thus the image index of the overridden vehicle
74 VehicleType type
; ///< %Vehicle type, ie #VEH_ROAD, #VEH_TRAIN, etc.
82 AircraftVehicleInfo air
;
85 /* NewGRF related data */
87 * Properties related the the grf file.
88 * NUM_CARGO real cargo plus two pseudo cargo sprite groups.
89 * Used for obtaining the sprite offset of custom sprites, and for
90 * evaluating callbacks.
92 GRFFilePropsBase
<NUM_CARGO
+ 2> grf_prop
;
93 uint16 overrides_count
;
94 struct WagonOverride
*overrides
;
98 Engine(VehicleType type
, EngineID base
);
100 bool IsEnabled() const;
103 * Determines the default cargo type of an engine.
105 * Usually a valid cargo is returned, even though the vehicle has zero capacity, and can therefore not carry anything. But the cargotype is still used
106 * for livery selection etc..
108 * Vehicles with CT_INVALID as default cargo are usually not available, but it can appear as default cargo of articulated parts.
110 * @return The default cargo type.
113 CargoID
GetDefaultCargoType() const
115 return this->info
.cargo_type
;
118 uint
DetermineCapacity(const Vehicle
*v
, uint16
*mail_capacity
= NULL
) const;
120 bool CanCarryCargo() const;
123 * Determines the default cargo capacity of an engine for display purposes.
125 * For planes carrying both passenger and mail this is the passenger capacity.
126 * For multiheaded engines this is the capacity of both heads.
127 * For articulated engines use GetCapacityOfArticulatedParts
129 * @param mail_capacity returns secondary cargo (mail) capacity of aircraft
130 * @return The default capacity
131 * @see GetDefaultCargoType
133 uint
GetDisplayDefaultCapacity(uint16
*mail_capacity
= NULL
) const
135 return this->DetermineCapacity(NULL
, mail_capacity
);
138 Money
GetRunningCost() const;
139 Money
GetCost() const;
140 uint
GetDisplayMaxSpeed() const;
141 uint
GetPower() const;
142 uint
GetDisplayWeight() const;
143 uint
GetDisplayMaxTractiveEffort() const;
144 Date
GetLifeLengthInDays() const;
145 uint16
GetRange() const;
148 * Check whether the engine is hidden in the GUI for the given company.
149 * @param c Company to check.
150 * @return \c true iff the engine is hidden in the GUI for the given company.
152 inline bool IsHidden(CompanyByte c
) const
154 return c
< MAX_COMPANIES
&& HasBit(this->company_hidden
, c
);
158 * Check if the engine is a ground vehicle.
159 * @return True iff the engine is a train or a road vehicle.
161 inline bool IsGroundVehicle() const
163 return this->type
== VEH_TRAIN
|| this->type
== VEH_ROAD
;
167 * Retrieve the NewGRF the engine is tied to.
168 * This is the GRF providing the Action 3.
169 * @return NewGRF associated to the engine.
171 const GRFFile
*GetGRF() const
173 return this->grf_prop
.grffile
;
176 uint32
GetGRFID() const;
179 struct EngineIDMapping
{
180 uint32 grfid
; ///< The GRF ID of the file the entity belongs to
181 uint16 internal_id
; ///< The internal ID within the GRF file
182 VehicleTypeByte type
; ///< The engine type
183 uint8 substitute_id
; ///< The (original) entity ID to use if this GRF is not available (currently not used)
187 * Stores the mapping of EngineID to the internal id of newgrfs.
188 * Note: This is not part of Engine, as the data in the EngineOverrideManager and the engine pool get resetted in different cases.
190 struct EngineOverrideManager
: SmallVector
<EngineIDMapping
, 256> {
191 static const uint NUM_DEFAULT_ENGINES
; ///< Number of default entries
193 void ResetToDefaultMapping();
194 EngineID
GetID(VehicleType type
, uint16 grf_local_id
, uint32 grfid
);
196 static bool ResetToCurrentNewGRFConfig();
199 extern EngineOverrideManager _engine_mngr
;
201 #define FOR_ALL_ENGINES_FROM(var, start) FOR_ALL_ITEMS_FROM(Engine, engine_index, var, start)
202 #define FOR_ALL_ENGINES(var) FOR_ALL_ENGINES_FROM(var, 0)
204 #define FOR_ALL_ENGINES_OF_TYPE(e, engine_type) FOR_ALL_ENGINES(e) if (e->type == engine_type)
206 static inline const EngineInfo
*EngInfo(EngineID e
)
208 return &Engine::Get(e
)->info
;
211 static inline const RailVehicleInfo
*RailVehInfo(EngineID e
)
213 return &Engine::Get(e
)->u
.rail
;
216 static inline const RoadVehicleInfo
*RoadVehInfo(EngineID e
)
218 return &Engine::Get(e
)->u
.road
;
221 static inline const ShipVehicleInfo
*ShipVehInfo(EngineID e
)
223 return &Engine::Get(e
)->u
.ship
;
226 static inline const AircraftVehicleInfo
*AircraftVehInfo(EngineID e
)
228 return &Engine::Get(e
)->u
.air
;
231 #endif /* ENGINE_BASE_H */