roadveh.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 ROADVEH_H
#define ROADVEH_H
 
#include "ground_vehicle.hpp"
#include "engine_base.h"
#include "cargotype.h"
#include "track_func.h"
#include "road.h"
#include "road_map.h"
#include "newgrf_engine.h"
 
struct RoadVehicle;
 
enum RoadVehicleStates {
  /*
   * Lower 4 bits are used for vehicle track direction. (Trackdirs)
   * When in a road stop (bit 5 or bit 6 set) these bits give the
   * track direction of the entry to the road stop.
   * As the entry direction will always be a diagonal
   * direction (X_NE, Y_SE, X_SW or Y_NW) only bits 0 and 3
   * are needed to hold this direction. Bit 1 is then used to show
   * that the vehicle is using the second road stop bay.
   * Bit 2 is then used for drive-through stops to show the vehicle
   * is stopping at this road stop.
   */
 
  /* Numeric values */
  RVSB_IN_DEPOT                = 0xFE,                      
  RVSB_WORMHOLE                = 0xFF,                      
 
  /* Bit numbers */
  RVS_USING_SECOND_BAY         =    1,                      
  RVS_ENTERED_STOP             =    2,                      
  RVS_DRIVE_SIDE               =    4,                      
  RVS_IN_ROAD_STOP             =    5,                      
  RVS_IN_DT_ROAD_STOP          =    6,                      
 
  /* Bit sets of the above specified bits */
  RVSB_IN_ROAD_STOP            = 1 << RVS_IN_ROAD_STOP,     
  RVSB_IN_ROAD_STOP_END        = RVSB_IN_ROAD_STOP + TRACKDIR_END,
  RVSB_IN_DT_ROAD_STOP         = 1 << RVS_IN_DT_ROAD_STOP,  
  RVSB_IN_DT_ROAD_STOP_END     = RVSB_IN_DT_ROAD_STOP + TRACKDIR_END,
 
  RVSB_DRIVE_SIDE              = 1 << RVS_DRIVE_SIDE,       
 
  RVSB_TRACKDIR_MASK           = 0x0F,                      
  RVSB_ROAD_STOP_TRACKDIR_MASK = 0x09,                      
};
 
static const uint RDE_NEXT_TILE = 0x80; 
static const uint RDE_TURNED    = 0x40; 
 
/* Start frames for when a vehicle enters a tile/changes its state.
 * The start frame is different for vehicles that turned around or
 * are leaving the depot as the do not start at the edge of the tile.
 * For trams there are a few different start frames as there are two
 * places where trams can turn. */
static const uint RVC_DEFAULT_START_FRAME                =  0;
static const uint RVC_TURN_AROUND_START_FRAME            =  1;
static const uint RVC_DEPOT_START_FRAME                  =  6;
static const uint RVC_START_FRAME_AFTER_LONG_TRAM        = 21;
static const uint RVC_TURN_AROUND_START_FRAME_SHORT_TRAM = 16;
/* Stop frame for a vehicle in a drive-through stop */
static const uint RVC_DRIVE_THROUGH_STOP_FRAME           = 11;
static const uint RVC_DEPOT_STOP_FRAME                   = 11;
 
static const byte RV_OVERTAKE_TIMEOUT = 35;
 
void RoadVehUpdateCache(RoadVehicle *v, bool same_length = false);
void GetRoadVehSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type);
 
struct RoadVehPathCache {
  std::deque<Trackdir> td;
  std::deque<TileIndex> tile;
 
  inline bool empty() const { return this->td.empty(); }
 
  inline size_t size() const
  {
    assert(this->td.size() == this->tile.size());
    return this->td.size();
  }
 
  inline void clear()
  {
    this->td.clear();
    this->tile.clear();
  }
};
 
struct RoadVehicle final : public GroundVehicle<RoadVehicle, VEH_ROAD> {
  RoadVehPathCache path;  
  byte state;             
  byte frame;
  uint16_t blocked_ctr;
  byte overtaking;        
  byte overtaking_ctr;    
  uint16_t crashed_ctr;     
  byte reverse_ctr;
 
  RoadType roadtype;              
  RoadTypes compatible_roadtypes; 
 
  VehicleID disaster_vehicle = INVALID_VEHICLE; 
 
  RoadVehicle() : GroundVehicleBase() {}
  virtual ~RoadVehicle() { this->PreDestructor(); }
 
  friend struct GroundVehicle<RoadVehicle, VEH_ROAD>; // GroundVehicle needs to use the acceleration functions defined at RoadVehicle.
 
  void MarkDirty() override;
  void UpdateDeltaXY() override;
  ExpensesType GetExpenseType(bool income) const override { return income ? EXPENSES_ROADVEH_REVENUE : EXPENSES_ROADVEH_RUN; }
  bool IsPrimaryVehicle() const override { return this->IsFrontEngine(); }
  void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const override;
  int GetDisplaySpeed() const override { return this->gcache.last_speed / 2; }
  int GetDisplayMaxSpeed() const override { return this->vcache.cached_max_speed / 2; }
  Money GetRunningCost() const override;
  int GetDisplayImageWidth(Point *offset = nullptr) const;
  bool IsInDepot() const override { return this->state == RVSB_IN_DEPOT; }
  bool Tick() override;
  void OnNewCalendarDay() override;
  void OnNewEconomyDay() override;
  uint Crash(bool flooded = false) override;
  Trackdir GetVehicleTrackdir() const override;
  TileIndex GetOrderStationLocation(StationID station) override;
  ClosestDepot FindClosestDepot() override;
 
  bool IsBus() const;
 
  int GetCurrentMaxSpeed() const override;
  int UpdateSpeed();
  void SetDestTile(TileIndex tile) override;
 
protected: // These functions should not be called outside acceleration code.
 
  inline uint16_t GetPower() const
  {
    /* Power is not added for articulated parts */
    if (!this->IsArticulatedPart()) {
      /* Road vehicle power is in units of 10 HP. */
      return 10 * GetVehicleProperty(this, PROP_ROADVEH_POWER, RoadVehInfo(this->engine_type)->power);
    }
    return 0;
  }
 
  inline uint16_t GetPoweredPartPower(const RoadVehicle *) const
  {
    return 0;
  }
 
  inline uint16_t GetWeight() const
  {
    uint16_t weight = CargoSpec::Get(this->cargo_type)->WeightOfNUnits(this->cargo.StoredCount());
 
    /* Vehicle weight is not added for articulated parts. */
    if (!this->IsArticulatedPart()) {
      /* Road vehicle weight is in units of 1/4 t. */
      weight += GetVehicleProperty(this, PROP_ROADVEH_WEIGHT, RoadVehInfo(this->engine_type)->weight) / 4;
    }
 
    return weight;
  }
 
  uint16_t GetMaxWeight() const override;
 
  inline byte GetTractiveEffort() const
  {
    /* The tractive effort coefficient is in units of 1/256.  */
    return GetVehicleProperty(this, PROP_ROADVEH_TRACTIVE_EFFORT, RoadVehInfo(this->engine_type)->tractive_effort);
  }
 
  inline byte GetAirDragArea() const
  {
    return 6;
  }
 
  inline byte GetAirDrag() const
  {
    return RoadVehInfo(this->engine_type)->air_drag;
  }
 
  inline AccelStatus GetAccelerationStatus() const
  {
    return (this->vehstatus & VS_STOPPED) ? AS_BRAKE : AS_ACCEL;
  }
 
  inline uint16_t GetCurrentSpeed() const
  {
    return this->cur_speed / 2;
  }
 
  inline uint32_t GetRollingFriction() const
  {
    /* Trams have a slightly greater friction coefficient than trains.
     * The rest of road vehicles have bigger values. */
    uint32_t coeff = RoadTypeIsTram(this->roadtype) ? 40 : 75;
    /* The friction coefficient increases with speed in a way that
     * it doubles at 128 km/h, triples at 256 km/h and so on. */
    return coeff * (128 + this->GetCurrentSpeed()) / 128;
  }
 
  inline int GetAccelerationType() const
  {
    return 0;
  }
 
  inline uint32_t GetSlopeSteepness() const
  {
    return _settings_game.vehicle.roadveh_slope_steepness;
  }
 
  inline uint16_t GetMaxTrackSpeed() const
  {
    return GetRoadTypeInfo(GetRoadType(this->tile, GetRoadTramType(this->roadtype)))->max_speed;
  }
 
  inline bool TileMayHaveSlopedTrack() const
  {
    TrackStatus ts = GetTileTrackStatus(this->tile, TRANSPORT_ROAD, GetRoadTramType(this->roadtype));
    TrackBits trackbits = TrackStatusToTrackBits(ts);
 
    return trackbits == TRACK_BIT_X || trackbits == TRACK_BIT_Y;
  }
 
  inline bool HasToUseGetSlopePixelZ()
  {
    const RoadVehicle *rv = this->First();
 
    /* Check if this vehicle is in the same direction as the road under.
     * We already know it has either GVF_GOINGUP_BIT or GVF_GOINGDOWN_BIT set. */
 
    if (rv->state <= RVSB_TRACKDIR_MASK && IsReversingRoadTrackdir((Trackdir)rv->state)) {
      /* If the first vehicle is reversing, this vehicle may be reversing too
       * (especially if this is the first, and maybe the only, vehicle).*/
      return true;
    }
 
    while (rv != this) {
      /* If any previous vehicle has different direction,
       * we may be in the middle of reversing. */
      if (this->direction != rv->direction) return true;
      rv = rv->Next();
    }
 
    return false;
  }
};
 
#endif /* ROADVEH_H */