1

/* $Id$ */

     2

     3

/** @file order.h */

     4

     5

#ifndef ORDER_H

     6

#define ORDER_H

     7

     8

#include "macros.h"

     9

#include "oldpool.h"

    10

    11

enum {

    12

	INVALID_VEH_ORDER_ID = 0xFF,

    13

};

    14

    15

static const OrderID INVALID_ORDER = 0xFFFF;

    16

    17

/* Order types */

    18

enum OrderType {

    19

	OT_BEGIN         = 0,

    20

	OT_NOTHING       = 0,

    21

	OT_GOTO_STATION  = 1,

    22

	OT_GOTO_DEPOT    = 2,

    23

	OT_LOADING       = 3,

    24

	OT_LEAVESTATION  = 4,

    25

	OT_DUMMY         = 5,

    26

	OT_GOTO_WAYPOINT = 6,

    27

	OT_END

    28

};

    29

    30

/* It needs to be 8bits, because we save and load it as such */

    31

/** Define basic enum properties */

    32

template <> struct EnumPropsT<OrderType> : MakeEnumPropsT<OrderType, byte, OT_BEGIN, OT_END, OT_END> {};

    33

typedef TinyEnumT<OrderType> OrderTypeByte;

    34

    35

    36

/* Order flags -- please use OFB instead OF and use HASBIT/SETBIT/CLEARBIT */

    37

    38

/** Order flag masks - these are for direct bit operations */

    39

enum OrderFlagMasks {

    40

	//Flags for stations:

    41

	/** vehicle will transfer cargo (i. e. not deliver to nearby industry/town even if accepted there) */

    42

	OF_TRANSFER           = 0x1,

    43

	/** If OF_TRANSFER is not set, drop any cargo loaded. If accepted, deliver, otherwise cargo remains at the station.

    44

      * No new cargo is loaded onto the vehicle whatsoever */

    45

	OF_UNLOAD             = 0x2,

    46

	/** Wait for full load of all vehicles, or of at least one cargo type, depending on patch setting

    47

	  * @todo make this two different flags */

    48

	OF_FULL_LOAD          = 0x4,

    49

    50

	//Flags for depots:

    51

	/** The current depot-order was initiated because it was in the vehicle's order list */

    52

	OF_PART_OF_ORDERS     = 0x2,

    53

	/** if OF_PART_OF_ORDERS is not set, this will cause the vehicle to be stopped in the depot */

    54

	OF_HALT_IN_DEPOT      = 0x4,

    55

	/** if OF_PART_OF_ORDERS is set, this will cause the order only be come active if the vehicle needs servicing */

    56

	OF_SERVICE_IF_NEEDED  = 0x4, //used when OF_PART_OF_ORDERS is set.

    57

    58

	//Common flags

    59

	/** This causes the vehicle not to stop at intermediate OR the destination station (depending on patch settings)

    60

	  * @todo make this two different flags */

    61

	OF_NON_STOP           = 0x8

    62

};

    63

    64

/** Order flags bits - these are for the *BIT macros

    65

 * for descrption of flags, see OrderFlagMasks

    66

 * @see OrderFlagMasks

    67

 */

    68

enum {

    69

	OFB_TRANSFER          = 0,

    70

	OFB_UNLOAD            = 1,

    71

	OFB_FULL_LOAD         = 2,

    72

	OFB_PART_OF_ORDERS    = 1,

    73

	OFB_HALT_IN_DEPOT     = 2,

    74

	OFB_SERVICE_IF_NEEDED = 2,

    75

	OFB_NON_STOP          = 3

    76

};

    77

    78

    79

/* Possible clone options */

    80

enum {

    81

	CO_SHARE   = 0,

    82

	CO_COPY    = 1,

    83

	CO_UNSHARE = 2

    84

};

    85

    86

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

    87

 * - Load_ORDR, all the global orders

    88

 * - Vehicle -> current_order

    89

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

    90

 */

    91

struct Order {

    92

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

    93

    94

	OrderTypeByte type;

    95

	uint8  flags;

    96

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

    97

    98

	OrderID index;         ///< Index of the order, is not saved or anything, just for reference

    99

   100

	CargoID refit_cargo; // Refit CargoID

   101

	byte refit_subtype; // Refit subtype

   102

   103

	bool IsValid() const;

   104

	void Free();

   105

	void FreeChain();

   106

};

   107

   108

#define MAX_BACKUP_ORDER_COUNT 40

   109

   110

struct BackuppedOrders {

   111

	VehicleID clone;

   112

	VehicleOrderID orderindex;

   113

	Order order[MAX_BACKUP_ORDER_COUNT + 1];

   114

	uint16 service_interval;

   115

	char name[32];

   116

};

   117

   118

VARDEF TileIndex _backup_orders_tile;

   119

VARDEF BackuppedOrders _backup_orders_data[1];

   120

   121

DECLARE_OLD_POOL(Order, Order, 6, 1000)

   122

   123

static inline VehicleOrderID GetMaxOrderIndex()

   124

{

   125

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

   126

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

   127

	 *  _really_ returns the highest index. Now it just returns

   128

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

   129

	 */

   130

	return GetOrderPoolSize() - 1;

   131

}

   132

   133

static inline VehicleOrderID GetNumOrders()

   134

{

   135

	return GetOrderPoolSize();

   136

}

   137

   138

/**

   139

 * Check if a Order really exists.

   140

 */

   141

inline bool Order::IsValid() const

   142

{

   143

	return type != OT_NOTHING;

   144

}

   145

   146

inline void Order::Free()

   147

{

   148

	type  = OT_NOTHING;

   149

	flags = 0;

   150

	dest  = 0;

   151

	next  = NULL;

   152

}

   153

   154

inline void Order::FreeChain()

   155

{

   156

	if (next != NULL) next->FreeChain();

   157

	Free();

   158

}

   159

   160

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

   161

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

   162

   163

   164

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

   165

   166

static inline bool HasOrderPoolFree(uint amount)

   167

{

   168

	const Order *order;

   169

   170

	/* There is always room if not all blocks in the pool are reserved */

   171

	if (_Order_pool.current_blocks < _Order_pool.max_blocks)

   172

		return true;

   173

   174

	FOR_ALL_ORDERS(order)

   175

		if (!order->IsValid())

   176

			if (--amount == 0)

   177

				return true;

   178

   179

	return false;

   180

}

   181

   182

   183

/* Pack and unpack routines */

   184

   185

static inline uint32 PackOrder(const Order *order)

   186

{

   187

	return order->dest << 16 | order->flags << 8 | order->type;

   188

}

   189

   190

static inline Order UnpackOrder(uint32 packed)

   191

{

   192

	Order order;

   193

	order.type    = (OrderType)GB(packed,  0,  8);

   194

	order.flags   = GB(packed,  8,  8);

   195

	order.dest    = GB(packed, 16, 16);

   196

	order.next    = NULL;

   197

	order.index   = 0; // avoid compiler warning

   198

	order.refit_cargo   = CT_NO_REFIT;

   199

	order.refit_subtype = 0;

   200

	return order;

   201

}

   202

   203

/* Functions */

   204

void BackupVehicleOrders(const Vehicle *v, BackuppedOrders *order);

   205

void RestoreVehicleOrders(const Vehicle* v, const BackuppedOrders* order);

   206

void RemoveOrderFromAllVehicles(OrderType type, DestinationID destination);

   207

void InvalidateVehicleOrder(const Vehicle *v);

   208

bool VehicleHasDepotOrders(const Vehicle *v);

   209

void CheckOrders(const Vehicle*);

   210

void DeleteVehicleOrders(Vehicle *v);

   211

bool IsOrderListShared(const Vehicle *v);

   212

void AssignOrder(Order *order, Order data);

   213

bool CheckForValidOrders(const Vehicle* v);

   214

   215

Order UnpackOldOrder(uint16 packed);

   216

   217

#endif /* ORDER_H */