1

/* $Id$ */

     2

     3

/** @file order_base.h */

     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

	OrderTypeByte type;   ///< The type of order

    31

	uint8 flags;          ///< 'Sub'type of order

    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->type == type; }

    64

    65

	/**

    66

	 * Get the type of order of this order.

    67

	 * @return the order type.

    68

	 */

    69

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

    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 cargo       the cargo type to change to.

    88

	 * @param subtype     the subtype to change to.

    89

	 */

    90

	void MakeGoToDepot(DepotID destination, bool order, CargoID cargo = CT_NO_REFIT, byte subtype = 0);

    91

    92

	/**

    93

	 * Makes this order a Go To Waypoint order.

    94

	 * @param destination the waypoint to go to.

    95

	 */

    96

	void MakeGoToWaypoint(WaypointID destination);

    97

    98

	/**

    99

	 * Makes this order a Loading order.

   100

	 * @param ordered is this an ordered stop?

   101

	 */

   102

	void MakeLoading(bool ordered);

   103

   104

	/**

   105

	 * Makes this order a Leave Station order.

   106

	 */

   107

	void MakeLeaveStation();

   108

   109

	/**

   110

	 * Makes this order a Dummy order.

   111

	 */

   112

	void MakeDummy();

   113

   114

	/**

   115

	 * Free a complete order chain.

   116

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

   117

	 */

   118

	void FreeChain();

   119

   120

	/**

   121

	 * Gets the destination of this order.

   122

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

   123

	 * @return the destination of the order.

   124

	 */

   125

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

   126

   127

	/**

   128

	 * Sets the destination of this order.

   129

	 * @param destination the new destination of the order.

   130

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

   131

	 */

   132

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

   133

   134

	/**

   135

	 * Is this order a refit order.

   136

	 * @pre IsType(OT_GOTO_DEPOT)

   137

	 * @return true if a refit should happen.

   138

	 */

   139

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

   140

   141

	/**

   142

	 * Get the cargo to to refit to.

   143

	 * @pre IsType(OT_GOTO_DEPOT)

   144

	 * @return the cargo type.

   145

	 */

   146

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

   147

   148

	/**

   149

	 * Get the cargo subtype to to refit to.

   150

	 * @pre IsType(OT_GOTO_DEPOT)

   151

	 * @return the cargo subtype.

   152

	 */

   153

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

   154

   155

	/**

   156

	 * Make this depot order also a refit order.

   157

	 * @param cargo   the cargo type to change to.

   158

	 * @param subtype the subtype to change to.

   159

	 * @pre IsType(OT_GOTO_DEPOT).

   160

	 */

   161

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

   162

   163

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

   164

	inline byte GetLoadType() const { return this->flags & OFB_FULL_LOAD; }

   165

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

   166

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

   167

	/** Where must we stop? */

   168

	OrderNonStopFlags GetNonStopType() const;

   169

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

   170

	inline byte GetDepotOrderType() const { return this->flags; }

   171

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

   172

	inline byte GetDepotActionType() const { return this->flags; }

   173

   174

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

   175

	inline void SetLoadType(byte load_type) { SB(this->flags, 2, 1, !!load_type); }

   176

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

   177

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

   178

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

   179

	inline void SetNonStopType(OrderNonStopFlags non_stop_type) { SB(this->flags, 3, 1, !!non_stop_type); }

   180

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

   181

	inline void SetDepotOrderType(byte depot_order_type) { this->flags = depot_order_type; }

   182

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

   183

	inline void SetDepotActionType(byte depot_service_type) { this->flags = depot_service_type; }

   184

   185

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

   186

   187

	/**

   188

	 * Assign the given order to this one.

   189

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

   190

	 */

   191

	void AssignOrder(const Order &other);

   192

   193

	/**

   194

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

   195

	 * @param other the second order to compare to.

   196

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

   197

	 */

   198

	bool Equals(const Order &other) const;

   199

   200

	/**

   201

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

   202

	 * the type, flags and destination.

   203

	 * @return the packed representation.

   204

	 * @note unpacking is done in the constructor.

   205

	 */

   206

	uint32 Pack() const;

   207

};

   208

   209

static inline VehicleOrderID GetMaxOrderIndex()

   210

{

   211

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

   212

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

   213

	 *  _really_ returns the highest index. Now it just returns

   214

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

   215

	 */

   216

	return GetOrderPoolSize() - 1;

   217

}

   218

   219

static inline VehicleOrderID GetNumOrders()

   220

{

   221

	return GetOrderPoolSize();

   222

}

   223

   224

#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())

   225

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

   226

   227

   228

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

   229

   230

/* (Un)pack routines */

   231

Order UnpackOldOrder(uint16 packed);

   232

   233

#endif /* ORDER_H */