OpenTTD Source: src/order_base.h Source File

OpenTTD Source 15.0-RC2

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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
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"
20#include "timer/timer_game_tick.h"
21#include "saveload/saveload.h"
22
23using OrderListPool = Pool<OrderList, OrderListID, 128>;
24extern OrderListPool _orderlist_pool;
25
26template <typename, typename>
27class EndianBufferWriter;
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 */
33 struct Order {
34private:
35 friend struct VEHSChunkHandler;
36 friend SaveLoadTable GetOrderDescription();
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;
49 DestinationID dest{};
50
51 CargoType refit_cargo = CARGO_NO_REFIT;
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);
77 void MakeGoToDepot(DestinationID destination, OrderDepotTypeFlags order, OrderNonStopFlags non_stop_type = OrderNonStopFlag::NoIntermediate, OrderDepotActionFlags action = {}, CargoType cargo = CARGO_NO_REFIT);
78 void MakeGoToWaypoint(StationID destination);
79 void MakeLoading(bool ordered);
80 void MakeLeaveStation();
81 void MakeDummy();
82 void MakeConditional(VehicleOrderID order);
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
135 inline bool IsFullLoadOrder() const
136 {
137 OrderLoadType type = GetLoadType();
138 return type == OrderLoadType::FullLoad || type == OrderLoadType::FullLoadAny;
139 }
140
142 inline OrderLoadType GetLoadType() const { return static_cast<OrderLoadType>(GB(this->flags, 4, 3)); }
144 inline OrderUnloadType GetUnloadType() const { return static_cast<OrderUnloadType>(GB(this->flags, 0, 3)); }
146 inline OrderNonStopFlags GetNonStopType() const { return static_cast<OrderNonStopFlags>(GB(this->type, 6, 2)); }
148 inline OrderStopLocation GetStopLocation() const { return static_cast<OrderStopLocation>(GB(this->type, 4, 2)); }
150 inline OrderDepotTypeFlags GetDepotOrderType() const { return static_cast<OrderDepotTypeFlags>(GB(this->flags, 0, 3)); }
152 inline OrderDepotActionFlags GetDepotActionType() const { return static_cast<OrderDepotActionFlags>(GB(this->flags, 3, 4)); }
154 inline OrderConditionVariable GetConditionVariable() const { return static_cast<OrderConditionVariable>(GB(this->dest.value, 11, 5)); }
156 inline OrderConditionComparator GetConditionComparator() const { return static_cast<OrderConditionComparator>(GB(this->type, 5, 3)); }
158 inline VehicleOrderID GetConditionSkipToOrder() const { return this->flags; }
160 inline uint16_t GetConditionValue() const { return GB(this->dest.value, 0, 11); }
161
163 inline void SetLoadType(OrderLoadType load_type) { SB(this->flags, 4, 3, to_underlying(load_type)); }
165 inline void SetUnloadType(OrderUnloadType unload_type) { SB(this->flags, 0, 3, to_underlying(unload_type)); }
167 inline void SetNonStopType(OrderNonStopFlags non_stop_type) { SB(this->type, 6, 2, non_stop_type.base()); }
169 inline void SetStopLocation(OrderStopLocation stop_location) { SB(this->type, 4, 2, to_underlying(stop_location)); }
171 inline void SetDepotOrderType(OrderDepotTypeFlags depot_order_type) { SB(this->flags, 0, 3, depot_order_type.base()); }
173 inline void SetDepotActionType(OrderDepotActionFlags depot_service_type) { SB(this->flags, 3, 4, depot_service_type.base()); }
175 inline void SetConditionVariable(OrderConditionVariable condition_variable) { SB(this->dest.value, 11, 5, to_underlying(condition_variable)); }
177 inline void SetConditionComparator(OrderConditionComparator condition_comparator) { SB(this->type, 5, 3, to_underlying(condition_comparator)); }
179 inline void SetConditionSkipToOrder(VehicleOrderID order_id) { this->flags = order_id; }
181 inline void SetConditionValue(uint16_t value) { SB(this->dest.value, 0, 11, value); }
182
183 /* As conditional orders write their "skip to" order all over the flags, we cannot check the
184 * flags to find out if timetabling is enabled. However, as conditional orders are never
185 * autofilled we can be sure that any non-zero values for their wait_time and travel_time are
186 * explicitly set (but travel_time is actually unused for conditionals). */
187
189 inline bool IsWaitTimetabled() const { return this->IsType(OT_CONDITIONAL) ? this->wait_time > 0 : HasBit(this->flags, 3); }
191 inline bool IsTravelTimetabled() const { return this->IsType(OT_CONDITIONAL) ? this->travel_time > 0 : HasBit(this->flags, 7); }
192
194 inline uint16_t GetTimetabledWait() const { return this->IsWaitTimetabled() ? this->wait_time : 0; }
196 inline uint16_t GetTimetabledTravel() const { return this->IsTravelTimetabled() ? this->travel_time : 0; }
198 inline uint16_t GetWaitTime() const { return this->wait_time; }
200 inline uint16_t GetTravelTime() const { return this->travel_time; }
201
207 inline uint16_t GetMaxSpeed() const { return this->max_speed; }
208
210 inline void SetWaitTimetabled(bool timetabled) { if (!this->IsType(OT_CONDITIONAL)) AssignBit(this->flags, 3, timetabled); }
212 inline void SetTravelTimetabled(bool timetabled) { if (!this->IsType(OT_CONDITIONAL)) AssignBit(this->flags, 7, timetabled); }
213
218 inline void SetWaitTime(uint16_t time) { this->wait_time = time; }
219
224 inline void SetTravelTime(uint16_t time) { this->travel_time = time; }
225
231 inline void SetMaxSpeed(uint16_t speed) { this->max_speed = speed; }
232
233 bool ShouldStopAtStation(const Vehicle *v, StationID station) const;
234 bool CanLoadOrUnload() const;
235 bool CanLeaveWithCargo(bool has_cargo) const;
236
237 TileIndex GetLocation(const Vehicle *v, bool airport = false) const;
238
240 inline bool IsCompletelyTimetabled() const
241 {
242 if (!this->IsTravelTimetabled() && !this->IsType(OT_CONDITIONAL)) return false;
243 if (!this->IsWaitTimetabled() && this->IsType(OT_GOTO_STATION) &&
244 !this->GetNonStopType().Test(OrderNonStopFlag::NoDestination)) {
245 return false;
246 }
247 return true;
248 }
249
250 void AssignOrder(const Order &other);
251 bool Equals(const Order &other) const;
252
253 uint16_t MapOldOrder() const;
254 void ConvertFromOldSavegame();
255};
256
258 struct OldOrderSaveLoadItem {
259 uint32_t index = 0;
260 uint32_t next = 0;
261 Order order{};
262};
263
264 OldOrderSaveLoadItem *GetOldOrder(size_t pool_index);
265 OldOrderSaveLoadItem &AllocateOldOrder(size_t pool_index);
266
267void InsertOrder(Vehicle *v, Order &&new_o, VehicleOrderID sel_ord);
268void DeleteOrder(Vehicle *v, VehicleOrderID sel_ord);
269
274 struct OrderList : OrderListPool::PoolItem<&_orderlist_pool> {
275private:
276 friend void AfterLoadVehiclesPhase1(bool part_of_load);
277 friend SaveLoadTable GetOrderListDescription();
278 friend struct ORDLChunkHandler;
279 template <typename T>
280 friend class SlOrders;
281
282 VehicleOrderID num_manual_orders = 0;
283 uint num_vehicles = 0;
284 Vehicle *first_shared = nullptr;
285 std::vector<Order> orders;
286 uint32_t old_order_index = 0;
287
288 TimerGameTick::Ticks timetable_duration{};
289 TimerGameTick::Ticks total_duration{};
290
291public:
293 OrderList() {}
294
300 OrderList(Order &&order, Vehicle *v)
301 {
302 this->orders.emplace_back(std::move(order));
303 this->Initialize(v);
304 }
305
306 OrderList(std::vector<Order> &&orders, Vehicle *v)
307 {
308 this->orders = std::move(orders);
309 this->Initialize(v);
310 }
311
312 OrderList(Vehicle *v)
313 {
314 this->Initialize(v);
315 }
316
318 ~OrderList() {}
319
320 void Initialize(Vehicle *v);
321
322 void RecalculateTimetableDuration();
323
328 inline VehicleOrderID GetFirstOrder() const { return this->orders.empty() ? INVALID_VEH_ORDER_ID : 0; }
329
330 inline std::span<const Order> GetOrders() const { return this->orders; }
331 inline std::span<Order> GetOrders() { return this->orders; }
332
338 const Order *GetOrderAt(VehicleOrderID index) const
339 {
340 if (index >= this->GetNumOrders()) return nullptr;
341 return &this->orders[index];
342 }
343
344 Order *GetOrderAt(VehicleOrderID index)
345 {
346 if (index >= this->GetNumOrders()) return nullptr;
347 return &this->orders[index];
348 }
349
354 inline VehicleOrderID GetLastOrder() const { return this->orders.empty() ? INVALID_VEH_ORDER_ID : (this->GetNumOrders() - 1); }
355
362 inline VehicleOrderID GetNext(VehicleOrderID cur) const
363 {
364 if (this->orders.empty()) return INVALID_VEH_ORDER_ID;
365 return static_cast<VehicleOrderID>((cur + 1) % this->GetNumOrders());
366 }
367
372 inline VehicleOrderID GetNumOrders() const { return static_cast<VehicleOrderID>(std::size(this->orders)); }
373
378 inline VehicleOrderID GetNumManualOrders() const { return this->num_manual_orders; }
379
380 void GetNextStoppingStation(std::vector<StationID> &next_station, const Vehicle *v, VehicleOrderID first = INVALID_VEH_ORDER_ID, uint hops = 0) const;
381 VehicleOrderID GetNextDecisionNode(VehicleOrderID next, uint hops) const;
382
383 void InsertOrderAt(Order &&order, VehicleOrderID index);
384 void DeleteOrderAt(VehicleOrderID index);
385 void MoveOrder(VehicleOrderID from, VehicleOrderID to);
386
391 inline bool IsShared() const { return this->num_vehicles > 1; };
392
397 inline Vehicle *GetFirstSharedVehicle() const { return this->first_shared; }
398
403 inline uint GetNumVehicles() const { return this->num_vehicles; }
404
411 inline void AddVehicle([[maybe_unused]] Vehicle *v) { ++this->num_vehicles; }
412
413 void RemoveVehicle(Vehicle *v);
414
415 bool IsCompleteTimetable() const;
416
421 inline TimerGameTick::Ticks GetTimetableTotalDuration() const { return this->IsCompleteTimetable() ? this->timetable_duration : Ticks::INVALID_TICKS; }
422
427 inline TimerGameTick::Ticks GetTimetableDurationIncomplete() const { return this->timetable_duration; }
428
433 inline TimerGameTick::Ticks GetTotalDuration() const { return this->total_duration; }
434
439 void UpdateTimetableDuration(TimerGameTick::Ticks delta) { this->timetable_duration += delta; }
440
445 void UpdateTotalDuration(TimerGameTick::Ticks delta) { this->total_duration += delta; }
446
447 void FreeChain(bool keep_orderlist = false);
448
449 void DebugCheckSanity() const;
450};
451
452#endif /* ORDER_BASE_H */
bitmath_func.hpp
Functions related to bit mathematics.
AssignBit
constexpr T AssignBit(T &x, const uint8_t y, bool value)
Assigns a bit in a variable.
Definition bitmath_func.hpp:176
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
GB
static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
Definition bitmath_func.hpp:32
HasBit
constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
Definition bitmath_func.hpp:103
cargo_type.h
Types related to cargoes...
CargoType
uint8_t CargoType
Cargo slots to indicate a cargo type within a game.
Definition cargo_type.h:21
CARGO_AUTO_REFIT
static const CargoType CARGO_AUTO_REFIT
Automatically choose cargo type when doing auto refitting.
Definition cargo_type.h:76
NUM_CARGO
static const CargoType NUM_CARGO
Maximum number of cargo types in a game.
Definition cargo_type.h:73
CARGO_NO_REFIT
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:77
BaseBitSet::base
constexpr Tstorage base() const noexcept
Retrieve the raw value behind this bit set.
Definition base_bitset_type.hpp:219
EndianBufferReader
Endian-aware buffer adapter that always reads values in little endian order.
Definition endian_buffer.hpp:145
EndianBufferWriter
Endian-aware buffer adapter that always writes values in little endian order.
Definition endian_buffer.hpp:24
EnumBitSet
Enum-as-bit-set wrapper.
Definition enum_type.hpp:177
SlOrders
Definition order_sl.cpp:218
SlVehicleCommon
Definition vehicle_sl.cpp:645
SlVehicleDisaster
Definition vehicle_sl.cpp:1037
Ticks::INVALID_TICKS
static constexpr TimerGameTick::Ticks INVALID_TICKS
Representation of an invalid number of ticks.
Definition timer_game_tick.h:68
TimerGameTick::Ticks
int32_t Ticks
The type to store ticks in.
Definition timer_game_tick.h:24
depot_type.h
Header files for depots (not hangars)
to_underlying
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23)
Definition enum_type.hpp:17
InsertOrder
void InsertOrder(Vehicle *v, Order &&new_o, VehicleOrderID sel_ord)
Insert a new order but skip the validation.
Definition order_cmd.cpp:846
GetOldOrder
OldOrderSaveLoadItem * GetOldOrder(size_t pool_index)
Get a pointer to an old order with the given reference index.
Definition order_sl.cpp:125
DeleteOrder
void DeleteOrder(Vehicle *v, VehicleOrderID sel_ord)
Delete an order but skip the parameter validation.
Definition order_cmd.cpp:971
AllocateOldOrder
OldOrderSaveLoadItem & AllocateOldOrder(size_t pool_index)
Allocate an old order with the given pool index.
Definition order_sl.cpp:137
order_type.h
Types related to orders.
OrderUnloadType
OrderUnloadType
Unloading order types.
Definition order_type.h:67
OrderConditionVariable
OrderConditionVariable
Variables (of a vehicle) to 'cause' skipping on.
Definition order_type.h:128
OrderStopLocation
OrderStopLocation
Where to stop the trains.
Definition order_type.h:97
OrderNonStopFlag::NoDestination
@ NoDestination
The vehicle will stop at any station it passes except the destination, aka via.
OrderNonStopFlag::NoIntermediate
@ NoIntermediate
The vehicle will not stop at any stations it passes except the destination, aka non-stop.
VehicleOrderID
uint8_t VehicleOrderID
The index of an order within its current vehicle (not pool related)
Definition order_type.h:18
OrderLoadType
OrderLoadType
Loading order types.
Definition order_type.h:77
OrderLoadType::FullLoad
@ FullLoad
Full load all cargoes of the consist.
OrderLoadType::FullLoadAny
@ FullLoadAny
Full load a single cargo of the consist.
INVALID_VEH_ORDER_ID
static const VehicleOrderID INVALID_VEH_ORDER_ID
Invalid vehicle order index (sentinel)
Definition order_type.h:39
OrderConditionComparator
OrderConditionComparator
Comparator for the skip reasoning.
Definition order_type.h:143
OrderType
OrderType
Order types.
Definition order_type.h:50
pool_type.hpp
Definition of Pool, structure used to access PoolItems, and PoolItem, base structure for Vehicle,...
saveload.h
Functions/types related to saving and loading games.
SaveLoadTable
std::span< const struct SaveLoad > SaveLoadTable
A table of SaveLoad entries.
Definition saveload.h:530
station_type.h
Types related to stations.
DestinationID
Definition order_type.h:21
ORDLChunkHandler
Definition order_sl.cpp:251
OldOrderSaveLoadItem
Compatibility struct to allow saveload of pool-based orders.
Definition order_base.h:258
OldOrderSaveLoadItem::index
uint32_t index
This order's index (1-based).
Definition order_base.h:259
OldOrderSaveLoadItem::order
Order order
The order data.
Definition order_base.h:261
OldOrderSaveLoadItem::next
uint32_t next
The next order index (1-based).
Definition order_base.h:260
OrderList
Shared order list linking together the linked list of orders and the list of vehicles sharing this or...
Definition order_base.h:274
OrderList::GetTimetableDurationIncomplete
TimerGameTick::Ticks GetTimetableDurationIncomplete() const
Gets the known duration of the vehicles timetable even if the timetable is not complete.
Definition order_base.h:427
OrderList::AfterLoadVehiclesPhase1
friend void AfterLoadVehiclesPhase1(bool part_of_load)
For instantiating the shared vehicle chain.
Definition vehicle_sl.cpp:256
OrderList::DeleteOrderAt
void DeleteOrderAt(VehicleOrderID index)
Remove an order from the order list and delete it.
Definition order_cmd.cpp:439
OrderList::orders
std::vector< Order > orders
Orders of the order list.
Definition order_base.h:285
OrderList::IsCompleteTimetable
bool IsCompleteTimetable() const
Checks whether all orders of the list have a filled timetable.
Definition order_cmd.cpp:486
OrderList::GetOrderListDescription
friend SaveLoadTable GetOrderListDescription()
Saving and loading of order lists.
Definition order_sl.cpp:240
OrderList::UpdateTotalDuration
void UpdateTotalDuration(TimerGameTick::Ticks delta)
Must be called if an order's timetable is changed to update internal book keeping.
Definition order_base.h:445
OrderList::GetNumVehicles
uint GetNumVehicles() const
Return the number of vehicles that share this orders list.
Definition order_base.h:403
OrderList::InsertOrderAt
void InsertOrderAt(Order &&order, VehicleOrderID index)
Insert a new order into the order chain.
Definition order_cmd.cpp:417
OrderList::~OrderList
~OrderList()
Destructor.
Definition order_base.h:318
OrderList::RemoveVehicle
void RemoveVehicle(Vehicle *v)
Removes the vehicle from the shared order list.
Definition order_cmd.cpp:476
OrderList::num_vehicles
uint num_vehicles
NOSAVE: Number of vehicles that share this order list.
Definition order_base.h:283
OrderList::AddVehicle
void AddVehicle(Vehicle *v)
Adds the given vehicle to this shared order list.
Definition order_base.h:411
OrderList::GetFirstSharedVehicle
Vehicle * GetFirstSharedVehicle() const
Get the first vehicle of this vehicle chain.
Definition order_base.h:397
OrderList::Initialize
void Initialize(Vehicle *v)
Recomputes everything.
Definition order_cmd.cpp:253
OrderList::timetable_duration
TimerGameTick::Ticks timetable_duration
NOSAVE: Total timetabled duration of the order list.
Definition order_base.h:288
OrderList::UpdateTimetableDuration
void UpdateTimetableDuration(TimerGameTick::Ticks delta)
Must be called if an order's timetable is changed to update internal book keeping.
Definition order_base.h:439
OrderList::first_shared
Vehicle * first_shared
NOSAVE: pointer to the first vehicle in the shared order chain.
Definition order_base.h:284
OrderList::OrderList
OrderList(Order &&order, Vehicle *v)
Create an order list with the given order chain for the given vehicle.
Definition order_base.h:300
OrderList::GetFirstOrder
VehicleOrderID GetFirstOrder() const
Get the first order of the order chain.
Definition order_base.h:328
OrderList::GetTimetableTotalDuration
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:421
OrderList::num_manual_orders
VehicleOrderID num_manual_orders
NOSAVE: How many manually added orders are there in the list.
Definition order_base.h:282
OrderList::MoveOrder
void MoveOrder(VehicleOrderID from, VehicleOrderID to)
Move an order to another position within the order list.
Definition order_cmd.cpp:457
OrderList::GetNextStoppingStation
void GetNextStoppingStation(std::vector< StationID > &next_station, const Vehicle *v, VehicleOrderID first=INVALID_VEH_ORDER_ID, uint hops=0) const
Recursively determine the next deterministic station to stop at.
Definition order_cmd.cpp:363
OrderList::GetNext
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:362
OrderList::GetNumOrders
VehicleOrderID GetNumOrders() const
Get number of orders in the order list.
Definition order_base.h:372
OrderList::RecalculateTimetableDuration
void RecalculateTimetableDuration()
Recomputes Timetable duration.
Definition order_cmd.cpp:280
OrderList::FreeChain
void FreeChain(bool keep_orderlist=false)
Free a complete order chain.
Definition order_cmd.cpp:293
OrderList::GetNumManualOrders
VehicleOrderID GetNumManualOrders() const
Get number of manually added orders in the order list.
Definition order_base.h:378
OrderList::GetNextDecisionNode
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...
Definition order_cmd.cpp:327
OrderList::GetTotalDuration
TimerGameTick::Ticks GetTotalDuration() const
Gets the known duration of the vehicles orders, timetabled or not.
Definition order_base.h:433
OrderList::IsShared
bool IsShared() const
Is this a shared order list?
Definition order_base.h:391
OrderList::total_duration
TimerGameTick::Ticks total_duration
NOSAVE: Total (timetabled or not) duration of the order list.
Definition order_base.h:289
OrderList::GetLastOrder
VehicleOrderID GetLastOrder() const
Get the last order of the order chain.
Definition order_base.h:354
OrderList::OrderList
OrderList()
Default constructor producing an invalid order list.
Definition order_base.h:293
OrderList::GetOrderAt
const Order * GetOrderAt(VehicleOrderID index) const
Get a certain order of the order chain.
Definition order_base.h:338
Order
Definition order_base.h:33
Order::GetLocation
TileIndex GetLocation(const Vehicle *v, bool airport=false) const
Returns a tile somewhat representing the order destination (not suitable for pathfinding).
Definition order_cmd.cpp:562
Order::IsGotoOrder
bool IsGotoOrder() const
Is this a 'goto' order with a real destination?
Definition order_base.h:89
Order::GetDepotOrderType
OrderDepotTypeFlags GetDepotOrderType() const
What caused us going to the depot?
Definition order_base.h:150
Order::GetTimetabledTravel
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:196
Order::GetConditionVariable
OrderConditionVariable GetConditionVariable() const
What variable do we have to compare?
Definition order_base.h:154
Order::Equals
bool Equals(const Order &other) const
Does this order have the same type, flags and destination?
Definition order_cmd.cpp:158
Order::MapOldOrder
uint16_t MapOldOrder() const
Pack this order into a 16 bits integer as close to the TTD representation as possible.
Definition order_cmd.cpp:180
Order::GetMaxSpeed
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:207
Order::max_speed
uint16_t max_speed
How fast the vehicle may go on the way to the destination.
Definition order_base.h:55
Order::ConvertFromOldSavegame
void ConvertFromOldSavegame()
Converts this order from an old savegame's version; it moves all bits to the new location.
Definition order_sl.cpp:26
Order::SetTravelTimetabled
void SetTravelTimetabled(bool timetabled)
Set if the travel time is explicitly timetabled (unless the order is conditional).
Definition order_base.h:212
Order::GetDestination
DestinationID GetDestination() const
Gets the destination of this order.
Definition order_base.h:99
Order::IsType
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition order_base.h:66
Order::SetNonStopType
void SetNonStopType(OrderNonStopFlags non_stop_type)
Set whether we must stop at stations or not.
Definition order_base.h:167
Order::GetConditionSkipToOrder
VehicleOrderID GetConditionSkipToOrder() const
Get the order to skip to.
Definition order_base.h:158
Order::GetStopLocation
OrderStopLocation GetStopLocation() const
Where must we stop at the platform?
Definition order_base.h:148
Order::GetWaitTime
uint16_t GetWaitTime() const
Get the time in ticks a vehicle will probably wait at the destination (timetabled or not).
Definition order_base.h:198
Order::GetRefitCargo
CargoType GetRefitCargo() const
Get the cargo to to refit to.
Definition order_base.h:127
Order::GetType
OrderType GetType() const
Get the type of order of this order.
Definition order_base.h:72
Order::IsFullLoadOrder
bool IsFullLoadOrder() const
Is this order a OrderLoadType::FullLoad or OrderLoadType::FullLoadAny?
Definition order_base.h:135
Order::MakeGoToStation
void MakeGoToStation(StationID destination)
Makes this order a Go To Station order.
Definition order_cmd.cpp:58
Order::type
uint8_t type
The type of order + non-stop flags.
Definition order_base.h:47
Order::wait_time
uint16_t wait_time
How long in ticks to wait at the destination.
Definition order_base.h:53
Order::SetRefit
void SetRefit(CargoType cargo)
Make this depot/station order also a refit order.
Definition order_cmd.cpp:148
Order::SetDepotOrderType
void SetDepotOrderType(OrderDepotTypeFlags depot_order_type)
Set the cause to go to the depot.
Definition order_base.h:171
Order::IsCompletelyTimetabled
bool IsCompletelyTimetabled() const
Checks if travel_time and wait_time apply to this order and if they are timetabled.
Definition order_base.h:240
Order::SetWaitTime
void SetWaitTime(uint16_t time)
Set the time in ticks to wait at the destination.
Definition order_base.h:218
Order::SetStopLocation
void SetStopLocation(OrderStopLocation stop_location)
Set where we must stop at the platform.
Definition order_base.h:169
Order::MakeDummy
void MakeDummy()
Makes this order a Dummy order.
Definition order_cmd.cpp:116
Order::MakeGoToWaypoint
void MakeGoToWaypoint(StationID destination)
Makes this order a Go To Waypoint order.
Definition order_cmd.cpp:87
Order::SetConditionVariable
void SetConditionVariable(OrderConditionVariable condition_variable)
Set variable we have to compare.
Definition order_base.h:175
Order::GetUnloadType
OrderUnloadType GetUnloadType() const
How must the consist be unloaded?
Definition order_base.h:144
Order::flags
uint8_t flags
Load/unload types, depot order/action types.
Definition order_base.h:48
Order::MakeGoToDepot
void MakeGoToDepot(DestinationID destination, OrderDepotTypeFlags order, OrderNonStopFlags non_stop_type=OrderNonStopFlag::NoIntermediate, OrderDepotActionFlags action={}, CargoType cargo=CARGO_NO_REFIT)
Makes this order a Go To Depot order.
Definition order_cmd.cpp:73
Order::IsWaitTimetabled
bool IsWaitTimetabled() const
Does this order have an explicit wait time set?
Definition order_base.h:189
Order::SetTravelTime
void SetTravelTime(uint16_t time)
Set the time in ticks to take for travelling to the destination.
Definition order_base.h:224
Order::GetOrderDescription
friend SaveLoadTable GetOrderDescription()
Saving and loading of orders.
Definition order_sl.cpp:144
Order::dest
DestinationID dest
The destination of the order.
Definition order_base.h:49
Order::SetDestination
void SetDestination(DestinationID destination)
Sets the destination of this order.
Definition order_base.h:106
Order::SetWaitTimetabled
void SetWaitTimetabled(bool timetabled)
Set if the wait time is explicitly timetabled (unless the order is conditional).
Definition order_base.h:210
Order::IsTravelTimetabled
bool IsTravelTimetabled() const
Does this order have an explicit travel time set?
Definition order_base.h:191
Order::SetConditionComparator
void SetConditionComparator(OrderConditionComparator condition_comparator)
Set the comparator to use.
Definition order_base.h:177
Order::MakeConditional
void MakeConditional(VehicleOrderID order)
Makes this order an conditional order.
Definition order_cmd.cpp:126
Order::SetDepotActionType
void SetDepotActionType(OrderDepotActionFlags depot_service_type)
Set what we are going to do in the depot.
Definition order_base.h:173
Order::SetConditionSkipToOrder
void SetConditionSkipToOrder(VehicleOrderID order_id)
Get the order to skip to.
Definition order_base.h:179
Order::GetLoadType
OrderLoadType GetLoadType() const
How must the consist be loaded?
Definition order_base.h:142
Order::GetDepotActionType
OrderDepotActionFlags GetDepotActionType() const
What are we going to do when in the depot.
Definition order_base.h:152
Order::MakeLeaveStation
void MakeLeaveStation()
Makes this order a Leave Station order.
Definition order_cmd.cpp:107
Order::CanLeaveWithCargo
bool CanLeaveWithCargo(bool has_cargo) const
A vehicle can leave the current station with cargo if:
Definition order_cmd.cpp:2197
Order::SetConditionValue
void SetConditionValue(uint16_t value)
Set the value to base the skip on.
Definition order_base.h:181
Order::SetUnloadType
void SetUnloadType(OrderUnloadType unload_type)
Set how the consist must be unloaded.
Definition order_base.h:165
Order::Free
void Free()
'Free' the order
Definition order_cmd.cpp:47
Order::GetTimetabledWait
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:194
Order::ShouldStopAtStation
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...
Definition order_cmd.cpp:2173
Order::refit_cargo
CargoType refit_cargo
Refit CargoType.
Definition order_base.h:51
Order::GetTravelTime
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:200
Order::MakeImplicit
void MakeImplicit(StationID destination)
Makes this order an implicit order.
Definition order_cmd.cpp:137
Order::SetLoadType
void SetLoadType(OrderLoadType load_type)
Set how the consist must be loaded.
Definition order_base.h:163
Order::IsAutoRefit
bool IsAutoRefit() const
Is this order a auto-refit order.
Definition order_base.h:120
Order::AssignOrder
void AssignOrder(const Order &other)
Assign data to an order (from another order) This function makes sure that the index is maintained co...
Definition order_cmd.cpp:235
Order::GetConditionComparator
OrderConditionComparator GetConditionComparator() const
What is the comparator to use?
Definition order_base.h:156
Order::GetNonStopType
OrderNonStopFlags GetNonStopType() const
At which stations must we stop?
Definition order_base.h:146
Order::IsRefit
bool IsRefit() const
Is this order a refit order.
Definition order_base.h:113
Order::MakeLoading
void MakeLoading(bool ordered)
Makes this order a Loading order.
Definition order_cmd.cpp:98
Order::GetConditionValue
uint16_t GetConditionValue() const
Get the value to base the skip on.
Definition order_base.h:160
Order::SetMaxSpeed
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:231
Order::travel_time
uint16_t travel_time
How long in ticks the journey to this destination should take.
Definition order_base.h:54
PoolID< uint16_t, struct StationIDTag, 64000, 0xFFFF >
Pool::PoolItem
Base class for all PoolItems.
Definition pool_type.hpp:285
Pool::PoolItem<&_orderlist_pool >::index
Tindex index
Index of this pool item.
Definition pool_type.hpp:286
Pool
Base class for all pools.
Definition pool_type.hpp:133
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
VEHSChunkHandler
Definition vehicle_sl.cpp:1105
Vehicle
Vehicle data structure.
Definition vehicle_base.h:205
timer_game_tick.h
Definition of the tick-based game-timer.
vehicle_type.h
Types related to vehicles.