OpenTTD Source 20250613-master-ga1786fa1f4
vehicle_base.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 VEHICLE_BASE_H
11#define VEHICLE_BASE_H
12
13#include "track_type.h"
14#include "command_type.h"
15#include "order_base.h"
16#include "cargopacket.h"
17#include "texteff.hpp"
18#include "engine_type.h"
19#include "order_func.h"
20#include "transport_type.h"
21#include "group_type.h"
22#include "base_consist.h"
23#include "network/network.h"
24#include "saveload/saveload.h"
26
27const uint TILE_AXIAL_DISTANCE = 192; // Logical length of the tile in any DiagDirection used in vehicle movement.
28const uint TILE_CORNER_DISTANCE = 128; // Logical length of the tile corner crossing in any non-diagonal direction used in vehicle movement.
29
31enum class VehState : uint8_t {
32 Hidden = 0,
33 Stopped = 1,
34 Unclickable = 2,
35 DefaultPalette = 3,
36 TrainSlowing = 4,
37 Shadow = 5,
38 AircraftBroken = 6,
39 Crashed = 7,
40};
42
52
55 /* Values calculated when they are requested for the first time after invalidating the NewGRF cache. */
59 uint32_t company_information = 0;
60 uint32_t position_in_vehicle = 0;
61 uint8_t cache_valid = 0;
62
63 auto operator<=>(const NewGRFCache &) const = default;
64};
65
85
95
109
112 uint16_t cached_max_speed = 0;
114
115 uint8_t cached_vis_effect = 0;
116
117 auto operator<=>(const VehicleCache &) const = default;
118};
119
122 std::array<PalSpriteID, 8> seq;
123 uint count;
124
125 bool operator==(const VehicleSpriteSeq &other) const
126 {
127 return std::ranges::equal(std::span(this->seq.data(), this->count), std::span(other.seq.data(), other.count));
128 }
129
133 bool IsValid() const
134 {
135 return this->count != 0;
136 }
137
141 void Clear()
142 {
143 this->count = 0;
144 }
145
149 void Set(SpriteID sprite)
150 {
151 this->count = 1;
152 this->seq[0].sprite = sprite;
153 this->seq[0].pal = 0;
154 }
155
160 {
161 this->count = src.count;
162 for (uint i = 0; i < src.count; ++i) {
163 this->seq[i].sprite = src.seq[i].sprite;
164 this->seq[i].pal = 0;
165 }
166 }
167
168 void GetBounds(Rect *bounds) const;
169 void Draw(int x, int y, PaletteID default_pal, bool force_pal) const;
170};
171
183
187
188/* Some declarations of functions, so we can make them friendly */
189struct GroundVehicleCache;
190struct LoadgameState;
191extern bool LoadOldVehicle(LoadgameState &ls, int num);
192extern void FixOldVehicles(LoadgameState &ls);
193
194struct GRFFile;
195
206
212 TileIndex location = INVALID_TILE;
214 bool reverse = false;
215 bool found = false;
216
217 ClosestDepot() = default;
218
219 ClosestDepot(TileIndex location, DestinationID destination, bool reverse = false) :
220 location(location), destination(destination), reverse(reverse), found(true) {}
221};
222
225private:
226 typedef std::list<RefitDesc> RefitList;
227
228 Vehicle *next = nullptr;
229 Vehicle *previous = nullptr;
230 Vehicle *first = nullptr;
231
232 Vehicle *next_shared = nullptr;
234
235public:
236 friend void FixOldVehicles(LoadgameState &ls);
237 friend void AfterLoadVehiclesPhase1(bool part_of_load);
238 friend bool LoadOldVehicle(LoadgameState &ls, int num);
239 /* So we can use private/protected variables in the saveload code */
240 friend class SlVehicleCommon;
241 friend class SlVehicleDisaster;
242 friend void Ptrs_VEHS();
243
245
252
256
258
259 mutable Rect coord{};
260
263
267
269
270 /* Related to age and service time */
277 uint16_t reliability = 0;
278 uint16_t reliability_spd_dec = 0;
279 uint8_t breakdown_ctr = 0;
280 uint8_t breakdown_delay = 0;
282 uint8_t breakdown_chance = 0;
283
284 int32_t x_pos = 0;
285 int32_t y_pos = 0;
286 int32_t z_pos = 0;
288
295 uint8_t spritenum = 0;
296 uint8_t x_extent = 0;
297 uint8_t y_extent = 0;
298 uint8_t z_extent = 0;
299 int8_t x_bb_offs = 0;
300 int8_t y_bb_offs = 0;
301 int8_t x_offs = 0;
302 int8_t y_offs = 0;
303 EngineID engine_type = EngineID::Invalid();
304
305 TextEffectID fill_percent_te_id = INVALID_TE_ID;
307
308 uint16_t cur_speed = 0;
309 uint8_t subspeed = 0;
310 uint8_t acceleration = 0;
311 uint32_t motion_counter = 0;
312 uint8_t progress = 0;
313
315 uint16_t random_bits = 0;
316
317 StationID last_station_visited = StationID::Invalid();
318 StationID last_loading_station = StationID::Invalid();
320
323 uint8_t cargo_subtype = 0;
324 uint16_t cargo_cap = 0;
325 uint16_t refit_cap = 0;
326 uint16_t cargo_age_counter = 0;
327 int8_t trip_occupancy = 0;
328
329 uint8_t day_counter = 0;
330 uint8_t tick_counter = 0;
331 uint8_t running_ticks = 0;
332 uint16_t load_unload_ticks = 0;
333
335 uint8_t subtype = 0;
337
338 union {
339 OrderList *orders = nullptr;
340 uint32_t old_orders;
341 };
342
345
346 GroupID group_id = GroupID::Invalid();
347
349
354 virtual uint16_t GetMaxWeight() const
355 {
356 return 0;
357 }
358
360
361 void PreDestructor();
363 virtual ~Vehicle();
364
365 void BeginLoading();
367 void LeaveStation();
368
371
372 uint16_t &GetGroundVehicleFlags();
373 const uint16_t &GetGroundVehicleFlags() const;
374
376
377 void HandleLoading(bool mode = false);
378
387 virtual void MarkDirty() {}
388
393 virtual void UpdateDeltaXY() {}
394
408 inline uint GetOldAdvanceSpeed(uint speed)
409 {
410 return (this->direction & 1) ? speed : speed * 3 / 4;
411 }
412
425 static inline uint GetAdvanceSpeed(uint speed)
426 {
427 return speed * 3 / 4;
428 }
429
437 inline uint GetAdvanceDistance()
438 {
439 return (this->direction & 1) ? TILE_AXIAL_DISTANCE : TILE_CORNER_DISTANCE * 2;
440 }
441
446 virtual ExpensesType GetExpenseType([[maybe_unused]] bool income) const { return EXPENSES_OTHER; }
447
452 virtual void PlayLeaveStationSound([[maybe_unused]] bool force = false) const {}
453
457 virtual bool IsPrimaryVehicle() const { return false; }
458
459 const Engine *GetEngine() const;
460
466 virtual void GetImage([[maybe_unused]] Direction direction, [[maybe_unused]] EngineImageType image_type, [[maybe_unused]] VehicleSpriteSeq *result) const { result->Clear(); }
467
468 const GRFFile *GetGRF() const;
469 uint32_t GetGRFID() const;
470
476 {
477 this->grf_cache.cache_valid = 0;
478 }
479
485 {
486 for (Vehicle *u = this; u != nullptr; u = u->Next()) {
487 u->InvalidateNewGRFCache();
488 }
489 }
490
495 debug_inline bool IsGroundVehicle() const
496 {
497 return this->type == VEH_TRAIN || this->type == VEH_ROAD;
498 }
499
504 virtual int GetDisplaySpeed() const { return 0; }
505
510 virtual int GetDisplayMaxSpeed() const { return 0; }
511
516 virtual int GetCurrentMaxSpeed() const { return 0; }
517
522 virtual Money GetRunningCost() const { return 0; }
523
528 virtual bool IsInDepot() const { return false; }
529
534 virtual bool IsChainInDepot() const { return this->IsInDepot(); }
535
540 bool IsStoppedInDepot() const
541 {
542 assert(this == this->First());
543 /* Free wagons have no VehState::Stopped state */
544 if (this->IsPrimaryVehicle() && !this->vehstatus.Test(VehState::Stopped)) return false;
545 return this->IsChainInDepot();
546 }
547
552 virtual bool Tick() { return true; };
553
557 virtual void OnNewCalendarDay() {};
558
562 virtual void OnNewEconomyDay() {};
563
564 void ShiftDates(TimerGameEconomy::Date interval);
565
571 virtual uint Crash(bool flooded = false);
572
585 virtual Trackdir GetVehicleTrackdir() const { return INVALID_TRACKDIR; }
586
591 Money GetDisplayRunningCost() const { return (this->GetRunningCost() >> 8); }
592
597 Money GetDisplayProfitThisYear() const { return (this->profit_this_year >> 8); }
598
603 Money GetDisplayProfitLastYear() const { return (this->profit_last_year >> 8); }
604
605 void SetNext(Vehicle *next);
606
612 inline Vehicle *Next() const { return this->next; }
613
619 inline Vehicle *Previous() const { return this->previous; }
620
625 inline Vehicle *First() const { return this->first; }
626
631 inline Vehicle *Last()
632 {
633 Vehicle *v = this;
634 while (v->Next() != nullptr) v = v->Next();
635 return v;
636 }
637
642 inline const Vehicle *Last() const
643 {
644 const Vehicle *v = this;
645 while (v->Next() != nullptr) v = v->Next();
646 return v;
647 }
648
654 inline Vehicle *Move(int n)
655 {
656 Vehicle *v = this;
657 if (n < 0) {
658 for (int i = 0; i != n && v != nullptr; i--) v = v->Previous();
659 } else {
660 for (int i = 0; i != n && v != nullptr; i++) v = v->Next();
661 }
662 return v;
663 }
664
670 inline const Vehicle *Move(int n) const
671 {
672 const Vehicle *v = this;
673 if (n < 0) {
674 for (int i = 0; i != n && v != nullptr; i--) v = v->Previous();
675 } else {
676 for (int i = 0; i != n && v != nullptr; i++) v = v->Next();
677 }
678 return v;
679 }
680
685 inline const Order *GetFirstOrder() const { return (this->orders == nullptr) ? nullptr : this->GetOrder(this->orders->GetFirstOrder()); }
686
687 inline std::span<const Order> Orders() const
688 {
689 if (this->orders == nullptr) return {};
690 return this->orders->GetOrders();
691 }
692
693 inline std::span<Order> Orders()
694 {
695 if (this->orders == nullptr) return {};
696 return this->orders->GetOrders();
697 }
698
699 void AddToShared(Vehicle *shared_chain);
700 void RemoveFromShared();
701
706 inline Vehicle *NextShared() const { return this->next_shared; }
707
712 inline Vehicle *PreviousShared() const { return this->previous_shared; }
713
718 inline Vehicle *FirstShared() const { return (this->orders == nullptr) ? this->First() : this->orders->GetFirstSharedVehicle(); }
719
724 inline bool IsOrderListShared() const { return this->orders != nullptr && this->orders->IsShared(); }
725
730 inline VehicleOrderID GetNumOrders() const { return (this->orders == nullptr) ? 0 : this->orders->GetNumOrders(); }
731
736 inline VehicleOrderID GetNumManualOrders() const { return (this->orders == nullptr) ? 0 : this->orders->GetNumManualOrders(); }
737
743 {
744 return (this->orders == nullptr) ? StationID::Invalid().base() : this->orders->GetNextStoppingStation(this);
745 }
746
747 void ResetRefitCaps();
748
749 void ReleaseUnitNumber();
750
758 {
759 this->CopyConsistPropertiesFrom(src);
760
761 this->ReleaseUnitNumber();
762 this->unitnumber = src->unitnumber;
763
764 this->current_order = src->current_order;
765 this->dest_tile = src->dest_tile;
766
767 this->profit_this_year = src->profit_this_year;
768 this->profit_last_year = src->profit_last_year;
769
770 src->unitnumber = 0;
771 }
772
773
774 bool HandleBreakdown();
775
776 bool NeedsAutorenewing(const Company *c, bool use_renew_setting = true) const;
777
778 bool NeedsServicing() const;
779 bool NeedsAutomaticServicing() const;
780
788 virtual TileIndex GetOrderStationLocation([[maybe_unused]] StationID station) { return INVALID_TILE; }
789
790 virtual TileIndex GetCargoTile() const { return this->tile; }
791
797 virtual ClosestDepot FindClosestDepot() { return {}; }
798
799 virtual void SetDestTile(TileIndex tile) { this->dest_tile = tile; }
800
802
803 void UpdateVisualEffect(bool allow_power_change = true);
804 void ShowVisualEffect() const;
805
806 void UpdatePosition();
807 void UpdateViewport(bool dirty);
808 void UpdateBoundingBoxCoordinates(bool update_cache) const;
810 bool MarkAllViewportsDirty() const;
811
812 inline uint16_t GetServiceInterval() const { return this->service_interval; }
813
814 inline void SetServiceInterval(uint16_t interval) { this->service_interval = interval; }
815
816 inline bool ServiceIntervalIsCustom() const { return this->vehicle_flags.Test(VehicleFlag::ServiceIntervalIsCustom); }
817
818 inline bool ServiceIntervalIsPercent() const { return this->vehicle_flags.Test(VehicleFlag::ServiceIntervalIsPercent); }
819
820 inline void SetServiceIntervalIsCustom(bool on) { this->vehicle_flags.Set(VehicleFlag::ServiceIntervalIsCustom, on); }
821
822 inline void SetServiceIntervalIsPercent(bool on) { this->vehicle_flags.Set(VehicleFlag::ServiceIntervalIsPercent, on); }
823
824 bool HasFullLoadOrder() const;
825 bool HasConditionalOrder() const;
826 bool HasUnbunchingOrder() const;
828 bool IsWaitingForUnbunching() const;
829
830private:
836 {
837 if (this->GetNumManualOrders() > 0) {
838 /* Advance to next real order */
839 do {
840 this->cur_real_order_index++;
841 if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
842 } while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT));
843 } else {
844 this->cur_real_order_index = 0;
845 }
846 }
847
848public:
855 {
857 /* Increment real order index as well */
859 }
860
861 assert(this->cur_real_order_index == 0 || this->cur_real_order_index < this->GetNumOrders());
862
863 /* Advance to next implicit order */
864 do {
866 if (this->cur_implicit_order_index >= this->GetNumOrders()) this->cur_implicit_order_index = 0;
867 } while (this->cur_implicit_order_index != this->cur_real_order_index && !this->GetOrder(this->cur_implicit_order_index)->IsType(OT_IMPLICIT));
868
869 InvalidateVehicleOrder(this, 0);
870 }
871
879 {
881 /* Increment both real and implicit order */
883 } else {
884 /* Increment real order only */
886 InvalidateVehicleOrder(this, 0);
887 }
888 }
889
894 {
895 /* Make sure the index is valid */
896 if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
897
898 if (this->GetNumManualOrders() > 0) {
899 /* Advance to next real order */
900 while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT)) {
901 this->cur_real_order_index++;
902 if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
903 }
904 } else {
905 this->cur_real_order_index = 0;
906 }
907 }
908
914 inline Order *GetOrder(int index) const
915 {
916 return (this->orders == nullptr) ? nullptr : this->orders->GetOrderAt(index);
917 }
918
923 inline const Order *GetLastOrder() const
924 {
925 return (this->orders == nullptr) ? nullptr : this->orders->GetOrderAt(this->orders->GetLastOrder());
926 }
927
928 bool IsEngineCountable() const;
929 bool HasEngineType() const;
930 bool HasDepotOrder() const;
931 void HandlePathfindingResult(bool path_found);
932
937 debug_inline bool IsFrontEngine() const
938 {
939 return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_FRONT);
940 }
941
946 inline bool IsArticulatedPart() const
947 {
948 return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_ARTICULATED_PART);
949 }
950
955 inline bool HasArticulatedPart() const
956 {
957 return this->Next() != nullptr && this->Next()->IsArticulatedPart();
958 }
959
966 {
967 assert(this->HasArticulatedPart());
968 return this->Next();
969 }
970
976 {
977 Vehicle *v = this;
978 while (v->IsArticulatedPart()) v = v->Previous();
979 return v;
980 }
981
986 inline const Vehicle *GetFirstEnginePart() const
987 {
988 const Vehicle *v = this;
989 while (v->IsArticulatedPart()) v = v->Previous();
990 return v;
991 }
992
998 {
999 Vehicle *v = this;
1000 while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
1001 return v;
1002 }
1003
1008 inline Vehicle *GetNextVehicle() const
1009 {
1010 const Vehicle *v = this;
1011 while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
1012
1013 /* v now contains the last articulated part in the engine */
1014 return v->Next();
1015 }
1016
1021 inline Vehicle *GetPrevVehicle() const
1022 {
1023 Vehicle *v = this->Previous();
1024 while (v != nullptr && v->IsArticulatedPart()) v = v->Previous();
1025
1026 return v;
1027 }
1028
1029 uint32_t GetDisplayMaxWeight() const;
1030 uint32_t GetDisplayMinPowerToWeight() const;
1031};
1032
1037template <class T, VehicleType Type>
1039 static const VehicleType EXPECTED_TYPE = Type;
1040
1042
1047 {
1048 this->sprite_cache.sprite_seq.count = 1;
1049 }
1050
1055 inline T *First() const { return (T *)this->Vehicle::First(); }
1056
1061 inline T *Last() { return (T *)this->Vehicle::Last(); }
1062
1067 inline const T *Last() const { return (const T *)this->Vehicle::Last(); }
1068
1073 inline T *Next() const { return (T *)this->Vehicle::Next(); }
1074
1079 inline T *Previous() const { return (T *)this->Vehicle::Previous(); }
1080
1086 inline T *GetNextArticulatedPart() { return (T *)this->Vehicle::GetNextArticulatedPart(); }
1087
1093 inline T *GetNextArticulatedPart() const { return (T *)this->Vehicle::GetNextArticulatedPart(); }
1094
1099 inline T *GetFirstEnginePart() { return (T *)this->Vehicle::GetFirstEnginePart(); }
1100
1105 inline const T *GetFirstEnginePart() const { return (const T *)this->Vehicle::GetFirstEnginePart(); }
1106
1111 inline T *GetLastEnginePart() { return (T *)this->Vehicle::GetLastEnginePart(); }
1112
1117 inline T *GetNextVehicle() const { return (T *)this->Vehicle::GetNextVehicle(); }
1118
1123 inline T *GetPrevVehicle() const { return (T *)this->Vehicle::GetPrevVehicle(); }
1124
1130 static inline bool IsValidID(auto index)
1131 {
1132 return Vehicle::IsValidID(index) && Vehicle::Get(index)->type == Type;
1133 }
1134
1139 static inline T *Get(auto index)
1140 {
1141 return (T *)Vehicle::Get(index);
1142 }
1143
1148 static inline T *GetIfValid(auto index)
1149 {
1150 return IsValidID(index) ? Get(index) : nullptr;
1151 }
1152
1158 static inline T *From(Vehicle *v)
1159 {
1160 assert(v->type == Type);
1161 return (T *)v;
1162 }
1163
1169 static inline const T *From(const Vehicle *v)
1170 {
1171 assert(v->type == Type);
1172 return (const T *)v;
1173 }
1174
1180 inline void UpdateViewport(bool force_update, bool update_delta)
1181 {
1182 bool sprite_has_changed = false;
1183
1184 /* Skip updating sprites on dedicated servers without screen */
1185 if (_network_dedicated) return;
1186
1187 /* Explicitly choose method to call to prevent vtable dereference -
1188 * it gives ~3% runtime improvements in games with many vehicles */
1189 if (update_delta) ((T *)this)->T::UpdateDeltaXY();
1190
1191 /*
1192 * Only check for a new sprite sequence if the vehicle direction
1193 * has changed since we last checked it, assuming that otherwise
1194 * there won't be enough change in bounding box or offsets to need
1195 * to resolve a new sprite.
1196 */
1197 if (this->direction != this->sprite_cache.last_direction || this->sprite_cache.is_viewport_candidate) {
1198 VehicleSpriteSeq seq;
1199
1200 ((T*)this)->T::GetImage(this->direction, EIT_ON_MAP, &seq);
1201 if (this->sprite_cache.sprite_seq != seq) {
1202 sprite_has_changed = true;
1203 this->sprite_cache.sprite_seq = seq;
1204 }
1205
1208 } else {
1209 /*
1210 * A change that could potentially invalidate the sprite has been
1211 * made, signal that we should still resolve it before drawing on a
1212 * viewport.
1213 */
1215 }
1216
1217 if (force_update || sprite_has_changed) {
1218 this->Vehicle::UpdateViewport(true);
1219 }
1220 }
1221
1227 static Pool::IterateWrapper<T> Iterate(size_t from = 0) { return Pool::IterateWrapper<T>(from); }
1228};
1229
1231static const int32_t INVALID_COORD = 0x7fffffff;
1232
1233#endif /* VEHICLE_BASE_H */
Properties for front vehicles/consists.
@ ServiceIntervalIsCustom
Service interval is custom.
@ ServiceIntervalIsPercent
Service interval is percent.
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
uint8_t CargoType
Cargo slots to indicate a cargo type within a game.
Definition cargo_type.h:23
Base class for cargo packets.
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
constexpr Timpl & Set()
Set all bits.
Common return value for all commands.
Minimal stack that uses a pool to avoid pointers.
uint64_t TickCounter
The type that the tick counter is stored in.
CargoList that is used for vehicles.
Types related to commands.
static constexpr Owner INVALID_OWNER
An invalid owner.
Direction
Defines the 8 directions on the map.
@ INVALID_DIR
Flag for an invalid direction.
ExpensesType
Types of expenses.
@ EXPENSES_OTHER
Other expenses.
Types related to engines.
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition gfx_type.h:17
uint32_t PaletteID
The number of the palette.
Definition gfx_type.h:18
virtual void MarkDirty()
Marks the vehicles to be redrawn and updates cached variables.
Types of a group.
bool _network_dedicated
are we a dedicated server?
Definition network.cpp:70
Basic functions/variables used all over the place.
Base class for orders.
void InvalidateVehicleOrder(const Vehicle *v, int data)
Updates the widgets of a vehicle which contains the order-data.
Functions related to orders.
uint8_t VehicleOrderID
The index of an order within its current vehicle (not pool related)
Definition order_type.h:18
Functions/types related to saving and loading games.
Various front vehicle properties that are preserved when autoreplacing, using order-backup or switchi...
VehicleOrderID cur_real_order_index
The index to the current real (non-implicit) order.
VehicleFlags vehicle_flags
Used for gradual loading and other miscellaneous things (.
VehicleOrderID cur_implicit_order_index
The index to the current implicit order.
uint16_t service_interval
The interval for (automatic) servicing; either in days or %.
void CopyConsistPropertiesFrom(const BaseConsist *src)
Copy properties of other BaseConsist.
Base vehicle class.
VehicleType type
Type of vehicle.
Helper class to perform the cargo payment.
Structure to return information about the closest depot location, and whether it could be found.
DestinationID destination
The DestinationID as used for orders.
Dynamic data of a loaded NewGRF.
Definition newgrf.h:115
Cached, frequently calculated values.
Cache for vehicle sprites and values relating to whether they should be updated before drawing,...
bool revalidate_before_draw
We need to do a GetImage() and check bounds before drawing this sprite.
VehicleSpriteSeq sprite_seq
Vehicle appearance.
bool is_viewport_candidate
This vehicle can potentially be drawn on a viewport.
Direction last_direction
Last direction we obtained sprites for.
Rect old_coord
Co-ordinates from the last valid bounding box.
Cached often queried (NewGRF) values.
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.
Shared order list linking together the linked list of orders and the list of vehicles sharing this or...
Definition order_base.h:264
StationIDStack GetNextStoppingStation(const Vehicle *v, VehicleOrderID first=INVALID_VEH_ORDER_ID, uint hops=0) const
Recursively determine the next deterministic station to stop at.
Vehicle * GetFirstSharedVehicle() const
Get the first vehicle of this vehicle chain.
Definition order_base.h:387
VehicleOrderID GetFirstOrder() const
Get the first order of the order chain.
Definition order_base.h:318
VehicleOrderID GetNumOrders() const
Get number of orders in the order list.
Definition order_base.h:362
VehicleOrderID GetNumManualOrders() const
Get number of manually added orders in the order list.
Definition order_base.h:368
bool IsShared() const
Is this a shared order list?
Definition order_base.h:381
VehicleOrderID GetLastOrder() const
Get the last order of the order chain.
Definition order_base.h:344
const Order * GetOrderAt(VehicleOrderID index) const
Get a certain order of the order chain.
Definition order_base.h:328
Base class for all PoolItems.
static Titem * Get(auto index)
Returns Titem with given index.
Tindex index
Index of this pool item.
static bool IsValidID(auto index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Base class for all pools.
Specification of a rectangle with absolute coordinates of all edges.
Simulated cargo type and capacity for prediction of future links.
CargoType cargo
Cargo type the vehicle will be carrying.
uint16_t capacity
Capacity the vehicle will have.
uint16_t remaining
Capacity remaining from before the previous refit.
Class defining several overloaded accessors so we don't have to cast vehicle types that often.
T * Next() const
Get next vehicle in the chain.
static Pool::IterateWrapper< T > Iterate(size_t from=0)
Returns an iterable ensemble of all valid vehicles of type T.
T * Previous() const
Get previous vehicle in the chain.
static const T * From(const Vehicle *v)
Converts a const Vehicle to const SpecializedVehicle with type checking.
static T * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
T * GetNextArticulatedPart()
Get the next part of an articulated engine.
static bool IsValidID(auto index)
Tests whether given index is a valid index for vehicle of this type.
static T * GetIfValid(auto index)
Returns vehicle if the index is a valid index for this vehicle type.
const T * GetFirstEnginePart() const
Get the first part of an articulated engine.
T * First() const
Get the first vehicle in the chain.
T * GetPrevVehicle() const
Get the previous real (non-articulated part) vehicle in the consist.
T * GetNextVehicle() const
Get the next real (non-articulated part) vehicle in the consist.
T * GetNextArticulatedPart() const
Get the next part of an articulated engine.
static T * Get(auto index)
Gets vehicle with given index.
SpecializedVehicle()
Set vehicle type correctly.
void UpdateViewport(bool force_update, bool update_delta)
Update vehicle sprite- and position caches.
T * GetLastEnginePart()
Get the last part of an articulated engine.
T * GetFirstEnginePart()
Get the first part of an articulated engine.
SpecializedVehicle< T, Type > SpecializedVehicleBase
Our type.
T * Last()
Get the last vehicle in the chain.
static const VehicleType EXPECTED_TYPE
Specialized type.
const T * Last() const
Get the last vehicle in the chain.
Station data structure.
Cached often queried values common to all vehicles.
uint8_t cached_vis_effect
Visual effect to show (see VisualEffect)
uint16_t cached_cargo_age_period
Number of ticks before carried cargo is aged.
uint16_t cached_max_speed
Maximum speed of the consist (minimum of the max speed of all vehicles in the consist).
Sprite sequence for a vehicle part.
bool IsValid() const
Check whether the sequence contains any sprites.
void GetBounds(Rect *bounds) const
Determine shared bounds of all sprites.
Definition vehicle.cpp:114
void Set(SpriteID sprite)
Assign a single sprite to the sequence.
void Clear()
Clear all information.
void CopyWithoutPalette(const VehicleSpriteSeq &src)
Copy data from another sprite sequence, while dropping all recolouring information.
void Draw(int x, int y, PaletteID default_pal, bool force_pal) const
Draw the sprite sequence.
Definition vehicle.cpp:142
Vehicle data structure.
Money GetDisplayProfitThisYear() const
Gets the profit vehicle had this year.
CargoPayment * cargo_payment
The cargo payment we're currently in.
EngineID engine_type
The type of engine used for this vehicle.
uint16_t cargo_age_counter
Ticks till cargo is aged next.
virtual int GetDisplaySpeed() const
Gets the speed in km-ish/h that can be sent into string parameters for string processing.
static uint GetAdvanceSpeed(uint speed)
Determines the effective vehicle movement speed.
int32_t z_pos
z coordinate.
uint16_t & GetGroundVehicleFlags()
Access the ground vehicle flags of the vehicle.
Definition vehicle.cpp:3146
Direction direction
facing
void ShiftDates(TimerGameEconomy::Date interval)
Shift all dates by given interval.
Definition vehicle.cpp:748
const Order * GetLastOrder() const
Returns the last order of a vehicle, or nullptr if it doesn't exists.
friend void AfterLoadVehiclesPhase1(bool part_of_load)
So we can set the previous and first pointers while loading.
StationIDStack GetNextStoppingStation() const
Get the next station the vehicle will stop at.
TimerGameEconomy::Date economy_age
Age in economy days.
bool IsOrderListShared() const
Check if we share our orders with another vehicle.
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition vehicle.cpp:718
void IncrementRealOrderIndex()
Advanced cur_real_order_index to the next real order, keeps care of the wrap-around and invalidates t...
virtual uint Crash(bool flooded=false)
Crash the (whole) vehicle chain.
Definition vehicle.cpp:291
bool IsStoppedInDepot() const
Check whether the vehicle is in the depot and stopped.
virtual ExpensesType GetExpenseType(bool income) const
Sets the expense type associated to this vehicle type.
Vehicle * GetNextArticulatedPart() const
Get the next part of an articulated engine.
Order * GetOrder(int index) const
Returns order 'index' of a vehicle or nullptr when it doesn't exists.
bool HasDepotOrder() const
Checks if a vehicle has a depot in its order list.
friend void FixOldVehicles(LoadgameState &ls)
Convert the old style vehicles into something that resembles the old new style savegames.
void LeaveStation()
Perform all actions when leaving a station.
Definition vehicle.cpp:2316
virtual bool IsChainInDepot() const
Check whether the whole vehicle chain is in the depot.
void AddToShared(Vehicle *shared_chain)
Adds this vehicle to a shared vehicle chain.
Definition vehicle.cpp:2929
VehicleCargoList cargo
The cargo this vehicle is carrying.
uint8_t x_extent
x-extent of vehicle bounding box
Vehicle ** hash_tile_prev
NOSAVE: Previous vehicle in the tile location hash.
bool HasUnbunchingOrder() const
Check if the current vehicle has an unbunching order.
Definition vehicle.cpp:2451
TimerGameEconomy::Date date_of_last_service
Last economy date the vehicle had a service at a depot.
uint16_t cargo_cap
total capacity
StationID last_loading_station
Last station the vehicle has stopped at and could possibly leave from with any cargo loaded.
VehicleOrderID GetNumOrders() const
Get the number of orders this vehicle has.
Vehicle * GetFirstEnginePart()
Get the first part of an articulated engine.
uint8_t subtype
subtype (Filled with values from AircraftSubType/DisasterSubType/EffectVehicleType/GroundVehicleSubty...
const Order * GetFirstOrder() const
Get the first order of the vehicles order list.
CommandCost SendToDepot(DoCommandFlags flags, DepotCommandFlags command)
Send this vehicle to the depot using the given command(s).
Definition vehicle.cpp:2544
friend bool LoadOldVehicle(LoadgameState &ls, int num)
So we can set the proper next pointer while loading.
virtual void UpdateDeltaXY()
Updates the x and y offsets and the size of the sprite used for this vehicle.
Vehicle * Last()
Get the last vehicle of this vehicle chain.
uint16_t random_bits
Bits used for randomized variational spritegroups.
void ReleaseUnitNumber()
Release the vehicle's unit number.
Definition vehicle.cpp:2385
void UpdateBoundingBoxCoordinates(bool update_cache) const
Update the bounding box co-ordinates of the vehicle.
Definition vehicle.cpp:1672
uint8_t day_counter
Increased by one for each day.
void HandleLoading(bool mode=false)
Handle the loading of the vehicle; when not it skips through dummy orders and does nothing in all oth...
Definition vehicle.cpp:2396
Money profit_this_year
Profit this year << 8, low 8 bits are fract.
bool HasArticulatedPart() const
Check if an engine has an articulated part.
SpriteID colourmap
NOSAVE: cached colour mapping.
uint8_t breakdown_ctr
Counter for managing breakdown events.
uint GetOldAdvanceSpeed(uint speed)
Determines the effective direction-specific vehicle movement speed.
uint8_t breakdown_delay
Counter for managing breakdown length.
Vehicle * GetNextVehicle() const
Get the next real (non-articulated part) vehicle in the consist.
uint GetAdvanceDistance()
Determines the vehicle "progress" needed for moving a step.
GroupID group_id
Index of group Pool array.
const Vehicle * Move(int n) const
Get the vehicle at offset n of this vehicle chain.
virtual int GetDisplayMaxSpeed() const
Gets the maximum speed in km-ish/h that can be sent into string parameters for string processing.
void IncrementImplicitOrderIndex()
Increments cur_implicit_order_index, keeps care of the wrap-around and invalidates the GUI.
uint8_t z_extent
z-extent of vehicle bounding box
VehStates vehstatus
Status.
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...
Vehicle * first
NOSAVE: pointer to the first vehicle in the chain.
void CancelReservation(StationID next, Station *st)
Return all reserved cargo packets to the station and reset all packets staged for transfer.
Definition vehicle.cpp:2300
Money profit_last_year
Profit last year << 8, low 8 bits are fract.
bool IsEngineCountable() const
Check if a vehicle is counted in num_engines in each company struct.
Definition vehicle.cpp:685
virtual ~Vehicle()
We want to 'destruct' the right class.
Definition vehicle.cpp:863
uint8_t subspeed
fractional speed
bool IsArticulatedPart() const
Check if the vehicle is an articulated part of an engine.
bool NeedsAutorenewing(const Company *c, bool use_renew_setting=true) const
Function to tell if a vehicle needs to be autorenewed.
Definition vehicle.cpp:156
void UpdateVisualEffect(bool allow_power_change=true)
Update the cached visual effect.
Definition vehicle.cpp:2625
void LeaveUnbunchingDepot()
Leave an unbunching depot and calculate the next departure time for shared order vehicles.
Definition vehicle.cpp:2475
Vehicle * Move(int n)
Get the vehicle at offset n of this vehicle chain.
int8_t y_offs
y offset for vehicle sprite
CargoType cargo_type
type of cargo this vehicle is carrying
debug_inline bool IsFrontEngine() const
Check if the vehicle is a front engine.
uint8_t acceleration
used by train & aircraft
Vehicle * previous_shared
NOSAVE: pointer to the previous vehicle in the shared order chain.
VehicleOrderID GetNumManualOrders() const
Get the number of manually added orders this vehicle has.
Vehicle * First() const
Get the first vehicle of this vehicle chain.
int8_t trip_occupancy
NOSAVE: Occupancy of vehicle of the current trip (updated after leaving a station).
virtual TileIndex GetOrderStationLocation(StationID station)
Determine the location for the station where the vehicle goes to next.
int8_t x_bb_offs
x offset of vehicle bounding box
Order current_order
The current order (+ status, like: loading)
void PreDestructor()
Destroy all stuff that (still) needs the virtual functions to work properly.
Definition vehicle.cpp:796
TimerGameTick::TickCounter last_loading_tick
Last TimerGameTick::counter tick that the vehicle has stopped at a station and could possibly leave w...
void HandlePathfindingResult(bool path_found)
Handle the pathfinding result, especially the lost status.
Definition vehicle.cpp:762
Vehicle * Next() const
Get the next vehicle of this vehicle.
int8_t x_offs
x offset for vehicle sprite
int32_t y_pos
y coordinate.
int32_t x_pos
x coordinate.
const GRFFile * GetGRF() const
Retrieve the NewGRF the vehicle is tied to.
Definition vehicle.cpp:728
OrderList * orders
Pointer to the order list for this vehicle.
uint32_t GetDisplayMinPowerToWeight() const
Calculates the minimum power-to-weight ratio using the maximum weight of the ground vehicle.
Definition vehicle.cpp:3220
uint8_t y_extent
y-extent of vehicle bounding box
virtual ClosestDepot FindClosestDepot()
Find the closest depot for this vehicle and tell us the location, DestinationID and whether we should...
void UpdateViewport(bool dirty)
Update the vehicle on the viewport, updating the right hash and setting the new coordinates.
Definition vehicle.cpp:1705
Money value
Value of the vehicle.
bool MarkAllViewportsDirty() const
Marks viewports dirty where the vehicle's image is.
Definition vehicle.cpp:1744
uint16_t refit_cap
Capacity left over from before last refit.
void InvalidateNewGRFCache()
Invalidates cached NewGRF variables.
VehicleRandomTriggers waiting_random_triggers
Triggers to be yet matched before rerandomizing the random bits.
VehicleCache vcache
Cache of often used vehicle values.
Vehicle * GetLastEnginePart()
Get the last part of an articulated engine.
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.
Definition vehicle.cpp:738
GroundVehicleCache * GetGroundVehicleCache()
Access the ground vehicle cache of the vehicle.
Definition vehicle.cpp:3116
virtual void OnNewEconomyDay()
Calls the new economy day handler of the vehicle.
Vehicle ** hash_tile_current
NOSAVE: Cache of the current hash chain.
virtual void OnNewCalendarDay()
Calls the new calendar day handler of the vehicle.
Vehicle * NextShared() const
Get the next vehicle of the shared vehicle chain.
int8_t y_bb_offs
y offset of vehicle bounding box
virtual int GetCurrentMaxSpeed() const
Calculates the maximum speed of the vehicle under its current conditions.
bool HasFullLoadOrder() const
Check if the current vehicle has a full load order.
Definition vehicle.cpp:2431
virtual bool IsPrimaryVehicle() const
Whether this is the primary vehicle in the chain.
void BeginLoading()
Prepare everything to begin the loading when arriving at a station.
Definition vehicle.cpp:2172
uint32_t old_orders
Only used during conversion of old save games.
uint16_t load_unload_ticks
Ticks to wait before starting next cycle.
Money GetDisplayProfitLastYear() const
Gets the profit vehicle had last year.
Vehicle * hash_tile_next
NOSAVE: Next vehicle in the tile location hash.
uint8_t spritenum
currently displayed sprite index 0xfd == custom sprite, 0xfe == custom second head sprite 0xff == res...
uint16_t cur_speed
current speed
Vehicle * previous
NOSAVE: pointer to the previous vehicle in the chain.
uint8_t cargo_subtype
Used for livery refits (NewGRF variations)
bool HasEngineType() const
Check whether Vehicle::engine_type has any meaning.
Definition vehicle.cpp:702
TimerGameCalendar::Date age
Age in calendar days.
bool IsWaitingForUnbunching() const
Check whether a vehicle inside a depot is waiting for unbunching.
Definition vehicle.cpp:2522
TextEffectID fill_percent_te_id
a text-effect id to a loading indicator object
Money GetDisplayRunningCost() const
Gets the running cost of a vehicle that can be sent into string parameters for string processing.
void SetNext(Vehicle *next)
Set the next vehicle of this vehicle.
Definition vehicle.cpp:2900
uint8_t breakdowns_since_last_service
Counter for the amount of breakdowns.
Vehicle * next
pointer to the next vehicle in the chain
TimerGameCalendar::Date max_age
Maximum age.
MutableSpriteCache sprite_cache
Cache of sprites and values related to recalculating them, see MutableSpriteCache.
uint16_t reliability
Reliability.
uint32_t GetDisplayMaxWeight() const
Calculates the maximum weight of the ground vehicle when loaded.
Definition vehicle.cpp:3205
const Vehicle * Last() const
Get the last vehicle of this vehicle chain.
Vehicle * PreviousShared() const
Get the previous vehicle of the shared vehicle chain.
Vehicle * FirstShared() const
Get the first vehicle of this vehicle chain.
void RemoveFromShared()
Removes the vehicle from the shared order list.
Definition vehicle.cpp:2952
bool HandleBreakdown()
Handle all of the aspects of a vehicle breakdown This includes adding smoke and sounds,...
Definition vehicle.cpp:1333
debug_inline bool IsGroundVehicle() const
Check if the vehicle is a ground vehicle.
uint8_t progress
The percentage (if divided by 256) this vehicle already crossed the tile unit.
void UpdatePositionAndViewport()
Update the position of the vehicle, and update the viewport.
Definition vehicle.cpp:1734
Vehicle * Previous() const
Get the previous vehicle of this vehicle.
virtual void PlayLeaveStationSound(bool force=false) const
Play the sound associated with leaving the station.
Vehicle * GetPrevVehicle() const
Get the previous real (non-articulated part) vehicle in the consist.
Rect coord
NOSAVE: Graphical bounding box of the vehicle, i.e. what to redraw on moves.
uint16_t reliability_spd_dec
Reliability decrease speed.
uint8_t tick_counter
Increased by one for each tick.
void SkipToNextRealOrderIndex()
Advance cur_real_order_index to the next real order.
virtual bool IsInDepot() const
Check whether the vehicle is in the depot.
TileIndex tile
Current tile index.
virtual bool Tick()
Calls the tick handler of the vehicle.
TileIndex dest_tile
Heading for this tile.
void CopyVehicleConfigAndStatistics(Vehicle *src)
Copy certain configurations and statistics of a vehicle after successful autoreplace/renew The functi...
bool NeedsServicing() const
Check if the vehicle needs to go to a depot in near future (if a opportunity presents itself) for ser...
Definition vehicle.cpp:201
bool HasConditionalOrder() const
Check if the current vehicle has a conditional order.
Definition vehicle.cpp:2442
virtual uint16_t GetMaxWeight() const
Calculates the weight value that this vehicle will have when fully loaded with its current cargo.
void UpdatePosition()
Update the position of the vehicle.
Definition vehicle.cpp:1663
virtual Money GetRunningCost() const
Gets the running cost of a vehicle.
StationID last_station_visited
The last station we stopped at.
void ResetRefitCaps()
Reset all refit_cap in the consist to cargo_cap.
Definition vehicle.cpp:2377
void InvalidateNewGRFCacheOfChain()
Invalidates cached NewGRF variables of all vehicles in the chain (after the current vehicle)
uint8_t breakdown_chance
Current chance of breakdowns.
void ShowVisualEffect() const
Draw visual effects (smoke and/or sparks) for a vehicle chain.
Definition vehicle.cpp:2750
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
Vehicle * next_shared
pointer to the next vehicle that shares the order
bool NeedsAutomaticServicing() const
Checks if the current order should be interrupted for a service-in-depot order.
Definition vehicle.cpp:283
void DeleteUnreachedImplicitOrders()
Delete all implicit orders which were not reached.
Definition vehicle.cpp:2134
uint8_t running_ticks
Number of ticks this vehicle was not stopped this day.
Vehicle ** hash_viewport_prev
NOSAVE: Previous vehicle in the visual location hash.
virtual void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const
Gets the sprite to show for the given direction.
Vehicle * hash_viewport_next
NOSAVE: Next vehicle in the visual location hash.
virtual Trackdir GetVehicleTrackdir() const
Returns the Trackdir on which the vehicle is currently located.
void UpdateRealOrderIndex()
Skip implicit orders until cur_real_order_index is a non-implicit order.
const Vehicle * GetFirstEnginePart() const
Get the first part of an articulated engine.
Functions related to text effects.
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition tile_type.h:95
Definition of the game-calendar-timer.
All types related to tracks.
Trackdir
Enumeration for tracks and directions.
Definition track_type.h:66
@ INVALID_TRACKDIR
Flag for an invalid trackdir.
Definition track_type.h:85
Base types related to transport.
uint16_t UnitID
Type for the company global vehicle unit number.
VehiclePool _vehicle_pool("Vehicle")
The pool with all our precious vehicles.
void FixOldVehicles(LoadgameState &ls)
Convert the old style vehicles into something that resembles the old new style savegames.
bool LoadOldVehicle(LoadgameState &ls, int num)
Load the vehicles of an old style savegame.
VisualEffect
Meaning of the various bits of the visual effect.
@ VE_TYPE_DEFAULT
Use default from engine class.
@ VE_TYPE_COUNT
Number of bits used for the effect type.
@ VE_OFFSET_CENTRE
Value of offset corresponding to a position above the centre of the vehicle.
@ VE_TYPE_ELECTRIC
Electric sparks.
@ VE_TYPE_START
First bit used for the type of effect.
@ VE_OFFSET_COUNT
Number of bits used for the offset.
@ VE_ADVANCED_EFFECT
Flag for advanced effects.
@ VE_DISABLE_EFFECT
Flag to disable visual effect.
@ VE_TYPE_STEAM
Steam plumes.
@ VE_TYPE_DIESEL
Diesel fumes.
@ VE_DEFAULT
Default value to indicate that visual effect should be based on engine class.
@ VE_OFFSET_START
First bit that contains the offset (0 = front, 8 = centre, 15 = rear)
@ VE_DISABLE_WAGON_POWER
Flag to disable wagon power.
VehState
Vehicle state bits in Vehicle::vehstatus.
@ Unclickable
Vehicle is not clickable by the user (shadow vehicles).
@ Crashed
Vehicle is crashed.
@ Shadow
Vehicle is a shadow vehicle.
@ TrainSlowing
Train is slowing down.
@ AircraftBroken
Aircraft is broken down.
@ Hidden
Vehicle is not visible.
@ DefaultPalette
Use default vehicle palette.
@ Stopped
Vehicle is stopped by the player.
GroundVehicleSubtypeFlags
Enum to handle ground vehicle subtypes.
@ GVSF_ARTICULATED_PART
Articulated part of an engine.
@ GVSF_FRONT
Leading engine of a consist.
@ GVSF_MULTIHEADED
Engine is multiheaded (not used for road vehicles).
@ GVSF_FREE_WAGON
First in a wagon chain (in depot) (not used for road vehicles).
@ GVSF_WAGON
Wagon (not used for road vehicles).
@ GVSF_ENGINE
Engine that can be front engine, but might be placed behind another engine (not used for road vehicle...
VisualEffectSpawnModel
Models for spawning visual effects.
@ VESM_ELECTRIC
Electric model.
@ VESM_STEAM
Steam model.
@ VESM_DIESEL
Diesel model.
@ VESM_NONE
No visual effect.
Pool< Vehicle, VehicleID, 512 > VehiclePool
A vehicle pool for a little over 1 million vehicles.
NewGRFCacheValidValues
Bit numbers used to indicate which of the NewGRFCache values are valid.
@ 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.
static const int32_t INVALID_COORD
Sentinel for an invalid coordinate.
EngineImageType
Visualisation contexts of vehicles and engines.
@ EIT_ON_MAP
Vehicle drawn in viewport.
VehicleType
Available vehicle types.
@ VEH_INVALID
Non-existing type of vehicle.
@ VEH_ROAD
Road vehicle type.
@ VEH_TRAIN
Train vehicle type.