src/train.h

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