road.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 ROAD_H
#define ROAD_H
 
#include "road_type.h"
#include "gfx_type.h"
#include "core/bitmath_func.hpp"
#include "strings_type.h"
#include "timer/timer_game_calendar.h"
#include "core/enum_type.hpp"
#include "newgrf.h"
#include "economy_func.h"
 
 
enum RoadTramType : bool {
  RTT_ROAD,
  RTT_TRAM,
};
 
enum RoadTramTypes : uint8_t {
  RTTB_ROAD = 1 << RTT_ROAD,
  RTTB_TRAM = 1 << RTT_TRAM,
};
DECLARE_ENUM_AS_BIT_SET(RoadTramTypes)
 
static const RoadTramType _roadtramtypes[] = { RTT_ROAD, RTT_TRAM };
 
enum RoadTypeFlag {
  ROTF_CATENARY = 0,                                     
  ROTF_NO_LEVEL_CROSSING,                                
  ROTF_NO_HOUSES,                                        
  ROTF_HIDDEN,                                           
  ROTF_TOWN_BUILD,                                       
};
 
enum RoadTypeFlags : uint8_t {
  ROTFB_NONE = 0,                                        
  ROTFB_CATENARY          = 1 << ROTF_CATENARY,          
  ROTFB_NO_LEVEL_CROSSING = 1 << ROTF_NO_LEVEL_CROSSING, 
  ROTFB_NO_HOUSES         = 1 << ROTF_NO_HOUSES,         
  ROTFB_HIDDEN            = 1 << ROTF_HIDDEN,            
  ROTFB_TOWN_BUILD        = 1 << ROTF_TOWN_BUILD,        
};
DECLARE_ENUM_AS_BIT_SET(RoadTypeFlags)
 
struct SpriteGroup;
 
enum RoadTypeSpriteGroup {
  ROTSG_CURSORS,        
  ROTSG_OVERLAY,        
  ROTSG_GROUND,         
  ROTSG_TUNNEL,         
  ROTSG_CATENARY_FRONT, 
  ROTSG_CATENARY_BACK,  
  ROTSG_BRIDGE,         
  ROTSG_reserved2,      
  ROTSG_DEPOT,          
  ROTSG_reserved3,      
  ROTSG_ROADSTOP,       
  ROTSG_ONEWAY,         
  ROTSG_END,
};
 
typedef std::vector<RoadTypeLabel> RoadTypeLabelList;
 
class RoadTypeInfo {
public:
  struct {
    SpriteID build_x_road;        
    SpriteID build_y_road;        
    SpriteID auto_road;           
    SpriteID build_depot;         
    SpriteID build_tunnel;        
    SpriteID convert_road;        
  } gui_sprites;
 
  struct {
    CursorID road_swne;     
    CursorID road_nwse;     
    CursorID autoroad;      
    CursorID depot;         
    CursorID tunnel;        
    SpriteID convert_road;  
  } cursor;                       
 
  struct {
    StringID name;            
    StringID toolbar_caption; 
    StringID menu_text;       
    StringID build_caption;   
    StringID replace_text;    
    StringID new_engine;      
 
    StringID err_build_road;        
    StringID err_remove_road;       
    StringID err_depot;             
    StringID err_build_station[2];  
    StringID err_remove_station[2]; 
    StringID err_convert_road;      
 
    StringID picker_title[2];       
    StringID picker_tooltip[2];     
  } strings;                        
 
  RoadTypes powered_roadtypes;
 
  RoadTypeFlags flags;
 
  uint16_t cost_multiplier;
 
  uint16_t maintenance_multiplier;
 
  uint16_t max_speed;
 
  RoadTypeLabel label;
 
  RoadTypeLabelList alternate_labels;
 
  byte map_colour;
 
  TimerGameCalendar::Date introduction_date;
 
  RoadTypes introduction_required_roadtypes;
 
  RoadTypes introduces_roadtypes;
 
  byte sorting_order;
 
  const GRFFile *grffile[ROTSG_END];
 
  const SpriteGroup *group[ROTSG_END];
 
  inline bool UsesOverlay() const
  {
    return this->group[ROTSG_GROUND] != nullptr;
  }
};
 
extern RoadTypes _roadtypes_type;
 
inline bool RoadTypeIsRoad(RoadType roadtype)
{
  return !HasBit(_roadtypes_type, roadtype);
}
 
inline bool RoadTypeIsTram(RoadType roadtype)
{
  return HasBit(_roadtypes_type, roadtype);
}
 
inline RoadTramType GetRoadTramType(RoadType roadtype)
{
  return RoadTypeIsTram(roadtype) ? RTT_TRAM : RTT_ROAD;
}
 
inline RoadTramType OtherRoadTramType(RoadTramType rtt)
{
  return rtt == RTT_ROAD ? RTT_TRAM : RTT_ROAD;
}
 
inline const RoadTypeInfo *GetRoadTypeInfo(RoadType roadtype)
{
  extern RoadTypeInfo _roadtypes[ROADTYPE_END];
  assert(roadtype < ROADTYPE_END);
  return &_roadtypes[roadtype];
}
 
inline bool HasPowerOnRoad(RoadType enginetype, RoadType tiletype)
{
  return HasBit(GetRoadTypeInfo(enginetype)->powered_roadtypes, tiletype);
}
 
inline Money RoadBuildCost(RoadType roadtype)
{
  assert(roadtype < ROADTYPE_END);
  return (_price[PR_BUILD_ROAD] * GetRoadTypeInfo(roadtype)->cost_multiplier) >> 3;
}
 
inline Money RoadClearCost(RoadType roadtype)
{
  assert(roadtype < ROADTYPE_END);
 
  /* Flat fee for removing road. */
  if (RoadTypeIsRoad(roadtype)) return _price[PR_CLEAR_ROAD];
 
  /* Clearing tram earns a little money, but also incurs the standard clear road cost,
   * so no profit can be made. */
  return _price[PR_CLEAR_ROAD] - RoadBuildCost(roadtype) * 3 / 4;
}
 
inline Money RoadConvertCost(RoadType from, RoadType to)
{
  /* Don't apply convert costs when converting to the same roadtype (ex. building a roadstop over existing road) */
  if (from == to) return (Money)0;
 
  /* Same cost as removing and then building. */
  return RoadBuildCost(to) + RoadClearCost(from);
}
 
inline bool RoadNoLevelCrossing(RoadType roadtype)
{
  assert(roadtype < ROADTYPE_END);
  return HasBit(GetRoadTypeInfo(roadtype)->flags, ROTF_NO_LEVEL_CROSSING);
}
 
RoadType GetRoadTypeByLabel(RoadTypeLabel label, bool allow_alternate_labels = true);
 
void ResetRoadTypes();
void InitRoadTypes();
RoadType AllocateRoadType(RoadTypeLabel label, RoadTramType rtt);
bool HasAnyRoadTypesAvail(CompanyID company, RoadTramType rtt);
 
extern std::vector<RoadType> _sorted_roadtypes;
extern RoadTypes _roadtypes_hidden_mask;
 
#endif /* ROAD_H */