train.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 TRAIN_H
#define TRAIN_H
 
#include "core/enum_type.hpp"
 
#include "newgrf_engine.h"
#include "cargotype.h"
#include "rail.h"
#include "engine_base.h"
#include "rail_map.h"
#include "ground_vehicle.hpp"
 
struct Train;
 
enum VehicleRailFlags : uint8_t {
  VRF_REVERSING                     = 0,
  VRF_POWEREDWAGON                  = 3, 
  VRF_REVERSE_DIRECTION             = 4, 
 
  VRF_EL_ENGINE_ALLOWED_NORMAL_RAIL = 6, 
  VRF_TOGGLE_REVERSE                = 7, 
  VRF_TRAIN_STUCK                   = 8, 
  VRF_LEAVING_STATION               = 9, 
};
 
enum TrainForceProceeding : uint8_t {
  TFP_NONE   = 0,    
  TFP_STUCK  = 1,    
  TFP_SIGNAL = 2,    
};
 
enum class ConsistChangeFlag : uint8_t {
  Length, 
  Capacity, 
};
 
using ConsistChangeFlags = EnumBitSet<ConsistChangeFlag, uint8_t>;
 
static constexpr ConsistChangeFlags CCF_TRACK{}; 
static constexpr ConsistChangeFlags CCF_LOADUNLOAD{}; 
static constexpr ConsistChangeFlags CCF_AUTOREFIT{ConsistChangeFlag::Capacity}; 
static constexpr ConsistChangeFlags CCF_REFIT{ConsistChangeFlag::Length, ConsistChangeFlag::Capacity}; 
static constexpr ConsistChangeFlags CCF_ARRANGE{ConsistChangeFlag::Length, ConsistChangeFlag::Capacity}; 
static constexpr ConsistChangeFlags CCF_SAVELOAD{ConsistChangeFlag::Length}; 
 
uint8_t FreightWagonMult(CargoType cargo);
 
void CheckTrainsLengths();
 
void FreeTrainTrackReservation(const Train *v);
bool TryPathReserve(Train *v, bool mark_as_stuck = false, bool first_tile_okay = false);
 
int GetTrainStopLocation(StationID station_id, TileIndex tile, const Train *v, int *station_ahead, int *station_length);
 
void GetTrainSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type);
 
bool TrainOnCrossing(TileIndex tile);
void NormalizeTrainVehInDepot(const Train *u);
 
struct TrainCache {
  /* Cached wagon override spritegroup */
  const struct SpriteGroup *cached_override = nullptr;
 
  /* cached values, recalculated on load and each time a vehicle is added to/removed from the consist. */
  bool cached_tilt = false; 
  uint8_t user_def_data = 0; 
 
  int16_t cached_curve_speed_mod = 0; 
  uint16_t cached_max_curve_speed = 0; 
 
  auto operator<=>(const TrainCache &) const = default;
};
 
struct Train final : public GroundVehicle<Train, VEH_TRAIN> {
  uint16_t flags = 0;
  uint16_t crash_anim_pos = 0; 
  uint16_t wait_counter = 0; 
 
  TrainCache tcache{};
 
  /* Link between the two ends of a multiheaded engine */
  Train *other_multiheaded_part = nullptr;
 
  RailTypes compatible_railtypes{};
  RailType railtype = INVALID_RAILTYPE;
 
  TrackBits track{};
  TrainForceProceeding force_proceed{};
 
  Train() : GroundVehicleBase() {}
  virtual ~Train() { this->PreDestructor(); }
 
  friend struct GroundVehicle<Train, VEH_TRAIN>; // GroundVehicle needs to use the acceleration functions defined at Train.
 
  void MarkDirty() override;
  void UpdateDeltaXY() override;
  ExpensesType GetExpenseType(bool income) const override { return income ? EXPENSES_TRAIN_REVENUE : EXPENSES_TRAIN_RUN; }
  void PlayLeaveStationSound(bool force = false) const override;
  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; }
  int GetDisplayMaxSpeed() const override { return this->vcache.cached_max_speed; }
  Money GetRunningCost() const override;
  int GetCursorImageOffset() const;
  int GetDisplayImageWidth(Point *offset = nullptr) const;
  bool IsInDepot() const override { return this->track == TRACK_BIT_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;
 
  void ReserveTrackUnderConsist() const;
 
  uint16_t GetCurveSpeedLimit() const;
 
  void ConsistChanged(ConsistChangeFlags allowed_changes);
 
  int UpdateSpeed();
 
  void UpdateAcceleration();
 
  int GetCurrentMaxSpeed() const override;
 
  inline Train *GetNextUnit() const
  {
    Train *v = this->GetNextVehicle();
    if (v != nullptr && v->IsRearDualheaded()) v = v->GetNextVehicle();
 
    return v;
  }
 
  inline Train *GetPrevUnit()
  {
    Train *v = this->GetPrevVehicle();
    if (v != nullptr && v->IsRearDualheaded()) v = v->GetPrevVehicle();
 
    return v;
  }
 
  int CalcNextVehicleOffset() const
  {
    /* For vehicles with odd lengths the part before the center will be one unit
     * longer than the part after the center. This means we have to round up the
     * length of the next vehicle but may not round the length of the current
     * vehicle. */
    return this->gcache.cached_veh_length / 2 + (this->Next() != nullptr ? this->Next()->gcache.cached_veh_length + 1 : 0) / 2;
  }
 
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() && HasPowerOnRail(this->railtype, GetRailType(this->tile))) {
      uint16_t power = GetVehicleProperty(this, PROP_TRAIN_POWER, RailVehInfo(this->engine_type)->power);
      /* Halve power for multiheaded parts */
      if (this->IsMultiheaded()) power /= 2;
      return power;
    }
 
    return 0;
  }
 
  inline uint16_t GetPoweredPartPower(const Train *head) const
  {
    /* For powered wagons the engine defines the type of engine (i.e. railtype) */
    if (HasBit(this->flags, VRF_POWEREDWAGON) && HasPowerOnRail(head->railtype, GetRailType(this->tile))) {
      return RailVehInfo(this->gcache.first_engine)->pow_wag_power;
    }
 
    return 0;
  }
 
  inline uint16_t GetWeight() const
  {
    uint16_t weight = CargoSpec::Get(this->cargo_type)->WeightOfNUnitsInTrain(this->cargo.StoredCount());
 
    /* Vehicle weight is not added for articulated parts. */
    if (!this->IsArticulatedPart()) {
      weight += GetVehicleProperty(this, PROP_TRAIN_WEIGHT, RailVehInfo(this->engine_type)->weight);
    }
 
    /* Powered wagons have extra weight added. */
    if (HasBit(this->flags, VRF_POWEREDWAGON)) {
      weight += RailVehInfo(this->gcache.first_engine)->pow_wag_weight;
    }
 
    return weight;
  }
 
  uint16_t GetMaxWeight() const override;
 
  inline uint8_t GetTractiveEffort() const
  {
    return GetVehicleProperty(this, PROP_TRAIN_TRACTIVE_EFFORT, RailVehInfo(this->engine_type)->tractive_effort);
  }
 
  inline uint8_t GetAirDragArea() const
  {
    /* Air drag is higher in tunnels due to the limited cross-section. */
    return (this->track == TRACK_BIT_WORMHOLE && this->vehstatus.Test(VehState::Hidden)) ? 28 : 14;
  }
 
  inline uint8_t GetAirDrag() const
  {
    return RailVehInfo(this->engine_type)->air_drag;
  }
 
  inline AccelStatus GetAccelerationStatus() const
  {
    return this->vehstatus.Test(VehState::Stopped) || HasBit(this->flags, VRF_REVERSING) || HasBit(this->flags, VRF_TRAIN_STUCK) ? AS_BRAKE : AS_ACCEL;
  }
 
  inline uint16_t GetCurrentSpeed() const
  {
    return this->cur_speed;
  }
 
  inline uint32_t GetRollingFriction() const
  {
    /* Rolling friction for steel on steel is between 0.1% and 0.2%.
     * The friction coefficient increases with speed in a way that
     * it doubles at 512 km/h, triples at 1024 km/h and so on. */
    return 15 * (512 + this->GetCurrentSpeed()) / 512;
  }
 
  inline int GetAccelerationType() const
  {
    return GetRailTypeInfo(this->railtype)->acceleration_type;
  }
 
  inline uint32_t GetSlopeSteepness() const
  {
    return _settings_game.vehicle.train_slope_steepness;
  }
 
  inline uint16_t GetMaxTrackSpeed() const
  {
    return GetRailTypeInfo(GetRailType(this->tile))->max_speed;
  }
 
  inline int16_t GetCurveSpeedModifier() const
  {
    return GetVehicleProperty(this, PROP_TRAIN_CURVE_SPEED_MOD, RailVehInfo(this->engine_type)->curve_speed_mod, true);
  }
 
  inline bool TileMayHaveSlopedTrack() const
  {
    /* Any track that isn't TRACK_BIT_X or TRACK_BIT_Y cannot be sloped. */
    return this->track == TRACK_BIT_X || this->track == TRACK_BIT_Y;
  }
 
  inline bool HasToUseGetSlopePixelZ()
  {
    return false;
  }
};
 
#endif /* TRAIN_H */