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

typedef struct {

    94

	VehicleID clone;

    95

	OrderID orderindex;

    96

	Order order[41];

    97

	uint16 service_interval;

    98

	char name[32];

    99

} BackuppedOrders;

   100

   101

VARDEF TileIndex _backup_orders_tile;

   102

VARDEF BackuppedOrders _backup_orders_data[1];

   103

   104

extern MemoryPool _order_pool;

   105

   106

/**

   107

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

   108

 */

   109

static inline Order *GetOrder(uint index)

   110

{

   111

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

   112

}

   113

   114

/**

   115

 * Get the current size of the OrderPool

   116

 */

   117

static inline uint16 GetOrderPoolSize(void)

   118

{

   119

	return _order_pool.total_items;

   120

}

   121

   122

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

   123

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

   124

   125

   126

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

   127

   128

static inline bool HasOrderPoolFree(uint amount)

   129

{

   130

	const Order *order;

   131

   132

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

   133

	if (_order_pool.current_blocks < _order_pool.max_blocks)

   134

		return true;

   135

   136

	FOR_ALL_ORDERS(order)

   137

		if (order->type == OT_NOTHING)

   138

			if (--amount == 0)

   139

				return true;

   140

   141

	return false;

   142

}

   143

   144

static inline bool IsOrderPoolFull(void)

   145

{

   146

	return !HasOrderPoolFree(1);

   147

}

   148

   149

/* Pack and unpack routines */

   150

   151

static inline uint32 PackOrder(const Order *order)

   152

{

   153

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

   154

}

   155

   156

static inline Order UnpackOrder(uint32 packed)

   157

{

   158

	Order order;

   159

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

   160

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

   161

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

   162

	order.next    = NULL;

   163

	order.index   = 0; // avoid compiler warning

   164

	return order;

   165

}

   166

   167

/* Functions */

   168

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

   169

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

   170

void DeleteDestinationFromVehicleOrder(Order dest);

   171

void InvalidateVehicleOrder(const Vehicle *v);

   172

bool VehicleHasDepotOrders(const Vehicle *v);

   173

bool CheckOrders(uint data_a, uint data_b);

   174

void DeleteVehicleOrders(Vehicle *v);

   175

bool IsOrderListShared(const Vehicle *v);

   176

void AssignOrder(Order *order, Order data);

   177

bool CheckForValidOrders(Vehicle *v);

   178

   179

Order UnpackVersion4Order(uint16 packed);

   180

Order UnpackOldOrder(uint16 packed);

   181

   182

#endif /* ORDER_H */