src/rail.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 rail.h Rail specific functions. */
   9
  10 #ifndef RAIL_H
  11 #define RAIL_H
  12
  13 #include "rail_type.h"
  14 #include "track_type.h"
  15 #include "gfx_type.h"
  16 #include "core/bitmath_func.hpp"
  17 #include "economy_func.h"
  18 #include "slope_type.h"
  19 #include "strings_type.h"
  20 #include "date_type.h"
  21 #include "signal_type.h"
  22 #include "settings_type.h"
  23
  24 /** Railtype flags. */
  25 enum RailTypeFlags {
  26         RTF_CATENARY          = 0,                           ///< Bit number for drawing a catenary.
  27         RTF_NO_LEVEL_CROSSING = 1,                           ///< Bit number for disallowing level crossings.
  28         RTF_HIDDEN            = 2,                           ///< Bit number for hiding from selection.
  29         RTF_NO_SPRITE_COMBINE = 3,                           ///< Bit number for using non-combined junctions.
  30         RTF_ALLOW_90DEG       = 4,                           ///< Bit number for always allowed 90 degree turns, regardless of setting.
  31         RTF_DISALLOW_90DEG    = 5,                           ///< Bit number for never allowed 90 degree turns, regardless of setting.
  32
  33         RTFB_NONE              = 0,                          ///< All flags cleared.
  34         RTFB_CATENARY          = 1 << RTF_CATENARY,          ///< Value for drawing a catenary.
  35         RTFB_NO_LEVEL_CROSSING = 1 << RTF_NO_LEVEL_CROSSING, ///< Value for disallowing level crossings.
  36         RTFB_HIDDEN            = 1 << RTF_HIDDEN,            ///< Value for hiding from selection.
  37         RTFB_NO_SPRITE_COMBINE = 1 << RTF_NO_SPRITE_COMBINE, ///< Value for using non-combined junctions.
  38         RTFB_ALLOW_90DEG       = 1 << RTF_ALLOW_90DEG,       ///< Value for always allowed 90 degree turns, regardless of setting.
  39         RTFB_DISALLOW_90DEG    = 1 << RTF_DISALLOW_90DEG,    ///< Value for never allowed 90 degree turns, regardless of setting.
  40 };
  41 DECLARE_ENUM_AS_BIT_SET(RailTypeFlags)
  42
  43 struct SpriteGroup;
  44
  45 /** Sprite groups for a railtype. */
  46 enum RailTypeSpriteGroup {
  47         RTSG_CURSORS,     ///< Cursor and toolbar icon images
  48         RTSG_OVERLAY,     ///< Images for overlaying track
  49         RTSG_GROUND,      ///< Main group of ground images
  50         RTSG_TUNNEL,      ///< Main group of ground images for snow or desert
  51         RTSG_WIRES,       ///< Catenary wires
  52         RTSG_PYLONS,      ///< Catenary pylons
  53         RTSG_BRIDGE,      ///< Bridge surface images
  54         RTSG_CROSSING,    ///< Level crossing overlay images
  55         RTSG_DEPOT,       ///< Depot images
  56         RTSG_FENCES,      ///< Fence images
  57         RTSG_TUNNEL_PORTAL, ///< Tunnel portal overlay
  58         RTSG_SIGNALS,     ///< Signal images
  59         RTSG_GROUND_COMPLETE, ///< Complete ground images
  60         RTSG_END,
  61 };
  62
  63 /**
  64  * Offsets for sprites within an overlay/underlay set.
  65  * These are the same for overlay and underlay sprites.
  66  */
  67 enum RailTrackOffset {
  68         RTO_X,            ///< Piece of rail in X direction
  69         RTO_Y,            ///< Piece of rail in Y direction
  70         RTO_N,            ///< Piece of rail in northern corner
  71         RTO_S,            ///< Piece of rail in southern corner
  72         RTO_E,            ///< Piece of rail in eastern corner
  73         RTO_W,            ///< Piece of rail in western corner
  74         RTO_SLOPE_NE,     ///< Piece of rail on slope with north-east raised
  75         RTO_SLOPE_SE,     ///< Piece of rail on slope with south-east raised
  76         RTO_SLOPE_SW,     ///< Piece of rail on slope with south-west raised
  77         RTO_SLOPE_NW,     ///< Piece of rail on slope with north-west raised
  78         RTO_CROSSING_XY,  ///< Crossing of X and Y rail, with ballast
  79         RTO_JUNCTION_SW,  ///< Ballast for junction 'pointing' SW
  80         RTO_JUNCTION_NE,  ///< Ballast for junction 'pointing' NE
  81         RTO_JUNCTION_SE,  ///< Ballast for junction 'pointing' SE
  82         RTO_JUNCTION_NW,  ///< Ballast for junction 'pointing' NW
  83         RTO_JUNCTION_NSEW,///< Ballast for full junction
  84 };
  85
  86 /**
  87  * Offsets for sprites within a bridge surface overlay set.
  88  */
  89 enum RailTrackBridgeOffset {
  90         RTBO_X,     ///< Piece of rail in X direction
  91         RTBO_Y,     ///< Piece of rail in Y direction
  92         RTBO_SLOPE, ///< Sloped rail pieces, in order NE, SE, SW, NW
  93 };
  94
  95 /**
  96  * Offsets from base sprite for fence sprites. These are in the order of
  97  *  the sprites in the original data files.
  98  */
  99 enum RailFenceOffset {
 100         RFO_FLAT_X_NW,     //!< Slope FLAT, Track X,     Fence NW
 101         RFO_FLAT_Y_NE,     //!< Slope FLAT, Track Y,     Fence NE
 102         RFO_FLAT_LEFT,     //!< Slope FLAT, Track LEFT,  Fence E
 103         RFO_FLAT_UPPER,    //!< Slope FLAT, Track UPPER, Fence S
 104         RFO_SLOPE_SW_NW,   //!< Slope SW,   Track X,     Fence NW
 105         RFO_SLOPE_SE_NE,   //!< Slope SE,   Track Y,     Fence NE
 106         RFO_SLOPE_NE_NW,   //!< Slope NE,   Track X,     Fence NW
 107         RFO_SLOPE_NW_NE,   //!< Slope NW,   Track Y,     Fence NE
 108         RFO_FLAT_X_SE,     //!< Slope FLAT, Track X,     Fence SE
 109         RFO_FLAT_Y_SW,     //!< Slope FLAT, Track Y,     Fence SW
 110         RFO_FLAT_RIGHT,    //!< Slope FLAT, Track RIGHT, Fence W
 111         RFO_FLAT_LOWER,    //!< Slope FLAT, Track LOWER, Fence N
 112         RFO_SLOPE_SW_SE,   //!< Slope SW,   Track X,     Fence SE
 113         RFO_SLOPE_SE_SW,   //!< Slope SE,   Track Y,     Fence SW
 114         RFO_SLOPE_NE_SE,   //!< Slope NE,   Track X,     Fence SE
 115         RFO_SLOPE_NW_SW,   //!< Slope NW,   Track Y,     Fence SW
 116 };
 117
 118 /** List of rail type labels. */
 119 typedef std::vector<RailTypeLabel> RailTypeLabelList;
 120
 121 /**
 122  * This struct contains all the info that is needed to draw and construct tracks.
 123  */
 124 class RailtypeInfo {
 125 public:
 126         /**
 127          * Struct containing the main sprites. @note not all sprites are listed, but only
 128          *  the ones used directly in the code
 129          */
 130         struct {
 131                 SpriteID track_y;      ///< single piece of rail in Y direction, with ground
 132                 SpriteID track_ns;     ///< two pieces of rail in North and South corner (East-West direction)
 133                 SpriteID ground;       ///< ground sprite for a 3-way switch
 134                 SpriteID single_x;     ///< single piece of rail in X direction, without ground
 135                 SpriteID single_y;     ///< single piece of rail in Y direction, without ground
 136                 SpriteID single_n;     ///< single piece of rail in the northern corner
 137                 SpriteID single_s;     ///< single piece of rail in the southern corner
 138                 SpriteID single_e;     ///< single piece of rail in the eastern corner
 139                 SpriteID single_w;     ///< single piece of rail in the western corner
 140                 SpriteID single_sloped;///< single piece of rail for slopes
 141                 SpriteID crossing;     ///< level crossing, rail in X direction
 142                 SpriteID tunnel;       ///< tunnel sprites base
 143         } base_sprites;
 144
 145         /**
 146          * struct containing the sprites for the rail GUI. @note only sprites referred to
 147          * directly in the code are listed
 148          */
 149         struct {
 150                 SpriteID build_ns_rail;      ///< button for building single rail in N-S direction
 151                 SpriteID build_x_rail;       ///< button for building single rail in X direction
 152                 SpriteID build_ew_rail;      ///< button for building single rail in E-W direction
 153                 SpriteID build_y_rail;       ///< button for building single rail in Y direction
 154                 SpriteID auto_rail;          ///< button for the autorail construction
 155                 SpriteID build_depot;        ///< button for building depots
 156                 SpriteID build_tunnel;       ///< button for building a tunnel
 157                 SpriteID convert_rail;       ///< button for converting rail
 158                 SpriteID signals[SIGTYPE_END][2][2]; ///< signal GUI sprites (type, variant, state)
 159         } gui_sprites;
 160
 161         struct {
 162                 CursorID rail_ns;    ///< Cursor for building rail in N-S direction
 163                 CursorID rail_swne;  ///< Cursor for building rail in X direction
 164                 CursorID rail_ew;    ///< Cursor for building rail in E-W direction
 165                 CursorID rail_nwse;  ///< Cursor for building rail in Y direction
 166                 CursorID autorail;   ///< Cursor for autorail tool
 167                 CursorID depot;      ///< Cursor for building a depot
 168                 CursorID tunnel;     ///< Cursor for building a tunnel
 169                 CursorID convert;    ///< Cursor for converting track
 170         } cursor;                    ///< Cursors associated with the rail type.
 171
 172         struct {
 173                 StringID name;            ///< Name of this rail type.
 174                 StringID toolbar_caption; ///< Caption in the construction toolbar GUI for this rail type.
 175                 StringID menu_text;       ///< Name of this rail type in the main toolbar dropdown.
 176                 StringID build_caption;   ///< Caption of the build vehicle GUI for this rail type.
 177                 StringID replace_text;    ///< Text used in the autoreplace GUI.
 178                 StringID new_loco;        ///< Name of an engine for this type of rail in the engine preview GUI.
 179         } strings;                        ///< Strings associated with the rail type.
 180
 181         /** sprite number difference between a piece of track on a snowy ground and the corresponding one on normal ground */
 182         SpriteID snow_offset;
 183
 184         /** bitmask to the OTHER railtypes on which an engine of THIS railtype generates power */
 185         RailTypes powered_railtypes;
 186
 187         /** bitmask to the OTHER railtypes on which an engine of THIS railtype can physically travel */
 188         RailTypes compatible_railtypes;
 189
 190         /**
 191          * Bridge offset
 192          */
 193         SpriteID bridge_offset;
 194
 195         /**
 196          * Original railtype number to use when drawing non-newgrf railtypes, or when drawing stations.
 197          */
 198         byte fallback_railtype;
 199
 200         /**
 201          * Multiplier for curve maximum speed advantage
 202          */
 203         byte curve_speed;
 204
 205         /**
 206          * Bit mask of rail type flags
 207          */
 208         RailTypeFlags flags;
 209
 210         /**
 211          * Cost multiplier for building this rail type
 212          */
 213         uint16 cost_multiplier;
 214
 215         /**
 216          * Cost multiplier for maintenance of this rail type
 217          */
 218         uint16 maintenance_multiplier;
 219
 220         /**
 221          * Acceleration type of this rail type
 222          */
 223         uint8 acceleration_type;
 224
 225         /**
 226          * Maximum speed for vehicles travelling on this rail type
 227          */
 228         uint16 max_speed;
 229
 230         /**
 231          * Unique 32 bit rail type identifier
 232          */
 233         RailTypeLabel label;
 234
 235         /**
 236          * Rail type labels this type provides in addition to the main label.
 237          */
 238         RailTypeLabelList alternate_labels;
 239
 240         /**
 241          * Colour on mini-map
 242          */
 243         byte map_colour;
 244
 245         /**
 246          * Introduction date.
 247          * When #INVALID_DATE or a vehicle using this railtype gets introduced earlier,
 248          * the vehicle's introduction date will be used instead for this railtype.
 249          * The introduction at this date is furthermore limited by the
 250          * #introduction_required_railtypes.
 251          */
 252         Date introduction_date;
 253
 254         /**
 255          * Bitmask of railtypes that are required for this railtype to be introduced
 256          * at a given #introduction_date.
 257          */
 258         RailTypes introduction_required_railtypes;
 259
 260         /**
 261          * Bitmask of which other railtypes are introduced when this railtype is introduced.
 262          */
 263         RailTypes introduces_railtypes;
 264
 265         /**
 266          * The sorting order of this railtype for the toolbar dropdown.
 267          */
 268         byte sorting_order;
 269
 270         /**
 271          * NewGRF providing the Action3 for the railtype. nullptr if not available.
 272          */
 273         const GRFFile *grffile[RTSG_END];
 274
 275         /**
 276          * Sprite groups for resolving sprites
 277          */
 278         const SpriteGroup *group[RTSG_END];
 279
 280         inline bool UsesOverlay() const
 281         {
 282                 return this->group[RTSG_GROUND] != nullptr;
 283         }
 284
 285         /**
 286          * Offset between the current railtype and normal rail. This means that:<p>
 287          * 1) All the sprites in a railset MUST be in the same order. This order
 288          *    is determined by normal rail. Check sprites 1005 and following for this order<p>
 289          * 2) The position where the railtype is loaded must always be the same, otherwise
 290          *    the offset will fail.
 291          */
 292         inline uint GetRailtypeSpriteOffset() const
 293         {
 294                 return 82 * this->fallback_railtype;
 295         }
 296 };
 297
 298
 299 /**
 300  * Returns a pointer to the Railtype information for a given railtype
 301  * @param railtype the rail type which the information is requested for
 302  * @return The pointer to the RailtypeInfo
 303  */
 304 static inline const RailtypeInfo *GetRailTypeInfo(RailType railtype)
 305 {
 306         extern RailtypeInfo _railtypes[RAILTYPE_END];
 307         assert(railtype < RAILTYPE_END);
 308         return &_railtypes[railtype];
 309 }
 310
 311 /**
 312  * Checks if an engine of the given RailType can drive on a tile with a given
 313  * RailType. This would normally just be an equality check, but for electric
 314  * rails (which also support non-electric engines).
 315  * @return Whether the engine can drive on this tile.
 316  * @param  enginetype The RailType of the engine we are considering.
 317  * @param  tiletype   The RailType of the tile we are considering.
 318  */
 319 static inline bool IsCompatibleRail(RailType enginetype, RailType tiletype)
 320 {
 321         return HasBit(GetRailTypeInfo(enginetype)->compatible_railtypes, tiletype);
 322 }
 323
 324 /**
 325  * Checks if an engine of the given RailType got power on a tile with a given
 326  * RailType. This would normally just be an equality check, but for electric
 327  * rails (which also support non-electric engines).
 328  * @return Whether the engine got power on this tile.
 329  * @param  enginetype The RailType of the engine we are considering.
 330  * @param  tiletype   The RailType of the tile we are considering.
 331  */
 332 static inline bool HasPowerOnRail(RailType enginetype, RailType tiletype)
 333 {
 334         return HasBit(GetRailTypeInfo(enginetype)->powered_railtypes, tiletype);
 335 }
 336
 337 /**
 338  * Test if a RailType disallows build of level crossings.
 339  * @param rt The RailType to check.
 340  * @return Whether level crossings are not allowed.
 341  */
 342 static inline bool RailNoLevelCrossings(RailType rt)
 343 {
 344         return HasBit(GetRailTypeInfo(rt)->flags, RTF_NO_LEVEL_CROSSING);
 345 }
 346
 347 /**
 348  * Test if 90 degree turns are disallowed between two railtypes.
 349  * @param rt1 First railtype to test for.
 350  * @param rt2 Second railtype to test for.
 351  * @param def Default value to use if the rail type doesn't specify anything.
 352  * @return True if 90 degree turns are disallowed between the two rail types.
 353  */
 354 static inline bool Rail90DegTurnDisallowed(RailType rt1, RailType rt2, bool def = _settings_game.pf.forbid_90_deg)
 355 {
 356         if (rt1 == INVALID_RAILTYPE || rt2 == INVALID_RAILTYPE) return def;
 357
 358         const RailtypeInfo *rti1 = GetRailTypeInfo(rt1);
 359         const RailtypeInfo *rti2 = GetRailTypeInfo(rt2);
 360
 361         bool rt1_90deg = HasBit(rti1->flags, RTF_DISALLOW_90DEG) || (!HasBit(rti1->flags, RTF_ALLOW_90DEG) && def);
 362         bool rt2_90deg = HasBit(rti2->flags, RTF_DISALLOW_90DEG) || (!HasBit(rti2->flags, RTF_ALLOW_90DEG) && def);
 363
 364         return rt1_90deg || rt2_90deg;
 365 }
 366
 367 /**
 368  * Returns the cost of building the specified railtype.
 369  * @param railtype The railtype being built.
 370  * @return The cost multiplier.
 371  */
 372 static inline Money RailBuildCost(RailType railtype)
 373 {
 374         assert(railtype < RAILTYPE_END);
 375         return (_price[PR_BUILD_RAIL] * GetRailTypeInfo(railtype)->cost_multiplier) >> 3;
 376 }
 377
 378 /**
 379  * Returns the 'cost' of clearing the specified railtype.
 380  * @param railtype The railtype being removed.
 381  * @return The cost.
 382  */
 383 static inline Money RailClearCost(RailType railtype)
 384 {
 385         /* Clearing rail in fact earns money, but if the build cost is set
 386          * very low then a loophole exists where money can be made.
 387          * In this case we limit the removal earnings to 3/4s of the build
 388          * cost.
 389          */
 390         assert(railtype < RAILTYPE_END);
 391         return max(_price[PR_CLEAR_RAIL], -RailBuildCost(railtype) * 3 / 4);
 392 }
 393
 394 /**
 395  * Calculates the cost of rail conversion
 396  * @param from The railtype we are converting from
 397  * @param to   The railtype we are converting to
 398  * @return Cost per TrackBit
 399  */
 400 static inline Money RailConvertCost(RailType from, RailType to)
 401 {
 402         /* Get the costs for removing and building anew
 403          * A conversion can never be more costly */
 404         Money rebuildcost = RailBuildCost(to) + RailClearCost(from);
 405
 406         /* Conversion between somewhat compatible railtypes:
 407          * Pay 1/8 of the target rail cost (labour costs) and additionally any difference in the
 408          * build costs, if the target type is more expensive (material upgrade costs).
 409          * Upgrade can never be more expensive than re-building. */
 410         if (HasPowerOnRail(from, to) || HasPowerOnRail(to, from)) {
 411                 Money upgradecost = RailBuildCost(to) / 8 + max((Money)0, RailBuildCost(to) - RailBuildCost(from));
 412                 return min(upgradecost, rebuildcost);
 413         }
 414
 415         /* make the price the same as remove + build new type for rail types
 416          * which are not compatible in any way */
 417         return rebuildcost;
 418 }
 419
 420 /**
 421  * Calculates the maintenance cost of a number of track bits.
 422  * @param railtype The railtype to get the cost of.
 423  * @param num Number of track bits of this railtype.
 424  * @param total_num Total number of track bits of all railtypes.
 425  * @return Total cost.
 426  */
 427 static inline Money RailMaintenanceCost(RailType railtype, uint32 num, uint32 total_num)
 428 {
 429         assert(railtype < RAILTYPE_END);
 430         return (_price[PR_INFRASTRUCTURE_RAIL] * GetRailTypeInfo(railtype)->maintenance_multiplier * num * (1 + IntSqrt(total_num))) >> 11; // 4 bits fraction for the multiplier and 7 bits scaling.
 431 }
 432
 433 /**
 434  * Calculates the maintenance cost of a number of signals.
 435  * @param num Number of signals.
 436  * @return Total cost.
 437  */
 438 static inline Money SignalMaintenanceCost(uint32 num)
 439 {
 440         return (_price[PR_INFRASTRUCTURE_RAIL] * 15 * num * (1 + IntSqrt(num))) >> 8; // 1 bit fraction for the multiplier and 7 bits scaling.
 441 }
 442
 443 void DrawTrainDepotSprite(int x, int y, int image, RailType railtype);
 444 int TicksToLeaveDepot(const Train *v);
 445
 446 Foundation GetRailFoundation(Slope tileh, TrackBits bits);
 447
 448
 449 bool HasRailtypeAvail(const CompanyID company, const RailType railtype);
 450 bool HasAnyRailtypesAvail(const CompanyID company);
 451 bool ValParamRailtype(const RailType rail);
 452
 453 RailTypes AddDateIntroducedRailTypes(RailTypes current, Date date);
 454
 455 RailTypes GetCompanyRailtypes(CompanyID company, bool introduces = true);
 456 RailTypes GetRailTypes(bool introduces);
 457
 458 RailType GetRailTypeByLabel(RailTypeLabel label, bool allow_alternate_labels = true);
 459
 460 void ResetRailTypes();
 461 void InitRailTypes();
 462 RailType AllocateRailType(RailTypeLabel label);
 463
 464 extern std::vector<RailType> _sorted_railtypes;
 465 extern RailTypes _railtypes_hidden_mask;
 466
 467 /**
 468  * Loop header for iterating over railtypes, sorted by sortorder.
 469  * @param var Railtype.
 470  */
 471 #define FOR_ALL_SORTED_RAILTYPES(var) for (uint8 index = 0; index < _sorted_railtypes.size() && (var = _sorted_railtypes[index], true) ; index++)
 472
 473 #endif /* RAIL_H */