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

enum {

    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

};

    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

typedef struct Order {

    79

	uint8  type;

    80

	uint8  flags;

    81

	StationID station;

    82

    83

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

    84

    85

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

    86

} Order;

    87

    88

#define MAX_BACKUP_ORDER_COUNT 40

    89

    90

typedef struct {

    91

	VehicleID clone;

    92

	OrderID orderindex;

    93

	Order order[MAX_BACKUP_ORDER_COUNT + 1];

    94

	uint16 service_interval;

    95

	char name[32];

    96

} BackuppedOrders;

    97

    98

VARDEF TileIndex _backup_orders_tile;

    99

VARDEF BackuppedOrders _backup_orders_data[1];

   100

   101

extern MemoryPool _order_pool;

   102

   103

/**

   104

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

   105

 */

   106

static inline Order *GetOrder(uint index)

   107

{

   108

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

   109

}

   110

   111

/**

   112

 * Get the current size of the OrderPool

   113

 */

   114

static inline uint16 GetOrderPoolSize(void)

   115

{

   116

	return _order_pool.total_items;

   117

}

   118

   119

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

   120

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

   121

   122

   123

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

   124

   125

static inline bool HasOrderPoolFree(uint amount)

   126

{

   127

	const Order *order;

   128

   129

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

   130

	if (_order_pool.current_blocks < _order_pool.max_blocks)

   131

		return true;

   132

   133

	FOR_ALL_ORDERS(order)

   134

		if (order->type == OT_NOTHING)

   135

			if (--amount == 0)

   136

				return true;

   137

   138

	return false;

   139

}

   140

   141

static inline bool IsOrderPoolFull(void)

   142

{

   143

	return !HasOrderPoolFree(1);

   144

}

   145

   146

/* Pack and unpack routines */

   147

   148

static inline uint32 PackOrder(const Order *order)

   149

{

   150

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

   151

}

   152

   153

static inline Order UnpackOrder(uint32 packed)

   154

{

   155

	Order order;

   156

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

   157

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

   158

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

   159

	order.next    = NULL;

   160

	order.index   = 0; // avoid compiler warning

   161

	return order;

   162

}

   163

   164

/* Functions */

   165

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

   166

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

   167

void DeleteDestinationFromVehicleOrder(Order dest);

   168

void InvalidateVehicleOrder(const Vehicle *v);

   169

bool VehicleHasDepotOrders(const Vehicle *v);

   170

void CheckOrders(const Vehicle*);

   171

void DeleteVehicleOrders(Vehicle *v);

   172

bool IsOrderListShared(const Vehicle *v);

   173

void AssignOrder(Order *order, Order data);

   174

bool CheckForValidOrders(const Vehicle* v);

   175

   176

Order UnpackOldOrder(uint16 packed);

   177

   178

#endif /* ORDER_H */