1

/* $Id$ */

     2

     3

/** @file rail.h Rail specific functions. */

     4

     5

#ifndef RAIL_H

     6

#define RAIL_H

     7

     8

#include "rail_type.h"

     9

#include "track_type.h"

    10

#include "vehicle_type.h"

    11

#include "gfx_type.h"

    12

#include "core/bitmath_func.hpp"

    13

#include "economy_func.h"

    14

#include "slope_type.h"

    15

    16

enum RailTypeFlag {

    17

	RTF_CATENARY = 0,  ///< Set if the rail type should have catenary drawn

    18

};

    19

    20

enum RailTypeFlags {

    21

	RTFB_NONE     = 0,

    22

	RTFB_CATENARY = 1 << RTF_CATENARY,

    23

};

    24

DECLARE_ENUM_AS_BIT_SET(RailTypeFlags);

    25

    26

/** This struct contains all the info that is needed to draw and construct tracks.

    27

 */

    28

struct RailtypeInfo {

    29

	/** Struct containing the main sprites. @note not all sprites are listed, but only

    30

	 *  the ones used directly in the code */

    31

	struct {

    32

		SpriteID track_y;      ///< single piece of rail in Y direction, with ground

    33

		SpriteID track_ns;     ///< two pieces of rail in North and South corner (East-West direction)

    34

		SpriteID ground;       ///< ground sprite for a 3-way switch

    35

		SpriteID single_y;     ///< single piece of rail in Y direction, without ground

    36

		SpriteID single_x;     ///< single piece of rail in X direction

    37

		SpriteID single_n;     ///< single piece of rail in the northern corner

    38

		SpriteID single_s;     ///< single piece of rail in the southern corner

    39

		SpriteID single_e;     ///< single piece of rail in the eastern corner

    40

		SpriteID single_w;     ///< single piece of rail in the western corner

    41

		SpriteID single_sloped;///< single piecs of rail for slopes

    42

		SpriteID crossing;     ///< level crossing, rail in X direction

    43

		SpriteID tunnel;       ///< tunnel sprites base

    44

	} base_sprites;

    45

    46

	/** struct containing the sprites for the rail GUI. @note only sprites referred to

    47

	 * directly in the code are listed */

    48

	struct {

    49

		SpriteID build_ns_rail;      ///< button for building single rail in N-S direction

    50

		SpriteID build_x_rail;       ///< button for building single rail in X direction

    51

		SpriteID build_ew_rail;      ///< button for building single rail in E-W direction

    52

		SpriteID build_y_rail;       ///< button for building single rail in Y direction

    53

		SpriteID auto_rail;          ///< button for the autorail construction

    54

		SpriteID build_depot;        ///< button for building depots

    55

		SpriteID build_tunnel;       ///< button for building a tunnel

    56

		SpriteID convert_rail;       ///< button for converting rail

    57

	} gui_sprites;

    58

    59

	struct {

    60

		CursorID rail_ns;    ///< Cursor for building rail in N-S direction

    61

		CursorID rail_swne;  ///< Cursor for building rail in X direction

    62

		CursorID rail_ew;    ///< Cursor for building rail in E-W direction

    63

		CursorID rail_nwse;  ///< Cursor for building rail in Y direction

    64

		CursorID autorail;   ///< Cursor for autorail tool

    65

		CursorID depot;      ///< Cursor for building a depot

    66

		CursorID tunnel;     ///< Cursor for building a tunnel

    67

		CursorID convert;    ///< Cursor for converting track

    68

	} cursor;

    69

    70

	struct {

    71

		StringID toolbar_caption;

    72

		StringID menu_text;

    73

		StringID build_caption;

    74

		StringID replace_text;

    75

		StringID new_loco;

    76

	} strings;

    77

    78

	/** sprite number difference between a piece of track on a snowy ground and the corresponding one on normal ground */

    79

	SpriteID snow_offset;

    80

    81

	/** bitmask to the OTHER railtypes on which an engine of THIS railtype generates power */

    82

	RailTypes powered_railtypes;

    83

    84

	/** bitmask to the OTHER railtypes on which an engine of THIS railtype can physically travel */

    85

	RailTypes compatible_railtypes;

    86

    87

	/**

    88

	 * Offset between the current railtype and normal rail. This means that:<p>

    89

	 * 1) All the sprites in a railset MUST be in the same order. This order

    90

	 *    is determined by normal rail. Check sprites 1005 and following for this order<p>

    91

	 * 2) The position where the railtype is loaded must always be the same, otherwise

    92

	 *    the offset will fail.

    93

	 * @note: Something more flexible might be desirable in the future.

    94

	 */

    95

	SpriteID total_offset;

    96

    97

	/**

    98

	 * Bridge offset

    99

	 */

   100

	SpriteID bridge_offset;

   101

   102

	/**

   103

	 * Offset to add to ground sprite when drawing custom waypoints / stations

   104

	 */

   105

	byte custom_ground_offset;

   106

   107

	/**

   108

	 * Multiplier for curve maximum speed advantage

   109

	 */

   110

	byte curve_speed;

   111

   112

	/**

   113

	 * Bit mask of rail type flags

   114

	 */

   115

	RailTypeFlags flags;

   116

   117

	/**

   118

	 * Cost multiplier for building this rail type

   119

	 */

   120

	uint8 cost_multiplier;

   121

};

   122

   123

   124

/**

   125

 * Returns a pointer to the Railtype information for a given railtype

   126

 * @param railtype the rail type which the information is requested for

   127

 * @return The pointer to the RailtypeInfo

   128

 */

   129

static inline const RailtypeInfo *GetRailTypeInfo(RailType railtype)

   130

{

   131

	extern RailtypeInfo _railtypes[RAILTYPE_END];

   132

	assert(railtype < RAILTYPE_END);

   133

	return &_railtypes[railtype];

   134

}

   135

   136

/**

   137

 * Checks if an engine of the given RailType can drive on a tile with a given

   138

 * RailType. This would normally just be an equality check, but for electric

   139

 * rails (which also support non-electric engines).

   140

 * @return Whether the engine can drive on this tile.

   141

 * @param  enginetype The RailType of the engine we are considering.

   142

 * @param  tiletype   The RailType of the tile we are considering.

   143

 */

   144

static inline bool IsCompatibleRail(RailType enginetype, RailType tiletype)

   145

{

   146

	return HasBit(GetRailTypeInfo(enginetype)->compatible_railtypes, tiletype);

   147

}

   148

   149

/**

   150

 * Checks if an engine of the given RailType got power on a tile with a given

   151

 * RailType. This would normally just be an equality check, but for electric

   152

 * rails (which also support non-electric engines).

   153

 * @return Whether the engine got power on this tile.

   154

 * @param  enginetype The RailType of the engine we are considering.

   155

 * @param  tiletype   The RailType of the tile we are considering.

   156

 */

   157

static inline bool HasPowerOnRail(RailType enginetype, RailType tiletype)

   158

{

   159

	return HasBit(GetRailTypeInfo(enginetype)->powered_railtypes, tiletype);

   160

}

   161

   162

/**

   163

 * Returns the cost of building the specified railtype.

   164

 * @param railtype The railtype being built.

   165

 * @return The cost multiplier.

   166

 */

   167

static inline Money RailBuildCost(RailType railtype)

   168

{

   169

	assert(railtype < RAILTYPE_END);

   170

	return (_price.build_rail * GetRailTypeInfo(railtype)->cost_multiplier) >> 3;

   171

}

   172

   173

/**

   174

 * Calculates the cost of rail conversion

   175

 * @param from The railtype we are converting from

   176

 * @param to   The railtype we are converting to

   177

 * @return Cost per TrackBit

   178

 */

   179

static inline Money RailConvertCost(RailType from, RailType to)

   180

{

   181

	/* rail -> el. rail

   182

	 * calculate the price as 5 / 4 of (cost build el. rail) - (cost build rail)

   183

	 * (the price of workers to get to place is that 1/4)

   184

	 */

   185

	if (HasPowerOnRail(from, to)) {

   186

		Money cost = ((RailBuildCost(to) - RailBuildCost(from)) * 5) >> 2;

   187

		if (cost != 0) return cost;

   188

	}

   189

   190

	/* el. rail -> rail

   191

	 * calculate the price as 1 / 4 of (cost build el. rail) - (cost build rail)

   192

	 * (the price of workers is 1 / 4 + price of copper sold to a recycle center)

   193

	 */

   194

	if (HasPowerOnRail(to, from)) {

   195

		Money cost = (RailBuildCost(from) - RailBuildCost(to)) >> 2;

   196

		if (cost != 0) return cost;

   197

	}

   198

   199

	/* make the price the same as remove + build new type */

   200

	return RailBuildCost(to) + _price.remove_rail;

   201

}

   202

   203

Vehicle *UpdateTrainPowerProc(Vehicle *v, void *data);

   204

void DrawTrainDepotSprite(int x, int y, int image, RailType railtype);

   205

void DrawDefaultWaypointSprite(int x, int y, RailType railtype);

   206

Vehicle *EnsureNoTrainOnTrackProc(Vehicle *v, void *data);

   207

int TicksToLeaveDepot(const Vehicle *v);

   208

   209

Foundation GetRailFoundation(Slope tileh, TrackBits bits);

   210

   211

   212

/**

   213

 * Finds out if a company has a certain railtype available

   214

 * @param company the company in question

   215

 * @param railtype requested RailType

   216

 * @return true if company has requested RailType available

   217

 */

   218

bool HasRailtypeAvail(const CompanyID company, const RailType railtype);

   219

   220

/**

   221

 * Validate functions for rail building.

   222

 * @param rail the railtype to check.

   223

 * @return true if the current company may build the rail.

   224

 */

   225

bool ValParamRailtype(const RailType rail);

   226

   227

/**

   228

 * Returns the "best" railtype a company can build.

   229

 * As the AI doesn't know what the BEST one is, we have our own priority list

   230

 * here. When adding new railtypes, modify this function

   231

 * @param company the company "in action"

   232

 * @return The "best" railtype a company has available

   233

 */

   234

RailType GetBestRailtype(const CompanyID company);

   235

   236

/**

   237

 * Get the rail types the given company can build.

   238

 * @param company the company to get the rail types for.

   239

 * @return the rail types.

   240

 */

   241

RailTypes GetCompanyRailtypes(const CompanyID c);

   242

   243

/**

   244

 * Reset all rail type information to its default values.

   245

 */

   246

void ResetRailTypes();

   247

   248

#endif /* RAIL_H */