Go to the documentation of this file.
1 /* $Id: roadveh.h 27666 2016-10-16 14:57:56Z frosch $ */
3 /*
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 <>.
8  */
12 #ifndef ROADVEH_H
13 #define ROADVEH_H
15 #include "ground_vehicle.hpp"
16 #include "engine_base.h"
17 #include "cargotype.h"
18 #include "track_func.h"
19 #include "road_type.h"
20 #include "newgrf_engine.h"
22 struct RoadVehicle;
26  /*
27  * Lower 4 bits are used for vehicle track direction. (Trackdirs)
28  * When in a road stop (bit 5 or bit 6 set) these bits give the
29  * track direction of the entry to the road stop.
30  * As the entry direction will always be a diagonal
31  * direction (X_NE, Y_SE, X_SW or Y_NW) only bits 0 and 3
32  * are needed to hold this direction. Bit 1 is then used to show
33  * that the vehicle is using the second road stop bay.
34  * Bit 2 is then used for drive-through stops to show the vehicle
35  * is stopping at this road stop.
36  */
38  /* Numeric values */
42  /* Bit numbers */
49  /* Bit sets of the above specified bits */
59 };
62 static const uint RDE_NEXT_TILE = 0x80;
63 static const uint RDE_TURNED = 0x40;
65 /* Start frames for when a vehicle enters a tile/changes its state.
66  * The start frame is different for vehicles that turned around or
67  * are leaving the depot as the do not start at the edge of the tile.
68  * For trams there are a few different start frames as there are two
69  * places where trams can turn. */
70 static const uint RVC_DEFAULT_START_FRAME = 0;
71 static const uint RVC_TURN_AROUND_START_FRAME = 1;
72 static const uint RVC_DEPOT_START_FRAME = 6;
73 static const uint RVC_START_FRAME_AFTER_LONG_TRAM = 21;
74 static const uint RVC_TURN_AROUND_START_FRAME_SHORT_TRAM = 16;
75 /* Stop frame for a vehicle in a drive-through stop */
76 static const uint RVC_DRIVE_THROUGH_STOP_FRAME = 11;
77 static const uint RVC_DEPOT_STOP_FRAME = 11;
80 static const byte RV_OVERTAKE_TIMEOUT = 35;
82 void RoadVehUpdateCache(RoadVehicle *v, bool same_length = false);
83 void GetRoadVehSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type);
88 struct RoadVehicle FINAL : public GroundVehicle<RoadVehicle, VEH_ROAD> {
89  byte state;
90  byte frame;
91  uint16 blocked_ctr;
92  byte overtaking;
94  uint16 crashed_ctr;
95  byte reverse_ctr;
97  RoadType roadtype;
98  RoadTypes compatible_roadtypes;
103  virtual ~RoadVehicle() { this->PreDestructor(); }
105  friend struct GroundVehicle<RoadVehicle, VEH_ROAD>; // GroundVehicle needs to use the acceleration functions defined at RoadVehicle.
107  void MarkDirty();
109  ExpensesType GetExpenseType(bool income) const { return income ? EXPENSES_ROADVEH_INC : EXPENSES_ROADVEH_RUN; }
110  bool IsPrimaryVehicle() const { return this->IsFrontEngine(); }
111  void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const;
112  int GetDisplaySpeed() const { return this->gcache.last_speed / 2; }
113  int GetDisplayMaxSpeed() const { return this->vcache.cached_max_speed / 2; }
114  Money GetRunningCost() const;
115  int GetDisplayImageWidth(Point *offset = NULL) const;
116  bool IsInDepot() const { return this->state == RVSB_IN_DEPOT; }
117  bool Tick();
118  void OnNewDay();
119  uint Crash(bool flooded = false);
121  TileIndex GetOrderStationLocation(StationID station);
122  bool FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse);
124  bool IsBus() const;
126  int GetCurrentMaxSpeed() const;
127  int UpdateSpeed();
129 protected: // These functions should not be called outside acceleration code.
135  inline uint16 GetPower() const
136  {
137  /* Power is not added for articulated parts */
138  if (!this->IsArticulatedPart()) {
139  /* Road vehicle power is in units of 10 HP. */
140  return 10 * GetVehicleProperty(this, PROP_ROADVEH_POWER, RoadVehInfo(this->engine_type)->power);
141  }
142  return 0;
143  }
149  inline uint16 GetPoweredPartPower(const RoadVehicle *head) const
150  {
151  return 0;
152  }
158  inline uint16 GetWeight() const
159  {
160  uint16 weight = (CargoSpec::Get(this->cargo_type)->weight * this->cargo.StoredCount()) / 16;
162  /* Vehicle weight is not added for articulated parts. */
163  if (!this->IsArticulatedPart()) {
164  /* Road vehicle weight is in units of 1/4 t. */
165  weight += GetVehicleProperty(this, PROP_ROADVEH_WEIGHT, RoadVehInfo(this->engine_type)->weight) / 4;
166  }
168  return weight;
169  }
175  inline byte GetTractiveEffort() const
176  {
177  /* The tractive effort coefficient is in units of 1/256. */
178  return GetVehicleProperty(this, PROP_ROADVEH_TRACTIVE_EFFORT, RoadVehInfo(this->engine_type)->tractive_effort);
179  }
185  inline byte GetAirDragArea() const
186  {
187  return 6;
188  }
194  inline byte GetAirDrag() const
195  {
196  return RoadVehInfo(this->engine_type)->air_drag;
197  }
204  {
205  return (this->vehstatus & VS_STOPPED) ? AS_BRAKE : AS_ACCEL;
206  }
212  inline uint16 GetCurrentSpeed() const
213  {
214  return this->cur_speed / 2;
215  }
221  inline uint32 GetRollingFriction() const
222  {
223  /* Trams have a slightly greater friction coefficient than trains.
224  * The rest of road vehicles have bigger values. */
225  uint32 coeff = (this->roadtype == ROADTYPE_TRAM) ? 40 : 75;
226  /* The friction coefficient increases with speed in a way that
227  * it doubles at 128 km/h, triples at 256 km/h and so on. */
228  return coeff * (128 + this->GetCurrentSpeed()) / 128;
229  }
235  inline int GetAccelerationType() const
236  {
237  return 0;
238  }
244  inline uint32 GetSlopeSteepness() const
245  {
247  }
253  inline uint16 GetMaxTrackSpeed() const
254  {
255  return 0;
256  }
262  inline bool TileMayHaveSlopedTrack() const
263  {
264  TrackStatus ts = GetTileTrackStatus(this->tile, TRANSPORT_ROAD, this->compatible_roadtypes);
265  TrackBits trackbits = TrackStatusToTrackBits(ts);
267  return trackbits == TRACK_BIT_X || trackbits == TRACK_BIT_Y;
268  }
278  {
279  const RoadVehicle *rv = this->First();
281  /* Check if this vehicle is in the same direction as the road under.
282  * We already know it has either GVF_GOINGUP_BIT or GVF_GOINGDOWN_BIT set. */
285  /* If the first vehicle is reversing, this vehicle may be reversing too
286  * (especially if this is the first, and maybe the only, vehicle).*/
287  return true;
288  }
290  while (rv != this) {
291  /* If any previous vehicle has different direction,
292  * we may be in the middle of reversing. */
293  if (this->direction != rv->direction) return true;
294  rv = rv->Next();
295  }
297  return false;
298  }
299 };
301 #define FOR_ALL_ROADVEHICLES(var) FOR_ALL_VEHICLES_OF_TYPE(RoadVehicle, var)
303 #endif /* ROADVEH_H */
VehicleSettings vehicle
options for vehicles
Vehicle is stopped by the player.
Definition: vehicle_base.h:33
VehicleCargoList cargo
The cargo this vehicle is carrying.
Definition: vehicle_base.h:309
byte state
Definition: roadveh.h:89
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:77
Enums and other types related to roads.
Functions for NewGRF engines.
bool Tick()
Calls the tick handler of the vehicle.
uint8 weight
Weight of a single unit of this cargo type in 1/16 ton (62.5 kg).
Definition: cargotype.h:61
What is the status of our acceleration?
static const uint RDE_TURNED
We just finished turning.
Definition: roadveh.h:63
DirectionByte direction
Definition: vehicle_base.h:271
static bool IsReversingRoadTrackdir(Trackdir dir)
Checks whether the trackdir means that we are reversing.
Definition: track_func.h:661
uint16 GetPower() const
Allows to know the power value that this vehicle will use.
Definition: roadveh.h:135
The vehicle is at the opposite side of the road.
Definition: roadveh.h:55
int GetCurrentMaxSpeed() const
Calculates the maximum speed of the vehicle under its current conditions.
Used for iterations.
Definition: track_type.h:92
The vehicle is in a drive-through road stop.
Definition: roadveh.h:47
AccelStatus GetAccelerationStatus() const
Checks the current acceleration status of this vehicle.
Definition: roadveh.h:203
uint16 cur_speed
current speed
Definition: vehicle_base.h:293
int GetDisplayMaxSpeed() const
Gets the maximum speed in km-ish/h that can be sent into SetDParam for string processing.
Definition: roadveh.h:113
bool TileMayHaveSlopedTrack() const
Checks if the vehicle is at a tile that can be sloped.
Definition: roadveh.h:262
We don&#39;t want GCC to zero our struct! It already is zeroed and has an index!
Definition: roadveh.h:101
static const uint RDE_NEXT_TILE
State information about the Road Vehicle controller.
Definition: roadveh.h:62
Only used when retrieving move data.
Definition: roadveh.h:45
ExpensesType GetExpenseType(bool income) const
Sets the expense type associated to this vehicle type.
Definition: roadveh.h:109
void PreDestructor()
Destroy all stuff that (still) needs the virtual functions to work properly.
Definition: vehicle.cpp:802
uint32 GetSlopeSteepness() const
Returns the slope steepness used by this vehicle.
Definition: roadveh.h:244
RoadVehicle * First() const
Get the first vehicle in the chain.
The different roadtypes we support.
Definition: road_type.h:22
uint16 GetMaxTrackSpeed() const
Gets the maximum speed allowed by the track for this vehicle.
Definition: roadveh.h:253
byte vehstatus
Definition: vehicle_base.h:317
Visualisation contexts of vehicles and engines.
Definition: vehicle_type.h:87
uint StoredCount() const
Returns sum of cargo on board the vehicle (ie not only reserved).
Definition: cargopacket.h:366
byte overtaking
Set to RVSB_DRIVE_SIDE when overtaking, otherwise 0.
Definition: roadveh.h:92
uint16 cached_max_speed
Maximum speed of the consist (minimum of the max speed of all vehicles in the consist).
Definition: vehicle_base.h:123
Defines the 8 directions on the map.
Road vehicle states.
Definition: roadveh.h:25
Bitfield corresponding to Track.
Definition: track_type.h:41
Buses, trucks and trams belong to this class.
Definition: roadveh.h:88
The vehicle is in a road stop.
Definition: roadveh.h:46
int UpdateSpeed()
This function looks at the vehicle and updates its speed (cur_speed and subspeed) variables...
Income from road vehicles.
Definition: economy_type.h:159
X-axis track.
Definition: track_type.h:43
void OnNewDay()
Calls the new day handler of the vehicle.
We want to stop.
The vehicle is in a tunnel and/or bridge.
Definition: roadveh.h:40
T * Next() const
Get next vehicle in the chain.
Weight in 1/4 t.
byte GetAirDragArea() const
Gets the area used for calculating air drag.
Definition: roadveh.h:185
Trackdir GetVehicleTrackdir() const
Returns the Trackdir on which the vehicle is currently located.
bool IsArticulatedPart() const
Check if the vehicle is an articulated part of an engine.
Definition: vehicle_base.h:891
Definition: road_type.h:25
Enumeration for tracks and directions.
Definition: track_type.h:74
Only used while in a road stop.
Definition: roadveh.h:43
The vehicle is in a depot.
Definition: roadveh.h:39
CargoID cargo_type
type of cargo this vehicle is carrying
Definition: vehicle_base.h:305
bool IsFrontEngine() const
Check if the vehicle is a front engine.
Definition: vehicle_base.h:882
TileIndex tile
Current tile index.
Definition: vehicle_base.h:230
Types of expenses.
Definition: economy_type.h:150
Power in 10 HP.
bool HasToUseGetSlopePixelZ()
Road vehicles have to use GetSlopePixelZ() to compute their height if they are reversing because in t...
Definition: roadveh.h:277
uint16 GetPoweredPartPower(const RoadVehicle *head) const
Returns a value if this articulated part is powered.
Definition: roadveh.h:149
virtual ~RoadVehicle()
We want to &#39;destruct&#39; the right class.
Definition: roadveh.h:103
Sprite sequence for a vehicle part.
Definition: vehicle_base.h:130
uint Crash(bool flooded=false)
Crash the (whole) vehicle chain.
byte GetTractiveEffort() const
Allows to know the tractive effort value that this vehicle will use.
Definition: roadveh.h:175
bool FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse)
Find the closest depot for this vehicle and tell us the location, DestinationID and whether we should...
We want to go faster, if possible of course.
int GetDisplayImageWidth(Point *offset=NULL) const
Get the width of a road vehicle image in the GUI.
Definition: roadveh_cmd.cpp:91
uint16 crashed_ctr
Animation counter when the vehicle has crashed.
Definition: roadveh.h:94
The different roadtypes we support, but then a bitmask of them.
Definition: road_type.h:36
byte GetAirDrag() const
Gets the air drag coefficient of this vehicle.
Definition: roadveh.h:194
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition: landscape.cpp:509
bool IsInDepot() const
Check whether the vehicle is in the depot.
Definition: roadveh.h:116
void MarkDirty()
Marks the vehicles to be redrawn and updates cached variables.
uint16 last_speed
The last speed we did display, so we only have to redraw when this changes.
static const byte RV_OVERTAKE_TIMEOUT
The number of ticks a vehicle has for overtaking.
Definition: roadveh.h:80
The vehicle is in a drive-through road stop.
Definition: roadveh.h:52
bool IsBus() const
Check whether a roadvehicle is a bus.
Definition: roadveh_cmd.cpp:80
Base class for engines.
Running costs road vehicles.
Definition: economy_type.h:154
int GetAccelerationType() const
Allows to know the acceleration type of a vehicle.
Definition: roadveh.h:235
Only bits 0 and 3 are used to encode the trackdir for road stops.
Definition: roadveh.h:58
void RoadVehUpdateCache(RoadVehicle *v, bool same_length=false)
Update the cache of a road vehicle.
uint32 GetRollingFriction() const
Returns the rolling friction coefficient of this vehicle.
Definition: roadveh.h:221
uint16 EngineID
Unique identification number of an engine.
Definition: engine_type.h:22
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo ID.
Definition: cargotype.h:118
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:80
Only set when a vehicle has entered the stop.
Definition: roadveh.h:44
Money GetRunningCost() const
Gets the running cost of a vehicle.
static TrackBits TrackStatusToTrackBits(TrackStatus ts)
Returns the present-track-information of a TrackStatus.
Definition: track_func.h:351
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).
TileIndex GetOrderStationLocation(StationID station)
Determine the location for the station where the vehicle goes to next.
Transport by road vehicle.
The vehicle is in a road stop.
Definition: roadveh.h:50
Types/functions related to cargoes.
Coordinates of a point in 2D.
The mask used to extract track dirs.
Definition: roadveh.h:57
Tractive effort coefficient in 1/256.
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:288
void UpdateDeltaXY(Direction direction)
Updates the x and y offsets and the size of the sprite used for this vehicle.
uint8 roadveh_slope_steepness
Steepness of hills for road vehicles when using realistic acceleration.
bool IsPrimaryVehicle() const
Whether this is the primary vehicle in the chain.
Definition: roadveh.h:110
Different conversion functions from one kind of track to another.
int GetDisplaySpeed() const
Gets the speed in km-ish/h that can be sent into SetDParam for string processing. ...
Definition: roadveh.h:112
Base class for all vehicles that move through ground.
VehicleCache vcache
Cache of often used vehicle values.
Definition: vehicle_base.h:330
Base class and functions for all vehicles that move through ground.
void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const
Gets the sprite to show for the given direction.
Y-axis track.
Definition: track_type.h:44
GroundVehicleCache gcache
Cache of often calculated values.
byte overtaking_ctr
The length of the current overtake attempt.
Definition: roadveh.h:93
uint16 GetCurrentSpeed() const
Calculates the current speed of this vehicle.
Definition: roadveh.h:212
uint16 GetWeight() const
Allows to know the weight value that this vehicle will use.
Definition: roadveh.h:158