1

/* $Id$ */

     2

     3

/** @file order.h

     4

  */

     5

     6

#ifndef ORDER_H

     7

#define ORDER_H

     8

     9

#include "macros.h"

    10

#include "pool.h"

    11

    12

/* Order types */

    13

enum {

    14

	OT_NOTHING       = 0,

    15

	OT_GOTO_STATION  = 1,

    16

	OT_GOTO_DEPOT    = 2,

    17

	OT_LOADING       = 3,

    18

	OT_LEAVESTATION  = 4,

    19

	OT_DUMMY         = 5,

    20

	OT_GOTO_WAYPOINT = 6

    21

};

    22

    23

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

    24

    25

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

    26

enum OrderFlagMasks {

    27

	//Flags for stations:

    28

	/** vehicle will transfer cargo (i. e. not deliver to nearby industry/town even if accepted there) */

    29

	OF_TRANSFER           = 0x1,

    30

	/** If OF_TRANSFER is not set, drop any cargo loaded. If accepted, deliver, otherwise cargo remains at the station.

    31

      * No new cargo is loaded onto the vehicle whatsoever */

    32

	OF_UNLOAD             = 0x2,

    33

	/** Wait for full load of all vehicles, or of at least one cargo type, depending on patch setting

    34

	  * @todo make this two different flags */

    35

	OF_FULL_LOAD          = 0x4,

    36

    37

	//Flags for depots:

    38

	/** The current depot-order was initiated because it was in the vehicle's order list */

    39

	OF_PART_OF_ORDERS	  = 0x2,

    40

	/** if OF_PART_OF_ORDERS is not set, this will cause the vehicle to be stopped in the depot */

    41

	OF_HALT_IN_DEPOT      = 0x4,

    42

	/** if OF_PART_OF_ORDERS is set, this will cause the order only be come active if the vehicle needs servicing */

    43

	OF_SERVICE_IF_NEEDED  = 0x4, //used when OF_PART_OF_ORDERS is set.

    44

    45

	//Common flags

    46

	/** This causes the vehicle not to stop at intermediate OR the destination station (depending on patch settings)

    47

	  * @todo make this two different flags */

    48

	OF_NON_STOP           = 0x8

    49

};

    50

    51

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

    52

  * for descrption of flags, see OrderFlagMasks

    53

  * @see OrderFlagMasks

    54

  */

    55

enum {

    56

	OFB_TRANSFER          = 0,

    57

	OFB_UNLOAD            = 1,

    58

	OFB_FULL_LOAD         = 2,

    59

	OFB_PART_OF_ORDERS    = 1,

    60

	OFB_HALT_IN_DEPOT     = 2,

    61

	OFB_SERVICE_IF_NEEDED = 2,

    62

	OFB_NON_STOP          = 3

    63

};

    64

    65

    66

/* Possible clone options */

    67

enum {

    68

	CO_SHARE   = 0,

    69

	CO_COPY    = 1,

    70

	CO_UNSHARE = 2

    71

};

    72

    73

/* Modes for the order checker */

    74

enum {

    75

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

    76

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

    77

};

    78

    79

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

    80

    - Load_ORDR, all the global orders

    81

    - Vehicle -> current_order

    82

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

    83

typedef struct Order {

    84

	uint8  type;

    85

	uint8  flags;

    86

	uint16 station;

    87

    88

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

    89

    90

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

    91

} Order;

    92

    93

#define MAX_BACKUP_ORDER_COUNT 40

    94

    95

typedef struct {

    96

	VehicleID clone;

    97

	OrderID orderindex;

    98

	Order order[MAX_BACKUP_ORDER_COUNT + 1];

    99

	uint16 service_interval;

   100

	char name[32];

   101

} BackuppedOrders;

   102

   103

VARDEF TileIndex _backup_orders_tile;

   104

VARDEF BackuppedOrders _backup_orders_data[1];

   105

   106

extern MemoryPool _order_pool;

   107

   108

/**

   109

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

   110

 */

   111

static inline Order *GetOrder(uint index)

   112

{

   113

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

   114

}

   115

   116

/**

   117

 * Get the current size of the OrderPool

   118

 */

   119

static inline uint16 GetOrderPoolSize(void)

   120

{

   121

	return _order_pool.total_items;

   122

}

   123

   124

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

   125

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

   126

   127

   128

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

   129

   130

static inline bool HasOrderPoolFree(uint amount)

   131

{

   132

	const Order *order;

   133

   134

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

   135

	if (_order_pool.current_blocks < _order_pool.max_blocks)

   136

		return true;

   137

   138

	FOR_ALL_ORDERS(order)

   139

		if (order->type == OT_NOTHING)

   140

			if (--amount == 0)

   141

				return true;

   142

   143

	return false;

   144

}

   145

   146

static inline bool IsOrderPoolFull(void)

   147

{

   148

	return !HasOrderPoolFree(1);

   149

}

   150

   151

/* Pack and unpack routines */

   152

   153

static inline uint32 PackOrder(const Order *order)

   154

{

   155

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

   156

}

   157

   158

static inline Order UnpackOrder(uint32 packed)

   159

{

   160

	Order order;

   161

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

   162

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

   163

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

   164

	order.next    = NULL;

   165

	order.index   = 0; // avoid compiler warning

   166

	return order;

   167

}

   168

   169

/* Functions */

   170

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

   171

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

   172

void DeleteDestinationFromVehicleOrder(Order dest);

   173

void InvalidateVehicleOrder(const Vehicle *v);

   174

bool VehicleHasDepotOrders(const Vehicle *v);

   175

bool CheckOrders(uint data_a, uint data_b);

   176

void DeleteVehicleOrders(Vehicle *v);

   177

bool IsOrderListShared(const Vehicle *v);

   178

void AssignOrder(Order *order, Order data);

   179

bool CheckForValidOrders(const Vehicle* v);

   180

   181

Order UnpackOldOrder(uint16 packed);

   182

   183

#endif /* ORDER_H */