1

#ifndef ORDER_H

     2

#define ORDER_H

     3

     4

#include "pool.h"

     5

     6

/* Order types */

     7

enum {

     8

	OT_NOTHING       = 0,

     9

	OT_GOTO_STATION  = 1,

    10

	OT_GOTO_DEPOT    = 2,

    11

	OT_LOADING       = 3,

    12

	OT_LEAVESTATION  = 4,

    13

	OT_DUMMY         = 5,

    14

	OT_GOTO_WAYPOINT = 6

    15

};

    16

    17

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

    18

enum {

    19

	OF_UNLOAD    = 0x2,

    20

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

    21

	OF_NON_STOP  = 0x8

    22

};

    23

    24

/* Order flags bits */

    25

enum {

    26

	OFB_UNLOAD    = 1,

    27

	OFB_FULL_LOAD = 2,

    28

	OFB_NON_STOP  = 3

    29

};

    30

    31

/* Possible clone options */

    32

enum {

    33

	CO_SHARE   = 0,

    34

	CO_COPY    = 1,

    35

	CO_UNSHARE = 2

    36

};

    37

    38

/* Modes for the order checker */

    39

enum {

    40

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

    41

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

    42

};

    43

    44

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

    45

    - Load_ORDR, all the global orders

    46

    - Vehicle -> current_order

    47

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

    48

typedef struct Order {

    49

	uint8  type;

    50

	uint8  flags;

    51

	uint16 station;

    52

    53

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

    54

    55

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

    56

} Order;

    57

    58

typedef struct {

    59

	VehicleID clone;

    60

	byte orderindex;

    61

	Order order[41];

    62

	uint16 service_interval;

    63

	char name[32];

    64

} BackuppedOrders;

    65

    66

VARDEF TileIndex _backup_orders_tile;

    67

VARDEF BackuppedOrders _backup_orders_data[1];

    68

    69

extern MemoryPool _order_pool;

    70

    71

/**

    72

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

    73

 */

    74

static inline Order *GetOrder(uint index)

    75

{

    76

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

    77

}

    78

    79

/**

    80

 * Get the current size of the OrderPool

    81

 */

    82

static inline uint16 GetOrderPoolSize(void)

    83

{

    84

	return _order_pool.total_items;

    85

}

    86

    87

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

    88

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

    89

    90

    91

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

    92

    93

static inline bool HasOrderPoolFree(uint amount)

    94

{

    95

	const Order *order;

    96

    97

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

    98

	if (_order_pool.current_blocks < _order_pool.max_blocks)

    99

		return true;

   100

   101

	FOR_ALL_ORDERS(order)

   102

		if (order->type == OT_NOTHING)

   103

			if (--amount == 0)

   104

				return true;

   105

   106

	return false;

   107

}

   108

   109

static inline bool IsOrderPoolFull(void)

   110

{

   111

	return !HasOrderPoolFree(1);

   112

}

   113

   114

/* Pack and unpack routines */

   115

   116

static inline uint32 PackOrder(const Order *order)

   117

{

   118

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

   119

}

   120

   121

static inline Order UnpackOrder(uint32 packed)

   122

{

   123

	Order order;

   124

	order.type    = (packed & 0x000000FF);

   125

	order.flags   = (packed & 0x0000FF00) >> 8;

   126

	order.station = (packed & 0xFFFF0000) >> 16;

   127

	order.next    = NULL;

   128

	return order;

   129

}

   130

   131

/* Functions */

   132

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

   133

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

   134

void DeleteDestinationFromVehicleOrder(Order dest);

   135

void InvalidateVehicleOrder(const Vehicle *v);

   136

bool VehicleHasDepotOrders(const Vehicle *v);

   137

bool CheckOrders(uint data_a, uint data_b);

   138

void DeleteVehicleOrders(Vehicle *v);

   139

bool IsOrderListShared(const Vehicle *v);

   140

void AssignOrder(Order *order, Order data);

   141

bool CheckForValidOrders(Vehicle *v);

   142

   143

Order UnpackVersion4Order(uint16 packed);

   144

Order UnpackOldOrder(uint16 packed);

   145

   146

#endif /* ORDER_H */