src/order_base.h

   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
   8 /** @file order_base.h Base class for orders. */
   9
  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
  23 typedef Pool<Order, OrderID, 256, 0xFF0000> OrderPool;
  24 typedef Pool<OrderList, OrderListID, 128, 64000> OrderListPool;
  25 extern OrderPool _order_pool;
  26 extern OrderListPool _orderlist_pool;
  27
  28 template <typename, typename>
  29 class EndianBufferWriter;
  30
  31 /* If you change this, keep in mind that it is saved on 3 places:
  32  * - Load_ORDR, all the global orders
  33  * - Vehicle -> current_order
  34  * - REF_ORDER (all REFs are currently limited to 16 bits!!)
  35  */
  36 struct Order : OrderPool::PoolItem<&_order_pool> {
  37 private:
  38         friend struct VEHSChunkHandler;                             ///< Loading of ancient vehicles.
  39         friend SaveLoadTable GetOrderDescription();                 ///< Saving and loading of orders.
  40         /* So we can use private/protected variables in the saveload code */
  41         friend class SlVehicleCommon;
  42         friend class SlVehicleDisaster;
  43
  44         template <typename Tcont, typename Titer>
  45         friend EndianBufferWriter<Tcont, Titer> &operator <<(EndianBufferWriter<Tcont, Titer> &buffer, const Order &data);
  46         friend class EndianBufferReader &operator >>(class EndianBufferReader &buffer, Order &order);
  47
  48         uint8_t type = 0; ///< The type of order + non-stop flags
  49         uint8_t flags = 0; ///< Load/unload types, depot order/action types.
  50         DestinationID dest = 0; ///< The destination of the order.
  51
  52         CargoID refit_cargo = CARGO_NO_REFIT; ///< Refit CargoID
  53
  54         uint16_t wait_time = 0; ///< How long in ticks to wait at the destination.
  55         uint16_t travel_time = 0; ///< How long in ticks the journey to this destination should take.
  56         uint16_t max_speed = UINT16_MAX; ///< How fast the vehicle may go on the way to the destination.
  57
  58 public:
  59         Order *next = nullptr; ///< Pointer to next order. If nullptr, end of list
  60
  61         Order() {}
  62         Order(uint8_t type, uint8_t flags, DestinationID dest) : type(type), flags(flags), dest(dest) {}
  63         ~Order();
  64
  65         /**
  66          * Check whether this order is of the given type.
  67          * @param type the type to check against.
  68          * @return true if the order matches.
  69          */
  70         inline bool IsType(OrderType type) const { return this->GetType() == type; }
  71
  72         /**
  73          * Get the type of order of this order.
  74          * @return the order type.
  75          */
  76         inline OrderType GetType() const { return (OrderType)GB(this->type, 0, 4); }
  77
  78         void Free();
  79
  80         void MakeGoToStation(StationID destination);
  81         void MakeGoToDepot(DepotID destination, OrderDepotTypeFlags order, OrderNonStopFlags non_stop_type = ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS, OrderDepotActionFlags action = ODATF_SERVICE_ONLY, CargoID cargo = CARGO_NO_REFIT);
  82         void MakeGoToWaypoint(StationID destination);
  83         void MakeLoading(bool ordered);
  84         void MakeLeaveStation();
  85         void MakeDummy();
  86         void MakeConditional(VehicleOrderID order);
  87         void MakeImplicit(StationID destination);
  88
  89         /**
  90          * Is this a 'goto' order with a real destination?
  91          * @return True if the type is either #OT_GOTO_WAYPOINT, #OT_GOTO_DEPOT or #OT_GOTO_STATION.
  92          */
  93         inline bool IsGotoOrder() const
  94         {
  95                 return IsType(OT_GOTO_WAYPOINT) || IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION);
  96         }
  97
  98         /**
  99          * Gets the destination of this order.
 100          * @pre IsType(OT_GOTO_WAYPOINT) || IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION).
 101          * @return the destination of the order.
 102          */
 103         inline DestinationID GetDestination() const { return this->dest; }
 104
 105         /**
 106          * Sets the destination of this order.
 107          * @param destination the new destination of the order.
 108          * @pre IsType(OT_GOTO_WAYPOINT) || IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION).
 109          */
 110         inline void SetDestination(DestinationID destination) { this->dest = destination; }
 111
 112         /**
 113          * Is this order a refit order.
 114          * @pre IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION)
 115          * @return true if a refit should happen.
 116          */
 117         inline bool IsRefit() const { return this->refit_cargo < NUM_CARGO || this->refit_cargo == CARGO_AUTO_REFIT; }
 118
 119         /**
 120          * Is this order a auto-refit order.
 121          * @pre IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION)
 122          * @return true if a auto-refit should happen.
 123          */
 124         inline bool IsAutoRefit() const { return this->refit_cargo == CARGO_AUTO_REFIT; }
 125
 126         /**
 127          * Get the cargo to to refit to.
 128          * @pre IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION)
 129          * @return the cargo type.
 130          */
 131         inline CargoID GetRefitCargo() const { return this->refit_cargo; }
 132
 133         void SetRefit(CargoID cargo);
 134
 135         /** How must the consist be loaded? */
 136         inline OrderLoadFlags GetLoadType() const { return (OrderLoadFlags)GB(this->flags, 4, 3); }
 137         /** How must the consist be unloaded? */
 138         inline OrderUnloadFlags GetUnloadType() const { return (OrderUnloadFlags)GB(this->flags, 0, 3); }
 139         /** At which stations must we stop? */
 140         inline OrderNonStopFlags GetNonStopType() const { return (OrderNonStopFlags)GB(this->type, 6, 2); }
 141         /** Where must we stop at the platform? */
 142         inline OrderStopLocation GetStopLocation() const { return (OrderStopLocation)GB(this->type, 4, 2); }
 143         /** What caused us going to the depot? */
 144         inline OrderDepotTypeFlags GetDepotOrderType() const { return (OrderDepotTypeFlags)GB(this->flags, 0, 3); }
 145         /** What are we going to do when in the depot. */
 146         inline OrderDepotActionFlags GetDepotActionType() const { return (OrderDepotActionFlags)GB(this->flags, 3, 4); }
 147         /** What variable do we have to compare? */
 148         inline OrderConditionVariable GetConditionVariable() const { return (OrderConditionVariable)GB(this->dest, 11, 5); }
 149         /** What is the comparator to use? */
 150         inline OrderConditionComparator GetConditionComparator() const { return (OrderConditionComparator)GB(this->type, 5, 3); }
 151         /** Get the order to skip to. */
 152         inline VehicleOrderID GetConditionSkipToOrder() const { return this->flags; }
 153         /** Get the value to base the skip on. */
 154         inline uint16_t GetConditionValue() const { return GB(this->dest, 0, 11); }
 155
 156         /** Set how the consist must be loaded. */
 157         inline void SetLoadType(OrderLoadFlags load_type) { SB(this->flags, 4, 3, load_type); }
 158         /** Set how the consist must be unloaded. */
 159         inline void SetUnloadType(OrderUnloadFlags unload_type) { SB(this->flags, 0, 3, unload_type); }
 160         /** Set whether we must stop at stations or not. */
 161         inline void SetNonStopType(OrderNonStopFlags non_stop_type) { SB(this->type, 6, 2, non_stop_type); }
 162         /** Set where we must stop at the platform. */
 163         inline void SetStopLocation(OrderStopLocation stop_location) { SB(this->type, 4, 2, stop_location); }
 164         /** Set the cause to go to the depot. */
 165         inline void SetDepotOrderType(OrderDepotTypeFlags depot_order_type) { SB(this->flags, 0, 3, depot_order_type); }
 166         /** Set what we are going to do in the depot. */
 167         inline void SetDepotActionType(OrderDepotActionFlags depot_service_type) { SB(this->flags, 3, 4, depot_service_type); }
 168         /** Set variable we have to compare. */
 169         inline void SetConditionVariable(OrderConditionVariable condition_variable) { SB(this->dest, 11, 5, condition_variable); }
 170         /** Set the comparator to use. */
 171         inline void SetConditionComparator(OrderConditionComparator condition_comparator) { SB(this->type, 5, 3, condition_comparator); }
 172         /** Get the order to skip to. */
 173         inline void SetConditionSkipToOrder(VehicleOrderID order_id) { this->flags = order_id; }
 174         /** Set the value to base the skip on. */
 175         inline void SetConditionValue(uint16_t value) { SB(this->dest, 0, 11, value); }
 176
 177         /* As conditional orders write their "skip to" order all over the flags, we cannot check the
 178          * flags to find out if timetabling is enabled. However, as conditional orders are never
 179          * autofilled we can be sure that any non-zero values for their wait_time and travel_time are
 180          * explicitly set (but travel_time is actually unused for conditionals). */
 181
 182         /** Does this order have an explicit wait time set? */
 183         inline bool IsWaitTimetabled() const { return this->IsType(OT_CONDITIONAL) ? this->wait_time > 0 : HasBit(this->flags, 3); }
 184         /** Does this order have an explicit travel time set? */
 185         inline bool IsTravelTimetabled() const { return this->IsType(OT_CONDITIONAL) ? this->travel_time > 0 : HasBit(this->flags, 7); }
 186
 187         /** Get the time in ticks a vehicle should wait at the destination or 0 if it's not timetabled. */
 188         inline uint16_t GetTimetabledWait() const { return this->IsWaitTimetabled() ? this->wait_time : 0; }
 189         /** Get the time in ticks a vehicle should take to reach the destination or 0 if it's not timetabled. */
 190         inline uint16_t GetTimetabledTravel() const { return this->IsTravelTimetabled() ? this->travel_time : 0; }
 191         /** Get the time in ticks a vehicle will probably wait at the destination (timetabled or not). */
 192         inline uint16_t GetWaitTime() const { return this->wait_time; }
 193         /** Get the time in ticks a vehicle will probably take to reach the destination (timetabled or not). */
 194         inline uint16_t GetTravelTime() const { return this->travel_time; }
 195
 196         /**
 197          * Get the maxmimum speed in km-ish/h a vehicle is allowed to reach on the way to the
 198          * destination.
 199          * @return maximum speed.
 200          */
 201         inline uint16_t GetMaxSpeed() const { return this->max_speed; }
 202
 203         /** Set if the wait time is explicitly timetabled (unless the order is conditional). */
 204         inline void SetWaitTimetabled(bool timetabled) { if (!this->IsType(OT_CONDITIONAL)) AssignBit(this->flags, 3, timetabled); }
 205         /** Set if the travel time is explicitly timetabled (unless the order is conditional). */
 206         inline void SetTravelTimetabled(bool timetabled) { if (!this->IsType(OT_CONDITIONAL)) AssignBit(this->flags, 7, timetabled); }
 207
 208         /**
 209          * Set the time in ticks to wait at the destination.
 210          * @param time Time to set as wait time.
 211          */
 212         inline void SetWaitTime(uint16_t time) { this->wait_time = time;  }
 213
 214         /**
 215          * Set the time in ticks to take for travelling to the destination.
 216          * @param time Time to set as travel time.
 217          */
 218         inline void SetTravelTime(uint16_t time) { this->travel_time = time; }
 219
 220         /**
 221          * Set the maxmimum speed in km-ish/h a vehicle is allowed to reach on the way to the
 222          * destination.
 223          * @param speed Speed to be set.
 224          */
 225         inline void SetMaxSpeed(uint16_t speed) { this->max_speed = speed; }
 226
 227         bool ShouldStopAtStation(const Vehicle *v, StationID station) const;
 228         bool CanLoadOrUnload() const;
 229         bool CanLeaveWithCargo(bool has_cargo) const;
 230
 231         TileIndex GetLocation(const Vehicle *v, bool airport = false) const;
 232
 233         /** Checks if travel_time and wait_time apply to this order and if they are timetabled. */
 234         inline bool IsCompletelyTimetabled() const
 235         {
 236                 if (!this->IsTravelTimetabled() && !this->IsType(OT_CONDITIONAL)) return false;
 237                 if (!this->IsWaitTimetabled() && this->IsType(OT_GOTO_STATION) &&
 238                                 !(this->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION)) {
 239                         return false;
 240                 }
 241                 return true;
 242         }
 243
 244         void AssignOrder(const Order &other);
 245         bool Equals(const Order &other) const;
 246
 247         uint32_t Pack() const;
 248         uint16_t MapOldOrder() const;
 249         void ConvertFromOldSavegame();
 250 };
 251
 252 void InsertOrder(Vehicle *v, Order *new_o, VehicleOrderID sel_ord);
 253 void DeleteOrder(Vehicle *v, VehicleOrderID sel_ord);
 254
 255 /**
 256  * Shared order list linking together the linked list of orders and the list
 257  *  of vehicles sharing this order list.
 258  */
 259 struct OrderList : OrderListPool::PoolItem<&_orderlist_pool> {
 260 private:
 261         friend void AfterLoadVehiclesPhase1(bool part_of_load); ///< For instantiating the shared vehicle chain
 262         friend SaveLoadTable GetOrderListDescription(); ///< Saving and loading of order lists.
 263
 264         VehicleOrderID num_orders;        ///< NOSAVE: How many orders there are in the list.
 265         VehicleOrderID num_manual_orders; ///< NOSAVE: How many manually added orders are there in the list.
 266         uint num_vehicles;                ///< NOSAVE: Number of vehicles that share this order list.
 267         Vehicle *first_shared;            ///< NOSAVE: pointer to the first vehicle in the shared order chain.
 268         Order *first;                     ///< First order of the order list.
 269
 270         TimerGameTick::Ticks timetable_duration;         ///< NOSAVE: Total timetabled duration of the order list.
 271         TimerGameTick::Ticks total_duration;             ///< NOSAVE: Total (timetabled or not) duration of the order list.
 272
 273 public:
 274         /** Default constructor producing an invalid order list. */
 275         OrderList(VehicleOrderID num_orders = INVALID_VEH_ORDER_ID)
 276                 : num_orders(num_orders), num_manual_orders(0), num_vehicles(0), first_shared(nullptr), first(nullptr),
 277                   timetable_duration(0), total_duration(0) { }
 278
 279         /**
 280          * Create an order list with the given order chain for the given vehicle.
 281          *  @param chain pointer to the first order of the order chain
 282          *  @param v any vehicle using this orderlist
 283          */
 284         OrderList(Order *chain, Vehicle *v) { this->Initialize(chain, v); }
 285
 286         /** Destructor. Invalidates OrderList for re-usage by the pool. */
 287         ~OrderList() {}
 288
 289         void Initialize(Order *chain, Vehicle *v);
 290
 291         void RecalculateTimetableDuration();
 292
 293         /**
 294          * Get the first order of the order chain.
 295          * @return the first order of the chain.
 296          */
 297         inline Order *GetFirstOrder() const { return this->first; }
 298
 299         Order *GetOrderAt(int index) const;
 300
 301         /**
 302          * Get the last order of the order chain.
 303          * @return the last order of the chain.
 304          */
 305         inline Order *GetLastOrder() const { return this->GetOrderAt(this->num_orders - 1); }
 306
 307         /**
 308          * Get the order after the given one or the first one, if the given one is the
 309          * last one.
 310          * @param curr Order to find the next one for.
 311          * @return Next order.
 312          */
 313         inline const Order *GetNext(const Order *curr) const { return (curr->next == nullptr) ? this->GetFirstOrder() : curr->next; }
 314
 315         /**
 316          * Get number of orders in the order list.
 317          * @return number of orders in the chain.
 318          */
 319         inline VehicleOrderID GetNumOrders() const { return this->num_orders; }
 320
 321         /**
 322          * Get number of manually added orders in the order list.
 323          * @return number of manual orders in the chain.
 324          */
 325         inline VehicleOrderID GetNumManualOrders() const { return this->num_manual_orders; }
 326
 327         StationIDStack GetNextStoppingStation(const Vehicle *v, const Order *first = nullptr, uint hops = 0) const;
 328         const Order *GetNextDecisionNode(const Order *next, uint hops) const;
 329
 330         void InsertOrderAt(Order *new_order, int index);
 331         void DeleteOrderAt(int index);
 332         void MoveOrder(int from, int to);
 333
 334         /**
 335          * Is this a shared order list?
 336          * @return whether this order list is shared among multiple vehicles
 337          */
 338         inline bool IsShared() const { return this->num_vehicles > 1; };
 339
 340         /**
 341          * Get the first vehicle of this vehicle chain.
 342          * @return the first vehicle of the chain.
 343          */
 344         inline Vehicle *GetFirstSharedVehicle() const { return this->first_shared; }
 345
 346         /**
 347          * Return the number of vehicles that share this orders list
 348          * @return the count of vehicles that use this shared orders list
 349          */
 350         inline uint GetNumVehicles() const { return this->num_vehicles; }
 351
 352         /**
 353          * Adds the given vehicle to this shared order list.
 354          * @note This is supposed to be called after the vehicle has been inserted
 355          *       into the shared vehicle chain.
 356          * @param v vehicle to add to the list
 357          */
 358         inline void AddVehicle([[maybe_unused]] Vehicle *v) { ++this->num_vehicles; }
 359
 360         void RemoveVehicle(Vehicle *v);
 361
 362         bool IsCompleteTimetable() const;
 363
 364         /**
 365          * Gets the total duration of the vehicles timetable or Ticks::INVALID_TICKS is the timetable is not complete.
 366          * @return total timetable duration or Ticks::INVALID_TICKS for incomplete timetables
 367          */
 368         inline TimerGameTick::Ticks GetTimetableTotalDuration() const { return this->IsCompleteTimetable() ? this->timetable_duration : Ticks::INVALID_TICKS; }
 369
 370         /**
 371          * Gets the known duration of the vehicles timetable even if the timetable is not complete.
 372          * @return known timetable duration
 373          */
 374         inline TimerGameTick::Ticks GetTimetableDurationIncomplete() const { return this->timetable_duration; }
 375
 376         /**
 377          * Gets the known duration of the vehicles orders, timetabled or not.
 378          * @return  known order duration.
 379          */
 380         inline TimerGameTick::Ticks GetTotalDuration() const { return this->total_duration; }
 381
 382         /**
 383          * Must be called if an order's timetable is changed to update internal book keeping.
 384          * @param delta By how many ticks has the timetable duration changed
 385          */
 386         void UpdateTimetableDuration(TimerGameTick::Ticks delta) { this->timetable_duration += delta; }
 387
 388         /**
 389          * Must be called if an order's timetable is changed to update internal book keeping.
 390          * @param delta By how many ticks has the total duration changed
 391          */
 392         void UpdateTotalDuration(TimerGameTick::Ticks delta) { this->total_duration += delta; }
 393
 394         void FreeChain(bool keep_orderlist = false);
 395
 396         void DebugCheckSanity() const;
 397 };
 398
 399 #endif /* ORDER_BASE_H */