src/road_func.h

   1 /* $Id: road_func.h 26105 2013-11-25 13:16:06Z rubidium $ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * 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.
   6  * 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.
   7  * 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/>.
   8  */
   9
  10 /** @file road_func.h Functions related to roads. */
  11
  12 #ifndef ROAD_FUNC_H
  13 #define ROAD_FUNC_H
  14
  15 #include "core/bitmath_func.hpp"
  16 #include "road.h"
  17 #include "economy_func.h"
  18 #include "transparency.h"
  19
  20 /**
  21  * Whether the given roadtype is valid.
  22  * @param rt the roadtype to check for validness
  23  * @return true if and only if valid
  24  */
  25 static inline bool IsValidRoadType(RoadType rt)
  26 {
  27         return rt == ROADTYPE_ROAD || rt == ROADTYPE_TRAM;
  28 }
  29
  30 /**
  31  * Whether the given roadtype is valid.
  32  * @param rt the roadtype to check for validness
  33  * @return true if and only if valid
  34  */
  35 static inline bool IsValidRoadBits(RoadBits r)
  36 {
  37         return r < ROAD_END;
  38 }
  39
  40 /**
  41  * Maps a RoadType to the corresponding RoadTypes value
  42  *
  43  * @param rt the roadtype to get the roadtypes from
  44  * @return the roadtypes with the given roadtype
  45  */
  46 static inline RoadTypes RoadTypeToRoadTypes(RoadType rt)
  47 {
  48         assert(IsValidRoadType(rt));
  49         return (RoadTypes)(1 << rt);
  50 }
  51
  52 /**
  53  * Returns the RoadTypes which are not present in the given RoadTypes
  54  *
  55  * This function returns the complement of a given RoadTypes.
  56  *
  57  * @param r The given RoadTypes
  58  * @return The complement of the given RoadTypes
  59  */
  60 static inline RoadTypes ComplementRoadTypes(RoadTypes r)
  61 {
  62         return (RoadTypes)(ROADTYPES_ALL ^ r);
  63 }
  64
  65
  66 /**
  67  * Calculate the complement of a RoadBits value
  68  *
  69  * Simply flips all bits in the RoadBits value to get the complement
  70  * of the RoadBits.
  71  *
  72  * @param r The given RoadBits value
  73  * @return the complement
  74  */
  75 static inline RoadBits ComplementRoadBits(RoadBits r)
  76 {
  77         assert(IsValidRoadBits(r));
  78         return (RoadBits)(ROAD_ALL ^ r);
  79 }
  80
  81 /**
  82  * Calculate the mirrored RoadBits
  83  *
  84  * Simply move the bits to their new position.
  85  *
  86  * @param r The given RoadBits value
  87  * @return the mirrored
  88  */
  89 static inline RoadBits MirrorRoadBits(RoadBits r)
  90 {
  91         assert(IsValidRoadBits(r));
  92         return (RoadBits)(GB(r, 0, 2) << 2 | GB(r, 2, 2));
  93 }
  94
  95 /**
  96  * Calculate rotated RoadBits
  97  *
  98  * Move the Roadbits clockwise until they are in their final position.
  99  *
 100  * @param r The given RoadBits value
 101  * @param rot The given Rotation angle
 102  * @return the rotated
 103  */
 104 static inline RoadBits RotateRoadBits(RoadBits r, DiagDirDiff rot)
 105 {
 106         assert(IsValidRoadBits(r));
 107         for (; rot > (DiagDirDiff)0; rot--) {
 108                 r = (RoadBits)(GB(r, 0, 1) << 3 | GB(r, 1, 3));
 109         }
 110         return r;
 111 }
 112
 113 /**
 114  * Check if we've got a straight road
 115  *
 116  * @param r The given RoadBits
 117  * @return true if we've got a straight road
 118  */
 119 static inline bool IsStraightRoad(RoadBits r)
 120 {
 121         assert(IsValidRoadBits(r));
 122         return (r == ROAD_X || r == ROAD_Y);
 123 }
 124
 125 /**
 126  * Create the road-part which belongs to the given DiagDirection
 127  *
 128  * This function returns a RoadBits value which belongs to
 129  * the given DiagDirection.
 130  *
 131  * @param d The DiagDirection
 132  * @return The result RoadBits which the selected road-part set
 133  */
 134 static inline RoadBits DiagDirToRoadBits(DiagDirection d)
 135 {
 136         assert(IsValidDiagDirection(d));
 137         return (RoadBits)(ROAD_NW << (3 ^ d));
 138 }
 139
 140 /**
 141  * Create the road-part which belongs to the given Axis
 142  *
 143  * This function returns a RoadBits value which belongs to
 144  * the given Axis.
 145  *
 146  * @param a The Axis
 147  * @return The result RoadBits which the selected road-part set
 148  */
 149 static inline RoadBits AxisToRoadBits(Axis a)
 150 {
 151         assert(IsValidAxis(a));
 152         return a == AXIS_X ? ROAD_X : ROAD_Y;
 153 }
 154
 155
 156 /**
 157  * Calculates the maintenance cost of a number of road bits.
 158  * @param rtid Road type to get the cost for.
 159  * @param num Number of road bits.
 160  * @param total_num Total number of road bits of all road/tram-types.
 161  * @return Total cost.
 162  */
 163 static inline Money RoadMaintenanceCost(RoadTypeIdentifier rtid, uint32 num, uint32 total_num)
 164 {
 165         assert(rtid.IsValid());
 166         return (_price[PR_INFRASTRUCTURE_ROAD] * GetRoadTypeInfo(rtid)->maintenance_multiplier * num * (1 + IntSqrt(total_num))) >> 12;
 167 }
 168
 169 /**
 170  * Test if a road type has catenary
 171  * @param rti Road type to test
 172  */
 173 static inline bool HasRoadCatenary(RoadTypeIdentifier rti)
 174 {
 175         assert(IsValidRoadType(rti.basetype));
 176         return HasBit(GetRoadTypeInfo(rti)->flags, ROTF_CATENARY);
 177 }
 178
 179 /**
 180  * Test if we should draw road catenary
 181  * @param rti Road type to test
 182  */
 183 static inline bool HasRoadCatenaryDrawn(RoadTypeIdentifier rti)
 184 {
 185         return HasRoadCatenary(rti) && !IsInvisibilitySet(TO_CATENARY);
 186 }
 187
 188 bool HasRoadTypeAvail(CompanyID company, RoadTypeIdentifier rtid);
 189 bool ValParamRoadType(RoadTypeIdentifier rtid);
 190 RoadSubTypes GetCompanyRoadtypes(CompanyID company, RoadType rt);
 191 RoadSubTypes AddDateIntroducedRoadTypes(RoadType rt, RoadSubTypes current, Date date);
 192
 193 void UpdateLevelCrossing(TileIndex tile, bool sound = true, bool force_close = false);
 194
 195 #endif /* ROAD_FUNC_H */