2005-07-24 16:12:37 +02:00
|
|
|
/* $Id$ */
|
|
|
|
|
2009-08-21 22:21:05 +02:00
|
|
|
/*
|
|
|
|
* 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 <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2007-12-27 14:35:39 +01:00
|
|
|
/** @file vehicle_base.h Base class for all vehicles. */
|
2007-04-04 06:08:47 +02:00
|
|
|
|
2007-12-27 14:35:39 +01:00
|
|
|
#ifndef VEHICLE_BASE_H
|
|
|
|
#define VEHICLE_BASE_H
|
2004-08-09 19:04:08 +02:00
|
|
|
|
2007-12-18 21:38:16 +01:00
|
|
|
#include "track_type.h"
|
2007-12-23 11:56:02 +01:00
|
|
|
#include "command_type.h"
|
2008-03-31 01:24:18 +02:00
|
|
|
#include "order_base.h"
|
2007-06-22 13:58:59 +02:00
|
|
|
#include "cargopacket.h"
|
2007-06-21 18:17:47 +02:00
|
|
|
#include "texteff.hpp"
|
2008-03-28 19:00:38 +01:00
|
|
|
#include "engine_type.h"
|
2008-04-27 22:09:29 +02:00
|
|
|
#include "order_func.h"
|
2008-05-07 11:07:19 +02:00
|
|
|
#include "transport_type.h"
|
2010-08-18 17:15:59 +02:00
|
|
|
#include "group_type.h"
|
2007-02-13 11:26:53 +01:00
|
|
|
|
2010-11-05 17:34:22 +01:00
|
|
|
/** Vehicle status bits in #Vehicle::vehstatus. */
|
2005-05-03 01:59:11 +02:00
|
|
|
enum VehStatus {
|
2010-11-05 17:34:22 +01:00
|
|
|
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.
|
2005-05-03 01:59:11 +02:00
|
|
|
};
|
|
|
|
|
2010-11-05 17:34:22 +01:00
|
|
|
/** Bit numbers in #Vehicle::vehicle_flags. */
|
2007-02-28 18:18:36 +01:00
|
|
|
enum VehicleFlags {
|
2010-11-05 17:34:22 +01:00
|
|
|
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).
|
2008-11-19 00:53:37 +01:00
|
|
|
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
|
2010-08-16 00:37:30 +02:00
|
|
|
VF_STOP_LOADING, ///< Don't load anymore during the next load cycle.
|
2010-12-13 22:52:39 +01:00
|
|
|
VF_PATHFINDER_LOST, ///< Vehicle's pathfinder is lost.
|
2006-12-02 17:56:32 +01:00
|
|
|
};
|
|
|
|
|
2010-11-06 13:39:18 +01:00
|
|
|
/** 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.
|
2010-11-27 22:09:41 +01:00
|
|
|
NCVV_END, ///< End of the bits.
|
2010-11-06 13:39:18 +01:00
|
|
|
};
|
|
|
|
|
2010-11-05 16:48:30 +01:00
|
|
|
/** Cached often queried (NewGRF) values */
|
2010-11-06 13:37:55 +01:00
|
|
|
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.
|
2009-05-23 11:10:56 +02:00
|
|
|
};
|
|
|
|
|
2010-11-18 15:04:36 +01:00
|
|
|
/** 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
|
2010-11-18 15:20:03 +01:00
|
|
|
|
|
|
|
VE_DEFAULT = 0xFF, ///< Default value to indicate that visual effect should be based on engine class
|
2010-11-18 15:04:36 +01:00
|
|
|
};
|
|
|
|
|
2011-01-29 18:21:39 +01:00
|
|
|
/**
|
|
|
|
* 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).
|
|
|
|
};
|
|
|
|
|
2010-11-06 13:53:31 +01:00
|
|
|
/** 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).
|
2010-11-18 15:04:36 +01:00
|
|
|
|
|
|
|
byte cached_vis_effect; ///< Visual effect to show (see #VisualEffect)
|
2010-11-06 13:53:31 +01:00
|
|
|
};
|
|
|
|
|
2010-08-19 22:58:30 +02:00
|
|
|
/** A vehicle pool for a little over 1 million vehicles. */
|
|
|
|
typedef Pool<Vehicle, VehicleID, 512, 0xFF000> VehiclePool;
|
2009-05-22 17:13:50 +02:00
|
|
|
extern VehiclePool _vehicle_pool;
|
2004-08-09 19:04:08 +02:00
|
|
|
|
2007-09-08 00:06:52 +02:00
|
|
|
/* Some declarations of functions, so we can make them friendly */
|
2007-08-30 15:09:44 +02:00
|
|
|
struct SaveLoad;
|
2010-12-14 22:31:00 +01:00
|
|
|
struct GroundVehicleCache;
|
2007-09-08 00:06:52 +02:00
|
|
|
extern const SaveLoad *GetVehicleDescription(VehicleType vt);
|
|
|
|
struct LoadgameState;
|
|
|
|
extern bool LoadOldVehicle(LoadgameState *ls, int num);
|
2009-05-22 17:13:50 +02:00
|
|
|
extern void FixOldVehicles();
|
2007-08-30 15:09:44 +02:00
|
|
|
|
2011-01-29 22:37:11 +01:00
|
|
|
/** %Vehicle data structure. */
|
2009-05-22 17:13:50 +02:00
|
|
|
struct Vehicle : VehiclePool::PoolItem<&_vehicle_pool>, BaseVehicle {
|
2007-08-30 15:09:44 +02:00
|
|
|
private:
|
2010-11-05 16:48:30 +01:00
|
|
|
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
|
2008-08-17 21:56:17 +02:00
|
|
|
|
2010-11-05 16:48:30 +01:00
|
|
|
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
|
2007-08-30 15:09:44 +02:00
|
|
|
public:
|
2008-04-21 10:35:27 +02:00
|
|
|
friend const SaveLoad *GetVehicleDescription(VehicleType vt); ///< So we can use private/protected variables in the saveload code
|
2009-05-22 17:13:50 +02:00
|
|
|
friend void FixOldVehicles();
|
2011-05-14 20:35:40 +02:00
|
|
|
friend void AfterLoadVehicles(bool part_of_load); ///< So we can set the #previous and #first pointers while loading
|
2008-04-21 10:35:27 +02:00
|
|
|
friend bool LoadOldVehicle(LoadgameState *ls, int num); ///< So we can set the proper next pointer while loading
|
2007-08-30 15:09:44 +02:00
|
|
|
|
2010-11-05 16:48:30 +01:00
|
|
|
char *name; ///< Name of vehicle
|
2004-08-09 19:04:08 +02:00
|
|
|
|
2010-11-05 16:48:30 +01:00
|
|
|
TileIndex tile; ///< Current tile index
|
2008-12-20 12:51:52 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Heading for this tile.
|
|
|
|
* For airports and train stations this tile does not necessarily belong to the destination station,
|
2011-01-29 22:37:11 +01:00
|
|
|
* but it can be used for heuristic purposes to estimate the distance.
|
2008-12-20 12:51:52 +01:00
|
|
|
*/
|
|
|
|
TileIndex dest_tile;
|
2008-04-21 10:35:27 +02:00
|
|
|
|
2010-11-05 16:48:30 +01:00
|
|
|
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
|
2009-06-29 21:55:36 +02:00
|
|
|
|
2010-11-05 16:48:30 +01:00
|
|
|
CargoPayment *cargo_payment; ///< The cargo payment we're currently in
|
2004-08-09 19:04:08 +02:00
|
|
|
|
2008-04-21 10:35:27 +02:00
|
|
|
/* Used for timetabling. */
|
2010-11-05 16:48:30 +01:00
|
|
|
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.
|
2008-04-21 10:35:27 +02:00
|
|
|
|
2011-01-31 21:27:33 +01:00
|
|
|
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.
|
2008-04-21 10:35:27 +02:00
|
|
|
|
2010-11-05 16:48:30 +01:00
|
|
|
SpriteID colourmap; ///< NOSAVE: cached colour mapping
|
2008-04-21 10:35:27 +02:00
|
|
|
|
|
|
|
/* Related to age and service time */
|
2011-01-31 21:27:33 +01:00
|
|
|
Year build_year; ///< Year the vehicle has been built.
|
2010-11-05 16:48:30 +01:00
|
|
|
Date age; ///< Age in days
|
|
|
|
Date max_age; ///< Maximum age
|
2011-01-31 21:27:33 +01:00
|
|
|
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 %.
|
2010-11-05 17:34:22 +01:00
|
|
|
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.
|
2011-01-31 21:27:33 +01:00
|
|
|
byte breakdowns_since_last_service; ///< Counter for the amount of breakdowns.
|
|
|
|
byte breakdown_chance; ///< Current chance of breakdowns.
|
2004-08-09 19:04:08 +02:00
|
|
|
|
2010-11-05 16:48:30 +01:00
|
|
|
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
|
2011-01-04 13:04:09 +01:00
|
|
|
SpriteID cur_image; ///< sprite number for this vehicle
|
2010-11-05 16:48:30 +01:00
|
|
|
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
|
2011-01-31 21:27:33 +01:00
|
|
|
EngineID engine_type; ///< The type of engine used for this vehicle.
|
2004-08-09 19:04:08 +02:00
|
|
|
|
2010-11-05 16:48:30 +01:00
|
|
|
TextEffectID fill_percent_te_id; ///< a text-effect id to a loading indicator object
|
|
|
|
UnitID unitnumber; ///< unit number, for display purposes only
|
2008-04-21 10:35:27 +02:00
|
|
|
|
2010-11-05 16:48:30 +01:00
|
|
|
uint16 cur_speed; ///< current speed
|
|
|
|
byte subspeed; ///< fractional speed
|
|
|
|
byte acceleration; ///< used by train & aircraft
|
2011-01-31 21:27:33 +01:00
|
|
|
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.
|
2007-06-21 18:17:47 +02:00
|
|
|
|
2011-01-31 21:27:33 +01:00
|
|
|
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.
|
2004-08-09 19:04:08 +02:00
|
|
|
|
2011-01-31 21:27:33 +01:00
|
|
|
StationID last_station_visited; ///< The last station we stopped at.
|
2004-09-10 21:02:27 +02:00
|
|
|
|
2010-11-05 16:48:30 +01:00
|
|
|
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
|
2007-06-22 13:58:59 +02:00
|
|
|
|
2010-11-05 16:48:30 +01:00
|
|
|
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
|
2004-08-09 19:04:08 +02:00
|
|
|
|
2010-11-05 16:48:30 +01:00
|
|
|
byte vehstatus; ///< Status
|
|
|
|
Order current_order; ///< The current order (+ status, like: loading)
|
2011-05-18 14:19:58 +02:00
|
|
|
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
|
2005-01-15 20:06:22 +01:00
|
|
|
|
2009-01-03 14:52:06 +01:00
|
|
|
union {
|
2010-11-05 16:48:30 +01:00
|
|
|
OrderList *list; ///< Pointer to the order list for this vehicle
|
|
|
|
Order *old; ///< Only used during conversion of old save games
|
2011-01-31 21:27:33 +01:00
|
|
|
} orders; ///< The orders currently assigned to the vehicle.
|
2004-08-09 19:04:08 +02:00
|
|
|
|
2010-11-05 16:48:30 +01:00
|
|
|
byte vehicle_flags; ///< Used for gradual loading and other miscellaneous things (@see VehicleFlags enum)
|
2009-09-15 22:58:44 +02:00
|
|
|
|
2011-02-01 22:18:27 +01:00
|
|
|
uint16 load_unload_ticks; ///< Ticks to wait before starting next cycle.
|
2010-11-05 16:48:30 +01:00
|
|
|
GroupID group_id; ///< Index of group Pool array
|
|
|
|
byte subtype; ///< subtype (Filled with values from #EffectVehicles/#TrainSubTypes/#AircraftSubTypes)
|
2007-10-28 16:40:18 +01:00
|
|
|
|
2010-11-06 13:37:55 +01:00
|
|
|
NewGRFCache grf_cache; ///< Cache of often used calculated NewGRF values
|
2010-11-06 13:53:31 +01:00
|
|
|
VehicleCache vcache; ///< Cache of often used vehicle values.
|
2007-08-03 21:36:00 +02:00
|
|
|
|
2009-05-30 22:13:12 +02:00
|
|
|
Vehicle(VehicleType type = VEH_INVALID);
|
2007-08-03 21:36:00 +02:00
|
|
|
|
2007-08-05 19:43:04 +02:00
|
|
|
void PreDestructor();
|
2007-08-03 21:36:00 +02:00
|
|
|
/** We want to 'destruct' the right class. */
|
|
|
|
virtual ~Vehicle();
|
|
|
|
|
2007-01-13 19:55:54 +01:00
|
|
|
void BeginLoading();
|
|
|
|
void LeaveStation();
|
2007-04-29 23:24:08 +02:00
|
|
|
|
2010-12-14 22:31:00 +01:00
|
|
|
GroundVehicleCache *GetGroundVehicleCache();
|
|
|
|
const GroundVehicleCache *GetGroundVehicleCache() const;
|
|
|
|
|
2011-04-16 18:41:02 +02:00
|
|
|
uint16 &GetGroundVehicleFlags();
|
|
|
|
const uint16 &GetGroundVehicleFlags() const;
|
|
|
|
|
2011-05-18 14:19:58 +02:00
|
|
|
void DeleteUnreachedImplicitOrders();
|
2011-01-15 19:14:29 +01:00
|
|
|
|
2007-05-07 18:21:34 +02:00
|
|
|
void HandleLoading(bool mode = false);
|
|
|
|
|
2007-04-30 00:33:51 +02:00
|
|
|
/**
|
|
|
|
* Marks the vehicles to be redrawn and updates cached variables
|
2007-09-09 12:13:17 +02:00
|
|
|
*
|
|
|
|
* This method marks the area of the vehicle on the screen as dirty.
|
|
|
|
* It can be use to repaint the vehicle.
|
|
|
|
*
|
|
|
|
* @ingroup dirty
|
2007-04-30 00:33:51 +02:00
|
|
|
*/
|
|
|
|
virtual void MarkDirty() {}
|
2007-05-01 18:35:14 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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) {}
|
2007-05-02 11:29:41 +02:00
|
|
|
|
2010-07-04 15:07:47 +02:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2007-05-02 11:29:41 +02:00
|
|
|
/**
|
|
|
|
* Sets the expense type associated to this vehicle type
|
|
|
|
* @param income whether this is income or (running) expenses of the vehicle
|
|
|
|
*/
|
2007-05-02 11:39:11 +02:00
|
|
|
virtual ExpensesType GetExpenseType(bool income) const { return EXPENSES_OTHER; }
|
2007-05-02 11:29:41 +02:00
|
|
|
|
2007-05-07 17:58:05 +02:00
|
|
|
/**
|
|
|
|
* Play the sound associated with leaving the station
|
|
|
|
*/
|
|
|
|
virtual void PlayLeaveStationSound() const {}
|
2007-06-01 14:03:10 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Whether this is the primary vehicle in the chain.
|
|
|
|
*/
|
|
|
|
virtual bool IsPrimaryVehicle() const { return false; }
|
|
|
|
|
2007-07-01 21:11:47 +02:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*/
|
2008-04-21 22:50:58 +02:00
|
|
|
virtual SpriteID GetImage(Direction direction) const { return 0; }
|
2007-07-01 21:24:54 +02:00
|
|
|
|
2009-05-31 14:03:14 +02:00
|
|
|
/**
|
|
|
|
* Invalidates cached NewGRF variables
|
|
|
|
* @see InvalidateNewGRFCacheOfChain
|
|
|
|
*/
|
|
|
|
FORCEINLINE void InvalidateNewGRFCache()
|
|
|
|
{
|
2010-11-06 13:37:55 +01:00
|
|
|
this->grf_cache.cache_valid = 0;
|
2009-05-31 14:03:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-14 22:26:03 +01:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2007-08-26 22:43:22 +02:00
|
|
|
/**
|
2009-02-01 18:14:39 +01:00
|
|
|
* Gets the speed in km-ish/h that can be sent into SetDParam for string processing.
|
2007-08-26 22:43:22 +02:00
|
|
|
* @return the vehicle's speed
|
|
|
|
*/
|
|
|
|
virtual int GetDisplaySpeed() const { return 0; }
|
|
|
|
|
2007-08-28 08:46:33 +02:00
|
|
|
/**
|
2009-02-01 18:14:39 +01:00
|
|
|
* Gets the maximum speed in km-ish/h that can be sent into SetDParam for string processing.
|
2007-08-28 08:46:33 +02:00
|
|
|
* @return the vehicle's maximum speed
|
|
|
|
*/
|
|
|
|
virtual int GetDisplayMaxSpeed() const { return 0; }
|
|
|
|
|
2007-08-29 23:27:16 +02:00
|
|
|
/**
|
|
|
|
* Gets the running cost of a vehicle
|
|
|
|
* @return the vehicle's running cost
|
|
|
|
*/
|
|
|
|
virtual Money GetRunningCost() const { return 0; }
|
|
|
|
|
2007-08-29 23:49:08 +02:00
|
|
|
/**
|
|
|
|
* 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; }
|
|
|
|
|
2007-07-01 21:24:54 +02:00
|
|
|
/**
|
|
|
|
* Calls the tick handler of the vehicle
|
2009-05-22 15:53:14 +02:00
|
|
|
* @return is this vehicle still valid?
|
2007-07-01 21:24:54 +02:00
|
|
|
*/
|
2009-05-22 15:53:14 +02:00
|
|
|
virtual bool Tick() { return true; };
|
2007-08-02 23:19:07 +02:00
|
|
|
|
2008-02-01 23:02:14 +01:00
|
|
|
/**
|
|
|
|
* Calls the new day handler of the vehicle
|
|
|
|
*/
|
|
|
|
virtual void OnNewDay() {};
|
|
|
|
|
2009-12-04 21:29:46 +01:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2009-05-22 20:17:20 +02:00
|
|
|
/**
|
|
|
|
* 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; }
|
|
|
|
|
2007-08-29 23:27:16 +02:00
|
|
|
/**
|
|
|
|
* 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); }
|
|
|
|
|
2008-02-20 18:06:58 +01:00
|
|
|
/**
|
|
|
|
* 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); }
|
|
|
|
|
2007-08-30 23:11:12 +02:00
|
|
|
void SetNext(Vehicle *next);
|
2007-08-30 15:03:56 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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; }
|
2007-08-30 23:11:12 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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; }
|
2008-02-02 03:45:09 +01:00
|
|
|
|
2009-07-20 21:58:33 +02:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
2008-08-17 21:56:17 +02:00
|
|
|
|
2009-01-03 14:52:06 +01:00
|
|
|
/**
|
|
|
|
* 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(); }
|
|
|
|
|
2008-08-17 21:56:17 +02:00
|
|
|
void AddToShared(Vehicle *shared_chain);
|
|
|
|
void RemoveFromShared();
|
|
|
|
|
|
|
|
/**
|
2009-01-03 14:52:06 +01:00
|
|
|
* Get the next vehicle of the shared vehicle chain.
|
|
|
|
* @return the next shared vehicle or NULL when there isn't a next vehicle.
|
2008-08-17 21:56:17 +02:00
|
|
|
*/
|
|
|
|
inline Vehicle *NextShared() const { return this->next_shared; }
|
|
|
|
|
2009-01-03 14:52:06 +01:00
|
|
|
/**
|
|
|
|
* 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; }
|
|
|
|
|
2008-08-17 21:56:17 +02:00
|
|
|
/**
|
|
|
|
* Get the first vehicle of this vehicle chain.
|
|
|
|
* @return the first vehicle of the chain.
|
|
|
|
*/
|
2009-02-05 16:58:42 +01:00
|
|
|
inline Vehicle *FirstShared() const { return (this->orders.list == NULL) ? this->First() : this->orders.list->GetFirstSharedVehicle(); }
|
2008-08-17 21:56:17 +02:00
|
|
|
|
2008-02-02 03:45:09 +01:00
|
|
|
/**
|
|
|
|
* Check if we share our orders with another vehicle.
|
|
|
|
* @return true if there are other vehicles sharing the same order
|
|
|
|
*/
|
2009-01-03 14:52:06 +01:00
|
|
|
inline bool IsOrderListShared() const { return this->orders.list != NULL && this->orders.list->IsShared(); }
|
2008-02-23 23:01:55 +01:00
|
|
|
|
2009-01-03 14:52:06 +01:00
|
|
|
/**
|
2009-01-03 14:20:32 +01:00
|
|
|
* Get the number of orders this vehicle has.
|
|
|
|
* @return the number of orders this vehicle has.
|
|
|
|
*/
|
2009-01-03 14:52:06 +01:00
|
|
|
inline VehicleOrderID GetNumOrders() const { return (this->orders.list == NULL) ? 0 : this->orders.list->GetNumOrders(); }
|
2009-01-03 14:20:32 +01:00
|
|
|
|
2010-12-26 14:25:34 +01:00
|
|
|
/**
|
|
|
|
* 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(); }
|
|
|
|
|
2008-08-16 16:02:20 +02:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
|
2011-01-31 21:44:15 +01:00
|
|
|
this->cur_real_order_index = src->cur_real_order_index;
|
2011-05-18 14:19:58 +02:00
|
|
|
this->cur_implicit_order_index = src->cur_implicit_order_index;
|
2008-08-16 16:02:20 +02:00
|
|
|
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;
|
2009-11-26 15:56:17 +01:00
|
|
|
this->timetable_start = src->timetable_start;
|
2008-08-16 16:02:20 +02:00
|
|
|
|
2010-01-27 21:07:29 +01:00
|
|
|
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);
|
|
|
|
|
2008-08-16 16:02:20 +02:00
|
|
|
this->service_interval = src->service_interval;
|
|
|
|
}
|
|
|
|
|
2010-08-28 16:14:37 +02:00
|
|
|
|
|
|
|
bool HandleBreakdown();
|
2010-08-28 16:01:50 +02:00
|
|
|
|
2008-09-30 22:39:50 +02:00
|
|
|
bool NeedsAutorenewing(const Company *c) const;
|
2008-04-05 12:55:50 +02:00
|
|
|
|
2008-04-08 17:48:32 +02:00
|
|
|
bool NeedsServicing() const;
|
|
|
|
bool NeedsAutomaticServicing() const;
|
|
|
|
|
2008-04-05 12:55:50 +02:00
|
|
|
/**
|
|
|
|
* 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; }
|
2008-04-11 10:14:43 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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; }
|
2008-04-11 10:40:10 +02:00
|
|
|
|
2009-02-09 22:20:05 +01:00
|
|
|
CommandCost SendToDepot(DoCommandFlag flags, DepotCommand command);
|
2009-05-09 15:37:18 +02:00
|
|
|
|
2010-11-18 15:09:39 +01:00
|
|
|
void UpdateVisualEffect(bool allow_power_change = true);
|
2010-11-18 15:15:27 +01:00
|
|
|
void ShowVisualEffect() const;
|
|
|
|
|
2011-01-31 21:44:15 +01:00
|
|
|
private:
|
2009-05-09 15:37:18 +02:00
|
|
|
/**
|
2011-01-31 21:44:15 +01:00
|
|
|
* Advance cur_real_order_index to the next real order.
|
2011-05-18 14:19:58 +02:00
|
|
|
* cur_implicit_order_index is not touched.
|
2011-01-31 21:44:15 +01:00
|
|
|
*/
|
|
|
|
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;
|
2011-05-18 14:19:58 +02:00
|
|
|
} while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT));
|
2011-01-31 21:44:15 +01:00
|
|
|
} else {
|
|
|
|
this->cur_real_order_index = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
/**
|
2011-05-18 14:19:58 +02:00
|
|
|
* Increments cur_implicit_order_index, keeps care of the wrap-around and invalidates the GUI.
|
2011-01-31 21:44:15 +01:00
|
|
|
* cur_real_order_index is incremented as well, if needed.
|
2009-05-09 15:37:18 +02:00
|
|
|
* Note: current_order is not invalidated.
|
|
|
|
*/
|
2011-05-18 14:19:58 +02:00
|
|
|
void IncrementImplicitOrderIndex()
|
2009-05-09 16:23:19 +02:00
|
|
|
{
|
2011-05-18 14:19:58 +02:00
|
|
|
if (this->cur_implicit_order_index == this->cur_real_order_index) {
|
2011-01-31 21:44:15 +01:00
|
|
|
/* Increment real order index as well */
|
|
|
|
this->SkipToNextRealOrderIndex();
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(this->cur_real_order_index == 0 || this->cur_real_order_index < this->GetNumOrders());
|
|
|
|
|
2011-05-18 14:19:58 +02:00
|
|
|
/* Advance to next implicit order */
|
2011-01-31 21:44:15 +01:00
|
|
|
do {
|
2011-05-18 14:19:58 +02:00
|
|
|
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));
|
2011-01-31 21:44:15 +01:00
|
|
|
|
2009-05-09 15:37:18 +02:00
|
|
|
InvalidateVehicleOrder(this, 0);
|
|
|
|
}
|
2009-05-23 14:27:42 +02:00
|
|
|
|
2011-01-31 21:44:15 +01:00
|
|
|
/**
|
|
|
|
* Advanced cur_real_order_index to the next real order, keeps care of the wrap-around and invalidates the GUI.
|
2011-05-18 14:19:58 +02:00
|
|
|
* 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.
|
2011-01-31 21:44:15 +01:00
|
|
|
* Note: current_order is not invalidated.
|
|
|
|
*/
|
|
|
|
void IncrementRealOrderIndex()
|
|
|
|
{
|
2011-05-18 14:19:58 +02:00
|
|
|
if (this->cur_implicit_order_index == this->cur_real_order_index) {
|
|
|
|
/* Increment both real and implicit order */
|
|
|
|
this->IncrementImplicitOrderIndex();
|
2011-01-31 21:44:15 +01:00
|
|
|
} else {
|
|
|
|
/* Increment real order only */
|
|
|
|
this->SkipToNextRealOrderIndex();
|
|
|
|
InvalidateVehicleOrder(this, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-05-18 14:19:58 +02:00
|
|
|
* Skip implicit orders until cur_real_order_index is a non-implicit order.
|
2011-01-31 21:44:15 +01:00
|
|
|
*/
|
|
|
|
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 */
|
2011-05-18 14:19:58 +02:00
|
|
|
while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT)) {
|
2011-01-31 21:44:15 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-23 14:27:42 +02:00
|
|
|
/**
|
|
|
|
* 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();
|
|
|
|
}
|
2009-07-13 18:35:22 +02:00
|
|
|
|
|
|
|
bool IsEngineCountable() const;
|
2010-12-11 14:48:30 +01:00
|
|
|
bool HasDepotOrder() const;
|
2010-12-13 22:55:06 +01:00
|
|
|
void HandlePathfindingResult(bool path_found);
|
2011-01-29 18:26:23 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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();
|
|
|
|
}
|
2011-01-29 18:27:32 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
2007-04-29 23:24:08 +02:00
|
|
|
};
|
|
|
|
|
2011-01-31 21:27:33 +01:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2009-05-27 00:45:48 +02:00
|
|
|
#define FOR_ALL_VEHICLES_FROM(var, start) FOR_ALL_ITEMS_FROM(Vehicle, vehicle_index, var, start)
|
2011-01-31 21:27:33 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Iterate over all vehicles.
|
|
|
|
* @param var The variable used to iterate over.
|
|
|
|
*/
|
2009-05-27 00:45:48 +02:00
|
|
|
#define FOR_ALL_VEHICLES(var) FOR_ALL_VEHICLES_FROM(var, 0)
|
|
|
|
|
2009-05-27 00:10:13 +02:00
|
|
|
/**
|
|
|
|
* Class defining several overloaded accessors so we don't
|
|
|
|
* have to cast vehicle types that often
|
|
|
|
*/
|
|
|
|
template <class T, VehicleType Type>
|
|
|
|
struct SpecializedVehicle : public Vehicle {
|
|
|
|
static const VehicleType EXPECTED_TYPE = Type; ///< Specialized type
|
|
|
|
|
2011-01-21 15:43:38 +01:00
|
|
|
typedef SpecializedVehicle<T, Type> SpecializedVehicleBase; ///< Our type
|
|
|
|
|
2009-05-30 22:13:12 +02:00
|
|
|
/**
|
|
|
|
* Set vehicle type correctly
|
|
|
|
*/
|
|
|
|
FORCEINLINE SpecializedVehicle<T, Type>() : Vehicle(Type) { }
|
|
|
|
|
2009-05-27 00:10:13 +02:00
|
|
|
/**
|
|
|
|
* Get the first vehicle in the chain
|
|
|
|
* @return first vehicle in the chain
|
|
|
|
*/
|
|
|
|
FORCEINLINE T *First() const { return (T *)this->Vehicle::First(); }
|
|
|
|
|
2009-07-20 21:58:33 +02:00
|
|
|
/**
|
|
|
|
* 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(); }
|
|
|
|
|
2009-05-27 00:10:13 +02:00
|
|
|
/**
|
|
|
|
* 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(); }
|
|
|
|
|
2011-01-29 18:27:32 +01:00
|
|
|
/**
|
|
|
|
* 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(); }
|
2009-05-27 00:10:13 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2009-11-29 20:20:39 +01:00
|
|
|
return IsValidID(index) ? Get(index) : NULL;
|
2009-05-27 00:10:13 +02:00
|
|
|
}
|
2009-06-06 18:54:22 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
2010-05-04 01:36:17 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
}
|
2009-05-27 00:10:13 +02:00
|
|
|
};
|
|
|
|
|
2011-01-31 21:27:33 +01:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2009-05-27 00:10:13 +02:00
|
|
|
#define FOR_ALL_VEHICLES_OF_TYPE(name, var) FOR_ALL_ITEMS_FROM(name, vehicle_index, var, 0) if (var->type == name::EXPECTED_TYPE)
|
|
|
|
|
2007-04-29 23:24:08 +02:00
|
|
|
/**
|
2009-05-27 01:24:34 +02:00
|
|
|
* Disasters, like submarines, skyrangers and their shadows, belong to this class.
|
2007-04-29 23:24:08 +02:00
|
|
|
*/
|
2009-05-27 00:10:13 +02:00
|
|
|
struct DisasterVehicle : public SpecializedVehicle<DisasterVehicle, VEH_DISASTER> {
|
2011-01-31 21:27:33 +01:00
|
|
|
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.
|
2009-05-22 20:57:11 +02:00
|
|
|
|
2009-06-02 21:12:28 +02:00
|
|
|
/** We don't want GCC to zero our struct! It already is zeroed and has an index! */
|
2011-01-21 15:43:38 +01:00
|
|
|
DisasterVehicle() : SpecializedVehicleBase() {}
|
2007-04-29 23:24:08 +02:00
|
|
|
/** We want to 'destruct' the right class. */
|
|
|
|
virtual ~DisasterVehicle() {}
|
|
|
|
|
2007-05-01 18:35:14 +02:00
|
|
|
void UpdateDeltaXY(Direction direction);
|
2009-05-22 15:53:14 +02:00
|
|
|
bool Tick();
|
2007-04-29 23:24:08 +02:00
|
|
|
};
|
|
|
|
|
2011-01-31 21:27:33 +01:00
|
|
|
/**
|
|
|
|
* Iterate over disaster vehicles.
|
|
|
|
* @param var The variable used to iterate over.
|
|
|
|
*/
|
2009-05-27 00:45:48 +02:00
|
|
|
#define FOR_ALL_DISASTERVEHICLES(var) FOR_ALL_VEHICLES_OF_TYPE(DisasterVehicle, var)
|
2008-12-27 00:53:07 +01:00
|
|
|
|
|
|
|
/** 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
|
2009-11-29 20:20:39 +01:00
|
|
|
UnitID curid; ///< last ID returned; 0 if none
|
2008-12-27 00:53:07 +01:00
|
|
|
|
|
|
|
FreeUnitIDGenerator(VehicleType type, CompanyID owner);
|
|
|
|
UnitID NextID();
|
|
|
|
|
|
|
|
/** Releases allocated memory */
|
|
|
|
~FreeUnitIDGenerator() { free(this->cache); }
|
|
|
|
};
|
|
|
|
|
2011-01-31 21:27:33 +01:00
|
|
|
/** Sentinel for an invalid coordinate. */
|
2009-01-04 16:32:25 +01:00
|
|
|
static const int32 INVALID_COORD = 0x7fffffff;
|
|
|
|
|
2007-12-27 14:35:39 +01:00
|
|
|
#endif /* VEHICLE_BASE_H */
|