src/order_base.h

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * 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.
   6  * 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.
   7  * 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/>.
   8  */
   9
  10 /** @file order_base.h Base class for orders. */
  11
  12 #ifndef ORDER_BASE_H
  13 #define ORDER_BASE_H
  14
  15 #include "order_type.h"
  16 #include "core/pool_type.hpp"
  17 #include "core/bitmath_func.hpp"
  18 #include "cargo_type.h"
  19 #include "depot_type.h"
  20 #include "station_type.h"
  21 #include "vehicle_type.h"
  22 #include "date_type.h"
  23 #include "saveload/saveload_buffer.h"
  24
  25 typedef Pool<Order, OrderID, 256, 64000> OrderPool;
  26 typedef Pool<OrderList, OrderListID, 128, 64000> OrderListPool;
  27 extern OrderPool _order_pool;
  28 extern OrderListPool _orderlist_pool;
  29
  30 /* If you change this, keep in mind that it is saved on 3 places:
  31  * - Load_ORDR, all the global orders
  32  * - Vehicle -> current_order
  33  * - REF_ORDER (all REFs are currently limited to 16 bits!!)
  34  */
  35 struct Order : OrderPool::PoolItem<&_order_pool> {
  36 private:
  37         friend const struct SaveLoad *GetVehicleDescription(VehicleType vt); ///< Saving and loading the current order of vehicles.
  38         friend void Load_VEHS(LoadBuffer *reader);                           ///< Loading of ancient vehicles.
  39         friend const struct SaveLoad *GetOrderDescription();                 ///< Saving and loading of orders.
  40
  41         uint8 type;           ///< The type of order + non-stop flags
  42         uint8 flags;          ///< Load/unload types, depot order/action types.
  43         DestinationID dest;   ///< The destination of the order.
  44
  45         CargoID refit_cargo;  ///< Refit CargoID
  46
  47 public:
  48         Order *next;          ///< Pointer to next order. If NULL, end of list
  49
  50         uint16 wait_time;    ///< How long in ticks to wait at the destination.
  51         uint16 travel_time;  ///< How long in ticks the journey to this destination should take.
  52         uint16 max_speed;    ///< How fast the vehicle may go on the way to the destination.
  53
  54         Order() : refit_cargo(CT_NO_REFIT), max_speed(UINT16_MAX) {}
  55         ~Order();
  56
  57         Order(uint32 packed);
  58
  59         /**
  60          * Check whether this order is of the given type.
  61          * @param type the type to check against.
  62          * @return true if the order matches.
  63          */
  64         inline bool IsType(OrderType type) const { return this->GetType() == type; }
  65
  66         /**
  67          * Get the type of order of this order.
  68          * @return the order type.
  69          */
  70         inline OrderType GetType() const { return (OrderType)GB(this->type, 0, 4); }
  71
  72         void Free();
  73
  74         void MakeGoToStation(StationID destination);
  75         void MakeGoToDepot(DepotID destination, OrderDepotTypeFlags order, OrderNonStopFlags non_stop_type = ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS, OrderDepotActionFlags action = ODATF_SERVICE_ONLY, CargoID cargo = CT_NO_REFIT);
  76         void MakeGoToWaypoint(StationID destination);
  77         void MakeLoading(bool ordered);
  78         void MakeLeaveStation();
  79         void MakeDummy();
  80         void MakeConditional(VehicleOrderID order);
  81         void MakeImplicit(StationID destination);
  82
  83         /**
  84          * Is this a 'goto' order with a real destination?
  85          * @return True if the type is either #OT_GOTO_WAYPOINT, #OT_GOTO_DEPOT or #OT_GOTO_STATION.
  86          */
  87         inline bool IsGotoOrder() const
  88         {
  89                 return IsType(OT_GOTO_WAYPOINT) || IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION);
  90         }
  91
  92         /**
  93          * Gets the destination of this order.
  94          * @pre IsType(OT_GOTO_WAYPOINT) || IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION).
  95          * @return the destination of the order.
  96          */
  97         inline DestinationID GetDestination() const { return this->dest; }
  98
  99         /**
 100          * Sets the destination of this order.
 101          * @param destination the new destination of the order.
 102          * @pre IsType(OT_GOTO_WAYPOINT) || IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION).
 103          */
 104         inline void SetDestination(DestinationID destination) { this->dest = destination; }
 105
 106         /**
 107          * Is this order a refit order.
 108          * @pre IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION)
 109          * @return true if a refit should happen.
 110          */
 111         inline bool IsRefit() const { return this->refit_cargo < NUM_CARGO || this->refit_cargo == CT_AUTO_REFIT; }
 112
 113         /**
 114          * Is this order a auto-refit order.
 115          * @pre IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION)
 116          * @return true if a auto-refit should happen.
 117          */
 118         inline bool IsAutoRefit() const { return this->refit_cargo == CT_AUTO_REFIT; }
 119
 120         /**
 121          * Get the cargo to to refit to.
 122          * @pre IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION)
 123          * @return the cargo type.
 124          */
 125         inline CargoID GetRefitCargo() const { return this->refit_cargo; }
 126
 127         void SetRefit(CargoID cargo);
 128
 129         /** How must the consist be loaded? */
 130         inline OrderLoadFlags GetLoadType() const { return (OrderLoadFlags)GB(this->flags, 4, 4); }
 131         /** How must the consist be unloaded? */
 132         inline OrderUnloadFlags GetUnloadType() const { return (OrderUnloadFlags)GB(this->flags, 0, 4); }
 133         /** At which stations must we stop? */
 134         inline OrderNonStopFlags GetNonStopType() const { return (OrderNonStopFlags)GB(this->type, 6, 2); }
 135         /** Where must we stop at the platform? */
 136         inline OrderStopLocation GetStopLocation() const { return (OrderStopLocation)GB(this->type, 4, 2); }
 137         /** What caused us going to the depot? */
 138         inline OrderDepotTypeFlags GetDepotOrderType() const { return (OrderDepotTypeFlags)GB(this->flags, 0, 4); }
 139         /** What are we going to do when in the depot. */
 140         inline OrderDepotActionFlags GetDepotActionType() const { return (OrderDepotActionFlags)GB(this->flags, 4, 4); }
 141         /** What variable do we have to compare? */
 142         inline OrderConditionVariable GetConditionVariable() const { return (OrderConditionVariable)GB(this->dest, 11, 5); }
 143         /** What is the comparator to use? */
 144         inline OrderConditionComparator GetConditionComparator() const { return (OrderConditionComparator)GB(this->type, 5, 3); }
 145         /** Get the order to skip to. */
 146         inline VehicleOrderID GetConditionSkipToOrder() const { return this->flags; }
 147         /** Get the value to base the skip on. */
 148         inline uint16 GetConditionValue() const { return GB(this->dest, 0, 11); }
 149
 150         /** Set how the consist must be loaded. */
 151         inline void SetLoadType(OrderLoadFlags load_type) { SB(this->flags, 4, 4, load_type); }
 152         /** Set how the consist must be unloaded. */
 153         inline void SetUnloadType(OrderUnloadFlags unload_type) { SB(this->flags, 0, 4, unload_type); }
 154         /** Set whether we must stop at stations or not. */
 155         inline void SetNonStopType(OrderNonStopFlags non_stop_type) { SB(this->type, 6, 2, non_stop_type); }
 156         /** Set where we must stop at the platform. */
 157         inline void SetStopLocation(OrderStopLocation stop_location) { SB(this->type, 4, 2, stop_location); }
 158         /** Set the cause to go to the depot. */
 159         inline void SetDepotOrderType(OrderDepotTypeFlags depot_order_type) { SB(this->flags, 0, 4, depot_order_type); }
 160         /** Set what we are going to do in the depot. */
 161         inline void SetDepotActionType(OrderDepotActionFlags depot_service_type) { SB(this->flags, 4, 4, depot_service_type); }
 162         /** Set variable we have to compare. */
 163         inline void SetConditionVariable(OrderConditionVariable condition_variable) { SB(this->dest, 11, 5, condition_variable); }
 164         /** Set the comparator to use. */
 165         inline void SetConditionComparator(OrderConditionComparator condition_comparator) { SB(this->type, 5, 3, condition_comparator); }
 166         /** Get the order to skip to. */
 167         inline void SetConditionSkipToOrder(VehicleOrderID order_id) { this->flags = order_id; }
 168         /** Set the value to base the skip on. */
 169         inline void SetConditionValue(uint16 value) { SB(this->dest, 0, 11, value); }
 170
 171         bool ShouldStopAtStation(const Vehicle *v, StationID station) const;
 172         bool CanLoadOrUnload() const;
 173         bool CanLeaveWithCargo(bool has_cargo) const;
 174
 175         TileIndex GetLocation(const Vehicle *v, bool airport = false) const;
 176
 177         /** Checks if this order has travel_time and if needed wait_time set. */
 178         inline bool IsCompletelyTimetabled() const
 179         {
 180                 if (this->travel_time == 0 && !this->IsType(OT_CONDITIONAL)) return false;
 181                 if (this->wait_time == 0 && this->IsType(OT_GOTO_STATION) && !(this->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION)) return false;
 182                 return true;
 183         }
 184
 185         void AssignOrder(const Order &other);
 186         bool Equals(const Order &other) const;
 187
 188         uint32 Pack() const;
 189         uint16 MapOldOrder() const;
 190         void ConvertFromOldSavegame(const SavegameTypeVersion *stv);
 191 };
 192
 193 void InsertOrder(Vehicle *v, Order *new_o, VehicleOrderID sel_ord);
 194 void DeleteOrder(Vehicle *v, VehicleOrderID sel_ord);
 195
 196 /**
 197  * Shared order list linking together the linked list of orders and the list
 198  *  of vehicles sharing this order list.
 199  */
 200 struct OrderList : OrderListPool::PoolItem<&_orderlist_pool> {
 201 private:
 202         friend void AfterLoadVehicles(const SavegameTypeVersion *stv); ///< For instantiating the shared vehicle chain
 203         friend const struct SaveLoad *GetOrderListDescription(); ///< Saving and loading of order lists.
 204
 205         StationID GetBestLoadableNext(const Vehicle *v, const Order *o1, const Order *o2) const;
 206
 207         Order *first;                     ///< First order of the order list.
 208         VehicleOrderID num_orders;        ///< NOSAVE: How many orders there are in the list.
 209         VehicleOrderID num_manual_orders; ///< NOSAVE: How many manually added orders are there in the list.
 210         uint num_vehicles;                ///< NOSAVE: Number of vehicles that share this order list.
 211         Vehicle *first_shared;            ///< NOSAVE: pointer to the first vehicle in the shared order chain.
 212
 213         Ticks timetable_duration;         ///< NOSAVE: Total duration of the order list
 214
 215 public:
 216         /** Default constructor producing an invalid order list. */
 217         OrderList(VehicleOrderID num_orders = INVALID_VEH_ORDER_ID)
 218                 : first(NULL), num_orders(num_orders), num_manual_orders(0), num_vehicles(0), first_shared(NULL),
 219                   timetable_duration(0) { }
 220
 221         /**
 222          * Create an order list with the given order chain for the given vehicle.
 223          *  @param chain pointer to the first order of the order chain
 224          *  @param v any vehicle using this orderlist
 225          */
 226         OrderList(Order *chain, Vehicle *v) { this->Initialize(chain, v); }
 227
 228         /** Destructor. Invalidates OrderList for re-usage by the pool. */
 229         ~OrderList() {}
 230
 231         void Initialize(Order *chain, Vehicle *v);
 232
 233         /**
 234          * Get the first order of the order chain.
 235          * @return the first order of the chain.
 236          */
 237         inline Order *GetFirstOrder() const { return this->first; }
 238
 239         Order *GetOrderAt(int index) const;
 240
 241         /**
 242          * Get the last order of the order chain.
 243          * @return the last order of the chain.
 244          */
 245         inline Order *GetLastOrder() const { return this->GetOrderAt(this->num_orders - 1); }
 246
 247         /**
 248          * Get the order after the given one or the first one, if the given one is the
 249          * last one.
 250          * @param curr Order to find the next one for.
 251          * @return Next order.
 252          */
 253         inline const Order *GetNext(const Order *curr) const { return (curr->next == NULL) ? this->GetFirstOrder() : curr->next; }
 254
 255         /**
 256          * Get number of orders in the order list.
 257          * @return number of orders in the chain.
 258          */
 259         inline VehicleOrderID GetNumOrders() const { return this->num_orders; }
 260
 261         /**
 262          * Get number of manually added orders in the order list.
 263          * @return number of manual orders in the chain.
 264          */
 265         inline VehicleOrderID GetNumManualOrders() const { return this->num_manual_orders; }
 266
 267         StationIDStack GetNextStoppingStation(const Vehicle *v, const Order *first = NULL) const;
 268         const Order *GetNextDecisionNode(const Order *next, uint hops) const;
 269
 270         void InsertOrderAt(Order *new_order, int index);
 271         void DeleteOrderAt(int index);
 272         void MoveOrder(int from, int to);
 273
 274         /**
 275          * Is this a shared order list?
 276          * @return whether this order list is shared among multiple vehicles
 277          */
 278         inline bool IsShared() const { return this->num_vehicles > 1; };
 279
 280         /**
 281          * Get the first vehicle of this vehicle chain.
 282          * @return the first vehicle of the chain.
 283          */
 284         inline Vehicle *GetFirstSharedVehicle() const { return this->first_shared; }
 285
 286         /**
 287          * Return the number of vehicles that share this orders list
 288          * @return the count of vehicles that use this shared orders list
 289          */
 290         inline uint GetNumVehicles() const { return this->num_vehicles; }
 291
 292         bool IsVehicleInSharedOrdersList(const Vehicle *v) const;
 293         int GetPositionInSharedOrderList(const Vehicle *v) const;
 294
 295         /**
 296          * Adds the given vehicle to this shared order list.
 297          * @note This is supposed to be called after the vehicle has been inserted
 298          *       into the shared vehicle chain.
 299          * @param v vehicle to add to the list
 300          */
 301         inline void AddVehicle(Vehicle *v) { ++this->num_vehicles; }
 302
 303         void RemoveVehicle(Vehicle *v);
 304
 305         bool IsCompleteTimetable() const;
 306
 307         /**
 308          * Gets the total duration of the vehicles timetable or INVALID_TICKS is the timetable is not complete.
 309          * @return total timetable duration or INVALID_TICKS for incomplete timetables
 310          */
 311         inline Ticks GetTimetableTotalDuration() const { return this->IsCompleteTimetable() ? this->timetable_duration : INVALID_TICKS; }
 312
 313         /**
 314          * Gets the known duration of the vehicles timetable even if the timetable is not complete.
 315          * @return known timetable duration
 316          */
 317         inline Ticks GetTimetableDurationIncomplete() const { return this->timetable_duration; }
 318
 319         /**
 320          * Must be called if an order's timetable is changed to update internal book keeping.
 321          * @param delta By how many ticks has the timetable duration changed
 322          */
 323         void UpdateOrderTimetable(Ticks delta) { this->timetable_duration += delta; }
 324
 325         void FreeChain(bool keep_orderlist = false);
 326
 327         void DebugCheckSanity() const;
 328 };
 329
 330 #define FOR_ALL_ORDERS_FROM(var, start) FOR_ALL_ITEMS_FROM(Order, order_index, var, start)
 331 #define FOR_ALL_ORDERS(var) FOR_ALL_ORDERS_FROM(var, 0)
 332
 333
 334 #define FOR_VEHICLE_ORDERS(v, order) for (order = (v->orders.list == NULL) ? NULL : v->orders.list->GetFirstOrder(); order != NULL; order = order->next)
 335
 336
 337 #define FOR_ALL_ORDER_LISTS_FROM(var, start) FOR_ALL_ITEMS_FROM(OrderList, orderlist_index, var, start)
 338 #define FOR_ALL_ORDER_LISTS(var) FOR_ALL_ORDER_LISTS_FROM(var, 0)
 339
 340 #endif /* ORDER_BASE_H */