/* $Id$ */
/*
* This file is part of OpenTTD.
* OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
* OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see .
*/
/** @file vehicle_base.h Base class for all vehicles. */
#ifndef VEHICLE_BASE_H
#define VEHICLE_BASE_H
#include "track_type.h"
#include "command_type.h"
#include "order_base.h"
#include "cargopacket.h"
#include "texteff.hpp"
#include "engine_type.h"
#include "order_func.h"
#include "transport_type.h"
#include "group_type.h"
/** Vehicle status bits in #Vehicle::vehstatus. */
enum VehStatus {
VS_HIDDEN = 0x01, ///< Vehicle is not visible.
VS_STOPPED = 0x02, ///< Vehicle is stopped by the player.
VS_UNCLICKABLE = 0x04, ///< Vehicle is not clickable by the user (shadow vehicles).
VS_DEFPAL = 0x08, ///< Use default vehicle palette. @see DoDrawVehicle
VS_TRAIN_SLOWING = 0x10, ///< Train is slowing down.
VS_SHADOW = 0x20, ///< Vehicle is a shadow vehicle.
VS_AIRCRAFT_BROKEN = 0x40, ///< Aircraft is broken down.
VS_CRASHED = 0x80, ///< Vehicle is crashed.
};
/** Bit numbers in #Vehicle::vehicle_flags. */
enum VehicleFlags {
VF_LOADING_FINISHED, ///< Vehicle has finished loading.
VF_CARGO_UNLOADING, ///< Vehicle is unloading cargo.
VF_BUILT_AS_PROTOTYPE, ///< Vehicle is a prototype (accepted as exclusive preview).
VF_TIMETABLE_STARTED, ///< Whether the vehicle has started running on the timetable yet.
VF_AUTOFILL_TIMETABLE, ///< Whether the vehicle should fill in the timetable automatically.
VF_AUTOFILL_PRES_WAIT_TIME, ///< Whether non-destructive auto-fill should preserve waiting times
VF_STOP_LOADING, ///< Don't load anymore during the next load cycle.
VF_PATHFINDER_LOST, ///< Vehicle's pathfinder is lost.
};
/** Bit numbers used to indicate which of the #NewGRFCache values are valid. */
enum NewGRFCacheValidValues {
NCVV_POSITION_CONSIST_LENGTH = 0, ///< This bit will be set if the NewGRF var 40 currently stored is valid.
NCVV_POSITION_SAME_ID_LENGTH = 1, ///< This bit will be set if the NewGRF var 41 currently stored is valid.
NCVV_CONSIST_CARGO_INFORMATION = 2, ///< This bit will be set if the NewGRF var 42 currently stored is valid.
NCVV_COMPANY_INFORMATION = 3, ///< This bit will be set if the NewGRF var 43 currently stored is valid.
NCVV_END, ///< End of the bits.
};
/** Cached often queried (NewGRF) values */
struct NewGRFCache {
/* Values calculated when they are requested for the first time after invalidating the NewGRF cache. */
uint32 position_consist_length; ///< Cache for NewGRF var 40.
uint32 position_same_id_length; ///< Cache for NewGRF var 41.
uint32 consist_cargo_information; ///< Cache for NewGRF var 42.
uint32 company_information; ///< Cache for NewGRF var 43.
uint8 cache_valid; ///< Bitset that indicates which cache values are valid.
};
/** Meaning of the various bits of the visual effect. */
enum VisualEffect {
VE_OFFSET_START = 0, ///< First bit that contains the offset (0 = front, 8 = centre, 15 = rear)
VE_OFFSET_COUNT = 4, ///< Number of bits used for the offset
VE_OFFSET_CENTRE = 8, ///< Value of offset corresponding to a position above the centre of the vehicle
VE_TYPE_START = 4, ///< First bit used for the type of effect
VE_TYPE_COUNT = 2, ///< Number of bits used for the effect type
VE_TYPE_DEFAULT = 0, ///< Use default from engine class
VE_TYPE_STEAM = 1, ///< Steam plumes
VE_TYPE_DIESEL = 2, ///< Diesel fumes
VE_TYPE_ELECTRIC = 3, ///< Electric sparks
VE_DISABLE_EFFECT = 6, ///< Flag to disable visual effect
VE_DISABLE_WAGON_POWER = 7, ///< Flag to disable wagon power
VE_DEFAULT = 0xFF, ///< Default value to indicate that visual effect should be based on engine class
};
/**
* Enum to handle ground vehicle subtypes.
* This is defined here instead of at #GroundVehicle because some common function require access to these flags.
* Do not access it directly unless you have to. Use the subtype access functions.
*/
enum GroundVehicleSubtypeFlags {
GVSF_FRONT = 0, ///< Leading engine of a consist.
GVSF_ARTICULATED_PART = 1, ///< Articulated part of an engine.
GVSF_WAGON = 2, ///< Wagon (not used for road vehicles).
GVSF_ENGINE = 3, ///< Engine that can be front engine, but might be placed behind another engine (not used for road vehicles).
GVSF_FREE_WAGON = 4, ///< First in a wagon chain (in depot) (not used for road vehicles).
GVSF_MULTIHEADED = 5, ///< Engine is multiheaded (not used for road vehicles).
};
/** Cached often queried values common to all vehicles. */
struct VehicleCache {
uint16 cached_max_speed; ///< Maximum speed of the consist (minimum of the max speed of all vehicles in the consist).
byte cached_vis_effect; ///< Visual effect to show (see #VisualEffect)
};
/** A vehicle pool for a little over 1 million vehicles. */
typedef Pool VehiclePool;
extern VehiclePool _vehicle_pool;
/* Some declarations of functions, so we can make them friendly */
struct SaveLoad;
struct GroundVehicleCache;
extern const SaveLoad *GetVehicleDescription(VehicleType vt);
struct LoadgameState;
extern bool LoadOldVehicle(LoadgameState *ls, int num);
extern void FixOldVehicles();
/** %Vehicle data structure. */
struct Vehicle : VehiclePool::PoolItem<&_vehicle_pool>, BaseVehicle {
private:
Vehicle *next; ///< pointer to the next vehicle in the chain
Vehicle *previous; ///< NOSAVE: pointer to the previous vehicle in the chain
Vehicle *first; ///< NOSAVE: pointer to the first vehicle in the chain
Vehicle *next_shared; ///< pointer to the next vehicle that shares the order
Vehicle *previous_shared; ///< NOSAVE: pointer to the previous vehicle in the shared order chain
public:
friend const SaveLoad *GetVehicleDescription(VehicleType vt); ///< So we can use private/protected variables in the saveload code
friend void FixOldVehicles();
friend void AfterLoadVehicles(bool part_of_load); ///< So we can set the #previous and #first pointers while loading
friend bool LoadOldVehicle(LoadgameState *ls, int num); ///< So we can set the proper next pointer while loading
char *name; ///< Name of vehicle
TileIndex tile; ///< Current tile index
/**
* Heading for this tile.
* For airports and train stations this tile does not necessarily belong to the destination station,
* but it can be used for heuristic purposes to estimate the distance.
*/
TileIndex dest_tile;
Money profit_this_year; ///< Profit this year << 8, low 8 bits are fract
Money profit_last_year; ///< Profit last year << 8, low 8 bits are fract
Money value; ///< Value of the vehicle
CargoPayment *cargo_payment; ///< The cargo payment we're currently in
/* Used for timetabling. */
uint32 current_order_time; ///< How many ticks have passed since this order started.
int32 lateness_counter; ///< How many ticks late (or early if negative) this vehicle is.
Date timetable_start; ///< When the vehicle is supposed to start the timetable.
Rect coord; ///< NOSAVE: Graphical bounding box of the vehicle, i.e. what to redraw on moves.
Vehicle *next_hash; ///< NOSAVE: Next vehicle in the visual location hash.
Vehicle **prev_hash; ///< NOSAVE: Previous vehicle in the visual location hash.
Vehicle *next_new_hash; ///< NOSAVE: Next vehicle in the tile location hash.
Vehicle **prev_new_hash; ///< NOSAVE: Previous vehicle in the tile location hash.
Vehicle **old_new_hash; ///< NOSAVE: Cache of the current hash chain.
SpriteID colourmap; ///< NOSAVE: cached colour mapping
/* Related to age and service time */
Year build_year; ///< Year the vehicle has been built.
Date age; ///< Age in days
Date max_age; ///< Maximum age
Date date_of_last_service; ///< Last date the vehicle had a service at a depot.
Date service_interval; ///< The interval for (automatic) servicing; either in days or %.
uint16 reliability; ///< Reliability.
uint16 reliability_spd_dec; ///< Reliability decrease speed.
byte breakdown_ctr; ///< Counter for managing breakdown events. @see Vehicle::HandleBreakdown
byte breakdown_delay; ///< Counter for managing breakdown length.
byte breakdowns_since_last_service; ///< Counter for the amount of breakdowns.
byte breakdown_chance; ///< Current chance of breakdowns.
int32 x_pos; ///< x coordinate.
int32 y_pos; ///< y coordinate.
byte z_pos; ///< z coordinate.
DirectionByte direction; ///< facing
OwnerByte owner; ///< Which company owns the vehicle?
byte spritenum; ///< currently displayed sprite index
///< 0xfd == custom sprite, 0xfe == custom second head sprite
///< 0xff == reserved for another custom sprite
SpriteID cur_image; ///< sprite number for this vehicle
byte x_extent; ///< x-extent of vehicle bounding box
byte y_extent; ///< y-extent of vehicle bounding box
byte z_extent; ///< z-extent of vehicle bounding box
int8 x_offs; ///< x offset for vehicle sprite
int8 y_offs; ///< y offset for vehicle sprite
EngineID engine_type; ///< The type of engine used for this vehicle.
TextEffectID fill_percent_te_id; ///< a text-effect id to a loading indicator object
UnitID unitnumber; ///< unit number, for display purposes only
uint16 cur_speed; ///< current speed
byte subspeed; ///< fractional speed
byte acceleration; ///< used by train & aircraft
uint32 motion_counter; ///< counter to occasionally play a vehicle sound.
byte progress; ///< The percentage (if divided by 256) this vehicle already crossed the tile unit.
byte random_bits; ///< Bits used for determining which randomized variational spritegroups to use when drawing.
byte waiting_triggers; ///< Triggers to be yet matched before rerandomizing the random bits.
StationID last_station_visited; ///< The last station we stopped at.
CargoID cargo_type; ///< type of cargo this vehicle is carrying
byte cargo_subtype; ///< Used for livery refits (NewGRF variations)
uint16 cargo_cap; ///< total capacity
VehicleCargoList cargo; ///< The cargo this vehicle is carrying
byte day_counter; ///< Increased by one for each day
byte tick_counter; ///< Increased by one for each tick
byte running_ticks; ///< Number of ticks this vehicle was not stopped this day
byte vehstatus; ///< Status
Order current_order; ///< The current order (+ status, like: loading)
VehicleOrderID cur_real_order_index;///< The index to the current real (non-implicit) order
VehicleOrderID cur_implicit_order_index;///< The index to the current implicit order
union {
OrderList *list; ///< Pointer to the order list for this vehicle
Order *old; ///< Only used during conversion of old save games
} orders; ///< The orders currently assigned to the vehicle.
byte vehicle_flags; ///< Used for gradual loading and other miscellaneous things (@see VehicleFlags enum)
uint16 load_unload_ticks; ///< Ticks to wait before starting next cycle.
GroupID group_id; ///< Index of group Pool array
byte subtype; ///< subtype (Filled with values from #EffectVehicles/#TrainSubTypes/#AircraftSubTypes)
NewGRFCache grf_cache; ///< Cache of often used calculated NewGRF values
VehicleCache vcache; ///< Cache of often used vehicle values.
Vehicle(VehicleType type = VEH_INVALID);
void PreDestructor();
/** We want to 'destruct' the right class. */
virtual ~Vehicle();
void BeginLoading();
void LeaveStation();
GroundVehicleCache *GetGroundVehicleCache();
const GroundVehicleCache *GetGroundVehicleCache() const;
uint16 &GetGroundVehicleFlags();
const uint16 &GetGroundVehicleFlags() const;
void DeleteUnreachedImplicitOrders();
void HandleLoading(bool mode = false);
/**
* Marks the vehicles to be redrawn and updates cached variables
*
* This method marks the area of the vehicle on the screen as dirty.
* It can be use to repaint the vehicle.
*
* @ingroup dirty
*/
virtual void MarkDirty() {}
/**
* Updates the x and y offsets and the size of the sprite used
* for this vehicle.
* @param direction the direction the vehicle is facing
*/
virtual void UpdateDeltaXY(Direction direction) {}
/**
* Determines the effective direction-specific vehicle movement speed.
*
* This method belongs to the old vehicle movement method:
* A vehicle moves a step every 256 progress units.
* The vehicle speed is scaled by 3/4 when moving in X or Y direction due to the longer distance.
*
* However, this method is slightly wrong in corners, as the leftover progress is not scaled correctly
* when changing movement direction. #GetAdvanceSpeed() and #GetAdvanceDistance() are better wrt. this.
*
* @param speed Direction-independent unscaled speed.
* @return speed scaled by movement direction. 256 units are required for each movement step.
*/
FORCEINLINE uint GetOldAdvanceSpeed(uint speed)
{
return (this->direction & 1) ? speed : speed * 3 / 4;
}
/**
* Determines the effective vehicle movement speed.
*
* Together with #GetAdvanceDistance() this function is a replacement for #GetOldAdvanceSpeed().
*
* A vehicle progresses independent of it's movement direction.
* However different amounts of "progress" are needed for moving a step in a specific direction.
* That way the leftover progress does not need any adaption when changing movement direction.
*
* @param speed Direction-independent unscaled speed.
* @return speed, scaled to match #GetAdvanceDistance().
*/
static FORCEINLINE uint GetAdvanceSpeed(uint speed)
{
return speed * 3 / 4;
}
/**
* Determines the vehicle "progress" needed for moving a step.
*
* Together with #GetAdvanceSpeed() this function is a replacement for #GetOldAdvanceSpeed().
*
* @return distance to drive for a movement step on the map.
*/
FORCEINLINE uint GetAdvanceDistance()
{
return (this->direction & 1) ? 192 : 256;
}
/**
* Sets the expense type associated to this vehicle type
* @param income whether this is income or (running) expenses of the vehicle
*/
virtual ExpensesType GetExpenseType(bool income) const { return EXPENSES_OTHER; }
/**
* Play the sound associated with leaving the station
*/
virtual void PlayLeaveStationSound() const {}
/**
* Whether this is the primary vehicle in the chain.
*/
virtual bool IsPrimaryVehicle() const { return false; }
/**
* Gets the sprite to show for the given direction
* @param direction the direction the vehicle is facing
* @return the sprite for the given vehicle in the given direction
*/
virtual SpriteID GetImage(Direction direction) const { return 0; }
/**
* Invalidates cached NewGRF variables
* @see InvalidateNewGRFCacheOfChain
*/
FORCEINLINE void InvalidateNewGRFCache()
{
this->grf_cache.cache_valid = 0;
}
/**
* Invalidates cached NewGRF variables of all vehicles in the chain (after the current vehicle)
* @see InvalidateNewGRFCache
*/
FORCEINLINE void InvalidateNewGRFCacheOfChain()
{
for (Vehicle *u = this; u != NULL; u = u->Next()) {
u->InvalidateNewGRFCache();
}
}
/**
* Check if the vehicle is a ground vehicle.
* @return True iff the vehicle is a train or a road vehicle.
*/
FORCEINLINE bool IsGroundVehicle() const
{
return this->type == VEH_TRAIN || this->type == VEH_ROAD;
}
/**
* Gets the speed in km-ish/h that can be sent into SetDParam for string processing.
* @return the vehicle's speed
*/
virtual int GetDisplaySpeed() const { return 0; }
/**
* Gets the maximum speed in km-ish/h that can be sent into SetDParam for string processing.
* @return the vehicle's maximum speed
*/
virtual int GetDisplayMaxSpeed() const { return 0; }
/**
* Gets the running cost of a vehicle
* @return the vehicle's running cost
*/
virtual Money GetRunningCost() const { return 0; }
/**
* Check whether the vehicle is in the depot.
* @return true if and only if the vehicle is in the depot.
*/
virtual bool IsInDepot() const { return false; }
/**
* Check whether the vehicle is in the depot *and* stopped.
* @return true if and only if the vehicle is in the depot and stopped.
*/
virtual bool IsStoppedInDepot() const { return this->IsInDepot() && (this->vehstatus & VS_STOPPED) != 0; }
/**
* Calls the tick handler of the vehicle
* @return is this vehicle still valid?
*/
virtual bool Tick() { return true; };
/**
* Calls the new day handler of the vehicle
*/
virtual void OnNewDay() {};
/**
* Crash the (whole) vehicle chain.
* @param flooded whether the cause of the crash is flooding or not.
* @return the number of lost souls.
*/
virtual uint Crash(bool flooded = false);
/**
* Returns the Trackdir on which the vehicle is currently located.
* Works for trains and ships.
* Currently works only sortof for road vehicles, since they have a fuzzy
* concept of being "on" a trackdir. Dunno really what it returns for a road
* vehicle that is halfway a tile, never really understood that part. For road
* vehicles that are at the beginning or end of the tile, should just return
* the diagonal trackdir on which they are driving. I _think_.
* For other vehicles types, or vehicles with no clear trackdir (such as those
* in depots), returns 0xFF.
* @return the trackdir of the vehicle
*/
virtual Trackdir GetVehicleTrackdir() const { return INVALID_TRACKDIR; }
/**
* Gets the running cost of a vehicle that can be sent into SetDParam for string processing.
* @return the vehicle's running cost
*/
Money GetDisplayRunningCost() const { return (this->GetRunningCost() >> 8); }
/**
* Gets the profit vehicle had this year. It can be sent into SetDParam for string processing.
* @return the vehicle's profit this year
*/
Money GetDisplayProfitThisYear() const { return (this->profit_this_year >> 8); }
/**
* Gets the profit vehicle had last year. It can be sent into SetDParam for string processing.
* @return the vehicle's profit last year
*/
Money GetDisplayProfitLastYear() const { return (this->profit_last_year >> 8); }
void SetNext(Vehicle *next);
/**
* Get the next vehicle of this vehicle.
* @note articulated parts are also counted as vehicles.
* @return the next vehicle or NULL when there isn't a next vehicle.
*/
inline Vehicle *Next() const { return this->next; }
/**
* Get the previous vehicle of this vehicle.
* @note articulated parts are also counted as vehicles.
* @return the previous vehicle or NULL when there isn't a previous vehicle.
*/
inline Vehicle *Previous() const { return this->previous; }
/**
* Get the first vehicle of this vehicle chain.
* @return the first vehicle of the chain.
*/
inline Vehicle *First() const { return this->first; }
/**
* Get the last vehicle of this vehicle chain.
* @return the last vehicle of the chain.
*/
inline Vehicle *Last()
{
Vehicle *v = this;
while (v->Next() != NULL) v = v->Next();
return v;
}
/**
* Get the last vehicle of this vehicle chain.
* @return the last vehicle of the chain.
*/
inline const Vehicle *Last() const
{
const Vehicle *v = this;
while (v->Next() != NULL) v = v->Next();
return v;
}
/**
* Get the first order of the vehicles order list.
* @return first order of order list.
*/
inline Order *GetFirstOrder() const { return (this->orders.list == NULL) ? NULL : this->orders.list->GetFirstOrder(); }
void AddToShared(Vehicle *shared_chain);
void RemoveFromShared();
/**
* Get the next vehicle of the shared vehicle chain.
* @return the next shared vehicle or NULL when there isn't a next vehicle.
*/
inline Vehicle *NextShared() const { return this->next_shared; }
/**
* Get the previous vehicle of the shared vehicle chain
* @return the previous shared vehicle or NULL when there isn't a previous vehicle.
*/
inline Vehicle *PreviousShared() const { return this->previous_shared; }
/**
* Get the first vehicle of this vehicle chain.
* @return the first vehicle of the chain.
*/
inline Vehicle *FirstShared() const { return (this->orders.list == NULL) ? this->First() : this->orders.list->GetFirstSharedVehicle(); }
/**
* Check if we share our orders with another vehicle.
* @return true if there are other vehicles sharing the same order
*/
inline bool IsOrderListShared() const { return this->orders.list != NULL && this->orders.list->IsShared(); }
/**
* Get the number of orders this vehicle has.
* @return the number of orders this vehicle has.
*/
inline VehicleOrderID GetNumOrders() const { return (this->orders.list == NULL) ? 0 : this->orders.list->GetNumOrders(); }
/**
* Get the number of manually added orders this vehicle has.
* @return the number of manually added orders this vehicle has.
*/
inline VehicleOrderID GetNumManualOrders() const { return (this->orders.list == NULL) ? 0 : this->orders.list->GetNumManualOrders(); }
/**
* Copy certain configurations and statistics of a vehicle after successful autoreplace/renew
* The function shall copy everything that cannot be copied by a command (like orders / group etc),
* and that shall not be resetted for the new vehicle.
* @param src The old vehicle
*/
inline void CopyVehicleConfigAndStatistics(const Vehicle *src)
{
this->unitnumber = src->unitnumber;
this->cur_real_order_index = src->cur_real_order_index;
this->cur_implicit_order_index = src->cur_implicit_order_index;
this->current_order = src->current_order;
this->dest_tile = src->dest_tile;
this->profit_this_year = src->profit_this_year;
this->profit_last_year = src->profit_last_year;
this->current_order_time = src->current_order_time;
this->lateness_counter = src->lateness_counter;
this->timetable_start = src->timetable_start;
if (HasBit(src->vehicle_flags, VF_TIMETABLE_STARTED)) SetBit(this->vehicle_flags, VF_TIMETABLE_STARTED);
if (HasBit(src->vehicle_flags, VF_AUTOFILL_TIMETABLE)) SetBit(this->vehicle_flags, VF_AUTOFILL_TIMETABLE);
if (HasBit(src->vehicle_flags, VF_AUTOFILL_PRES_WAIT_TIME)) SetBit(this->vehicle_flags, VF_AUTOFILL_PRES_WAIT_TIME);
this->service_interval = src->service_interval;
}
bool HandleBreakdown();
bool NeedsAutorenewing(const Company *c) const;
bool NeedsServicing() const;
bool NeedsAutomaticServicing() const;
/**
* Determine the location for the station where the vehicle goes to next.
* Things done for example are allocating slots in a road stop or exact
* location of the platform is determined for ships.
* @param station the station to make the next location of the vehicle.
* @return the location (tile) to aim for.
*/
virtual TileIndex GetOrderStationLocation(StationID station) { return INVALID_TILE; }
/**
* Find the closest depot for this vehicle and tell us the location,
* DestinationID and whether we should reverse.
* @param location where do we go to?
* @param destination what hangar do we go to?
* @param reverse should the vehicle be reversed?
* @return true if a depot could be found.
*/
virtual bool FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse) { return false; }
CommandCost SendToDepot(DoCommandFlag flags, DepotCommand command);
void UpdateVisualEffect(bool allow_power_change = true);
void ShowVisualEffect() const;
private:
/**
* Advance cur_real_order_index to the next real order.
* cur_implicit_order_index is not touched.
*/
void SkipToNextRealOrderIndex()
{
if (this->GetNumManualOrders() > 0) {
/* Advance to next real order */
do {
this->cur_real_order_index++;
if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
} while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT));
} else {
this->cur_real_order_index = 0;
}
}
public:
/**
* Increments cur_implicit_order_index, keeps care of the wrap-around and invalidates the GUI.
* cur_real_order_index is incremented as well, if needed.
* Note: current_order is not invalidated.
*/
void IncrementImplicitOrderIndex()
{
if (this->cur_implicit_order_index == this->cur_real_order_index) {
/* Increment real order index as well */
this->SkipToNextRealOrderIndex();
}
assert(this->cur_real_order_index == 0 || this->cur_real_order_index < this->GetNumOrders());
/* Advance to next implicit order */
do {
this->cur_implicit_order_index++;
if (this->cur_implicit_order_index >= this->GetNumOrders()) this->cur_implicit_order_index = 0;
} while (this->cur_implicit_order_index != this->cur_real_order_index && !this->GetOrder(this->cur_implicit_order_index)->IsType(OT_IMPLICIT));
InvalidateVehicleOrder(this, 0);
}
/**
* Advanced cur_real_order_index to the next real order, keeps care of the wrap-around and invalidates the GUI.
* cur_implicit_order_index is incremented as well, if it was equal to cur_real_order_index, i.e. cur_real_order_index is skipped
* but not any implicit orders.
* Note: current_order is not invalidated.
*/
void IncrementRealOrderIndex()
{
if (this->cur_implicit_order_index == this->cur_real_order_index) {
/* Increment both real and implicit order */
this->IncrementImplicitOrderIndex();
} else {
/* Increment real order only */
this->SkipToNextRealOrderIndex();
InvalidateVehicleOrder(this, 0);
}
}
/**
* Skip implicit orders until cur_real_order_index is a non-implicit order.
*/
void UpdateRealOrderIndex()
{
/* Make sure the index is valid */
if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
if (this->GetNumManualOrders() > 0) {
/* Advance to next real order */
while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT)) {
this->cur_real_order_index++;
if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
}
} else {
this->cur_real_order_index = 0;
}
}
/**
* Returns order 'index' of a vehicle or NULL when it doesn't exists
* @param index the order to fetch
* @return the found (or not) order
*/
inline Order *GetOrder(int index) const
{
return (this->orders.list == NULL) ? NULL : this->orders.list->GetOrderAt(index);
}
/**
* Returns the last order of a vehicle, or NULL if it doesn't exists
* @return last order of a vehicle, if available
*/
inline Order *GetLastOrder() const
{
return (this->orders.list == NULL) ? NULL : this->orders.list->GetLastOrder();
}
bool IsEngineCountable() const;
bool HasDepotOrder() const;
void HandlePathfindingResult(bool path_found);
/**
* Check if the vehicle is a front engine.
* @return Returns true if the vehicle is a front engine.
*/
FORCEINLINE bool IsFrontEngine() const
{
return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_FRONT);
}
/**
* Check if the vehicle is an articulated part of an engine.
* @return Returns true if the vehicle is an articulated part.
*/
FORCEINLINE bool IsArticulatedPart() const
{
return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_ARTICULATED_PART);
}
/**
* Check if an engine has an articulated part.
* @return True if the engine has an articulated part.
*/
FORCEINLINE bool HasArticulatedPart() const
{
return this->Next() != NULL && this->Next()->IsArticulatedPart();
}
/**
* Get the next part of an articulated engine.
* @return Next part of the articulated engine.
* @pre The vehicle is an articulated engine.
*/
FORCEINLINE Vehicle *GetNextArticulatedPart() const
{
assert(this->HasArticulatedPart());
return this->Next();
}
/**
* Get the first part of an articulated engine.
* @return First part of the engine.
*/
FORCEINLINE Vehicle *GetFirstEnginePart()
{
Vehicle *v = this;
while (v->IsArticulatedPart()) v = v->Previous();
return v;
}
/**
* Get the first part of an articulated engine.
* @return First part of the engine.
*/
FORCEINLINE const Vehicle *GetFirstEnginePart() const
{
const Vehicle *v = this;
while (v->IsArticulatedPart()) v = v->Previous();
return v;
}
/**
* Get the last part of an articulated engine.
* @return Last part of the engine.
*/
FORCEINLINE Vehicle *GetLastEnginePart()
{
Vehicle *v = this;
while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
return v;
}
/**
* Get the next real (non-articulated part) vehicle in the consist.
* @return Next vehicle in the consist.
*/
FORCEINLINE Vehicle *GetNextVehicle() const
{
const Vehicle *v = this;
while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
/* v now contains the last articulated part in the engine */
return v->Next();
}
/**
* Get the previous real (non-articulated part) vehicle in the consist.
* @return Previous vehicle in the consist.
*/
FORCEINLINE Vehicle *GetPrevVehicle() const
{
Vehicle *v = this->Previous();
while (v != NULL && v->IsArticulatedPart()) v = v->Previous();
return v;
}
};
/**
* Iterate over all vehicles from a given point.
* @param var The variable used to iterate over.
* @param start The vehicle to start the iteration at.
*/
#define FOR_ALL_VEHICLES_FROM(var, start) FOR_ALL_ITEMS_FROM(Vehicle, vehicle_index, var, start)
/**
* Iterate over all vehicles.
* @param var The variable used to iterate over.
*/
#define FOR_ALL_VEHICLES(var) FOR_ALL_VEHICLES_FROM(var, 0)
/**
* Class defining several overloaded accessors so we don't
* have to cast vehicle types that often
*/
template
struct SpecializedVehicle : public Vehicle {
static const VehicleType EXPECTED_TYPE = Type; ///< Specialized type
typedef SpecializedVehicle SpecializedVehicleBase; ///< Our type
/**
* Set vehicle type correctly
*/
FORCEINLINE SpecializedVehicle() : Vehicle(Type) { }
/**
* Get the first vehicle in the chain
* @return first vehicle in the chain
*/
FORCEINLINE T *First() const { return (T *)this->Vehicle::First(); }
/**
* Get the last vehicle in the chain
* @return last vehicle in the chain
*/
FORCEINLINE T *Last() { return (T *)this->Vehicle::Last(); }
/**
* Get the last vehicle in the chain
* @return last vehicle in the chain
*/
FORCEINLINE const T *Last() const { return (const T *)this->Vehicle::Last(); }
/**
* Get next vehicle in the chain
* @return next vehicle in the chain
*/
FORCEINLINE T *Next() const { return (T *)this->Vehicle::Next(); }
/**
* Get previous vehicle in the chain
* @return previous vehicle in the chain
*/
FORCEINLINE T *Previous() const { return (T *)this->Vehicle::Previous(); }
/**
* Get the next part of an articulated engine.
* @return Next part of the articulated engine.
* @pre The vehicle is an articulated engine.
*/
FORCEINLINE T *GetNextArticulatedPart() { return (T *)this->Vehicle::GetNextArticulatedPart(); }
/**
* Get the next part of an articulated engine.
* @return Next part of the articulated engine.
* @pre The vehicle is an articulated engine.
*/
FORCEINLINE T *GetNextArticulatedPart() const { return (T *)this->Vehicle::GetNextArticulatedPart(); }
/**
* Get the first part of an articulated engine.
* @return First part of the engine.
*/
FORCEINLINE T *GetFirstEnginePart() { return (T *)this->Vehicle::GetFirstEnginePart(); }
/**
* Get the first part of an articulated engine.
* @return First part of the engine.
*/
FORCEINLINE const T *GetFirstEnginePart() const { return (const T *)this->Vehicle::GetFirstEnginePart(); }
/**
* Get the last part of an articulated engine.
* @return Last part of the engine.
*/
FORCEINLINE T *GetLastEnginePart() { return (T *)this->Vehicle::GetLastEnginePart(); }
/**
* Get the next real (non-articulated part) vehicle in the consist.
* @return Next vehicle in the consist.
*/
FORCEINLINE T *GetNextVehicle() const { return (T *)this->Vehicle::GetNextVehicle(); }
/**
* Get the previous real (non-articulated part) vehicle in the consist.
* @return Previous vehicle in the consist.
*/
FORCEINLINE T *GetPrevVehicle() const { return (T *)this->Vehicle::GetPrevVehicle(); }
/**
* Tests whether given index is a valid index for vehicle of this type
* @param index tested index
* @return is this index valid index of T?
*/
static FORCEINLINE bool IsValidID(size_t index)
{
return Vehicle::IsValidID(index) && Vehicle::Get(index)->type == Type;
}
/**
* Gets vehicle with given index
* @return pointer to vehicle with given index casted to T *
*/
static FORCEINLINE T *Get(size_t index)
{
return (T *)Vehicle::Get(index);
}
/**
* Returns vehicle if the index is a valid index for this vehicle type
* @return pointer to vehicle with given index if it's a vehicle of this type
*/
static FORCEINLINE T *GetIfValid(size_t index)
{
return IsValidID(index) ? Get(index) : NULL;
}
/**
* Converts a Vehicle to SpecializedVehicle with type checking.
* @param v Vehicle pointer
* @return pointer to SpecializedVehicle
*/
static FORCEINLINE T *From(Vehicle *v)
{
assert(v->type == Type);
return (T *)v;
}
/**
* Converts a const Vehicle to const SpecializedVehicle with type checking.
* @param v Vehicle pointer
* @return pointer to SpecializedVehicle
*/
static FORCEINLINE const T *From(const Vehicle *v)
{
assert(v->type == Type);
return (const T *)v;
}
/**
* Update vehicle sprite- and position caches
* @param moved Was the vehicle moved?
* @param turned Did the vehicle direction change?
*/
FORCEINLINE void UpdateViewport(bool moved, bool turned)
{
extern void VehicleMove(Vehicle *v, bool update_viewport);
/* Explicitly choose method to call to prevent vtable dereference -
* it gives ~3% runtime improvements in games with many vehicles */
if (turned) ((T *)this)->T::UpdateDeltaXY(this->direction);
SpriteID old_image = this->cur_image;
this->cur_image = ((T *)this)->T::GetImage(this->direction);
if (moved || this->cur_image != old_image) VehicleMove(this, true);
}
};
/**
* Iterate over all vehicles of a particular type.
* @param name The type of vehicle to iterate over.
* @param var The variable used to iterate over.
*/
#define FOR_ALL_VEHICLES_OF_TYPE(name, var) FOR_ALL_ITEMS_FROM(name, vehicle_index, var, 0) if (var->type == name::EXPECTED_TYPE)
/**
* Disasters, like submarines, skyrangers and their shadows, belong to this class.
*/
struct DisasterVehicle : public SpecializedVehicle {
SpriteID image_override; ///< Override for the default disaster vehicle sprite.
VehicleID big_ufo_destroyer_target; ///< The big UFO that this destroyer is supposed to bomb.
/** We don't want GCC to zero our struct! It already is zeroed and has an index! */
DisasterVehicle() : SpecializedVehicleBase() {}
/** We want to 'destruct' the right class. */
virtual ~DisasterVehicle() {}
void UpdateDeltaXY(Direction direction);
bool Tick();
};
/**
* Iterate over disaster vehicles.
* @param var The variable used to iterate over.
*/
#define FOR_ALL_DISASTERVEHICLES(var) FOR_ALL_VEHICLES_OF_TYPE(DisasterVehicle, var)
/** Generates sequence of free UnitID numbers */
struct FreeUnitIDGenerator {
bool *cache; ///< array of occupied unit id numbers
UnitID maxid; ///< maximum ID at the moment of constructor call
UnitID curid; ///< last ID returned; 0 if none
FreeUnitIDGenerator(VehicleType type, CompanyID owner);
UnitID NextID();
/** Releases allocated memory */
~FreeUnitIDGenerator() { free(this->cache); }
};
/** Sentinel for an invalid coordinate. */
static const int32 INVALID_COORD = 0x7fffffff;
#endif /* VEHICLE_BASE_H */