1

#ifndef ORDER_H

     2

#define ORDER_H

     3

     4

/* Order types */

     5

enum {

     6

	OT_NOTHING       = 0,

     7

	OT_GOTO_STATION  = 1,

     8

	OT_GOTO_DEPOT    = 2,

     9

	OT_LOADING       = 3,

    10

	OT_LEAVESTATION  = 4,

    11

	OT_DUMMY         = 5,

    12

	OT_GOTO_WAYPOINT = 6

    13

};

    14

    15

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

    16

enum {

    17

	OF_UNLOAD    = 0x2,

    18

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

    19

	OF_NON_STOP  = 0x8

    20

};

    21

    22

/* Order flags bits */

    23

enum {

    24

	OFB_UNLOAD    = 1,

    25

	OFB_FULL_LOAD = 2,

    26

	OFB_NON_STOP  = 3

    27

};

    28

    29

/* Possible clone options */

    30

enum {

    31

	CO_SHARE   = 0,

    32

	CO_COPY    = 1,

    33

	CO_UNSHARE = 2

    34

};

    35

    36

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

    37

    - Load_ORDR, all the global orders

    38

    - Vehicle -> current_order

    39

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

    40

typedef struct Order {

    41

	uint8  type;

    42

	uint8  flags;

    43

	uint16 station;

    44

    45

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

    46

    47

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

    48

} Order;

    49

    50

typedef struct {

    51

	VehicleID clone;

    52

	byte orderindex;

    53

	Order order[41];

    54

	uint16 service_interval;

    55

	char name[32];

    56

} BackuppedOrders;

    57

    58

VARDEF TileIndex _backup_orders_tile;

    59

VARDEF BackuppedOrders _backup_orders_data[1];

    60

    61

VARDEF Order _orders[5000];

    62

VARDEF uint32 _orders_size;

    63

    64

static inline Order *GetOrder(uint index)

    65

{

    66

	assert(index < _orders_size);

    67

	return &_orders[index];

    68

}

    69

    70

#define FOR_ALL_ORDERS_FROM(o, from) for(o = GetOrder(from); o != &_orders[_orders_size]; o++)

    71

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

    72

    73

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

    74

    75

static inline bool HasOrderPoolFree(uint amount)

    76

{

    77

	const Order *order;

    78

    79

	FOR_ALL_ORDERS(order)

    80

		if (order->type == OT_NOTHING)

    81

			if (--amount == 0)

    82

				return true;

    83

    84

	return false;

    85

}

    86

    87

static inline bool IsOrderPoolFull()

    88

{

    89

	return !HasOrderPoolFree(1);

    90

}

    91

    92

/* Pack and unpack routines */

    93

    94

static inline uint32 PackOrder(const Order *order)

    95

{

    96

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

    97

}

    98

    99

static inline Order UnpackOrder(uint32 packed)

   100

{

   101

	Order order;

   102

	order.type    = (packed & 0x000000FF);

   103

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

   104

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

   105

	order.next    = NULL;

   106

	return order;

   107

}

   108

   109

/* Functions */

   110

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

   111

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

   112

void DeleteDestinationFromVehicleOrder(Order dest);

   113

void InvalidateVehicleOrder(const Vehicle *v);

   114

bool VehicleHasDepotOrders(const Vehicle *v);

   115

bool CheckOrders(const Vehicle *v);

   116

void DeleteVehicleOrders(Vehicle *v);

   117

bool IsOrderListShared(const Vehicle *v);

   118

void AssignOrder(Order *order, Order data);

   119

bool CheckForValidOrders(Vehicle *v);

   120

   121

Order UnpackVersion4Order(uint16 packed);

   122

Order UnpackOldOrder(uint16 packed);

   123

   124

#endif /* ORDER_H */