rail.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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef RAIL_H
#define RAIL_H
 
#include "rail_type.h"
#include "track_type.h"
#include "gfx_type.h"
#include "core/enum_type.hpp"
#include "core/flatset_type.hpp"
#include "economy_func.h"
#include "slope_type.h"
#include "strings_type.h"
#include "timer/timer_game_calendar.h"
#include "signal_type.h"
#include "settings_type.h"
#include "newgrf_badge_type.h"

enum class RailTypeFlag : uint8_t {
  Catenary        = 0, 
  NoLevelCrossing = 1, 
  Hidden          = 2, 
  NoSpriteCombine = 3, 
  Allow90Deg      = 4, 
  Disallow90Deg   = 5, 
};

using RailTypeFlags = EnumBitSet<RailTypeFlag, uint8_t>;
 
struct SpriteGroup;

enum class RailSpriteType : uint8_t {
  UI, 
  Overlay, 
  Ground, 
  Tunnel, 
  Wires, 
  Pylons, 
  Bridge, 
  Crossing, 
  Depot, 
  Fences, 
  TunnelPortal, 
  Signals, 
  GroundComplete, 
  End, 
};

enum RailTrackOffset : uint8_t {
  RTO_X,            
  RTO_Y,            
  RTO_N,            
  RTO_S,            
  RTO_E,            
  RTO_W,            
  RTO_SLOPE_NE,     
  RTO_SLOPE_SE,     
  RTO_SLOPE_SW,     
  RTO_SLOPE_NW,     
  RTO_CROSSING_XY,  
  RTO_JUNCTION_SW,  
  RTO_JUNCTION_NE,  
  RTO_JUNCTION_SE,  
  RTO_JUNCTION_NW,  
  RTO_JUNCTION_NSEW,
};

enum RailTrackBridgeOffset : uint8_t {
  RTBO_X,     
  RTBO_Y,     
  RTBO_SLOPE, 
};

enum RailFenceOffset : uint8_t {
  RFO_FLAT_X_NW,     
  RFO_FLAT_Y_NE,     
  RFO_FLAT_LEFT,     
  RFO_FLAT_UPPER,    
  RFO_SLOPE_SW_NW,   
  RFO_SLOPE_SE_NE,   
  RFO_SLOPE_NE_NW,   
  RFO_SLOPE_NW_NE,   
  RFO_FLAT_X_SE,     
  RFO_FLAT_Y_SW,     
  RFO_FLAT_RIGHT,    
  RFO_FLAT_LOWER,    
  RFO_SLOPE_SW_SE,   
  RFO_SLOPE_SE_SW,   
  RFO_SLOPE_NE_SE,   
  RFO_SLOPE_NW_SW,   
};

class RailTypeInfo {
public:
  struct {
    SpriteID track_y;      
    SpriteID track_ns;     
    SpriteID ground;       
    SpriteID single_x;     
    SpriteID single_y;     
    SpriteID single_n;     
    SpriteID single_s;     
    SpriteID single_e;     
    SpriteID single_w;     
    SpriteID single_sloped;
    SpriteID crossing;     
    SpriteID tunnel;       
    SpriteID bridge_deck;  
  } base_sprites;

  struct {
    SpriteID build_ns_rail;      
    SpriteID build_x_rail;       
    SpriteID build_ew_rail;      
    SpriteID build_y_rail;       
    SpriteID auto_rail;          
    SpriteID build_depot;        
    SpriteID build_tunnel;       
    SpriteID convert_rail;       
    EnumIndexArray<EnumIndexArray<EnumIndexArray<SpriteID, SignalState, SignalState::End>, SignalVariant, SignalVariant::End>, SignalType, SignalType::End> signals; 
  } gui_sprites;
 
  struct {
    CursorID rail_ns;    
    CursorID rail_swne;  
    CursorID rail_ew;    
    CursorID rail_nwse;  
    CursorID autorail;   
    CursorID depot;      
    CursorID tunnel;     
    CursorID convert;    
  } cursor;                    
 
  struct {
    StringID name;            
    StringID toolbar_caption; 
    StringID menu_text;       
    StringID build_caption;   
    StringID replace_text;    
    StringID new_loco;        
  } strings;                        

  SpriteID snow_offset;

  RailTypes powered_railtypes;

  RailTypes compatible_railtypes;

  uint8_t bridge_offset;

  uint8_t fallback_railtype;

  uint8_t curve_speed;

  RailTypeFlags flags;

  uint16_t cost_multiplier;

  uint16_t maintenance_multiplier;

  VehicleAccelerationModel acceleration_type;

  uint16_t max_speed;

  RailTypeLabel label;

  FlatSet<RailTypeLabel> alternate_labels;

  PixelColour map_colour;

  TimerGameCalendar::Date introduction_date;

  RailTypes introduction_required_railtypes;

  RailTypes introduces_railtypes;

  uint8_t sorting_order;

  EnumIndexArray<const GRFFile *, RailSpriteType, RailSpriteType::End> grffile{};

  EnumIndexArray<const SpriteGroup *, RailSpriteType, RailSpriteType::End> group{};
 
  std::vector<BadgeID> badges;
 
  inline bool UsesOverlay() const
  {
    return this->group[RailSpriteType::Ground] != nullptr;
  }

  inline uint GetRailtypeSpriteOffset() const
  {
    return 82 * this->fallback_railtype;
  }
 
  RailType Index() const;
};
 

inline const RailTypeInfo *GetRailTypeInfo(RailType railtype)
{
  extern RailTypeInfo _railtypes[RAILTYPE_END];
  assert(railtype < RAILTYPE_END);
  return &_railtypes[railtype];
}

inline RailTypes GetAllCompatibleRailTypes(RailTypes railtypes)
{
  RailTypes compatible{};
  for (RailType rt : railtypes) compatible.Set(GetRailTypeInfo(rt)->compatible_railtypes);
  return compatible;
}

inline RailTypes GetAllPoweredRailTypes(RailTypes railtypes)
{
  RailTypes powered{};
  for (RailType rt : railtypes) powered.Set(GetRailTypeInfo(rt)->powered_railtypes);
  return powered;
}

inline RailTypes GetAllIntroducesRailTypes(RailTypes railtypes)
{
  RailTypes introduces{};
  for (RailType rt : railtypes) introduces.Set(GetRailTypeInfo(rt)->introduces_railtypes);
  return introduces;
}

inline bool IsCompatibleRail(RailType enginetype, RailType tiletype)
{
  return GetRailTypeInfo(enginetype)->compatible_railtypes.Test(tiletype);
}

inline bool IsCompatibleRail(RailTypes enginetype, RailType tiletype)
{
  return GetAllCompatibleRailTypes(enginetype).Test(tiletype);
}

inline bool HasPowerOnRail(RailType enginetype, RailType tiletype)
{
  return GetRailTypeInfo(enginetype)->powered_railtypes.Test(tiletype);
}

inline bool HasPowerOnRail(RailTypes enginetype, RailType tiletype)
{
  return GetAllPoweredRailTypes(enginetype).Test(tiletype);
}

inline bool RailNoLevelCrossings(RailType rt)
{
  return GetRailTypeInfo(rt)->flags.Test(RailTypeFlag::NoLevelCrossing);
}

inline bool Rail90DegTurnDisallowed(RailType rt1, RailType rt2, bool def = _settings_game.pf.forbid_90_deg)
{
  if (rt1 == INVALID_RAILTYPE || rt2 == INVALID_RAILTYPE) return def;
 
  const RailTypeInfo *rti1 = GetRailTypeInfo(rt1);
  const RailTypeInfo *rti2 = GetRailTypeInfo(rt2);
 
  bool rt1_90deg = rti1->flags.Test(RailTypeFlag::Disallow90Deg) || (!rti1->flags.Test(RailTypeFlag::Allow90Deg) && def);
  bool rt2_90deg = rti2->flags.Test(RailTypeFlag::Disallow90Deg) || (!rti2->flags.Test(RailTypeFlag::Allow90Deg) && def);
 
  return rt1_90deg || rt2_90deg;
}

inline Money RailBuildCost(RailType railtype)
{
  assert(railtype < RAILTYPE_END);
  return (_price[Price::BuildRail] * GetRailTypeInfo(railtype)->cost_multiplier) >> 3;
}

inline Money RailClearCost(RailType railtype)
{
  /* Clearing rail in fact earns money, but if the build cost is set
   * very low then a loophole exists where money can be made.
   * In this case we limit the removal earnings to 3/4s of the build
   * cost.
   */
  assert(railtype < RAILTYPE_END);
  return std::max(_price[Price::ClearRail], -RailBuildCost(railtype) * 3 / 4);
}

inline Money RailConvertCost(RailType from, RailType to)
{
  /* Get the costs for removing and building anew
   * A conversion can never be more costly */
  Money rebuildcost = RailBuildCost(to) + RailClearCost(from);
 
  /* Conversion between somewhat compatible railtypes:
   * Pay 1/8 of the target rail cost (labour costs) and additionally any difference in the
   * build costs, if the target type is more expensive (material upgrade costs).
   * Upgrade can never be more expensive than re-building. */
  if (HasPowerOnRail(from, to) || HasPowerOnRail(to, from)) {
    Money upgradecost = RailBuildCost(to) / 8 + std::max((Money)0, RailBuildCost(to) - RailBuildCost(from));
    return std::min(upgradecost, rebuildcost);
  }
 
  /* make the price the same as remove + build new type for rail types
   * which are not compatible in any way */
  return rebuildcost;
}

inline Money RailMaintenanceCost(RailType railtype, uint32_t num, uint32_t total_num)
{
  assert(railtype < RAILTYPE_END);
  return (_price[Price::InfrastructureRail] * GetRailTypeInfo(railtype)->maintenance_multiplier * num * (1 + IntSqrt(total_num))) >> 11; // 4 bits fraction for the multiplier and 7 bits scaling.
}

inline Money SignalMaintenanceCost(uint32_t num)
{
  return (_price[Price::InfrastructureRail] * 15 * num * (1 + IntSqrt(num))) >> 8; // 1 bit fraction for the multiplier and 7 bits scaling.
}
 
void DrawTrainDepotSprite(int x, int y, DiagDirection dir, RailType railtype);
int TicksToLeaveDepot(const Train *v);
 
Foundation GetRailFoundation(Slope tileh, TrackBits bits);
 
 
bool HasRailTypeAvail(const CompanyID company, const RailType railtype);
bool HasAnyRailTypesAvail(const CompanyID company);
bool ValParamRailType(const RailType rail);
 
RailTypes AddDateIntroducedRailTypes(RailTypes current, TimerGameCalendar::Date date);
 
RailTypes GetCompanyRailTypes(CompanyID company, bool introduces = true);
RailTypes GetRailTypes(bool introduces);
 
RailType GetRailTypeByLabel(RailTypeLabel label, bool allow_alternate_labels = true);
 
void ResetRailTypes();
void InitRailTypes();
RailType AllocateRailType(RailTypeLabel label);
 
extern std::vector<RailType> _sorted_railtypes;
extern RailTypes _railtypes_hidden_mask;
 
#endif /* RAIL_H */