src/train.h

   1 /*
   2  * This file is part of OpenTTD.
   3  * 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.
   4  * 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.
   5  * 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/>.
   6  */
   7
   8 /** @file train.h Base for the train class. */
   9
  10 #ifndef TRAIN_H
  11 #define TRAIN_H
  12
  13 #include "core/enum_type.hpp"
  14
  15 #include "newgrf_engine.h"
  16 #include "cargotype.h"
  17 #include "rail.h"
  18 #include "engine_base.h"
  19 #include "rail_map.h"
  20 #include "ground_vehicle.hpp"
  21
  22 struct Train;
  23
  24 /** Rail vehicle flags. */
  25 enum VehicleRailFlags {
  26         VRF_REVERSING                     = 0,
  27         VRF_POWEREDWAGON                  = 3, ///< Wagon is powered.
  28         VRF_REVERSE_DIRECTION             = 4, ///< Reverse the visible direction of the vehicle.
  29
  30         VRF_EL_ENGINE_ALLOWED_NORMAL_RAIL = 6, ///< Electric train engine is allowed to run on normal rail. */
  31         VRF_TOGGLE_REVERSE                = 7, ///< Used for vehicle var 0xFE bit 8 (toggled each time the train is reversed, accurate for first vehicle only).
  32         VRF_TRAIN_STUCK                   = 8, ///< Train can't get a path reservation.
  33         VRF_LEAVING_STATION               = 9, ///< Train is just leaving a station.
  34 };
  35
  36 /** Modes for ignoring signals. */
  37 enum TrainForceProceeding : uint8_t {
  38         TFP_NONE   = 0,    ///< Normal operation.
  39         TFP_STUCK  = 1,    ///< Proceed till next signal, but ignore being stuck till then. This includes force leaving depots.
  40         TFP_SIGNAL = 2,    ///< Ignore next signal, after the signal ignore being stuck.
  41 };
  42
  43 /** Flags for Train::ConsistChanged */
  44 enum ConsistChangeFlags {
  45         CCF_LENGTH     = 0x01,     ///< Allow vehicles to change length.
  46         CCF_CAPACITY   = 0x02,     ///< Allow vehicles to change capacity.
  47
  48         CCF_TRACK      = 0,                          ///< Valid changes while vehicle is driving, and possibly changing tracks.
  49         CCF_LOADUNLOAD = 0,                          ///< Valid changes while vehicle is loading/unloading.
  50         CCF_AUTOREFIT  = CCF_CAPACITY,               ///< Valid changes for autorefitting in stations.
  51         CCF_REFIT      = CCF_LENGTH | CCF_CAPACITY,  ///< Valid changes for refitting in a depot.
  52         CCF_ARRANGE    = CCF_LENGTH | CCF_CAPACITY,  ///< Valid changes for arranging the consist in a depot.
  53         CCF_SAVELOAD   = CCF_LENGTH,                 ///< Valid changes when loading a savegame. (Everything that is not stored in the save.)
  54 };
  55 DECLARE_ENUM_AS_BIT_SET(ConsistChangeFlags)
  56
  57 uint8_t FreightWagonMult(CargoID cargo);
  58
  59 void CheckTrainsLengths();
  60
  61 void FreeTrainTrackReservation(const Train *v);
  62 bool TryPathReserve(Train *v, bool mark_as_stuck = false, bool first_tile_okay = false);
  63
  64 int GetTrainStopLocation(StationID station_id, TileIndex tile, const Train *v, int *station_ahead, int *station_length);
  65
  66 void GetTrainSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type);
  67
  68 bool TrainOnCrossing(TileIndex tile);
  69 void NormalizeTrainVehInDepot(const Train *u);
  70
  71 /** Variables that are cached to improve performance and such */
  72 struct TrainCache {
  73         /* Cached wagon override spritegroup */
  74         const struct SpriteGroup *cached_override;
  75
  76         /* cached values, recalculated on load and each time a vehicle is added to/removed from the consist. */
  77         bool cached_tilt;           ///< train can tilt; feature provides a bonus in curves
  78         uint8_t user_def_data;         ///< Cached property 0x25. Can be set by Callback 0x36.
  79
  80         int16_t cached_curve_speed_mod; ///< curve speed modifier of the entire train
  81         uint16_t cached_max_curve_speed; ///< max consist speed limited by curves
  82
  83         auto operator<=>(const TrainCache &) const = default;
  84 };
  85
  86 /**
  87  * 'Train' is either a loco or a wagon.
  88  */
  89 struct Train final : public GroundVehicle<Train, VEH_TRAIN> {
  90         uint16_t flags;
  91         uint16_t crash_anim_pos; ///< Crash animation counter.
  92         uint16_t wait_counter; ///< Ticks waiting in front of a signal, ticks being stuck or a counter for forced proceeding through signals.
  93
  94         TrainCache tcache;
  95
  96         /* Link between the two ends of a multiheaded engine */
  97         Train *other_multiheaded_part;
  98
  99         RailTypes compatible_railtypes;
 100         RailType railtype;
 101
 102         TrackBits track;
 103         TrainForceProceeding force_proceed;
 104
 105         /** We don't want GCC to zero our struct! It already is zeroed and has an index! */
 106         Train() : GroundVehicleBase() {}
 107         /** We want to 'destruct' the right class. */
 108         virtual ~Train() { this->PreDestructor(); }
 109
 110         friend struct GroundVehicle<Train, VEH_TRAIN>; // GroundVehicle needs to use the acceleration functions defined at Train.
 111
 112         void MarkDirty() override;
 113         void UpdateDeltaXY() override;
 114         ExpensesType GetExpenseType(bool income) const override { return income ? EXPENSES_TRAIN_REVENUE : EXPENSES_TRAIN_RUN; }
 115         void PlayLeaveStationSound(bool force = false) const override;
 116         bool IsPrimaryVehicle() const override { return this->IsFrontEngine(); }
 117         void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const override;
 118         int GetDisplaySpeed() const override { return this->gcache.last_speed; }
 119         int GetDisplayMaxSpeed() const override { return this->vcache.cached_max_speed; }
 120         Money GetRunningCost() const override;
 121         int GetCursorImageOffset() const;
 122         int GetDisplayImageWidth(Point *offset = nullptr) const;
 123         bool IsInDepot() const override { return this->track == TRACK_BIT_DEPOT; }
 124         bool Tick() override;
 125         void OnNewCalendarDay() override;
 126         void OnNewEconomyDay() override;
 127         uint Crash(bool flooded = false) override;
 128         Trackdir GetVehicleTrackdir() const override;
 129         TileIndex GetOrderStationLocation(StationID station) override;
 130         ClosestDepot FindClosestDepot() override;
 131
 132         void ReserveTrackUnderConsist() const;
 133
 134         uint16_t GetCurveSpeedLimit() const;
 135
 136         void ConsistChanged(ConsistChangeFlags allowed_changes);
 137
 138         int UpdateSpeed();
 139
 140         void UpdateAcceleration();
 141
 142         int GetCurrentMaxSpeed() const override;
 143
 144         /**
 145          * Get the next real (non-articulated part and non rear part of dualheaded engine) vehicle in the consist.
 146          * @return Next vehicle in the consist.
 147          */
 148         inline Train *GetNextUnit() const
 149         {
 150                 Train *v = this->GetNextVehicle();
 151                 if (v != nullptr && v->IsRearDualheaded()) v = v->GetNextVehicle();
 152
 153                 return v;
 154         }
 155
 156         /**
 157          * Get the previous real (non-articulated part and non rear part of dualheaded engine) vehicle in the consist.
 158          * @return Previous vehicle in the consist.
 159          */
 160         inline Train *GetPrevUnit()
 161         {
 162                 Train *v = this->GetPrevVehicle();
 163                 if (v != nullptr && v->IsRearDualheaded()) v = v->GetPrevVehicle();
 164
 165                 return v;
 166         }
 167
 168         /**
 169          * Calculate the offset from this vehicle's center to the following center taking the vehicle lengths into account.
 170          * @return Offset from center to center.
 171          */
 172         int CalcNextVehicleOffset() const
 173         {
 174                 /* For vehicles with odd lengths the part before the center will be one unit
 175                  * longer than the part after the center. This means we have to round up the
 176                  * length of the next vehicle but may not round the length of the current
 177                  * vehicle. */
 178                 return this->gcache.cached_veh_length / 2 + (this->Next() != nullptr ? this->Next()->gcache.cached_veh_length + 1 : 0) / 2;
 179         }
 180
 181 protected: // These functions should not be called outside acceleration code.
 182
 183         /**
 184          * Allows to know the power value that this vehicle will use.
 185          * @return Power value from the engine in HP, or zero if the vehicle is not powered.
 186          */
 187         inline uint16_t GetPower() const
 188         {
 189                 /* Power is not added for articulated parts */
 190                 if (!this->IsArticulatedPart() && HasPowerOnRail(this->railtype, GetRailType(this->tile))) {
 191                         uint16_t power = GetVehicleProperty(this, PROP_TRAIN_POWER, RailVehInfo(this->engine_type)->power);
 192                         /* Halve power for multiheaded parts */
 193                         if (this->IsMultiheaded()) power /= 2;
 194                         return power;
 195                 }
 196
 197                 return 0;
 198         }
 199
 200         /**
 201          * Returns a value if this articulated part is powered.
 202          * @return Power value from the articulated part in HP, or zero if it is not powered.
 203          */
 204         inline uint16_t GetPoweredPartPower(const Train *head) const
 205         {
 206                 /* For powered wagons the engine defines the type of engine (i.e. railtype) */
 207                 if (HasBit(this->flags, VRF_POWEREDWAGON) && HasPowerOnRail(head->railtype, GetRailType(this->tile))) {
 208                         return RailVehInfo(this->gcache.first_engine)->pow_wag_power;
 209                 }
 210
 211                 return 0;
 212         }
 213
 214         /**
 215          * Allows to know the weight value that this vehicle will use.
 216          * @return Weight value from the engine in tonnes.
 217          */
 218         inline uint16_t GetWeight() const
 219         {
 220                 uint16_t weight = CargoSpec::Get(this->cargo_type)->WeightOfNUnitsInTrain(this->cargo.StoredCount());
 221
 222                 /* Vehicle weight is not added for articulated parts. */
 223                 if (!this->IsArticulatedPart()) {
 224                         weight += GetVehicleProperty(this, PROP_TRAIN_WEIGHT, RailVehInfo(this->engine_type)->weight);
 225                 }
 226
 227                 /* Powered wagons have extra weight added. */
 228                 if (HasBit(this->flags, VRF_POWEREDWAGON)) {
 229                         weight += RailVehInfo(this->gcache.first_engine)->pow_wag_weight;
 230                 }
 231
 232                 return weight;
 233         }
 234
 235         /**
 236          * Calculates the weight value that this vehicle will have when fully loaded with its current cargo.
 237          * @return Weight value in tonnes.
 238          */
 239         uint16_t GetMaxWeight() const override;
 240
 241         /**
 242          * Allows to know the tractive effort value that this vehicle will use.
 243          * @return Tractive effort value from the engine.
 244          */
 245         inline uint8_t GetTractiveEffort() const
 246         {
 247                 return GetVehicleProperty(this, PROP_TRAIN_TRACTIVE_EFFORT, RailVehInfo(this->engine_type)->tractive_effort);
 248         }
 249
 250         /**
 251          * Gets the area used for calculating air drag.
 252          * @return Area of the engine in m^2.
 253          */
 254         inline uint8_t GetAirDragArea() const
 255         {
 256                 /* Air drag is higher in tunnels due to the limited cross-section. */
 257                 return (this->track == TRACK_BIT_WORMHOLE && this->vehstatus & VS_HIDDEN) ? 28 : 14;
 258         }
 259
 260         /**
 261          * Gets the air drag coefficient of this vehicle.
 262          * @return Air drag value from the engine.
 263          */
 264         inline uint8_t GetAirDrag() const
 265         {
 266                 return RailVehInfo(this->engine_type)->air_drag;
 267         }
 268
 269         /**
 270          * Checks the current acceleration status of this vehicle.
 271          * @return Acceleration status.
 272          */
 273         inline AccelStatus GetAccelerationStatus() const
 274         {
 275                 return (this->vehstatus & VS_STOPPED) || HasBit(this->flags, VRF_REVERSING) || HasBit(this->flags, VRF_TRAIN_STUCK) ? AS_BRAKE : AS_ACCEL;
 276         }
 277
 278         /**
 279          * Calculates the current speed of this vehicle.
 280          * @return Current speed in km/h-ish.
 281          */
 282         inline uint16_t GetCurrentSpeed() const
 283         {
 284                 return this->cur_speed;
 285         }
 286
 287         /**
 288          * Returns the rolling friction coefficient of this vehicle.
 289          * @return Rolling friction coefficient in [1e-4].
 290          */
 291         inline uint32_t GetRollingFriction() const
 292         {
 293                 /* Rolling friction for steel on steel is between 0.1% and 0.2%.
 294                  * The friction coefficient increases with speed in a way that
 295                  * it doubles at 512 km/h, triples at 1024 km/h and so on. */
 296                 return 15 * (512 + this->GetCurrentSpeed()) / 512;
 297         }
 298
 299         /**
 300          * Allows to know the acceleration type of a vehicle.
 301          * @return Acceleration type of the vehicle.
 302          */
 303         inline int GetAccelerationType() const
 304         {
 305                 return GetRailTypeInfo(this->railtype)->acceleration_type;
 306         }
 307
 308         /**
 309          * Returns the slope steepness used by this vehicle.
 310          * @return Slope steepness used by the vehicle.
 311          */
 312         inline uint32_t GetSlopeSteepness() const
 313         {
 314                 return _settings_game.vehicle.train_slope_steepness;
 315         }
 316
 317         /**
 318          * Gets the maximum speed allowed by the track for this vehicle.
 319          * @return Maximum speed allowed.
 320          */
 321         inline uint16_t GetMaxTrackSpeed() const
 322         {
 323                 return GetRailTypeInfo(GetRailType(this->tile))->max_speed;
 324         }
 325
 326         /**
 327          * Returns the curve speed modifier of this vehicle.
 328          * @return Current curve speed modifier, in fixed-point binary representation with 8 fractional bits.
 329          */
 330         inline int16_t GetCurveSpeedModifier() const
 331         {
 332                 return GetVehicleProperty(this, PROP_TRAIN_CURVE_SPEED_MOD, RailVehInfo(this->engine_type)->curve_speed_mod, true);
 333         }
 334
 335         /**
 336          * Checks if the vehicle is at a tile that can be sloped.
 337          * @return True if the tile can be sloped.
 338          */
 339         inline bool TileMayHaveSlopedTrack() const
 340         {
 341                 /* Any track that isn't TRACK_BIT_X or TRACK_BIT_Y cannot be sloped. */
 342                 return this->track == TRACK_BIT_X || this->track == TRACK_BIT_Y;
 343         }
 344
 345         /**
 346          * Trains can always use the faster algorithm because they
 347          * have always the same direction as the track under them.
 348          * @return false
 349          */
 350         inline bool HasToUseGetSlopePixelZ()
 351         {
 352                 return false;
 353         }
 354 };
 355
 356 #endif /* TRAIN_H */