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

 
#ifndef ROAD_H
#define ROAD_H
 
#include "road_type.h"
#include "gfx_type.h"
#include "core/flatset_type.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 class RoadTypeFlag : uint8_t {
  Catenary        = 0, 
  NoLevelCrossing = 1, 
  NoHouses        = 2, 
  Hidden          = 3, 
  TownBuild       = 4, 
};
using RoadTypeFlags = EnumBitSet<RoadTypeFlag, uint8_t>;
 
struct SpriteGroup;

enum class RoadSpriteType : uint8_t {
  UI, 
  Overlay, 
  Ground, 
  Tunnel, 
  CatenaryFront, 
  CatenaryRear, 
  Bridge, 
  ReservedCrossing, 
  Depot, 
  ReservedFence, 
  Roadstop, 
  Oneway, 
  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;

  FlatSet<RoadTypeLabel> alternate_labels;

  PixelColour map_colour;

  TimerGameCalendar::Date introduction_date;

  RoadTypes introduction_required_roadtypes;

  RoadTypes introduces_roadtypes;

  uint8_t sorting_order;

  EnumClassIndexContainer<std::array<const GRFFile *, to_underlying(RoadSpriteType::End)>, RoadSpriteType> grffile{};

  EnumClassIndexContainer<std::array<const SpriteGroup *, to_underlying(RoadSpriteType::End)>, RoadSpriteType> group{};
 
  std::vector<BadgeID> badges;
 
  inline bool UsesOverlay() const
  {
    return this->group[RoadSpriteType::Ground] != nullptr;
  }
 
  RoadType Index() const;
};

inline RoadTypes GetMaskForRoadTramType(RoadTramType rtt)
{
  extern RoadTypes _roadtypes_road;
  extern RoadTypes _roadtypes_tram;
  return rtt == RoadTramType::Road ? _roadtypes_road : _roadtypes_tram;
}
 
inline bool RoadTypeIsRoad(RoadType roadtype)
{
  return GetMaskForRoadTramType(RoadTramType::Road).Test(roadtype);
}
 
inline bool RoadTypeIsTram(RoadType roadtype)
{
  return GetMaskForRoadTramType(RoadTramType::Tram).Test(roadtype);
}
 
inline RoadTramType GetRoadTramType(RoadType roadtype)
{
  return RoadTypeIsTram(roadtype) ? RoadTramType::Tram : RoadTramType::Road;
}
 
inline RoadTramType OtherRoadTramType(RoadTramType rtt)
{
  return rtt == RoadTramType::Road ? RoadTramType::Tram : RoadTramType::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 GetRoadTypeInfo(enginetype)->powered_roadtypes.Test(tiletype);
}

inline Money RoadBuildCost(RoadType roadtype)
{
  assert(roadtype < ROADTYPE_END);
  return (_price[Price::BuildRoad] * GetRoadTypeInfo(roadtype)->cost_multiplier) >> 3;
}

inline Money RoadClearCost(RoadType roadtype)
{
  assert(roadtype < ROADTYPE_END);
 
  /* Flat fee for removing road. */
  if (RoadTypeIsRoad(roadtype)) return _price[Price::ClearRoad];
 
  /* Clearing tram earns a little money, but also incurs the standard clear road cost,
   * so no profit can be made. */
  return _price[Price::ClearRoad] - 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 */