Fix #9521: Don't load at just removed docks that were part of a multi-dock station...

[openttd-github.git] / src / vehicle_base.h

/*
 * 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/>.
 */

/** @file  vehicle_base.h Base class for all vehicles. */

#ifndef VEHICLE_BASE_H
#define VEHICLE_BASE_H

#include "core/smallmap_type.hpp"
#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"
#include "base_consist.h"
#include "network/network.h"
#include "saveload/saveload.h"
#include <list>
#include <map>

/** 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.
        VF_SERVINT_IS_CUSTOM,       ///< Service interval is custom.
        VF_SERVINT_IS_PERCENT,      ///< Service interval is percent.
};

/** 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_POSITION_IN_VEHICLE       = 4, ///< This bit will be set if the NewGRF var 4D 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. (Note: The cargotype is untranslated in the cache because the accessing GRF is yet unknown.)
        uint32 company_information;       ///< Cache for NewGRF var 43.
        uint32 position_in_vehicle;       ///< Cache for NewGRF var 4D.
        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_ADVANCED_EFFECT     = VE_DISABLE_EFFECT, ///< Flag for advanced effects
        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
};

/** Models for spawning visual effects. */
enum VisualEffectSpawnModel {
        VESM_NONE              = 0, ///< No visual effect
        VESM_STEAM,                 ///< Steam model
        VESM_DIESEL,                ///< Diesel model
        VESM_ELECTRIC,              ///< Electric model

        VESM_END
};

/**
 * 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).
        uint16 cached_cargo_age_period; ///< Number of ticks before carried cargo is aged.

        byte cached_vis_effect;  ///< Visual effect to show (see #VisualEffect)
};

/** Sprite sequence for a vehicle part. */
struct VehicleSpriteSeq {
        PalSpriteID seq[4];
        uint count;

        bool operator==(const VehicleSpriteSeq &other) const
        {
                return this->count == other.count && MemCmpT<PalSpriteID>(this->seq, other.seq, this->count) == 0;
        }

        bool operator!=(const VehicleSpriteSeq &other) const
        {
                return !this->operator==(other);
        }

        /**
         * Check whether the sequence contains any sprites.
         */
        bool IsValid() const
        {
                return this->count != 0;
        }

        /**
         * Clear all information.
         */
        void Clear()
        {
                this->count = 0;
        }

        /**
         * Assign a single sprite to the sequence.
         */
        void Set(SpriteID sprite)
        {
                this->count = 1;
                this->seq[0].sprite = sprite;
                this->seq[0].pal = 0;
        }

        /**
         * Copy data from another sprite sequence, while dropping all recolouring information.
         */
        void CopyWithoutPalette(const VehicleSpriteSeq &src)
        {
                this->count = src.count;
                for (uint i = 0; i < src.count; ++i) {
                        this->seq[i].sprite = src.seq[i].sprite;
                        this->seq[i].pal = 0;
                }
        }

        void GetBounds(Rect *bounds) const;
        void Draw(int x, int y, PaletteID default_pal, bool force_pal) const;
};

/**
 * Cache for vehicle sprites and values relating to whether they should be updated before drawing,
 * or calculating the viewport.
 */
struct MutableSpriteCache {
        Direction last_direction;     ///< Last direction we obtained sprites for
        bool revalidate_before_draw;  ///< We need to do a GetImage() and check bounds before drawing this sprite
        Rect old_coord;               ///< Co-ordinates from the last valid bounding box
        bool is_viewport_candidate;   ///< This vehicle can potentially be drawn on a viewport
        VehicleSpriteSeq sprite_seq;  ///< Vehicle appearance.
};

/** A vehicle pool for a little over 1 million vehicles. */
typedef Pool<Vehicle, VehicleID, 512, 0xFF000> VehiclePool;
extern VehiclePool _vehicle_pool;

/* Some declarations of functions, so we can make them friendly */
struct GroundVehicleCache;
struct LoadgameState;
extern bool LoadOldVehicle(LoadgameState *ls, int num);
extern void FixOldVehicles();

struct GRFFile;

/**
 * Simulated cargo type and capacity for prediction of future links.
 */
struct RefitDesc {
        CargoID cargo;    ///< Cargo type the vehicle will be carrying.
        uint16 capacity;  ///< Capacity the vehicle will have.
        uint16 remaining; ///< Capacity remaining from before the previous refit.
        RefitDesc(CargoID cargo, uint16 capacity, uint16 remaining) :
                        cargo(cargo), capacity(capacity), remaining(remaining) {}
};

/** %Vehicle data structure. */
struct Vehicle : VehiclePool::PoolItem<&_vehicle_pool>, BaseVehicle, BaseConsist {
private:
        typedef std::list<RefitDesc> RefitList;
        typedef std::map<CargoID, uint> CapacitiesMap;

        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 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
        /* So we can use private/protected variables in the saveload code */
        friend class SlVehicleCommon;
        friend class SlVehicleDisaster;
        friend void Ptrs_VEHS();

        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

        mutable Rect coord;                 ///< NOSAVE: Graphical bounding box of the vehicle, i.e. what to redraw on moves.

        Vehicle *hash_viewport_next;        ///< NOSAVE: Next vehicle in the visual location hash.
        Vehicle **hash_viewport_prev;       ///< NOSAVE: Previous vehicle in the visual location hash.

        Vehicle *hash_tile_next;            ///< NOSAVE: Next vehicle in the tile location hash.
        Vehicle **hash_tile_prev;           ///< NOSAVE: Previous vehicle in the tile location hash.
        Vehicle **hash_tile_current;        ///< 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.
        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.
        int32 z_pos;                        ///< z coordinate.
        Direction direction;                ///< facing

        Owner owner;                        ///< Which company owns the vehicle?
        /**
         * currently displayed sprite index
         * 0xfd == custom sprite, 0xfe == custom second head sprite
         * 0xff == reserved for another custom sprite
         */
        byte spritenum;
        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_bb_offs;                     ///< x offset of vehicle bounding box
        int8 y_bb_offs;                     ///< y offset 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.
        StationID last_loading_station;     ///< Last station the vehicle has stopped at and could possibly leave from with any cargo loaded.

        CargoID cargo_type;                 ///< type of cargo this vehicle is carrying
        byte cargo_subtype;                 ///< Used for livery refits (NewGRF variations)
        uint16 cargo_cap;                   ///< total capacity
        uint16 refit_cap;                   ///< Capacity left over from before last refit.
        VehicleCargoList cargo;             ///< The cargo this vehicle is carrying
        uint16 cargo_age_counter;           ///< Ticks till cargo is aged next.
        int8 trip_occupancy;                ///< NOSAVE: Occupancy of vehicle of the current trip (updated after leaving a station).

        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)

        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.

        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 #AircraftSubType/#DisasterSubType/#EffectVehicleType/#GroundVehicleSubtypeFlags)

        NewGRFCache grf_cache;              ///< Cache of often used calculated NewGRF values
        VehicleCache vcache;                ///< Cache of often used vehicle values.

        mutable MutableSpriteCache sprite_cache; ///< Cache of sprites and values related to recalculating them, see #MutableSpriteCache

        Vehicle(VehicleType type = VEH_INVALID);

        void PreDestructor();
        /** We want to 'destruct' the right class. */
        virtual ~Vehicle();

        void BeginLoading();
        void CancelReservation(StationID next, Station *st);
        void LeaveStation();

        GroundVehicleCache *GetGroundVehicleCache();
        const GroundVehicleCache *GetGroundVehicleCache() const;

        uint16 &GetGroundVehicleFlags();
        const uint16 &GetGroundVehicleFlags() const;

        void DeleteUnreachedImplicitOrders();

        void HandleLoading(bool mode = false);

        void GetConsistFreeCapacities(SmallMap<CargoID, uint> &capacities) const;

        uint GetConsistTotalCapacity() const;

        /**
         * 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.
         */
        virtual void UpdateDeltaXY() {}

        /**
         * 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.
         */
        inline 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 inline 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.
         */
        inline 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; }

        const Engine *GetEngine() const;

        /**
         * Gets the sprite to show for the given direction
         * @param direction the direction the vehicle is facing
         * @param[out] result Vehicle sprite sequence.
         */
        virtual void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const { result->Clear(); }

        const GRFFile *GetGRF() const;
        uint32 GetGRFID() const;

        /**
         * Invalidates cached NewGRF variables
         * @see InvalidateNewGRFCacheOfChain
         */
        inline void InvalidateNewGRFCache()
        {
                this->grf_cache.cache_valid = 0;
        }

        /**
         * Invalidates cached NewGRF variables of all vehicles in the chain (after the current vehicle)
         * @see InvalidateNewGRFCache
         */
        inline void InvalidateNewGRFCacheOfChain()
        {
                for (Vehicle *u = this; u != nullptr; 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.
         */
        inline 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; }

        /**
         * Calculates the maximum speed of the vehicle under its current conditions.
         * @return Current maximum speed in native units.
         */
        virtual int GetCurrentMaxSpeed() 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 whole vehicle chain is in the depot.
         * @return true if and only if the whole chain is in the depot.
         */
        virtual bool IsChainInDepot() const { return this->IsInDepot(); }

        /**
         * Check whether the vehicle is in the depot *and* stopped.
         * @return true if and only if the vehicle is in the depot and stopped.
         */
        bool IsStoppedInDepot() const
        {
                assert(this == this->First());
                /* Free wagons have no VS_STOPPED state */
                if (this->IsPrimaryVehicle() && !(this->vehstatus & VS_STOPPED)) return false;
                return this->IsChainInDepot();
        }

        /**
         * 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 nullptr 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 nullptr 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() != nullptr) 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() != nullptr) v = v->Next();
                return v;
        }

        /**
         * Get the vehicle at offset \a n of this vehicle chain.
         * @param n Offset from the current vehicle.
         * @return The new vehicle or nullptr if the offset is out-of-bounds.
         */
        inline Vehicle *Move(int n)
        {
                Vehicle *v = this;
                if (n < 0) {
                        for (int i = 0; i != n && v != nullptr; i--) v = v->Previous();
                } else {
                        for (int i = 0; i != n && v != nullptr; i++) v = v->Next();
                }
                return v;
        }

        /**
         * Get the vehicle at offset \a n of this vehicle chain.
         * @param n Offset from the current vehicle.
         * @return The new vehicle or nullptr if the offset is out-of-bounds.
         */
        inline const Vehicle *Move(int n) const
        {
                const Vehicle *v = this;
                if (n < 0) {
                        for (int i = 0; i != n && v != nullptr; i--) v = v->Previous();
                } else {
                        for (int i = 0; i != n && v != nullptr; i++) 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 == nullptr) ? nullptr : 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 nullptr 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 nullptr 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 == nullptr) ? 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 != nullptr && 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 == nullptr) ? 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 == nullptr) ? 0 : this->orders.list->GetNumManualOrders(); }

        /**
         * Get the next station the vehicle will stop at.
         * @return ID of the next station the vehicle will stop at or INVALID_STATION.
         */
        inline StationIDStack GetNextStoppingStation() const
        {
                return (this->orders.list == nullptr) ? INVALID_STATION : this->orders.list->GetNextStoppingStation(this);
        }

        void ResetRefitCaps();

        /**
         * 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->CopyConsistPropertiesFrom(src);

                this->unitnumber = src->unitnumber;

                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;
        }


        bool HandleBreakdown();

        bool NeedsAutorenewing(const Company *c, bool use_renew_setting = true) 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; }

        virtual void SetDestTile(TileIndex tile) { this->dest_tile = tile; }

        CommandCost SendToDepot(DoCommandFlag flags, DepotCommand command);

        void UpdateVisualEffect(bool allow_power_change = true);
        void ShowVisualEffect() const;

        void UpdatePosition();
        void UpdateViewport(bool dirty);
        void UpdateBoundingBoxCoordinates(bool update_cache) const;
        void UpdatePositionAndViewport();
        bool MarkAllViewportsDirty() const;

        inline uint16 GetServiceInterval() const { return this->service_interval; }

        inline void SetServiceInterval(uint16 interval) { this->service_interval = interval; }

        inline bool ServiceIntervalIsCustom() const { return HasBit(this->vehicle_flags, VF_SERVINT_IS_CUSTOM); }

        inline bool ServiceIntervalIsPercent() const { return HasBit(this->vehicle_flags, VF_SERVINT_IS_PERCENT); }

        inline void SetServiceIntervalIsCustom(bool on) { SB(this->vehicle_flags, VF_SERVINT_IS_CUSTOM, 1, on); }

        inline void SetServiceIntervalIsPercent(bool on) { SB(this->vehicle_flags, VF_SERVINT_IS_PERCENT, 1, on); }

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 nullptr 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 == nullptr) ? nullptr : this->orders.list->GetOrderAt(index);
        }

        /**
         * Returns the last order of a vehicle, or nullptr if it doesn't exists
         * @return last order of a vehicle, if available
         */
        inline Order *GetLastOrder() const
        {
                return (this->orders.list == nullptr) ? nullptr : this->orders.list->GetLastOrder();
        }

        bool IsEngineCountable() const;
        bool HasEngineType() 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.
         */
        inline 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.
         */
        inline 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.
         */
        inline bool HasArticulatedPart() const
        {
                return this->Next() != nullptr && 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.
         */
        inline Vehicle *GetNextArticulatedPart() const
        {
                assert(this->HasArticulatedPart());
                return this->Next();
        }

        /**
         * Get the first part of an articulated engine.
         * @return First part of the engine.
         */
        inline 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.
         */
        inline 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.
         */
        inline 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.
         */
        inline 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.
         */
        inline Vehicle *GetPrevVehicle() const
        {
                Vehicle *v = this->Previous();
                while (v != nullptr && v->IsArticulatedPart()) v = v->Previous();

                return v;
        }

        /**
         * Iterator to iterate orders
         * Supports deletion of current order
         */
        struct OrderIterator {
                typedef Order value_type;
                typedef Order* pointer;
                typedef Order& reference;
                typedef size_t difference_type;
                typedef std::forward_iterator_tag iterator_category;

                explicit OrderIterator(OrderList *list) : list(list), prev(nullptr)
                {
                        this->order = (this->list == nullptr) ? nullptr : this->list->GetFirstOrder();
                }

                bool operator==(const OrderIterator &other) const { return this->order == other.order; }
                bool operator!=(const OrderIterator &other) const { return !(*this == other); }
                Order * operator*() const { return this->order; }
                OrderIterator & operator++()
                {
                        this->prev = (this->prev == nullptr) ? this->list->GetFirstOrder() : this->prev->next;
                        this->order = (this->prev == nullptr) ? nullptr : this->prev->next;
                        return *this;
                }

        private:
                OrderList *list;
                Order *order;
                Order *prev;
        };

        /**
         * Iterable ensemble of orders
         */
        struct IterateWrapper {
                OrderList *list;
                IterateWrapper(OrderList *list = nullptr) : list(list) {}
                OrderIterator begin() { return OrderIterator(this->list); }
                OrderIterator end() { return OrderIterator(nullptr); }
                bool empty() { return this->begin() == this->end(); }
        };

        /**
         * Returns an iterable ensemble of orders of a vehicle
         * @return an iterable ensemble of orders of a vehicle
         */
        IterateWrapper Orders() const { return IterateWrapper(this->orders.list); }
};

/**
 * 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

        typedef SpecializedVehicle<T, Type> SpecializedVehicleBase; ///< Our type

        /**
         * Set vehicle type correctly
         */
        inline SpecializedVehicle<T, Type>() : Vehicle(Type)
        {
                this->sprite_cache.sprite_seq.count = 1;
        }

        /**
         * Get the first vehicle in the chain
         * @return first vehicle in the chain
         */
        inline T *First() const { return (T *)this->Vehicle::First(); }

        /**
         * Get the last vehicle in the chain
         * @return last vehicle in the chain
         */
        inline T *Last() { return (T *)this->Vehicle::Last(); }

        /**
         * Get the last vehicle in the chain
         * @return last vehicle in the chain
         */
        inline const T *Last() const { return (const T *)this->Vehicle::Last(); }

        /**
         * Get next vehicle in the chain
         * @return next vehicle in the chain
         */
        inline T *Next() const { return (T *)this->Vehicle::Next(); }

        /**
         * Get previous vehicle in the chain
         * @return previous vehicle in the chain
         */
        inline 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.
         */
        inline 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.
         */
        inline T *GetNextArticulatedPart() const { return (T *)this->Vehicle::GetNextArticulatedPart(); }

        /**
         * Get the first part of an articulated engine.
         * @return First part of the engine.
         */
        inline T *GetFirstEnginePart() { return (T *)this->Vehicle::GetFirstEnginePart(); }

        /**
         * Get the first part of an articulated engine.
         * @return First part of the engine.
         */
        inline const T *GetFirstEnginePart() const { return (const T *)this->Vehicle::GetFirstEnginePart(); }

        /**
         * Get the last part of an articulated engine.
         * @return Last part of the engine.
         */
        inline T *GetLastEnginePart() { return (T *)this->Vehicle::GetLastEnginePart(); }

        /**
         * Get the next real (non-articulated part) vehicle in the consist.
         * @return Next vehicle in the consist.
         */
        inline 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.
         */
        inline 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 inline 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 inline 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 inline T *GetIfValid(size_t index)
        {
                return IsValidID(index) ? Get(index) : nullptr;
        }

        /**
         * Converts a Vehicle to SpecializedVehicle with type checking.
         * @param v Vehicle pointer
         * @return pointer to SpecializedVehicle
         */
        static inline 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 inline const T *From(const Vehicle *v)
        {
                assert(v->type == Type);
                return (const T *)v;
        }

        /**
         * Update vehicle sprite- and position caches
         * @param force_update Force updating the vehicle on the viewport.
         * @param update_delta Also update the delta?
         */
        inline void UpdateViewport(bool force_update, bool update_delta)
        {
                bool sprite_has_changed = false;

                /* Skip updating sprites on dedicated servers without screen */
                if (_network_dedicated) return;

                /* Explicitly choose method to call to prevent vtable dereference -
                 * it gives ~3% runtime improvements in games with many vehicles */
                if (update_delta) ((T *)this)->T::UpdateDeltaXY();

                /*
                 * Only check for a new sprite sequence if the vehicle direction
                 * has changed since we last checked it, assuming that otherwise
                 * there won't be enough change in bounding box or offsets to need
                 * to resolve a new sprite.
                 */
                if (this->direction != this->sprite_cache.last_direction || this->sprite_cache.is_viewport_candidate) {
                        VehicleSpriteSeq seq;

                        ((T*)this)->T::GetImage(this->direction, EIT_ON_MAP, &seq);
                        if (this->sprite_cache.sprite_seq != seq) {
                                sprite_has_changed = true;
                                this->sprite_cache.sprite_seq = seq;
                        }

                        this->sprite_cache.last_direction = this->direction;
                        this->sprite_cache.revalidate_before_draw = false;
                } else {
                        /*
                         * A change that could potentially invalidate the sprite has been
                         * made, signal that we should still resolve it before drawing on a
                         * viewport.
                         */
                        this->sprite_cache.revalidate_before_draw = true;
                }

                if (force_update || sprite_has_changed) {
                        this->Vehicle::UpdateViewport(true);
                }
        }

        /**
         * Returns an iterable ensemble of all valid vehicles of type T
         * @param from index of the first vehicle to consider
         * @return an iterable ensemble of all valid vehicles of type T
         */
        static Pool::IterateWrapper<T> Iterate(size_t from = 0) { return Pool::IterateWrapper<T>(from); }
};

/** 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 */