1

/* $Id$ */

     2

     3

/** @file order.h */

     4

     5

#ifndef ORDER_H

     6

#define ORDER_H

     7

     9

#include "oldpool.h"

    10

#include "core/bitmath_func.hpp"

    11

#include "cargo_type.h"

    12

#include "vehicle_type.h"

    13

#include "tile_type.h"

    14

#include "date_type.h"

    15

#include "group_type.h"

    16

    17

DECLARE_OLD_POOL(Order, Order, 6, 1000)

    18

    19

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

    20

 * - Load_ORDR, all the global orders

    21

 * - Vehicle -> current_order

    22

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

    23

 */

    24

struct Order : PoolItem<Order, OrderID, &_Order_pool> {

    25

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

    26

    27

	OrderTypeByte type;

    28

	uint8  flags;

    29

	DestinationID dest;   ///< The destionation of the order.

    30

    31

	CargoID refit_cargo; // Refit CargoID

    32

	byte refit_subtype; // Refit subtype

    33

    34

	uint16 wait_time;    ///< How long in ticks to wait at the destination.

    35

	uint16 travel_time;  ///< How long in ticks the journey to this destination should take.

    36

    37

	Order() : refit_cargo(CT_NO_REFIT) {}

    38

	~Order() { this->type = OT_NOTHING; }

    39

    40

	/**

    41

	 * Check if a Order really exists.

    42

	 */

    43

	inline bool IsValid() const { return this->type != OT_NOTHING; }

    44

    45

	void Free();

    46

	void FreeChain();

    47

};

    48

    49

struct BackuppedOrders {

    50

	BackuppedOrders() : order(NULL), name(NULL) { }

    51

	~BackuppedOrders() { free(order); free(name); }

    52

    53

	VehicleID clone;

    54

	VehicleOrderID orderindex;

    55

	GroupID group;

    56

	Order *order;

    57

	uint16 service_interval;

    58

	char *name;

    59

};

    60

    61

extern TileIndex _backup_orders_tile;

    62

extern BackuppedOrders _backup_orders_data;

    63

    64

static inline VehicleOrderID GetMaxOrderIndex()

    65

{

    66

	/* TODO - This isn't the real content of the function, but

    67

	 *  with the new pool-system this will be replaced with one that

    68

	 *  _really_ returns the highest index. Now it just returns

    69

	 *  the next safe value we are sure about everything is below.

    70

	 */

    71

	return GetOrderPoolSize() - 1;

    72

}

    73

    74

static inline VehicleOrderID GetNumOrders()

    75

{

    76

	return GetOrderPoolSize();

    77

}

    78

    79

inline void Order::Free()

    80

{

    81

	this->type  = OT_NOTHING;

    82

	this->flags = 0;

    83

	this->dest  = 0;

    84

	this->next  = NULL;

    85

}

    86

    87

inline void Order::FreeChain()

    88

{

    89

	if (next != NULL) next->FreeChain();

    90

	delete this;

    91

}

    92

    93

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

    94

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

    95

    96

    97

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

    98

    99

static inline bool HasOrderPoolFree(uint amount)

   100

{

   101

	const Order *order;

   102

   103

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

   104

	if (_Order_pool.CanAllocateMoreBlocks()) return true;

   105

   106

	FOR_ALL_ORDERS(order) if (!order->IsValid() && --amount == 0) return true;

   107

   108

	return false;

   109

}

   110

   111

   112

/* Pack and unpack routines */

   113

   114

static inline uint32 PackOrder(const Order *order)

   115

{

   116

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

   117

}

   118

   119

static inline Order UnpackOrder(uint32 packed)

   120

{

   121

	Order order;

   122

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

   123

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

   124

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

   125

	order.next    = NULL;

   126

	order.index   = 0; // avoid compiler warning

   127

	order.refit_cargo   = CT_NO_REFIT;

   128

	order.refit_subtype = 0;

   129

	order.wait_time     = 0;

   130

	order.travel_time   = 0;

   131

	return order;

   132

}

   133

   134

/* Functions */

   135

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

   136

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

   137

void RemoveOrderFromAllVehicles(OrderType type, DestinationID destination);

   138

void InvalidateVehicleOrder(const Vehicle *v);

   139

bool VehicleHasDepotOrders(const Vehicle *v);

   140

void CheckOrders(const Vehicle*);

   141

void DeleteVehicleOrders(Vehicle *v);

   142

void AssignOrder(Order *order, Order data);

   143

bool CheckForValidOrders(const Vehicle* v);

   144

   145

Order UnpackOldOrder(uint16 packed);

   146

   147

#define MIN_SERVINT_PERCENT  5

   148

#define MAX_SERVINT_PERCENT 90

   149

#define MIN_SERVINT_DAYS    30

   150

#define MAX_SERVINT_DAYS   800

   151

   152

/**

   153

 * Get the service interval domain.

   154

 * Get the new proposed service interval for the vehicle is indeed, clamped

   155

 * within the given bounds. @see MIN_SERVINT_PERCENT ,etc.

   156

 * @param index proposed service interval

   157

 * @return service interval

   158

 */

   159

Date GetServiceIntervalClamped(uint index);

   160

   161

#endif /* ORDER_H */