diff options
author | rubidium <rubidium@openttd.org> | 2007-01-02 19:19:48 +0000 |
---|---|---|
committer | rubidium <rubidium@openttd.org> | 2007-01-02 19:19:48 +0000 |
commit | 013df98f79866a75f367853c9e436f3c5c79f645 (patch) | |
tree | ad4a63860df2626b22f77e7dac712e958bea54cb /src/order.h | |
parent | 3d32fd3f4bfaceb8a48530fbc2f4bd5db2752596 (diff) | |
download | openttd-013df98f79866a75f367853c9e436f3c5c79f645.tar.xz |
(svn r7759) -Merge: makefile rewrite. This merge features:
- A proper ./configure, so everything needs to be configured only once, not for every make.
- Usage of makedepend when available. This greatly reduces the time needed for generating the dependencies.
- A generator for all project files. There is a single file with sources, which is used to generate Makefiles and the project files for MSVC.
- Proper support for OSX universal binaries.
- Object files for non-MSVC compiles are also placed in separate directories, making is faster to switch between debug and release compiles and it does not touch the directory with the source files.
- Functionality to make a bundle of all needed files for for example a nightly or distribution of a binary with all needed GRFs and language files.
Note: as this merge moves almost all files, it is recommended to make a backup of your working copy before updating your working copy.
Diffstat (limited to 'src/order.h')
-rw-r--r-- | src/order.h | 202 |
1 files changed, 202 insertions, 0 deletions
diff --git a/src/order.h b/src/order.h new file mode 100644 index 000000000..7031f2455 --- /dev/null +++ b/src/order.h @@ -0,0 +1,202 @@ +/* $Id$ */ + +/** @file order.h */ + +#ifndef ORDER_H +#define ORDER_H + +#include "macros.h" +#include "oldpool.h" + +enum { + INVALID_VEH_ORDER_ID = 0xFF, + INVALID_ORDER = 0xFFFF, +}; + +/* Order types */ +enum OrderTypes { + OT_NOTHING = 0, + OT_GOTO_STATION = 1, + OT_GOTO_DEPOT = 2, + OT_LOADING = 3, + OT_LEAVESTATION = 4, + OT_DUMMY = 5, + OT_GOTO_WAYPOINT = 6, +}; +/* It needs to be 8bits, because we save and load it as such */ +typedef uint8 OrderType; + +/* Order flags -- please use OFB instead OF and use HASBIT/SETBIT/CLEARBIT */ + +/** Order flag masks - these are for direct bit operations */ +enum OrderFlagMasks { + //Flags for stations: + /** vehicle will transfer cargo (i. e. not deliver to nearby industry/town even if accepted there) */ + OF_TRANSFER = 0x1, + /** If OF_TRANSFER is not set, drop any cargo loaded. If accepted, deliver, otherwise cargo remains at the station. + * No new cargo is loaded onto the vehicle whatsoever */ + OF_UNLOAD = 0x2, + /** Wait for full load of all vehicles, or of at least one cargo type, depending on patch setting + * @todo make this two different flags */ + OF_FULL_LOAD = 0x4, + + //Flags for depots: + /** The current depot-order was initiated because it was in the vehicle's order list */ + OF_PART_OF_ORDERS = 0x2, + /** if OF_PART_OF_ORDERS is not set, this will cause the vehicle to be stopped in the depot */ + OF_HALT_IN_DEPOT = 0x4, + /** if OF_PART_OF_ORDERS is set, this will cause the order only be come active if the vehicle needs servicing */ + OF_SERVICE_IF_NEEDED = 0x4, //used when OF_PART_OF_ORDERS is set. + + //Common flags + /** This causes the vehicle not to stop at intermediate OR the destination station (depending on patch settings) + * @todo make this two different flags */ + OF_NON_STOP = 0x8 +}; + +/** Order flags bits - these are for the *BIT macros + * for descrption of flags, see OrderFlagMasks + * @see OrderFlagMasks + */ +enum { + OFB_TRANSFER = 0, + OFB_UNLOAD = 1, + OFB_FULL_LOAD = 2, + OFB_PART_OF_ORDERS = 1, + OFB_HALT_IN_DEPOT = 2, + OFB_SERVICE_IF_NEEDED = 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 { + OrderType type; + uint8 flags; + DestinationID dest; ///< The destionation of the order. + + struct Order *next; ///< Pointer to next order. If NULL, end of list + + OrderID index; ///< Index of the order, is not saved or anything, just for reference + + CargoID refit_cargo; // Refit CargoID + byte refit_subtype; // Refit subtype +} Order; + +#define MAX_BACKUP_ORDER_COUNT 40 + +typedef struct { + VehicleID clone; + VehicleOrderID orderindex; + Order order[MAX_BACKUP_ORDER_COUNT + 1]; + uint16 service_interval; + char name[32]; +} BackuppedOrders; + +VARDEF TileIndex _backup_orders_tile; +VARDEF BackuppedOrders _backup_orders_data[1]; + +DECLARE_OLD_POOL(Order, Order, 6, 1000) + +static inline VehicleOrderID GetMaxOrderIndex(void) +{ + /* TODO - This isn't the real content of the function, but + * with the new pool-system this will be replaced with one that + * _really_ returns the highest index. Now it just returns + * the next safe value we are sure about everything is below. + */ + return GetOrderPoolSize() - 1; +} + +static inline VehicleOrderID GetNumOrders(void) +{ + return GetOrderPoolSize(); +} + +/** + * Check if a Order really exists. + */ +static inline bool IsValidOrder(const Order *o) +{ + return o->type != OT_NOTHING; +} + +static inline void DeleteOrder(Order *o) +{ + o->type = OT_NOTHING; + o->next = NULL; +} + +#define FOR_ALL_ORDERS_FROM(order, start) for (order = GetOrder(start); order != NULL; order = (order->index + 1U < GetOrderPoolSize()) ? GetOrder(order->index + 1U) : NULL) if (IsValidOrder(order)) +#define FOR_ALL_ORDERS(order) FOR_ALL_ORDERS_FROM(order, 0) + + +#define FOR_VEHICLE_ORDERS(v, order) for (order = v->orders; order != NULL; order = order->next) + +static inline bool HasOrderPoolFree(uint amount) +{ + const Order *order; + + /* There is always room if not all blocks in the pool are reserved */ + if (_Order_pool.current_blocks < _Order_pool.max_blocks) + return true; + + FOR_ALL_ORDERS(order) + if (order->type == OT_NOTHING) + if (--amount == 0) + return true; + + return false; +} + +static inline bool IsOrderPoolFull(void) +{ + return !HasOrderPoolFree(1); +} + +/* Pack and unpack routines */ + +static inline uint32 PackOrder(const Order *order) +{ + return order->dest << 16 | order->flags << 8 | order->type; +} + +static inline Order UnpackOrder(uint32 packed) +{ + Order order; + order.type = (OrderType)GB(packed, 0, 8); + order.flags = GB(packed, 8, 8); + order.dest = GB(packed, 16, 16); + order.next = NULL; + order.index = 0; // avoid compiler warning + order.refit_cargo = CT_NO_REFIT; + order.refit_subtype = 0; + return order; +} + +/* Functions */ +void BackupVehicleOrders(const Vehicle *v, BackuppedOrders *order); +void RestoreVehicleOrders(const Vehicle* v, const BackuppedOrders* order); +void RemoveOrderFromAllVehicles(OrderType type, DestinationID destination); +void InvalidateVehicleOrder(const Vehicle *v); +bool VehicleHasDepotOrders(const Vehicle *v); +void CheckOrders(const Vehicle*); +void DeleteVehicleOrders(Vehicle *v); +bool IsOrderListShared(const Vehicle *v); +void AssignOrder(Order *order, Order data); +bool CheckForValidOrders(const Vehicle* v); + +Order UnpackOldOrder(uint16 packed); + +#endif /* ORDER_H */ |