vehicle_base.h

Go to the documentation of this file.

/*
 * 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/>.
 */
 
#ifndef VEHICLE_BASE_H
#define VEHICLE_BASE_H
 
#include "track_type.h"
#include "command_type.h"
#include "order_base.h"
#include "cargopacket.h"
#include "texteff.hpp"
#include "engine_type.h"
#include "order_func.h"
#include "transport_type.h"
#include "group_type.h"
#include "base_consist.h"
#include "network/network.h"
#include "saveload/saveload.h"
#include "timer/timer_game_calendar.h"
#include "core/mem_func.hpp"
 
const uint TILE_AXIAL_DISTANCE = 192;  // Logical length of the tile in any DiagDirection used in vehicle movement.
const uint TILE_CORNER_DISTANCE = 128;  // Logical length of the tile corner crossing in any non-diagonal direction used in vehicle movement.
 
enum VehStatus {
  VS_HIDDEN          = 0x01, 
  VS_STOPPED         = 0x02, 
  VS_UNCLICKABLE     = 0x04, 
  VS_DEFPAL          = 0x08, 
  VS_TRAIN_SLOWING   = 0x10, 
  VS_SHADOW          = 0x20, 
  VS_AIRCRAFT_BROKEN = 0x40, 
  VS_CRASHED         = 0x80, 
};
 
enum VehicleFlags {
  VF_LOADING_FINISHED,        
  VF_CARGO_UNLOADING,         
  VF_BUILT_AS_PROTOTYPE,      
  VF_TIMETABLE_STARTED,       
  VF_AUTOFILL_TIMETABLE,      
  VF_AUTOFILL_PRES_WAIT_TIME, 
  VF_STOP_LOADING,            
  VF_PATHFINDER_LOST,         
  VF_SERVINT_IS_CUSTOM,       
  VF_SERVINT_IS_PERCENT,      
};
 
enum NewGRFCacheValidValues {
  NCVV_POSITION_CONSIST_LENGTH   = 0, 
  NCVV_POSITION_SAME_ID_LENGTH   = 1, 
  NCVV_CONSIST_CARGO_INFORMATION = 2, 
  NCVV_COMPANY_INFORMATION       = 3, 
  NCVV_POSITION_IN_VEHICLE       = 4, 
  NCVV_END,                           
};
 
struct NewGRFCache {
  /* Values calculated when they are requested for the first time after invalidating the NewGRF cache. */
  uint32_t position_consist_length;   
  uint32_t position_same_id_length;   
  uint32_t consist_cargo_information; 
  uint32_t company_information;       
  uint32_t position_in_vehicle;       
  uint8_t  cache_valid;               
 
  auto operator<=>(const NewGRFCache &) const = default;
};
 
enum VisualEffect {
  VE_OFFSET_START        = 0, 
  VE_OFFSET_COUNT        = 4, 
  VE_OFFSET_CENTRE       = 8, 
 
  VE_TYPE_START          = 4, 
  VE_TYPE_COUNT          = 2, 
  VE_TYPE_DEFAULT        = 0, 
  VE_TYPE_STEAM          = 1, 
  VE_TYPE_DIESEL         = 2, 
  VE_TYPE_ELECTRIC       = 3, 
 
  VE_DISABLE_EFFECT      = 6, 
  VE_ADVANCED_EFFECT     = VE_DISABLE_EFFECT, 
  VE_DISABLE_WAGON_POWER = 7, 
 
  VE_DEFAULT = 0xFF,          
};
 
enum VisualEffectSpawnModel {
  VESM_NONE              = 0, 
  VESM_STEAM,                 
  VESM_DIESEL,                
  VESM_ELECTRIC,              
 
  VESM_END
};
 
enum GroundVehicleSubtypeFlags {
  GVSF_FRONT            = 0, 
  GVSF_ARTICULATED_PART = 1, 
  GVSF_WAGON            = 2, 
  GVSF_ENGINE           = 3, 
  GVSF_FREE_WAGON       = 4, 
  GVSF_MULTIHEADED      = 5, 
};
 
struct VehicleCache {
  uint16_t cached_max_speed;        
  uint16_t cached_cargo_age_period; 
 
  uint8_t cached_vis_effect;  
 
  auto operator<=>(const VehicleCache &) const = default;
};
 
struct VehicleSpriteSeq {
  PalSpriteID seq[8];
  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);
  }
 
  bool IsValid() const
  {
    return this->count != 0;
  }
 
  void Clear()
  {
    this->count = 0;
  }
 
  void Set(SpriteID sprite)
  {
    this->count = 1;
    this->seq[0].sprite = sprite;
    this->seq[0].pal = 0;
  }
 
  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;
};
 
struct MutableSpriteCache {
  Direction last_direction;     
  bool revalidate_before_draw;  
  bool is_viewport_candidate;   
  Rect old_coord;               
  VehicleSpriteSeq sprite_seq;  
};
 
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;
 
struct RefitDesc {
  CargoID cargo;    
  uint16_t capacity;  
  uint16_t remaining; 
  RefitDesc(CargoID cargo, uint16_t capacity, uint16_t remaining) :
      cargo(cargo), capacity(capacity), remaining(remaining) {}
};
 
struct ClosestDepot {
  TileIndex location;
  DestinationID destination; 
  bool reverse;
  bool found;
 
  ClosestDepot() :
    location(INVALID_TILE), destination(0), reverse(false), found(false) {}
 
  ClosestDepot(TileIndex location, DestinationID destination, bool reverse = false) :
    location(location), destination(destination), reverse(reverse), found(true) {}
};
 
struct Vehicle : VehiclePool::PoolItem<&_vehicle_pool>, BaseVehicle, BaseConsist {
private:
  typedef std::list<RefitDesc> RefitList;
 
  Vehicle *next;                      
  Vehicle *previous;                  
  Vehicle *first;                     
 
  Vehicle *next_shared;               
  Vehicle *previous_shared;           
 
public:
  friend void FixOldVehicles();
  friend void AfterLoadVehiclesPhase1(bool part_of_load);       
  friend bool LoadOldVehicle(LoadgameState *ls, int num);       
  /* So we can use private/protected variables in the saveload code */
  friend class SlVehicleCommon;
  friend class SlVehicleDisaster;
  friend void Ptrs_VEHS();
 
  TileIndex tile;                     
 
  TileIndex dest_tile;
 
  Money profit_this_year;             
  Money profit_last_year;             
  Money value;                        
 
  CargoPayment *cargo_payment;        
 
  mutable Rect coord;                 
 
  Vehicle *hash_viewport_next;        
  Vehicle **hash_viewport_prev;       
 
  Vehicle *hash_tile_next;            
  Vehicle **hash_tile_prev;           
  Vehicle **hash_tile_current;        
 
  SpriteID colourmap;                 
 
  /* Related to age and service time */
  TimerGameCalendar::Year build_year;           
  TimerGameCalendar::Date age;                  
  TimerGameEconomy::Date economy_age;           
  TimerGameCalendar::Date max_age;              
  TimerGameEconomy::Date date_of_last_service; 
  TimerGameCalendar::Date date_of_last_service_newgrf; 
  uint16_t reliability;                 
  uint16_t reliability_spd_dec;         
  uint8_t breakdown_ctr;                 
  uint8_t breakdown_delay;               
  uint8_t breakdowns_since_last_service; 
  uint8_t breakdown_chance;              
 
  int32_t x_pos;                        
  int32_t y_pos;                        
  int32_t z_pos;                        
  Direction direction;                
 
  Owner owner;                        
  uint8_t spritenum;
  uint8_t x_extent;                      
  uint8_t y_extent;                      
  uint8_t z_extent;                      
  int8_t x_bb_offs;                     
  int8_t y_bb_offs;                     
  int8_t x_offs;                        
  int8_t y_offs;                        
  EngineID engine_type;               
 
  TextEffectID fill_percent_te_id;    
  UnitID unitnumber;                  
 
  uint16_t cur_speed;                   
  uint8_t subspeed;                      
  uint8_t acceleration;                  
  uint32_t motion_counter;              
  uint8_t progress;                      
 
  uint8_t waiting_triggers;              
  uint16_t random_bits; 
 
  StationID last_station_visited;     
  StationID last_loading_station;     
  TimerGameTick::TickCounter last_loading_tick; 
 
  VehicleCargoList cargo;             
  CargoID cargo_type;                 
  uint8_t cargo_subtype;                 
  uint16_t cargo_cap;                   
  uint16_t refit_cap;                   
  uint16_t cargo_age_counter;           
  int8_t trip_occupancy;                
 
  uint8_t day_counter;                   
  uint8_t tick_counter;                  
  uint8_t running_ticks;                 
  uint16_t load_unload_ticks;           
 
  uint8_t vehstatus;                     
  uint8_t subtype;                       
  Order current_order;                
 
  union {
    OrderList *orders;              
    Order *old_orders;              
  };
 
  NewGRFCache grf_cache;              
  VehicleCache vcache;                
 
  GroupID group_id;                   
 
  mutable MutableSpriteCache sprite_cache; 
 
  virtual uint16_t GetMaxWeight() const
  {
    return 0;
  }
 
  Vehicle(VehicleType type = VEH_INVALID);
 
  void PreDestructor();
  virtual ~Vehicle();
 
  void BeginLoading();
  void CancelReservation(StationID next, Station *st);
  void LeaveStation();
 
  GroundVehicleCache *GetGroundVehicleCache();
  const GroundVehicleCache *GetGroundVehicleCache() const;
 
  uint16_t &GetGroundVehicleFlags();
  const uint16_t &GetGroundVehicleFlags() const;
 
  void DeleteUnreachedImplicitOrders();
 
  void HandleLoading(bool mode = false);
 
  virtual void MarkDirty() {}
 
  virtual void UpdateDeltaXY() {}
 
  inline uint GetOldAdvanceSpeed(uint speed)
  {
    return (this->direction & 1) ? speed : speed * 3 / 4;
  }
 
  static inline uint GetAdvanceSpeed(uint speed)
  {
    return speed * 3 / 4;
  }
 
  inline uint GetAdvanceDistance()
  {
    return (this->direction & 1) ? TILE_AXIAL_DISTANCE : TILE_CORNER_DISTANCE * 2;
  }
 
  virtual ExpensesType GetExpenseType([[maybe_unused]] bool income) const { return EXPENSES_OTHER; }
 
  virtual void PlayLeaveStationSound([[maybe_unused]] bool force = false) const {}
 
  virtual bool IsPrimaryVehicle() const { return false; }
 
  const Engine *GetEngine() const;
 
  virtual void GetImage([[maybe_unused]] Direction direction, [[maybe_unused]] EngineImageType image_type, [[maybe_unused]] VehicleSpriteSeq *result) const { result->Clear(); }
 
  const GRFFile *GetGRF() const;
  uint32_t GetGRFID() const;
 
  inline void InvalidateNewGRFCache()
  {
    this->grf_cache.cache_valid = 0;
  }
 
  inline void InvalidateNewGRFCacheOfChain()
  {
    for (Vehicle *u = this; u != nullptr; u = u->Next()) {
      u->InvalidateNewGRFCache();
    }
  }
 
  debug_inline bool IsGroundVehicle() const
  {
    return this->type == VEH_TRAIN || this->type == VEH_ROAD;
  }
 
  virtual int GetDisplaySpeed() const { return 0; }
 
  virtual int GetDisplayMaxSpeed() const { return 0; }
 
  virtual int GetCurrentMaxSpeed() const { return 0; }
 
  virtual Money GetRunningCost() const { return 0; }
 
  virtual bool IsInDepot() const { return false; }
 
  virtual bool IsChainInDepot() const { return this->IsInDepot(); }
 
  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();
  }
 
  virtual bool Tick() { return true; };
 
  virtual void OnNewCalendarDay() {};
 
  virtual void OnNewEconomyDay() {};
 
  void ShiftDates(TimerGameEconomy::Date interval);
 
  virtual uint Crash(bool flooded = false);
 
  virtual Trackdir GetVehicleTrackdir() const { return INVALID_TRACKDIR; }
 
  Money GetDisplayRunningCost() const { return (this->GetRunningCost() >> 8); }
 
  Money GetDisplayProfitThisYear() const { return (this->profit_this_year >> 8); }
 
  Money GetDisplayProfitLastYear() const { return (this->profit_last_year >> 8); }
 
  void SetNext(Vehicle *next);
 
  inline Vehicle *Next() const { return this->next; }
 
  inline Vehicle *Previous() const { return this->previous; }
 
  inline Vehicle *First() const { return this->first; }
 
  inline Vehicle *Last()
  {
    Vehicle *v = this;
    while (v->Next() != nullptr) v = v->Next();
    return v;
  }
 
  inline const Vehicle *Last() const
  {
    const Vehicle *v = this;
    while (v->Next() != nullptr) v = v->Next();
    return v;
  }
 
  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;
  }
 
  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;
  }
 
  inline Order *GetFirstOrder() const { return (this->orders == nullptr) ? nullptr : this->orders->GetFirstOrder(); }
 
  void AddToShared(Vehicle *shared_chain);
  void RemoveFromShared();
 
  inline Vehicle *NextShared() const { return this->next_shared; }
 
  inline Vehicle *PreviousShared() const { return this->previous_shared; }
 
  inline Vehicle *FirstShared() const { return (this->orders == nullptr) ? this->First() : this->orders->GetFirstSharedVehicle(); }
 
  inline bool IsOrderListShared() const { return this->orders != nullptr && this->orders->IsShared(); }
 
  inline VehicleOrderID GetNumOrders() const { return (this->orders == nullptr) ? 0 : this->orders->GetNumOrders(); }
 
  inline VehicleOrderID GetNumManualOrders() const { return (this->orders == nullptr) ? 0 : this->orders->GetNumManualOrders(); }
 
  inline StationIDStack GetNextStoppingStation() const
  {
    return (this->orders == nullptr) ? INVALID_STATION : this->orders->GetNextStoppingStation(this);
  }
 
  void ResetRefitCaps();
 
  void ReleaseUnitNumber();
 
  inline void CopyVehicleConfigAndStatistics(Vehicle *src)
  {
    this->CopyConsistPropertiesFrom(src);
 
    this->ReleaseUnitNumber();
    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;
 
    src->unitnumber = 0;
  }
 
 
  bool HandleBreakdown();
 
  bool NeedsAutorenewing(const Company *c, bool use_renew_setting = true) const;
 
  bool NeedsServicing() const;
  bool NeedsAutomaticServicing() const;
 
  virtual TileIndex GetOrderStationLocation([[maybe_unused]] StationID station) { return INVALID_TILE; }
 
  virtual TileIndex GetCargoTile() const { return this->tile; }
 
  virtual ClosestDepot FindClosestDepot() { return {}; }
 
  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_t GetServiceInterval() const { return this->service_interval; }
 
  inline void SetServiceInterval(uint16_t 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) { AssignBit(this->vehicle_flags, VF_SERVINT_IS_CUSTOM, on); }
 
  inline void SetServiceIntervalIsPercent(bool on) { AssignBit(this->vehicle_flags, VF_SERVINT_IS_PERCENT, on); }
 
  bool HasFullLoadOrder() const;
  bool HasConditionalOrder() const;
  bool HasUnbunchingOrder() const;
  void LeaveUnbunchingDepot();
  bool IsWaitingForUnbunching() const;
 
private:
  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:
  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);
  }
 
  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);
    }
  }
 
  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;
    }
  }
 
  inline Order *GetOrder(int index) const
  {
    return (this->orders == nullptr) ? nullptr : this->orders->GetOrderAt(index);
  }
 
  inline Order *GetLastOrder() const
  {
    return (this->orders == nullptr) ? nullptr : this->orders->GetLastOrder();
  }
 
  bool IsEngineCountable() const;
  bool HasEngineType() const;
  bool HasDepotOrder() const;
  void HandlePathfindingResult(bool path_found);
 
  debug_inline bool IsFrontEngine() const
  {
    return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_FRONT);
  }
 
  inline bool IsArticulatedPart() const
  {
    return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_ARTICULATED_PART);
  }
 
  inline bool HasArticulatedPart() const
  {
    return this->Next() != nullptr && this->Next()->IsArticulatedPart();
  }
 
  inline Vehicle *GetNextArticulatedPart() const
  {
    assert(this->HasArticulatedPart());
    return this->Next();
  }
 
  inline Vehicle *GetFirstEnginePart()
  {
    Vehicle *v = this;
    while (v->IsArticulatedPart()) v = v->Previous();
    return v;
  }
 
  inline const Vehicle *GetFirstEnginePart() const
  {
    const Vehicle *v = this;
    while (v->IsArticulatedPart()) v = v->Previous();
    return v;
  }
 
  inline Vehicle *GetLastEnginePart()
  {
    Vehicle *v = this;
    while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
    return v;
  }
 
  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();
  }
 
  inline Vehicle *GetPrevVehicle() const
  {
    Vehicle *v = this->Previous();
    while (v != nullptr && v->IsArticulatedPart()) v = v->Previous();
 
    return v;
  }
 
  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;
  };
 
  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(); }
  };
 
  IterateWrapper Orders() const { return IterateWrapper(this->orders); }
 
  uint32_t GetDisplayMaxWeight() const;
  uint32_t GetDisplayMinPowerToWeight() const;
};
 
template <class T, VehicleType Type>
struct SpecializedVehicle : public Vehicle {
  static const VehicleType EXPECTED_TYPE = Type; 
 
  typedef SpecializedVehicle<T, Type> SpecializedVehicleBase; 
 
  inline SpecializedVehicle() : Vehicle(Type)
  {
    this->sprite_cache.sprite_seq.count = 1;
  }
 
  inline T *First() const { return (T *)this->Vehicle::First(); }
 
  inline T *Last() { return (T *)this->Vehicle::Last(); }
 
  inline const T *Last() const { return (const T *)this->Vehicle::Last(); }
 
  inline T *Next() const { return (T *)this->Vehicle::Next(); }
 
  inline T *Previous() const { return (T *)this->Vehicle::Previous(); }
 
  inline T *GetNextArticulatedPart() { return (T *)this->Vehicle::GetNextArticulatedPart(); }
 
  inline T *GetNextArticulatedPart() const { return (T *)this->Vehicle::GetNextArticulatedPart(); }
 
  inline T *GetFirstEnginePart() { return (T *)this->Vehicle::GetFirstEnginePart(); }
 
  inline const T *GetFirstEnginePart() const { return (const T *)this->Vehicle::GetFirstEnginePart(); }
 
  inline T *GetLastEnginePart() { return (T *)this->Vehicle::GetLastEnginePart(); }
 
  inline T *GetNextVehicle() const { return (T *)this->Vehicle::GetNextVehicle(); }
 
  inline T *GetPrevVehicle() const { return (T *)this->Vehicle::GetPrevVehicle(); }
 
  static inline bool IsValidID(size_t index)
  {
    return Vehicle::IsValidID(index) && Vehicle::Get(index)->type == Type;
  }
 
  static inline T *Get(size_t index)
  {
    return (T *)Vehicle::Get(index);
  }
 
  static inline T *GetIfValid(size_t index)
  {
    return IsValidID(index) ? Get(index) : nullptr;
  }
 
  static inline T *From(Vehicle *v)
  {
    assert(v->type == Type);
    return (T *)v;
  }
 
  static inline const T *From(const Vehicle *v)
  {
    assert(v->type == Type);
    return (const T *)v;
  }
 
  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);
    }
  }
 
  static Pool::IterateWrapper<T> Iterate(size_t from = 0) { return Pool::IterateWrapper<T>(from); }
};
 
static const int32_t INVALID_COORD = 0x7fffffff;
 
#endif /* VEHICLE_BASE_H */