39 wo->engines.assign(engine_ids.begin(), engine_ids.end());
48 if (std::ranges::find(wo.engines, overriding_engine) != wo.engines.end())
return wo.group;
59 GrfMsg(6,
"SetCustomEngineSprites: engine {} cargo {} already has group -- replacing", engine, cargo);
79static int MapOldSubType(
const Vehicle *v)
91 default: NOT_REACHED();
97enum TTDPAircraftMovementStates {
103 AMS_TTDP_TO_ENTRY_2_AND_3,
104 AMS_TTDP_TO_ENTRY_2_AND_3_AND_H,
105 AMS_TTDP_TO_JUNCTION,
106 AMS_TTDP_LEAVE_RUNWAY,
114 AMS_TTDP_FLIGHT_APPROACH,
115 AMS_TTDP_UNUSED_0x11,
116 AMS_TTDP_FLIGHT_TO_TOWER,
117 AMS_TTDP_UNUSED_0x13,
118 AMS_TTDP_FLIGHT_FINAL,
119 AMS_TTDP_FLIGHT_DESCENT,
121 AMS_TTDP_HELI_TAKEOFF_AIRPORT,
122 AMS_TTDP_HELI_TO_TAKEOFF_AIRPORT,
123 AMS_TTDP_HELI_LAND_AIRPORT,
124 AMS_TTDP_HELI_TAKEOFF_HELIPORT,
125 AMS_TTDP_HELI_TO_TAKEOFF_HELIPORT,
126 AMS_TTDP_HELI_LAND_HELIPORT,
137 if (st ==
nullptr)
return AMS_TTDP_FLIGHT_TO_TOWER;
154 if (amdflag &
AMED_SLOWTURN)
return AMS_TTDP_FLIGHT_TO_TOWER;
161 return AMS_TTDP_TO_HANGAR;
165 return AMS_TTDP_TO_JUNCTION;
169 return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;
179 return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;
186 if (amdflag &
AMED_SLOWTURN)
return AMS_TTDP_FLIGHT_TO_TOWER;
187 return AMS_TTDP_TO_JUNCTION;
190 return AMS_TTDP_TO_OUTWAY;
193 return AMS_TTDP_TAKEOFF;
196 return AMS_TTDP_CLIMBING;
201 AMS_TTDP_HELI_TAKEOFF_AIRPORT : AMS_TTDP_TO_JUNCTION;
203 return AMS_TTDP_HELI_TAKEOFF_HELIPORT;
207 return amdflag &
AMED_HOLD ? AMS_TTDP_FLIGHT_APPROACH : AMS_TTDP_FLIGHT_TO_TOWER;
210 return AMS_TTDP_FLIGHT_DESCENT;
213 if (amdflag &
AMED_BRAKE)
return AMS_TTDP_BRAKING;
215 return AMS_TTDP_TO_INWAY;
221 AMS_TTDP_HELI_LAND_AIRPORT : AMS_TTDP_HELI_LAND_HELIPORT;
223 return AMS_TTDP_FLIGHT_TO_TOWER;
227 return AMS_TTDP_HANGAR;
233enum TTDPAircraftMovementActions {
238 AMA_TTDP_HANGAR_TO_PAD1,
239 AMA_TTDP_HANGAR_TO_PAD2,
240 AMA_TTDP_HANGAR_TO_PAD3,
241 AMA_TTDP_LANDING_TO_PAD1,
242 AMA_TTDP_LANDING_TO_PAD2,
243 AMA_TTDP_LANDING_TO_PAD3,
244 AMA_TTDP_PAD1_TO_HANGAR,
245 AMA_TTDP_PAD2_TO_HANGAR,
246 AMA_TTDP_PAD3_TO_HANGAR,
247 AMA_TTDP_PAD1_TO_TAKEOFF,
248 AMA_TTDP_PAD2_TO_TAKEOFF,
249 AMA_TTDP_PAD3_TO_TAKEOFF,
250 AMA_TTDP_HANGAR_TO_TAKOFF,
251 AMA_TTDP_LANDING_TO_HANGAR,
265 return (v->
cur_speed > 0) ? AMA_TTDP_LANDING_TO_HANGAR : AMA_TTDP_IN_HANGAR;
269 return (v->
current_order.
IsType(OT_LOADING)) ? AMA_TTDP_ON_PAD1 : AMA_TTDP_LANDING_TO_PAD1;
273 return (v->
current_order.
IsType(OT_LOADING)) ? AMA_TTDP_ON_PAD2 : AMA_TTDP_LANDING_TO_PAD2;
282 return (v->
current_order.
IsType(OT_LOADING)) ? AMA_TTDP_ON_PAD3 : AMA_TTDP_LANDING_TO_PAD3;
289 return AMA_TTDP_PAD1_TO_TAKEOFF;
292 return AMA_TTDP_IN_FLIGHT;
300 AMA_TTDP_LANDING_TO_HANGAR : AMA_TTDP_LANDING_TO_PAD1;
303 return AMA_TTDP_IN_HANGAR;
310 return this->v ==
nullptr ? 0 : this->v->
random_bits;
325 int32_t count =
GB(relative, 0, 4);
326 if (this->
self_scope.
v !=
nullptr && (relative != this->cached_relative_count || count == 0)) {
332 switch (
GB(relative, 6, 2)) {
333 default: NOT_REACHED();
350 if (v ==
nullptr) v = u;
353 if (v ==
nullptr) v = self;
400 uint8_t chain_before = 0;
401 uint8_t chain_after = 0;
403 for (u = v->
First(); u != v; u = u->
Next()) {
413 return chain_before | chain_after << 8 | (chain_before + chain_after + consecutive) << 16;
416static uint32_t VehicleGetVariable(
Vehicle *v,
const VehicleScopeResolver *
object, uint8_t variable, uint32_t parameter,
bool &available)
439 std::array<uint8_t, NUM_CARGO> common_cargoes{};
440 uint8_t cargo_classes = 0;
441 uint8_t user_def_data = 0;
443 for (
const Vehicle *u = v; u !=
nullptr; u = u->
Next()) {
447 if (!u->GetEngine()->CanCarryCargo())
continue;
450 common_cargoes[u->cargo_type]++;
454 auto cargo_it = std::max_element(std::begin(common_cargoes), std::end(common_cargoes));
456 CargoID common_cargo_type = (*cargo_it == 0) ? INVALID_CARGO : static_cast<
CargoID>(std::distance(std::begin(common_cargoes), cargo_it));
459 std::array<uint8_t, UINT8_MAX + 1> common_subtypes{};
460 for (
const Vehicle *u = v; u !=
nullptr; u = u->
Next()) {
462 if (u->cargo_type != common_cargo_type || !u->GetEngine()->CanCarryCargo())
continue;
464 common_subtypes[u->cargo_subtype]++;
468 auto subtype_it = std::max_element(std::begin(common_subtypes), std::end(common_subtypes));
470 uint8_t common_subtype = (*subtype_it == 0) ? UINT8_MAX : static_cast<uint8_t>(std::distance(std::begin(common_subtypes), subtype_it));
489 const GRFFile *grffile =
object->ro.grffile;
490 uint8_t common_bitnum = (common_cargo_type == INVALID_CARGO) ? 0xFF :
491 (grffile == nullptr || grffile->grf_version < 8) ?
CargoSpec::Get(common_cargo_type)->bitnum : grffile->cargo_map[common_cargo_type];
508 assert(w !=
nullptr);
509 uint16_t altitude = ClampTo<uint16_t>(v->
z_pos - w->
z_pos);
518 return (ClampTo<uint8_t>(altitude) << 8) | airporttype;
594 uint8_t artic_before = 0;
596 uint8_t artic_after = 0;
609 for (; v !=
nullptr; v = v->
Next()) {
626 if (u ==
nullptr)
return 0;
628 if (parameter == 0x5F) {
632 return VehicleGetVariable(u,
object, parameter,
GetRegister(0x10E), available);
649 if (u ==
nullptr)
return 0;
652 bool prev = (int8_t)parameter < 0;
679 if (tile_type == param_type)
return 0x0F;
689 if (tile_type == param_type)
return 0x0F;
693 default:
return 0x00;
698 uint16_t modflags = 0;
703 const Train *u = is_powered_wagon ? t->
First() : t;
705 bool powered = t->
IsEngine() || is_powered_wagon;
708 if (powered && has_power)
SetBit(modflags, 5);
709 if (powered && !has_power)
SetBit(modflags, 6);
715 return variable == 0xFE ? modflags :
GB(modflags, 8, 8);
725 switch (variable - 0x80) {
726 case 0x00:
return v->
type + 0x10;
727 case 0x01:
return MapOldSubType(v);
730 case 0x04:
return v->
index;
731 case 0x05:
return GB(v->
index, 8, 8);
751 default: ticks = 0;
break;
754 return (variable - 0x80) == 0x10 ? ticks :
GB(ticks, 8, 8);
758 case 0x14:
return v->GetServiceInterval();
759 case 0x15:
return GB(v->GetServiceInterval(), 8, 8);
774 return (variable - 0x80) == 0x18 ? max_speed :
GB(max_speed, 8, 8);
776 case 0x1A:
return v->
x_pos;
777 case 0x1B:
return GB(v->
x_pos, 8, 8);
778 case 0x1C:
return v->
y_pos;
779 case 0x1D:
return GB(v->
y_pos, 8, 8);
780 case 0x1E:
return v->
z_pos;
814 case 0x40:
return ClampTo<uint16_t>(v->
age);
815 case 0x41:
return GB(ClampTo<uint16_t>(v->
age), 8, 8);
816 case 0x42:
return ClampTo<uint16_t>(v->
max_age);
817 case 0x43:
return GB(ClampTo<uint16_t>(v->
max_age), 8, 8);
845 case 0x5C:
return ClampTo<int32_t>(v->
value);
846 case 0x5D:
return GB(ClampTo<int32_t>(v->
value), 8, 24);
847 case 0x5E:
return GB(ClampTo<int32_t>(v->
value), 16, 16);
848 case 0x5F:
return GB(ClampTo<int32_t>(v->
value), 24, 8);
887 switch (variable - 0x80) {
888 case 0x62:
return t->track;
889 case 0x66:
return t->railtype;
895 case 0x7C:
return t->
First()->index;
896 case 0x7D:
return GB(t->
First()->index, 8, 8);
904 switch (variable - 0x80) {
905 case 0x62:
return rv->
state;
906 case 0x64:
return rv->blocked_ctr;
907 case 0x65:
return GB(rv->blocked_ctr, 8, 8);
918 switch (variable - 0x80) {
919 case 0x62:
return s->
state;
926 switch (variable - 0x80) {
937 Debug(grf, 1,
"Unhandled vehicle variable 0x{:X}, type 0x{:X}", variable, (uint)v->
type);
945 if (this->v ==
nullptr) {
976 return VehicleGetVariable(
const_cast<Vehicle*
>(this->v),
this, variable, parameter, available);
992 uint totalsets = in_motion ? (uint)group->
loaded.size() : (uint)group->
loading.size();
994 if (totalsets == 0)
return nullptr;
997 set = std::min(set, totalsets - 1);
1006 case VEH_ROAD:
return GSF_ROADVEHICLES;
1026 return (e !=
nullptr) ? e->
GetGRF() :
nullptr;
1040 CallbackID callback, uint32_t callback_param1, uint32_t callback_param2)
1042 self_scope(*this, engine_type, v, rotor_in_gui),
1043 parent_scope(*this, engine_type, ((v != nullptr) ? v->First() : v), rotor_in_gui),
1044 relative_scope(*this, engine_type, v, rotor_in_gui),
1045 cached_relative_count(0)
1047 if (wagon_override ==
WO_SELF) {
1080 uint max_stack = sprite_stack ?
lengthof(result->seq) : 1;
1081 for (uint stack = 0; stack < max_stack; ++stack) {
1082 object.ResetState();
1083 object.callback_param1 = image_type | (stack << 8);
1085 uint32_t reg100 = sprite_stack ?
GetRegister(0x100) : 0;
1086 if (group !=
nullptr && group->GetNumResults() != 0) {
1087 result->seq[result->count].
sprite = group->GetResult() + (direction % group->GetNumResults());
1088 result->seq[result->count].
pal =
GB(reg100, 0, 16);
1091 if (!
HasBit(reg100, 31))
break;
1108 bool rotor_in_gui = image_type !=
EIT_ON_MAP;
1111 uint rotor_pos = v ==
nullptr || rotor_in_gui ? 0 : v->
Next()->
Next()->
state;
1114 uint max_stack = sprite_stack ?
lengthof(result->seq) : 1;
1115 for (uint stack = 0; stack < max_stack; ++stack) {
1116 object.ResetState();
1117 object.callback_param1 = image_type | (stack << 8);
1119 uint32_t reg100 = sprite_stack ?
GetRegister(0x100) : 0;
1120 if (group !=
nullptr && group->GetNumResults() != 0) {
1121 result->seq[result->count].
sprite = group->GetResult() + (rotor_pos % group->GetNumResults());
1122 result->seq[result->count].
pal =
GB(reg100, 0, 16);
1125 if (!
HasBit(reg100, 31))
break;
1138 return Train::From(v)->tcache.cached_override !=
nullptr;
1153 return object.ResolveCallback();
1169 object.parent_scope.SetVehicle(parent);
1170 return object.ResolveCallback();
1175int GetVehicleProperty(
const Vehicle *v,
PropertyID property,
int orig_value,
bool is_signed)
1177 return GetEngineProperty(v->
engine_type, property, orig_value, v, is_signed);
1187 return static_cast<int16_t
>(callback << 1) / 2;
1207 const uint16_t PROBABILITY_RANGE = 100;
1208 return p +
RandomRange(PROBABILITY_RANGE) >= PROBABILITY_RANGE;
1211static void DoTriggerVehicle(
Vehicle *v, VehicleTrigger trigger, uint16_t base_random_bits,
bool first)
1214 assert(v !=
nullptr);
1221 if (group ==
nullptr)
return;
1227 uint16_t new_random_bits = Random();
1228 uint32_t reseed =
object.GetReseedSum();
1230 v->
random_bits |= (first ? new_random_bits : base_random_bits) & reseed;
1233 case VEHICLE_TRIGGER_NEW_CARGO:
1242 DoTriggerVehicle(v->
First(), VEHICLE_TRIGGER_ANY_NEW_CARGO, new_random_bits,
false);
1245 case VEHICLE_TRIGGER_DEPOT:
1249 if (v->
Next() !=
nullptr) DoTriggerVehicle(v->
Next(), trigger, 0,
true);
1252 case VEHICLE_TRIGGER_EMPTY:
1257 if (v->
Next() !=
nullptr) DoTriggerVehicle(v->
Next(), trigger, first ? new_random_bits : base_random_bits, false);
1260 case VEHICLE_TRIGGER_ANY_NEW_CARGO:
1264 if (v->
Next() !=
nullptr) DoTriggerVehicle(v->
Next(), VEHICLE_TRIGGER_ANY_NEW_CARGO, base_random_bits,
false);
1267 case VEHICLE_TRIGGER_CALLBACK_32:
1273void TriggerVehicle(
Vehicle *v, VehicleTrigger trigger)
1275 if (trigger == VEHICLE_TRIGGER_DEPOT) {
1281 DoTriggerVehicle(v, trigger, 0,
true);
1294static std::vector<ListOrderChange> _list_order_changes;
1305 _list_order_changes.emplace_back(engine, target);
1320 if (engine_a.
type != engine_b.
type)
return static_cast<int>(engine_a.
type) <
static_cast<int>(engine_b.
type);
1336 std::iota(std::begin(ordering), std::end(ordering), 0);
1351 auto it_source = std::ranges::find(ordering, source);
1352 auto it_target = std::ranges::find(ordering, target);
1354 assert(it_source != std::end(ordering) && it_target != std::end(ordering));
1355 assert(it_source != it_target);
1358 Slide(it_source, std::next(it_source), it_target);
1362 for (uint16_t index = 0;
const EngineID &eid : ordering) {
1368 _list_order_changes.clear();
1369 _list_order_changes.shrink_to_fit();
1381 static const int cache_entries[][2] = {
1391 for (
const auto &cache_entry : cache_entries) {
Station * GetTargetAirportIfValid(const Aircraft *v)
Returns aircraft's target station if v->target_airport is a valid station with airport.
@ AMED_BRAKE
Taxiing at the airport.
@ AMED_HOLD
Holding pattern movement (above the airport).
@ AMED_SLOWTURN
Turn slowly (mostly used in the air).
@ AMED_HELI_LOWER
Helicopter landing.
@ AMED_EXACTPOS
Go exactly to the destination coordinates.
@ AMED_HELI_RAISE
Helicopter take-off.
@ HELITAKEOFF
Helicopter wants to leave the airport.
@ TERM4
Heading for terminal 4.
@ STARTTAKEOFF
Airplane has arrived at a runway for take-off.
@ HELIPAD2
Heading for helipad 2.
@ ENDTAKEOFF
Airplane has reached end-point of the take-off runway.
@ TERM5
Heading for terminal 5.
@ TERM6
Heading for terminal 6.
@ TERM3
Heading for terminal 3.
@ TERM8
Heading for terminal 8.
@ HELIPAD3
Heading for helipad 3.
@ HELIPAD1
Heading for helipad 1.
@ TERM2
Heading for terminal 2.
@ HANGAR
Heading for hangar.
@ FLYING
Vehicle is flying in the air.
@ TAKEOFF
Airplane wants to leave the airport.
@ HELILANDING
Helicopter wants to land.
@ ENDLANDING
Airplane wants to finish landing.
@ HELIENDLANDING
Helicopter wants to finish landing.
@ TERM1
Heading for terminal 1.
@ LANDING
Airplane wants to land.
@ TERM7
Heading for terminal 7.
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
debug_inline static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
uint8_t CargoID
Cargo slots to indicate a cargo type within a game.
bool IsValidCargoID(CargoID t)
Test whether cargo type is not INVALID_CARGO.
static const CargoID NUM_CARGO
Maximum number of cargo types in a game.
uint PeriodsInTransit() const
Returns average number of cargo aging periods in transit for a cargo entity.
This struct contains all the info that is needed to draw and construct tracks.
RailTypeFlags flags
Bit mask of rail type flags.
RoadTypeFlags flags
Bit mask of road type flags.
static Date date
Current date in days (day counter).
static Year year
Current year, starting at 0.
static constexpr TimerGame< struct Calendar >::Year ORIGINAL_MAX_YEAR
The maximum year of the original TTD.
static constexpr TimerGame< struct Calendar >::Year ORIGINAL_BASE_YEAR
The minimum starting year/base year of the original TTD.
static constexpr TimerGame< struct Calendar >::Date DAYS_TILL_ORIGINAL_BASE_YEAR
The date of the first day of the original base year.
StationID GetFirstStation() const
Returns the first station of the first cargo packet in this list.
uint StoredCount() const
Returns sum of cargo on board the vehicle (ie not only reserved).
Definition of stuff that is very close to a company, like the company struct itself.
CompanyID _current_company
Company currently doing an action.
Functions related to companies.
Some simple functions to help with accessing containers.
auto Slide(TIter first, TIter last, TIter position) -> std::pair< TIter, TIter >
Move elements between first and last to a new position, rotating elements in between as necessary.
Functions related to debugging.
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
DirDiff DirDifference(Direction d0, Direction d1)
Calculate the difference between two directions.
DirDiff ChangeDirDiff(DirDiff d, DirDiff delta)
Applies two differences together.
Direction
Defines the 8 directions on the map.
DirDiff
Allow incrementing of Direction variables.
@ DIRDIFF_REVERSE
One direction is the opposite of the other one.
@ DIRDIFF_SAME
Both directions faces to the same direction.
static const EngineID INVALID_ENGINE
Constant denoting an invalid engine.
uint16_t EngineID
Unique identification number of an engine.
@ AIR_CTOL
Conventional Take Off and Landing, i.e. planes.
@ EF_SPRITE_STACK
Draw vehicle by stacking multiple sprites.
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23)
static const uint8_t LIT_ALL
Show the liveries of all companies.
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
static constexpr CargoID SG_DEFAULT
Default type used when no more-specific cargo matches.
static constexpr CargoID SG_PURCHASE
Used in purchase lists before an item exists.
@ GSF_INVALID
An invalid spec feature.
@ ATP_TTDP_LARGE
Same as AT_LARGE.
CallbackID
List of implemented NewGRF callbacks.
@ CBID_VEHICLE_BUILD_PROBABILITY
Called to determine probability during build.
@ CBID_VEHICLE_SPAWN_VISUAL_EFFECT
Called to spawn visual effects for vehicles.
@ CBID_VEHICLE_COLOUR_MAPPING
Called to determine if a specific colour map should be used for a vehicle instead of the default live...
@ CBID_VEHICLE_32DAY_CALLBACK
Called for every vehicle every 32 days (not all on same date though).
@ CBID_NO_CALLBACK
Set when using the callback resolve system, but not to resolve a callback.
@ CBID_VEHICLE_START_STOP_CHECK
Called when the company (or AI) tries to start or stop a vehicle.
@ CBID_RANDOM_TRIGGER
Set when calling a randomizing trigger (almost undocumented).
@ CBID_TRAIN_ALLOW_WAGON_ATTACH
Determine whether a wagon can be attached to an already existing train.
@ CBID_VEHICLE_MODIFY_PROPERTY
Called to modify various vehicle properties.
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
Cargo support for NewGRFs.
uint32_t GetCompanyInfo(CompanyID owner, const Livery *l)
Returns company information like in vehicle var 43 or station var 43.
void SetEngineGRF(EngineID engine, const GRFFile *file)
Tie a GRFFile entry to an engine, to allow us to retrieve GRF parameters etc during a game.
static uint32_t PositionHelper(const Vehicle *v, bool consecutive)
Helper to get the position of a vehicle within a chain of vehicles.
static bool EnginePreSort(const EngineID &a, const EngineID &b)
Comparator function to sort engines via scope-GRFID and local ID.
void FillNewGRFVehicleCache(const Vehicle *v)
Fill the grf_cache of the given vehicle.
uint16_t GetVehicleCallbackParent(CallbackID callback, uint32_t param1, uint32_t param2, EngineID engine, const Vehicle *v, const Vehicle *parent)
Evaluate a newgrf callback for vehicles with a different vehicle for parent scope.
bool UsesWagonOverride(const Vehicle *v)
Check if a wagon is currently using a wagon override.
static const Livery * LiveryHelper(EngineID engine, const Vehicle *v)
Determines the livery of an engine.
static uint8_t MapAircraftMovementState(const Aircraft *v)
Map OTTD aircraft movement states to TTDPatch style movement states (VarAction 2 Variable 0xE2)
bool TestVehicleBuildProbability(Vehicle *v, EngineID engine, BuildProbabilityType type)
Test for vehicle build probablity type.
uint16_t GetVehicleCallback(CallbackID callback, uint32_t param1, uint32_t param2, EngineID engine, const Vehicle *v)
Evaluate a newgrf callback for vehicles.
static uint8_t MapAircraftMovementAction(const Aircraft *v)
Map OTTD aircraft movement states to TTDPatch style movement actions (VarAction 2 Variable 0xE6) This...
void CommitVehicleListOrderChanges()
Deternine default engine sorting and execute recorded ListOrderChanges from AlterVehicleListOrder.
static const GRFFile * GetEngineGrfFile(EngineID engine_type)
Get the grf file associated with an engine type.
void AlterVehicleListOrder(EngineID engine, uint16_t target)
Record a vehicle ListOrderChange.
PropertyID
List of NewGRF properties used in Action 0 or Callback 0x36 (CBID_VEHICLE_MODIFY_PROPERTY).
uint8_t GetReverseRailTypeTranslation(RailType railtype, const GRFFile *grffile)
Perform a reverse railtype lookup to get the GRF internal ID.
RailType GetRailTypeTranslation(uint8_t railtype, const GRFFile *grffile)
Translate an index to the GRF-local railtype-translation table into a RailType.
NewGRF handling of rail types.
uint8_t GetReverseRoadTypeTranslation(RoadType roadtype, const GRFFile *grffile)
Perform a reverse roadtype lookup to get the GRF internal ID.
RoadType GetRoadTypeTranslation(RoadTramType rtt, uint8_t tracktype, const GRFFile *grffile)
Translate an index to the GRF-local road/tramtype-translation table into a RoadType.
NewGRF handling of road types.
@ VSG_SCOPE_SELF
Resolved object itself.
@ VSG_SCOPE_PARENT
Related object of the resolved one.
@ VSG_SCOPE_RELATIVE
Relative position (vehicles only)
uint32_t GetRegister(uint i)
Gets the value of a so-called newgrf "register".
RailType GetTileRailType(Tile tile)
Return the rail type of tile, or INVALID_RAILTYPE if this is no rail tile.
bool IsCompatibleRail(RailType enginetype, RailType tiletype)
Checks if an engine of the given RailType can drive on a tile with a given RailType.
bool HasPowerOnRail(RailType enginetype, RailType tiletype)
Checks if an engine of the given RailType got power on a tile with a given RailType.
const RailTypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
@ RTFB_CATENARY
Value for drawing a catenary.
RailType GetRailType(Tile t)
Gets the rail type of the given tile.
RailType
Enumeration for all possible railtypes.
@ INVALID_RAILTYPE
Flag for invalid railtype.
Pseudo random number generator.
uint32_t RandomRange(uint32_t limit, const std::source_location location=std::source_location::current())
Pick a random number between 0 and limit - 1, inclusive.
bool HasPowerOnRoad(RoadType enginetype, RoadType tiletype)
Checks if an engine of the given RoadType got power on a tile with a given RoadType.
@ ROTFB_CATENARY
Value for drawing a catenary.
const RoadTypeInfo * GetRoadTypeInfo(RoadType roadtype)
Returns a pointer to the Roadtype information for a given roadtype.
RoadType
The different roadtypes we support.
@ INVALID_ROADTYPE
flag for invalid roadtype
A number of safeguards to prevent using unsafe methods.
Base classes/functions for stations.
Definition of base types and functions in a cross-platform compatible way.
#define lengthof(array)
Return the length of an fixed size array.
uint8_t subtype
Type of aircraft.
Aircraft, helicopters, rotors and their shadows belong to this class.
uint8_t pos
Next desired position of the aircraft.
uint8_t state
State of the airport.
uint8_t turn_counter
Ticks between each turn to prevent > 45 degree turns.
bool IsNormalAircraft() const
Check if the aircraft type is a normal flying device; eg not a rotor or a shadow.
StationID targetairport
Airport to go to next.
Finite sTate mAchine (FTA) of an airport.
const AirportMovingData * MovingData(uint8_t position) const
Get movement data at a position.
uint8_t delta_z
Z adjustment for helicopter pads.
uint16_t flag
special flags when moving towards the destination.
TTDPAirportType ttd_airport_type
ttdpatch airport type (Small/Large/Helipad/Oilrig)
const AirportFTAClass * GetFTA() const
Get the finite-state machine for this airport or the finite-state machine for the dummy airport in ca...
const AirportSpec * GetSpec() const
Get the AirportSpec that from the airport type of this airport.
VehicleOrderID cur_real_order_index
The index to the current real (non-implicit) order.
uint16_t vehicle_flags
Used for gradual loading and other miscellaneous things (.
VehicleType type
Type of vehicle.
Specification of a cargo type.
CargoClasses classes
Classes of this cargo type.
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo ID.
uint8_t weight
Weight of a single unit of this cargo type in 1/16 ton (62.5 kg).
uint8_t misc_flags
Miscellaneous flags.
EngineID GetID(VehicleType type, uint16_t grf_local_id, uint32_t grfid)
Looks up an EngineID in the EngineOverrideManager.
CargoID GetDefaultCargoType() const
Determines the default cargo type of an engine.
GRFFilePropsBase< NUM_CARGO+2 > grf_prop
Properties related the the grf file.
const GRFFile * GetGRF() const
Retrieve the NewGRF the engine is tied to.
VehicleType type
Vehicle type, ie VEH_ROAD, VEH_TRAIN, etc.
uint8_t flags
Flags of the engine.
uint16_t local_id
id defined by the grf file for this entity
uint32_t grfid
grfid that introduced this entity.
const struct GRFFile * grffile
grf file that introduced this entity
std::array< const struct SpriteGroup *, Tcnt > spritegroup
pointers to the different sprites of the entity
Dynamic data of a loaded NewGRF.
std::array< uint8_t, NUM_CARGO > cargo_map
Inverse cargo translation table (CargoID -> local ID)
EngineID first_engine
Cached EngineID of the front vehicle. INVALID_ENGINE for the front vehicle itself.
uint32_t cached_power
Total power of the consist (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...
GroundVehicleCache gcache
Cache of often calculated values.
bool IsEngine() const
Check if a vehicle is an engine (can be first in a consist).
uint16_t target
GRF-local ID.
EngineID engine
Engine ID.
Information about a particular livery.
uint32_t position_in_vehicle
Cache for NewGRF var 4D.
uint32_t position_consist_length
Cache for NewGRF var 40.
uint32_t consist_cargo_information
Cache for NewGRF var 42. (Note: The cargotype is untranslated in the cache because the accessing GRF ...
uint8_t cache_valid
Bitset that indicates which cache values are valid.
uint32_t company_information
Cache for NewGRF var 43.
uint32_t position_same_id_length
Cache for NewGRF var 41.
uint16_t MapOldOrder() const
Pack this order into a 16 bits integer as close to the TTD representation as possible.
DestinationID GetDestination() const
Gets the destination of this order.
bool IsType(OrderType type) const
Check whether this order is of the given type.
TileIndex tile
The base tile of the area.
SpriteID sprite
The 'real' sprite.
PaletteID pal
The palette (use PAL_NONE) if not needed)
Tindex index
Index of this pool item.
static size_t GetNumItems()
Returns number of valid items in the pool.
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
static Titem * Get(size_t index)
Returns Titem with given index.
std::vector< const SpriteGroup * > loaded
List of loaded groups (can be SpriteIDs or Callback results)
std::vector< const SpriteGroup * > loading
List of loading groups (can be SpriteIDs or Callback results)
Interface for SpriteGroup-s to access the gamestate.
const GRFFile * grffile
GRFFile the resolved SpriteGroup belongs to.
CallbackID callback
Callback being resolved.
const SpriteGroup * root_spritegroup
Root SpriteGroup to use for resolving.
virtual ScopeResolver * GetScope(VarSpriteGroupScope scope=VSG_SCOPE_SELF, uint8_t relative=0)
Get a resolver for the scope.
Buses, trucks and trams belong to this class.
uint16_t crashed_ctr
Animation counter when the vehicle has crashed.
uint8_t overtaking_ctr
The length of the current overtake attempt.
uint8_t overtaking
Set to RVSB_DRIVE_SIDE when overtaking, otherwise 0.
Interface to query and set values specific to a single VarSpriteGroupScope (action 2 scope).
virtual uint32_t GetVariable(uint8_t variable, uint32_t parameter, bool &available) const
Get a variable value.
ResolverObject & ro
Surrounding resolver object.
All ships have this type.
TrackBits state
The "track" the ship is following.
T * Next() const
Get next vehicle in the chain.
static T * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
T * First() const
Get the first vehicle in the chain.
virtual const SpriteGroup * Resolve(ResolverObject &object) const
Base sprite group resolver.
Airport airport
Tile area the airport covers.
'Train' is either a loco or a wagon.
uint16_t cached_max_speed
Maximum speed of the consist (minimum of the max speed of all vehicles in the consist).
Resolver for a vehicle (chain)
VehicleScopeResolver self_scope
Scope resolver for the indicated vehicle.
ScopeResolver * GetScope(VarSpriteGroupScope scope=VSG_SCOPE_SELF, uint8_t relative=0) override
Get a resolver for the scope.
const SpriteGroup * ResolveReal(const RealSpriteGroup *group) const override
Get the real sprites of the grf.
VehicleScopeResolver parent_scope
Scope resolver for its parent vehicle.
GrfSpecFeature GetFeature() const override
Get the feature number being resolved for.
VehicleResolverObject(EngineID engine_type, const Vehicle *v, WagonOverride wagon_override, bool rotor_in_gui=false, CallbackID callback=CBID_NO_CALLBACK, uint32_t callback_param1=0, uint32_t callback_param2=0)
Resolver of a vehicle (chain).
VehicleScopeResolver relative_scope
Scope resolver for an other vehicle in the chain.
@ WO_NONE
Resolve no wagon overrides.
@ WO_SELF
Resolve self-override (helicopter rotors and such).
@ WO_UNCACHED
Resolve wagon overrides.
@ WO_CACHED
Resolve wagon overrides using TrainCache::cached_override.
uint32_t GetDebugID() const override
Get an identifier for the item being resolved.
Resolver for a vehicle scope.
uint32_t GetTriggers() const override
Get the triggers.
const struct Vehicle * v
The vehicle being resolved.
EngineID self_type
Type of the vehicle.
uint32_t GetVariable(uint8_t variable, uint32_t parameter, bool &available) const override
Get a variable value.
uint32_t GetRandomBits() const override
Get a few random bits.
Sprite sequence for a vehicle part.
void Clear()
Clear all information.
Money GetDisplayProfitThisYear() const
Gets the profit vehicle had this year.
EngineID engine_type
The type of engine used for this vehicle.
int32_t z_pos
z coordinate.
Direction direction
facing
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
VehicleCargoList cargo
The cargo this vehicle is carrying.
uint16_t cargo_cap
total capacity
VehicleOrderID GetNumOrders() const
Get the number of orders this vehicle has.
uint8_t subtype
subtype (Filled with values from AircraftSubType/DisasterSubType/EffectVehicleType/GroundVehicleSubty...
uint16_t random_bits
Bits used for randomized variational spritegroups.
uint8_t day_counter
Increased by one for each day.
bool HasArticulatedPart() const
Check if an engine has an articulated part.
uint8_t breakdown_ctr
Counter for managing breakdown events.
uint8_t breakdown_delay
Counter for managing breakdown length.
TimerGameCalendar::Date date_of_last_service_newgrf
Last calendar date the vehicle had a service at a depot, unchanged by the date cheat to protect again...
uint8_t subspeed
fractional speed
bool IsArticulatedPart() const
Check if the vehicle is an articulated part of an engine.
Vehicle * Move(int n)
Get the vehicle at offset n of this vehicle chain.
uint8_t acceleration
used by train & aircraft
Vehicle * First() const
Get the first vehicle of this vehicle chain.
Order current_order
The current order (+ status, like: loading)
CargoID cargo_type
type of cargo this vehicle is carrying
Vehicle * Next() const
Get the next vehicle of this vehicle.
int32_t y_pos
y coordinate.
int32_t x_pos
x coordinate.
Money value
Value of the vehicle.
uint8_t waiting_triggers
Triggers to be yet matched before rerandomizing the random bits.
VehicleCache vcache
Cache of often used vehicle values.
uint32_t motion_counter
counter to occasionally play a vehicle sound.
NewGRFCache grf_cache
Cache of often used calculated NewGRF values.
uint32_t GetGRFID() const
Retrieve the GRF ID of the NewGRF the vehicle is tied to.
GroundVehicleCache * GetGroundVehicleCache()
Access the ground vehicle cache of the vehicle.
virtual int GetCurrentMaxSpeed() const
Calculates the maximum speed of the vehicle under its current conditions.
virtual bool IsPrimaryVehicle() const
Whether this is the primary vehicle in the chain.
uint16_t load_unload_ticks
Ticks to wait before starting next cycle.
Money GetDisplayProfitLastYear() const
Gets the profit vehicle had last year.
uint8_t spritenum
currently displayed sprite index 0xfd == custom sprite, 0xfe == custom second head sprite 0xff == res...
uint16_t cur_speed
current speed
uint8_t cargo_subtype
Used for livery refits (NewGRF variations)
TimerGameCalendar::Date age
Age in calendar days.
uint8_t breakdowns_since_last_service
Counter for the amount of breakdowns.
TimerGameCalendar::Date max_age
Maximum age.
uint16_t reliability
Reliability.
debug_inline bool IsGroundVehicle() const
Check if the vehicle is a ground vehicle.
Vehicle * Previous() const
Get the previous vehicle of this vehicle.
uint16_t reliability_spd_dec
Reliability decrease speed.
uint8_t tick_counter
Increased by one for each tick.
TileIndex tile
Current tile index.
StationID last_station_visited
The last station we stopped at.
void InvalidateNewGRFCacheOfChain()
Invalidates cached NewGRF variables of all vehicles in the chain (after the current vehicle)
uint8_t breakdown_chance
Current chance of breakdowns.
TimerGameCalendar::Year build_year
Year the vehicle has been built.
Owner owner
Which company owns the vehicle?
UnitID unitnumber
unit number, for display purposes only
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition of the game-calendar-timer.
Base for the train class.
@ VRF_POWEREDWAGON
Wagon is powered.
@ VRF_TOGGLE_REVERSE
Used for vehicle var 0xFE bit 8 (toggled each time the train is reversed, accurate for first vehicle ...
@ VRF_REVERSE_DIRECTION
Reverse the visible direction of the vehicle.
const Livery * GetEngineLivery(EngineID engine_type, CompanyID company, EngineID parent_engine_type, const Vehicle *v, uint8_t livery_setting)
Determines the livery for a vehicle.
void VehicleEnteredDepotThisTick(Vehicle *v)
Adds a vehicle to the list of vehicles that visited a depot this tick.
@ VF_BUILT_AS_PROTOTYPE
Vehicle is a prototype (accepted as exclusive preview).
@ VF_CARGO_UNLOADING
Vehicle is unloading cargo.
@ NCVV_COMPANY_INFORMATION
This bit will be set if the NewGRF var 43 currently stored is valid.
@ NCVV_CONSIST_CARGO_INFORMATION
This bit will be set if the NewGRF var 42 currently stored is valid.
@ NCVV_POSITION_CONSIST_LENGTH
This bit will be set if the NewGRF var 40 currently stored is valid.
@ NCVV_POSITION_SAME_ID_LENGTH
This bit will be set if the NewGRF var 41 currently stored is valid.
@ NCVV_POSITION_IN_VEHICLE
This bit will be set if the NewGRF var 4D currently stored is valid.
@ NCVV_END
End of the bits.
@ VS_HIDDEN
Vehicle is not visible.
Functions related to vehicles.
EngineImageType
Visualisation contexts of vehicles and engines.
@ EIT_ON_MAP
Vehicle drawn in viewport.
@ VEH_ROAD
Road vehicle type.
@ VEH_DISASTER
Disaster vehicle type.
@ VEH_AIRCRAFT
Aircraft vehicle type.
@ VEH_SHIP
Ship vehicle type.
@ VEH_EFFECT
Effect vehicle type (smoke, explosions, sparks, bubbles)
@ VEH_TRAIN
Train vehicle type.
static const VehicleID INVALID_VEHICLE
Constant representing a non-existing vehicle.
static const uint VEHICLE_LENGTH
The length of a vehicle in tile units.