1

/* $Id$ */

     2

     3

/** @file order.h

     4

  */

     5

     6

#ifndef ORDER_H

     7

#define ORDER_H

     8

     9

#include "macros.h"

    10

#include "pool.h"

    11

    12

/* Order types */

    13

typedef enum OrderTypes {

    14

	OT_NOTHING       = 0,

    15

	OT_GOTO_STATION  = 1,

    16

	OT_GOTO_DEPOT    = 2,

    17

	OT_LOADING       = 3,

    18

	OT_LEAVESTATION  = 4,

    19

	OT_DUMMY         = 5,

    20

	OT_GOTO_WAYPOINT = 6

    21

} OrderType;

    22

    23

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

    24

    25

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

    26

enum OrderFlagMasks {

    27

	//Flags for stations:

    28

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

    29

	OF_TRANSFER           = 0x1,

    30

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

    31

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

    32

	OF_UNLOAD             = 0x2,

    33

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

    34

	  * @todo make this two different flags */

    35

	OF_FULL_LOAD          = 0x4,

    36

    37

	//Flags for depots:

    38

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

    39

	OF_PART_OF_ORDERS     = 0x2,

    40

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

    41

	OF_HALT_IN_DEPOT      = 0x4,

    42

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

    43

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

    44

    45

	//Common flags

    46

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

    47

	  * @todo make this two different flags */

    48

	OF_NON_STOP           = 0x8

    49

};

    50

    51

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

    52

 * for descrption of flags, see OrderFlagMasks

    53

 * @see OrderFlagMasks

    54

 */

    55

enum {

    56

	OFB_TRANSFER          = 0,

    57

	OFB_UNLOAD            = 1,

    58

	OFB_FULL_LOAD         = 2,

    59

	OFB_PART_OF_ORDERS    = 1,

    60

	OFB_HALT_IN_DEPOT     = 2,

    61

	OFB_SERVICE_IF_NEEDED = 2,

    62

	OFB_NON_STOP          = 3

    63

};

    64

    65

    66

/* Possible clone options */

    67

enum {

    68

	CO_SHARE   = 0,

    69

	CO_COPY    = 1,

    70

	CO_UNSHARE = 2

    71

};

    72

    73

    74

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

    75

 * - Load_ORDR, all the global orders

    76

 * - Vehicle -> current_order

    77

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

    78

 */

    79

typedef struct Order {

    80

	OrderType type;

    81

	uint8  flags;

    82

	StationID station;

    83

    84

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

    85

    86

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

    87

} Order;

    88

    89

#define MAX_BACKUP_ORDER_COUNT 40

    90

    91

typedef struct {

    92

	VehicleID clone;

    93

	OrderID orderindex;

    94

	Order order[MAX_BACKUP_ORDER_COUNT + 1];

    95

	uint16 service_interval;

    96

	char name[32];

    97

} BackuppedOrders;

    98

    99

VARDEF TileIndex _backup_orders_tile;

   100

VARDEF BackuppedOrders _backup_orders_data[1];

   101

   102

extern MemoryPool _order_pool;

   103

   104

/**

   105

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

   106

 */

   107

static inline Order *GetOrder(uint index)

   108

{

   109

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

   110

}

   111

   112

/**

   113

 * Get the current size of the OrderPool

   114

 */

   115

static inline uint16 GetOrderPoolSize(void)

   116

{

   117

	return _order_pool.total_items;

   118

}

   119

   130

/**

   131

 * Check if a Order really exists.

   132

 */

   133

static inline bool IsValidOrder(const Order *o)

   134

{

   135

	return o->type != OT_NOTHING;

   136

}

   137

   138

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

   139

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

   140

   141

   142

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

   143

   144

static inline bool HasOrderPoolFree(uint amount)

   145

{

   146

	const Order *order;

   147

   148

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

   149

	if (_order_pool.current_blocks < _order_pool.max_blocks)

   150

		return true;

   151

   152

	FOR_ALL_ORDERS(order)

   153

		if (order->type == OT_NOTHING)

   154

			if (--amount == 0)

   155

				return true;

   156

   157

	return false;

   158

}

   159

   160

static inline bool IsOrderPoolFull(void)

   161

{

   162

	return !HasOrderPoolFree(1);

   163

}

   164

   165

/* Pack and unpack routines */

   166

   167

static inline uint32 PackOrder(const Order *order)

   168

{

   169

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

   170

}

   171

   172

static inline Order UnpackOrder(uint32 packed)

   173

{

   174

	Order order;

   175

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

   176

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

   177

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

   178

	order.next    = NULL;

   179

	order.index   = 0; // avoid compiler warning

   180

	return order;

   181

}

   182

   183

/* Functions */

   184

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

   185

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

   186

void RemoveOrderFromAllVehicles(OrderType type, StationID destination);

   187

void InvalidateVehicleOrder(const Vehicle *v);

   188

bool VehicleHasDepotOrders(const Vehicle *v);

   189

void CheckOrders(const Vehicle*);

   190

void DeleteVehicleOrders(Vehicle *v);

   191

bool IsOrderListShared(const Vehicle *v);

   192

void AssignOrder(Order *order, Order data);

   193

bool CheckForValidOrders(const Vehicle* v);

   194

   195

Order UnpackOldOrder(uint16 packed);

   196

   197

#endif /* ORDER_H */