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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#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"
 
using OrderListPool = Pool<OrderList, OrderListID, 128>;
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
 */
struct Order {
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 T>
  friend class SlOrders;
 
  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{}; 
 
  CargoType refit_cargo = CARGO_NO_REFIT; 
 
  uint16_t wait_time = 0; 
  uint16_t travel_time = 0; 
  uint16_t max_speed = UINT16_MAX; 
 
public:
  Order() {}
  Order(uint8_t type, uint8_t flags, DestinationID dest) : type(type), flags(flags), dest(dest) {}

  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(DestinationID destination, OrderDepotTypeFlags order, OrderNonStopFlags non_stop_type = OrderNonStopFlag::NoIntermediate, OrderDepotActionFlags action = {}, CargoType 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 CargoType GetRefitCargo() const { return this->refit_cargo; }
 
  void SetRefit(CargoType cargo);

  inline bool IsFullLoadOrder() const
  {
    OrderLoadType type = GetLoadType();
    return type == OrderLoadType::FullLoad || type == OrderLoadType::FullLoadAny;
  }

  inline OrderLoadType GetLoadType() const { return static_cast<OrderLoadType>(GB(this->flags, 4, 3)); }

  inline OrderUnloadType GetUnloadType() const { return static_cast<OrderUnloadType>(GB(this->flags, 0, 3)); }

  inline OrderNonStopFlags GetNonStopType() const { return static_cast<OrderNonStopFlags>(GB(this->type, 6, 2)); }

  inline OrderStopLocation GetStopLocation() const { return static_cast<OrderStopLocation>(GB(this->type, 4, 2)); }

  inline OrderDepotTypeFlags GetDepotOrderType() const { return static_cast<OrderDepotTypeFlags>(GB(this->flags, 0, 3)); }

  inline OrderDepotActionFlags GetDepotActionType() const { return static_cast<OrderDepotActionFlags>(GB(this->flags, 3, 4)); }

  inline OrderConditionVariable GetConditionVariable() const { return static_cast<OrderConditionVariable>(GB(this->dest.value, 11, 5)); }

  inline OrderConditionComparator GetConditionComparator() const { return static_cast<OrderConditionComparator>(GB(this->type, 5, 3)); }

  inline VehicleOrderID GetConditionSkipToOrder() const { return this->flags; }

  inline uint16_t GetConditionValue() const { return GB(this->dest.value, 0, 11); }

  inline void SetLoadType(OrderLoadType load_type) { SB(this->flags, 4, 3, to_underlying(load_type)); }

  inline void SetUnloadType(OrderUnloadType unload_type) { SB(this->flags, 0, 3, to_underlying(unload_type)); }

  inline void SetNonStopType(OrderNonStopFlags non_stop_type) { SB(this->type, 6, 2, non_stop_type.base()); }

  inline void SetStopLocation(OrderStopLocation stop_location) { SB(this->type, 4, 2, to_underlying(stop_location)); }

  inline void SetDepotOrderType(OrderDepotTypeFlags depot_order_type) { SB(this->flags, 0, 3, depot_order_type.base()); }

  inline void SetDepotActionType(OrderDepotActionFlags depot_service_type) { SB(this->flags, 3, 4, depot_service_type.base()); }

  inline void SetConditionVariable(OrderConditionVariable condition_variable) { SB(this->dest.value, 11, 5, to_underlying(condition_variable)); }

  inline void SetConditionComparator(OrderConditionComparator condition_comparator) { SB(this->type, 5, 3, to_underlying(condition_comparator)); }

  inline void SetConditionSkipToOrder(VehicleOrderID order_id) { this->flags = order_id; }

  inline void SetConditionValue(uint16_t value) { SB(this->dest.value, 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().Test(OrderNonStopFlag::NoDestination)) {
      return false;
    }
    return true;
  }
 
  void AssignOrder(const Order &other);
  bool Equals(const Order &other) const;
 
  uint16_t MapOldOrder() const;
  void ConvertFromOldSavegame();
};

struct OldOrderSaveLoadItem {
  uint32_t index = 0; 
  uint32_t next = 0; 
  Order order{}; 
};
 
OldOrderSaveLoadItem *GetOldOrder(size_t pool_index);
OldOrderSaveLoadItem &AllocateOldOrder(size_t pool_index);
 
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 AfterLoadVehiclesPhase1(bool part_of_load); 
  friend SaveLoadTable GetOrderListDescription(); 
  friend struct ORDLChunkHandler;
  template <typename T>
  friend class SlOrders;
 
  VehicleOrderID num_manual_orders = 0; 
  uint num_vehicles = 0; 
  Vehicle *first_shared = nullptr; 
  std::vector<Order> orders; 
  uint32_t old_order_index = 0;
 
  TimerGameTick::Ticks timetable_duration{}; 
  TimerGameTick::Ticks total_duration{}; 
 
public:
  OrderList(OrderListID index) : OrderListPool::PoolItem<&_orderlist_pool>(index) {}

  OrderList(OrderListID index, Order &&order, Vehicle *v) : OrderListPool::PoolItem<&_orderlist_pool>(index)
  {
    this->orders.emplace_back(std::move(order));
    this->Initialize(v);
  }
 
  OrderList(OrderListID index, std::vector<Order> &&orders, Vehicle *v) : OrderListPool::PoolItem<&_orderlist_pool>(index)
  {
    this->orders = std::move(orders);
    this->Initialize(v);
  }
 
  OrderList(OrderListID index, Vehicle *v) : OrderListPool::PoolItem<&_orderlist_pool>(index)
  {
    this->Initialize(v);
  }

  ~OrderList() {}
 
  void Initialize(Vehicle *v);
 
  void RecalculateTimetableDuration();

  inline VehicleOrderID GetFirstOrder() const { return this->orders.empty() ? INVALID_VEH_ORDER_ID : 0; }
 
  inline std::span<const Order> GetOrders() const { return this->orders; }
  inline std::span<Order> GetOrders() { return this->orders; }

  const Order *GetOrderAt(VehicleOrderID index) const
  {
    if (index >= this->GetNumOrders()) return nullptr;
    return &this->orders[index];
  }
 
  Order *GetOrderAt(VehicleOrderID index)
  {
    if (index >= this->GetNumOrders()) return nullptr;
    return &this->orders[index];
  }

  inline VehicleOrderID GetLastOrder() const { return this->orders.empty() ? INVALID_VEH_ORDER_ID : (this->GetNumOrders() - 1); }

  inline VehicleOrderID GetNext(VehicleOrderID cur) const
  {
    if (this->orders.empty()) return INVALID_VEH_ORDER_ID;
    return static_cast<VehicleOrderID>((cur + 1) % this->GetNumOrders());
  }

  inline VehicleOrderID GetNumOrders() const { return static_cast<VehicleOrderID>(std::size(this->orders)); }

  inline VehicleOrderID GetNumManualOrders() const { return this->num_manual_orders; }
 
  void GetNextStoppingStation(std::vector<StationID> &next_station, const Vehicle *v, VehicleOrderID first = INVALID_VEH_ORDER_ID, uint hops = 0) const;
  VehicleOrderID GetNextDecisionNode(VehicleOrderID next, uint hops) const;
 
  void InsertOrderAt(Order &&order, VehicleOrderID index);
  void DeleteOrderAt(VehicleOrderID index);
  void MoveOrder(VehicleOrderID from, VehicleOrderID 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 */