1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
#ifndef ORDER_H
#define ORDER_H
/* Order types */
enum {
OT_NOTHING = 0,
OT_GOTO_STATION = 1,
OT_GOTO_DEPOT = 2,
OT_LOADING = 3,
OT_LEAVESTATION = 4,
OT_DUMMY = 5,
OT_GOTO_WAYPOINT = 6
};
/* Order flags -- please use OFB instead OF and use HASBIT/SETBIT/CLEARBIT */
enum {
OF_UNLOAD = 0x2,
OF_FULL_LOAD = 0x4, // Also used when to force an aircraft into a depot
OF_NON_STOP = 0x8
};
/* Order flags bits */
enum {
OFB_UNLOAD = 1,
OFB_FULL_LOAD = 2,
OFB_NON_STOP = 3
};
/* Possible clone options */
enum {
CO_SHARE = 0,
CO_COPY = 1,
CO_UNSHARE = 2
};
/* If you change this, keep in mind that it is saved on 3 places:
- Load_ORDR, all the global orders
- Vehicle -> current_order
- REF_SHEDULE (all REFs are currently limited to 16 bits!!) */
typedef struct Order {
uint8 type;
uint8 flags;
uint16 station;
struct Order *next; //! Pointer to next order. If NULL, end of list
uint16 index; //! Index of the order, is not saved or anything, just for reference
} Order;
typedef struct {
VehicleID clone;
byte orderindex;
Order order[41];
uint16 service_interval;
char name[32];
} BackuppedOrders;
VARDEF TileIndex _backup_orders_tile;
VARDEF BackuppedOrders _backup_orders_data[1];
VARDEF Order _orders[5000];
VARDEF uint32 _orders_size;
static inline Order *GetOrder(uint index)
{
assert(index < _orders_size);
return &_orders[index];
}
#define FOR_ALL_ORDERS_FROM(o, from) for(o = GetOrder(from); o != &_orders[_orders_size]; o++)
#define FOR_ALL_ORDERS(o) FOR_ALL_ORDERS_FROM(o, 0)
#define FOR_VEHICLE_ORDERS(v, order) for (order = v->orders; order != NULL; order = order->next)
static inline bool HasOrderPoolFree(uint amount)
{
Order *order;
FOR_ALL_ORDERS(order)
if (order->type == OT_NOTHING)
if (--amount == 0)
return true;
return false;
}
static inline bool IsOrderPoolFull()
{
return !HasOrderPoolFree(1);
}
/* Pack and unpack routines */
static inline uint32 PackOrder(const Order *order)
{
return order->station << 16 | order->flags << 8 | order->type;
}
static inline Order UnpackOrder(uint32 packed)
{
Order order;
order.type = (packed & 0x000000FF);
order.flags = (packed & 0x0000FF00) >> 8;
order.station = (packed & 0xFFFF0000) >> 16;
order.next = NULL;
return order;
}
/* Functions */
void BackupVehicleOrders(Vehicle *v, BackuppedOrders *order);
void RestoreVehicleOrders(Vehicle *v, BackuppedOrders *order);
void DeleteDestinationFromVehicleOrder(Order dest);
void InvalidateVehicleOrder(const Vehicle *v);
bool VehicleHasDepotOrders(const Vehicle *v);
bool CheckOrders(const Vehicle *v);
void DeleteVehicleOrders(Vehicle *v);
bool IsOrderListShared(const Vehicle *v);
void AssignOrder(Order *order, Order data);
bool CheckForValidOrders(Vehicle *v);
Order UnpackVersion4Order(uint16 packed);
Order UnpackOldOrder(uint16 packed);
#endif /* ORDER_H */
|
