OpenTTD Source  20241120-master-g6d3adc6169
roadveh.h
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 <http://www.gnu.org/licenses/>.
6  */
7 
10 #ifndef ROADVEH_H
11 #define ROADVEH_H
12 
13 #include "ground_vehicle.hpp"
14 #include "engine_base.h"
15 #include "cargotype.h"
16 #include "track_func.h"
17 #include "road.h"
18 #include "road_map.h"
19 #include "newgrf_engine.h"
20 
21 struct RoadVehicle;
22 
25  /*
26  * Lower 4 bits are used for vehicle track direction. (Trackdirs)
27  * When in a road stop (bit 5 or bit 6 set) these bits give the
28  * track direction of the entry to the road stop.
29  * As the entry direction will always be a diagonal
30  * direction (X_NE, Y_SE, X_SW or Y_NW) only bits 0 and 3
31  * are needed to hold this direction. Bit 1 is then used to show
32  * that the vehicle is using the second road stop bay.
33  * Bit 2 is then used for drive-through stops to show the vehicle
34  * is stopping at this road stop.
35  */
36 
37  /* Numeric values */
38  RVSB_IN_DEPOT = 0xFE,
39  RVSB_WORMHOLE = 0xFF,
40 
41  /* Bit numbers */
47 
48  /* Bit sets of the above specified bits */
50  RVSB_IN_ROAD_STOP_END = RVSB_IN_ROAD_STOP + TRACKDIR_END,
52  RVSB_IN_DT_ROAD_STOP_END = RVSB_IN_DT_ROAD_STOP + TRACKDIR_END,
53 
55 
58 };
59 
61 static const uint RDE_NEXT_TILE = 0x80;
62 static const uint RDE_TURNED = 0x40;
63 
64 /* Start frames for when a vehicle enters a tile/changes its state.
65  * The start frame is different for vehicles that turned around or
66  * are leaving the depot as the do not start at the edge of the tile.
67  * For trams there are a few different start frames as there are two
68  * places where trams can turn. */
69 static const uint RVC_DEFAULT_START_FRAME = 0;
70 static const uint RVC_TURN_AROUND_START_FRAME = 1;
71 static const uint RVC_DEPOT_START_FRAME = 6;
72 static const uint RVC_START_FRAME_AFTER_LONG_TRAM = 21;
73 static const uint RVC_TURN_AROUND_START_FRAME_SHORT_TRAM = 16;
74 /* Stop frame for a vehicle in a drive-through stop */
75 static const uint RVC_DRIVE_THROUGH_STOP_FRAME = 11;
76 static const uint RVC_DEPOT_STOP_FRAME = 11;
77 
79 static const uint8_t RV_OVERTAKE_TIMEOUT = 35;
80 
81 void RoadVehUpdateCache(RoadVehicle *v, bool same_length = false);
82 void GetRoadVehSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type);
83 
88 
91 };
92 
93 using RoadVehPathCache = std::vector<RoadVehPathElement>;
94 
98 struct RoadVehicle final : public GroundVehicle<RoadVehicle, VEH_ROAD> {
99  RoadVehPathCache path;
100  uint8_t state;
101  uint8_t frame;
102  uint16_t blocked_ctr;
103  uint8_t overtaking;
104  uint8_t overtaking_ctr;
105  uint16_t crashed_ctr;
106  uint8_t reverse_ctr;
107 
111 
115  virtual ~RoadVehicle() { this->PreDestructor(); }
116 
117  friend struct GroundVehicle<RoadVehicle, VEH_ROAD>; // GroundVehicle needs to use the acceleration functions defined at RoadVehicle.
118 
119  void MarkDirty() override;
120  void UpdateDeltaXY() override;
121  ExpensesType GetExpenseType(bool income) const override { return income ? EXPENSES_ROADVEH_REVENUE : EXPENSES_ROADVEH_RUN; }
122  bool IsPrimaryVehicle() const override { return this->IsFrontEngine(); }
123  void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const override;
124  int GetDisplaySpeed() const override { return this->gcache.last_speed / 2; }
125  int GetDisplayMaxSpeed() const override { return this->vcache.cached_max_speed / 2; }
126  Money GetRunningCost() const override;
127  int GetDisplayImageWidth(Point *offset = nullptr) const;
128  bool IsInDepot() const override { return this->state == RVSB_IN_DEPOT; }
129  bool Tick() override;
130  void OnNewCalendarDay() override;
131  void OnNewEconomyDay() override;
132  uint Crash(bool flooded = false) override;
133  Trackdir GetVehicleTrackdir() const override;
134  TileIndex GetOrderStationLocation(StationID station) override;
135  ClosestDepot FindClosestDepot() override;
136 
137  bool IsBus() const;
138 
139  int GetCurrentMaxSpeed() const override;
140  int UpdateSpeed();
141  void SetDestTile(TileIndex tile) override;
142 
143 protected: // These functions should not be called outside acceleration code.
144 
149  inline uint16_t GetPower() const
150  {
151  /* Power is not added for articulated parts */
152  if (!this->IsArticulatedPart()) {
153  /* Road vehicle power is in units of 10 HP. */
154  return 10 * GetVehicleProperty(this, PROP_ROADVEH_POWER, RoadVehInfo(this->engine_type)->power);
155  }
156  return 0;
157  }
158 
163  inline uint16_t GetPoweredPartPower(const RoadVehicle *) const
164  {
165  return 0;
166  }
167 
172  inline uint16_t GetWeight() const
173  {
174  uint16_t weight = CargoSpec::Get(this->cargo_type)->WeightOfNUnits(this->cargo.StoredCount());
175 
176  /* Vehicle weight is not added for articulated parts. */
177  if (!this->IsArticulatedPart()) {
178  /* Road vehicle weight is in units of 1/4 t. */
179  weight += GetVehicleProperty(this, PROP_ROADVEH_WEIGHT, RoadVehInfo(this->engine_type)->weight) / 4;
180  }
181 
182  return weight;
183  }
184 
189  uint16_t GetMaxWeight() const override;
190 
195  inline uint8_t GetTractiveEffort() const
196  {
197  /* The tractive effort coefficient is in units of 1/256. */
198  return GetVehicleProperty(this, PROP_ROADVEH_TRACTIVE_EFFORT, RoadVehInfo(this->engine_type)->tractive_effort);
199  }
200 
205  inline uint8_t GetAirDragArea() const
206  {
207  return 6;
208  }
209 
214  inline uint8_t GetAirDrag() const
215  {
216  return RoadVehInfo(this->engine_type)->air_drag;
217  }
218 
224  {
225  return (this->vehstatus & VS_STOPPED) ? AS_BRAKE : AS_ACCEL;
226  }
227 
232  inline uint16_t GetCurrentSpeed() const
233  {
234  return this->cur_speed / 2;
235  }
236 
241  inline uint32_t GetRollingFriction() const
242  {
243  /* Trams have a slightly greater friction coefficient than trains.
244  * The rest of road vehicles have bigger values. */
245  uint32_t coeff = RoadTypeIsTram(this->roadtype) ? 40 : 75;
246  /* The friction coefficient increases with speed in a way that
247  * it doubles at 128 km/h, triples at 256 km/h and so on. */
248  return coeff * (128 + this->GetCurrentSpeed()) / 128;
249  }
250 
255  inline int GetAccelerationType() const
256  {
257  return 0;
258  }
259 
264  inline uint32_t GetSlopeSteepness() const
265  {
267  }
268 
273  inline uint16_t GetMaxTrackSpeed() const
274  {
275  return GetRoadTypeInfo(GetRoadType(this->tile, GetRoadTramType(this->roadtype)))->max_speed;
276  }
277 
282  inline bool TileMayHaveSlopedTrack() const
283  {
284  TrackStatus ts = GetTileTrackStatus(this->tile, TRANSPORT_ROAD, GetRoadTramType(this->roadtype));
285  TrackBits trackbits = TrackStatusToTrackBits(ts);
286 
287  return trackbits == TRACK_BIT_X || trackbits == TRACK_BIT_Y;
288  }
289 
298  {
299  const RoadVehicle *rv = this->First();
300 
301  /* Check if this vehicle is in the same direction as the road under.
302  * We already know it has either GVF_GOINGUP_BIT or GVF_GOINGDOWN_BIT set. */
303 
305  /* If the first vehicle is reversing, this vehicle may be reversing too
306  * (especially if this is the first, and maybe the only, vehicle).*/
307  return true;
308  }
309 
310  while (rv != this) {
311  /* If any previous vehicle has different direction,
312  * we may be in the middle of reversing. */
313  if (this->direction != rv->direction) return true;
314  rv = rv->Next();
315  }
316 
317  return false;
318  }
319 };
320 
321 #endif /* ROADVEH_H */
Types/functions related to cargoes.
uint16_t max_speed
Maximum speed for vehicles travelling on this road type.
Definition: road.h:142
uint StoredCount() const
Returns sum of cargo on board the vehicle (ie not only reserved).
Definition: cargopacket.h:434
Direction
Defines the 8 directions on the map.
ExpensesType
Types of expenses.
Definition: economy_type.h:172
@ EXPENSES_ROADVEH_RUN
Running costs road vehicles.
Definition: economy_type.h:176
@ EXPENSES_ROADVEH_REVENUE
Revenue from road vehicles.
Definition: economy_type.h:181
Base class for engines.
uint16_t EngineID
Unique identification number of an engine.
Definition: engine_type.h:21
Base class and functions for all vehicles that move through ground.
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.
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition: landscape.cpp:554
Functions for NewGRF engines.
@ PROP_ROADVEH_WEIGHT
Weight in 1/4 t.
@ PROP_ROADVEH_TRACTIVE_EFFORT
Tractive effort coefficient in 1/256.
@ PROP_ROADVEH_POWER
Power in 10 HP.
Road specific functions.
const RoadTypeInfo * GetRoadTypeInfo(RoadType roadtype)
Returns a pointer to the Roadtype information for a given roadtype.
Definition: road.h:227
Map accessors for roads.
RoadTypes
The different roadtypes we support, but then a bitmask of them.
Definition: road_type.h:38
RoadType
The different roadtypes we support.
Definition: road_type.h:25
static const uint RDE_TURNED
We just finished turning.
Definition: roadveh.h:62
static const uint8_t RV_OVERTAKE_TIMEOUT
The number of ticks a vehicle has for overtaking.
Definition: roadveh.h:79
RoadVehicleStates
Road vehicle states.
Definition: roadveh.h:24
@ RVSB_IN_DT_ROAD_STOP
The vehicle is in a drive-through road stop.
Definition: roadveh.h:51
@ RVS_ENTERED_STOP
Only set when a vehicle has entered the stop.
Definition: roadveh.h:43
@ RVSB_IN_ROAD_STOP
The vehicle is in a road stop.
Definition: roadveh.h:49
@ RVS_USING_SECOND_BAY
Only used while in a road stop.
Definition: roadveh.h:42
@ RVSB_ROAD_STOP_TRACKDIR_MASK
Only bits 0 and 3 are used to encode the trackdir for road stops.
Definition: roadveh.h:57
@ RVS_IN_DT_ROAD_STOP
The vehicle is in a drive-through road stop.
Definition: roadveh.h:46
@ RVSB_TRACKDIR_MASK
The mask used to extract track dirs.
Definition: roadveh.h:56
@ RVSB_DRIVE_SIDE
The vehicle is at the opposite side of the road.
Definition: roadveh.h:54
@ RVS_IN_ROAD_STOP
The vehicle is in a road stop.
Definition: roadveh.h:45
@ RVSB_IN_DEPOT
The vehicle is in a depot.
Definition: roadveh.h:38
@ RVSB_WORMHOLE
The vehicle is in a tunnel and/or bridge.
Definition: roadveh.h:39
@ RVS_DRIVE_SIDE
Only used when retrieving move data.
Definition: roadveh.h:44
void GetRoadVehSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
Get the size of the sprite of a road vehicle sprite heading west (used for lists).
void RoadVehUpdateCache(RoadVehicle *v, bool same_length=false)
Update the cache of a road vehicle.
static const uint RDE_NEXT_TILE
State information about the Road Vehicle controller.
Definition: roadveh.h:61
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:57
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo ID.
Definition: cargotype.h:134
Structure to return information about the closest depot location, and whether it could be found.
Definition: vehicle_base.h:230
VehicleSettings vehicle
options for vehicles
uint16_t last_speed
The last speed we did display, so we only have to redraw when this changes.
Base class for all vehicles that move through ground.
GroundVehicleCache gcache
Cache of often calculated values.
Coordinates of a point in 2D.
Element of the RoadVehPathCache.
Definition: roadveh.h:85
Trackdir trackdir
Trackdir for this element.
Definition: roadveh.h:86
TileIndex tile
Tile for this element.
Definition: roadveh.h:87
uint8_t air_drag
Coefficient of air drag.
Definition: engine_type.h:125
Buses, trucks and trams belong to this class.
Definition: roadveh.h:98
uint Crash(bool flooded=false) override
Crash the (whole) vehicle chain.
uint8_t GetAirDragArea() const
Gets the area used for calculating air drag.
Definition: roadveh.h:205
void OnNewEconomyDay() override
Economy day handler.
uint8_t state
Definition: roadveh.h:100
int GetDisplaySpeed() const override
Gets the speed in km-ish/h that can be sent into SetDParam for string processing.
Definition: roadveh.h:124
virtual ~RoadVehicle()
We want to 'destruct' the right class.
Definition: roadveh.h:115
int GetDisplayImageWidth(Point *offset=nullptr) const
Get the width of a road vehicle image in the GUI.
Definition: roadveh_cmd.cpp:93
uint32_t GetSlopeSteepness() const
Returns the slope steepness used by this vehicle.
Definition: roadveh.h:264
uint16_t GetPower() const
Allows to know the power value that this vehicle will use.
Definition: roadveh.h:149
Money GetRunningCost() const override
Gets the running cost of a vehicle.
bool IsPrimaryVehicle() const override
Whether this is the primary vehicle in the chain.
Definition: roadveh.h:122
uint16_t GetMaxWeight() const override
Calculates the weight value that this vehicle will have when fully loaded with its current cargo.
uint16_t GetCurrentSpeed() const
Calculates the current speed of this vehicle.
Definition: roadveh.h:232
RoadTypes compatible_roadtypes
NOSAVE: Roadtypes this consist is powered on.
Definition: roadveh.h:110
AccelStatus GetAccelerationStatus() const
Checks the current acceleration status of this vehicle.
Definition: roadveh.h:223
void UpdateDeltaXY() override
Updates the x and y offsets and the size of the sprite used for this vehicle.
uint16_t crashed_ctr
Animation counter when the vehicle has crashed.
Definition: roadveh.h:105
bool IsBus() const
Check whether a roadvehicle is a bus.
Definition: roadveh_cmd.cpp:82
uint8_t overtaking_ctr
The length of the current overtake attempt.
Definition: roadveh.h:104
void OnNewCalendarDay() override
Calandar day handler.
uint16_t GetMaxTrackSpeed() const
Gets the maximum speed allowed by the track for this vehicle.
Definition: roadveh.h:273
uint32_t GetRollingFriction() const
Returns the rolling friction coefficient of this vehicle.
Definition: roadveh.h:241
int GetAccelerationType() const
Allows to know the acceleration type of a vehicle.
Definition: roadveh.h:255
uint8_t GetTractiveEffort() const
Allows to know the tractive effort value that this vehicle will use.
Definition: roadveh.h:195
bool IsInDepot() const override
Check whether the vehicle is in the depot.
Definition: roadveh.h:128
int GetDisplayMaxSpeed() const override
Gets the maximum speed in km-ish/h that can be sent into SetDParam for string processing.
Definition: roadveh.h:125
RoadVehPathCache path
Cached path.
Definition: roadveh.h:99
Trackdir GetVehicleTrackdir() const override
Returns the Trackdir on which the vehicle is currently located.
bool TileMayHaveSlopedTrack() const
Checks if the vehicle is at a tile that can be sloped.
Definition: roadveh.h:282
int GetCurrentMaxSpeed() const override
Calculates the maximum speed of the vehicle under its current conditions.
bool HasToUseGetSlopePixelZ()
Road vehicles have to use GetSlopePixelZ() to compute their height if they are reversing because in t...
Definition: roadveh.h:297
RoadType roadtype
NOSAVE: Roadtype of this vehicle.
Definition: roadveh.h:108
uint8_t overtaking
Set to RVSB_DRIVE_SIDE when overtaking, otherwise 0.
Definition: roadveh.h:103
int UpdateSpeed()
This function looks at the vehicle and updates its speed (cur_speed and subspeed) variables.
uint16_t GetPoweredPartPower(const RoadVehicle *) const
Returns a value if this articulated part is powered.
Definition: roadveh.h:163
bool Tick() override
Calls the tick handler of the vehicle.
VehicleID disaster_vehicle
NOSAVE: Disaster vehicle targetting this vehicle.
Definition: roadveh.h:109
RoadVehicle()
We don't want GCC to zero our struct! It already is zeroed and has an index!
Definition: roadveh.h:113
ClosestDepot FindClosestDepot() override
Find the closest depot for this vehicle and tell us the location, DestinationID and whether we should...
uint16_t GetWeight() const
Allows to know the weight value that this vehicle will use.
Definition: roadveh.h:172
void MarkDirty() override
Marks the vehicles to be redrawn and updates cached variables.
uint8_t GetAirDrag() const
Gets the air drag coefficient of this vehicle.
Definition: roadveh.h:214
T * Next() const
Get next vehicle in the chain.
T * First() const
Get the first vehicle in the chain.
uint16_t cached_max_speed
Maximum speed of the consist (minimum of the max speed of all vehicles in the consist).
Definition: vehicle_base.h:126
uint8_t roadveh_slope_steepness
Steepness of hills for road vehicles when using realistic acceleration.
Sprite sequence for a vehicle part.
Definition: vehicle_base.h:135
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:323
Direction direction
facing
Definition: vehicle_base.h:307
VehicleCargoList cargo
The cargo this vehicle is carrying.
Definition: vehicle_base.h:341
virtual void GetImage([[maybe_unused]] Direction direction, [[maybe_unused]] EngineImageType image_type, [[maybe_unused]] VehicleSpriteSeq *result) const
Gets the sprite to show for the given direction.
Definition: vehicle_base.h:486
virtual TileIndex GetOrderStationLocation([[maybe_unused]] StationID station)
Determine the location for the station where the vehicle goes to next.
Definition: vehicle_base.h:796
bool IsArticulatedPart() const
Check if the vehicle is an articulated part of an engine.
Definition: vehicle_base.h:954
debug_inline bool IsFrontEngine() const
Check if the vehicle is a front engine.
Definition: vehicle_base.h:945
void PreDestructor()
Destroy all stuff that (still) needs the virtual functions to work properly.
Definition: vehicle.cpp:826
CargoID cargo_type
type of cargo this vehicle is carrying
Definition: vehicle_base.h:342
uint8_t vehstatus
Status.
Definition: vehicle_base.h:354
VehicleCache vcache
Cache of often used vehicle values.
Definition: vehicle_base.h:364
virtual ExpensesType GetExpenseType([[maybe_unused]] bool income) const
Sets the expense type associated to this vehicle type.
Definition: vehicle_base.h:466
uint16_t cur_speed
current speed
Definition: vehicle_base.h:328
TileIndex tile
Current tile index.
Definition: vehicle_base.h:264
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:95
Different conversion functions from one kind of track to another.
bool IsReversingRoadTrackdir(Trackdir dir)
Checks whether the trackdir means that we are reversing.
Definition: track_func.h:673
TrackBits TrackStatusToTrackBits(TrackStatus ts)
Returns the present-track-information of a TrackStatus.
Definition: track_func.h:363
TrackBits
Allow incrementing of Track variables.
Definition: track_type.h:35
@ TRACK_BIT_Y
Y-axis track.
Definition: track_type.h:38
@ TRACK_BIT_X
X-axis track.
Definition: track_type.h:37
Trackdir
Enumeration for tracks and directions.
Definition: track_type.h:67
@ INVALID_TRACKDIR
Flag for an invalid trackdir.
Definition: track_type.h:86
@ TRACKDIR_END
Used for iterations.
Definition: track_type.h:85
@ TRANSPORT_ROAD
Transport by road vehicle.
@ VS_STOPPED
Vehicle is stopped by the player.
Definition: vehicle_base.h:34
EngineImageType
Visualisation contexts of vehicles and engines.
Definition: vehicle_type.h:78
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
uint32_t VehicleID
The type all our vehicle IDs have.
Definition: vehicle_type.h:16
static const VehicleID INVALID_VEHICLE
Constant representing a non-existing vehicle.
Definition: vehicle_type.h:54