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