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 train.h Base for the train class. */
15 #include "core/enum_type.hpp"
17 #include "newgrf_engine.h"
18 #include "cargotype.h"
20 #include "engine_base.h"
22 #include "ground_vehicle.hpp"
23 #include "pathfinder/railpos.h"
27 /** Rail vehicle flags. */
28 enum VehicleRailFlags
{
30 VRF_POWEREDWAGON
= 3, ///< Wagon is powered.
31 VRF_REVERSE_DIRECTION
= 4, ///< Reverse the visible direction of the vehicle.
33 VRF_EL_ENGINE_ALLOWED_NORMAL_RAIL
= 6, ///< Electric train engine is allowed to run on normal rail. */
34 VRF_TOGGLE_REVERSE
= 7, ///< Used for vehicle var 0xFE bit 8 (toggled each time the train is reversed, accurate for first vehicle only).
35 VRF_TRAIN_STUCK
= 8, ///< Train can't get a path reservation.
36 VRF_LEAVING_STATION
= 9, ///< Train is just leaving a station.
39 /** Modes for ignoring signals. */
40 enum TrainForceProceeding
{
41 TFP_NONE
= 0, ///< Normal operation.
42 TFP_STUCK
= 1, ///< Proceed till next signal, but ignore being stuck till then. This includes force leaving depots.
43 TFP_SIGNAL
= 2, ///< Ignore next signal, after the signal ignore being stuck.
45 typedef SimpleTinyEnumT
<TrainForceProceeding
, byte
> TrainForceProceedingByte
;
47 /** Flags for Train::ConsistChanged */
48 enum ConsistChangeFlags
{
49 CCF_LENGTH
= 0x01, ///< Allow vehicles to change length.
50 CCF_CAPACITY
= 0x02, ///< Allow vehicles to change capacity.
52 CCF_TRACK
= 0, ///< Valid changes while vehicle is driving, and possibly changing tracks.
53 CCF_LOADUNLOAD
= 0, ///< Valid changes while vehicle is loading/unloading.
54 CCF_AUTOREFIT
= CCF_CAPACITY
, ///< Valid changes for autorefitting in stations.
55 CCF_REFIT
= CCF_LENGTH
| CCF_CAPACITY
, ///< Valid changes for refitting in a depot.
56 CCF_ARRANGE
= CCF_LENGTH
| CCF_CAPACITY
, ///< Valid changes for arranging the consist in a depot.
57 CCF_SAVELOAD
= CCF_LENGTH
, ///< Valid changes when loading a savegame. (Everything that is not stored in the save.)
59 DECLARE_ENUM_AS_BIT_SET(ConsistChangeFlags
)
61 byte
FreightWagonMult(CargoID cargo
);
63 void CheckTrainsLengths();
65 void FreeTrainTrackReservation(const Train
*v
);
66 bool TryPathReserve(Train
*v
, bool mark_as_stuck
= false, bool first_tile_okay
= false);
68 int GetTrainStopLocation(StationID station_id
, TileIndex tile
, const Train
*v
, int *station_ahead
, int *station_length
);
70 void GetTrainSpriteSize(EngineID engine
, uint
&width
, uint
&height
, int &xoffs
, int &yoffs
, EngineImageType image_type
);
72 /** Variables that are cached to improve performance and such */
74 /* Cached wagon override spritegroup */
75 const struct SpriteGroup
*cached_override
;
77 /* cached values, recalculated on load and each time a vehicle is added to/removed from the consist. */
78 bool cached_tilt
; ///< train can tilt; feature provides a bonus in curves
80 byte user_def_data
; ///< Cached property 0x25. Can be set by Callback 0x36.
82 /* cached max. speed / acceleration data */
83 int cached_max_curve_speed
; ///< max consist speed limited by curves
87 * 'Train' is either a loco or a wagon.
89 struct Train FINAL
: public GroundVehicle
<Train
, VEH_TRAIN
> {
92 /* Link between the two ends of a multiheaded engine */
93 Train
*other_multiheaded_part
;
95 uint16 crash_anim_pos
; ///< Crash animation counter.
98 TrackdirByte trackdir
;
99 TrainForceProceedingByte force_proceed
;
100 RailTypeByte railtype
;
101 RailTypes compatible_railtypes
;
103 /** Ticks waiting in front of a signal, ticks being stuck or a counter for forced proceeding through signals. */
106 /** We don't want GCC to zero our struct! It already is zeroed and has an index! */
107 Train() : GroundVehicleBase() {}
108 /** We want to 'destruct' the right class. */
109 virtual ~Train() { this->PreDestructor(); }
111 friend struct GroundVehicle
<Train
, VEH_TRAIN
>; // GroundVehicle needs to use the acceleration functions defined at Train.
114 void UpdateDeltaXY(Direction direction
);
115 ExpensesType
GetExpenseType(bool income
) const { return income
? EXPENSES_TRAIN_INC
: EXPENSES_TRAIN_RUN
; }
116 void PlayLeaveStationSound() const;
117 bool IsPrimaryVehicle() const { return this->IsFrontEngine(); }
118 SpriteID
GetImage(Direction direction
, EngineImageType image_type
) const;
119 int GetDisplaySpeed() const { return this->gcache
.last_speed
; }
120 int GetDisplayMaxSpeed() const { return this->vcache
.cached_max_speed
; }
121 Money
GetRunningCost() const;
122 int GetDisplayImageWidth(Point
*offset
= NULL
) const;
123 bool IsInDepot() const { return this->trackdir
== TRACKDIR_DEPOT
; }
126 uint
Crash(bool flooded
= false);
127 Trackdir
GetTrackdir() const;
128 RailPathPos
GetPos() const;
129 RailPathPos
GetReversePos() const;
130 TileIndex
GetOrderStationLocation(StationID station
);
131 bool FindClosestDepot(TileIndex
*location
, DestinationID
*destination
, bool *reverse
);
133 void ReserveTrackUnderConsist() const;
135 int GetCurveSpeedLimit() const;
137 void ConsistChanged(ConsistChangeFlags allowed_changes
);
141 void UpdateAcceleration();
143 int GetCurrentMaxSpeed() const;
146 * Get the next real (non-articulated part and non rear part of dualheaded engine) vehicle in the consist.
147 * @return Next vehicle in the consist.
149 inline Train
*GetNextUnit() const
151 Train
*v
= this->GetNextVehicle();
152 if (v
!= NULL
&& v
->IsRearDualheaded()) v
= v
->GetNextVehicle();
158 * Get the previous real (non-articulated part and non rear part of dualheaded engine) vehicle in the consist.
159 * @return Previous vehicle in the consist.
161 inline Train
*GetPrevUnit()
163 Train
*v
= this->GetPrevVehicle();
164 if (v
!= NULL
&& v
->IsRearDualheaded()) v
= v
->GetPrevVehicle();
170 * Calculate the offset from this vehicle's center to the following center taking the vehicle lengths into account.
171 * @return Offset from center to center.
173 int CalcNextVehicleOffset() const
175 /* For vehicles with odd lengths the part before the center will be one unit
176 * longer than the part after the center. This means we have to round up the
177 * length of the next vehicle but may not round the length of the current
179 return this->gcache
.cached_veh_length
/ 2 + (this->Next() != NULL
? this->Next()->gcache
.cached_veh_length
+ 1 : 0) / 2;
183 * Get the railtype the vehicle is currently running on.
184 * @return The railtype under the vehicle
186 inline RailType
GetTrackRailType() const
188 return !IsRailwayTile(this->tile
) ? GetRailType(this->tile
) :
189 (this->trackdir
== TRACKDIR_WORMHOLE
) ? GetBridgeRailType(this->tile
) :
190 GetRailType(this->tile
, TrackdirToTrack(this->trackdir
));
193 protected: // These functions should not be called outside acceleration code.
196 * Allows to know the power value that this vehicle will use.
197 * @return Power value from the engine in HP, or zero if the vehicle is not powered.
199 inline uint16
GetPower() const
201 /* Power is not added for articulated parts */
202 if (!this->IsArticulatedPart() && HasPowerOnRail(this->railtype
, this->GetTrackRailType())) {
203 uint16 power
= GetVehicleProperty(this, PROP_TRAIN_POWER
, RailVehInfo(this->engine_type
)->power
);
204 /* Halve power for multiheaded parts */
205 if (this->IsMultiheaded()) power
/= 2;
213 * Returns a value if this articulated part is powered.
214 * @return Power value from the articulated part in HP, or zero if it is not powered.
216 inline uint16
GetPoweredPartPower(const Train
*head
) const
218 /* For powered wagons the engine defines the type of engine (i.e. railtype) */
219 if (HasBit(this->flags
, VRF_POWEREDWAGON
) && HasPowerOnRail(head
->railtype
, this->GetTrackRailType())) {
220 return RailVehInfo(this->gcache
.first_engine
)->pow_wag_power
;
227 * Allows to know the weight value that this vehicle will use.
228 * @return Weight value from the engine in tonnes.
230 inline uint16
GetWeight() const
232 uint16 weight
= (CargoSpec::Get(this->cargo_type
)->weight
* this->cargo
.StoredCount() * FreightWagonMult(this->cargo_type
)) / 16;
234 /* Vehicle weight is not added for articulated parts. */
235 if (!this->IsArticulatedPart()) {
236 weight
+= GetVehicleProperty(this, PROP_TRAIN_WEIGHT
, RailVehInfo(this->engine_type
)->weight
);
239 /* Powered wagons have extra weight added. */
240 if (HasBit(this->flags
, VRF_POWEREDWAGON
)) {
241 weight
+= RailVehInfo(this->gcache
.first_engine
)->pow_wag_weight
;
248 * Allows to know the tractive effort value that this vehicle will use.
249 * @return Tractive effort value from the engine.
251 inline byte
GetTractiveEffort() const
253 return GetVehicleProperty(this, PROP_TRAIN_TRACTIVE_EFFORT
, RailVehInfo(this->engine_type
)->tractive_effort
);
257 * Gets the area used for calculating air drag.
258 * @return Area of the engine in m^2.
260 inline byte
GetAirDragArea() const
262 /* Air drag is higher in tunnels due to the limited cross-section. */
263 return (this->trackdir
== TRACKDIR_WORMHOLE
&& this->vehstatus
& VS_HIDDEN
) ? 28 : 14;
267 * Gets the air drag coefficient of this vehicle.
268 * @return Air drag value from the engine.
270 inline byte
GetAirDrag() const
272 return RailVehInfo(this->engine_type
)->air_drag
;
276 * Checks the current acceleration status of this vehicle.
277 * @return Acceleration status.
279 inline AccelStatus
GetAccelerationStatus() const
281 return (this->vehstatus
& VS_STOPPED
) || HasBit(this->flags
, VRF_REVERSING
) || HasBit(this->flags
, VRF_TRAIN_STUCK
) ? AS_BRAKE
: AS_ACCEL
;
285 * Calculates the current speed of this vehicle.
286 * @return Current speed in km/h-ish.
288 inline uint16
GetCurrentSpeed() const
290 return this->cur_speed
;
294 * Returns the rolling friction coefficient of this vehicle.
295 * @return Rolling friction coefficient in [1e-4].
297 inline uint32
GetRollingFriction() const
299 /* Rolling friction for steel on steel is between 0.1% and 0.2%.
300 * The friction coefficient increases with speed in a way that
301 * it doubles at 512 km/h, triples at 1024 km/h and so on. */
302 return 15 * (512 + this->GetCurrentSpeed()) / 512;
306 * Allows to know the acceleration type of a vehicle.
307 * @return Acceleration type of the vehicle.
309 inline int GetAccelerationType() const
311 return GetRailTypeInfo(this->railtype
)->acceleration_type
;
315 * Returns the slope steepness used by this vehicle.
316 * @return Slope steepness used by the vehicle.
318 inline uint32
GetSlopeSteepness() const
320 return _settings_game
.vehicle
.train_slope_steepness
;
324 * Gets the maximum speed allowed by the track for this vehicle.
325 * @return Maximum speed allowed.
327 inline uint16
GetMaxTrackSpeed() const
329 return GetRailTypeInfo(this->GetTrackRailType())->max_speed
;
333 * Checks if the vehicle is at a tile that can be sloped.
334 * @return True if the tile can be sloped.
336 inline bool TileMayHaveSlopedTrack() const
338 /* Any track that isn't TRACK_X or TRACK_Y cannot be sloped. */
339 return IsDiagonalTrackdir(this->trackdir
);
343 * Trains can always use the faster algorithm because they
344 * have always the same direction as the track under them.
347 inline bool HasToUseGetSlopePixelZ()
353 #define FOR_ALL_TRAINS(var) FOR_ALL_VEHICLES_OF_TYPE(Train, var)