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

    88

	 * @param subtype     the subtype to change to.

    89

	 */

    90

	void MakeGoToDepot(DepotID destination, OrderDepotTypeFlags 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

	 * Makes this order an conditional order.

   116

	 * @param order the order to jump to.

   117

	 */

   118

	void MakeConditional(VehicleOrderID order);

   119

   120

	/**

   121

	 * Free a complete order chain.

   122

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

   123

	 */

   124

	void FreeChain();

   125

   126

	/**

   127

	 * Gets the destination of this order.

   128

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

   129

	 * @return the destination of the order.

   130

	 */

   131

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

   132

   133

	/**

   134

	 * Sets the destination of this order.

   135

	 * @param destination the new destination of the order.

   136

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

   137

	 */

   138

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

   139

   140

	/**

   141

	 * Is this order a refit order.

   142

	 * @pre IsType(OT_GOTO_DEPOT)

   143

	 * @return true if a refit should happen.

   144

	 */

   145

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

   146

   147

	/**

   148

	 * Get the cargo to to refit to.

   149

	 * @pre IsType(OT_GOTO_DEPOT)

   150

	 * @return the cargo type.

   151

	 */

   152

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

   153

   154

	/**

   155

	 * Get the cargo subtype to to refit to.

   156

	 * @pre IsType(OT_GOTO_DEPOT)

   157

	 * @return the cargo subtype.

   158

	 */

   159

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

   160

   161

	/**

   162

	 * Make this depot order also a refit order.

   163

	 * @param cargo   the cargo type to change to.

   164

	 * @param subtype the subtype to change to.

   165

	 * @pre IsType(OT_GOTO_DEPOT).

   166

	 */

   167

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

   168

   169

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

   170

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

   171

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

   172

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

   173

	/** Where must we stop? */

   174

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

   175

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

   176

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

   177

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

   178

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

   179

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

   180

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

   181

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

   182

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

   183

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

   184

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

   185

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

   186

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

   187

   188

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

   189

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

   190

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

   191

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

   192

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

   193

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

   194

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

   195

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

   196

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

   197

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

   198

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

   199

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

   200

	/** Set the comparator to use. */

   201

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

   202

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

   203

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

   204

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

   205

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

   206

   207

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

   208

   209

	/**

   210

	 * Assign the given order to this one.

   211

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

   212

	 */

   213

	void AssignOrder(const Order &other);

   214

   215

	/**

   216

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

   217

	 * @param other the second order to compare to.

   218

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

   219

	 */

   220

	bool Equals(const Order &other) const;

   221

   222

	/**

   223

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

   224

	 * the type, flags and destination.

   225

	 * @return the packed representation.

   226

	 * @note unpacking is done in the constructor.

   227

	 */

   228

	uint32 Pack() const;

   229

   230

	/**

   231

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

   232

	 * it moves all bits to the new location.

   233

	 */

   234

	void ConvertFromOldSavegame();

   235

};

   236

   237

static inline VehicleOrderID GetMaxOrderIndex()

   238

{

   239

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

   240

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

   241

	 *  _really_ returns the highest index. Now it just returns

   242

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

   243

	 */

   244

	return GetOrderPoolSize() - 1;

   245

}

   246

   247

static inline VehicleOrderID GetNumOrders()

   248

{

   249

	return GetOrderPoolSize();

   250

}

   251

   252

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

   253

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

   254

   255

   256

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

   257

   258

/* (Un)pack routines */

   259

Order UnpackOldOrder(uint16 packed);

   260

   261

#endif /* ORDER_H */