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 <http://www.gnu.org/licenses/>.
 */
 
#ifndef RAIL_H
#define RAIL_H
 
#include "rail_type.h"
#include "track_type.h"
#include "gfx_type.h"
#include "core/bitmath_func.hpp"
#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 RailTypeSpriteGroup : uint8_t {
  RTSG_CURSORS,     
  RTSG_OVERLAY,     
  RTSG_GROUND,      
  RTSG_TUNNEL,      
  RTSG_WIRES,       
  RTSG_PYLONS,      
  RTSG_BRIDGE,      
  RTSG_CROSSING,    
  RTSG_DEPOT,       
  RTSG_FENCES,      
  RTSG_TUNNEL_PORTAL, 
  RTSG_SIGNALS,     
  RTSG_GROUND_COMPLETE, 
  RTSG_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;       
    SpriteID signals[SIGTYPE_END][2][2]; 
  } 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;
 
  const GRFFile *grffile[RTSG_END];
 
  const SpriteGroup *group[RTSG_END];
 
  std::vector<BadgeID> badges;
 
  inline bool UsesOverlay() const
  {
    return this->group[RTSG_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[PR_BUILD_RAIL] * 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[PR_CLEAR_RAIL], -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[PR_INFRASTRUCTURE_RAIL] * 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[PR_INFRASTRUCTURE_RAIL] * 15 * num * (1 + IntSqrt(num))) >> 8; // 1 bit fraction for the multiplier and 7 bits scaling.
}
 
void DrawTrainDepotSprite(int x, int y, int image, 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 */