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

/* Modes for the order checker */

    37

enum {

    38

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

    39

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

    40

};

    41

    42

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

    43

    - Load_ORDR, all the global orders

    44

    - Vehicle -> current_order

    45

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

    46

typedef struct Order {

    47

	uint8  type;

    48

	uint8  flags;

    49

	uint16 station;

    50

    51

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

    52

    53

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

    54

} Order;

    55

    56

typedef struct {

    57

	VehicleID clone;

    58

	byte orderindex;

    59

	Order order[41];

    60

	uint16 service_interval;

    61

	char name[32];

    62

} BackuppedOrders;

    63

    64

VARDEF TileIndex _backup_orders_tile;

    65

VARDEF BackuppedOrders _backup_orders_data[1];

    66

    67

VARDEF Order _orders[5000];

    68

VARDEF uint32 _orders_size;

    69

    70

static inline Order *GetOrder(uint index)

    71

{

    72

	assert(index < _orders_size);

    73

	return &_orders[index];

    74

}

    75

    76

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

    77

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

    78

    79

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

    80

    81

static inline bool HasOrderPoolFree(uint amount)

    82

{

    83

	const Order *order;

    84

    85

	FOR_ALL_ORDERS(order)

    86

		if (order->type == OT_NOTHING)

    87

			if (--amount == 0)

    88

				return true;

    89

    90

	return false;

    91

}

    92

    94

{

    95

	return !HasOrderPoolFree(1);

    96

}

    97

    98

/* Pack and unpack routines */

    99

   100

static inline uint32 PackOrder(const Order *order)

   101

{

   102

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

   103

}

   104

   105

static inline Order UnpackOrder(uint32 packed)

   106

{

   107

	Order order;

   108

	order.type    = (packed & 0x000000FF);

   109

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

   110

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

   111

	order.next    = NULL;

   112

	return order;

   113

}

   114

   115

/* Functions */

   116

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

   117

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

   118

void DeleteDestinationFromVehicleOrder(Order dest);

   119

void InvalidateVehicleOrder(const Vehicle *v);

   120

bool VehicleHasDepotOrders(const Vehicle *v);

   121

bool CheckOrders(uint data_a, uint data_b);

   122

void DeleteVehicleOrders(Vehicle *v);

   123

bool IsOrderListShared(const Vehicle *v);

   124

void AssignOrder(Order *order, Order data);

   125

bool CheckForValidOrders(Vehicle *v);

   126

   127

Order UnpackVersion4Order(uint16 packed);

   128

Order UnpackOldOrder(uint16 packed);

   129

   130

#endif /* ORDER_H */