order_base.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#ifndef ORDER_BASE_H
#define ORDER_BASE_H
 
#include "order_type.h"
#include "core/pool_type.hpp"
#include "core/bitmath_func.hpp"
#include "cargo_type.h"
#include "depot_type.h"
#include "station_type.h"
#include "vehicle_type.h"
#include "timer/timer_game_tick.h"
#include "saveload/saveload.h"
 
typedef Pool<Order, OrderID, 256, 0xFF0000> OrderPool;
typedef Pool<OrderList, OrderListID, 128, 64000> OrderListPool;
extern OrderPool _order_pool;
extern OrderListPool _orderlist_pool;
 
template <typename, typename>
class EndianBufferWriter;
 
/* If you change this, keep in mind that it is saved on 3 places:
 * - Load_ORDR, all the global orders
 * - Vehicle -> current_order
 * - REF_ORDER (all REFs are currently limited to 16 bits!!)
 */
struct Order : OrderPool::PoolItem<&_order_pool> {
private:
  friend struct VEHSChunkHandler;                             
  friend SaveLoadTable GetOrderDescription();                 
  /* So we can use private/protected variables in the saveload code */
  friend class SlVehicleCommon;
  friend class SlVehicleDisaster;
 
  template <typename Tcont, typename Titer>
  friend EndianBufferWriter<Tcont, Titer> &operator <<(EndianBufferWriter<Tcont, Titer> &buffer, const Order &data);
  friend class EndianBufferReader &operator >>(class EndianBufferReader &buffer, Order &order);
 
  uint8_t type = 0; 
  uint8_t flags = 0; 
  DestinationID dest = 0; 
 
  CargoID refit_cargo = CARGO_NO_REFIT; 
 
  uint16_t wait_time = 0; 
  uint16_t travel_time = 0; 
  uint16_t max_speed = UINT16_MAX; 
 
public:
  Order *next = nullptr; 
 
  Order() {}
  Order(uint8_t type, uint8_t flags, DestinationID dest) : type(type), flags(flags), dest(dest) {}
  ~Order();
 
  inline bool IsType(OrderType type) const { return this->GetType() == type; }
 
  inline OrderType GetType() const { return (OrderType)GB(this->type, 0, 4); }
 
  void Free();
 
  void MakeGoToStation(StationID destination);
  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);
  void MakeGoToWaypoint(StationID destination);
  void MakeLoading(bool ordered);
  void MakeLeaveStation();
  void MakeDummy();
  void MakeConditional(VehicleOrderID order);
  void MakeImplicit(StationID destination);
 
  inline bool IsGotoOrder() const
  {
    return IsType(OT_GOTO_WAYPOINT) || IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION);
  }
 
  inline DestinationID GetDestination() const { return this->dest; }
 
  inline void SetDestination(DestinationID destination) { this->dest = destination; }
 
  inline bool IsRefit() const { return this->refit_cargo < NUM_CARGO || this->refit_cargo == CARGO_AUTO_REFIT; }
 
  inline bool IsAutoRefit() const { return this->refit_cargo == CARGO_AUTO_REFIT; }
 
  inline CargoID GetRefitCargo() const { return this->refit_cargo; }
 
  void SetRefit(CargoID cargo);
 
  inline OrderLoadFlags GetLoadType() const { return (OrderLoadFlags)GB(this->flags, 4, 3); }
  inline OrderUnloadFlags GetUnloadType() const { return (OrderUnloadFlags)GB(this->flags, 0, 3); }
  inline OrderNonStopFlags GetNonStopType() const { return (OrderNonStopFlags)GB(this->type, 6, 2); }
  inline OrderStopLocation GetStopLocation() const { return (OrderStopLocation)GB(this->type, 4, 2); }
  inline OrderDepotTypeFlags GetDepotOrderType() const { return (OrderDepotTypeFlags)GB(this->flags, 0, 3); }
  inline OrderDepotActionFlags GetDepotActionType() const { return (OrderDepotActionFlags)GB(this->flags, 3, 4); }
  inline OrderConditionVariable GetConditionVariable() const { return (OrderConditionVariable)GB(this->dest, 11, 5); }
  inline OrderConditionComparator GetConditionComparator() const { return (OrderConditionComparator)GB(this->type, 5, 3); }
  inline VehicleOrderID GetConditionSkipToOrder() const { return this->flags; }
  inline uint16_t GetConditionValue() const { return GB(this->dest, 0, 11); }
 
  inline void SetLoadType(OrderLoadFlags load_type) { SB(this->flags, 4, 3, load_type); }
  inline void SetUnloadType(OrderUnloadFlags unload_type) { SB(this->flags, 0, 3, unload_type); }
  inline void SetNonStopType(OrderNonStopFlags non_stop_type) { SB(this->type, 6, 2, non_stop_type); }
  inline void SetStopLocation(OrderStopLocation stop_location) { SB(this->type, 4, 2, stop_location); }
  inline void SetDepotOrderType(OrderDepotTypeFlags depot_order_type) { SB(this->flags, 0, 3, depot_order_type); }
  inline void SetDepotActionType(OrderDepotActionFlags depot_service_type) { SB(this->flags, 3, 4, depot_service_type); }
  inline void SetConditionVariable(OrderConditionVariable condition_variable) { SB(this->dest, 11, 5, condition_variable); }
  inline void SetConditionComparator(OrderConditionComparator condition_comparator) { SB(this->type, 5, 3, condition_comparator); }
  inline void SetConditionSkipToOrder(VehicleOrderID order_id) { this->flags = order_id; }
  inline void SetConditionValue(uint16_t value) { SB(this->dest, 0, 11, value); }
 
  /* As conditional orders write their "skip to" order all over the flags, we cannot check the
   * flags to find out if timetabling is enabled. However, as conditional orders are never
   * autofilled we can be sure that any non-zero values for their wait_time and travel_time are
   * explicitly set (but travel_time is actually unused for conditionals). */
 
  inline bool IsWaitTimetabled() const { return this->IsType(OT_CONDITIONAL) ? this->wait_time > 0 : HasBit(this->flags, 3); }
  inline bool IsTravelTimetabled() const { return this->IsType(OT_CONDITIONAL) ? this->travel_time > 0 : HasBit(this->flags, 7); }
 
  inline uint16_t GetTimetabledWait() const { return this->IsWaitTimetabled() ? this->wait_time : 0; }
  inline uint16_t GetTimetabledTravel() const { return this->IsTravelTimetabled() ? this->travel_time : 0; }
  inline uint16_t GetWaitTime() const { return this->wait_time; }
  inline uint16_t GetTravelTime() const { return this->travel_time; }
 
  inline uint16_t GetMaxSpeed() const { return this->max_speed; }
 
  inline void SetWaitTimetabled(bool timetabled) { if (!this->IsType(OT_CONDITIONAL)) AssignBit(this->flags, 3, timetabled); }
  inline void SetTravelTimetabled(bool timetabled) { if (!this->IsType(OT_CONDITIONAL)) AssignBit(this->flags, 7, timetabled); }
 
  inline void SetWaitTime(uint16_t time) { this->wait_time = time;  }
 
  inline void SetTravelTime(uint16_t time) { this->travel_time = time; }
 
  inline void SetMaxSpeed(uint16_t speed) { this->max_speed = speed; }
 
  bool ShouldStopAtStation(const Vehicle *v, StationID station) const;
  bool CanLoadOrUnload() const;
  bool CanLeaveWithCargo(bool has_cargo) const;
 
  TileIndex GetLocation(const Vehicle *v, bool airport = false) const;
 
  inline bool IsCompletelyTimetabled() const
  {
    if (!this->IsTravelTimetabled() && !this->IsType(OT_CONDITIONAL)) return false;
    if (!this->IsWaitTimetabled() && this->IsType(OT_GOTO_STATION) &&
        !(this->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION)) {
      return false;
    }
    return true;
  }
 
  void AssignOrder(const Order &other);
  bool Equals(const Order &other) const;
 
  uint32_t Pack() const;
  uint16_t MapOldOrder() const;
  void ConvertFromOldSavegame();
};
 
void InsertOrder(Vehicle *v, Order *new_o, VehicleOrderID sel_ord);
void DeleteOrder(Vehicle *v, VehicleOrderID sel_ord);
 
struct OrderList : OrderListPool::PoolItem<&_orderlist_pool> {
private:
  friend void AfterLoadVehicles(bool part_of_load); 
  friend SaveLoadTable GetOrderListDescription(); 
 
  VehicleOrderID num_orders;        
  VehicleOrderID num_manual_orders; 
  uint num_vehicles;                
  Vehicle *first_shared;            
  Order *first;                     
 
  TimerGameTick::Ticks timetable_duration;         
  TimerGameTick::Ticks total_duration;             
 
public:
  OrderList(VehicleOrderID num_orders = INVALID_VEH_ORDER_ID)
    : num_orders(num_orders), num_manual_orders(0), num_vehicles(0), first_shared(nullptr), first(nullptr),
      timetable_duration(0), total_duration(0) { }
 
  OrderList(Order *chain, Vehicle *v) { this->Initialize(chain, v); }
 
  ~OrderList() {}
 
  void Initialize(Order *chain, Vehicle *v);
 
  void RecalculateTimetableDuration();
 
  inline Order *GetFirstOrder() const { return this->first; }
 
  Order *GetOrderAt(int index) const;
 
  inline Order *GetLastOrder() const { return this->GetOrderAt(this->num_orders - 1); }
 
  inline const Order *GetNext(const Order *curr) const { return (curr->next == nullptr) ? this->GetFirstOrder() : curr->next; }
 
  inline VehicleOrderID GetNumOrders() const { return this->num_orders; }
 
  inline VehicleOrderID GetNumManualOrders() const { return this->num_manual_orders; }
 
  StationIDStack GetNextStoppingStation(const Vehicle *v, const Order *first = nullptr, uint hops = 0) const;
  const Order *GetNextDecisionNode(const Order *next, uint hops) const;
 
  void InsertOrderAt(Order *new_order, int index);
  void DeleteOrderAt(int index);
  void MoveOrder(int from, int to);
 
  inline bool IsShared() const { return this->num_vehicles > 1; };
 
  inline Vehicle *GetFirstSharedVehicle() const { return this->first_shared; }
 
  inline uint GetNumVehicles() const { return this->num_vehicles; }
 
  inline void AddVehicle([[maybe_unused]] Vehicle *v) { ++this->num_vehicles; }
 
  void RemoveVehicle(Vehicle *v);
 
  bool IsCompleteTimetable() const;
 
  inline TimerGameTick::Ticks GetTimetableTotalDuration() const { return this->IsCompleteTimetable() ? this->timetable_duration : Ticks::INVALID_TICKS; }
 
  inline TimerGameTick::Ticks GetTimetableDurationIncomplete() const { return this->timetable_duration; }
 
  inline TimerGameTick::Ticks GetTotalDuration() const { return this->total_duration; }
 
  void UpdateTimetableDuration(TimerGameTick::Ticks delta) { this->timetable_duration += delta; }
 
  void UpdateTotalDuration(TimerGameTick::Ticks delta) { this->total_duration += delta; }
 
  void FreeChain(bool keep_orderlist = false);
 
  void DebugCheckSanity() const;
};
 
#endif /* ORDER_BASE_H */