Fix: Don't allow right-click to close world generation progress window. (#13084)
[openttd-github.git] / src / train.h
blobbbf1e04365e0b8a7ef396b580879e7a7bb334c01
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 */
8 /** @file train.h Base for the train class. */
10 #ifndef TRAIN_H
11 #define TRAIN_H
13 #include "core/enum_type.hpp"
15 #include "newgrf_engine.h"
16 #include "cargotype.h"
17 #include "rail.h"
18 #include "engine_base.h"
19 #include "rail_map.h"
20 #include "ground_vehicle.hpp"
22 struct Train;
24 /** Rail vehicle flags. */
25 enum VehicleRailFlags {
26 VRF_REVERSING = 0,
27 VRF_POWEREDWAGON = 3, ///< Wagon is powered.
28 VRF_REVERSE_DIRECTION = 4, ///< Reverse the visible direction of the vehicle.
30 VRF_EL_ENGINE_ALLOWED_NORMAL_RAIL = 6, ///< Electric train engine is allowed to run on normal rail. */
31 VRF_TOGGLE_REVERSE = 7, ///< Used for vehicle var 0xFE bit 8 (toggled each time the train is reversed, accurate for first vehicle only).
32 VRF_TRAIN_STUCK = 8, ///< Train can't get a path reservation.
33 VRF_LEAVING_STATION = 9, ///< Train is just leaving a station.
36 /** Modes for ignoring signals. */
37 enum TrainForceProceeding : uint8_t {
38 TFP_NONE = 0, ///< Normal operation.
39 TFP_STUCK = 1, ///< Proceed till next signal, but ignore being stuck till then. This includes force leaving depots.
40 TFP_SIGNAL = 2, ///< Ignore next signal, after the signal ignore being stuck.
43 /** Flags for Train::ConsistChanged */
44 enum ConsistChangeFlags {
45 CCF_LENGTH = 0x01, ///< Allow vehicles to change length.
46 CCF_CAPACITY = 0x02, ///< Allow vehicles to change capacity.
48 CCF_TRACK = 0, ///< Valid changes while vehicle is driving, and possibly changing tracks.
49 CCF_LOADUNLOAD = 0, ///< Valid changes while vehicle is loading/unloading.
50 CCF_AUTOREFIT = CCF_CAPACITY, ///< Valid changes for autorefitting in stations.
51 CCF_REFIT = CCF_LENGTH | CCF_CAPACITY, ///< Valid changes for refitting in a depot.
52 CCF_ARRANGE = CCF_LENGTH | CCF_CAPACITY, ///< Valid changes for arranging the consist in a depot.
53 CCF_SAVELOAD = CCF_LENGTH, ///< Valid changes when loading a savegame. (Everything that is not stored in the save.)
55 DECLARE_ENUM_AS_BIT_SET(ConsistChangeFlags)
57 uint8_t FreightWagonMult(CargoID cargo);
59 void CheckTrainsLengths();
61 void FreeTrainTrackReservation(const Train *v);
62 bool TryPathReserve(Train *v, bool mark_as_stuck = false, bool first_tile_okay = false);
64 int GetTrainStopLocation(StationID station_id, TileIndex tile, const Train *v, int *station_ahead, int *station_length);
66 void GetTrainSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type);
68 bool TrainOnCrossing(TileIndex tile);
69 void NormalizeTrainVehInDepot(const Train *u);
71 /** Variables that are cached to improve performance and such */
72 struct TrainCache {
73 /* Cached wagon override spritegroup */
74 const struct SpriteGroup *cached_override;
76 /* cached values, recalculated on load and each time a vehicle is added to/removed from the consist. */
77 bool cached_tilt; ///< train can tilt; feature provides a bonus in curves
78 uint8_t user_def_data; ///< Cached property 0x25. Can be set by Callback 0x36.
80 int16_t cached_curve_speed_mod; ///< curve speed modifier of the entire train
81 uint16_t cached_max_curve_speed; ///< max consist speed limited by curves
83 auto operator<=>(const TrainCache &) const = default;
86 /**
87 * 'Train' is either a loco or a wagon.
89 struct Train final : public GroundVehicle<Train, VEH_TRAIN> {
90 uint16_t flags;
91 uint16_t crash_anim_pos; ///< Crash animation counter.
92 uint16_t wait_counter; ///< Ticks waiting in front of a signal, ticks being stuck or a counter for forced proceeding through signals.
94 TrainCache tcache;
96 /* Link between the two ends of a multiheaded engine */
97 Train *other_multiheaded_part;
99 RailTypes compatible_railtypes;
100 RailType railtype;
102 TrackBits track;
103 TrainForceProceeding force_proceed;
105 /** We don't want GCC to zero our struct! It already is zeroed and has an index! */
106 Train() : GroundVehicleBase() {}
107 /** We want to 'destruct' the right class. */
108 virtual ~Train() { this->PreDestructor(); }
110 friend struct GroundVehicle<Train, VEH_TRAIN>; // GroundVehicle needs to use the acceleration functions defined at Train.
112 void MarkDirty() override;
113 void UpdateDeltaXY() override;
114 ExpensesType GetExpenseType(bool income) const override { return income ? EXPENSES_TRAIN_REVENUE : EXPENSES_TRAIN_RUN; }
115 void PlayLeaveStationSound(bool force = false) const override;
116 bool IsPrimaryVehicle() const override { return this->IsFrontEngine(); }
117 void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const override;
118 int GetDisplaySpeed() const override { return this->gcache.last_speed; }
119 int GetDisplayMaxSpeed() const override { return this->vcache.cached_max_speed; }
120 Money GetRunningCost() const override;
121 int GetCursorImageOffset() const;
122 int GetDisplayImageWidth(Point *offset = nullptr) const;
123 bool IsInDepot() const override { return this->track == TRACK_BIT_DEPOT; }
124 bool Tick() override;
125 void OnNewCalendarDay() override;
126 void OnNewEconomyDay() override;
127 uint Crash(bool flooded = false) override;
128 Trackdir GetVehicleTrackdir() const override;
129 TileIndex GetOrderStationLocation(StationID station) override;
130 ClosestDepot FindClosestDepot() override;
132 void ReserveTrackUnderConsist() const;
134 uint16_t GetCurveSpeedLimit() const;
136 void ConsistChanged(ConsistChangeFlags allowed_changes);
138 int UpdateSpeed();
140 void UpdateAcceleration();
142 int GetCurrentMaxSpeed() const override;
145 * Get the next real (non-articulated part and non rear part of dualheaded engine) vehicle in the consist.
146 * @return Next vehicle in the consist.
148 inline Train *GetNextUnit() const
150 Train *v = this->GetNextVehicle();
151 if (v != nullptr && v->IsRearDualheaded()) v = v->GetNextVehicle();
153 return v;
157 * Get the previous real (non-articulated part and non rear part of dualheaded engine) vehicle in the consist.
158 * @return Previous vehicle in the consist.
160 inline Train *GetPrevUnit()
162 Train *v = this->GetPrevVehicle();
163 if (v != nullptr && v->IsRearDualheaded()) v = v->GetPrevVehicle();
165 return v;
169 * Calculate the offset from this vehicle's center to the following center taking the vehicle lengths into account.
170 * @return Offset from center to center.
172 int CalcNextVehicleOffset() const
174 /* For vehicles with odd lengths the part before the center will be one unit
175 * longer than the part after the center. This means we have to round up the
176 * length of the next vehicle but may not round the length of the current
177 * vehicle. */
178 return this->gcache.cached_veh_length / 2 + (this->Next() != nullptr ? this->Next()->gcache.cached_veh_length + 1 : 0) / 2;
181 protected: // These functions should not be called outside acceleration code.
184 * Allows to know the power value that this vehicle will use.
185 * @return Power value from the engine in HP, or zero if the vehicle is not powered.
187 inline uint16_t GetPower() const
189 /* Power is not added for articulated parts */
190 if (!this->IsArticulatedPart() && HasPowerOnRail(this->railtype, GetRailType(this->tile))) {
191 uint16_t power = GetVehicleProperty(this, PROP_TRAIN_POWER, RailVehInfo(this->engine_type)->power);
192 /* Halve power for multiheaded parts */
193 if (this->IsMultiheaded()) power /= 2;
194 return power;
197 return 0;
201 * Returns a value if this articulated part is powered.
202 * @return Power value from the articulated part in HP, or zero if it is not powered.
204 inline uint16_t GetPoweredPartPower(const Train *head) const
206 /* For powered wagons the engine defines the type of engine (i.e. railtype) */
207 if (HasBit(this->flags, VRF_POWEREDWAGON) && HasPowerOnRail(head->railtype, GetRailType(this->tile))) {
208 return RailVehInfo(this->gcache.first_engine)->pow_wag_power;
211 return 0;
215 * Allows to know the weight value that this vehicle will use.
216 * @return Weight value from the engine in tonnes.
218 inline uint16_t GetWeight() const
220 uint16_t weight = CargoSpec::Get(this->cargo_type)->WeightOfNUnitsInTrain(this->cargo.StoredCount());
222 /* Vehicle weight is not added for articulated parts. */
223 if (!this->IsArticulatedPart()) {
224 weight += GetVehicleProperty(this, PROP_TRAIN_WEIGHT, RailVehInfo(this->engine_type)->weight);
227 /* Powered wagons have extra weight added. */
228 if (HasBit(this->flags, VRF_POWEREDWAGON)) {
229 weight += RailVehInfo(this->gcache.first_engine)->pow_wag_weight;
232 return weight;
236 * Calculates the weight value that this vehicle will have when fully loaded with its current cargo.
237 * @return Weight value in tonnes.
239 uint16_t GetMaxWeight() const override;
242 * Allows to know the tractive effort value that this vehicle will use.
243 * @return Tractive effort value from the engine.
245 inline uint8_t GetTractiveEffort() const
247 return GetVehicleProperty(this, PROP_TRAIN_TRACTIVE_EFFORT, RailVehInfo(this->engine_type)->tractive_effort);
251 * Gets the area used for calculating air drag.
252 * @return Area of the engine in m^2.
254 inline uint8_t GetAirDragArea() const
256 /* Air drag is higher in tunnels due to the limited cross-section. */
257 return (this->track == TRACK_BIT_WORMHOLE && this->vehstatus & VS_HIDDEN) ? 28 : 14;
261 * Gets the air drag coefficient of this vehicle.
262 * @return Air drag value from the engine.
264 inline uint8_t GetAirDrag() const
266 return RailVehInfo(this->engine_type)->air_drag;
270 * Checks the current acceleration status of this vehicle.
271 * @return Acceleration status.
273 inline AccelStatus GetAccelerationStatus() const
275 return (this->vehstatus & VS_STOPPED) || HasBit(this->flags, VRF_REVERSING) || HasBit(this->flags, VRF_TRAIN_STUCK) ? AS_BRAKE : AS_ACCEL;
279 * Calculates the current speed of this vehicle.
280 * @return Current speed in km/h-ish.
282 inline uint16_t GetCurrentSpeed() const
284 return this->cur_speed;
288 * Returns the rolling friction coefficient of this vehicle.
289 * @return Rolling friction coefficient in [1e-4].
291 inline uint32_t GetRollingFriction() const
293 /* Rolling friction for steel on steel is between 0.1% and 0.2%.
294 * The friction coefficient increases with speed in a way that
295 * it doubles at 512 km/h, triples at 1024 km/h and so on. */
296 return 15 * (512 + this->GetCurrentSpeed()) / 512;
300 * Allows to know the acceleration type of a vehicle.
301 * @return Acceleration type of the vehicle.
303 inline int GetAccelerationType() const
305 return GetRailTypeInfo(this->railtype)->acceleration_type;
309 * Returns the slope steepness used by this vehicle.
310 * @return Slope steepness used by the vehicle.
312 inline uint32_t GetSlopeSteepness() const
314 return _settings_game.vehicle.train_slope_steepness;
318 * Gets the maximum speed allowed by the track for this vehicle.
319 * @return Maximum speed allowed.
321 inline uint16_t GetMaxTrackSpeed() const
323 return GetRailTypeInfo(GetRailType(this->tile))->max_speed;
327 * Returns the curve speed modifier of this vehicle.
328 * @return Current curve speed modifier, in fixed-point binary representation with 8 fractional bits.
330 inline int16_t GetCurveSpeedModifier() const
332 return GetVehicleProperty(this, PROP_TRAIN_CURVE_SPEED_MOD, RailVehInfo(this->engine_type)->curve_speed_mod, true);
336 * Checks if the vehicle is at a tile that can be sloped.
337 * @return True if the tile can be sloped.
339 inline bool TileMayHaveSlopedTrack() const
341 /* Any track that isn't TRACK_BIT_X or TRACK_BIT_Y cannot be sloped. */
342 return this->track == TRACK_BIT_X || this->track == TRACK_BIT_Y;
346 * Trains can always use the faster algorithm because they
347 * have always the same direction as the track under them.
348 * @return false
350 inline bool HasToUseGetSlopePixelZ()
352 return false;
356 #endif /* TRAIN_H */