1

/* $Id$ */

     2

     3

/** @file order.h */

     4

     5

#ifndef ORDER_H

     6

#define ORDER_H

     7

     8

#include "macros.h"

     9

#include "pool.h"

    10

    11

enum {

    12

	INVALID_VEH_ORDER_ID = 0xFF,

    13

	INVALID_ORDER        = 0xFFFF,

    14

};

    15

    16

/* Order types */

    17

enum OrderTypes {

    18

	OT_NOTHING       = 0,

    19

	OT_GOTO_STATION  = 1,

    20

	OT_GOTO_DEPOT    = 2,

    21

	OT_LOADING       = 3,

    22

	OT_LEAVESTATION  = 4,

    23

	OT_DUMMY         = 5,

    24

	OT_GOTO_WAYPOINT = 6,

    25

};

    26

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

    27

typedef uint8 OrderType;

    28

    29

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

    30

    31

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

    32

enum OrderFlagMasks {

    33

	//Flags for stations:

    34

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

    35

	OF_TRANSFER           = 0x1,

    36

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

    37

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

    38

	OF_UNLOAD             = 0x2,

    39

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

    40

	  * @todo make this two different flags */

    41

	OF_FULL_LOAD          = 0x4,

    42

    43

	//Flags for depots:

    44

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

    45

	OF_PART_OF_ORDERS     = 0x2,

    46

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

    47

	OF_HALT_IN_DEPOT      = 0x4,

    48

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

    49

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

    50

    51

	//Common flags

    52

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

    53

	  * @todo make this two different flags */

    54

	OF_NON_STOP           = 0x8

    55

};

    56

    57

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

    58

 * for descrption of flags, see OrderFlagMasks

    59

 * @see OrderFlagMasks

    60

 */

    61

enum {

    62

	OFB_TRANSFER          = 0,

    63

	OFB_UNLOAD            = 1,

    64

	OFB_FULL_LOAD         = 2,

    65

	OFB_PART_OF_ORDERS    = 1,

    66

	OFB_HALT_IN_DEPOT     = 2,

    67

	OFB_SERVICE_IF_NEEDED = 2,

    68

	OFB_NON_STOP          = 3

    69

};

    70

    71

    72

/* Possible clone options */

    73

enum {

    74

	CO_SHARE   = 0,

    75

	CO_COPY    = 1,

    76

	CO_UNSHARE = 2

    77

};

    78

    79

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

    80

 * - Load_ORDR, all the global orders

    81

 * - Vehicle -> current_order

    82

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

    83

 */

    84

typedef struct Order {

    85

	OrderType type;

    86

	uint8  flags;

    87

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

    88

    89

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

    90

    91

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

    92

    93

	CargoID refit_cargo; // Refit CargoID

    94

	byte refit_subtype; // Refit subtype

    95

} Order;

    96

    97

#define MAX_BACKUP_ORDER_COUNT 40

    98

    99

typedef struct {

   100

	VehicleID clone;

   101

	VehicleOrderID orderindex;

   102

	Order order[MAX_BACKUP_ORDER_COUNT + 1];

   103

	uint16 service_interval;

   104

	char name[32];

   105

} BackuppedOrders;

   106

   107

VARDEF TileIndex _backup_orders_tile;

   108

VARDEF BackuppedOrders _backup_orders_data[1];

   109

   110

extern MemoryPool _order_pool;

   111

   112

/**

   113

 * Get the pointer to the order with index 'index'

   114

 */

   115

static inline Order *GetOrder(OrderID index)

   116

{

   117

	return (Order*)GetItemFromPool(&_order_pool, index);

   118

}

   119

   120

/**

   121

 * Get the current size of the OrderPool

   122

 */

   123

static inline uint16 GetOrderPoolSize(void)

   124

{

   125

	return _order_pool.total_items;

   126

}

   127

   128

static inline VehicleOrderID GetOrderArraySize(void)

   129

{

   130

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

   131

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

   132

	 *  _really_ returns the highest index + 1. Now it just returns

   133

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

   134

	 */

   135

	return GetOrderPoolSize();

   136

}

   137

   138

/**

   139

 * Check if a Order really exists.

   140

 */

   141

static inline bool IsValidOrder(const Order *o)

   142

{

   143

	return o->type != OT_NOTHING;

   144

}

   145

   146

static inline void DeleteOrder(Order *o)

   147

{

   148

	o->type = OT_NOTHING;

   149

	o->next = NULL;

   150

}

   151

   152

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

   153

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

   154

   155

   156

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

   157

   158

static inline bool HasOrderPoolFree(uint amount)

   159

{

   160

	const Order *order;

   161

   162

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

   163

	if (_order_pool.current_blocks < _order_pool.max_blocks)

   164

		return true;

   165

   166

	FOR_ALL_ORDERS(order)

   167

		if (order->type == OT_NOTHING)

   168

			if (--amount == 0)

   169

				return true;

   170

   171

	return false;

   172

}

   173

   174

static inline bool IsOrderPoolFull(void)

   175

{

   176

	return !HasOrderPoolFree(1);

   177

}

   178

   179

/* Pack and unpack routines */

   180

   181

static inline uint32 PackOrder(const Order *order)

   182

{

   183

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

   184

}

   185

   186

static inline Order UnpackOrder(uint32 packed)

   187

{

   188

	Order order;

   189

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

   190

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

   191

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

   192

	order.next    = NULL;

   193

	order.index   = 0; // avoid compiler warning

   194

	order.refit_cargo   = CT_INVALID;

   195

	order.refit_subtype = 0;

   196

	return order;

   197

}

   198

   199

/* Functions */

   200

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

   201

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

   202

void RemoveOrderFromAllVehicles(OrderType type, DestinationID destination);

   203

void InvalidateVehicleOrder(const Vehicle *v);

   204

bool VehicleHasDepotOrders(const Vehicle *v);

   205

void CheckOrders(const Vehicle*);

   206

void DeleteVehicleOrders(Vehicle *v);

   207

bool IsOrderListShared(const Vehicle *v);

   208

void AssignOrder(Order *order, Order data);

   209

bool CheckForValidOrders(const Vehicle* v);

   210

   211

Order UnpackOldOrder(uint16 packed);

   212

   213

#endif /* ORDER_H */