rail.h

Go to the documentation of this file.
00001 /* $Id: rail.h 23952 2012-02-15 21:23:48Z michi_cc $ */
00002 
00003 /*
00004  * This file is part of OpenTTD.
00005  * 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.
00006  * 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.
00007  * 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/>.
00008  */
00009 
00012 #ifndef RAIL_H
00013 #define RAIL_H
00014 
00015 #include "rail_type.h"
00016 #include "track_type.h"
00017 #include "gfx_type.h"
00018 #include "core/bitmath_func.hpp"
00019 #include "economy_func.h"
00020 #include "slope_type.h"
00021 #include "strings_type.h"
00022 #include "date_type.h"
00023 
00025 enum RailTypeFlags {
00026   RTF_CATENARY          = 0,                           
00027   RTF_NO_LEVEL_CROSSING = 1,                           
00028 
00029   RTFB_NONE              = 0,                          
00030   RTFB_CATENARY          = 1 << RTF_CATENARY,          
00031   RTFB_NO_LEVEL_CROSSING = 1 << RTF_NO_LEVEL_CROSSING, 
00032 };
00033 DECLARE_ENUM_AS_BIT_SET(RailTypeFlags)
00034 
00035 struct SpriteGroup;
00036 
00038 enum RailTypeSpriteGroup {
00039   RTSG_CURSORS,     
00040   RTSG_OVERLAY,     
00041   RTSG_GROUND,      
00042   RTSG_TUNNEL,      
00043   RTSG_WIRES,       
00044   RTSG_PYLONS,      
00045   RTSG_BRIDGE,      
00046   RTSG_CROSSING,    
00047   RTSG_DEPOT,       
00048   RTSG_FENCES,      
00049   RTSG_TUNNEL_PORTAL, 
00050   RTSG_END,
00051 };
00052 
00057 enum RailTrackOffset {
00058   RTO_X,            
00059   RTO_Y,            
00060   RTO_N,            
00061   RTO_S,            
00062   RTO_E,            
00063   RTO_W,            
00064   RTO_SLOPE_NE,     
00065   RTO_SLOPE_SE,     
00066   RTO_SLOPE_SW,     
00067   RTO_SLOPE_NW,     
00068   RTO_CROSSING_XY,  
00069   RTO_JUNCTION_SW,  
00070   RTO_JUNCTION_NE,  
00071   RTO_JUNCTION_SE,  
00072   RTO_JUNCTION_NW,  
00073   RTO_JUNCTION_NSEW,
00074 };
00075 
00079 enum RailTrackBridgeOffset {
00080   RTBO_X,     
00081   RTBO_Y,     
00082   RTBO_SLOPE, 
00083 };
00084 
00089 enum RailFenceOffset {
00090   RFO_FLAT_X,
00091   RFO_FLAT_Y,
00092   RFO_FLAT_VERT,
00093   RFO_FLAT_HORZ,
00094   RFO_SLOPE_SW,
00095   RFO_SLOPE_SE,
00096   RFO_SLOPE_NE,
00097   RFO_SLOPE_NW,
00098 };
00099 
00101 typedef SmallVector<RailTypeLabel, 4> RailTypeLabelList;
00102 
00106 struct RailtypeInfo {
00111   struct {
00112     SpriteID track_y;      
00113     SpriteID track_ns;     
00114     SpriteID ground;       
00115     SpriteID single_x;     
00116     SpriteID single_y;     
00117     SpriteID single_n;     
00118     SpriteID single_s;     
00119     SpriteID single_e;     
00120     SpriteID single_w;     
00121     SpriteID single_sloped;
00122     SpriteID crossing;     
00123     SpriteID tunnel;       
00124   } base_sprites;
00125 
00130   struct {
00131     SpriteID build_ns_rail;      
00132     SpriteID build_x_rail;       
00133     SpriteID build_ew_rail;      
00134     SpriteID build_y_rail;       
00135     SpriteID auto_rail;          
00136     SpriteID build_depot;        
00137     SpriteID build_tunnel;       
00138     SpriteID convert_rail;       
00139   } gui_sprites;
00140 
00141   struct {
00142     CursorID rail_ns;    
00143     CursorID rail_swne;  
00144     CursorID rail_ew;    
00145     CursorID rail_nwse;  
00146     CursorID autorail;   
00147     CursorID depot;      
00148     CursorID tunnel;     
00149     CursorID convert;    
00150   } cursor;
00151 
00152   struct {
00153     StringID name;
00154     StringID toolbar_caption;
00155     StringID menu_text;
00156     StringID build_caption;
00157     StringID replace_text;
00158     StringID new_loco;
00159   } strings;
00160 
00162   SpriteID snow_offset;
00163 
00165   RailTypes powered_railtypes;
00166 
00168   RailTypes compatible_railtypes;
00169 
00173   SpriteID bridge_offset;
00174 
00178   byte fallback_railtype;
00179 
00183   byte curve_speed;
00184 
00188   RailTypeFlags flags;
00189 
00193   uint16 cost_multiplier;
00194 
00198   uint16 maintenance_multiplier;
00199 
00203   uint8 acceleration_type;
00204 
00208   uint16 max_speed;
00209 
00213   RailTypeLabel label;
00214 
00218   RailTypeLabelList alternate_labels;
00219 
00223   byte map_colour;
00224 
00232   Date introduction_date;
00233 
00238   RailTypes introduction_required_railtypes;
00239 
00243   RailTypes introduces_railtypes;
00244 
00248   byte sorting_order;
00249 
00253   const GRFFile *grffile[RTSG_END];
00254 
00258   const SpriteGroup *group[RTSG_END];
00259 
00260   inline bool UsesOverlay() const
00261   {
00262     return this->group[RTSG_GROUND] != NULL;
00263   }
00264 
00272   inline uint GetRailtypeSpriteOffset() const
00273   {
00274     return 82 * this->fallback_railtype;
00275   }
00276 };
00277 
00278 
00284 static inline const RailtypeInfo *GetRailTypeInfo(RailType railtype)
00285 {
00286   extern RailtypeInfo _railtypes[RAILTYPE_END];
00287   assert(railtype < RAILTYPE_END);
00288   return &_railtypes[railtype];
00289 }
00290 
00299 static inline bool IsCompatibleRail(RailType enginetype, RailType tiletype)
00300 {
00301   return HasBit(GetRailTypeInfo(enginetype)->compatible_railtypes, tiletype);
00302 }
00303 
00312 static inline bool HasPowerOnRail(RailType enginetype, RailType tiletype)
00313 {
00314   return HasBit(GetRailTypeInfo(enginetype)->powered_railtypes, tiletype);
00315 }
00316 
00322 static inline bool RailNoLevelCrossings(RailType rt)
00323 {
00324   return HasBit(GetRailTypeInfo(rt)->flags, RTF_NO_LEVEL_CROSSING);
00325 }
00326 
00332 static inline Money RailBuildCost(RailType railtype)
00333 {
00334   assert(railtype < RAILTYPE_END);
00335   return (_price[PR_BUILD_RAIL] * GetRailTypeInfo(railtype)->cost_multiplier) >> 3;
00336 }
00337 
00343 static inline Money RailClearCost(RailType railtype)
00344 {
00345   /* Clearing rail in fact earns money, but if the build cost is set
00346    * very low then a loophole exists where money can be made.
00347    * In this case we limit the removal earnings to 3/4s of the build
00348    * cost.
00349    */
00350   assert(railtype < RAILTYPE_END);
00351   return max(_price[PR_CLEAR_RAIL], -RailBuildCost(railtype) * 3 / 4);
00352 }
00353 
00360 static inline Money RailConvertCost(RailType from, RailType to)
00361 {
00362   /* Get the costs for removing and building anew
00363    * A conversion can never be more costly */
00364   Money rebuildcost = RailBuildCost(to) + RailClearCost(from);
00365 
00366   /* Conversion between somewhat compatible railtypes:
00367    * Pay 1/8 of the target rail cost (labour costs) and additionally any difference in the
00368    * build costs, if the target type is more expensive (material upgrade costs).
00369    * Upgrade can never be more expensive than re-building. */
00370   if (HasPowerOnRail(from, to) || HasPowerOnRail(to, from)) {
00371     Money upgradecost = RailBuildCost(to) / 8 + max((Money)0, RailBuildCost(to) - RailBuildCost(from));
00372     return min(upgradecost, rebuildcost);
00373   }
00374 
00375   /* make the price the same as remove + build new type for rail types
00376    * which are not compatible in any way */
00377   return rebuildcost;
00378 }
00379 
00387 static inline Money RailMaintenanceCost(RailType railtype, uint32 num, uint32 total_num)
00388 {
00389   assert(railtype < RAILTYPE_END);
00390   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.
00391 }
00392 
00398 static inline Money SignalMaintenanceCost(uint32 num)
00399 {
00400   return (_price[PR_INFRASTRUCTURE_RAIL] * 15 * num * (1 + IntSqrt(num))) >> 8; // 1 bit fraction for the multiplier and 7 bits scaling.
00401 }
00402 
00403 void DrawTrainDepotSprite(int x, int y, int image, RailType railtype);
00404 int TicksToLeaveDepot(const Train *v);
00405 
00406 Foundation GetRailFoundation(Slope tileh, TrackBits bits);
00407 
00408 
00409 bool HasRailtypeAvail(const CompanyID company, const RailType railtype);
00410 bool ValParamRailtype(const RailType rail);
00411 
00412 RailTypes AddDateIntroducedRailTypes(RailTypes current, Date date);
00413 
00414 RailType GetBestRailtype(const CompanyID company);
00415 RailTypes GetCompanyRailtypes(const CompanyID c);
00416 
00417 RailType GetRailTypeByLabel(RailTypeLabel label, bool allow_alternate_labels = true);
00418 
00419 void ResetRailTypes();
00420 void InitRailTypes();
00421 RailType AllocateRailType(RailTypeLabel label);
00422 
00423 #endif /* RAIL_H */