2005-07-24 16:12:37 +02:00
|
|
|
/* $Id$ */
|
|
|
|
|
2008-03-31 01:24:18 +02:00
|
|
|
/** @file order_base.h */
|
2005-07-28 08:09:15 +02:00
|
|
|
|
2008-03-31 01:24:18 +02:00
|
|
|
#ifndef ORDER_BASE_H
|
|
|
|
#define ORDER_BASE_H
|
2005-01-15 20:06:22 +01:00
|
|
|
|
2008-03-28 17:36:32 +01:00
|
|
|
#include "order_type.h"
|
2006-12-03 18:27:43 +01:00
|
|
|
#include "oldpool.h"
|
2007-12-21 20:21:21 +01:00
|
|
|
#include "core/bitmath_func.hpp"
|
2007-12-21 23:50:51 +01:00
|
|
|
#include "cargo_type.h"
|
2005-02-06 11:24:57 +01:00
|
|
|
|
2007-08-03 01:40:19 +02:00
|
|
|
DECLARE_OLD_POOL(Order, Order, 6, 1000)
|
|
|
|
|
2005-01-15 20:06:22 +01:00
|
|
|
/* If you change this, keep in mind that it is saved on 3 places:
|
2006-06-27 23:25:53 +02:00
|
|
|
* - Load_ORDR, all the global orders
|
|
|
|
* - Vehicle -> current_order
|
2007-06-20 21:17:22 +02:00
|
|
|
* - REF_ORDER (all REFs are currently limited to 16 bits!!)
|
2006-06-27 23:25:53 +02:00
|
|
|
*/
|
2007-08-03 01:40:19 +02:00
|
|
|
struct Order : PoolItem<Order, OrderID, &_Order_pool> {
|
2007-03-07 13:11:48 +01:00
|
|
|
Order *next; ///< Pointer to next order. If NULL, end of list
|
2007-02-04 14:46:21 +01:00
|
|
|
|
2007-01-10 19:56:51 +01:00
|
|
|
OrderTypeByte type;
|
2005-01-15 20:06:22 +01:00
|
|
|
uint8 flags;
|
2006-08-26 18:34:03 +02:00
|
|
|
DestinationID dest; ///< The destionation of the order.
|
2005-01-15 20:06:22 +01:00
|
|
|
|
2006-10-03 16:52:39 +02:00
|
|
|
CargoID refit_cargo; // Refit CargoID
|
|
|
|
byte refit_subtype; // Refit subtype
|
2007-03-08 22:39:34 +01:00
|
|
|
|
2007-06-20 21:17:22 +02:00
|
|
|
uint16 wait_time; ///< How long in ticks to wait at the destination.
|
|
|
|
uint16 travel_time; ///< How long in ticks the journey to this destination should take.
|
|
|
|
|
2007-08-03 01:40:19 +02:00
|
|
|
Order() : refit_cargo(CT_NO_REFIT) {}
|
|
|
|
~Order() { this->type = OT_NOTHING; }
|
|
|
|
|
2007-08-30 22:40:33 +02:00
|
|
|
/**
|
|
|
|
* Check if a Order really exists.
|
|
|
|
*/
|
|
|
|
inline bool IsValid() const { return this->type != OT_NOTHING; }
|
|
|
|
|
2007-03-08 22:39:34 +01:00
|
|
|
void Free();
|
|
|
|
void FreeChain();
|
2007-03-07 13:11:48 +01:00
|
|
|
};
|
2005-01-15 20:06:22 +01:00
|
|
|
|
2007-03-07 12:47:46 +01:00
|
|
|
static inline VehicleOrderID GetMaxOrderIndex()
|
2006-08-22 22:41:26 +02:00
|
|
|
{
|
|
|
|
/* TODO - This isn't the real content of the function, but
|
|
|
|
* with the new pool-system this will be replaced with one that
|
2006-12-05 14:58:20 +01:00
|
|
|
* _really_ returns the highest index. Now it just returns
|
2006-08-22 22:41:26 +02:00
|
|
|
* the next safe value we are sure about everything is below.
|
|
|
|
*/
|
2006-12-05 14:58:20 +01:00
|
|
|
return GetOrderPoolSize() - 1;
|
|
|
|
}
|
|
|
|
|
2007-03-07 12:47:46 +01:00
|
|
|
static inline VehicleOrderID GetNumOrders()
|
2006-12-05 14:58:20 +01:00
|
|
|
{
|
2006-08-22 22:41:26 +02:00
|
|
|
return GetOrderPoolSize();
|
|
|
|
}
|
|
|
|
|
2007-03-08 22:39:34 +01:00
|
|
|
inline void Order::Free()
|
2006-08-22 17:33:35 +02:00
|
|
|
{
|
2007-08-03 01:40:19 +02:00
|
|
|
this->type = OT_NOTHING;
|
|
|
|
this->flags = 0;
|
|
|
|
this->dest = 0;
|
|
|
|
this->next = NULL;
|
2006-08-22 17:33:35 +02:00
|
|
|
}
|
|
|
|
|
2007-03-08 22:39:34 +01:00
|
|
|
inline void Order::FreeChain()
|
2006-08-26 16:22:54 +02:00
|
|
|
{
|
2007-03-08 22:39:34 +01:00
|
|
|
if (next != NULL) next->FreeChain();
|
2007-08-03 01:40:19 +02:00
|
|
|
delete this;
|
2006-08-26 16:22:54 +02:00
|
|
|
}
|
|
|
|
|
2007-03-08 22:39:34 +01:00
|
|
|
#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())
|
2005-02-06 11:24:57 +01:00
|
|
|
#define FOR_ALL_ORDERS(order) FOR_ALL_ORDERS_FROM(order, 0)
|
|
|
|
|
2005-01-15 20:06:22 +01:00
|
|
|
|
|
|
|
#define FOR_VEHICLE_ORDERS(v, order) for (order = v->orders; order != NULL; order = order->next)
|
|
|
|
|
|
|
|
static inline bool HasOrderPoolFree(uint amount)
|
|
|
|
{
|
2005-01-16 15:42:53 +01:00
|
|
|
const Order *order;
|
2005-01-15 20:06:22 +01:00
|
|
|
|
2005-02-06 11:24:57 +01:00
|
|
|
/* There is always room if not all blocks in the pool are reserved */
|
2007-08-02 00:10:54 +02:00
|
|
|
if (_Order_pool.CanAllocateMoreBlocks()) return true;
|
2005-02-06 11:24:57 +01:00
|
|
|
|
2007-08-02 00:10:54 +02:00
|
|
|
FOR_ALL_ORDERS(order) if (!order->IsValid() && --amount == 0) return true;
|
2005-01-15 20:06:22 +01:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Pack and unpack routines */
|
|
|
|
|
|
|
|
static inline uint32 PackOrder(const Order *order)
|
|
|
|
{
|
2006-09-03 10:25:27 +02:00
|
|
|
return order->dest << 16 | order->flags << 8 | order->type;
|
2005-01-15 20:06:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline Order UnpackOrder(uint32 packed)
|
|
|
|
{
|
|
|
|
Order order;
|
2006-08-22 19:13:49 +02:00
|
|
|
order.type = (OrderType)GB(packed, 0, 8);
|
2005-07-20 17:29:28 +02:00
|
|
|
order.flags = GB(packed, 8, 8);
|
2006-09-03 10:25:27 +02:00
|
|
|
order.dest = GB(packed, 16, 16);
|
2005-01-15 20:06:22 +01:00
|
|
|
order.next = NULL;
|
2005-06-01 13:52:44 +02:00
|
|
|
order.index = 0; // avoid compiler warning
|
2006-10-08 22:54:27 +02:00
|
|
|
order.refit_cargo = CT_NO_REFIT;
|
2006-10-03 18:05:11 +02:00
|
|
|
order.refit_subtype = 0;
|
2007-06-20 21:17:22 +02:00
|
|
|
order.wait_time = 0;
|
|
|
|
order.travel_time = 0;
|
2005-01-15 20:06:22 +01:00
|
|
|
return order;
|
|
|
|
}
|
|
|
|
|
|
|
|
void AssignOrder(Order *order, Order data);
|
|
|
|
Order UnpackOldOrder(uint16 packed);
|
|
|
|
|
|
|
|
#endif /* ORDER_H */
|