OpenTTD Source: src/vehicle_base.h Source File

OpenTTD Source 14.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 "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"
25 #include "timer/timer_game_calendar.h"
26 #include "core/mem_func.hpp"
27
28 const uint TILE_AXIAL_DISTANCE = 192; // Logical length of the tile in any DiagDirection used in vehicle movement.
29 const uint TILE_CORNER_DISTANCE = 128; // Logical length of the tile corner crossing in any non-diagonal direction used in vehicle movement.
30
32 enum VehStatus {
33 VS_HIDDEN = 0x01,
34 VS_STOPPED = 0x02,
35 VS_UNCLICKABLE = 0x04,
36 VS_DEFPAL = 0x08,
37 VS_TRAIN_SLOWING = 0x10,
38 VS_SHADOW = 0x20,
39 VS_AIRCRAFT_BROKEN = 0x40,
40 VS_CRASHED = 0x80,
41 };
42
44 enum VehicleFlags {
45 VF_LOADING_FINISHED,
46 VF_CARGO_UNLOADING,
47 VF_BUILT_AS_PROTOTYPE,
48 VF_TIMETABLE_STARTED,
49 VF_AUTOFILL_TIMETABLE,
50 VF_AUTOFILL_PRES_WAIT_TIME,
51 VF_STOP_LOADING,
52 VF_PATHFINDER_LOST,
53 VF_SERVINT_IS_CUSTOM,
54 VF_SERVINT_IS_PERCENT,
55 };
56
58 enum NewGRFCacheValidValues {
59 NCVV_POSITION_CONSIST_LENGTH = 0,
60 NCVV_POSITION_SAME_ID_LENGTH = 1,
61 NCVV_CONSIST_CARGO_INFORMATION = 2,
62 NCVV_COMPANY_INFORMATION = 3,
63 NCVV_POSITION_IN_VEHICLE = 4,
64 NCVV_END,
65 };
66
68 struct NewGRFCache {
69 /* Values calculated when they are requested for the first time after invalidating the NewGRF cache. */
70 uint32_t position_consist_length;
71 uint32_t position_same_id_length;
72 uint32_t consist_cargo_information;
73 uint32_t company_information;
74 uint32_t position_in_vehicle;
75 uint8_t cache_valid;
76 };
77
79 enum VisualEffect {
80 VE_OFFSET_START = 0,
81 VE_OFFSET_COUNT = 4,
82 VE_OFFSET_CENTRE = 8,
83
84 VE_TYPE_START = 4,
85 VE_TYPE_COUNT = 2,
86 VE_TYPE_DEFAULT = 0,
87 VE_TYPE_STEAM = 1,
88 VE_TYPE_DIESEL = 2,
89 VE_TYPE_ELECTRIC = 3,
90
91 VE_DISABLE_EFFECT = 6,
92 VE_ADVANCED_EFFECT = VE_DISABLE_EFFECT,
93 VE_DISABLE_WAGON_POWER = 7,
94
95 VE_DEFAULT = 0xFF,
96 };
97
99 enum VisualEffectSpawnModel {
100 VESM_NONE = 0,
101 VESM_STEAM,
102 VESM_DIESEL,
103 VESM_ELECTRIC,
104
105 VESM_END
106 };
107
113 enum GroundVehicleSubtypeFlags {
114 GVSF_FRONT = 0,
115 GVSF_ARTICULATED_PART = 1,
116 GVSF_WAGON = 2,
117 GVSF_ENGINE = 3,
118 GVSF_FREE_WAGON = 4,
119 GVSF_MULTIHEADED = 5,
120 };
121
123 struct VehicleCache {
124 uint16_t cached_max_speed;
125 uint16_t cached_cargo_age_period;
126
127 byte cached_vis_effect;
128 };
129
131 struct VehicleSpriteSeq {
132 PalSpriteID seq[8];
133 uint count;
134
135 bool operator==(const VehicleSpriteSeq &other) const
136 {
137 return this->count == other.count && MemCmpT<PalSpriteID>(this->seq, other.seq, this->count) == 0;
138 }
139
140 bool operator!=(const VehicleSpriteSeq &other) const
141 {
142 return !this->operator==(other);
143 }
144
148 bool IsValid() const
149 {
150 return this->count != 0;
151 }
152
156 void Clear()
157 {
158 this->count = 0;
159 }
160
164 void Set(SpriteID sprite)
165 {
166 this->count = 1;
167 this->seq[0].sprite = sprite;
168 this->seq[0].pal = 0;
169 }
170
174 void CopyWithoutPalette(const VehicleSpriteSeq &src)
175 {
176 this->count = src.count;
177 for (uint i = 0; i < src.count; ++i) {
178 this->seq[i].sprite = src.seq[i].sprite;
179 this->seq[i].pal = 0;
180 }
181 }
182
183 void GetBounds(Rect *bounds) const;
184 void Draw(int x, int y, PaletteID default_pal, bool force_pal) const;
185 };
186
191 struct MutableSpriteCache {
192 Direction last_direction;
193 bool revalidate_before_draw;
194 Rect old_coord;
195 bool is_viewport_candidate;
196 VehicleSpriteSeq sprite_seq;
197 };
198
200 typedef Pool<Vehicle, VehicleID, 512, 0xFF000> VehiclePool;
201 extern VehiclePool _vehicle_pool;
202
203 /* Some declarations of functions, so we can make them friendly */
204 struct GroundVehicleCache;
205 struct LoadgameState;
206 extern bool LoadOldVehicle(LoadgameState *ls, int num);
207 extern void FixOldVehicles();
208
209 struct GRFFile;
210
214 struct RefitDesc {
215 CargoID cargo;
216 uint16_t capacity;
217 uint16_t remaining;
218 RefitDesc(CargoID cargo, uint16_t capacity, uint16_t remaining) :
219 cargo(cargo), capacity(capacity), remaining(remaining) {}
220 };
221
226 struct ClosestDepot {
227 TileIndex location;
228 DestinationID destination;
229 bool reverse;
230 bool found;
231
232 ClosestDepot() :
233 location(INVALID_TILE), destination(0), reverse(false), found(false) {}
234
235 ClosestDepot(TileIndex location, DestinationID destination, bool reverse = false) :
236 location(location), destination(destination), reverse(reverse), found(true) {}
237 };
238
240 struct Vehicle : VehiclePool::PoolItem<&_vehicle_pool>, BaseVehicle, BaseConsist {
241 private:
242 typedef std::list<RefitDesc> RefitList;
243
244 Vehicle *next;
245 Vehicle *previous;
246 Vehicle *first;
247
248 Vehicle *next_shared;
249 Vehicle *previous_shared;
250
251 public:
252 friend void FixOldVehicles();
253 friend void AfterLoadVehicles(bool part_of_load);
254 friend bool LoadOldVehicle(LoadgameState *ls, int num);
255 /* So we can use private/protected variables in the saveload code */
256 friend class SlVehicleCommon;
257 friend class SlVehicleDisaster;
258 friend void Ptrs_VEHS();
259
260 TileIndex tile;
261
267 TileIndex dest_tile;
268
269 Money profit_this_year;
270 Money profit_last_year;
271 Money value;
272
273 CargoPayment *cargo_payment;
274
275 mutable Rect coord;
276
277 Vehicle *hash_viewport_next;
278 Vehicle **hash_viewport_prev;
279
280 Vehicle *hash_tile_next;
281 Vehicle **hash_tile_prev;
282 Vehicle **hash_tile_current;
283
284 SpriteID colourmap;
285
286 /* Related to age and service time */
287 TimerGameCalendar::Year build_year;
288 TimerGameCalendar::Date age;
289 TimerGameEconomy::Date economy_age;
290 TimerGameCalendar::Date max_age;
291 TimerGameEconomy::Date date_of_last_service;
292 TimerGameCalendar::Date date_of_last_service_newgrf;
293 uint16_t reliability;
294 uint16_t reliability_spd_dec;
295 byte breakdown_ctr;
296 byte breakdown_delay;
297 byte breakdowns_since_last_service;
298 byte breakdown_chance;
299
300 int32_t x_pos;
301 int32_t y_pos;
302 int32_t z_pos;
303 Direction direction;
304
305 Owner owner;
306
311 byte spritenum;
312 byte x_extent;
313 byte y_extent;
314 byte z_extent;
315 int8_t x_bb_offs;
316 int8_t y_bb_offs;
317 int8_t x_offs;
318 int8_t y_offs;
319 EngineID engine_type;
320
321 TextEffectID fill_percent_te_id;
322 UnitID unitnumber;
323
324 uint16_t cur_speed;
325 byte subspeed;
326 byte acceleration;
327 uint32_t motion_counter;
328 byte progress;
329
330 uint16_t random_bits;
331 byte waiting_triggers;
332
333 StationID last_station_visited;
334 StationID last_loading_station;
335 TimerGameTick::TickCounter last_loading_tick;
336
337 CargoID cargo_type;
338 byte cargo_subtype;
339 uint16_t cargo_cap;
340 uint16_t refit_cap;
341 VehicleCargoList cargo;
342 uint16_t cargo_age_counter;
343 int8_t trip_occupancy;
344
345 byte day_counter;
346 byte tick_counter;
347 byte running_ticks;
348
349 byte vehstatus;
350 Order current_order;
351
352 union {
353 OrderList *orders;
354 Order *old_orders;
355 };
356
357 uint16_t load_unload_ticks;
358 GroupID group_id;
359 byte subtype;
360
361 NewGRFCache grf_cache;
362 VehicleCache vcache;
363
364 mutable MutableSpriteCache sprite_cache;
365
370 virtual uint16_t GetMaxWeight() const
371 {
372 return 0;
373 }
374
375 Vehicle(VehicleType type = VEH_INVALID);
376
377 void PreDestructor();
379 virtual ~Vehicle();
380
381 void BeginLoading();
382 void CancelReservation(StationID next, Station *st);
383 void LeaveStation();
384
385 GroundVehicleCache *GetGroundVehicleCache();
386 const GroundVehicleCache *GetGroundVehicleCache() const;
387
388 uint16_t &GetGroundVehicleFlags();
389 const uint16_t &GetGroundVehicleFlags() const;
390
391 void DeleteUnreachedImplicitOrders();
392
393 void HandleLoading(bool mode = false);
394
403 virtual void MarkDirty() {}
404
409 virtual void UpdateDeltaXY() {}
410
424 inline uint GetOldAdvanceSpeed(uint speed)
425 {
426 return (this->direction & 1) ? speed : speed * 3 / 4;
427 }
428
441 static inline uint GetAdvanceSpeed(uint speed)
442 {
443 return speed * 3 / 4;
444 }
445
453 inline uint GetAdvanceDistance()
454 {
455 return (this->direction & 1) ? TILE_AXIAL_DISTANCE : TILE_CORNER_DISTANCE * 2;
456 }
457
462 virtual ExpensesType GetExpenseType([[maybe_unused]] bool income) const { return EXPENSES_OTHER; }
463
468 virtual void PlayLeaveStationSound([[maybe_unused]] bool force = false) const {}
469
473 virtual bool IsPrimaryVehicle() const { return false; }
474
475 const Engine *GetEngine() const;
476
482 virtual void GetImage([[maybe_unused]] Direction direction, [[maybe_unused]] EngineImageType image_type, [[maybe_unused]] VehicleSpriteSeq *result) const { result->Clear(); }
483
484 const GRFFile *GetGRF() const;
485 uint32_t GetGRFID() const;
486
491 inline void InvalidateNewGRFCache()
492 {
493 this->grf_cache.cache_valid = 0;
494 }
495
500 inline void InvalidateNewGRFCacheOfChain()
501 {
502 for (Vehicle *u = this; u != nullptr; u = u->Next()) {
503 u->InvalidateNewGRFCache();
504 }
505 }
506
511 debug_inline bool IsGroundVehicle() const
512 {
513 return this->type == VEH_TRAIN || this->type == VEH_ROAD;
514 }
515
520 virtual int GetDisplaySpeed() const { return 0; }
521
526 virtual int GetDisplayMaxSpeed() const { return 0; }
527
532 virtual int GetCurrentMaxSpeed() const { return 0; }
533
538 virtual Money GetRunningCost() const { return 0; }
539
544 virtual bool IsInDepot() const { return false; }
545
550 virtual bool IsChainInDepot() const { return this->IsInDepot(); }
551
556 bool IsStoppedInDepot() const
557 {
558 assert(this == this->First());
559 /* Free wagons have no VS_STOPPED state */
560 if (this->IsPrimaryVehicle() && !(this->vehstatus & VS_STOPPED)) return false;
561 return this->IsChainInDepot();
562 }
563
568 virtual bool Tick() { return true; };
569
573 virtual void OnNewCalendarDay() {};
574
578 virtual void OnNewEconomyDay() {};
579
580 void ShiftDates(TimerGameEconomy::Date interval);
581
587 virtual uint Crash(bool flooded = false);
588
601 virtual Trackdir GetVehicleTrackdir() const { return INVALID_TRACKDIR; }
602
607 Money GetDisplayRunningCost() const { return (this->GetRunningCost() >> 8); }
608
613 Money GetDisplayProfitThisYear() const { return (this->profit_this_year >> 8); }
614
619 Money GetDisplayProfitLastYear() const { return (this->profit_last_year >> 8); }
620
621 void SetNext(Vehicle *next);
622
628 inline Vehicle *Next() const { return this->next; }
629
635 inline Vehicle *Previous() const { return this->previous; }
636
641 inline Vehicle *First() const { return this->first; }
642
647 inline Vehicle *Last()
648 {
649 Vehicle *v = this;
650 while (v->Next() != nullptr) v = v->Next();
651 return v;
652 }
653
658 inline const Vehicle *Last() const
659 {
660 const Vehicle *v = this;
661 while (v->Next() != nullptr) v = v->Next();
662 return v;
663 }
664
670 inline Vehicle *Move(int n)
671 {
672 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
686 inline const Vehicle *Move(int n) const
687 {
688 const Vehicle *v = this;
689 if (n < 0) {
690 for (int i = 0; i != n && v != nullptr; i--) v = v->Previous();
691 } else {
692 for (int i = 0; i != n && v != nullptr; i++) v = v->Next();
693 }
694 return v;
695 }
696
701 inline Order *GetFirstOrder() const { return (this->orders == nullptr) ? nullptr : this->orders->GetFirstOrder(); }
702
703 void AddToShared(Vehicle *shared_chain);
704 void RemoveFromShared();
705
710 inline Vehicle *NextShared() const { return this->next_shared; }
711
716 inline Vehicle *PreviousShared() const { return this->previous_shared; }
717
722 inline Vehicle *FirstShared() const { return (this->orders == nullptr) ? this->First() : this->orders->GetFirstSharedVehicle(); }
723
728 inline bool IsOrderListShared() const { return this->orders != nullptr && this->orders->IsShared(); }
729
734 inline VehicleOrderID GetNumOrders() const { return (this->orders == nullptr) ? 0 : this->orders->GetNumOrders(); }
735
740 inline VehicleOrderID GetNumManualOrders() const { return (this->orders == nullptr) ? 0 : this->orders->GetNumManualOrders(); }
741
746 inline StationIDStack GetNextStoppingStation() const
747 {
748 return (this->orders == nullptr) ? INVALID_STATION : this->orders->GetNextStoppingStation(this);
749 }
750
751 void ResetRefitCaps();
752
753 void ReleaseUnitNumber();
754
761 inline void CopyVehicleConfigAndStatistics(Vehicle *src)
762 {
763 this->CopyConsistPropertiesFrom(src);
764
765 this->ReleaseUnitNumber();
766 this->unitnumber = src->unitnumber;
767
768 this->current_order = src->current_order;
769 this->dest_tile = src->dest_tile;
770
771 this->profit_this_year = src->profit_this_year;
772 this->profit_last_year = src->profit_last_year;
773
774 src->unitnumber = 0;
775 }
776
777
778 bool HandleBreakdown();
779
780 bool NeedsAutorenewing(const Company *c, bool use_renew_setting = true) const;
781
782 bool NeedsServicing() const;
783 bool NeedsAutomaticServicing() const;
784
792 virtual TileIndex GetOrderStationLocation([[maybe_unused]] StationID station) { return INVALID_TILE; }
793
794 virtual TileIndex GetCargoTile() const { return this->tile; }
795
801 virtual ClosestDepot FindClosestDepot() { return {}; }
802
803 virtual void SetDestTile(TileIndex tile) { this->dest_tile = tile; }
804
805 CommandCost SendToDepot(DoCommandFlag flags, DepotCommand command);
806
807 void UpdateVisualEffect(bool allow_power_change = true);
808 void ShowVisualEffect() const;
809
810 void UpdatePosition();
811 void UpdateViewport(bool dirty);
812 void UpdateBoundingBoxCoordinates(bool update_cache) const;
813 void UpdatePositionAndViewport();
814 bool MarkAllViewportsDirty() const;
815
816 inline uint16_t GetServiceInterval() const { return this->service_interval; }
817
818 inline void SetServiceInterval(uint16_t interval) { this->service_interval = interval; }
819
820 inline bool ServiceIntervalIsCustom() const { return HasBit(this->vehicle_flags, VF_SERVINT_IS_CUSTOM); }
821
822 inline bool ServiceIntervalIsPercent() const { return HasBit(this->vehicle_flags, VF_SERVINT_IS_PERCENT); }
823
824 inline void SetServiceIntervalIsCustom(bool on) { SB(this->vehicle_flags, VF_SERVINT_IS_CUSTOM, 1, on); }
825
826 inline void SetServiceIntervalIsPercent(bool on) { SB(this->vehicle_flags, VF_SERVINT_IS_PERCENT, 1, on); }
827
828 bool HasFullLoadOrder() const;
829 bool HasConditionalOrder() const;
830 bool HasUnbunchingOrder() const;
831 void LeaveUnbunchingDepot();
832 bool IsWaitingForUnbunching() const;
833
834 private:
839 void SkipToNextRealOrderIndex()
840 {
841 if (this->GetNumManualOrders() > 0) {
842 /* Advance to next real order */
843 do {
844 this->cur_real_order_index++;
845 if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
846 } while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT));
847 } else {
848 this->cur_real_order_index = 0;
849 }
850 }
851
852 public:
858 void IncrementImplicitOrderIndex()
859 {
860 if (this->cur_implicit_order_index == this->cur_real_order_index) {
861 /* Increment real order index as well */
862 this->SkipToNextRealOrderIndex();
863 }
864
865 assert(this->cur_real_order_index == 0 || this->cur_real_order_index < this->GetNumOrders());
866
867 /* Advance to next implicit order */
868 do {
869 this->cur_implicit_order_index++;
870 if (this->cur_implicit_order_index >= this->GetNumOrders()) this->cur_implicit_order_index = 0;
871 } while (this->cur_implicit_order_index != this->cur_real_order_index && !this->GetOrder(this->cur_implicit_order_index)->IsType(OT_IMPLICIT));
872
873 InvalidateVehicleOrder(this, 0);
874 }
875
882 void IncrementRealOrderIndex()
883 {
884 if (this->cur_implicit_order_index == this->cur_real_order_index) {
885 /* Increment both real and implicit order */
886 this->IncrementImplicitOrderIndex();
887 } else {
888 /* Increment real order only */
889 this->SkipToNextRealOrderIndex();
890 InvalidateVehicleOrder(this, 0);
891 }
892 }
893
897 void UpdateRealOrderIndex()
898 {
899 /* Make sure the index is valid */
900 if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
901
902 if (this->GetNumManualOrders() > 0) {
903 /* Advance to next real order */
904 while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT)) {
905 this->cur_real_order_index++;
906 if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
907 }
908 } else {
909 this->cur_real_order_index = 0;
910 }
911 }
912
918 inline Order *GetOrder(int index) const
919 {
920 return (this->orders == nullptr) ? nullptr : this->orders->GetOrderAt(index);
921 }
922
927 inline Order *GetLastOrder() const
928 {
929 return (this->orders == nullptr) ? nullptr : this->orders->GetLastOrder();
930 }
931
932 bool IsEngineCountable() const;
933 bool HasEngineType() const;
934 bool HasDepotOrder() const;
935 void HandlePathfindingResult(bool path_found);
936
941 debug_inline bool IsFrontEngine() const
942 {
943 return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_FRONT);
944 }
945
950 inline bool IsArticulatedPart() const
951 {
952 return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_ARTICULATED_PART);
953 }
954
959 inline bool HasArticulatedPart() const
960 {
961 return this->Next() != nullptr && this->Next()->IsArticulatedPart();
962 }
963
969 inline Vehicle *GetNextArticulatedPart() const
970 {
971 assert(this->HasArticulatedPart());
972 return this->Next();
973 }
974
979 inline Vehicle *GetFirstEnginePart()
980 {
981 Vehicle *v = this;
982 while (v->IsArticulatedPart()) v = v->Previous();
983 return v;
984 }
985
990 inline const Vehicle *GetFirstEnginePart() const
991 {
992 const Vehicle *v = this;
993 while (v->IsArticulatedPart()) v = v->Previous();
994 return v;
995 }
996
1001 inline Vehicle *GetLastEnginePart()
1002 {
1003 Vehicle *v = this;
1004 while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
1005 return v;
1006 }
1007
1012 inline Vehicle *GetNextVehicle() const
1013 {
1014 const Vehicle *v = this;
1015 while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
1016
1017 /* v now contains the last articulated part in the engine */
1018 return v->Next();
1019 }
1020
1025 inline Vehicle *GetPrevVehicle() const
1026 {
1027 Vehicle *v = this->Previous();
1028 while (v != nullptr && v->IsArticulatedPart()) v = v->Previous();
1029
1030 return v;
1031 }
1032
1037 struct OrderIterator {
1038 typedef Order value_type;
1039 typedef Order *pointer;
1040 typedef Order &reference;
1041 typedef size_t difference_type;
1042 typedef std::forward_iterator_tag iterator_category;
1043
1044 explicit OrderIterator(OrderList *list) : list(list), prev(nullptr)
1045 {
1046 this->order = (this->list == nullptr) ? nullptr : this->list->GetFirstOrder();
1047 }
1048
1049 bool operator==(const OrderIterator &other) const { return this->order == other.order; }
1050 bool operator!=(const OrderIterator &other) const { return !(*this == other); }
1051 Order * operator*() const { return this->order; }
1052 OrderIterator & operator++()
1053 {
1054 this->prev = (this->prev == nullptr) ? this->list->GetFirstOrder() : this->prev->next;
1055 this->order = (this->prev == nullptr) ? nullptr : this->prev->next;
1056 return *this;
1057 }
1058
1059 private:
1060 OrderList *list;
1061 Order *order;
1062 Order *prev;
1063 };
1064
1068 struct IterateWrapper {
1069 OrderList *list;
1070 IterateWrapper(OrderList *list = nullptr) : list(list) {}
1071 OrderIterator begin() { return OrderIterator(this->list); }
1072 OrderIterator end() { return OrderIterator(nullptr); }
1073 bool empty() { return this->begin() == this->end(); }
1074 };
1075
1080 IterateWrapper Orders() const { return IterateWrapper(this->orders); }
1081
1082 uint32_t GetDisplayMaxWeight() const;
1083 uint32_t GetDisplayMinPowerToWeight() const;
1084 };
1085
1090 template <class T, VehicleType Type>
1091 struct SpecializedVehicle : public Vehicle {
1092 static const VehicleType EXPECTED_TYPE = Type;
1093
1094 typedef SpecializedVehicle<T, Type> SpecializedVehicleBase;
1095
1099 inline SpecializedVehicle<T, Type>() : Vehicle(Type)
1100 {
1101 this->sprite_cache.sprite_seq.count = 1;
1102 }
1103
1108 inline T *First() const { return (T *)this->Vehicle::First(); }
1109
1114 inline T *Last() { return (T *)this->Vehicle::Last(); }
1115
1120 inline const T *Last() const { return (const T *)this->Vehicle::Last(); }
1121
1126 inline T *Next() const { return (T *)this->Vehicle::Next(); }
1127
1132 inline T *Previous() const { return (T *)this->Vehicle::Previous(); }
1133
1139 inline T *GetNextArticulatedPart() { return (T *)this->Vehicle::GetNextArticulatedPart(); }
1140
1146 inline T *GetNextArticulatedPart() const { return (T *)this->Vehicle::GetNextArticulatedPart(); }
1147
1152 inline T *GetFirstEnginePart() { return (T *)this->Vehicle::GetFirstEnginePart(); }
1153
1158 inline const T *GetFirstEnginePart() const { return (const T *)this->Vehicle::GetFirstEnginePart(); }
1159
1164 inline T *GetLastEnginePart() { return (T *)this->Vehicle::GetLastEnginePart(); }
1165
1170 inline T *GetNextVehicle() const { return (T *)this->Vehicle::GetNextVehicle(); }
1171
1176 inline T *GetPrevVehicle() const { return (T *)this->Vehicle::GetPrevVehicle(); }
1177
1183 static inline bool IsValidID(size_t index)
1184 {
1185 return Vehicle::IsValidID(index) && Vehicle::Get(index)->type == Type;
1186 }
1187
1192 static inline T *Get(size_t index)
1193 {
1194 return (T *)Vehicle::Get(index);
1195 }
1196
1201 static inline T *GetIfValid(size_t index)
1202 {
1203 return IsValidID(index) ? Get(index) : nullptr;
1204 }
1205
1211 static inline T *From(Vehicle *v)
1212 {
1213 assert(v->type == Type);
1214 return (T *)v;
1215 }
1216
1222 static inline const T *From(const Vehicle *v)
1223 {
1224 assert(v->type == Type);
1225 return (const T *)v;
1226 }
1227
1233 inline void UpdateViewport(bool force_update, bool update_delta)
1234 {
1235 bool sprite_has_changed = false;
1236
1237 /* Skip updating sprites on dedicated servers without screen */
1238 if (_network_dedicated) return;
1239
1240 /* Explicitly choose method to call to prevent vtable dereference -
1241 * it gives ~3% runtime improvements in games with many vehicles */
1242 if (update_delta) ((T *)this)->T::UpdateDeltaXY();
1243
1244 /*
1245 * Only check for a new sprite sequence if the vehicle direction
1246 * has changed since we last checked it, assuming that otherwise
1247 * there won't be enough change in bounding box or offsets to need
1248 * to resolve a new sprite.
1249 */
1250 if (this->direction != this->sprite_cache.last_direction || this->sprite_cache.is_viewport_candidate) {
1251 VehicleSpriteSeq seq;
1252
1253 ((T*)this)->T::GetImage(this->direction, EIT_ON_MAP, &seq);
1254 if (this->sprite_cache.sprite_seq != seq) {
1255 sprite_has_changed = true;
1256 this->sprite_cache.sprite_seq = seq;
1257 }
1258
1259 this->sprite_cache.last_direction = this->direction;
1260 this->sprite_cache.revalidate_before_draw = false;
1261 } else {
1262 /*
1263 * A change that could potentially invalidate the sprite has been
1264 * made, signal that we should still resolve it before drawing on a
1265 * viewport.
1266 */
1267 this->sprite_cache.revalidate_before_draw = true;
1268 }
1269
1270 if (force_update || sprite_has_changed) {
1271 this->Vehicle::UpdateViewport(true);
1272 }
1273 }
1274
1280 static Pool::IterateWrapper<T> Iterate(size_t from = 0) { return Pool::IterateWrapper<T>(from); }
1281 };
1282
1284 static const int32_t INVALID_COORD = 0x7fffffff;
1285
1286 #endif /* VEHICLE_BASE_H */
SpecializedVehicle::GetNextVehicle
T * GetNextVehicle() const
Get the next real (non-articulated part) vehicle in the consist.
Definition: vehicle_base.h:1170
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:117
Vehicle::GetGroundVehicleCache
GroundVehicleCache * GetGroundVehicleCache()
Access the ground vehicle cache of the vehicle.
Definition: vehicle.cpp:3148
Vehicle::IsChainInDepot
virtual bool IsChainInDepot() const
Check whether the whole vehicle chain is in the depot.
Definition: vehicle_base.h:550
Vehicle::IsFrontEngine
debug_inline bool IsFrontEngine() const
Check if the vehicle is a front engine.
Definition: vehicle_base.h:941
BaseConsist::cur_implicit_order_index
VehicleOrderID cur_implicit_order_index
The index to the current implicit order.
Definition: base_consist.h:32
Vehicle::x_bb_offs
int8_t x_bb_offs
x offset of vehicle bounding box
Definition: vehicle_base.h:315
Vehicle::SkipToNextRealOrderIndex
void SkipToNextRealOrderIndex()
Advance cur_real_order_index to the next real order.
Definition: vehicle_base.h:839
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:195
transport_type.h
LoadgameState
Definition: oldloader.h:19
SmallStack
Minimal stack that uses a pool to avoid pointers.
Definition: smallstack_type.hpp:135
MutableSpriteCache::last_direction
Direction last_direction
Last direction we obtained sprites for.
Definition: vehicle_base.h:192
VE_OFFSET_COUNT
@ VE_OFFSET_COUNT
Number of bits used for the offset.
Definition: vehicle_base.h:81
VehicleCache::cached_cargo_age_period
uint16_t cached_cargo_age_period
Number of ticks before carried cargo is aged.
Definition: vehicle_base.h:125
VE_DISABLE_EFFECT
@ VE_DISABLE_EFFECT
Flag to disable visual effect.
Definition: vehicle_base.h:91
Vehicle::PreDestructor
void PreDestructor()
Destroy all stuff that (still) needs the virtual functions to work properly.
Definition: vehicle.cpp:826
UnitID
uint16_t UnitID
Type for the company global vehicle unit number.
Definition: transport_type.h:16
Pool::PoolItem<&_vehicle_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:339
Direction
Direction
Defines the 8 directions on the map.
Definition: direction_type.h:24
SpecializedVehicle::SpecializedVehicleBase
SpecializedVehicle< T, Type > SpecializedVehicleBase
Our type.
Definition: vehicle_base.h:1094
MutableSpriteCache::sprite_seq
VehicleSpriteSeq sprite_seq
Vehicle appearance.
Definition: vehicle_base.h:196
VehicleSpriteSeq::CopyWithoutPalette
void CopyWithoutPalette(const VehicleSpriteSeq &src)
Copy data from another sprite sequence, while dropping all recolouring information.
Definition: vehicle_base.h:174
Vehicle::PreviousShared
Vehicle * PreviousShared() const
Get the previous vehicle of the shared vehicle chain.
Definition: vehicle_base.h:716
Vehicle::GetNumManualOrders
VehicleOrderID GetNumManualOrders() const
Get the number of manually added orders this vehicle has.
Definition: vehicle_base.h:740
Vehicle::reliability_spd_dec
uint16_t reliability_spd_dec
Reliability decrease speed.
Definition: vehicle_base.h:294
Vehicle::GetRunningCost
virtual Money GetRunningCost() const
Gets the running cost of a vehicle.
Definition: vehicle_base.h:538
Vehicle::value
Money value
Value of the vehicle.
Definition: vehicle_base.h:271
_vehicle_pool
VehiclePool _vehicle_pool
The pool with all our precious vehicles.
Vehicle::HasEngineType
bool HasEngineType() const
Check whether Vehicle::engine_type has any meaning.
Definition: vehicle.cpp:731
mem_func.hpp
Vehicle::IsEngineCountable
bool IsEngineCountable() const
Check if a vehicle is counted in num_engines in each company struct.
Definition: vehicle.cpp:714
Vehicle::cargo_cap
uint16_t cargo_cap
total capacity
Definition: vehicle_base.h:339
INVALID_COORD
static const int32_t INVALID_COORD
Sentinel for an invalid coordinate.
Definition: vehicle_base.h:1284
Vehicle::Previous
Vehicle * Previous() const
Get the previous vehicle of this vehicle.
Definition: vehicle_base.h:635
Vehicle::GetNextVehicle
Vehicle * GetNextVehicle() const
Get the next real (non-articulated part) vehicle in the consist.
Definition: vehicle_base.h:1012
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:409
Vehicle::LeaveStation
void LeaveStation()
Perform all actions when leaving a station.
Definition: vehicle.cpp:2343
Vehicle::Next
Vehicle * Next() const
Get the next vehicle of this vehicle.
Definition: vehicle_base.h:628
SpecializedVehicle::Next
T * Next() const
Get next vehicle in the chain.
Definition: vehicle_base.h:1126
EXPENSES_OTHER
@ EXPENSES_OTHER
Other expenses.
Definition: economy_type.h:185
timer_game_calendar.h
BaseConsist::service_interval
uint16_t service_interval
The interval for (automatic) servicing; either in days or %.
Definition: base_consist.h:29
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:526
Vehicle::y_extent
byte y_extent
y-extent of vehicle bounding box
Definition: vehicle_base.h:313
Station
Station data structure.
Definition: station_base.h:442
Vehicle::NeedsAutomaticServicing
bool NeedsAutomaticServicing() const
Checks if the current order should be interrupted for a service-in-depot order.
Definition: vehicle.cpp:272
Vehicle::GetLastEnginePart
Vehicle * GetLastEnginePart()
Get the last part of an articulated engine.
Definition: vehicle_base.h:1001
VehicleSpriteSeq::Clear
void Clear()
Clear all information.
Definition: vehicle_base.h:156
VehicleSpriteSeq::Set
void Set(SpriteID sprite)
Assign a single sprite to the sequence.
Definition: vehicle_base.h:164
Vehicle::old_orders
Order * old_orders
Only used during conversion of old save games.
Definition: vehicle_base.h:354
Vehicle::vehstatus
byte vehstatus
Status.
Definition: vehicle_base.h:349
VE_DEFAULT
@ VE_DEFAULT
Default value to indicate that visual effect should be based on engine class.
Definition: vehicle_base.h:95
Vehicle::grf_cache
NewGRFCache grf_cache
Cache of often used calculated NewGRF values.
Definition: vehicle_base.h:361
VS_DEFPAL
@ VS_DEFPAL
Use default vehicle palette.
Definition: vehicle_base.h:36
Pool::PoolItem<&_vehicle_pool >::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:238
Vehicle::SetNext
void SetNext(Vehicle *next)
Set the next vehicle of this vehicle.
Definition: vehicle.cpp:2930
order_base.h
Vehicle::GetGRFID
uint32_t GetGRFID() const
Retrieve the GRF ID of the NewGRF the vehicle is tied to.
Definition: vehicle.cpp:767
Vehicle::Crash
virtual uint Crash(bool flooded=false)
Crash the (whole) vehicle chain.
Definition: vehicle.cpp:280
Vehicle::acceleration
byte acceleration
used by train & aircraft
Definition: vehicle_base.h:326
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:358
Vehicle::Vehicle
Vehicle(VehicleType type=VEH_INVALID)
Vehicle constructor.
Definition: vehicle.cpp:361
INVALID_TILE
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:95
GroundVehicleSubtypeFlags
GroundVehicleSubtypeFlags
Enum to handle ground vehicle subtypes.
Definition: vehicle_base.h:113
BaseConsist::vehicle_flags
uint16_t vehicle_flags
Used for gradual loading and other miscellaneous things (.
Definition: base_consist.h:34
Vehicle::GetMaxWeight
virtual uint16_t GetMaxWeight() const
Calculates the weight value that this vehicle will have when fully loaded with its current cargo.
Definition: vehicle_base.h:370
Vehicle::trip_occupancy
int8_t trip_occupancy
NOSAVE: Occupancy of vehicle of the current trip (updated after leaving a station).
Definition: vehicle_base.h:343
VE_TYPE_ELECTRIC
@ VE_TYPE_ELECTRIC
Electric sparks.
Definition: vehicle_base.h:89
Vehicle::next
Vehicle * next
pointer to the next vehicle in the chain
Definition: vehicle_base.h:244
Vehicle::GetGRF
const GRFFile * GetGRF() const
Retrieve the NewGRF the vehicle is tied to.
Definition: vehicle.cpp:757
Vehicle::last_loading_tick
TimerGameTick::TickCounter last_loading_tick
Last TimerGameTick::counter tick that the vehicle has stopped at a station and could possibly leave w...
Definition: vehicle_base.h:335
VF_LOADING_FINISHED
@ VF_LOADING_FINISHED
Vehicle has finished loading.
Definition: vehicle_base.h:45
saveload.h
SpecializedVehicle::GetNextArticulatedPart
T * GetNextArticulatedPart()
Get the next part of an articulated engine.
Definition: vehicle_base.h:1139
Vehicle::running_ticks
byte running_ticks
Number of ticks this vehicle was not stopped this day.
Definition: vehicle_base.h:347
Vehicle::~Vehicle
virtual ~Vehicle()
We want to 'destruct' the right class.
Definition: vehicle.cpp:893
base_consist.h
VE_TYPE_COUNT
@ VE_TYPE_COUNT
Number of bits used for the effect type.
Definition: vehicle_base.h:85
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
NewGRFCache::position_in_vehicle
uint32_t position_in_vehicle
Cache for NewGRF var 4D.
Definition: vehicle_base.h:74
VS_TRAIN_SLOWING
@ VS_TRAIN_SLOWING
Train is slowing down.
Definition: vehicle_base.h:37
Vehicle::OrderIterator
Iterator to iterate orders Supports deletion of current order.
Definition: vehicle_base.h:1037
Vehicle::GetNextArticulatedPart
Vehicle * GetNextArticulatedPart() const
Get the next part of an articulated engine.
Definition: vehicle_base.h:969
Vehicle::AfterLoadVehicles
friend void AfterLoadVehicles(bool part_of_load)
So we can set the previous and first pointers while loading.
Definition: vehicle_sl.cpp:255
EngineImageType
EngineImageType
Visualisation contexts of vehicles and engines.
Definition: vehicle_type.h:85
Engine
Definition: engine_base.h:37
Vehicle::FindClosestDepot
virtual ClosestDepot FindClosestDepot()
Find the closest depot for this vehicle and tell us the location, DestinationID and whether we should...
Definition: vehicle_base.h:801
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:240
Vehicle::IsPrimaryVehicle
virtual bool IsPrimaryVehicle() const
Whether this is the primary vehicle in the chain.
Definition: vehicle_base.h:473
OrderList::IsShared
bool IsShared() const
Is this a shared order list?
Definition: order_base.h:339
VehicleSpriteSeq::Draw
void Draw(int x, int y, PaletteID default_pal, bool force_pal) const
Draw the sprite sequence.
Definition: vehicle.cpp:131
Vehicle::owner
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:305
Owner
Owner
Enum for all companies/owners.
Definition: company_type.h:18
TimerGameTick::TickCounter
uint64_t TickCounter
The type that the tick counter is stored in.
Definition: timer_game_tick.h:25
Vehicle::IsInDepot
virtual bool IsInDepot() const
Check whether the vehicle is in the depot.
Definition: vehicle_base.h:544
PaletteID
uint32_t PaletteID
The number of the palette.
Definition: gfx_type.h:18
Vehicle::IsGroundVehicle
debug_inline bool IsGroundVehicle() const
Check if the vehicle is a ground vehicle.
Definition: vehicle_base.h:511
VS_AIRCRAFT_BROKEN
@ VS_AIRCRAFT_BROKEN
Aircraft is broken down.
Definition: vehicle_base.h:39
Vehicle::motion_counter
uint32_t motion_counter
counter to occasionally play a vehicle sound.
Definition: vehicle_base.h:327
DoCommandFlag
DoCommandFlag
List of flags for a command.
Definition: command_type.h:369
VE_OFFSET_START
@ VE_OFFSET_START
First bit that contains the offset (0 = front, 8 = centre, 15 = rear)
Definition: vehicle_base.h:80
Vehicle::breakdowns_since_last_service
byte breakdowns_since_last_service
Counter for the amount of breakdowns.
Definition: vehicle_base.h:297
Vehicle::UpdateRealOrderIndex
void UpdateRealOrderIndex()
Skip implicit orders until cur_real_order_index is a non-implicit order.
Definition: vehicle_base.h:897
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:63
Vehicle::x_pos
int32_t x_pos
x coordinate.
Definition: vehicle_base.h:300
Vehicle::IsArticulatedPart
bool IsArticulatedPart() const
Check if the vehicle is an articulated part of an engine.
Definition: vehicle_base.h:950
VehicleCargoList
CargoList that is used for vehicles.
Definition: cargopacket.h:351
VF_STOP_LOADING
@ VF_STOP_LOADING
Don't load anymore during the next load cycle.
Definition: vehicle_base.h:51
SlVehicleCommon
Definition: vehicle_sl.cpp:635
VE_TYPE_DIESEL
@ VE_TYPE_DIESEL
Diesel fumes.
Definition: vehicle_base.h:88
Vehicle::date_of_last_service
TimerGameEconomy::Date date_of_last_service
Last economy date the vehicle had a service at a depot.
Definition: vehicle_base.h:291
Vehicle::GetImage
virtual void GetImage([[maybe_unused]] Direction direction, [[maybe_unused]] EngineImageType image_type, [[maybe_unused]] VehicleSpriteSeq *result) const
Gets the sprite to show for the given direction.
Definition: vehicle_base.h:482
VESM_STEAM
@ VESM_STEAM
Steam model.
Definition: vehicle_base.h:101
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:607
VehicleCache::cached_max_speed
uint16_t cached_max_speed
Maximum speed of the consist (minimum of the max speed of all vehicles in the consist).
Definition: vehicle_base.h:124
VF_AUTOFILL_TIMETABLE
@ VF_AUTOFILL_TIMETABLE
Whether the vehicle should fill in the timetable automatically.
Definition: vehicle_base.h:49
MutableSpriteCache
Cache for vehicle sprites and values relating to whether they should be updated before drawing,...
Definition: vehicle_base.h:191
Vehicle::Orders
IterateWrapper Orders() const
Returns an iterable ensemble of orders of a vehicle.
Definition: vehicle_base.h:1080
Vehicle::Last
const Vehicle * Last() const
Get the last vehicle of this vehicle chain.
Definition: vehicle_base.h:658
Vehicle::BeginLoading
void BeginLoading()
Prepare everything to begin the loading when arriving at a station.
Definition: vehicle.cpp:2196
NewGRFCache::position_consist_length
uint32_t position_consist_length
Cache for NewGRF var 40.
Definition: vehicle_base.h:70
Vehicle::breakdown_ctr
byte breakdown_ctr
Counter for managing breakdown events.
Definition: vehicle_base.h:295
VS_HIDDEN
@ VS_HIDDEN
Vehicle is not visible.
Definition: vehicle_base.h:33
Vehicle::UpdateVisualEffect
void UpdateVisualEffect(bool allow_power_change=true)
Update the cached visual effect.
Definition: vehicle.cpp:2657
DepotCommand
DepotCommand
Flags for goto depot commands.
Definition: vehicle_type.h:64
VehicleSpriteSeq::IsValid
bool IsValid() const
Check whether the sequence contains any sprites.
Definition: vehicle_base.h:148
Vehicle::dest_tile
TileIndex dest_tile
Heading for this tile.
Definition: vehicle_base.h:267
Vehicle::HandlePathfindingResult
void HandlePathfindingResult(bool path_found)
Handle the pathfinding result, especially the lost status.
Definition: vehicle.cpp:791
Vehicle::GetDisplayProfitThisYear
Money GetDisplayProfitThisYear() const
Gets the profit vehicle had this year.
Definition: vehicle_base.h:613
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:520
Vehicle::GetPrevVehicle
Vehicle * GetPrevVehicle() const
Get the previous real (non-articulated part) vehicle in the consist.
Definition: vehicle_base.h:1025
VE_TYPE_START
@ VE_TYPE_START
First bit used for the type of effect.
Definition: vehicle_base.h:84
GroundVehicleCache
Cached, frequently calculated values.
Definition: ground_vehicle.hpp:29
CommandCost
Common return value for all commands.
Definition: command_type.h:23
OrderList::GetNumManualOrders
VehicleOrderID GetNumManualOrders() const
Get number of manually added orders in the order list.
Definition: order_base.h:326
Vehicle::UpdateBoundingBoxCoordinates
void UpdateBoundingBoxCoordinates(bool update_cache) const
Update the bounding box co-ordinates of the vehicle.
Definition: vehicle.cpp:1695
BaseVehicle
Base vehicle class.
Definition: vehicle_type.h:49
Vehicle::GetCurrentMaxSpeed
virtual int GetCurrentMaxSpeed() const
Calculates the maximum speed of the vehicle under its current conditions.
Definition: vehicle_base.h:532
Vehicle::AddToShared
void AddToShared(Vehicle *shared_chain)
Adds this vehicle to a shared vehicle chain.
Definition: vehicle.cpp:2959
VehStatus
VehStatus
Vehicle status bits in Vehicle::vehstatus.
Definition: vehicle_base.h:32
Vehicle::IsWaitingForUnbunching
bool IsWaitingForUnbunching() const
Check whether a vehicle inside a depot is waiting for unbunching.
Definition: vehicle.cpp:2554
Vehicle::RemoveFromShared
void RemoveFromShared()
Removes the vehicle from the shared order list.
Definition: vehicle.cpp:2982
VF_CARGO_UNLOADING
@ VF_CARGO_UNLOADING
Vehicle is unloading cargo.
Definition: vehicle_base.h:46
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:59
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:260
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:2327
EIT_ON_MAP
@ EIT_ON_MAP
Vehicle drawn in viewport.
Definition: vehicle_type.h:86
Vehicle::random_bits
uint16_t random_bits
Bits used for randomized variational spritegroups.
Definition: vehicle_base.h:330
Vehicle::engine_type
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:319
VS_CRASHED
@ VS_CRASHED
Vehicle is crashed.
Definition: vehicle_base.h:40
VehicleSpriteSeq
Sprite sequence for a vehicle part.
Definition: vehicle_base.h:131
LoadOldVehicle
bool LoadOldVehicle(LoadgameState *ls, int num)
Load the vehicles of an old style savegame.
Definition: oldloader_sl.cpp:1241
OrderList::GetFirstSharedVehicle
Vehicle * GetFirstSharedVehicle() const
Get the first vehicle of this vehicle chain.
Definition: order_base.h:345
Vehicle::last_station_visited
StationID last_station_visited
The last station we stopped at.
Definition: vehicle_base.h:333
Vehicle::GetVehicleTrackdir
virtual Trackdir GetVehicleTrackdir() const
Returns the Trackdir on which the vehicle is currently located.
Definition: vehicle_base.h:601
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:341
Vehicle::GetOldAdvanceSpeed
uint GetOldAdvanceSpeed(uint speed)
Determines the effective direction-specific vehicle movement speed.
Definition: vehicle_base.h:424
RefitDesc::remaining
uint16_t remaining
Capacity remaining from before the previous refit.
Definition: vehicle_base.h:217
VehicleFlags
VehicleFlags
Bit numbers in Vehicle::vehicle_flags.
Definition: vehicle_base.h:44
SpecializedVehicle
Class defining several overloaded accessors so we don't have to cast vehicle types that often.
Definition: vehicle_base.h:1091
Vehicle::hash_tile_current
Vehicle ** hash_tile_current
NOSAVE: Cache of the current hash chain.
Definition: vehicle_base.h:282
GVSF_ARTICULATED_PART
@ GVSF_ARTICULATED_PART
Articulated part of an engine.
Definition: vehicle_base.h:115
Vehicle::current_order
Order current_order
The current order (+ status, like: loading)
Definition: vehicle_base.h:350
NewGRFCache::consist_cargo_information
uint32_t consist_cargo_information
Cache for NewGRF var 42. (Note: The cargotype is untranslated in the cache because the accessing GRF ...
Definition: vehicle_base.h:72
Vehicle::GetExpenseType
virtual ExpensesType GetExpenseType([[maybe_unused]] bool income) const
Sets the expense type associated to this vehicle type.
Definition: vehicle_base.h:462
Vehicle::cur_speed
uint16_t cur_speed
current speed
Definition: vehicle_base.h:324
Vehicle::GetLastOrder
Order * GetLastOrder() const
Returns the last order of a vehicle, or nullptr if it doesn't exists.
Definition: vehicle_base.h:927
Vehicle::build_year
TimerGameCalendar::Year build_year
Year the vehicle has been built.
Definition: vehicle_base.h:287
SpecializedVehicle::Get
static T * Get(size_t index)
Gets vehicle with given index.
Definition: vehicle_base.h:1192
Pool::IterateWrapper
Definition: pool_type.hpp:178
VS_STOPPED
@ VS_STOPPED
Vehicle is stopped by the player.
Definition: vehicle_base.h:34
VehicleCache
Cached often queried values common to all vehicles.
Definition: vehicle_base.h:123
Vehicle::ShowVisualEffect
void ShowVisualEffect() const
Draw visual effects (smoke and/or sparks) for a vehicle chain.
Definition: vehicle.cpp:2780
Vehicle::GetEngine
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition: vehicle.cpp:747
VisualEffectSpawnModel
VisualEffectSpawnModel
Models for spawning visual effects.
Definition: vehicle_base.h:99
cargopacket.h
Vehicle::ResetRefitCaps
void ResetRefitCaps()
Reset all refit_cap in the consist to cargo_cap.
Definition: vehicle.cpp:2404
Vehicle::UpdateViewport
void UpdateViewport(bool dirty)
Update the vehicle on the viewport, updating the right hash and setting the new coordinates.
Definition: vehicle.cpp:1728
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:334
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:53
Vehicle::previous_shared
Vehicle * previous_shared
NOSAVE: pointer to the previous vehicle in the shared order chain.
Definition: vehicle_base.h:249
Vehicle::profit_this_year
Money profit_this_year
Profit this year << 8, low 8 bits are fract.
Definition: vehicle_base.h:269
Vehicle::PlayLeaveStationSound
virtual void PlayLeaveStationSound([[maybe_unused]] bool force=false) const
Play the sound associated with leaving the station.
Definition: vehicle_base.h:468
Vehicle::CopyVehicleConfigAndStatistics
void CopyVehicleConfigAndStatistics(Vehicle *src)
Copy certain configurations and statistics of a vehicle after successful autoreplace/renew The functi...
Definition: vehicle_base.h:761
Vehicle::y_bb_offs
int8_t y_bb_offs
y offset of vehicle bounding box
Definition: vehicle_base.h:316
VehiclePool
Pool< Vehicle, VehicleID, 512, 0xFF000 > VehiclePool
A vehicle pool for a little over 1 million vehicles.
Definition: vehicle_base.h:200
Vehicle::MarkAllViewportsDirty
bool MarkAllViewportsDirty() const
Marks viewports dirty where the vehicle's image is.
Definition: vehicle.cpp:1767
Vehicle::OnNewEconomyDay
virtual void OnNewEconomyDay()
Calls the new economy day handler of the vehicle.
Definition: vehicle_base.h:578
GVSF_WAGON
@ GVSF_WAGON
Wagon (not used for road vehicles).
Definition: vehicle_base.h:116
INVALID_TRACKDIR
@ INVALID_TRACKDIR
Flag for an invalid trackdir.
Definition: track_type.h:86
FixOldVehicles
void FixOldVehicles()
Convert the old style vehicles into something that resembles the old new style savegames.
Definition: oldloader_sl.cpp:163
VehicleCache::cached_vis_effect
byte cached_vis_effect
Visual effect to show (see VisualEffect)
Definition: vehicle_base.h:127
CargoID
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:22
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:2423
Vehicle::HasDepotOrder
bool HasDepotOrder() const
Checks if a vehicle has a depot in its order list.
Definition: order_cmd.cpp:1859
Vehicle::cargo_age_counter
uint16_t cargo_age_counter
Ticks till cargo is aged next.
Definition: vehicle_base.h:342
_network_dedicated
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:68
Vehicle::Move
const Vehicle * Move(int n) const
Get the vehicle at offset n of this vehicle chain.
Definition: vehicle_base.h:686
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:79
Vehicle::SendToDepot
CommandCost SendToDepot(DoCommandFlag flags, DepotCommand command)
Send this vehicle to the depot using the given command(s).
Definition: vehicle.cpp:2576
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:364
SpriteID
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
Vehicle::IsOrderListShared
bool IsOrderListShared() const
Check if we share our orders with another vehicle.
Definition: vehicle_base.h:728
VE_TYPE_DEFAULT
@ VE_TYPE_DEFAULT
Use default from engine class.
Definition: vehicle_base.h:86
Vehicle::colourmap
SpriteID colourmap
NOSAVE: cached colour mapping.
Definition: vehicle_base.h:284
Vehicle::waiting_triggers
byte waiting_triggers
Triggers to be yet matched before rerandomizing the random bits.
Definition: vehicle_base.h:331
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:102
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:882
Vehicle::z_pos
int32_t z_pos
z coordinate.
Definition: vehicle_base.h:302
VF_BUILT_AS_PROTOTYPE
@ VF_BUILT_AS_PROTOTYPE
Vehicle is a prototype (accepted as exclusive preview).
Definition: vehicle_base.h:47
command_type.h
Vehicle::IterateWrapper
Iterable ensemble of orders.
Definition: vehicle_base.h:1068
Vehicle::direction
Direction direction
facing
Definition: vehicle_base.h:303
SpecializedVehicle::EXPECTED_TYPE
static const VehicleType EXPECTED_TYPE
Specialized type.
Definition: vehicle_base.h:1092
BaseConsist::cur_real_order_index
VehicleOrderID cur_real_order_index
The index to the current real (non-implicit) order.
Definition: base_consist.h:31
Vehicle::next_shared
Vehicle * next_shared
pointer to the next vehicle that shares the order
Definition: vehicle_base.h:248
texteff.hpp
Vehicle::load_unload_ticks
uint16_t load_unload_ticks
Ticks to wait before starting next cycle.
Definition: vehicle_base.h:357
Vehicle::FirstShared
Vehicle * FirstShared() const
Get the first vehicle of this vehicle chain.
Definition: vehicle_base.h:722
Vehicle::x_extent
byte x_extent
x-extent of vehicle bounding box
Definition: vehicle_base.h:312
Vehicle::Move
Vehicle * Move(int n)
Get the vehicle at offset n of this vehicle chain.
Definition: vehicle_base.h:670
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:61
Vehicle::GetFirstEnginePart
const Vehicle * GetFirstEnginePart() const
Get the first part of an articulated engine.
Definition: vehicle_base.h:990
Vehicle::vcache
VehicleCache vcache
Cache of often used vehicle values.
Definition: vehicle_base.h:362
NewGRFCache::position_same_id_length
uint32_t position_same_id_length
Cache for NewGRF var 41.
Definition: vehicle_base.h:71
GVSF_FREE_WAGON
@ GVSF_FREE_WAGON
First in a wagon chain (in depot) (not used for road vehicles).
Definition: vehicle_base.h:118
VESM_NONE
@ VESM_NONE
No visual effect.
Definition: vehicle_base.h:100
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:193
Vehicle::hash_viewport_next
Vehicle * hash_viewport_next
NOSAVE: Next vehicle in the visual location hash.
Definition: vehicle_base.h:277
Pool
Base class for all pools.
Definition: pool_type.hpp:80
Vehicle::First
Vehicle * First() const
Get the first vehicle of this vehicle chain.
Definition: vehicle_base.h:641
Vehicle::max_age
TimerGameCalendar::Date max_age
Maximum age.
Definition: vehicle_base.h:290
Vehicle::tick_counter
byte tick_counter
Increased by one for each tick.
Definition: vehicle_base.h:346
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:858
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:60
Vehicle::subspeed
byte subspeed
fractional speed
Definition: vehicle_base.h:325
Vehicle::GetAdvanceSpeed
static uint GetAdvanceSpeed(uint speed)
Determines the effective vehicle movement speed.
Definition: vehicle_base.h:441
Vehicle::GetFirstOrder
Order * GetFirstOrder() const
Get the first order of the vehicles order list.
Definition: vehicle_base.h:701
SpecializedVehicle::From
static T * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Definition: vehicle_base.h:1211
Vehicle::x_offs
int8_t x_offs
x offset for vehicle sprite
Definition: vehicle_base.h:317
Vehicle::z_extent
byte z_extent
z-extent of vehicle bounding box
Definition: vehicle_base.h:314
Vehicle::date_of_last_service_newgrf
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...
Definition: vehicle_base.h:292
Vehicle::GetFirstEnginePart
Vehicle * GetFirstEnginePart()
Get the first part of an articulated engine.
Definition: vehicle_base.h:979
Vehicle::InvalidateNewGRFCacheOfChain
void InvalidateNewGRFCacheOfChain()
Invalidates cached NewGRF variables of all vehicles in the chain (after the current vehicle)
Definition: vehicle_base.h:500
Vehicle::economy_age
TimerGameEconomy::Date economy_age
Age in economy days.
Definition: vehicle_base.h:289
Vehicle::HasFullLoadOrder
bool HasFullLoadOrder() const
Check if the current vehicle has a full load order.
Definition: vehicle.cpp:2458
OrderList
Shared order list linking together the linked list of orders and the list of vehicles sharing this or...
Definition: order_base.h:260
RefitDesc::capacity
uint16_t capacity
Capacity the vehicle will have.
Definition: vehicle_base.h:216
VF_SERVINT_IS_PERCENT
@ VF_SERVINT_IS_PERCENT
Service interval is percent.
Definition: vehicle_base.h:54
Vehicle::cargo_payment
CargoPayment * cargo_payment
The cargo payment we're currently in.
Definition: vehicle_base.h:273
Vehicle::reliability
uint16_t reliability
Reliability.
Definition: vehicle_base.h:293
Vehicle::NextShared
Vehicle * NextShared() const
Get the next vehicle of the shared vehicle chain.
Definition: vehicle_base.h:710
OrderList::GetLastOrder
Order * GetLastOrder() const
Get the last order of the order chain.
Definition: order_base.h:306
VE_DISABLE_WAGON_POWER
@ VE_DISABLE_WAGON_POWER
Flag to disable wagon power.
Definition: vehicle_base.h:93
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:1183
Vehicle::age
TimerGameCalendar::Date age
Age in calendar days.
Definition: vehicle_base.h:288
Vehicle::HasArticulatedPart
bool HasArticulatedPart() const
Check if an engine has an articulated part.
Definition: vehicle_base.h:959
Vehicle::profit_last_year
Money profit_last_year
Profit last year << 8, low 8 bits are fract.
Definition: vehicle_base.h:270
Vehicle::breakdown_chance
byte breakdown_chance
Current chance of breakdowns.
Definition: vehicle_base.h:298
GVSF_MULTIHEADED
@ GVSF_MULTIHEADED
Engine is multiheaded (not used for road vehicles).
Definition: vehicle_base.h:119
GroupID
uint16_t GroupID
Type for all group identifiers.
Definition: group_type.h:13
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:322
ClosestDepot::destination
DestinationID destination
The DestinationID as used for orders.
Definition: vehicle_base.h:228
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:1201
Vehicle::HasUnbunchingOrder
bool HasUnbunchingOrder() const
Check if the current vehicle has an unbunching order.
Definition: vehicle.cpp:2482
VF_AUTOFILL_PRES_WAIT_TIME
@ VF_AUTOFILL_PRES_WAIT_TIME
Whether non-destructive auto-fill should preserve waiting times.
Definition: vehicle_base.h:50
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:1280
Vehicle::LoadOldVehicle
friend bool LoadOldVehicle(LoadgameState *ls, int num)
So we can set the proper next pointer while loading.
Definition: oldloader_sl.cpp:1241
NCVV_END
@ NCVV_END
End of the bits.
Definition: vehicle_base.h:64
VE_ADVANCED_EFFECT
@ VE_ADVANCED_EFFECT
Flag for advanced effects.
Definition: vehicle_base.h:92
Vehicle::hash_viewport_prev
Vehicle ** hash_viewport_prev
NOSAVE: Previous vehicle in the visual location hash.
Definition: vehicle_base.h:278
Vehicle::y_pos
int32_t y_pos
y coordinate.
Definition: vehicle_base.h:301
ClosestDepot
Structure to return information about the closest depot location, and whether it could be found.
Definition: vehicle_base.h:226
Vehicle::breakdown_delay
byte breakdown_delay
Counter for managing breakdown length.
Definition: vehicle_base.h:296
Vehicle::Last
Vehicle * Last()
Get the last vehicle of this vehicle chain.
Definition: vehicle_base.h:647
Vehicle::GetDisplayMaxWeight
uint32_t GetDisplayMaxWeight() const
Calculates the maximum weight of the ground vehicle when loaded.
Definition: vehicle.cpp:3237
Vehicle::coord
Rect coord
NOSAVE: Graphical bounding box of the vehicle, i.e. what to redraw on moves.
Definition: vehicle_base.h:275
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:190
Vehicle::InvalidateNewGRFCache
void InvalidateNewGRFCache()
Invalidates cached NewGRF variables.
Definition: vehicle_base.h:491
network.h
Vehicle::subtype
byte subtype
subtype (Filled with values from AircraftSubType/DisasterSubType/EffectVehicleType/GroundVehicleSubty...
Definition: vehicle_base.h:359
VF_TIMETABLE_STARTED
@ VF_TIMETABLE_STARTED
Whether the vehicle has started running on the timetable yet.
Definition: vehicle_base.h:48
OrderList::GetFirstOrder
Order * GetFirstOrder() const
Get the first order of the order chain.
Definition: order_base.h:298
Vehicle::day_counter
byte day_counter
Increased by one for each day.
Definition: vehicle_base.h:345
VS_UNCLICKABLE
@ VS_UNCLICKABLE
Vehicle is not clickable by the user (shadow vehicles).
Definition: vehicle_base.h:35
NewGRFCacheValidValues
NewGRFCacheValidValues
Bit numbers used to indicate which of the NewGRFCache values are valid.
Definition: vehicle_base.h:58
GVSF_FRONT
@ GVSF_FRONT
Leading engine of a consist.
Definition: vehicle_base.h:114
Vehicle::HasConditionalOrder
bool HasConditionalOrder() const
Check if the current vehicle has a conditional order.
Definition: vehicle.cpp:2470
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:145
VF_PATHFINDER_LOST
@ VF_PATHFINDER_LOST
Vehicle's pathfinder is lost.
Definition: vehicle_base.h:52
Vehicle::ReleaseUnitNumber
void ReleaseUnitNumber()
Release the vehicle's unit number.
Definition: vehicle.cpp:2412
Vehicle::progress
byte progress
The percentage (if divided by 256) this vehicle already crossed the tile unit.
Definition: vehicle_base.h:328
NewGRFCache::company_information
uint32_t company_information
Cache for NewGRF var 43.
Definition: vehicle_base.h:73
OverflowSafeInt< int64_t >
Vehicle::IsStoppedInDepot
bool IsStoppedInDepot() const
Check whether the vehicle is in the depot and stopped.
Definition: vehicle_base.h:556
Vehicle::FixOldVehicles
friend void FixOldVehicles()
Convert the old style vehicles into something that resembles the old new style savegames.
Definition: oldloader_sl.cpp:163
Vehicle::previous
Vehicle * previous
NOSAVE: pointer to the previous vehicle in the chain.
Definition: vehicle_base.h:245
Vehicle::cargo_type
CargoID cargo_type
type of cargo this vehicle is carrying
Definition: vehicle_base.h:337
Vehicle::spritenum
byte spritenum
currently displayed sprite index 0xfd == custom sprite, 0xfe == custom second head sprite 0xff == res...
Definition: vehicle_base.h:311
NCVV_COMPANY_INFORMATION
@ NCVV_COMPANY_INFORMATION
This bit will be set if the NewGRF var 43 currently stored is valid.
Definition: vehicle_base.h:62
SlVehicleDisaster
Definition: vehicle_sl.cpp:983
SpecializedVehicle::GetLastEnginePart
T * GetLastEnginePart()
Get the last part of an articulated engine.
Definition: vehicle_base.h:1164
SB
constexpr T SB(T &x, const uint8_t s, const uint8_t n, const U d)
Set n bits in x starting at bit s to d.
Definition: bitmath_func.hpp:58
Vehicle::OnNewCalendarDay
virtual void OnNewCalendarDay()
Calls the new calendar day handler of the vehicle.
Definition: vehicle_base.h:573
PalSpriteID::pal
PaletteID pal
The palette (use PAL_NONE) if not needed)
Definition: gfx_type.h:24
Vehicle::GetGroundVehicleFlags
uint16_t & GetGroundVehicleFlags()
Access the ground vehicle flags of the vehicle.
Definition: vehicle.cpp:3178
EngineID
uint16_t EngineID
Unique identification number of an engine.
Definition: engine_type.h:21
SpecializedVehicle::Previous
T * Previous() const
Get previous vehicle in the chain.
Definition: vehicle_base.h:1132
Trackdir
Trackdir
Enumeration for tracks and directions.
Definition: track_type.h:67
Vehicle::cargo_subtype
byte cargo_subtype
Used for livery refits (NewGRF variations)
Definition: vehicle_base.h:338
NewGRFCache::cache_valid
uint8_t cache_valid
Bitset that indicates which cache values are valid.
Definition: vehicle_base.h:75
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
Vehicle::GetOrderStationLocation
virtual TileIndex GetOrderStationLocation([[maybe_unused]] StationID station)
Determine the location for the station where the vehicle goes to next.
Definition: vehicle_base.h:792
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:328
Vehicle::GetAdvanceDistance
uint GetAdvanceDistance()
Determines the vehicle "progress" needed for moving a step.
Definition: vehicle_base.h:453
Vehicle::GetOrder
Order * GetOrder(int index) const
Returns order 'index' of a vehicle or nullptr when it doesn't exists.
Definition: vehicle_base.h:918
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:51
Vehicle::Tick
virtual bool Tick()
Calls the tick handler of the vehicle.
Definition: vehicle_base.h:568
Vehicle::UpdatePositionAndViewport
void UpdatePositionAndViewport()
Update the position of the vehicle, and update the viewport.
Definition: vehicle.cpp:1757
SpecializedVehicle::First
T * First() const
Get the first vehicle in the chain.
Definition: vehicle_base.h:1108
Vehicle::UpdatePosition
void UpdatePosition()
Update the position of the vehicle.
Definition: vehicle.cpp:1686
Vehicle::hash_tile_prev
Vehicle ** hash_tile_prev
NOSAVE: Previous vehicle in the tile location hash.
Definition: vehicle_base.h:281
ExpensesType
ExpensesType
Types of expenses.
Definition: economy_type.h:172
Vehicle::HandleBreakdown
bool HandleBreakdown()
Handle all of the aspects of a vehicle breakdown This includes adding smoke and sounds,...
Definition: vehicle.cpp:1359
VESM_ELECTRIC
@ VESM_ELECTRIC
Electric model.
Definition: vehicle_base.h:103
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition: geometry_type.hpp:75
Company
Definition: company_base.h:129
group_type.h
Vehicle::GetNumOrders
VehicleOrderID GetNumOrders() const
Get the number of orders this vehicle has.
Definition: vehicle_base.h:734
BaseConsist
Various front vehicle properties that are preserved when autoreplacing, using order-backup or switchi...
Definition: base_consist.h:17
SpecializedVehicle::Last
T * Last()
Get the last vehicle in the chain.
Definition: vehicle_base.h:1114
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:353
VehicleSpriteSeq::GetBounds
void GetBounds(Rect *bounds) const
Determine shared bounds of all sprites.
Definition: vehicle.cpp:103
Vehicle::hash_tile_next
Vehicle * hash_tile_next
NOSAVE: Next vehicle in the tile location hash.
Definition: vehicle_base.h:280
Pool::PoolItem
Base class for all PoolItems.
Definition: pool_type.hpp:237
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:2157
Vehicle::first
Vehicle * first
NOSAVE: pointer to the first vehicle in the chain.
Definition: vehicle_base.h:246
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:1233
Vehicle::fill_percent_te_id
TextEffectID fill_percent_te_id
a text-effect id to a loading indicator object
Definition: vehicle_base.h:321
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:1176
VS_SHADOW
@ VS_SHADOW
Vehicle is a shadow vehicle.
Definition: vehicle_base.h:38
Vehicle::LeaveUnbunchingDepot
void LeaveUnbunchingDepot()
Leave an unbunching depot and calculate the next departure time for shared order vehicles.
Definition: vehicle.cpp:2507
MutableSpriteCache::old_coord
Rect old_coord
Co-ordinates from the last valid bounding box.
Definition: vehicle_base.h:194
OrderList::GetNumOrders
VehicleOrderID GetNumOrders() const
Get number of orders in the order list.
Definition: order_base.h:320
Vehicle::GetDisplayProfitLastYear
Money GetDisplayProfitLastYear() const
Gets the profit vehicle had last year.
Definition: vehicle_base.h:619
VE_OFFSET_CENTRE
@ VE_OFFSET_CENTRE
Value of offset corresponding to a position above the centre of the vehicle.
Definition: vehicle_base.h:82
Vehicle::ShiftDates
void ShiftDates(TimerGameEconomy::Date interval)
Shift all dates by given interval.
Definition: vehicle.cpp:777
SpecializedVehicle::GetFirstEnginePart
T * GetFirstEnginePart()
Get the first part of an articulated engine.
Definition: vehicle_base.h:1152
VE_TYPE_STEAM
@ VE_TYPE_STEAM
Steam plumes.
Definition: vehicle_base.h:87
RefitDesc
Simulated cargo type and capacity for prediction of future links.
Definition: vehicle_base.h:214
track_type.h
order_func.h
Vehicle::y_offs
int8_t y_offs
y offset for vehicle sprite
Definition: vehicle_base.h:318
Vehicle::MarkDirty
virtual void MarkDirty()
Marks the vehicles to be redrawn and updates cached variables.
Definition: vehicle_base.h:403
GRFFile
Dynamic data of a loaded NewGRF.
Definition: newgrf.h:107
Vehicle::refit_cap
uint16_t refit_cap
Capacity left over from before last refit.
Definition: vehicle_base.h:340
NewGRFCache
Cached often queried (NewGRF) values.
Definition: vehicle_base.h:68
Vehicle::GetNextStoppingStation
StationIDStack GetNextStoppingStation() const
Get the next station the vehicle will stop at.
Definition: vehicle_base.h:746
RefitDesc::cargo
CargoID cargo
Cargo type the vehicle will be carrying.
Definition: vehicle_base.h:215
Vehicle::GetDisplayMinPowerToWeight
uint32_t GetDisplayMinPowerToWeight() const
Calculates the minimum power-to-weight ratio using the maximum weight of the ground vehicle.
Definition: vehicle.cpp:3252
HasBit
constexpr debug_inline bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103