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 "newgrf_badge_type.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 class RoadTypeFlag : uint8_t {
  Catenary        = 0, 
  NoLevelCrossing = 1, 
  NoHouses        = 2, 
  Hidden          = 3, 
  TownBuild       = 4, 
};
using RoadTypeFlags = EnumBitSet<RoadTypeFlag, uint8_t>;
 
struct SpriteGroup;
 
enum RoadTypeSpriteGroup : uint8_t {
  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,
};
 
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;
 
  std::vector<RoadTypeLabel> alternate_labels;
 
  PixelColour map_colour;
 
  TimerGameCalendar::Date introduction_date;
 
  RoadTypes introduction_required_roadtypes;
 
  RoadTypes introduces_roadtypes;
 
  uint8_t sorting_order;
 
  const GRFFile *grffile[ROTSG_END];
 
  const SpriteGroup *group[ROTSG_END];
 
  std::vector<BadgeID> badges;
 
  inline bool UsesOverlay() const
  {
    return this->group[ROTSG_GROUND] != nullptr;
  }
};
 
inline RoadTypes GetMaskForRoadTramType(RoadTramType rtt)
{
  extern RoadTypes _roadtypes_road;
  extern RoadTypes _roadtypes_tram;
  return rtt == RTT_ROAD ? _roadtypes_road : _roadtypes_tram;
}
 
inline bool RoadTypeIsRoad(RoadType roadtype)
{
  return GetMaskForRoadTramType(RTT_ROAD).Test(roadtype);
}
 
inline bool RoadTypeIsTram(RoadType roadtype)
{
  return GetMaskForRoadTramType(RTT_TRAM).Test(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 RoadType GetRoadTypeInfoIndex(const RoadTypeInfo *rti)
{
  extern RoadTypeInfo _roadtypes[ROADTYPE_END];
  size_t index = rti - _roadtypes;
  assert(index < ROADTYPE_END && rti == _roadtypes + index);
  return static_cast<RoadType>(index);
}
 
inline bool HasPowerOnRoad(RoadType enginetype, RoadType tiletype)
{
  return GetRoadTypeInfo(enginetype)->powered_roadtypes.Test(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 GetRoadTypeInfo(roadtype)->flags.Test(RoadTypeFlag::NoLevelCrossing);
}
 
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 */