1

/* $Id$ */

     2

     3

/** @file rail.h */

     4

     5

#ifndef RAIL_H

     6

#define RAIL_H

     7

    15

    16

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

    17

 */

    18

struct RailtypeInfo {

    19

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

    20

	 *  the ones used directly in the code */

    21

	struct {

    22

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

    23

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

    24

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

    25

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

    26

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

    27

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

    28

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

    29

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

    30

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

    31

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

    32

		SpriteID tunnel;       ///< tunnel sprites base

    33

	} base_sprites;

    34

    35

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

    36

	 * directly in the code are listed */

    37

	struct {

    38

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

    39

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

    40

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

    41

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

    42

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

    43

		SpriteID build_depot;        ///< button for building depots

    44

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

    45

		SpriteID convert_rail;       ///< button for converting rail

    46

	} gui_sprites;

    47

    48

	struct {

    49

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

    50

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

    51

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

    52

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

    53

		CursorID autorail;   ///< Cursor for autorail tool

    54

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

    55

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

    56

		CursorID convert;    ///< Cursor for converting track

    57

	} cursor;

    58

    59

	struct {

    60

		StringID toolbar_caption;

    61

	} strings;

    62

    63

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

    64

	SpriteID snow_offset;

    65

    66

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

    68

    69

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

    71

    72

	/**

    73

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

    74

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

    75

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

    76

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

    77

	 *    the offset will fail.

    78

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

    79

	 */

    80

	SpriteID total_offset;

    81

    82

	/**

    83

	 * Bridge offset

    84

	 */

    85

	SpriteID bridge_offset;

    86

    87

	/**

    88

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

    89

	 */

    90

	byte custom_ground_offset;

    91

    96

};

    97

    98

    99

/**

   100

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

   101

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

   102

 * @return The pointer to the RailtypeInfo

   103

 */

   104

static inline const RailtypeInfo *GetRailTypeInfo(RailType railtype)

   105

{

   106

	extern RailtypeInfo _railtypes[RAILTYPE_END];

   107

	assert(railtype < RAILTYPE_END);

   108

	return &_railtypes[railtype];

   109

}

   110

   111

/**

   112

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

   113

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

   114

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

   115

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

   116

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

   117

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

   118

 */

   119

static inline bool IsCompatibleRail(RailType enginetype, RailType tiletype)

   120

{

   121

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

   122

}

   123

   124

/**

   125

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

   126

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

   127

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

   128

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

   129

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

   130

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

   131

 */

   132

static inline bool HasPowerOnRail(RailType enginetype, RailType tiletype)

   133

{

   134

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

   135

}

   136

   137

   138

extern int _railtype_cost_multiplier[RAILTYPE_END];

   139

extern const int _default_railtype_cost_multiplier[RAILTYPE_END];

   140

   141

/**

   142

 * Returns the cost of building the specified railtype.

   143

 * @param railtype The railtype being built.

   144

 * @return The cost multiplier.

   145

 */

   146

static inline Money RailBuildCost(RailType railtype)

   147

{

   148

	assert(railtype < RAILTYPE_END);

   149

	return (_price.build_rail * _railtype_cost_multiplier[railtype]) >> 3;

   150

}

   151

   180

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

   181

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

   182

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

   184

   185

/**

   186

 * Draws overhead wires and pylons for electric railways.

   187

 * @param ti The TileInfo struct of the tile being drawn

   188

 * @see DrawCatenaryRailway

   189

 */

   190

void DrawCatenary(const TileInfo *ti);

   191

void DrawCatenaryOnTunnel(const TileInfo *ti);

   192

   193

Foundation GetRailFoundation(Slope tileh, TrackBits bits);

   194

   195

int32 SettingsDisableElrail(int32 p1); ///< _patches.disable_elrail callback

   196

   228

#endif /* RAIL_H */