OpenTTD Source 20261112-master-gbcbec5e63f
ground_vehicle.hpp
Go to the documentation of this file.
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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
6 */
7
9
10#ifndef GROUND_VEHICLE_HPP
11#define GROUND_VEHICLE_HPP
12
13#include "vehicle_base.h"
14#include "landscape.h"
15#include "window_func.h"
16
18
20enum AccelStatus : uint8_t {
23};
24
30 /* Cached acceleration values, recalculated when the cargo on a vehicle changes (in addition to the conditions below) */
31 uint32_t cached_weight = 0;
33 uint32_t cached_max_te = 0;
35
36 /* Cached acceleration values, recalculated on load and each time a vehicle is added to/removed from the consist. */
38 uint32_t cached_power = 0;
39 uint32_t cached_air_drag = 0;
40
41 /* Cached NewGRF values, recalculated on load and each time a vehicle is added to/removed from the consist. */
42 uint16_t cached_total_length = 0;
43 EngineID first_engine = EngineID::Invalid();
44 uint8_t cached_veh_length = 0;
45
46 /* Cached UI information. */
47 uint16_t last_speed = 0;
48
49 auto operator<=>(const GroundVehicleCache &) const = default;
50};
51
73template <class T, VehicleType Type>
74struct GroundVehicle : public SpecializedVehicle<T, Type> {
77
79
85
86 void PowerChanged();
87 void CargoChanged();
88 int GetAcceleration() const;
89 bool IsChainInDepot() const override;
90
96 uint Crash(bool flooded) override
97 {
98 /* Crashed vehicles aren't going up or down */
99 for (T *v = T::From(this); v != nullptr; v = v->Next()) {
101 }
102 return this->Vehicle::Crash(flooded);
103 }
104
109 inline int64_t GetSlopeResistance() const
110 {
111 int64_t incl = 0;
112
113 for (const T *u = T::From(this); u != nullptr; u = u->Next()) {
114 if (u->gv_flags.Test(GroundVehicleFlag::GoingUp)) {
115 incl += u->gcache.cached_slope_resistance;
116 } else if (u->gv_flags.Test(GroundVehicleFlag::GoingDown)) {
117 incl -= u->gcache.cached_slope_resistance;
118 }
119 }
120
121 return incl;
122 }
123
131 {
132 this->z_pos = GetSlopePixelZ(this->x_pos, this->y_pos, true);
134
135 if (T::From(this)->TileMayHaveSlopedTrack()) {
136 /* To check whether the current tile is sloped, and in which
137 * direction it is sloped, we get the 'z' at the center of
138 * the tile (middle_z) and the edge of the tile (old_z),
139 * which we then can compare. */
140 int middle_z = GetSlopePixelZ((this->x_pos & ~TILE_UNIT_MASK) | (TILE_SIZE / 2), (this->y_pos & ~TILE_UNIT_MASK) | (TILE_SIZE / 2), true);
141
142 if (middle_z != this->z_pos) {
143 this->gv_flags.Set((middle_z > this->z_pos) ? GroundVehicleFlag::GoingUp : GroundVehicleFlag::GoingDown);
144 }
145 }
146 }
147
154 inline void UpdateZPosition()
155 {
156#if 0
157 /* The following code does this: */
158
159 if (this->gv_flags.Test(GroundVehicleFlag::GoingUp)) {
160 switch (this->GetMovingDirection()) {
161 case Direction::NE:
162 this->z_pos += (this->x_pos & 1) ^ 1; break;
163 case Direction::SW:
164 this->z_pos += (this->x_pos & 1); break;
165 case Direction::NW:
166 this->z_pos += (this->y_pos & 1) ^ 1; break;
167 case Direction::SE:
168 this->z_pos += (this->y_pos & 1); break;
169 default: break;
170 }
171 } else if (this->gv_flags.Test(GroundVehicleFlag::GoingDown)) {
172 switch (this->GetMovingDirection()) {
173 case Direction::NE:
174 this->z_pos -= (this->x_pos & 1) ^ 1; break;
175 case Direction::SW:
176 this->z_pos -= (this->x_pos & 1); break;
177 case Direction::NW:
178 this->z_pos -= (this->y_pos & 1) ^ 1; break;
179 case Direction::SE:
180 this->z_pos -= (this->y_pos & 1); break;
181 default: break;
182 }
183 }
184
185 /* But gcc 4.4.5 isn't able to nicely optimise it, and the resulting
186 * code is full of conditional jumps. */
187#endif
188
189 /* Vehicle's Z position can change only if it has GroundVehicleFlag::GoingUp or GroundVehicleFlag::GoingDown set.
190 * Furthermore, if this function is called once every time the vehicle's position changes,
191 * we know the Z position changes by +/-1 at certain moments - when x_pos, y_pos is odd/even,
192 * depending on orientation of the slope and vehicle's direction */
193
194 if (this->gv_flags.Any({GroundVehicleFlag::GoingUp, GroundVehicleFlag::GoingDown})) {
195 if (T::From(this)->HasToUseGetSlopePixelZ()) {
196 /* In some cases, we have to use GetSlopePixelZ() */
197 this->z_pos = GetSlopePixelZ(this->x_pos, this->y_pos, true);
198 return;
199 }
200 /* DirToDiagDir() is a simple right shift */
202 /* Read variables, so the compiler knows the access doesn't trap */
203 int8_t x_pos = this->x_pos;
204 int8_t y_pos = this->y_pos;
205 /* DiagDirToAxis() is a simple mask */
206 int8_t d = DiagDirToAxis(dir) == Axis::X ? x_pos : y_pos;
207 /* We need only the least significant bit */
208 d &= 1;
209 d ^= (int8_t)(dir == DiagDirection::NW || dir == DiagDirection::NE);
210 /* Subtraction instead of addition because we are testing for GroundVehicleFlag::GoingUp.
211 * GroundVehicleFlag::GoingUp is used because it's bit 0, so simple AND can be used,
212 * without any shift */
213 this->z_pos += this->gv_flags.Test(GroundVehicleFlag::GoingUp) ? d : -d;
214 }
215
216 assert(this->z_pos == GetSlopePixelZ(this->x_pos, this->y_pos, true));
217 }
218
225 inline int UpdateInclination(bool new_tile, bool update_delta)
226 {
227 int old_z = this->z_pos;
228
229 if (new_tile) {
231 } else {
232 this->UpdateZPosition();
233 }
234
235 this->UpdateViewport(true, update_delta);
236 return old_z;
237 }
238
242 inline void SetFrontEngine() { SetBit(this->subtype, GVSF_FRONT); }
243
247 inline void ClearFrontEngine() { ClrBit(this->subtype, GVSF_FRONT); }
248
253
258
262 inline void SetWagon() { SetBit(this->subtype, GVSF_WAGON); }
263
267 inline void ClearWagon() { ClrBit(this->subtype, GVSF_WAGON); }
268
272 inline void SetEngine() { SetBit(this->subtype, GVSF_ENGINE); }
273
277 inline void ClearEngine() { ClrBit(this->subtype, GVSF_ENGINE); }
278
282 inline void SetFreeWagon() { SetBit(this->subtype, GVSF_FREE_WAGON); }
283
287 inline void ClearFreeWagon() { ClrBit(this->subtype, GVSF_FREE_WAGON); }
288
293
298
303 inline bool IsFreeWagon() const { return HasBit(this->subtype, GVSF_FREE_WAGON); }
304
309 inline bool IsEngine() const { return HasBit(this->subtype, GVSF_ENGINE); }
310
315 inline bool IsWagon() const { return HasBit(this->subtype, GVSF_WAGON); }
316
321 inline bool IsMultiheaded() const { return HasBit(this->subtype, GVSF_MULTIHEADED); }
322
327 inline bool IsRearDualheaded() const { return this->IsMultiheaded() && !this->IsEngine(); }
328
333 inline bool CanLeadTrain() const
334 {
335 /* NewGRFs can allow unpowered wagons to lead trains. */
336 if (this->GetEngine()->info.extra_flags.Test(ExtraEngineFlag::HasCab)) return true;
337
338 /* This might be an articulated engine. */
339 if (this->IsArticulatedPart()) {
340 return this->GetFirstEnginePart()->IsEngine();
341 }
342
343 return this->IsEngine() || this->IsRearDualheaded();
344 }
345
351 inline void SetLastSpeed()
352 {
353 if (this->cur_speed != this->gcache.last_speed) {
354 SetWindowWidgetDirty(WindowClass::VehicleView, this->index, WID_VV_START_STOP);
355 this->gcache.last_speed = this->cur_speed;
356 }
357 }
358
359protected:
373 inline uint DoUpdateSpeed(uint accel, int min_speed, int max_speed)
374 {
375 uint spd = this->subspeed + accel;
376 this->subspeed = (uint8_t)spd;
377
378 /* When we are going faster than the maximum speed, reduce the speed
379 * somewhat gradually. But never lower than the maximum speed. */
380 int tempmax = max_speed;
381 if (this->cur_speed > max_speed) {
382 tempmax = std::max(this->cur_speed - (this->cur_speed / 10) - 1, max_speed);
383 }
384
385 /* Enforce a maximum and minimum speed. Normally we would use something like
386 * Clamp for this, but in this case min_speed might be below the maximum speed
387 * threshold for some reason. That makes acceleration fail and assertions
388 * happen in Clamp. So make it explicit that min_speed overrules the maximum
389 * speed by explicit ordering of min and max. */
390 this->cur_speed = spd = std::max(std::min(this->cur_speed + ((int)spd >> 8), tempmax), min_speed);
391
392 int scaled_spd = this->GetAdvanceSpeed(spd);
393
394 scaled_spd += this->progress;
395 this->progress = 0; // set later in *Handler or *Controller
396 return scaled_spd;
397 }
398};
399
400#endif /* GROUND_VEHICLE_HPP */
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr T ClrBit(T &x, const uint8_t y)
Clears a bit in a variable.
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
constexpr Timpl & Reset()
Reset all bits.
constexpr Timpl & Set()
Set all bits.
constexpr bool Any(const Timpl &other) const
Test if any of the given values are set.
Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
DiagDirection DirToDiagDir(Direction dir)
Convert a Direction to a DiagDirection.
@ SW
Southwest.
@ NW
Northwest.
@ NE
Northeast.
@ SE
Southeast.
@ X
The X axis.
DiagDirection
Enumeration for diagonal directions.
@ NW
Northwest.
@ NE
Northeast, upper right on your monitor.
@ HasCab
Train wagon has a cab and can lead a train when backing up, without any speed reduction.
PoolID< uint16_t, struct EngineIDTag, 64000, 0xFFFF > EngineID
Unique identification number of an engine.
Definition engine_type.h:25
#define T
Climate temperate.
Definition engines.h:91
AccelStatus
What is the status of our acceleration?
@ AS_BRAKE
We want to stop.
@ AS_ACCEL
We want to go faster, if possible of course.
int GetSlopePixelZ(int x, int y, bool ground_vehicle)
Return world Z coordinate of a given point of a tile.
Functions related to OTTD's landscape.
Cached, frequently calculated values.
uint32_t cached_weight
Total weight of the consist (valid only for the first engine).
uint32_t cached_air_drag
Air drag coefficient of the vehicle (valid only for the first engine).
uint16_t cached_axle_resistance
Resistance caused by the axles of the vehicle (valid only for the first engine).
EngineID first_engine
Cached EngineID of the front vehicle. EngineID::Invalid() for the front vehicle itself.
uint16_t last_speed
The last speed we did display, so we only have to redraw when this changes.
uint32_t cached_power
Total power of the consist (valid only for the first engine).
uint16_t cached_total_length
Length of the whole vehicle (valid only for the first engine).
uint8_t cached_veh_length
Length of this vehicle in units of 1/VEHICLE_LENGTH of normal length. It is cached because this can b...
uint32_t cached_max_te
Maximum tractive effort of consist (valid only for the first engine).
uint16_t cached_max_track_speed
Maximum consist speed (in internal units) limited by track type (valid only for the first engine).
uint32_t cached_slope_resistance
Resistance caused by weight when this vehicle part is at a slope.
bool IsChainInDepot() const override
Check whether the whole vehicle chain is in the depot.
void SetFreeWagon()
Set a vehicle as a free wagon.
int UpdateInclination(bool new_tile, bool update_delta)
Checks if the vehicle is in a slope and sets the required flags in that case.
bool CanLeadTrain() const
Check if this vehicle can lead a train.
void ClearWagon()
Clear wagon property.
GroundVehicle(VehicleID index)
The constructor at SpecializedVehicle must be called.
GroundVehicle< T, Type > GroundVehicleBase
Our type.
GroundVehicleCache gcache
Cache of often calculated values.
void CargoChanged()
Recalculates the cached weight of a vehicle and its parts.
void SetMultiheaded()
Set a vehicle as a multiheaded engine.
bool IsEngine() const
Check if a vehicle is an engine (can be first in a consist).
bool IsRearDualheaded() const
Tell if we are dealing with the rear end of a multiheaded engine.
bool IsMultiheaded() const
Check if the vehicle is a multiheaded engine.
void SetEngine()
Set engine status.
void SetWagon()
Set a vehicle to be a wagon.
void UpdateZPositionAndInclination()
Updates vehicle's Z position and inclination.
void SetFrontEngine()
Set front engine state.
void ClearFreeWagon()
Clear a vehicle from being a free wagon.
bool IsWagon() const
Check if a vehicle is a wagon.
int64_t GetSlopeResistance() const
Calculates the total slope resistance for this vehicle.
void PowerChanged()
Recalculates the cached total power of a vehicle.
void ClearArticulatedPart()
Clear a vehicle from being an articulated part.
void SetArticulatedPart()
Set a vehicle to be an articulated part.
GroundVehicleFlags gv_flags
uint Crash(bool flooded) override
Common code executed for crashed ground vehicles.
bool IsFreeWagon() const
Check if the vehicle is a free wagon (got no engine in front of it).
void ClearEngine()
Clear engine status.
void ClearMultiheaded()
Clear multiheaded engine property.
uint DoUpdateSpeed(uint accel, int min_speed, int max_speed)
Update the speed of the vehicle.
int GetAcceleration() const
Calculates the acceleration of the vehicle under its current conditions.
void ClearFrontEngine()
Remove the front engine state.
void UpdateZPosition()
Updates vehicle's Z position.
void SetLastSpeed()
Update the GUI variant of the current speed of the vehicle.
SpecializedVehicle(VehicleID index)
Set vehicle type correctly.
void UpdateViewport(bool force_update, bool update_delta)
Update vehicle sprite- and position caches.
T * GetFirstEnginePart()
Get the first part of an articulated engine.
static uint GetAdvanceSpeed(uint speed)
Determines the effective vehicle movement speed.
int32_t z_pos
z coordinate.
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition vehicle.cpp:750
Direction GetMovingDirection() const
Get the moving direction of this vehicle chain.
virtual uint Crash(bool flooded=false)
Crash the (whole) vehicle chain.
Definition vehicle.cpp:302
uint8_t subtype
subtype (Filled with values from AircraftSubType/DisasterSubType/EffectVehicleType/GroundVehicleSubty...
uint8_t subspeed
fractional speed
bool IsArticulatedPart() const
Check if the vehicle is an articulated part of an engine.
int32_t y_pos
y coordinate.
int32_t x_pos
x coordinate.
uint16_t cur_speed
current speed
uint8_t progress
The percentage (if divided by 256) this vehicle already crossed the tile unit.
static constexpr uint TILE_UNIT_MASK
For masking in/out the inner-tile world coordinate units.
Definition tile_type.h:16
static constexpr uint TILE_SIZE
Tile size in world coordinates.
Definition tile_type.h:15
Base class for all vehicles.
@ GVSF_ARTICULATED_PART
Articulated part of an engine.
@ GVSF_FRONT
Leading engine of a consist.
@ GVSF_MULTIHEADED
Engine is multiheaded (not used for road vehicles).
@ GVSF_FREE_WAGON
First in a wagon chain (in depot) (not used for road vehicles).
@ GVSF_WAGON
Wagon (not used for road vehicles).
@ GVSF_ENGINE
Engine that can be front engine, but might be placed behind another engine (not used for road vehicle...
PoolID< uint32_t, struct VehicleIDTag, 0xFF000, 0xFFFFF > VehicleID
The type all our vehicle IDs have.
EnumBitSet< GroundVehicleFlag, uint16_t > GroundVehicleFlags
Bitset of GroundVehicleFlag elements.
@ GoingUp
Vehicle is currently going uphill. (Cached track information for acceleration).
@ GoingDown
Vehicle is currently going downhill. (Cached track information for acceleration).
Types related to the vehicle widgets.
@ WID_VV_START_STOP
Start or stop this vehicle, and show information about the current state.
void SetWindowWidgetDirty(WindowClass cls, WindowNumber number, WidgetID widget_index)
Mark a particular widget in a particular window as dirty (in need of repainting).
Definition window.cpp:3271
Window functions not directly related to making/drawing windows.