OpenTTD Source 20250613-master-ga1786fa1f4
order_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 ORDER_BASE_H
11#define ORDER_BASE_H
12
13#include "order_type.h"
14#include "core/pool_type.hpp"
15#include "core/bitmath_func.hpp"
16#include "cargo_type.h"
17#include "depot_type.h"
18#include "station_type.h"
19#include "vehicle_type.h"
21#include "saveload/saveload.h"
22
24extern OrderListPool _orderlist_pool;
25
26template <typename, typename>
28
29/* If you change this, keep in mind that it is saved on 3 places:
30 * - Load_ORDR, all the global orders
31 * - Vehicle -> current_order
32 */
33struct Order {
34private:
35 friend struct VEHSChunkHandler;
37 /* So we can use private/protected variables in the saveload code */
38 friend class SlVehicleCommon;
39 friend class SlVehicleDisaster;
40 template <typename T>
41 friend class SlOrders;
42
43 template <typename Tcont, typename Titer>
44 friend EndianBufferWriter<Tcont, Titer> &operator <<(EndianBufferWriter<Tcont, Titer> &buffer, const Order &data);
45 friend class EndianBufferReader &operator >>(class EndianBufferReader &buffer, Order &order);
46
47 uint8_t type = 0;
48 uint8_t flags = 0;
50
52
53 uint16_t wait_time = 0;
54 uint16_t travel_time = 0;
55 uint16_t max_speed = UINT16_MAX;
56
57public:
58 Order() {}
59 Order(uint8_t type, uint8_t flags, DestinationID dest) : type(type), flags(flags), dest(dest) {}
60
66 inline bool IsType(OrderType type) const { return this->GetType() == type; }
67
72 inline OrderType GetType() const { return (OrderType)GB(this->type, 0, 4); }
73
74 void Free();
75
76 void MakeGoToStation(StationID destination);
78 void MakeGoToWaypoint(StationID destination);
79 void MakeLoading(bool ordered);
80 void MakeLeaveStation();
81 void MakeDummy();
83 void MakeImplicit(StationID destination);
84
89 inline bool IsGotoOrder() const
90 {
91 return IsType(OT_GOTO_WAYPOINT) || IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION);
92 }
93
99 inline DestinationID GetDestination() const { return this->dest; }
100
106 inline void SetDestination(DestinationID destination) { this->dest = destination; }
107
113 inline bool IsRefit() const { return this->refit_cargo < NUM_CARGO || this->refit_cargo == CARGO_AUTO_REFIT; }
114
120 inline bool IsAutoRefit() const { return this->refit_cargo == CARGO_AUTO_REFIT; }
121
127 inline CargoType GetRefitCargo() const { return this->refit_cargo; }
128
129 void SetRefit(CargoType cargo);
130
132 inline OrderLoadFlags GetLoadType() const { return (OrderLoadFlags)GB(this->flags, 4, 3); }
134 inline OrderUnloadFlags GetUnloadType() const { return (OrderUnloadFlags)GB(this->flags, 0, 3); }
136 inline OrderNonStopFlags GetNonStopType() const { return (OrderNonStopFlags)GB(this->type, 6, 2); }
138 inline OrderStopLocation GetStopLocation() const { return (OrderStopLocation)GB(this->type, 4, 2); }
140 inline OrderDepotTypeFlags GetDepotOrderType() const { return (OrderDepotTypeFlags)GB(this->flags, 0, 3); }
142 inline OrderDepotActionFlags GetDepotActionType() const { return (OrderDepotActionFlags)GB(this->flags, 3, 4); }
144 inline OrderConditionVariable GetConditionVariable() const { return static_cast<OrderConditionVariable>(GB(this->dest.value, 11, 5)); }
148 inline VehicleOrderID GetConditionSkipToOrder() const { return this->flags; }
150 inline uint16_t GetConditionValue() const { return GB(this->dest.value, 0, 11); }
151
153 inline void SetLoadType(OrderLoadFlags load_type) { SB(this->flags, 4, 3, load_type); }
155 inline void SetUnloadType(OrderUnloadFlags unload_type) { SB(this->flags, 0, 3, unload_type); }
157 inline void SetNonStopType(OrderNonStopFlags non_stop_type) { SB(this->type, 6, 2, non_stop_type); }
159 inline void SetStopLocation(OrderStopLocation stop_location) { SB(this->type, 4, 2, stop_location); }
161 inline void SetDepotOrderType(OrderDepotTypeFlags depot_order_type) { SB(this->flags, 0, 3, depot_order_type); }
163 inline void SetDepotActionType(OrderDepotActionFlags depot_service_type) { SB(this->flags, 3, 4, depot_service_type); }
165 inline void SetConditionVariable(OrderConditionVariable condition_variable) { SB(this->dest.value, 11, 5, condition_variable); }
167 inline void SetConditionComparator(OrderConditionComparator condition_comparator) { SB(this->type, 5, 3, condition_comparator); }
169 inline void SetConditionSkipToOrder(VehicleOrderID order_id) { this->flags = order_id; }
171 inline void SetConditionValue(uint16_t value) { SB(this->dest.value, 0, 11, value); }
172
173 /* As conditional orders write their "skip to" order all over the flags, we cannot check the
174 * flags to find out if timetabling is enabled. However, as conditional orders are never
175 * autofilled we can be sure that any non-zero values for their wait_time and travel_time are
176 * explicitly set (but travel_time is actually unused for conditionals). */
177
179 inline bool IsWaitTimetabled() const { return this->IsType(OT_CONDITIONAL) ? this->wait_time > 0 : HasBit(this->flags, 3); }
181 inline bool IsTravelTimetabled() const { return this->IsType(OT_CONDITIONAL) ? this->travel_time > 0 : HasBit(this->flags, 7); }
182
184 inline uint16_t GetTimetabledWait() const { return this->IsWaitTimetabled() ? this->wait_time : 0; }
186 inline uint16_t GetTimetabledTravel() const { return this->IsTravelTimetabled() ? this->travel_time : 0; }
188 inline uint16_t GetWaitTime() const { return this->wait_time; }
190 inline uint16_t GetTravelTime() const { return this->travel_time; }
191
197 inline uint16_t GetMaxSpeed() const { return this->max_speed; }
198
200 inline void SetWaitTimetabled(bool timetabled) { if (!this->IsType(OT_CONDITIONAL)) AssignBit(this->flags, 3, timetabled); }
202 inline void SetTravelTimetabled(bool timetabled) { if (!this->IsType(OT_CONDITIONAL)) AssignBit(this->flags, 7, timetabled); }
203
208 inline void SetWaitTime(uint16_t time) { this->wait_time = time; }
209
214 inline void SetTravelTime(uint16_t time) { this->travel_time = time; }
215
221 inline void SetMaxSpeed(uint16_t speed) { this->max_speed = speed; }
222
223 bool ShouldStopAtStation(const Vehicle *v, StationID station) const;
224 bool CanLoadOrUnload() const;
225 bool CanLeaveWithCargo(bool has_cargo) const;
226
227 TileIndex GetLocation(const Vehicle *v, bool airport = false) const;
228
230 inline bool IsCompletelyTimetabled() const
231 {
232 if (!this->IsTravelTimetabled() && !this->IsType(OT_CONDITIONAL)) return false;
233 if (!this->IsWaitTimetabled() && this->IsType(OT_GOTO_STATION) &&
235 return false;
236 }
237 return true;
238 }
239
240 void AssignOrder(const Order &other);
241 bool Equals(const Order &other) const;
242
243 uint16_t MapOldOrder() const;
245};
246
249 uint32_t index = 0;
250 uint32_t next = 0;
252};
253
254OldOrderSaveLoadItem *GetOldOrder(size_t pool_index);
255OldOrderSaveLoadItem &AllocateOldOrder(size_t pool_index);
256
257void InsertOrder(Vehicle *v, Order &&new_o, VehicleOrderID sel_ord);
258void DeleteOrder(Vehicle *v, VehicleOrderID sel_ord);
259
264struct OrderList : OrderListPool::PoolItem<&_orderlist_pool> {
265private:
266 friend void AfterLoadVehiclesPhase1(bool part_of_load);
268 friend struct ORDLChunkHandler;
269 template <typename T>
270 friend class SlOrders;
271
273 uint num_vehicles = 0;
275 std::vector<Order> orders;
276 uint32_t old_order_index = 0;
277
280
281public:
284
291 {
292 this->orders.emplace_back(std::move(order));
293 this->Initialize(v);
294 }
295
296 OrderList(std::vector<Order> &&orders, Vehicle *v)
297 {
298 this->orders = std::move(orders);
299 this->Initialize(v);
300 }
301
303 {
304 this->Initialize(v);
305 }
306
309
310 void Initialize(Vehicle *v);
311
313
318 inline VehicleOrderID GetFirstOrder() const { return this->orders.empty() ? INVALID_VEH_ORDER_ID : 0; }
319
320 inline std::span<const Order> GetOrders() const { return this->orders; }
321 inline std::span<Order> GetOrders() { return this->orders; }
322
329 {
330 if (index >= this->GetNumOrders()) return nullptr;
331 return &this->orders[index];
332 }
333
335 {
336 if (index >= this->GetNumOrders()) return nullptr;
337 return &this->orders[index];
338 }
339
344 inline VehicleOrderID GetLastOrder() const { return this->orders.empty() ? INVALID_VEH_ORDER_ID : (this->GetNumOrders() - 1); }
345
353 {
354 if (this->orders.empty()) return INVALID_VEH_ORDER_ID;
355 return static_cast<VehicleOrderID>((cur + 1) % this->GetNumOrders());
356 }
357
362 inline VehicleOrderID GetNumOrders() const { return static_cast<VehicleOrderID>(std::size(this->orders)); }
363
368 inline VehicleOrderID GetNumManualOrders() const { return this->num_manual_orders; }
369
372
376
381 inline bool IsShared() const { return this->num_vehicles > 1; };
382
387 inline Vehicle *GetFirstSharedVehicle() const { return this->first_shared; }
388
393 inline uint GetNumVehicles() const { return this->num_vehicles; }
394
401 inline void AddVehicle([[maybe_unused]] Vehicle *v) { ++this->num_vehicles; }
402
403 void RemoveVehicle(Vehicle *v);
404
405 bool IsCompleteTimetable() const;
406
412
418
423 inline TimerGameTick::Ticks GetTotalDuration() const { return this->total_duration; }
424
430
436
437 void FreeChain(bool keep_orderlist = false);
438
439 void DebugCheckSanity() const;
440};
441
442#endif /* ORDER_BASE_H */
Functions related to bit mathematics.
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr T AssignBit(T &x, const uint8_t y, bool value)
Assigns a bit in a variable.
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.
debug_inline static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
Types related to cargoes...
uint8_t CargoType
Cargo slots to indicate a cargo type within a game.
Definition cargo_type.h:23
static const CargoType CARGO_AUTO_REFIT
Automatically choose cargo type when doing auto refitting.
Definition cargo_type.h:78
static const CargoType NUM_CARGO
Maximum number of cargo types in a game.
Definition cargo_type.h:75
static const CargoType CARGO_NO_REFIT
Do not refit cargo of a vehicle (used in vehicle orders and auto-replace/auto-renew).
Definition cargo_type.h:79
Endian-aware buffer adapter that always reads values in little endian order.
Endian-aware buffer adapter that always writes values in little endian order.
Minimal stack that uses a pool to avoid pointers.
static constexpr TimerGameTick::Ticks INVALID_TICKS
Representation of an invalid number of ticks.
int32_t Ticks
The type to store ticks in.
Header files for depots (not hangars)
void InsertOrder(Vehicle *v, Order &&new_o, VehicleOrderID sel_ord)
Insert a new order but skip the validation.
OldOrderSaveLoadItem * GetOldOrder(size_t pool_index)
Get a pointer to an old order with the given reference index.
Definition order_sl.cpp:122
void DeleteOrder(Vehicle *v, VehicleOrderID sel_ord)
Delete an order but skip the parameter validation.
OldOrderSaveLoadItem & AllocateOldOrder(size_t pool_index)
Allocate an old order with the given pool index.
Definition order_sl.cpp:134
Types related to orders.
OrderConditionVariable
Variables (of a vehicle) to 'cause' skipping on.
Definition order_type.h:128
OrderStopLocation
Where to stop the trains.
Definition order_type.h:98
OrderUnloadFlags
Flags related to the unloading order.
Definition order_type.h:67
OrderDepotTypeFlags
Reasons that could cause us to go to the depot.
Definition order_type.h:108
uint8_t VehicleOrderID
The index of an order within its current vehicle (not pool related)
Definition order_type.h:18
OrderDepotActionFlags
Actions that can be performed when the vehicle enters the depot.
Definition order_type.h:117
@ ODATF_SERVICE_ONLY
Only service the vehicle.
Definition order_type.h:118
OrderLoadFlags
Flags related to the loading order.
Definition order_type.h:77
static const VehicleOrderID INVALID_VEH_ORDER_ID
Invalid vehicle order index (sentinel)
Definition order_type.h:39
OrderConditionComparator
Comparator for the skip reasoning.
Definition order_type.h:143
OrderNonStopFlags
Non-stop order flags.
Definition order_type.h:87
@ ONSF_NO_STOP_AT_DESTINATION_STATION
The vehicle will stop at any station it passes except the destination.
Definition order_type.h:90
@ ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS
The vehicle will not stop at any stations it passes except the destination.
Definition order_type.h:89
OrderType
Order types.
Definition order_type.h:50
Definition of Pool, structure used to access PoolItems, and PoolItem, base structure for Vehicle,...
Functions/types related to saving and loading games.
std::span< const struct SaveLoad > SaveLoadTable
A table of SaveLoad entries.
Definition saveload.h:520
Types related to stations.
Compatibility struct to allow saveload of pool-based orders.
Definition order_base.h:248
uint32_t index
This order's index (1-based).
Definition order_base.h:249
Order order
The order data.
Definition order_base.h:251
uint32_t next
The next order index (1-based).
Definition order_base.h:250
Shared order list linking together the linked list of orders and the list of vehicles sharing this or...
Definition order_base.h:264
StationIDStack GetNextStoppingStation(const Vehicle *v, VehicleOrderID first=INVALID_VEH_ORDER_ID, uint hops=0) const
Recursively determine the next deterministic station to stop at.
TimerGameTick::Ticks GetTimetableDurationIncomplete() const
Gets the known duration of the vehicles timetable even if the timetable is not complete.
Definition order_base.h:417
friend void AfterLoadVehiclesPhase1(bool part_of_load)
For instantiating the shared vehicle chain.
void DeleteOrderAt(VehicleOrderID index)
Remove an order from the order list and delete it.
std::vector< Order > orders
Orders of the order list.
Definition order_base.h:275
bool IsCompleteTimetable() const
Checks whether all orders of the list have a filled timetable.
friend SaveLoadTable GetOrderListDescription()
Saving and loading of order lists.
Definition order_sl.cpp:237
void UpdateTotalDuration(TimerGameTick::Ticks delta)
Must be called if an order's timetable is changed to update internal book keeping.
Definition order_base.h:435
uint GetNumVehicles() const
Return the number of vehicles that share this orders list.
Definition order_base.h:393
void InsertOrderAt(Order &&order, VehicleOrderID index)
Insert a new order into the order chain.
~OrderList()
Destructor.
Definition order_base.h:308
void RemoveVehicle(Vehicle *v)
Removes the vehicle from the shared order list.
uint num_vehicles
NOSAVE: Number of vehicles that share this order list.
Definition order_base.h:273
void AddVehicle(Vehicle *v)
Adds the given vehicle to this shared order list.
Definition order_base.h:401
Vehicle * GetFirstSharedVehicle() const
Get the first vehicle of this vehicle chain.
Definition order_base.h:387
void Initialize(Vehicle *v)
Recomputes everything.
TimerGameTick::Ticks timetable_duration
NOSAVE: Total timetabled duration of the order list.
Definition order_base.h:278
void UpdateTimetableDuration(TimerGameTick::Ticks delta)
Must be called if an order's timetable is changed to update internal book keeping.
Definition order_base.h:429
Vehicle * first_shared
NOSAVE: pointer to the first vehicle in the shared order chain.
Definition order_base.h:274
OrderList(Order &&order, Vehicle *v)
Create an order list with the given order chain for the given vehicle.
Definition order_base.h:290
VehicleOrderID GetFirstOrder() const
Get the first order of the order chain.
Definition order_base.h:318
TimerGameTick::Ticks GetTimetableTotalDuration() const
Gets the total duration of the vehicles timetable or Ticks::INVALID_TICKS is the timetable is not com...
Definition order_base.h:411
VehicleOrderID num_manual_orders
NOSAVE: How many manually added orders are there in the list.
Definition order_base.h:272
void MoveOrder(VehicleOrderID from, VehicleOrderID to)
Move an order to another position within the order list.
VehicleOrderID GetNext(VehicleOrderID cur) const
Get the order after the given one or the first one, if the given one is the last one.
Definition order_base.h:352
VehicleOrderID GetNumOrders() const
Get number of orders in the order list.
Definition order_base.h:362
void RecalculateTimetableDuration()
Recomputes Timetable duration.
void FreeChain(bool keep_orderlist=false)
Free a complete order chain.
VehicleOrderID GetNumManualOrders() const
Get number of manually added orders in the order list.
Definition order_base.h:368
VehicleOrderID GetNextDecisionNode(VehicleOrderID next, uint hops) const
Get the next order which will make the given vehicle stop at a station or refit at a depot or evaluat...
TimerGameTick::Ticks GetTotalDuration() const
Gets the known duration of the vehicles orders, timetabled or not.
Definition order_base.h:423
bool IsShared() const
Is this a shared order list?
Definition order_base.h:381
TimerGameTick::Ticks total_duration
NOSAVE: Total (timetabled or not) duration of the order list.
Definition order_base.h:279
VehicleOrderID GetLastOrder() const
Get the last order of the order chain.
Definition order_base.h:344
OrderList()
Default constructor producing an invalid order list.
Definition order_base.h:283
const Order * GetOrderAt(VehicleOrderID index) const
Get a certain order of the order chain.
Definition order_base.h:328
TileIndex GetLocation(const Vehicle *v, bool airport=false) const
Returns a tile somewhat representing the order destination (not suitable for pathfinding).
bool IsGotoOrder() const
Is this a 'goto' order with a real destination?
Definition order_base.h:89
OrderDepotTypeFlags GetDepotOrderType() const
What caused us going to the depot?
Definition order_base.h:140
uint16_t GetTimetabledTravel() const
Get the time in ticks a vehicle should take to reach the destination or 0 if it's not timetabled.
Definition order_base.h:186
OrderConditionVariable GetConditionVariable() const
What variable do we have to compare?
Definition order_base.h:144
bool Equals(const Order &other) const
Does this order have the same type, flags and destination?
uint16_t MapOldOrder() const
Pack this order into a 16 bits integer as close to the TTD representation as possible.
uint16_t GetMaxSpeed() const
Get the maxmimum speed in km-ish/h a vehicle is allowed to reach on the way to the destination.
Definition order_base.h:197
void SetUnloadType(OrderUnloadFlags unload_type)
Set how the consist must be unloaded.
Definition order_base.h:155
void SetLoadType(OrderLoadFlags load_type)
Set how the consist must be loaded.
Definition order_base.h:153
uint16_t max_speed
How fast the vehicle may go on the way to the destination.
Definition order_base.h:55
void ConvertFromOldSavegame()
Converts this order from an old savegame's version; it moves all bits to the new location.
Definition order_sl.cpp:26
void SetTravelTimetabled(bool timetabled)
Set if the travel time is explicitly timetabled (unless the order is conditional).
Definition order_base.h:202
DestinationID GetDestination() const
Gets the destination of this order.
Definition order_base.h:99
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition order_base.h:66
void SetNonStopType(OrderNonStopFlags non_stop_type)
Set whether we must stop at stations or not.
Definition order_base.h:157
VehicleOrderID GetConditionSkipToOrder() const
Get the order to skip to.
Definition order_base.h:148
OrderStopLocation GetStopLocation() const
Where must we stop at the platform?
Definition order_base.h:138
uint16_t GetWaitTime() const
Get the time in ticks a vehicle will probably wait at the destination (timetabled or not).
Definition order_base.h:188
CargoType GetRefitCargo() const
Get the cargo to to refit to.
Definition order_base.h:127
OrderType GetType() const
Get the type of order of this order.
Definition order_base.h:72
void MakeGoToStation(StationID destination)
Makes this order a Go To Station order.
Definition order_cmd.cpp:59
uint8_t type
The type of order + non-stop flags.
Definition order_base.h:47
uint16_t wait_time
How long in ticks to wait at the destination.
Definition order_base.h:53
void SetRefit(CargoType cargo)
Make this depot/station order also a refit order.
void SetDepotOrderType(OrderDepotTypeFlags depot_order_type)
Set the cause to go to the depot.
Definition order_base.h:161
bool IsCompletelyTimetabled() const
Checks if travel_time and wait_time apply to this order and if they are timetabled.
Definition order_base.h:230
OrderLoadFlags GetLoadType() const
How must the consist be loaded?
Definition order_base.h:132
void SetWaitTime(uint16_t time)
Set the time in ticks to wait at the destination.
Definition order_base.h:208
void SetStopLocation(OrderStopLocation stop_location)
Set where we must stop at the platform.
Definition order_base.h:159
void MakeDummy()
Makes this order a Dummy order.
void MakeGoToWaypoint(StationID destination)
Makes this order a Go To Waypoint order.
Definition order_cmd.cpp:88
void SetConditionVariable(OrderConditionVariable condition_variable)
Set variable we have to compare.
Definition order_base.h:165
uint8_t flags
Load/unload types, depot order/action types.
Definition order_base.h:48
bool IsWaitTimetabled() const
Does this order have an explicit wait time set?
Definition order_base.h:179
void SetTravelTime(uint16_t time)
Set the time in ticks to take for travelling to the destination.
Definition order_base.h:214
friend SaveLoadTable GetOrderDescription()
Saving and loading of orders.
Definition order_sl.cpp:141
DestinationID dest
The destination of the order.
Definition order_base.h:49
void SetDestination(DestinationID destination)
Sets the destination of this order.
Definition order_base.h:106
void SetWaitTimetabled(bool timetabled)
Set if the wait time is explicitly timetabled (unless the order is conditional).
Definition order_base.h:200
bool IsTravelTimetabled() const
Does this order have an explicit travel time set?
Definition order_base.h:181
void SetConditionComparator(OrderConditionComparator condition_comparator)
Set the comparator to use.
Definition order_base.h:167
void MakeConditional(VehicleOrderID order)
Makes this order an conditional order.
void SetDepotActionType(OrderDepotActionFlags depot_service_type)
Set what we are going to do in the depot.
Definition order_base.h:163
void SetConditionSkipToOrder(VehicleOrderID order_id)
Get the order to skip to.
Definition order_base.h:169
OrderDepotActionFlags GetDepotActionType() const
What are we going to do when in the depot.
Definition order_base.h:142
void MakeLeaveStation()
Makes this order a Leave Station order.
bool CanLeaveWithCargo(bool has_cargo) const
A vehicle can leave the current station with cargo if:
void SetConditionValue(uint16_t value)
Set the value to base the skip on.
Definition order_base.h:171
void Free()
'Free' the order
Definition order_cmd.cpp:48
uint16_t GetTimetabledWait() const
Get the time in ticks a vehicle should wait at the destination or 0 if it's not timetabled.
Definition order_base.h:184
bool ShouldStopAtStation(const Vehicle *v, StationID station) const
Check whether the given vehicle should stop at the given station based on this order and the non-stop...
CargoType refit_cargo
Refit CargoType.
Definition order_base.h:51
uint16_t GetTravelTime() const
Get the time in ticks a vehicle will probably take to reach the destination (timetabled or not).
Definition order_base.h:190
void MakeImplicit(StationID destination)
Makes this order an implicit order.
bool IsAutoRefit() const
Is this order a auto-refit order.
Definition order_base.h:120
OrderUnloadFlags GetUnloadType() const
How must the consist be unloaded?
Definition order_base.h:134
void AssignOrder(const Order &other)
Assign data to an order (from another order) This function makes sure that the index is maintained co...
OrderConditionComparator GetConditionComparator() const
What is the comparator to use?
Definition order_base.h:146
OrderNonStopFlags GetNonStopType() const
At which stations must we stop?
Definition order_base.h:136
bool IsRefit() const
Is this order a refit order.
Definition order_base.h:113
void MakeLoading(bool ordered)
Makes this order a Loading order.
Definition order_cmd.cpp:99
uint16_t GetConditionValue() const
Get the value to base the skip on.
Definition order_base.h:150
void SetMaxSpeed(uint16_t speed)
Set the maxmimum speed in km-ish/h a vehicle is allowed to reach on the way to the destination.
Definition order_base.h:221
void MakeGoToDepot(DestinationID destination, OrderDepotTypeFlags order, OrderNonStopFlags non_stop_type=ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS, OrderDepotActionFlags action=ODATF_SERVICE_ONLY, CargoType cargo=CARGO_NO_REFIT)
Makes this order a Go To Depot order.
Definition order_cmd.cpp:74
uint16_t travel_time
How long in ticks the journey to this destination should take.
Definition order_base.h:54
Base class for all PoolItems.
Tindex index
Index of this pool item.
Base class for all pools.
Vehicle data structure.
Definition of the tick-based game-timer.
Types related to vehicles.