OpenTTD Source
1.11.0-beta2
|
Go to the documentation of this file.
38 #include "table/strings.h"
42 static const uint16 _roadveh_images[] = {
43 0xCD4, 0xCDC, 0xCE4, 0xCEC, 0xCF4, 0xCFC, 0xD0C, 0xD14,
44 0xD24, 0xD1C, 0xD2C, 0xD04, 0xD1C, 0xD24, 0xD6C, 0xD74,
45 0xD7C, 0xC14, 0xC1C, 0xC24, 0xC2C, 0xC34, 0xC3C, 0xC4C,
46 0xC54, 0xC64, 0xC5C, 0xC6C, 0xC44, 0xC5C, 0xC64, 0xCAC,
47 0xCB4, 0xCBC, 0xD94, 0xD9C, 0xDA4, 0xDAC, 0xDB4, 0xDBC,
48 0xDCC, 0xDD4, 0xDE4, 0xDDC, 0xDEC, 0xDC4, 0xDDC, 0xDE4,
49 0xE2C, 0xE34, 0xE3C, 0xC14, 0xC1C, 0xC2C, 0xC3C, 0xC4C,
50 0xC5C, 0xC64, 0xC6C, 0xC74, 0xC84, 0xC94, 0xCA4
53 static const uint16 _roadveh_full_adder[] = {
54 0, 88, 0, 0, 0, 0, 48, 48,
55 48, 48, 0, 0, 64, 64, 0, 16,
56 16, 0, 88, 0, 0, 0, 0, 48,
57 48, 48, 48, 0, 0, 64, 64, 0,
58 16, 16, 0, 88, 0, 0, 0, 0,
59 48, 48, 48, 48, 0, 0, 64, 64,
60 0, 16, 16, 0, 8, 8, 8, 8,
66 bool IsValidImageIndex<VEH_ROAD>(uint8 image_index)
68 return image_index <
lengthof(_roadveh_images);
92 int reference_width = ROADVEHINFO_DEFAULT_VEHICLE_WIDTH;
94 if (offset !=
nullptr) {
107 GetCustomVehicleIcon(engine,
DIR_W, image_type, result);
113 assert(IsValidImageIndex<VEH_ROAD>(
spritenum));
128 assert(IsValidImageIndex<VEH_ROAD>(
spritenum));
148 GetRoadVehIcon(engine, image_type, &seq);
152 preferred_x =
Clamp(preferred_x,
171 GetRoadVehIcon(engine, image_type, &seq);
176 width =
UnScaleGUI(rect.right - rect.left + 1);
177 height =
UnScaleGUI(rect.bottom - rect.top + 1);
193 if (e->
GetGRF() !=
nullptr && e->
GetGRF()->grf_version >= 8) {
226 assert(u->First() == v);
236 u->gcache.cached_veh_length = veh_len;
240 u->UpdateVisualEffect();
279 v->
z_pos = GetSlopePixelZ(x, y);
297 _new_vehicle_id = v->
index;
320 u->cargo_cap = u->GetEngine()->DetermineCapacity(u);
323 u->InvalidateNewGRFCache();
345 default: NOT_REACHED();
354 if (location !=
nullptr) *location = rfdd.
tile;
377 if (ret.
Failed())
return ret;
393 if (flags &
DC_EXEC) v->reverse_ctr = 180;
410 static const int8 _delta_xy_table[8][10] = {
412 {3, 3, -1, -1, 0, 0, -1, -1, -1, -1},
413 {3, 7, -1, -3, 0, -1, 0, -1, 0, 0},
414 {3, 3, -1, -1, 0, 0, 1, -1, 1, -1},
415 {7, 3, -3, -1, -1, 0, 0, 0, 1, 0},
416 {3, 3, -1, -1, 0, 0, 1, 1, 1, 1},
417 {3, 7, -1, -3, 0, -1, 0, 0, 0, 1},
418 {3, 3, -1, -1, 0, 0, -1, 1, -1, 1},
419 {7, 3, -3, -1, -1, 0, -1, 0, 0, 0},
425 const int8 *bb = _delta_xy_table[this->
direction];
426 this->
x_bb_offs = bb[5] + bb[9] * shorten;
427 this->
y_bb_offs = bb[4] + bb[8] * shorten;;
430 this->
x_extent = bb[1] + bb[7] * shorten;
431 this->
y_extent = bb[0] + bb[6] * shorten;
449 }
else if ((u->direction & 1) == 0) {
471 for (; v->
Next() !=
nullptr; v = v->
Next()) u = v;
481 static void RoadVehSetRandomDirection(
RoadVehicle *v)
483 static const DirDiff delta[] = {
492 }
while ((v = v->
Next()) !=
nullptr);
506 if ((v->
tick_counter & 7) == 0) RoadVehSetRandomDirection(v);
508 bool ret = v->
Next() !=
nullptr;
549 uint pass = v->
Crash();
552 Game::NewEvent(
new ScriptEventVehicleCrashed(v->
index, v->
tile, ScriptEventVehicleCrashed::CRASH_RV_LEVEL_CROSSING));
555 StringID newsitem = (pass == 1) ? STR_NEWS_ROAD_VEHICLE_CRASH_DRIVER : STR_NEWS_ROAD_VEHICLE_CRASH;
558 ModifyStationRatingAround(v->
tile, v->
owner, -160, 22);
594 static void StartRoadVehSound(
const RoadVehicle *v)
601 SndPlayVehicleFx(s, v);
616 static const int8 dist_x[] = { -4, -8, -4, -1, 4, 8, 4, 1 };
617 static const int8 dist_y[] = { -4, -1, 4, 8, 4, 1, -4, -8 };
621 short x_diff = v->
x_pos - rvf->x;
622 short y_diff = v->
y_pos - rvf->y;
633 uint diff =
abs(x_diff) +
abs(y_diff);
635 if (diff < rvf->best_diff || (diff == rvf->best_diff && v->
index < rvf->best->
index)) {
637 rvf->best_diff = diff;
649 if (front->reverse_ctr != 0)
return nullptr;
655 rvf.best_diff = UINT_MAX;
668 if (rvf.best_diff == UINT_MAX) {
669 front->blocked_ctr = 0;
673 if (update_blocked_ctr && ++front->blocked_ctr > 1480)
return nullptr;
687 if (!(st->had_vehicle_of_type &
HVOT_BUS)) {
688 st->had_vehicle_of_type |=
HVOT_BUS;
691 RoadTypeIsRoad(v->
roadtype) ? STR_NEWS_FIRST_BUS_ARRIVAL : STR_NEWS_FIRST_PASSENGER_TRAM_ARRIVAL,
701 if (!(st->had_vehicle_of_type &
HVOT_TRUCK)) {
705 RoadTypeIsRoad(v->
roadtype) ? STR_NEWS_FIRST_TRUCK_ARRIVAL : STR_NEWS_FIRST_CARGO_TRAM_ARRIVAL,
726 default: NOT_REACHED();
737 static const Direction _roadveh_new_dir[] = {
743 x = x - v->
x_pos + 1;
744 y = y - v->
y_pos + 1;
746 if ((uint)x > 2 || (uint)y > 2)
return v->
direction;
747 return _roadveh_new_dir[y * 4 + x];
752 Direction new_dir = RoadVehGetNewDirection(v, x, y);
756 if (new_dir == old_dir)
return old_dir;
768 static Vehicle *EnumFindVehBlockingOvertake(
Vehicle *v,
void *data)
772 return (v->
type ==
VEH_ROAD && v->
First() == v && v != od->u && v != od->v) ? v :
nullptr;
804 if (RoadTypeIsTram(v->
roadtype))
return;
848 static void RoadZPosAffectSpeed(
RoadVehicle *v,
int old_z)
852 if (old_z < v->z_pos) {
856 if (spd <= v->gcache.cached_max_track_speed) v->
cur_speed = spd;
860 static int PickRandomBit(uint bits)
865 for (i = 0; !(bits & 1) || (
int)--num >= 0; bits >>= 1, i++) {}
879 #define return_track(x) { best_track = (Trackdir)x; goto found_best_track; }
883 bool path_found =
true;
926 if (!v->
path.empty()) v->
path.clear();
928 return_track(_road_reverse_table[enterdir]);
931 if (v->reverse_ctr != 0) {
938 reverse = ((rb & straight) == straight) ||
943 if (v->
tile != tile) {
944 return_track(_road_reverse_table[enterdir]);
952 return_track(PickRandomBit(trackdirs));
957 if (!v->
path.empty() && v->
path.tile.front() == tile) {
965 if (!v->
path.empty()) {
966 if (v->
path.tile.front() != tile) {
972 if (
HasBit(trackdirs, trackdir)) {
973 v->
path.td.pop_front();
974 v->
path.tile.pop_front();
975 return_track(trackdir);
987 default: NOT_REACHED();
1004 static bool RoadVehLeaveDepot(
RoadVehicle *v,
bool first)
1027 if (RoadVehFindCloseTo(v, x, y, v->
direction,
false) !=
nullptr)
return true;
1031 StartRoadVehSound(v);
1039 v->frame = RVC_DEPOT_START_FRAME;
1053 if (prev->
tile == v->
tile && !already_reversed) {
1056 return _road_reverse_table[entry_dir];
1059 byte prev_state = prev->
state;
1074 if (already_reversed && prev->
tile != tile) {
1104 static const RoadBits required_roadbits[] = {
1108 RoadBits required = required_roadbits[dir & 0x07];
1204 dir = FollowPreviousRoadVehicle(v, prev, tile, (
DiagDirection)(rd.x & 3),
false);
1214 uint start_frame = RVC_DEFAULT_START_FRAME;
1225 default: NOT_REACHED();
1258 start_frame = RVC_TURN_AROUND_START_FRAME_SHORT_TRAM;
1278 Direction new_dir = RoadVehGetSlidingDirection(v, x, y);
1280 Vehicle *u = RoadVehFindCloseTo(v, x, y, new_dir);
1294 dir = _road_reverse_table[rd.x & 3];
1328 v->
state = (byte)dir;
1329 v->frame = start_frame;
1330 RoadTramType rtt = GetRoadTramType(v->
roadtype);
1331 if (GetRoadType(old_tile, rtt) != GetRoadType(tile, rtt)) {
1352 uint turn_around_start_frame = RVC_TURN_AROUND_START_FRAME;
1364 turn_around_start_frame = RVC_START_FRAME_AFTER_LONG_TRAM;
1365 switch (rd.x & 0x3) {
1366 default: NOT_REACHED();
1377 dir = FollowPreviousRoadVehicle(v, prev, v->
tile, (
DiagDirection)(rd.x & 3),
true);
1391 Direction new_dir = RoadVehGetSlidingDirection(v, x, y);
1392 if (v->
IsFrontEngine() && RoadVehFindCloseTo(v, x, y, new_dir) !=
nullptr) {
1395 if (!v->
path.empty()) {
1398 v->
path.td.push_front(dir);
1410 v->frame = turn_around_start_frame;
1429 RoadVehLeaveDepot(v->
Next(),
false);
1434 int x = (v->
x_pos & ~15) + (rd.x & 15);
1435 int y = (v->
y_pos & ~15) + (rd.y & 15);
1437 Direction new_dir = RoadVehGetSlidingDirection(v, x, y);
1442 RoadVehicle *u = RoadVehFindCloseTo(v, x, y, new_dir);
1447 if (v->
overtaking == 0) RoadVehCheckOvertake(v, u);
1465 if (new_dir != old_dir) {
1488 v->frame == RVC_DRIVE_THROUGH_STOP_FRAME))) {
1535 StartRoadVehSound(v);
1565 if (v->reverse_ctr != 0) v->reverse_ctr--;
1581 if (v->
IsInDepot() && RoadVehLeaveDepot(v,
true))
return true;
1589 bool blocked =
false;
1590 while (j >= adv_spd) {
1594 for (
RoadVehicle *prev =
nullptr; u !=
nullptr; prev = u, u = u->
Next()) {
1595 if (!IndividualRoadVehicleController(u, prev)) {
1606 if (j >= adv_spd && RoadVehCheckTrainCrash(v))
break;
1612 if ((u->vehstatus &
VS_HIDDEN) != 0)
continue;
1614 u->UpdateViewport(
false,
false);
1628 if (e->u.road.running_cost_class == INVALID_PRICE)
return 0;
1631 if (cost_factor == 0)
return 0;
1633 return GetPrice(e->u.road.running_cost_class, cost_factor, e->
GetGRF());
1644 return RoadVehController(
this);
1650 void RoadVehicle::SetDestTile(
TileIndex tile)
1657 static void CheckIfRoadVehNeedsService(
RoadVehicle *v)
1670 default: NOT_REACHED();
1696 v->SetDestTile(rfdd.
tile);
1707 if (this->blocked_ctr == 0) CheckVehicleBreakdown(
this);
1709 CheckIfRoadVehNeedsService(
this);
byte overtaking
Set to RVSB_DRIVE_SIDE when overtaking, otherwise 0.
@ VSE_START
Vehicle starting, i.e. leaving, the station.
Buses, trucks and trams belong to this class.
@ TRACKDIR_RVREV_SW
(Road vehicle) reverse direction south-west
static const EngineID INVALID_ENGINE
Constant denoting an invalid engine.
bool PlayVehicleSound(const Vehicle *v, VehicleSoundEvent event)
Checks whether a NewGRF wants to play a different vehicle sound effect.
@ WC_ROADVEH_LIST
Road vehicle list; Window numbers:
uint32 GetGRFID() const
Retrieve the GRF ID of the NewGRF the engine is tied to.
static DiagDirection GetRoadDepotDirection(TileIndex t)
Get the direction of the exit of a road depot.
uint32 TileIndex
The index/ID of a Tile.
uint StoredCount() const
Returns sum of cargo on board the vehicle (ie not only reserved).
NPFSettings npf
pathfinder settings for the new pathfinder
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
void MakeDummy()
Makes this order a Dummy order.
@ EXPENSES_ROADVEH_RUN
Running costs road vehicles.
@ DIRDIFF_REVERSE
One direction is the opposite of the other one.
static bool HasTileAnyRoadType(TileIndex t, RoadTypes rts)
Check if a tile has one of the specified road types.
static bool Chance16(const uint a, const uint b)
Flips a coin with given probability.
CommandCost DoCommand(const CommandContainer *container, DoCommandFlag flags)
Shorthand for calling the long DoCommand with a container.
uint8 pathfinder_for_roadvehs
the pathfinder to use for roadvehicles
bool IsType(OrderType type) const
Check whether this order is of the given type.
static Titem * Get(size_t index)
Returns Titem with given index.
static TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Direction
Defines the 8 directions on the map.
static bool IsRoadStop(TileIndex t)
Is the station at t a road station?
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
VehicleSpriteSeq sprite_seq
Vehicle appearance.
@ TRACKDIR_LOWER_E
Lower track and direction to east.
Money GetPrice(Price index, uint cost_factor, const GRFFile *grf_file, int shift)
Determine a certain price.
@ NT_ARRIVAL_OTHER
First vehicle arrived for competitor.
@ DIRDIFF_45LEFT
Angle of 45 degrees left.
static Direction ChangeDir(Direction d, DirDiff delta)
Change a direction by a given difference.
static BridgeType GetBridgeType(TileIndex t)
Determines the type of bridge on a tile.
int GetAcceleration() const
Calculates the acceleration of the vehicle under its current conditions.
Helper container to find a depot.
AccelStatus GetAccelerationStatus() const
Checks the current acceleration status of this vehicle.
TrackdirBits
Enumeration of bitmasks for the TrackDirs.
@ ODTFB_SERVICE
This depot order is because of the servicing limit.
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
bool IsEntranceBusy() const
Checks whether the entrance of the road stop is occupied by a vehicle.
bool IsPrimaryVehicle() const
Whether this is the primary vehicle in the chain.
@ TRACKDIR_RIGHT_S
Right track and direction to south.
bool HasVehicleOnPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
Checks whether a vehicle is on a specific location.
void CheckOrders(const Vehicle *v)
Check the orders of a vehicle, to see if there are invalid orders and stuff.
@ GVF_SUPPRESS_IMPLICIT_ORDERS
Disable insertion and removal of automatic orders until the vehicle completes the real order.
uint16 reliability_spd_dec
Speed of reliability decay between services (per day).
Class to backup a specific variable and restore it later.
EngineID first_engine
Cached EngineID of the front vehicle. INVALID_ENGINE for the front vehicle itself.
Year _cur_year
Current year, starting at 0.
T * Next() const
Get next vehicle in the chain.
void CheckConsistencyOfArticulatedVehicle(const Vehicle *v)
Checks whether the specs of freshly build articulated vehicles are consistent with the information sp...
@ DIRDIFF_SAME
Both directions faces to the same direction.
byte y_extent
y-extent of vehicle bounding box
DestinationID GetDestination() const
Gets the destination of this order.
bool NeedsAutomaticServicing() const
Checks if the current order should be interrupted for a service-in-depot order.
int UpdateSpeed()
This function looks at the vehicle and updates its speed (cur_speed and subspeed) variables.
void Set(SpriteID sprite)
Assign a single sprite to the sequence.
static const uint RDE_NEXT_TILE
State information about the Road Vehicle controller.
static Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
@ ROAD_SW
South-west part.
static bool IsDiagonalDirection(Direction dir)
Checks if a given Direction is diagonal.
static bool IsRoadDepotTile(TileIndex t)
Return whether a tile is a road depot tile.
static TileIndex TileAddByDir(TileIndex tile, Direction dir)
Adds a Direction to a tile.
byte random_bits
Bits used for determining which randomized variational spritegroups to use when drawing.
@ DIAGDIR_END
Used for iterations.
void OnNewDay()
Calls the new day handler of the vehicle.
@ VPF_YAPF
Yet Another PathFinder.
@ VS_DEFPAL
Use default vehicle palette.
uint16 DepotID
Type for the unique identifier of depots.
Tindex index
Index of this pool item.
void SetNext(Vehicle *next)
Set the next vehicle of this vehicle.
@ PROP_ROADVEH_SHORTEN_FACTOR
Shorter vehicles.
@ RVSB_IN_ROAD_STOP
The vehicle is in a road stop.
void RoadVehUpdateCache(RoadVehicle *v, bool same_length)
Update the cache of a road vehicle.
void AddArticulatedParts(Vehicle *first)
Add the remaining articulated parts to the given vehicle.
@ PFE_GL_ROADVEHS
Time spend processing road vehicles.
RoadVehPathCache path
Cached path.
void Free()
'Free' the order
static T KillFirstBit(T value)
Clear the first bit in an integer.
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
static int UnScaleGUI(int value)
Short-hand to apply GUI zoom level.
Money GetRunningCost() const
Gets the running cost of a vehicle.
@ TRACKDIR_LOWER_W
Lower track and direction to west.
@ SND_12_EXPLOSION
16 == 0x10 Destruction, crashes, disasters, ...
static Trackdir DiagDirToDiagTrackdir(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal trackdir that runs in that direction.
@ ROAD_X
Full road along the x-axis (south-west + north-east)
static RoadStopType GetRoadStopType(TileIndex t)
Get the road stop type of this tile.
byte overtaking_ctr
The length of the current overtake attempt.
static bool IsStandardRoadStopTile(TileIndex t)
Is tile t a standard (non-drive through) road stop station?
static RoadStop * GetByTile(TileIndex tile, RoadStopType type)
Find a roadstop at given tile.
@ TRACKDIR_RVREV_NW
(Road vehicle) reverse direction north-west
static bool IsDriveThroughStopTile(TileIndex t)
Is tile t a drive through road stop station?
static const uint TILE_SIZE
Tile size in world coordinates.
static void AddVehicleNewsItem(StringID string, NewsType type, VehicleID vehicle, StationID station=INVALID_STATION)
Adds a newsitem referencing a vehicle.
byte running_ticks
Number of ticks this vehicle was not stopped this day.
@ SND_19_DEPARTURE_OLD_RV_1
23 == 0x17 Station departure: truck and old bus (1) (non-toyland)
static Station * Get(size_t index)
Gets station with given index.
static DirDiff DirDifference(Direction d0, Direction d1)
Calculate the difference between two directions.
ClientSettings _settings_client
The current settings for this game.
void VehicleEnterDepot(Vehicle *v)
Vehicle entirely entered the depot, update its status, orders, vehicle windows, service it,...
@ DC_NO_WATER
don't allow building on water
void VehicleLengthChanged(const Vehicle *u)
Logs a bug in GRF and shows a warning message if this is for the first time this happened.
static const uint RDE_TURNED
We just finished turning.
static uint TileY(TileIndex tile)
Get the Y component of a tile.
int GetCurrentMaxSpeed() const
Calculates the maximum speed of the vehicle under its current conditions.
Date GetLifeLengthInDays() const
Returns the vehicle's (not model's!) life length in days.
static uint32 RandomRange(uint32 limit)
Pick a random number between 0 and limit - 1, inclusive.
RoadType roadtype
Roadtype of this vehicle.
byte road_side
the side of the road vehicles drive on
EngineImageType
Visualisation contexts of vehicles and engines.
@ TRACKDIR_UPPER_E
Upper track and direction to east.
@ VEH_ROAD
Road vehicle type.
@ CC_PASSENGERS
Passengers.
TileIndex GetOrderStationLocation(StationID station)
Determine the location for the station where the vehicle goes to next.
uint16 cur_speed
current speed
static void DeleteLastRoadVeh(RoadVehicle *v)
Delete last vehicle of a chain road vehicles.
CargoID GetDefaultCargoType() const
Determines the default cargo type of an engine.
void Draw(int x, int y, PaletteID default_pal, bool force_pal) const
Draw the sprite sequence.
RoadType roadtype
Road type.
Owner owner
Which company owns the vehicle?
Owner
Enum for all companies/owners.
uint16 speed
maximum travel speed (1 unit = 1/1.6 mph = 1 km-ish/h)
@ EV_EXPLOSION_LARGE
Various explosions.
uint16 GetVehicleCallback(CallbackID callback, uint32 param1, uint32 param2, EngineID engine, const Vehicle *v)
Evaluate a newgrf callback for vehicles.
virtual bool IsInDepot() const
Check whether the vehicle is in the depot.
@ DC_EXEC
execute the given command
@ TRACKDIR_RVREV_SE
(Road vehicle) reverse direction south-east
@ MP_ROAD
A tile with road (or tram tracks)
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
DoCommandFlag
List of flags for a command.
void VehicleServiceInDepot(Vehicle *v)
Service a vehicle and all subsequent vehicles in the consist.
@ RVSB_IN_DT_ROAD_STOP
The vehicle is in a drive-through road stop.
static Vehicle * EnumCheckRoadVehCrashTrain(Vehicle *v, void *data)
Check routine whether a road and a train vehicle have collided.
bool Succeeded() const
Did this command succeed?
static uint TileX(TileIndex tile)
Get the X component of a tile.
static RoadBits DiagDirToRoadBits(DiagDirection d)
Create the road-part which belongs to the given DiagDirection.
static uint CountBits(T value)
Counts the number of set bits in a variable.
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
void MakeGoToDepot(DepotID destination, OrderDepotTypeFlags order, OrderNonStopFlags non_stop_type=ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS, OrderDepotActionFlags action=ODATF_SERVICE_ONLY, CargoID cargo=CT_NO_REFIT)
Makes this order a Go To Depot order.
@ ROADSTOP_BUS
A standard stop for buses.
static bool IsInsideMM(const T x, const size_t min, const size_t max)
Checks if a value is in an interval.
uint16 GetMaxSpeed() const
Get the maxmimum speed in km-ish/h a vehicle is allowed to reach on the way to the destination.
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
static RoadBits AxisToRoadBits(Axis a)
Create the road-part which belongs to the given Axis.
@ TRACKDIR_LEFT_N
Left track and direction to north.
@ RVS_DRIVE_SIDE
Only used when retrieving move data.
@ TRACK_BIT_CROSS
X-Y-axis cross.
const GRFFile * GetGRF() const
Retrieve the NewGRF the engine is tied to.
@ TRANSPORT_ROAD
Transport by road vehicle.
RoadBits
Enumeration for the road parts on a tile.
void SetWindowWidgetDirty(WindowClass cls, WindowNumber number, byte widget_index)
Mark a particular widget in a particular window as dirty (in need of repainting)
@ ROAD_NONE
No road-part is build.
@ ENGINE_EXCLUSIVE_PREVIEW
This vehicle is in the exclusive preview stage, either being used or being offered to a company.
@ ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS
The vehicle will not stop at any stations it passes except the destination.
static const BridgeSpec * GetBridgeSpec(BridgeType i)
Get the specification of a bridge type.
static RoadBits GetRoadBits(TileIndex t, RoadTramType rtt)
Get the present road bits for a specific road type.
OrderNonStopFlags GetNonStopType() const
At which stations must we stop?
void BeginLoading()
Prepare everything to begin the loading when arriving at a station.
PathfinderSettings pf
settings for all pathfinders
@ PROP_ROADVEH_SPEED
Max. speed: 1 unit = 1/0.8 mph = 2 km-ish/h.
byte breakdown_ctr
Counter for managing breakdown events.
@ VS_HIDDEN
Vehicle is not visible.
uint16 EngineID
Unique identification number of an engine.
uint best_length
The distance towards the depot in penalty, or UINT_MAX if not found.
RoadTypes powered_roadtypes
bitmask to the OTHER roadtypes on which a vehicle of THIS roadtype generates power
CommandCost CheckOwnership(Owner owner, TileIndex tile)
Check whether the current owner owns something.
uint16 cached_total_length
Length of the whole vehicle (valid only for the first engine).
bool IsValid() const
Check whether the sequence contains any sprites.
TileIndex dest_tile
Heading for this tile.
static DiagDirection DirToDiagDir(Direction dir)
Convert a Direction to a DiagDirection.
void HandlePathfindingResult(bool path_found)
Handle the pathfinding result, especially the lost status.
#define return_cmd_error(errcode)
Returns from a function with a specific StringID as error.
static bool CheckRoadBlockedForOvertaking(OvertakeData *od)
Check if overtaking is possible on a piece of track.
static void NewEvent(CompanyID company, ScriptEvent *event)
Queue a new event for an AI.
const byte _road_stop_stop_frame[]
Table of road stop stop frames, when to stop at a road stop.
Common return value for all commands.
Date _date
Current date in days (day counter)
@ WC_VEHICLE_VIEW
Vehicle view; Window numbers:
SoundSettings sound
sound effect settings
@ CMD_BUILD_ROAD
build a "half" road
@ PROP_ROADVEH_CARGO_AGE_PERIOD
Number of ticks before carried cargo is aged.
RoadBits GetAnyRoadBits(TileIndex tile, RoadTramType rtt, bool straight_tunnel_bridge_entrance)
Returns the RoadBits on an arbitrary tile Special behaviour:
static bool HasExactlyOneBit(T value)
Test whether value has exactly 1 bit set.
@ DRD_NONE
None of the directions are disallowed.
void SubtractMoneyFromCompanyFract(CompanyID company, const CommandCost &cst)
Subtract money from a company, including the money fraction.
TileIndex tile
Current tile index.
EngineID engine_type
The type of engine used for this vehicle.
Information about a road vehicle.
uint8 cached_veh_length
Length of this vehicle in units of 1/VEHICLE_LENGTH of normal length. It is cached because this can b...
@ VS_CRASHED
Vehicle is crashed.
@ VETS_CANNOT_ENTER
The vehicle cannot enter the tile.
Sprite sequence for a vehicle part.
StationID last_station_visited
The last station we stopped at.
uint32 maximum_go_to_depot_penalty
What is the maximum penalty that may be endured for going to a depot.
VehicleCargoList cargo
The cargo this vehicle is carrying.
bool Failed() const
Did this command fail?
Order current_order
The current order (+ status, like: loading)
uint16 cached_max_track_speed
Maximum consist speed (in internal units) limited by track type (valid only for the first engine).
@ HVOT_TRUCK
Station has seen a truck.
bool IsChainInDepot() const override
Check whether the whole vehicle chain is in the depot.
static uint8 FindFirstBit2x64(const int value)
Finds the position of the first non-zero bit in an integer.
Trackdir YapfRoadVehicleChooseTrack(const RoadVehicle *v, TileIndex tile, DiagDirection enterdir, TrackdirBits trackdirs, bool &path_found, RoadVehPathCache &path_cache)
Finds the best path for given road vehicle using YAPF.
GroundVehicleCache gcache
Cache of often calculated values.
void SetFrontEngine()
Set front engine state.
@ RVSB_TRACKDIR_MASK
The mask used to extract track dirs.
bool IsFrontEngine() const
Check if the vehicle is a front engine.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
@ RVS_ENTERED_STOP
Only set when a vehicle has entered the stop.
FindDepotData NPFRoadVehicleFindNearestDepot(const RoadVehicle *v, int max_penalty)
Used when user sends road vehicle to the nearest depot or if road vehicle needs servicing using NPF.
@ WC_VEHICLE_DETAILS
Vehicle details; Window numbers:
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
@ VS_STOPPED
Vehicle is stopped by the player.
void ShowVisualEffect() const
Draw visual effects (smoke and/or sparks) for a vehicle chain.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
bool Tick()
Calls the tick handler of the vehicle.
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
@ ROAD_NE
North-east part.
VehicleEnterTileStatus VehicleEnterTile(Vehicle *v, TileIndex tile, int x, int y)
Call the tile callback function for a vehicle entering a tile.
@ ROAD_SE
South-east part.
void SetLastSpeed()
Update the GUI variant of the current speed of the vehicle.
TileIndex new_tile
Tile of the vehicle after moving.
uint16 reliability_spd_dec
Reliability decrease speed.
StationID last_loading_station
Last station the vehicle has stopped at and could possibly leave from with any cargo loaded.
static Direction DiagDirToDir(DiagDirection dir)
Convert a DiagDirection to a Direction.
Money GetCost() const
The costs as made up to this moment.
static DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
@ ROADSTOP_TRUCK
A standard stop for trucks.
Money profit_this_year
Profit this year << 8, low 8 bits are fract.
static bool IsTileOwner(TileIndex tile, Owner owner)
Checks if a tile belongs to the given owner.
@ RVSB_DRIVE_SIDE
The vehicle is at the opposite side of the road.
fluid_settings_t * settings
FluidSynth settings handle.
@ INVALID_DIAGDIR
Flag for an invalid DiagDirection.
FindDepotData YapfRoadVehicleFindNearestDepot(const RoadVehicle *v, int max_penalty)
Used when user sends road vehicle to the nearest depot or if road vehicle needs servicing using YAPF.
@ MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
RoadTypes compatible_roadtypes
Roadtypes this consist is powered on.
@ INVALID_TRACKDIR
Flag for an invalid trackdir.
bool disaster
Play disaster and accident sounds.
Coordinates of a point in 2D.
static bool RoadVehIsCrashed(RoadVehicle *v)
Road vehicle chain has crashed.
static bool CanBuildTramTrackOnTile(CompanyID c, TileIndex t, RoadType rt, RoadBits r)
Can a tram track build without destruction on the given tile?
static bool IsRoadDepot(TileIndex t)
Return whether a tile is a road depot.
DirDiff
Enumeration for the difference between two directions.
static DiagDirection GetRoadStopDir(TileIndex t)
Gets the direction the road stop entrance points towards.
DiagDirection
Enumeration for diagonal directions.
Trackdir NPFRoadVehicleChooseTrack(const RoadVehicle *v, TileIndex tile, DiagDirection enterdir, bool &path_found)
Finds the best path for given road vehicle using NPF.
void HandleLoading(bool mode=false)
Handle the loading of the vehicle; when not it skips through dummy orders and does nothing in all oth...
EffectVehicle * CreateEffectVehicleRel(const Vehicle *v, int x, int y, int z, EffectVehicleType type)
Create an effect vehicle above a particular vehicle.
static Trackdir RoadFindPathToDest(RoadVehicle *v, TileIndex tile, DiagDirection enterdir)
Returns direction to for a road vehicle to take or INVALID_TRACKDIR if the direction is currently blo...
@ TRACKDIR_UPPER_W
Upper track and direction to west.
void SetEntranceBusy(bool busy)
Makes an entrance occupied or free.
void MarkDirty()
Marks the vehicles to be redrawn and updates cached variables.
uint16 vehicle_flags
Used for gradual loading and other miscellaneous things (.
RoadType
The different roadtypes we support.
MutableSpriteCache sprite_cache
Cache of sprites and values related to recalculating them, see MutableSpriteCache.
void Leave(RoadVehicle *rv)
Leave the road stop.
uint Crash(bool flooded=false)
Crash the (whole) vehicle chain.
int8 y_offs
y offset for vehicle sprite
SpriteID colourmap
NOSAVE: cached colour mapping.
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a given tiletype.
@ ROAD_NW
North-west part.
@ SND_1A_DEPARTURE_OLD_RV_2
24 == 0x18 Station departure: truck and old bus (2) (random variation of SND_19_DEPARTURE_OLD_RV_1) (...
static DiagDirection GetTunnelBridgeDirection(TileIndex t)
Get the direction pointing to the other end.
void IncrementRealOrderIndex()
Advanced cur_real_order_index to the next real order, keeps care of the wrap-around and invalidates t...
static Owner GetTileOwner(TileIndex tile)
Returns the owner of a tile.
@ VF_BUILT_AS_PROTOTYPE
Vehicle is a prototype (accepted as exclusive preview).
Direction direction
facing
static TrackdirBits DiagdirReachesTrackdirs(DiagDirection diagdir)
Returns all trackdirs that can be reached when entering a tile from a given (diagonal) direction.
bool ProcessOrders(Vehicle *v)
Handle the orders of a vehicle and determine the next place to go to if needed.
byte x_extent
x-extent of vehicle bounding box
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
uint32 StringID
Numeric value that represents a string, independent of the selected language.
@ TRACKDIR_BIT_NONE
No track build.
VehicleCache vcache
Cache of often used vehicle values.
static DisallowedRoadDirections GetDisallowedRoadDirections(TileIndex t)
Gets the disallowed directions.
CompanyID _current_company
Company currently doing an action.
int UpdateInclination(bool new_tile, bool update_delta)
Checks if the vehicle is in a slope and sets the required flags in that case.
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
byte shorten_factor
length on main map for this type is 8 - shorten_factor
static const uint VEHICLE_LENGTH
The length of a vehicle in tile units.
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
Vehicle * First() const
Get the first vehicle of this vehicle chain.
byte tick_counter
Increased by one for each tick.
uint16 cargo_cap
total capacity
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...
int GetDisplayImageWidth(Point *offset=nullptr) const
Get the width of a road vehicle image in the GUI.
static uint GetRoadVehLength(const RoadVehicle *v)
Get length of a road vehicle.
int8 x_offs
x offset for vehicle sprite
void Restore()
Restore the variable.
static RoadVehicle * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
@ DIRDIFF_45RIGHT
Angle of 45 degrees right.
uint8 roadveh_acceleration_model
realistic acceleration for road vehicles
byte z_extent
z-extent of vehicle bounding box
RoadStopType
Types of RoadStops.
byte VehicleRandomBits()
Get a value for a vehicle's random_bits.
void InvalidateNewGRFCacheOfChain()
Invalidates cached NewGRF variables of all vehicles in the chain (after the current vehicle)
void UpdateDeltaXY()
Updates the x and y offsets and the size of the sprite used for this vehicle.
static int ScaleGUITrad(int value)
Scale traditional pixel dimensions to GUI zoom level.
uint32 PaletteID
The number of the palette.
uint32 current_order_time
How many ticks have passed since this order started.
static bool IsDriveThroughRoadStopContinuation(TileIndex rs, TileIndex next)
Checks whether the 'next' tile is still part of the road same drive through stop 'rs' in the same dir...
bool IsInDepot() const
Check whether the vehicle is in the depot.
CommandCost CmdBuildRoadVehicle(TileIndex tile, DoCommandFlag flags, const Engine *e, uint16 data, Vehicle **ret)
Build a road vehicle.
Position information of a vehicle after it moved.
@ WC_VEHICLE_DEPOT
Depot view; Window numbers:
static TrackdirBits TrackStatusToRedSignals(TrackStatus ts)
Returns the red-signal-information of a TrackStatus.
@ MP_STATION
A tile of a station.
static Station * GetByTile(TileIndex tile)
Get the station belonging to a specific tile.
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
bool HasArticulatedPart() const
Check if an engine has an articulated part.
Year build_year
Year the vehicle has been built.
@ ROAD_Y
Full road along the y-axis (north-west + south-east)
void FindVehicleOnPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
Find a vehicle from a specific location.
@ NT_ACCIDENT
An accident or disaster has occurred.
static const int DAYS_IN_YEAR
days per year
@ TRACKDIR_END
Used for iterations.
static const RoadTypeInfo * GetRoadTypeInfo(RoadType roadtype)
Returns a pointer to the Roadtype information for a given roadtype.
uint16 crashed_ctr
Animation counter when the vehicle has crashed.
static TrackdirBits TrackStatusToTrackdirBits(TrackStatus ts)
Returns the present-trackdir-information of a TrackStatus.
TileIndex tile
The tile of the depot.
TileIndex xy
Base tile of the station.
static RoadVehicle * GetIfValid(size_t index)
Returns vehicle if the index is a valid index for this vehicle type.
uint16 cached_max_speed
Maximum speed of the consist (minimum of the max speed of all vehicles in the consist).
static bool IsLevelCrossingTile(TileIndex t)
Return whether a tile is a level crossing tile.
@ NT_ARRIVAL_COMPANY
First vehicle arrived for company.
uint8 original_image_index
Original vehicle image index, thus the image index of the overridden vehicle.
int8 x_bb_offs
x offset of vehicle bounding box
static T abs(const T a)
Returns the absolute value of (scalar) variable.
bool ShouldStopAtStation(const Vehicle *v, StationID station) const
Check whether the given vehicle should stop at the given station based on this order and the non-stop...
void CDECL error(const char *s,...)
Error handling for fatal non-user errors.
void InvalidateNewGRFCache()
Invalidates cached NewGRF variables.
TrackBits
Bitfield corresponding to Track.
bool roadveh_queue
buggy road vehicle queueing
byte day_counter
Increased by one for each day.
void FindVehicleOnPosXY(int x, int y, void *data, VehicleFromPosProc *proc)
Find a vehicle from a specific location.
@ TRACKDIR_RVREV_NE
(Road vehicle) reverse direction north-east
static T SetBit(T &x, const uint8 y)
Set a bit in a variable.
void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const
Gets the sprite to show for the given direction.
#define lengthof(x)
Return the length of an fixed size array.
@ RVSB_WORMHOLE
The vehicle is in a tunnel and/or bridge.
bool HasVehicleOnPosXY(int x, int y, void *data, VehicleFromPosProc *proc)
Checks whether a vehicle in on a specific location.
YAPFSettings yapf
pathfinder settings for the yet another pathfinder
static const byte RV_OVERTAKE_TIMEOUT
The number of ticks a vehicle has for overtaking.
void AgeVehicle(Vehicle *v)
Update age of a vehicle.
byte progress
The percentage (if divided by 256) this vehicle already crossed the tile unit.
void CargoChanged()
Recalculates the cached weight of a vehicle and its parts.
static bool IsNormalRoadTile(TileIndex t)
Return whether a tile is a normal road tile.
bool IsBus() const
Check whether a roadvehicle is a bus.
CargoID cargo_type
type of cargo this vehicle is carrying
byte spritenum
currently displayed sprite index 0xfd == custom sprite, 0xfe == custom second head sprite 0xff == res...
static TileIndex GetOtherTunnelBridgeEnd(TileIndex t)
Determines type of the wormhole and returns its other end.
@ RVS_IN_DT_ROAD_STOP
The vehicle is in a drive-through road stop.
static bool IsReversingRoadTrackdir(Trackdir dir)
Checks whether the trackdir means that we are reversing.
@ CBID_VEHICLE_LENGTH
Vehicle length, returns the amount of 1/8's the vehicle is shorter for trains and RVs.
VehicleSettings vehicle
options for vehicles
void ErrorUnknownCallbackResult(uint32 grfid, uint16 cbid, uint16 cb_res)
Record that a NewGRF returned an unknown/invalid callback result.
static void RoadVehArrivesAt(const RoadVehicle *v, Station *st)
A road vehicle arrives at a station.
T * Previous() const
Get previous vehicle in the chain.
Trackdir
Enumeration for tracks and directions.
@ VEH_TRAIN
Train vehicle type.
uint32 maximum_go_to_depot_penalty
What is the maximum penalty that may be endured for going to a depot.
uint GetAdvanceDistance()
Determines the vehicle "progress" needed for moving a step.
@ TRACKDIR_LEFT_S
Left track and direction to south.
A Stop for a Road Vehicle.
VehicleType type
Type of vehicle.
uint16 reliability
Reliability.
T * First() const
Get the first vehicle in the chain.
void UpdatePosition()
Update the position of the vehicle.
byte flags
Flags of the engine.
@ AS_BRAKE
We want to stop.
@ INVALID_DIR
Flag for an invalid direction.
bool CanVehicleUseStation(EngineID engine_type, const Station *st)
Can this station be used by the given engine type?
bool HandleBreakdown()
Handle all of the aspects of a vehicle breakdown This includes adding smoke and sounds,...
void DecreaseVehicleValue(Vehicle *v)
Decrease the value of a vehicle.
int8 y_bb_offs
y offset of vehicle bounding box
int y
x and y position of the vehicle after moving
static bool IsCargoInClass(CargoID c, CargoClass cc)
Does cargo c have cargo class cc?
static TrackBits TrackdirBitsToTrackBits(TrackdirBits bits)
Discards all directional information from a TrackdirBits value.
@ DIAGDIR_NE
Northeast, upper right on your monitor.
Specification of a rectangle with absolute coordinates of all edges.
uint Crash(bool flooded) override
Common code executed for crashed ground vehicles.
void DrawRoadVehEngine(int left, int right, int preferred_x, int y, EngineID engine, PaletteID pal, EngineImageType image_type)
Draw a road vehicle engine.
@ PROP_ROADVEH_RUNNING_COST_FACTOR
Yearly runningcost.
@ RVSB_IN_DEPOT
The vehicle is in a depot.
uint DoUpdateSpeed(uint accel, int min_speed, int max_speed)
Update the speed of the vehicle.
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
void GetBounds(Rect *bounds) const
Determine shared bounds of all sprites.
@ TRACKDIR_RIGHT_N
Right track and direction to north.
static bool HasRoadWorks(TileIndex t)
Check if a tile has road works.
Vehicle * first
NOSAVE: pointer to the first vehicle in the chain.
void UpdateViewport(bool force_update, bool update_delta)
Update vehicle sprite- and position caches.
@ HVOT_BUS
Station has seen a bus.
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).
CommandCost CmdTurnRoadVeh(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
Turn a roadvehicle around.
static const int DAY_TICKS
1 day is 74 ticks; _date_fract used to be uint16 and incremented by 885.
Trackdir GetVehicleTrackdir() const
Returns the Trackdir on which the vehicle is currently located.
static DepotID GetDepotIndex(TileIndex t)
Get the index of which depot is attached to the tile.
static bool IsStraightRoadTrackdir(Trackdir dir)
Checks whether the given trackdir is a straight road.
@ RVSB_ROAD_STOP_TRACKDIR_MASK
Only bits 0 and 3 are used to encode the trackdir for road stops.
uint16 reliability
Current reliability of the engine.
uint16 refit_cap
Capacity left over from before last refit.
Date date_of_last_service
Last date the vehicle had a service at a depot.
GetNewVehiclePosResult GetNewVehiclePos(const Vehicle *v)
Get position information of a vehicle when moving one pixel in the direction it is facing.
@ VETS_ENTERED_WORMHOLE
The vehicle either entered a bridge, tunnel or depot tile (this includes the last tile of the bridge/...