1

/* $Id$ */

     2

     3

#ifndef ORDER_H

     4

#define ORDER_H

     5

     6

#include "macros.h"

     7

#include "pool.h"

     8

     9

/* Order types */

    10

enum {

    11

	OT_NOTHING       = 0,

    12

	OT_GOTO_STATION  = 1,

    13

	OT_GOTO_DEPOT    = 2,

    14

	OT_LOADING       = 3,

    15

	OT_LEAVESTATION  = 4,

    16

	OT_DUMMY         = 5,

    17

	OT_GOTO_WAYPOINT = 6

    18

};

    19

    20

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

    21

    22

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

    23

enum {

    24

	//Flags for stations:

    25

	OF_TRANSFER       = 0x1,

    26

	OF_UNLOAD         = 0x2,

    27

	OF_FULL_LOAD      = 0x4, // Also used when to force an aircraft into a depot

    28

    29

	//Flags for depots:

    30

	OF_PART_OF_ORDERS	= 0x2,

    31

	OF_HALT_IN_DEPOT  = 0x4,

    32

    33

	//Common flags

    34

	OF_NON_STOP  = 0x8

    35

};

    36

    37

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

    38

enum {

    39

	OFB_TRANSFER       = 0,

    40

	OFB_UNLOAD         = 1,

    41

	OFB_FULL_LOAD      = 2,

    42

	OFB_PART_OF_ORDERS = 1,

    43

	OFB_HALT_IN_DEPOT  = 2,

    44

	OFB_NON_STOP       = 3

    45

};

    46

    47

    48

/* Possible clone options */

    49

enum {

    50

	CO_SHARE   = 0,

    51

	CO_COPY    = 1,

    52

	CO_UNSHARE = 2

    53

};

    54

    55

/* Modes for the order checker */

    56

enum {

    57

	OC_INIT     = 0, //the order checker can initialize a news message

    58

	OC_VALIDATE = 1, //the order checker validates a news message

    59

};

    60

    61

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

    62

    - Load_ORDR, all the global orders

    63

    - Vehicle -> current_order

    64

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

    65

typedef struct Order {

    66

	uint8  type;

    67

	uint8  flags;

    68

	uint16 station;

    69

    70

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

    71

    72

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

    73

} Order;

    74

    75

typedef struct {

    76

	VehicleID clone;

    77

	OrderID orderindex;

    78

	Order order[41];

    79

	uint16 service_interval;

    80

	char name[32];

    81

} BackuppedOrders;

    82

    83

VARDEF TileIndex _backup_orders_tile;

    84

VARDEF BackuppedOrders _backup_orders_data[1];

    85

    86

extern MemoryPool _order_pool;

    87

    88

/**

    89

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

    90

 */

    91

static inline Order *GetOrder(uint index)

    92

{

    93

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

    94

}

    95

    96

/**

    97

 * Get the current size of the OrderPool

    98

 */

    99

static inline uint16 GetOrderPoolSize(void)

   100

{

   101

	return _order_pool.total_items;

   102

}

   103

   104

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

   105

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

   106

   107

   108

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

   109

   110

static inline bool HasOrderPoolFree(uint amount)

   111

{

   112

	const Order *order;

   113

   114

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

   115

	if (_order_pool.current_blocks < _order_pool.max_blocks)

   116

		return true;

   117

   118

	FOR_ALL_ORDERS(order)

   119

		if (order->type == OT_NOTHING)

   120

			if (--amount == 0)

   121

				return true;

   122

   123

	return false;

   124

}

   125

   126

static inline bool IsOrderPoolFull(void)

   127

{

   128

	return !HasOrderPoolFree(1);

   129

}

   130

   131

/* Pack and unpack routines */

   132

   133

static inline uint32 PackOrder(const Order *order)

   134

{

   135

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

   136

}

   137

   138

static inline Order UnpackOrder(uint32 packed)

   139

{

   140

	Order order;

   141

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

   142

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

   143

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

   144

	order.next    = NULL;

   145

	order.index   = 0; // avoid compiler warning

   146

	return order;

   147

}

   148

   149

/* Functions */

   150

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

   151

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

   152

void DeleteDestinationFromVehicleOrder(Order dest);

   153

void InvalidateVehicleOrder(const Vehicle *v);

   154

bool VehicleHasDepotOrders(const Vehicle *v);

   155

bool CheckOrders(uint data_a, uint data_b);

   156

void DeleteVehicleOrders(Vehicle *v);

   157

bool IsOrderListShared(const Vehicle *v);

   158

void AssignOrder(Order *order, Order data);

   159

bool CheckForValidOrders(Vehicle *v);

   160

   161

Order UnpackVersion4Order(uint16 packed);

   162

Order UnpackOldOrder(uint16 packed);

   163

   164

#endif /* ORDER_H */