1

/* $Id$ */

     2

     3

/** @file order_base.h Base class for orders. */

     4

     5

#ifndef ORDER_BASE_H

     6

#define ORDER_BASE_H

     7

     8

#include "order_type.h"

     9

#include "oldpool.h"

    10

#include "core/bitmath_func.hpp"

    11

#include "cargo_type.h"

    12

#include "depot_type.h"

    13

#include "station_type.h"

    14

#include "vehicle_type.h"

    15

#include "waypoint_type.h"

    16

    17

DECLARE_OLD_POOL(Order, Order, 6, 1000)

    18

    19

/* If you change this, keep in mind that it is saved on 3 places:

    20

 * - Load_ORDR, all the global orders

    21

 * - Vehicle -> current_order

    22

 * - REF_ORDER (all REFs are currently limited to 16 bits!!)

    23

 */

    24

struct Order : PoolItem<Order, OrderID, &_Order_pool> {

    25

private:

    26

	friend const struct SaveLoad *GetVehicleDescription(VehicleType vt); ///< Saving and loading the current order of vehicles.

    27

	friend void Load_VEHS();                                             ///< Loading of ancient vehicles.

    28

	friend const struct SaveLoad *GetOrderDescription();                 ///< Saving and loading of orders.

    29

    30

	uint8 type;           ///< The type of order + non-stop flags

    31

	uint8 flags;          ///< Load/unload types, depot order/action types.

    32

	DestinationID dest;   ///< The destination of the order.

    33

    34

	CargoID refit_cargo;  ///< Refit CargoID

    35

	byte refit_subtype;   ///< Refit subtype

    36

    37

public:

    38

	Order *next;          ///< Pointer to next order. If NULL, end of list

    39

    40

	uint16 wait_time;    ///< How long in ticks to wait at the destination.

    41

	uint16 travel_time;  ///< How long in ticks the journey to this destination should take.

    42

    43

	Order() : refit_cargo(CT_NO_REFIT) {}

    44

	~Order() { this->type = OT_NOTHING; }

    45

    46

	/**

    47

	 * Create an order based on a packed representation of that order.

    48

	 * @param packed the packed representation.

    49

	 */

    50

	Order(uint32 packed);

    51

    52

	/**

    53

	 * Check if a Order really exists.

    54

	 * @return true if the order is valid.

    55

	 */

    56

	inline bool IsValid() const { return this->type != OT_NOTHING; }

    57

    58

	/**

    59

	 * Check whether this order is of the given type.

    60

	 * @param type the type to check against.

    61

	 * @return true if the order matches.

    62

	 */

    63

	inline bool IsType(OrderType type) const { return this->GetType() == type; }

    64

    65

	/**

    66

	 * Get the type of order of this order.

    67

	 * @return the order type.

    68

	 */

    69

	inline OrderType GetType() const { return (OrderType)GB(this->type, 0, 4); }

    70

    71

	/**

    72

	 * 'Free' the order

    73

	 * @note ONLY use on "current_order" vehicle orders!

    74

	 */

    75

	void Free();

    76

    77

	/**

    78

	 * Makes this order a Go To Station order.

    79

	 * @param destsination the station to go to.

    80

	 */

    81

	void MakeGoToStation(StationID destination);

    82

    83

	/**

    84

	 * Makes this order a Go To Depot order.

    85

	 * @param destination the depot to go to.

    86

	 * @param order       is this order a 'default' order, or an overriden vehicle order?

    87

	 * @param action      what to do in the depot?

    88

	 * @param cargo       the cargo type to change to.

    89

	 * @param subtype     the subtype to change to.

    90

	 */

    91

	void MakeGoToDepot(DepotID destination, OrderDepotTypeFlags order, OrderDepotActionFlags action = ODATF_SERVICE_ONLY, CargoID cargo = CT_NO_REFIT, byte subtype = 0);

    92

    93

	/**

    94

	 * Makes this order a Go To Waypoint order.

    95

	 * @param destination the waypoint to go to.

    96

	 */

    97

	void MakeGoToWaypoint(WaypointID destination);

    98

    99

	/**

   100

	 * Makes this order a Loading order.

   101

	 * @param ordered is this an ordered stop?

   102

	 */

   103

	void MakeLoading(bool ordered);

   104

   105

	/**

   106

	 * Makes this order a Leave Station order.

   107

	 */

   108

	void MakeLeaveStation();

   109

   110

	/**

   111

	 * Makes this order a Dummy order.

   112

	 */

   113

	void MakeDummy();

   114

   115

	/**

   116

	 * Makes this order an conditional order.

   117

	 * @param order the order to jump to.

   118

	 */

   119

	void MakeConditional(VehicleOrderID order);

   120

   121

	/**

   122

	 * Free a complete order chain.

   123

	 * @note do not use on "current_order" vehicle orders!

   124

	 */

   125

	void FreeChain();

   126

   127

	/**

   128

	 * Gets the destination of this order.

   129

	 * @pre IsType(OT_GOTO_WAYPOINT) || IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION).

   130

	 * @return the destination of the order.

   131

	 */

   132

	inline DestinationID GetDestination() const { return this->dest; }

   133

   134

	/**

   135

	 * Sets the destination of this order.

   136

	 * @param destination the new destination of the order.

   137

	 * @pre IsType(OT_GOTO_WAYPOINT) || IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION).

   138

	 */

   139

	inline void SetDestination(DestinationID destination) { this->dest = destination; }

   140

   141

	/**

   142

	 * Is this order a refit order.

   143

	 * @pre IsType(OT_GOTO_DEPOT)

   144

	 * @return true if a refit should happen.

   145

	 */

   146

	inline bool IsRefit() const { return this->refit_cargo < NUM_CARGO; }

   147

   148

	/**

   149

	 * Get the cargo to to refit to.

   150

	 * @pre IsType(OT_GOTO_DEPOT)

   151

	 * @return the cargo type.

   152

	 */

   153

	inline CargoID GetRefitCargo() const { return this->refit_cargo; }

   154

   155

	/**

   156

	 * Get the cargo subtype to to refit to.

   157

	 * @pre IsType(OT_GOTO_DEPOT)

   158

	 * @return the cargo subtype.

   159

	 */

   160

	inline byte GetRefitSubtype() const { return this->refit_subtype; }

   161

   162

	/**

   163

	 * Make this depot order also a refit order.

   164

	 * @param cargo   the cargo type to change to.

   165

	 * @param subtype the subtype to change to.

   166

	 * @pre IsType(OT_GOTO_DEPOT).

   167

	 */

   168

	void SetRefit(CargoID cargo, byte subtype = 0);

   169

   170

	/** How must the consist be loaded? */

   171

	inline OrderLoadFlags GetLoadType() const { return (OrderLoadFlags)GB(this->flags, 4, 4); }

   172

	/** How must the consist be unloaded? */

   173

	inline OrderUnloadFlags GetUnloadType() const { return (OrderUnloadFlags)GB(this->flags, 0, 4); }

   174

	/** Where must we stop? */

   175

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

   176

	/** What caused us going to the depot? */

   177

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

   178

	/** What are we going to do when in the depot. */

   179

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

   180

	/** What variable do we have to compare? */

   181

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

   182

	/** What is the comparator to use? */

   183

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

   184

	/** Get the order to skip to. */

   185

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

   186

	/** Get the value to base the skip on. */

   187

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

   188

   189

	/** Set how the consist must be loaded. */

   190

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

   191

	/** Set how the consist must be unloaded. */

   192

	inline void SetUnloadType(OrderUnloadFlags unload_type) { SB(this->flags, 0, 4, unload_type); }

   193

	/** Set whether we must stop at stations or not. */

   194

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

   195

	/** Set the cause to go to the depot. */

   196

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

   197

	/** Set what we are going to do in the depot. */

   198

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

   199

	/** Set variable we have to compare. */

   200

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

   201

	/** Set the comparator to use. */

   202

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

   203

	/** Get the order to skip to. */

   204

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

   205

	/** Set the value to base the skip on. */

   206

	inline void SetConditionValue(uint16 value) { SB(this->dest, 0, 11, value); }

   207

   208

	bool ShouldStopAtStation(const Vehicle *v, StationID station) const;

   209

   210

	/**

   211

	 * Assign the given order to this one.

   212

	 * @param other the data to copy (except next pointer).

   213

	 */

   214

	void AssignOrder(const Order &other);

   215

   216

	/**

   217

	 * Does this order have the same type, flags and destination?

   218

	 * @param other the second order to compare to.

   219

	 * @return true if the type, flags and destination match.

   220

	 */

   221

	bool Equals(const Order &other) const;

   222

   223

	/**

   224

	 * Pack this order into a 32 bits integer, or actually only

   225

	 * the type, flags and destination.

   226

	 * @return the packed representation.

   227

	 * @note unpacking is done in the constructor.

   228

	 */

   229

	uint32 Pack() const;

   230

   231

	/**

   232

	 * Converts this order from an old savegame's version;

   233

	 * it moves all bits to the new location.

   234

	 */

   235

	void ConvertFromOldSavegame();

   236

};

   237

   238

static inline VehicleOrderID GetMaxOrderIndex()

   239

{

   240

	/* TODO - This isn't the real content of the function, but

   241

	 *  with the new pool-system this will be replaced with one that

   242

	 *  _really_ returns the highest index. Now it just returns

   243

	 *  the next safe value we are sure about everything is below.

   244

	 */

   245

	return GetOrderPoolSize() - 1;

   246

}

   247

   248

static inline VehicleOrderID GetNumOrders()

   249

{

   250

	return GetOrderPoolSize();

   251

}

   252

   253

#define FOR_ALL_ORDERS_FROM(order, start) for (order = GetOrder(start); order != NULL; order = (order->index + 1U < GetOrderPoolSize()) ? GetOrder(order->index + 1U) : NULL) if (order->IsValid())

   254

#define FOR_ALL_ORDERS(order) FOR_ALL_ORDERS_FROM(order, 0)

   255

   256

   257

#define FOR_VEHICLE_ORDERS(v, order) for (order = v->orders; order != NULL; order = order->next)

   258

   259

/* (Un)pack routines */

   260

Order UnpackOldOrder(uint16 packed);

   261

   262

#endif /* ORDER_H */