OpenTTD Source: src/vehicle_base.h Source File

OpenTTD Source 13.2.1

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 "core/smallmap_type.hpp"
14 #include "track_type.h"
15 #include "command_type.h"
16 #include "order_base.h"
17 #include "cargopacket.h"
18 #include "texteff.hpp"
19 #include "engine_type.h"
20 #include "order_func.h"
21 #include "transport_type.h"
22 #include "group_type.h"
23 #include "base_consist.h"
24 #include "network/network.h"
25 #include "saveload/saveload.h"
26 #include <list>
27 #include <map>
28
29 const uint TILE_AXIAL_DISTANCE = 192; // Logical length of the tile in any DiagDirection used in vehicle movement.
30 const uint TILE_CORNER_DISTANCE = 128; // Logical length of the tile corner crossing in any non-diagonal direction used in vehicle movement.
31
33 enum VehStatus {
34 VS_HIDDEN = 0x01,
35 VS_STOPPED = 0x02,
36 VS_UNCLICKABLE = 0x04,
37 VS_DEFPAL = 0x08,
38 VS_TRAIN_SLOWING = 0x10,
39 VS_SHADOW = 0x20,
40 VS_AIRCRAFT_BROKEN = 0x40,
41 VS_CRASHED = 0x80,
42 };
43
45 enum VehicleFlags {
46 VF_LOADING_FINISHED,
47 VF_CARGO_UNLOADING,
48 VF_BUILT_AS_PROTOTYPE,
49 VF_TIMETABLE_STARTED,
50 VF_AUTOFILL_TIMETABLE,
51 VF_AUTOFILL_PRES_WAIT_TIME,
52 VF_STOP_LOADING,
53 VF_PATHFINDER_LOST,
54 VF_SERVINT_IS_CUSTOM,
55 VF_SERVINT_IS_PERCENT,
56 };
57
59 enum NewGRFCacheValidValues {
60 NCVV_POSITION_CONSIST_LENGTH = 0,
61 NCVV_POSITION_SAME_ID_LENGTH = 1,
62 NCVV_CONSIST_CARGO_INFORMATION = 2,
63 NCVV_COMPANY_INFORMATION = 3,
64 NCVV_POSITION_IN_VEHICLE = 4,
65 NCVV_END,
66 };
67
69 struct NewGRFCache {
70 /* Values calculated when they are requested for the first time after invalidating the NewGRF cache. */
71 uint32 position_consist_length;
72 uint32 position_same_id_length;
73 uint32 consist_cargo_information;
74 uint32 company_information;
75 uint32 position_in_vehicle;
76 uint8 cache_valid;
77 };
78
80 enum VisualEffect {
81 VE_OFFSET_START = 0,
82 VE_OFFSET_COUNT = 4,
83 VE_OFFSET_CENTRE = 8,
84
85 VE_TYPE_START = 4,
86 VE_TYPE_COUNT = 2,
87 VE_TYPE_DEFAULT = 0,
88 VE_TYPE_STEAM = 1,
89 VE_TYPE_DIESEL = 2,
90 VE_TYPE_ELECTRIC = 3,
91
92 VE_DISABLE_EFFECT = 6,
93 VE_ADVANCED_EFFECT = VE_DISABLE_EFFECT,
94 VE_DISABLE_WAGON_POWER = 7,
95
96 VE_DEFAULT = 0xFF,
97 };
98
100 enum VisualEffectSpawnModel {
101 VESM_NONE = 0,
102 VESM_STEAM,
103 VESM_DIESEL,
104 VESM_ELECTRIC,
105
106 VESM_END
107 };
108
114 enum GroundVehicleSubtypeFlags {
115 GVSF_FRONT = 0,
116 GVSF_ARTICULATED_PART = 1,
117 GVSF_WAGON = 2,
118 GVSF_ENGINE = 3,
119 GVSF_FREE_WAGON = 4,
120 GVSF_MULTIHEADED = 5,
121 };
122
124 struct VehicleCache {
125 uint16 cached_max_speed;
126 uint16 cached_cargo_age_period;
127
128 byte cached_vis_effect;
129 };
130
132 struct VehicleSpriteSeq {
133 PalSpriteID seq[8];
134 uint count;
135
136 bool operator==(const VehicleSpriteSeq &other) const
137 {
138 return this->count == other.count && MemCmpT<PalSpriteID>(this->seq, other.seq, this->count) == 0;
139 }
140
141 bool operator!=(const VehicleSpriteSeq &other) const
142 {
143 return !this->operator==(other);
144 }
145
149 bool IsValid() const
150 {
151 return this->count != 0;
152 }
153
157 void Clear()
158 {
159 this->count = 0;
160 }
161
165 void Set(SpriteID sprite)
166 {
167 this->count = 1;
168 this->seq[0].sprite = sprite;
169 this->seq[0].pal = 0;
170 }
171
175 void CopyWithoutPalette(const VehicleSpriteSeq &src)
176 {
177 this->count = src.count;
178 for (uint i = 0; i < src.count; ++i) {
179 this->seq[i].sprite = src.seq[i].sprite;
180 this->seq[i].pal = 0;
181 }
182 }
183
184 void GetBounds(Rect *bounds) const;
185 void Draw(int x, int y, PaletteID default_pal, bool force_pal) const;
186 };
187
192 struct MutableSpriteCache {
193 Direction last_direction;
194 bool revalidate_before_draw;
195 Rect old_coord;
196 bool is_viewport_candidate;
197 VehicleSpriteSeq sprite_seq;
198 };
199
201 typedef Pool<Vehicle, VehicleID, 512, 0xFF000> VehiclePool;
202 extern VehiclePool _vehicle_pool;
203
204 /* Some declarations of functions, so we can make them friendly */
205 struct GroundVehicleCache;
206 struct LoadgameState;
207 extern bool LoadOldVehicle(LoadgameState *ls, int num);
208 extern void FixOldVehicles();
209
210 struct GRFFile;
211
215 struct RefitDesc {
216 CargoID cargo;
217 uint16 capacity;
218 uint16 remaining;
219 RefitDesc(CargoID cargo, uint16 capacity, uint16 remaining) :
220 cargo(cargo), capacity(capacity), remaining(remaining) {}
221 };
222
224 struct Vehicle : VehiclePool::PoolItem<&_vehicle_pool>, BaseVehicle, BaseConsist {
225 private:
226 typedef std::list<RefitDesc> RefitList;
227 typedef std::map<CargoID, uint> CapacitiesMap;
228
229 Vehicle *next;
230 Vehicle *previous;
231 Vehicle *first;
232
233 Vehicle *next_shared;
234 Vehicle *previous_shared;
235
236 public:
237 friend void FixOldVehicles();
238 friend void AfterLoadVehicles(bool part_of_load);
239 friend bool LoadOldVehicle(LoadgameState *ls, int num);
240 /* So we can use private/protected variables in the saveload code */
241 friend class SlVehicleCommon;
242 friend class SlVehicleDisaster;
243 friend void Ptrs_VEHS();
244
245 TileIndex tile;
246
252 TileIndex dest_tile;
253
254 Money profit_this_year;
255 Money profit_last_year;
256 Money value;
257
258 CargoPayment *cargo_payment;
259
260 mutable Rect coord;
261
262 Vehicle *hash_viewport_next;
263 Vehicle **hash_viewport_prev;
264
265 Vehicle *hash_tile_next;
266 Vehicle **hash_tile_prev;
267 Vehicle **hash_tile_current;
268
269 SpriteID colourmap;
270
271 /* Related to age and service time */
272 Year build_year;
273 Date age;
274 Date max_age;
275 Date date_of_last_service;
276 uint16 reliability;
277 uint16 reliability_spd_dec;
278 byte breakdown_ctr;
279 byte breakdown_delay;
280 byte breakdowns_since_last_service;
281 byte breakdown_chance;
282
283 int32 x_pos;
284 int32 y_pos;
285 int32 z_pos;
286 Direction direction;
287
288 Owner owner;
289
294 byte spritenum;
295 byte x_extent;
296 byte y_extent;
297 byte z_extent;
298 int8 x_bb_offs;
299 int8 y_bb_offs;
300 int8 x_offs;
301 int8 y_offs;
302 EngineID engine_type;
303
304 TextEffectID fill_percent_te_id;
305 UnitID unitnumber;
306
307 uint16 cur_speed;
308 byte subspeed;
309 byte acceleration;
310 uint32 motion_counter;
311 byte progress;
312
313 byte random_bits;
314 byte waiting_triggers;
315
316 StationID last_station_visited;
317 StationID last_loading_station;
318 uint64_t last_loading_tick;
319
320 CargoID cargo_type;
321 byte cargo_subtype;
322 uint16 cargo_cap;
323 uint16 refit_cap;
324 VehicleCargoList cargo;
325 uint16 cargo_age_counter;
326 int8 trip_occupancy;
327
328 byte day_counter;
329 byte tick_counter;
330 byte running_ticks;
331
332 byte vehstatus;
333 Order current_order;
334
335 union {
336 OrderList *orders;
337 Order *old_orders;
338 };
339
340 uint16 load_unload_ticks;
341 GroupID group_id;
342 byte subtype;
343
344 NewGRFCache grf_cache;
345 VehicleCache vcache;
346
347 mutable MutableSpriteCache sprite_cache;
348
353 virtual uint16 GetMaxWeight() const
354 {
355 return 0;
356 }
357
358 Vehicle(VehicleType type = VEH_INVALID);
359
360 void PreDestructor();
362 virtual ~Vehicle();
363
364 void BeginLoading();
365 void CancelReservation(StationID next, Station *st);
366 void LeaveStation();
367
368 GroundVehicleCache *GetGroundVehicleCache();
369 const GroundVehicleCache *GetGroundVehicleCache() const;
370
371 uint16 &GetGroundVehicleFlags();
372 const uint16 &GetGroundVehicleFlags() const;
373
374 void DeleteUnreachedImplicitOrders();
375
376 void HandleLoading(bool mode = false);
377
378 void GetConsistFreeCapacities(SmallMap<CargoID, uint> &capacities) const;
379
380 uint GetConsistTotalCapacity() const;
381
390 virtual void MarkDirty() {}
391
396 virtual void UpdateDeltaXY() {}
397
411 inline uint GetOldAdvanceSpeed(uint speed)
412 {
413 return (this->direction & 1) ? speed : speed * 3 / 4;
414 }
415
428 static inline uint GetAdvanceSpeed(uint speed)
429 {
430 return speed * 3 / 4;
431 }
432
440 inline uint GetAdvanceDistance()
441 {
442 return (this->direction & 1) ? TILE_AXIAL_DISTANCE : TILE_CORNER_DISTANCE * 2;
443 }
444
449 virtual ExpensesType GetExpenseType(bool income) const { return EXPENSES_OTHER; }
450
455 virtual void PlayLeaveStationSound(bool force = false) const {}
456
460 virtual bool IsPrimaryVehicle() const { return false; }
461
462 const Engine *GetEngine() const;
463
469 virtual void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const { result->Clear(); }
470
471 const GRFFile *GetGRF() const;
472 uint32 GetGRFID() const;
473
478 inline void InvalidateNewGRFCache()
479 {
480 this->grf_cache.cache_valid = 0;
481 }
482
487 inline void InvalidateNewGRFCacheOfChain()
488 {
489 for (Vehicle *u = this; u != nullptr; u = u->Next()) {
490 u->InvalidateNewGRFCache();
491 }
492 }
493
498 inline bool IsGroundVehicle() const
499 {
500 return this->type == VEH_TRAIN || this->type == VEH_ROAD;
501 }
502
507 virtual int GetDisplaySpeed() const { return 0; }
508
513 virtual int GetDisplayMaxSpeed() const { return 0; }
514
519 virtual int GetCurrentMaxSpeed() const { return 0; }
520
525 virtual Money GetRunningCost() const { return 0; }
526
531 virtual bool IsInDepot() const { return false; }
532
537 virtual bool IsChainInDepot() const { return this->IsInDepot(); }
538
543 bool IsStoppedInDepot() const
544 {
545 assert(this == this->First());
546 /* Free wagons have no VS_STOPPED state */
547 if (this->IsPrimaryVehicle() && !(this->vehstatus & VS_STOPPED)) return false;
548 return this->IsChainInDepot();
549 }
550
555 virtual bool Tick() { return true; };
556
560 virtual void OnNewDay() {};
561
562 void ShiftDates(int interval);
563
569 virtual uint Crash(bool flooded = false);
570
583 virtual Trackdir GetVehicleTrackdir() const { return INVALID_TRACKDIR; }
584
589 Money GetDisplayRunningCost() const { return (this->GetRunningCost() >> 8); }
590
595 Money GetDisplayProfitThisYear() const { return (this->profit_this_year >> 8); }
596
601 Money GetDisplayProfitLastYear() const { return (this->profit_last_year >> 8); }
602
603 void SetNext(Vehicle *next);
604
610 inline Vehicle *Next() const { return this->next; }
611
617 inline Vehicle *Previous() const { return this->previous; }
618
623 inline Vehicle *First() const { return this->first; }
624
629 inline Vehicle *Last()
630 {
631 Vehicle *v = this;
632 while (v->Next() != nullptr) v = v->Next();
633 return v;
634 }
635
640 inline const Vehicle *Last() const
641 {
642 const Vehicle *v = this;
643 while (v->Next() != nullptr) v = v->Next();
644 return v;
645 }
646
652 inline Vehicle *Move(int n)
653 {
654 Vehicle *v = this;
655 if (n < 0) {
656 for (int i = 0; i != n && v != nullptr; i--) v = v->Previous();
657 } else {
658 for (int i = 0; i != n && v != nullptr; i++) v = v->Next();
659 }
660 return v;
661 }
662
668 inline const Vehicle *Move(int n) const
669 {
670 const Vehicle *v = this;
671 if (n < 0) {
672 for (int i = 0; i != n && v != nullptr; i--) v = v->Previous();
673 } else {
674 for (int i = 0; i != n && v != nullptr; i++) v = v->Next();
675 }
676 return v;
677 }
678
683 inline Order *GetFirstOrder() const { return (this->orders == nullptr) ? nullptr : this->orders->GetFirstOrder(); }
684
685 void AddToShared(Vehicle *shared_chain);
686 void RemoveFromShared();
687
692 inline Vehicle *NextShared() const { return this->next_shared; }
693
698 inline Vehicle *PreviousShared() const { return this->previous_shared; }
699
704 inline Vehicle *FirstShared() const { return (this->orders == nullptr) ? this->First() : this->orders->GetFirstSharedVehicle(); }
705
710 inline bool IsOrderListShared() const { return this->orders != nullptr && this->orders->IsShared(); }
711
716 inline VehicleOrderID GetNumOrders() const { return (this->orders == nullptr) ? 0 : this->orders->GetNumOrders(); }
717
722 inline VehicleOrderID GetNumManualOrders() const { return (this->orders == nullptr) ? 0 : this->orders->GetNumManualOrders(); }
723
728 inline StationIDStack GetNextStoppingStation() const
729 {
730 return (this->orders == nullptr) ? INVALID_STATION : this->orders->GetNextStoppingStation(this);
731 }
732
733 void ResetRefitCaps();
734
741 inline void CopyVehicleConfigAndStatistics(const Vehicle *src)
742 {
743 this->CopyConsistPropertiesFrom(src);
744
745 this->unitnumber = src->unitnumber;
746
747 this->current_order = src->current_order;
748 this->dest_tile = src->dest_tile;
749
750 this->profit_this_year = src->profit_this_year;
751 this->profit_last_year = src->profit_last_year;
752 }
753
754
755 bool HandleBreakdown();
756
757 bool NeedsAutorenewing(const Company *c, bool use_renew_setting = true) const;
758
759 bool NeedsServicing() const;
760 bool NeedsAutomaticServicing() const;
761
769 virtual TileIndex GetOrderStationLocation(StationID station) { return INVALID_TILE; }
770
779 virtual bool FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse) { return false; }
780
781 virtual void SetDestTile(TileIndex tile) { this->dest_tile = tile; }
782
783 CommandCost SendToDepot(DoCommandFlag flags, DepotCommand command);
784
785 void UpdateVisualEffect(bool allow_power_change = true);
786 void ShowVisualEffect() const;
787
788 void UpdatePosition();
789 void UpdateViewport(bool dirty);
790 void UpdateBoundingBoxCoordinates(bool update_cache) const;
791 void UpdatePositionAndViewport();
792 bool MarkAllViewportsDirty() const;
793
794 inline uint16 GetServiceInterval() const { return this->service_interval; }
795
796 inline void SetServiceInterval(uint16 interval) { this->service_interval = interval; }
797
798 inline bool ServiceIntervalIsCustom() const { return HasBit(this->vehicle_flags, VF_SERVINT_IS_CUSTOM); }
799
800 inline bool ServiceIntervalIsPercent() const { return HasBit(this->vehicle_flags, VF_SERVINT_IS_PERCENT); }
801
802 inline void SetServiceIntervalIsCustom(bool on) { SB(this->vehicle_flags, VF_SERVINT_IS_CUSTOM, 1, on); }
803
804 inline void SetServiceIntervalIsPercent(bool on) { SB(this->vehicle_flags, VF_SERVINT_IS_PERCENT, 1, on); }
805
806 private:
811 void SkipToNextRealOrderIndex()
812 {
813 if (this->GetNumManualOrders() > 0) {
814 /* Advance to next real order */
815 do {
816 this->cur_real_order_index++;
817 if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
818 } while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT));
819 } else {
820 this->cur_real_order_index = 0;
821 }
822 }
823
824 public:
830 void IncrementImplicitOrderIndex()
831 {
832 if (this->cur_implicit_order_index == this->cur_real_order_index) {
833 /* Increment real order index as well */
834 this->SkipToNextRealOrderIndex();
835 }
836
837 assert(this->cur_real_order_index == 0 || this->cur_real_order_index < this->GetNumOrders());
838
839 /* Advance to next implicit order */
840 do {
841 this->cur_implicit_order_index++;
842 if (this->cur_implicit_order_index >= this->GetNumOrders()) this->cur_implicit_order_index = 0;
843 } while (this->cur_implicit_order_index != this->cur_real_order_index && !this->GetOrder(this->cur_implicit_order_index)->IsType(OT_IMPLICIT));
844
845 InvalidateVehicleOrder(this, 0);
846 }
847
854 void IncrementRealOrderIndex()
855 {
856 if (this->cur_implicit_order_index == this->cur_real_order_index) {
857 /* Increment both real and implicit order */
858 this->IncrementImplicitOrderIndex();
859 } else {
860 /* Increment real order only */
861 this->SkipToNextRealOrderIndex();
862 InvalidateVehicleOrder(this, 0);
863 }
864 }
865
869 void UpdateRealOrderIndex()
870 {
871 /* Make sure the index is valid */
872 if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
873
874 if (this->GetNumManualOrders() > 0) {
875 /* Advance to next real order */
876 while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT)) {
877 this->cur_real_order_index++;
878 if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
879 }
880 } else {
881 this->cur_real_order_index = 0;
882 }
883 }
884
890 inline Order *GetOrder(int index) const
891 {
892 return (this->orders == nullptr) ? nullptr : this->orders->GetOrderAt(index);
893 }
894
899 inline Order *GetLastOrder() const
900 {
901 return (this->orders == nullptr) ? nullptr : this->orders->GetLastOrder();
902 }
903
904 bool IsEngineCountable() const;
905 bool HasEngineType() const;
906 bool HasDepotOrder() const;
907 void HandlePathfindingResult(bool path_found);
908
913 inline bool IsFrontEngine() const
914 {
915 return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_FRONT);
916 }
917
922 inline bool IsArticulatedPart() const
923 {
924 return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_ARTICULATED_PART);
925 }
926
931 inline bool HasArticulatedPart() const
932 {
933 return this->Next() != nullptr && this->Next()->IsArticulatedPart();
934 }
935
941 inline Vehicle *GetNextArticulatedPart() const
942 {
943 assert(this->HasArticulatedPart());
944 return this->Next();
945 }
946
951 inline Vehicle *GetFirstEnginePart()
952 {
953 Vehicle *v = this;
954 while (v->IsArticulatedPart()) v = v->Previous();
955 return v;
956 }
957
962 inline const Vehicle *GetFirstEnginePart() const
963 {
964 const Vehicle *v = this;
965 while (v->IsArticulatedPart()) v = v->Previous();
966 return v;
967 }
968
973 inline Vehicle *GetLastEnginePart()
974 {
975 Vehicle *v = this;
976 while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
977 return v;
978 }
979
984 inline Vehicle *GetNextVehicle() const
985 {
986 const Vehicle *v = this;
987 while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
988
989 /* v now contains the last articulated part in the engine */
990 return v->Next();
991 }
992
997 inline Vehicle *GetPrevVehicle() const
998 {
999 Vehicle *v = this->Previous();
1000 while (v != nullptr && v->IsArticulatedPart()) v = v->Previous();
1001
1002 return v;
1003 }
1004
1009 struct OrderIterator {
1010 typedef Order value_type;
1011 typedef Order* pointer;
1012 typedef Order& reference;
1013 typedef size_t difference_type;
1014 typedef std::forward_iterator_tag iterator_category;
1015
1016 explicit OrderIterator(OrderList *list) : list(list), prev(nullptr)
1017 {
1018 this->order = (this->list == nullptr) ? nullptr : this->list->GetFirstOrder();
1019 }
1020
1021 bool operator==(const OrderIterator &other) const { return this->order == other.order; }
1022 bool operator!=(const OrderIterator &other) const { return !(*this == other); }
1023 Order * operator*() const { return this->order; }
1024 OrderIterator & operator++()
1025 {
1026 this->prev = (this->prev == nullptr) ? this->list->GetFirstOrder() : this->prev->next;
1027 this->order = (this->prev == nullptr) ? nullptr : this->prev->next;
1028 return *this;
1029 }
1030
1031 private:
1032 OrderList *list;
1033 Order *order;
1034 Order *prev;
1035 };
1036
1040 struct IterateWrapper {
1041 OrderList *list;
1042 IterateWrapper(OrderList *list = nullptr) : list(list) {}
1043 OrderIterator begin() { return OrderIterator(this->list); }
1044 OrderIterator end() { return OrderIterator(nullptr); }
1045 bool empty() { return this->begin() == this->end(); }
1046 };
1047
1052 IterateWrapper Orders() const { return IterateWrapper(this->orders); }
1053
1054 uint32 GetDisplayMaxWeight() const;
1055 uint32 GetDisplayMinPowerToWeight() const;
1056 };
1057
1062 template <class T, VehicleType Type>
1063 struct SpecializedVehicle : public Vehicle {
1064 static const VehicleType EXPECTED_TYPE = Type;
1065
1066 typedef SpecializedVehicle<T, Type> SpecializedVehicleBase;
1067
1071 inline SpecializedVehicle<T, Type>() : Vehicle(Type)
1072 {
1073 this->sprite_cache.sprite_seq.count = 1;
1074 }
1075
1080 inline T *First() const { return (T *)this->Vehicle::First(); }
1081
1086 inline T *Last() { return (T *)this->Vehicle::Last(); }
1087
1092 inline const T *Last() const { return (const T *)this->Vehicle::Last(); }
1093
1098 inline T *Next() const { return (T *)this->Vehicle::Next(); }
1099
1104 inline T *Previous() const { return (T *)this->Vehicle::Previous(); }
1105
1111 inline T *GetNextArticulatedPart() { return (T *)this->Vehicle::GetNextArticulatedPart(); }
1112
1118 inline T *GetNextArticulatedPart() const { return (T *)this->Vehicle::GetNextArticulatedPart(); }
1119
1124 inline T *GetFirstEnginePart() { return (T *)this->Vehicle::GetFirstEnginePart(); }
1125
1130 inline const T *GetFirstEnginePart() const { return (const T *)this->Vehicle::GetFirstEnginePart(); }
1131
1136 inline T *GetLastEnginePart() { return (T *)this->Vehicle::GetLastEnginePart(); }
1137
1142 inline T *GetNextVehicle() const { return (T *)this->Vehicle::GetNextVehicle(); }
1143
1148 inline T *GetPrevVehicle() const { return (T *)this->Vehicle::GetPrevVehicle(); }
1149
1155 static inline bool IsValidID(size_t index)
1156 {
1157 return Vehicle::IsValidID(index) && Vehicle::Get(index)->type == Type;
1158 }
1159
1164 static inline T *Get(size_t index)
1165 {
1166 return (T *)Vehicle::Get(index);
1167 }
1168
1173 static inline T *GetIfValid(size_t index)
1174 {
1175 return IsValidID(index) ? Get(index) : nullptr;
1176 }
1177
1183 static inline T *From(Vehicle *v)
1184 {
1185 assert(v->type == Type);
1186 return (T *)v;
1187 }
1188
1194 static inline const T *From(const Vehicle *v)
1195 {
1196 assert(v->type == Type);
1197 return (const T *)v;
1198 }
1199
1205 inline void UpdateViewport(bool force_update, bool update_delta)
1206 {
1207 bool sprite_has_changed = false;
1208
1209 /* Skip updating sprites on dedicated servers without screen */
1210 if (_network_dedicated) return;
1211
1212 /* Explicitly choose method to call to prevent vtable dereference -
1213 * it gives ~3% runtime improvements in games with many vehicles */
1214 if (update_delta) ((T *)this)->T::UpdateDeltaXY();
1215
1216 /*
1217 * Only check for a new sprite sequence if the vehicle direction
1218 * has changed since we last checked it, assuming that otherwise
1219 * there won't be enough change in bounding box or offsets to need
1220 * to resolve a new sprite.
1221 */
1222 if (this->direction != this->sprite_cache.last_direction || this->sprite_cache.is_viewport_candidate) {
1223 VehicleSpriteSeq seq;
1224
1225 ((T*)this)->T::GetImage(this->direction, EIT_ON_MAP, &seq);
1226 if (this->sprite_cache.sprite_seq != seq) {
1227 sprite_has_changed = true;
1228 this->sprite_cache.sprite_seq = seq;
1229 }
1230
1231 this->sprite_cache.last_direction = this->direction;
1232 this->sprite_cache.revalidate_before_draw = false;
1233 } else {
1234 /*
1235 * A change that could potentially invalidate the sprite has been
1236 * made, signal that we should still resolve it before drawing on a
1237 * viewport.
1238 */
1239 this->sprite_cache.revalidate_before_draw = true;
1240 }
1241
1242 if (force_update || sprite_has_changed) {
1243 this->Vehicle::UpdateViewport(true);
1244 }
1245 }
1246
1252 static Pool::IterateWrapper<T> Iterate(size_t from = 0) { return Pool::IterateWrapper<T>(from); }
1253 };
1254
1256 struct FreeUnitIDGenerator {
1257 bool *cache;
1258 UnitID maxid;
1259 UnitID curid;
1260
1261 FreeUnitIDGenerator(VehicleType type, CompanyID owner);
1262 UnitID NextID();
1263
1265 ~FreeUnitIDGenerator() { free(this->cache); }
1266 };
1267
1269 static const int32 INVALID_COORD = 0x7fffffff;
1270
1271 #endif /* VEHICLE_BASE_H */
SpecializedVehicle::GetNextVehicle
T * GetNextVehicle() const
Get the next real (non-articulated part) vehicle in the consist.
Definition: vehicle_base.h:1142
GVSF_ENGINE
@ GVSF_ENGINE
Engine that can be front engine, but might be placed behind another engine (not used for road vehicle...
Definition: vehicle_base.h:118
Vehicle::GetGroundVehicleCache
GroundVehicleCache * GetGroundVehicleCache()
Access the ground vehicle cache of the vehicle.
Definition: vehicle.cpp:2906
Vehicle::IsChainInDepot
virtual bool IsChainInDepot() const
Check whether the whole vehicle chain is in the depot.
Definition: vehicle_base.h:537
BaseConsist::cur_implicit_order_index
VehicleOrderID cur_implicit_order_index
The index to the current implicit order.
Definition: base_consist.h:29
Vehicle::SkipToNextRealOrderIndex
void SkipToNextRealOrderIndex()
Advance cur_real_order_index to the next real order.
Definition: vehicle_base.h:811
VehicleOrderID
byte VehicleOrderID
The index of an order within its current vehicle (not pool related)
Definition: order_type.h:15
MutableSpriteCache::is_viewport_candidate
bool is_viewport_candidate
This vehicle can potentially be drawn on a viewport.
Definition: vehicle_base.h:196
transport_type.h
LoadgameState
Definition: oldloader.h:19
SmallStack
Minimal stack that uses a pool to avoid pointers.
Definition: smallstack_type.hpp:136
MutableSpriteCache::last_direction
Direction last_direction
Last direction we obtained sprites for.
Definition: vehicle_base.h:193
VE_OFFSET_COUNT
@ VE_OFFSET_COUNT
Number of bits used for the offset.
Definition: vehicle_base.h:82
VE_DISABLE_EFFECT
@ VE_DISABLE_EFFECT
Flag to disable visual effect.
Definition: vehicle_base.h:92
Vehicle::PreDestructor
void PreDestructor()
Destroy all stuff that (still) needs the virtual functions to work properly.
Definition: vehicle.cpp:814
Pool::PoolItem<&_vehicle_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:337
Direction
Direction
Defines the 8 directions on the map.
Definition: direction_type.h:24
Vehicle::y_pos
int32 y_pos
y coordinate.
Definition: vehicle_base.h:284
SpecializedVehicle::SpecializedVehicleBase
SpecializedVehicle< T, Type > SpecializedVehicleBase
Our type.
Definition: vehicle_base.h:1066
MutableSpriteCache::sprite_seq
VehicleSpriteSeq sprite_seq
Vehicle appearance.
Definition: vehicle_base.h:197
VehicleSpriteSeq::CopyWithoutPalette
void CopyWithoutPalette(const VehicleSpriteSeq &src)
Copy data from another sprite sequence, while dropping all recolouring information.
Definition: vehicle_base.h:175
Vehicle::PreviousShared
Vehicle * PreviousShared() const
Get the previous vehicle of the shared vehicle chain.
Definition: vehicle_base.h:698
Vehicle::GetNumManualOrders
VehicleOrderID GetNumManualOrders() const
Get the number of manually added orders this vehicle has.
Definition: vehicle_base.h:722
Vehicle::GetRunningCost
virtual Money GetRunningCost() const
Gets the running cost of a vehicle.
Definition: vehicle_base.h:525
Vehicle::value
Money value
Value of the vehicle.
Definition: vehicle_base.h:256
Vehicle::PlayLeaveStationSound
virtual void PlayLeaveStationSound(bool force=false) const
Play the sound associated with leaving the station.
Definition: vehicle_base.h:455
Vehicle::x_pos
int32 x_pos
x coordinate.
Definition: vehicle_base.h:283
_vehicle_pool
VehiclePool _vehicle_pool
The pool with all our precious vehicles.
RefitDesc::capacity
uint16 capacity
Capacity the vehicle will have.
Definition: vehicle_base.h:217
Vehicle::HasEngineType
bool HasEngineType() const
Check whether Vehicle::engine_type has any meaning.
Definition: vehicle.cpp:725
Vehicle::GetGroundVehicleFlags
uint16 & GetGroundVehicleFlags()
Access the ground vehicle flags of the vehicle.
Definition: vehicle.cpp:2936
Vehicle::IsEngineCountable
bool IsEngineCountable() const
Check if a vehicle is counted in num_engines in each company struct.
Definition: vehicle.cpp:708
Vehicle::Previous
Vehicle * Previous() const
Get the previous vehicle of this vehicle.
Definition: vehicle_base.h:617
Vehicle::GetNextVehicle
Vehicle * GetNextVehicle() const
Get the next real (non-articulated part) vehicle in the consist.
Definition: vehicle_base.h:984
Vehicle::UpdateDeltaXY
virtual void UpdateDeltaXY()
Updates the x and y offsets and the size of the sprite used for this vehicle.
Definition: vehicle_base.h:396
Vehicle::LeaveStation
void LeaveStation()
Perform all actions when leaving a station.
Definition: vehicle.cpp:2261
Vehicle::Next
Vehicle * Next() const
Get the next vehicle of this vehicle.
Definition: vehicle_base.h:610
SpecializedVehicle::Next
T * Next() const
Get next vehicle in the chain.
Definition: vehicle_base.h:1098
EXPENSES_OTHER
@ EXPENSES_OTHER
Other expenses.
Definition: economy_type.h:170
Vehicle::GetDisplayMaxSpeed
virtual int GetDisplayMaxSpeed() const
Gets the maximum speed in km-ish/h that can be sent into SetDParam for string processing.
Definition: vehicle_base.h:513
Vehicle::y_extent
byte y_extent
y-extent of vehicle bounding box
Definition: vehicle_base.h:296
UnitID
uint16 UnitID
Type for the company global vehicle unit number.
Definition: transport_type.h:16
Station
Station data structure.
Definition: station_base.h:454
RefitDesc::remaining
uint16 remaining
Capacity remaining from before the previous refit.
Definition: vehicle_base.h:218
Vehicle::NeedsAutomaticServicing
bool NeedsAutomaticServicing() const
Checks if the current order should be interrupted for a service-in-depot order.
Definition: vehicle.cpp:252
Vehicle::z_pos
int32 z_pos
z coordinate.
Definition: vehicle_base.h:285
Vehicle::load_unload_ticks
uint16 load_unload_ticks
Ticks to wait before starting next cycle.
Definition: vehicle_base.h:340
Vehicle::GetLastEnginePart
Vehicle * GetLastEnginePart()
Get the last part of an articulated engine.
Definition: vehicle_base.h:973
VehicleSpriteSeq::Clear
void Clear()
Clear all information.
Definition: vehicle_base.h:157
VehicleSpriteSeq::Set
void Set(SpriteID sprite)
Assign a single sprite to the sequence.
Definition: vehicle_base.h:165
NewGRFCache::position_same_id_length
uint32 position_same_id_length
Cache for NewGRF var 41.
Definition: vehicle_base.h:72
FreeUnitIDGenerator::curid
UnitID curid
last ID returned; 0 if none
Definition: vehicle_base.h:1259
Vehicle::random_bits
byte random_bits
Bits used for determining which randomized variational spritegroups to use when drawing.
Definition: vehicle_base.h:313
Vehicle::old_orders
Order * old_orders
Only used during conversion of old save games.
Definition: vehicle_base.h:337
Vehicle::vehstatus
byte vehstatus
Status.
Definition: vehicle_base.h:332
VE_DEFAULT
@ VE_DEFAULT
Default value to indicate that visual effect should be based on engine class.
Definition: vehicle_base.h:96
Vehicle::grf_cache
NewGRFCache grf_cache
Cache of often used calculated NewGRF values.
Definition: vehicle_base.h:344
VS_DEFPAL
@ VS_DEFPAL
Use default vehicle palette.
Definition: vehicle_base.h:37
Pool::PoolItem<&_vehicle_pool >::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:235
Vehicle::SetNext
void SetNext(Vehicle *next)
Set the next vehicle of this vehicle.
Definition: vehicle.cpp:2741
order_base.h
Vehicle::Crash
virtual uint Crash(bool flooded=false)
Crash the (whole) vehicle chain.
Definition: vehicle.cpp:260
Vehicle::acceleration
byte acceleration
used by train & aircraft
Definition: vehicle_base.h:309
PalSpriteID::sprite
SpriteID sprite
The 'real' sprite.
Definition: gfx_type.h:23
Vehicle::group_id
GroupID group_id
Index of group Pool array.
Definition: vehicle_base.h:341
Vehicle::Vehicle
Vehicle(VehicleType type=VEH_INVALID)
Vehicle constructor.
Definition: vehicle.cpp:345
HasBit
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103
INVALID_TILE
static constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:108
GroundVehicleSubtypeFlags
GroundVehicleSubtypeFlags
Enum to handle ground vehicle subtypes.
Definition: vehicle_base.h:114
TileIndex
The index/ID of a Tile.
Definition: tile_type.h:85
VE_TYPE_ELECTRIC
@ VE_TYPE_ELECTRIC
Electric sparks.
Definition: vehicle_base.h:90
Vehicle::next
Vehicle * next
pointer to the next vehicle in the chain
Definition: vehicle_base.h:229
Vehicle::GetGRF
const GRFFile * GetGRF() const
Retrieve the NewGRF the vehicle is tied to.
Definition: vehicle.cpp:751
Year
int32 Year
Type for the year, note: 0 based, i.e. starts at the year 0.
Definition: date_type.h:18
NewGRFCache::cache_valid
uint8 cache_valid
Bitset that indicates which cache values are valid.
Definition: vehicle_base.h:76
VF_LOADING_FINISHED
@ VF_LOADING_FINISHED
Vehicle has finished loading.
Definition: vehicle_base.h:46
saveload.h
SpecializedVehicle::GetNextArticulatedPart
T * GetNextArticulatedPart()
Get the next part of an articulated engine.
Definition: vehicle_base.h:1111
Vehicle::GetDisplayMaxWeight
uint32 GetDisplayMaxWeight() const
Calculates the maximum weight of the ground vehicle when loaded.
Definition: vehicle.cpp:2995
Vehicle::running_ticks
byte running_ticks
Number of ticks this vehicle was not stopped this day.
Definition: vehicle_base.h:330
Vehicle::GetMaxWeight
virtual uint16 GetMaxWeight() const
Calculates the weight value that this vehicle will have when fully loaded with its current cargo.
Definition: vehicle_base.h:353
Vehicle::~Vehicle
virtual ~Vehicle()
We want to 'destruct' the right class.
Definition: vehicle.cpp:880
base_consist.h
VE_TYPE_COUNT
@ VE_TYPE_COUNT
Number of bits used for the effect type.
Definition: vehicle_base.h:86
Vehicle::GetConsistFreeCapacities
void GetConsistFreeCapacities(SmallMap< CargoID, uint > &capacities) const
Get a map of cargoes and free capacities in the consist.
Definition: vehicle.cpp:2359
VS_TRAIN_SLOWING
@ VS_TRAIN_SLOWING
Train is slowing down.
Definition: vehicle_base.h:38
Vehicle::OrderIterator
Iterator to iterate orders Supports deletion of current order.
Definition: vehicle_base.h:1009
smallmap_type.hpp
Vehicle::GetNextArticulatedPart
Vehicle * GetNextArticulatedPart() const
Get the next part of an articulated engine.
Definition: vehicle_base.h:941
Vehicle::AfterLoadVehicles
friend void AfterLoadVehicles(bool part_of_load)
So we can set the previous and first pointers while loading.
Definition: vehicle_sl.cpp:242
EngineImageType
EngineImageType
Visualisation contexts of vehicles and engines.
Definition: vehicle_type.h:86
Engine
Definition: engine_base.h:36
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
Vehicle::cur_speed
uint16 cur_speed
current speed
Definition: vehicle_base.h:307
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:224
Vehicle::IsPrimaryVehicle
virtual bool IsPrimaryVehicle() const
Whether this is the primary vehicle in the chain.
Definition: vehicle_base.h:460
Vehicle::IsGroundVehicle
bool IsGroundVehicle() const
Check if the vehicle is a ground vehicle.
Definition: vehicle_base.h:498
OrderList::IsShared
bool IsShared() const
Is this a shared order list?
Definition: order_base.h:341
VehicleSpriteSeq::Draw
void Draw(int x, int y, PaletteID default_pal, bool force_pal) const
Draw the sprite sequence.
Definition: vehicle.cpp:126
Vehicle::owner
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:288
Owner
Owner
Enum for all companies/owners.
Definition: company_type.h:18
VehicleCache::cached_cargo_age_period
uint16 cached_cargo_age_period
Number of ticks before carried cargo is aged.
Definition: vehicle_base.h:126
Vehicle::IsInDepot
virtual bool IsInDepot() const
Check whether the vehicle is in the depot.
Definition: vehicle_base.h:531
VS_AIRCRAFT_BROKEN
@ VS_AIRCRAFT_BROKEN
Aircraft is broken down.
Definition: vehicle_base.h:40
DoCommandFlag
DoCommandFlag
List of flags for a command.
Definition: command_type.h:355
VE_OFFSET_START
@ VE_OFFSET_START
First bit that contains the offset (0 = front, 8 = centre, 15 = rear)
Definition: vehicle_base.h:81
Vehicle::breakdowns_since_last_service
byte breakdowns_since_last_service
Counter for the amount of breakdowns.
Definition: vehicle_base.h:280
Vehicle::UpdateRealOrderIndex
void UpdateRealOrderIndex()
Skip implicit orders until cur_real_order_index is a non-implicit order.
Definition: vehicle_base.h:869
NCVV_POSITION_IN_VEHICLE
@ NCVV_POSITION_IN_VEHICLE
This bit will be set if the NewGRF var 4D currently stored is valid.
Definition: vehicle_base.h:64
SmallMap
Implementation of simple mapping class.
Definition: smallmap_type.hpp:26
Vehicle::IsArticulatedPart
bool IsArticulatedPart() const
Check if the vehicle is an articulated part of an engine.
Definition: vehicle_base.h:922
VehicleCargoList
CargoList that is used for vehicles.
Definition: cargopacket.h:269
SpriteID
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
VF_STOP_LOADING
@ VF_STOP_LOADING
Don't load anymore during the next load cycle.
Definition: vehicle_base.h:52
SlVehicleCommon
Definition: vehicle_sl.cpp:580
VE_TYPE_DIESEL
@ VE_TYPE_DIESEL
Diesel fumes.
Definition: vehicle_base.h:89
VESM_STEAM
@ VESM_STEAM
Steam model.
Definition: vehicle_base.h:102
Vehicle::GetDisplayRunningCost
Money GetDisplayRunningCost() const
Gets the running cost of a vehicle that can be sent into SetDParam for string processing.
Definition: vehicle_base.h:589
VF_AUTOFILL_TIMETABLE
@ VF_AUTOFILL_TIMETABLE
Whether the vehicle should fill in the timetable automatically.
Definition: vehicle_base.h:50
MutableSpriteCache
Cache for vehicle sprites and values relating to whether they should be updated before drawing,...
Definition: vehicle_base.h:192
Vehicle::Orders
IterateWrapper Orders() const
Returns an iterable ensemble of orders of a vehicle.
Definition: vehicle_base.h:1052
Vehicle::Last
const Vehicle * Last() const
Get the last vehicle of this vehicle chain.
Definition: vehicle_base.h:640
Vehicle::BeginLoading
void BeginLoading()
Prepare everything to begin the loading when arriving at a station.
Definition: vehicle.cpp:2113
Vehicle::breakdown_ctr
byte breakdown_ctr
Counter for managing breakdown events.
Definition: vehicle_base.h:278
VS_HIDDEN
@ VS_HIDDEN
Vehicle is not visible.
Definition: vehicle_base.h:34
EngineID
uint16 EngineID
Unique identification number of an engine.
Definition: engine_type.h:21
Vehicle::UpdateVisualEffect
void UpdateVisualEffect(bool allow_power_change=true)
Update the cached visual effect.
Definition: vehicle.cpp:2468
DepotCommand
DepotCommand
Flags for goto depot commands.
Definition: vehicle_type.h:65
VehicleSpriteSeq::IsValid
bool IsValid() const
Check whether the sequence contains any sprites.
Definition: vehicle_base.h:149
Vehicle::dest_tile
TileIndex dest_tile
Heading for this tile.
Definition: vehicle_base.h:252
Vehicle::HandlePathfindingResult
void HandlePathfindingResult(bool path_found)
Handle the pathfinding result, especially the lost status.
Definition: vehicle.cpp:783
Vehicle::GetDisplayProfitThisYear
Money GetDisplayProfitThisYear() const
Gets the profit vehicle had this year.
Definition: vehicle_base.h:595
Vehicle::GetDisplaySpeed
virtual int GetDisplaySpeed() const
Gets the speed in km-ish/h that can be sent into SetDParam for string processing.
Definition: vehicle_base.h:507
Vehicle::GetPrevVehicle
Vehicle * GetPrevVehicle() const
Get the previous real (non-articulated part) vehicle in the consist.
Definition: vehicle_base.h:997
VE_TYPE_START
@ VE_TYPE_START
First bit used for the type of effect.
Definition: vehicle_base.h:85
GroundVehicleCache
Cached, frequently calculated values.
Definition: ground_vehicle.hpp:29
CommandCost
Common return value for all commands.
Definition: command_type.h:24
OrderList::GetNumManualOrders
VehicleOrderID GetNumManualOrders() const
Get number of manually added orders in the order list.
Definition: order_base.h:328
Vehicle::UpdateBoundingBoxCoordinates
void UpdateBoundingBoxCoordinates(bool update_cache) const
Update the bounding box co-ordinates of the vehicle.
Definition: vehicle.cpp:1619
BaseVehicle
Base vehicle class.
Definition: vehicle_type.h:50
Vehicle::GetCurrentMaxSpeed
virtual int GetCurrentMaxSpeed() const
Calculates the maximum speed of the vehicle under its current conditions.
Definition: vehicle_base.h:519
FreeUnitIDGenerator::NextID
UnitID NextID()
Returns next free UnitID.
Definition: vehicle.cpp:1792
Vehicle::AddToShared
void AddToShared(Vehicle *shared_chain)
Adds this vehicle to a shared vehicle chain.
Definition: vehicle.cpp:2770
VehStatus
VehStatus
Vehicle status bits in Vehicle::vehstatus.
Definition: vehicle_base.h:33
NewGRFCache::consist_cargo_information
uint32 consist_cargo_information
Cache for NewGRF var 42. (Note: The cargotype is untranslated in the cache because the accessing GRF ...
Definition: vehicle_base.h:73
Vehicle::RemoveFromShared
void RemoveFromShared()
Removes the vehicle from the shared order list.
Definition: vehicle.cpp:2793
VF_CARGO_UNLOADING
@ VF_CARGO_UNLOADING
Vehicle is unloading cargo.
Definition: vehicle_base.h:47
NCVV_POSITION_CONSIST_LENGTH
@ NCVV_POSITION_CONSIST_LENGTH
This bit will be set if the NewGRF var 40 currently stored is valid.
Definition: vehicle_base.h:60
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:245
Vehicle::CancelReservation
void CancelReservation(StationID next, Station *st)
Return all reserved cargo packets to the station and reset all packets staged for transfer.
Definition: vehicle.cpp:2244
EIT_ON_MAP
@ EIT_ON_MAP
Vehicle drawn in viewport.
Definition: vehicle_type.h:87
Vehicle::engine_type
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:302
VS_CRASHED
@ VS_CRASHED
Vehicle is crashed.
Definition: vehicle_base.h:41
VehicleSpriteSeq
Sprite sequence for a vehicle part.
Definition: vehicle_base.h:132
SB
static T SB(T &x, const uint8 s, const uint8 n, const U d)
Set n bits in x starting at bit s to d.
Definition: bitmath_func.hpp:58
LoadOldVehicle
bool LoadOldVehicle(LoadgameState *ls, int num)
Load the vehicles of an old style savegame.
Definition: oldloader_sl.cpp:1222
OrderList::GetFirstSharedVehicle
Vehicle * GetFirstSharedVehicle() const
Get the first vehicle of this vehicle chain.
Definition: order_base.h:347
Vehicle::last_station_visited
StationID last_station_visited
The last station we stopped at.
Definition: vehicle_base.h:316
Vehicle::GetVehicleTrackdir
virtual Trackdir GetVehicleTrackdir() const
Returns the Trackdir on which the vehicle is currently located.
Definition: vehicle_base.h:583
CargoPayment
Helper class to perform the cargo payment.
Definition: economy_base.h:24
Vehicle::cargo
VehicleCargoList cargo
The cargo this vehicle is carrying.
Definition: vehicle_base.h:324
Vehicle::GetOldAdvanceSpeed
uint GetOldAdvanceSpeed(uint speed)
Determines the effective direction-specific vehicle movement speed.
Definition: vehicle_base.h:411
VehicleFlags
VehicleFlags
Bit numbers in Vehicle::vehicle_flags.
Definition: vehicle_base.h:45
Vehicle::GetExpenseType
virtual ExpensesType GetExpenseType(bool income) const
Sets the expense type associated to this vehicle type.
Definition: vehicle_base.h:449
SpecializedVehicle
Class defining several overloaded accessors so we don't have to cast vehicle types that often.
Definition: vehicle_base.h:1063
Vehicle::hash_tile_current
Vehicle ** hash_tile_current
NOSAVE: Cache of the current hash chain.
Definition: vehicle_base.h:267
GVSF_ARTICULATED_PART
@ GVSF_ARTICULATED_PART
Articulated part of an engine.
Definition: vehicle_base.h:116
Vehicle::current_order
Order current_order
The current order (+ status, like: loading)
Definition: vehicle_base.h:333
FreeUnitIDGenerator::~FreeUnitIDGenerator
~FreeUnitIDGenerator()
Releases allocated memory.
Definition: vehicle_base.h:1265
Date
int32 Date
The type to store our dates in.
Definition: date_type.h:14
Vehicle::max_age
Date max_age
Maximum age.
Definition: vehicle_base.h:274
Vehicle::IsFrontEngine
bool IsFrontEngine() const
Check if the vehicle is a front engine.
Definition: vehicle_base.h:913
Vehicle::GetLastOrder
Order * GetLastOrder() const
Returns the last order of a vehicle, or nullptr if it doesn't exists.
Definition: vehicle_base.h:899
FreeUnitIDGenerator
Generates sequence of free UnitID numbers.
Definition: vehicle_base.h:1256
SpecializedVehicle::Get
static T * Get(size_t index)
Gets vehicle with given index.
Definition: vehicle_base.h:1164
Pool::IterateWrapper
Definition: pool_type.hpp:175
VS_STOPPED
@ VS_STOPPED
Vehicle is stopped by the player.
Definition: vehicle_base.h:35
Vehicle::trip_occupancy
int8 trip_occupancy
NOSAVE: Occupancy of vehicle of the current trip (updated after leaving a station).
Definition: vehicle_base.h:326
Vehicle::GetGRFID
uint32 GetGRFID() const
Retrieve the GRF ID of the NewGRF the vehicle is tied to.
Definition: vehicle.cpp:761
VehicleCache
Cached often queried values common to all vehicles.
Definition: vehicle_base.h:124
Vehicle::ShowVisualEffect
void ShowVisualEffect() const
Draw visual effects (smoke and/or sparks) for a vehicle chain.
Definition: vehicle.cpp:2591
Vehicle::GetEngine
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition: vehicle.cpp:741
VisualEffectSpawnModel
VisualEffectSpawnModel
Models for spawning visual effects.
Definition: vehicle_base.h:100
Vehicle::CopyVehicleConfigAndStatistics
void CopyVehicleConfigAndStatistics(const Vehicle *src)
Copy certain configurations and statistics of a vehicle after successful autoreplace/renew The functi...
Definition: vehicle_base.h:741
cargopacket.h
Vehicle::ResetRefitCaps
void ResetRefitCaps()
Reset all refit_cap in the consist to cargo_cap.
Definition: vehicle.cpp:2314
Vehicle::reliability_spd_dec
uint16 reliability_spd_dec
Reliability decrease speed.
Definition: vehicle_base.h:277
Vehicle::UpdateViewport
void UpdateViewport(bool dirty)
Update the vehicle on the viewport, updating the right hash and setting the new coordinates.
Definition: vehicle.cpp:1652
Vehicle::last_loading_station
StationID last_loading_station
Last station the vehicle has stopped at and could possibly leave from with any cargo loaded.
Definition: vehicle_base.h:317
VEH_INVALID
@ VEH_INVALID
Non-existing type of vehicle.
Definition: vehicle_type.h:35
VF_SERVINT_IS_CUSTOM
@ VF_SERVINT_IS_CUSTOM
Service interval is custom.
Definition: vehicle_base.h:54
Vehicle::previous_shared
Vehicle * previous_shared
NOSAVE: pointer to the previous vehicle in the shared order chain.
Definition: vehicle_base.h:234
Vehicle::profit_this_year
Money profit_this_year
Profit this year << 8, low 8 bits are fract.
Definition: vehicle_base.h:254
VehiclePool
Pool< Vehicle, VehicleID, 512, 0xFF000 > VehiclePool
A vehicle pool for a little over 1 million vehicles.
Definition: vehicle_base.h:201
Vehicle::MarkAllViewportsDirty
bool MarkAllViewportsDirty() const
Marks viewports dirty where the vehicle's image is.
Definition: vehicle.cpp:1691
GVSF_WAGON
@ GVSF_WAGON
Wagon (not used for road vehicles).
Definition: vehicle_base.h:117
INVALID_TRACKDIR
@ INVALID_TRACKDIR
Flag for an invalid trackdir.
Definition: track_type.h:89
FixOldVehicles
void FixOldVehicles()
Convert the old style vehicles into something that resembles the old new style savegames.
Definition: oldloader_sl.cpp:171
VehicleCache::cached_vis_effect
byte cached_vis_effect
Visual effect to show (see VisualEffect)
Definition: vehicle_base.h:128
Vehicle::FindClosestDepot
virtual 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...
Definition: vehicle_base.h:779
Vehicle::HandleLoading
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:2324
Vehicle::HasDepotOrder
bool HasDepotOrder() const
Checks if a vehicle has a depot in its order list.
Definition: order_cmd.cpp:1832
_network_dedicated
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:61
Vehicle::Move
const Vehicle * Move(int n) const
Get the vehicle at offset n of this vehicle chain.
Definition: vehicle_base.h:668
OrderList::GetNextStoppingStation
StationIDStack GetNextStoppingStation(const Vehicle *v, const Order *first=nullptr, uint hops=0) const
Recursively determine the next deterministic station to stop at.
Definition: order_cmd.cpp:415
VisualEffect
VisualEffect
Meaning of the various bits of the visual effect.
Definition: vehicle_base.h:80
BaseConsist::vehicle_flags
uint16 vehicle_flags
Used for gradual loading and other miscellaneous things (.
Definition: base_consist.h:31
Vehicle::SendToDepot
CommandCost SendToDepot(DoCommandFlag flags, DepotCommand command)
Send this vehicle to the depot using the given command(s).
Definition: vehicle.cpp:2387
NewGRFCache::company_information
uint32 company_information
Cache for NewGRF var 43.
Definition: vehicle_base.h:74
VehicleType
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
Vehicle::sprite_cache
MutableSpriteCache sprite_cache
Cache of sprites and values related to recalculating them, see MutableSpriteCache.
Definition: vehicle_base.h:347
Vehicle::ShiftDates
void ShiftDates(int interval)
Shift all dates by given interval.
Definition: vehicle.cpp:771
Vehicle::IsOrderListShared
bool IsOrderListShared() const
Check if we share our orders with another vehicle.
Definition: vehicle_base.h:710
VE_TYPE_DEFAULT
@ VE_TYPE_DEFAULT
Use default from engine class.
Definition: vehicle_base.h:87
Vehicle::y_offs
int8 y_offs
y offset for vehicle sprite
Definition: vehicle_base.h:301
Vehicle::colourmap
SpriteID colourmap
NOSAVE: cached colour mapping.
Definition: vehicle_base.h:269
Vehicle::waiting_triggers
byte waiting_triggers
Triggers to be yet matched before rerandomizing the random bits.
Definition: vehicle_base.h:314
OrderList::GetOrderAt
Order * GetOrderAt(int index) const
Get a certain order of the order chain.
Definition: order_cmd.cpp:357
VESM_DIESEL
@ VESM_DIESEL
Diesel model.
Definition: vehicle_base.h:103
NewGRFCache::position_in_vehicle
uint32 position_in_vehicle
Cache for NewGRF var 4D.
Definition: vehicle_base.h:75
Vehicle::IncrementRealOrderIndex
void IncrementRealOrderIndex()
Advanced cur_real_order_index to the next real order, keeps care of the wrap-around and invalidates t...
Definition: vehicle_base.h:854
Vehicle::GetDisplayMinPowerToWeight
uint32 GetDisplayMinPowerToWeight() const
Calculates the minimum power-to-weight ratio using the maximum weight of the ground vehicle.
Definition: vehicle.cpp:3010
VF_BUILT_AS_PROTOTYPE
@ VF_BUILT_AS_PROTOTYPE
Vehicle is a prototype (accepted as exclusive preview).
Definition: vehicle_base.h:48
command_type.h
Vehicle::IterateWrapper
Iterable ensemble of orders.
Definition: vehicle_base.h:1040
Vehicle::direction
Direction direction
facing
Definition: vehicle_base.h:286
FreeUnitIDGenerator::cache
bool * cache
array of occupied unit id numbers
Definition: vehicle_base.h:1257
SpecializedVehicle::EXPECTED_TYPE
static const VehicleType EXPECTED_TYPE
Specialized type.
Definition: vehicle_base.h:1064
BaseConsist::cur_real_order_index
VehicleOrderID cur_real_order_index
The index to the current real (non-implicit) order.
Definition: base_consist.h:28
Vehicle::next_shared
Vehicle * next_shared
pointer to the next vehicle that shares the order
Definition: vehicle_base.h:233
texteff.hpp
Vehicle::FirstShared
Vehicle * FirstShared() const
Get the first vehicle of this vehicle chain.
Definition: vehicle_base.h:704
Vehicle::x_extent
byte x_extent
x-extent of vehicle bounding box
Definition: vehicle_base.h:295
Vehicle::Move
Vehicle * Move(int n)
Get the vehicle at offset n of this vehicle chain.
Definition: vehicle_base.h:652
NCVV_CONSIST_CARGO_INFORMATION
@ NCVV_CONSIST_CARGO_INFORMATION
This bit will be set if the NewGRF var 42 currently stored is valid.
Definition: vehicle_base.h:62
Vehicle::GetFirstEnginePart
const Vehicle * GetFirstEnginePart() const
Get the first part of an articulated engine.
Definition: vehicle_base.h:962
Vehicle::vcache
VehicleCache vcache
Cache of often used vehicle values.
Definition: vehicle_base.h:345
Vehicle::motion_counter
uint32 motion_counter
counter to occasionally play a vehicle sound.
Definition: vehicle_base.h:310
GVSF_FREE_WAGON
@ GVSF_FREE_WAGON
First in a wagon chain (in depot) (not used for road vehicles).
Definition: vehicle_base.h:119
VESM_NONE
@ VESM_NONE
No visual effect.
Definition: vehicle_base.h:101
MutableSpriteCache::revalidate_before_draw
bool revalidate_before_draw
We need to do a GetImage() and check bounds before drawing this sprite.
Definition: vehicle_base.h:194
Vehicle::hash_viewport_next
Vehicle * hash_viewport_next
NOSAVE: Next vehicle in the visual location hash.
Definition: vehicle_base.h:262
Pool
Base class for all pools.
Definition: pool_type.hpp:81
Vehicle::First
Vehicle * First() const
Get the first vehicle of this vehicle chain.
Definition: vehicle_base.h:623
Vehicle::cargo_age_counter
uint16 cargo_age_counter
Ticks till cargo is aged next.
Definition: vehicle_base.h:325
Vehicle::tick_counter
byte tick_counter
Increased by one for each tick.
Definition: vehicle_base.h:329
Vehicle::cargo_cap
uint16 cargo_cap
total capacity
Definition: vehicle_base.h:322
GroupID
uint16 GroupID
Type for all group identifiers.
Definition: group_type.h:13
engine_type.h
Vehicle::IncrementImplicitOrderIndex
void IncrementImplicitOrderIndex()
Increments cur_implicit_order_index, keeps care of the wrap-around and invalidates the GUI.
Definition: vehicle_base.h:830
NCVV_POSITION_SAME_ID_LENGTH
@ NCVV_POSITION_SAME_ID_LENGTH
This bit will be set if the NewGRF var 41 currently stored is valid.
Definition: vehicle_base.h:61
Vehicle::x_offs
int8 x_offs
x offset for vehicle sprite
Definition: vehicle_base.h:300
Vehicle::subspeed
byte subspeed
fractional speed
Definition: vehicle_base.h:308
Vehicle::GetAdvanceSpeed
static uint GetAdvanceSpeed(uint speed)
Determines the effective vehicle movement speed.
Definition: vehicle_base.h:428
Vehicle::GetFirstOrder
Order * GetFirstOrder() const
Get the first order of the vehicles order list.
Definition: vehicle_base.h:683
SpecializedVehicle::From
static T * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Definition: vehicle_base.h:1183
Vehicle::z_extent
byte z_extent
z-extent of vehicle bounding box
Definition: vehicle_base.h:297
Vehicle::GetFirstEnginePart
Vehicle * GetFirstEnginePart()
Get the first part of an articulated engine.
Definition: vehicle_base.h:951
Vehicle::InvalidateNewGRFCacheOfChain
void InvalidateNewGRFCacheOfChain()
Invalidates cached NewGRF variables of all vehicles in the chain (after the current vehicle)
Definition: vehicle_base.h:487
PaletteID
uint32 PaletteID
The number of the palette.
Definition: gfx_type.h:18
FreeUnitIDGenerator::maxid
UnitID maxid
maximum ID at the moment of constructor call
Definition: vehicle_base.h:1258
OrderList
Shared order list linking together the linked list of orders and the list of vehicles sharing this or...
Definition: order_base.h:260
VF_SERVINT_IS_PERCENT
@ VF_SERVINT_IS_PERCENT
Service interval is percent.
Definition: vehicle_base.h:55
Vehicle::cargo_payment
CargoPayment * cargo_payment
The cargo payment we're currently in.
Definition: vehicle_base.h:258
Vehicle::NextShared
Vehicle * NextShared() const
Get the next vehicle of the shared vehicle chain.
Definition: vehicle_base.h:692
OrderList::GetLastOrder
Order * GetLastOrder() const
Get the last order of the order chain.
Definition: order_base.h:308
VE_DISABLE_WAGON_POWER
@ VE_DISABLE_WAGON_POWER
Flag to disable wagon power.
Definition: vehicle_base.h:94
SpecializedVehicle::IsValidID
static bool IsValidID(size_t index)
Tests whether given index is a valid index for vehicle of this type.
Definition: vehicle_base.h:1155
Vehicle::age
Date age
Age in days.
Definition: vehicle_base.h:273
Vehicle::HasArticulatedPart
bool HasArticulatedPart() const
Check if an engine has an articulated part.
Definition: vehicle_base.h:931
Vehicle::build_year
Year build_year
Year the vehicle has been built.
Definition: vehicle_base.h:272
Vehicle::profit_last_year
Money profit_last_year
Profit last year << 8, low 8 bits are fract.
Definition: vehicle_base.h:255
Vehicle::breakdown_chance
byte breakdown_chance
Current chance of breakdowns.
Definition: vehicle_base.h:281
GVSF_MULTIHEADED
@ GVSF_MULTIHEADED
Engine is multiheaded (not used for road vehicles).
Definition: vehicle_base.h:120
PalSpriteID
Combination of a palette sprite and a 'real' sprite.
Definition: gfx_type.h:22
Vehicle::unitnumber
UnitID unitnumber
unit number, for display purposes only
Definition: vehicle_base.h:305
Vehicle::last_loading_tick
uint64_t last_loading_tick
Last time (relative to _tick_counter) the vehicle has stopped at a station and could possibly leave w...
Definition: vehicle_base.h:318
SpecializedVehicle::GetIfValid
static T * GetIfValid(size_t index)
Returns vehicle if the index is a valid index for this vehicle type.
Definition: vehicle_base.h:1173
VehicleCache::cached_max_speed
uint16 cached_max_speed
Maximum speed of the consist (minimum of the max speed of all vehicles in the consist).
Definition: vehicle_base.h:125
VF_AUTOFILL_PRES_WAIT_TIME
@ VF_AUTOFILL_PRES_WAIT_TIME
Whether non-destructive auto-fill should preserve waiting times.
Definition: vehicle_base.h:51
SpecializedVehicle::Iterate
static Pool::IterateWrapper< T > Iterate(size_t from=0)
Returns an iterable ensemble of all valid vehicles of type T.
Definition: vehicle_base.h:1252
Vehicle::LoadOldVehicle
friend bool LoadOldVehicle(LoadgameState *ls, int num)
So we can set the proper next pointer while loading.
Definition: oldloader_sl.cpp:1222
NCVV_END
@ NCVV_END
End of the bits.
Definition: vehicle_base.h:65
VE_ADVANCED_EFFECT
@ VE_ADVANCED_EFFECT
Flag for advanced effects.
Definition: vehicle_base.h:93
Vehicle::x_bb_offs
int8 x_bb_offs
x offset of vehicle bounding box
Definition: vehicle_base.h:298
Vehicle::hash_viewport_prev
Vehicle ** hash_viewport_prev
NOSAVE: Previous vehicle in the visual location hash.
Definition: vehicle_base.h:263
Vehicle::breakdown_delay
byte breakdown_delay
Counter for managing breakdown length.
Definition: vehicle_base.h:279
Vehicle::Last
Vehicle * Last()
Get the last vehicle of this vehicle chain.
Definition: vehicle_base.h:629
Vehicle::coord
Rect coord
NOSAVE: Graphical bounding box of the vehicle, i.e. what to redraw on moves.
Definition: vehicle_base.h:260
Vehicle::NeedsServicing
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:184
Vehicle::InvalidateNewGRFCache
void InvalidateNewGRFCache()
Invalidates cached NewGRF variables.
Definition: vehicle_base.h:478
network.h
Vehicle::subtype
byte subtype
subtype (Filled with values from AircraftSubType/DisasterSubType/EffectVehicleType/GroundVehicleSubty...
Definition: vehicle_base.h:342
VF_TIMETABLE_STARTED
@ VF_TIMETABLE_STARTED
Whether the vehicle has started running on the timetable yet.
Definition: vehicle_base.h:49
OrderList::GetFirstOrder
Order * GetFirstOrder() const
Get the first order of the order chain.
Definition: order_base.h:300
Vehicle::day_counter
byte day_counter
Increased by one for each day.
Definition: vehicle_base.h:328
BaseConsist::service_interval
uint16 service_interval
The interval for (automatic) servicing; either in days or %.
Definition: base_consist.h:26
VS_UNCLICKABLE
@ VS_UNCLICKABLE
Vehicle is not clickable by the user (shadow vehicles).
Definition: vehicle_base.h:36
NewGRFCacheValidValues
NewGRFCacheValidValues
Bit numbers used to indicate which of the NewGRFCache values are valid.
Definition: vehicle_base.h:59
GVSF_FRONT
@ GVSF_FRONT
Leading engine of a consist.
Definition: vehicle_base.h:115
Vehicle::NeedsAutorenewing
bool NeedsAutorenewing(const Company *c, bool use_renew_setting=true) const
Function to tell if a vehicle needs to be autorenewed.
Definition: vehicle.cpp:140
VF_PATHFINDER_LOST
@ VF_PATHFINDER_LOST
Vehicle's pathfinder is lost.
Definition: vehicle_base.h:53
Vehicle::progress
byte progress
The percentage (if divided by 256) this vehicle already crossed the tile unit.
Definition: vehicle_base.h:311
OverflowSafeInt< int64 >
CargoID
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
Vehicle::IsStoppedInDepot
bool IsStoppedInDepot() const
Check whether the vehicle is in the depot and stopped.
Definition: vehicle_base.h:543
Vehicle::FixOldVehicles
friend void FixOldVehicles()
Convert the old style vehicles into something that resembles the old new style savegames.
Definition: oldloader_sl.cpp:171
Vehicle::previous
Vehicle * previous
NOSAVE: pointer to the previous vehicle in the chain.
Definition: vehicle_base.h:230
Vehicle::cargo_type
CargoID cargo_type
type of cargo this vehicle is carrying
Definition: vehicle_base.h:320
Vehicle::spritenum
byte spritenum
currently displayed sprite index 0xfd == custom sprite, 0xfe == custom second head sprite 0xff == res...
Definition: vehicle_base.h:294
NCVV_COMPANY_INFORMATION
@ NCVV_COMPANY_INFORMATION
This bit will be set if the NewGRF var 43 currently stored is valid.
Definition: vehicle_base.h:63
SlVehicleDisaster
Definition: vehicle_sl.cpp:920
FreeUnitIDGenerator::FreeUnitIDGenerator
FreeUnitIDGenerator(VehicleType type, CompanyID owner)
Initializes the structure.
Definition: vehicle.cpp:1767
SpecializedVehicle::GetLastEnginePart
T * GetLastEnginePart()
Get the last part of an articulated engine.
Definition: vehicle_base.h:1136
Vehicle::OnNewDay
virtual void OnNewDay()
Calls the new day handler of the vehicle.
Definition: vehicle_base.h:560
PalSpriteID::pal
PaletteID pal
The palette (use PAL_NONE) if not needed)
Definition: gfx_type.h:24
SpecializedVehicle::Previous
T * Previous() const
Get previous vehicle in the chain.
Definition: vehicle_base.h:1104
Trackdir
Trackdir
Enumeration for tracks and directions.
Definition: track_type.h:70
Vehicle::cargo_subtype
byte cargo_subtype
Used for livery refits (NewGRF variations)
Definition: vehicle_base.h:321
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
Pool::PoolItem<&_vehicle_pool >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:326
Vehicle::GetAdvanceDistance
uint GetAdvanceDistance()
Determines the vehicle "progress" needed for moving a step.
Definition: vehicle_base.h:440
Vehicle::GetOrder
Order * GetOrder(int index) const
Returns order 'index' of a vehicle or nullptr when it doesn't exists.
Definition: vehicle_base.h:890
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:52
Vehicle::Tick
virtual bool Tick()
Calls the tick handler of the vehicle.
Definition: vehicle_base.h:555
Vehicle::UpdatePositionAndViewport
void UpdatePositionAndViewport()
Update the position of the vehicle, and update the viewport.
Definition: vehicle.cpp:1681
Vehicle::reliability
uint16 reliability
Reliability.
Definition: vehicle_base.h:276
SpecializedVehicle::First
T * First() const
Get the first vehicle in the chain.
Definition: vehicle_base.h:1080
Vehicle::UpdatePosition
void UpdatePosition()
Update the position of the vehicle.
Definition: vehicle.cpp:1610
Vehicle::hash_tile_prev
Vehicle ** hash_tile_prev
NOSAVE: Previous vehicle in the tile location hash.
Definition: vehicle_base.h:266
ExpensesType
ExpensesType
Types of expenses.
Definition: economy_type.h:157
Vehicle::HandleBreakdown
bool HandleBreakdown()
Handle all of the aspects of a vehicle breakdown This includes adding smoke and sounds,...
Definition: vehicle.cpp:1312
Vehicle::y_bb_offs
int8 y_bb_offs
y offset of vehicle bounding box
Definition: vehicle_base.h:299
free
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: stdafx.h:470
NewGRFCache::position_consist_length
uint32 position_consist_length
Cache for NewGRF var 40.
Definition: vehicle_base.h:71
VESM_ELECTRIC
@ VESM_ELECTRIC
Electric model.
Definition: vehicle_base.h:104
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition: geometry_type.hpp:69
Company
Definition: company_base.h:117
group_type.h
Vehicle::GetNumOrders
VehicleOrderID GetNumOrders() const
Get the number of orders this vehicle has.
Definition: vehicle_base.h:716
BaseConsist
Various front vehicle properties that are preserved when autoreplacing, using order-backup or switchi...
Definition: base_consist.h:18
SpecializedVehicle::Last
T * Last()
Get the last vehicle in the chain.
Definition: vehicle_base.h:1086
InvalidateVehicleOrder
void InvalidateVehicleOrder(const Vehicle *v, int data)
Updates the widgets of a vehicle which contains the order-data.
Definition: order_cmd.cpp:251
Vehicle::orders
OrderList * orders
Pointer to the order list for this vehicle.
Definition: vehicle_base.h:336
VehicleSpriteSeq::GetBounds
void GetBounds(Rect *bounds) const
Determine shared bounds of all sprites.
Definition: vehicle.cpp:98
Vehicle::hash_tile_next
Vehicle * hash_tile_next
NOSAVE: Next vehicle in the tile location hash.
Definition: vehicle_base.h:265
Pool::PoolItem
Base class for all PoolItems.
Definition: pool_type.hpp:234
BaseConsist::CopyConsistPropertiesFrom
void CopyConsistPropertiesFrom(const BaseConsist *src)
Copy properties of other BaseConsist.
Definition: base_consist.cpp:22
Vehicle::DeleteUnreachedImplicitOrders
void DeleteUnreachedImplicitOrders()
Delete all implicit orders which were not reached.
Definition: vehicle.cpp:2074
Vehicle::first
Vehicle * first
NOSAVE: pointer to the first vehicle in the chain.
Definition: vehicle_base.h:231
Order::next
Order * next
Pointer to next order. If nullptr, end of list.
Definition: order_base.h:59
SpecializedVehicle::UpdateViewport
void UpdateViewport(bool force_update, bool update_delta)
Update vehicle sprite- and position caches.
Definition: vehicle_base.h:1205
Vehicle::fill_percent_te_id
TextEffectID fill_percent_te_id
a text-effect id to a loading indicator object
Definition: vehicle_base.h:304
Order
Definition: order_base.h:36
SpecializedVehicle::GetPrevVehicle
T * GetPrevVehicle() const
Get the previous real (non-articulated part) vehicle in the consist.
Definition: vehicle_base.h:1148
VS_SHADOW
@ VS_SHADOW
Vehicle is a shadow vehicle.
Definition: vehicle_base.h:39
INVALID_COORD
static const int32 INVALID_COORD
Sentinel for an invalid coordinate.
Definition: vehicle_base.h:1269
MutableSpriteCache::old_coord
Rect old_coord
Co-ordinates from the last valid bounding box.
Definition: vehicle_base.h:195
OrderList::GetNumOrders
VehicleOrderID GetNumOrders() const
Get number of orders in the order list.
Definition: order_base.h:322
Vehicle::GetDisplayProfitLastYear
Money GetDisplayProfitLastYear() const
Gets the profit vehicle had last year.
Definition: vehicle_base.h:601
VE_OFFSET_CENTRE
@ VE_OFFSET_CENTRE
Value of offset corresponding to a position above the centre of the vehicle.
Definition: vehicle_base.h:83
SpecializedVehicle::GetFirstEnginePart
T * GetFirstEnginePart()
Get the first part of an articulated engine.
Definition: vehicle_base.h:1124
VE_TYPE_STEAM
@ VE_TYPE_STEAM
Steam plumes.
Definition: vehicle_base.h:88
RefitDesc
Simulated cargo type and capacity for prediction of future links.
Definition: vehicle_base.h:215
track_type.h
Vehicle::GetOrderStationLocation
virtual TileIndex GetOrderStationLocation(StationID station)
Determine the location for the station where the vehicle goes to next.
Definition: vehicle_base.h:769
order_func.h
Vehicle::MarkDirty
virtual void MarkDirty()
Marks the vehicles to be redrawn and updates cached variables.
Definition: vehicle_base.h:390
GRFFile
Dynamic data of a loaded NewGRF.
Definition: newgrf.h:106
Vehicle::refit_cap
uint16 refit_cap
Capacity left over from before last refit.
Definition: vehicle_base.h:323
NewGRFCache
Cached often queried (NewGRF) values.
Definition: vehicle_base.h:69
Vehicle::date_of_last_service
Date date_of_last_service
Last date the vehicle had a service at a depot.
Definition: vehicle_base.h:275
Vehicle::GetNextStoppingStation
StationIDStack GetNextStoppingStation() const
Get the next station the vehicle will stop at.
Definition: vehicle_base.h:728
RefitDesc::cargo
CargoID cargo
Cargo type the vehicle will be carrying.
Definition: vehicle_base.h:216
Vehicle::GetImage
virtual void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const
Gets the sprite to show for the given direction.
Definition: vehicle_base.h:469