1

/* $Id$ */

     2

     3

/** @file rail.h */

     4

     5

#ifndef RAIL_H

     6

#define RAIL_H

     7

     8

#include "gfx.h"

     9

#include "rail_type.h"

    10

#include "track_type.h"

    11

#include "variables.h"

    12

    13

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

    14

 */

    15

struct RailtypeInfo {

    16

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

    17

	 *  the ones used directly in the code */

    18

	struct {

    19

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

    20

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

    21

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

    22

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

    23

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

    24

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

    25

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

    26

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

    27

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

    28

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

    29

		SpriteID tunnel;       ///< tunnel sprites base

    30

	} base_sprites;

    31

    32

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

    33

	 * directly in the code are listed */

    34

	struct {

    35

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

    36

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

    37

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

    38

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

    39

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

    40

		SpriteID build_depot;        ///< button for building depots

    41

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

    42

		SpriteID convert_rail;       ///< button for converting rail

    43

	} gui_sprites;

    44

    45

	struct {

    46

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

    47

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

    48

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

    49

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

    50

		CursorID autorail;   ///< Cursor for autorail tool

    51

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

    52

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

    53

		CursorID convert;    ///< Cursor for converting track

    54

	} cursor;

    55

    56

	struct {

    57

		StringID toolbar_caption;

    58

	} strings;

    59

    60

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

    61

	SpriteID snow_offset;

    62

    63

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

    64

	RailTypeMask powered_railtypes;

    65

    66

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

    67

	RailTypeMask compatible_railtypes;

    68

    69

	/**

    70

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

    71

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

    72

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

    73

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

    74

	 *    the offset will fail.

    75

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

    76

	 */

    77

	SpriteID total_offset;

    78

    79

	/**

    80

	 * Bridge offset

    81

	 */

    82

	SpriteID bridge_offset;

    83

    84

	/**

    85

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

    86

	 */

    87

	byte custom_ground_offset;

    88

};

    89

    90

    91

/** these are the maximums used for updating signal blocks, and checking if a depot is in a pbs block */

    92

enum {

    93

	NUM_SSD_ENTRY = 256, ///< max amount of blocks

    94

	NUM_SSD_STACK =  32, ///< max amount of blocks to check recursively

    95

};

    96

    97

/*

    98

 * Functions to map tracks to the corresponding bits in the signal

    99

 * presence/status bytes in the map. You should not use these directly, but

   100

 * wrapper functions below instead. XXX: Which are these?

   101

 */

   102

   103

/**

   104

 * Maps a trackdir to the bit that stores its status in the map arrays, in the

   105

 * direction along with the trackdir.

   106

 */

   107

static inline byte SignalAlongTrackdir(Trackdir trackdir)

   108

{

   109

	extern const byte _signal_along_trackdir[TRACKDIR_END];

   110

	return _signal_along_trackdir[trackdir];

   111

}

   112

   113

/**

   114

 * Maps a trackdir to the bit that stores its status in the map arrays, in the

   115

 * direction against the trackdir.

   116

 */

   117

static inline byte SignalAgainstTrackdir(Trackdir trackdir)

   118

{

   119

	extern const byte _signal_against_trackdir[TRACKDIR_END];

   120

	return _signal_against_trackdir[trackdir];

   121

}

   122

   123

/**

   124

 * Maps a Track to the bits that store the status of the two signals that can

   125

 * be present on the given track.

   126

 */

   127

static inline byte SignalOnTrack(Track track)

   128

{

   129

	extern const byte _signal_on_track[TRACK_END];

   130

	return _signal_on_track[track];

   131

}

   132

   133

   134

   135

/**

   136

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

   137

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

   138

 * @return The pointer to the RailtypeInfo

   139

 */

   140

static inline const RailtypeInfo *GetRailTypeInfo(RailType railtype)

   141

{

   142

	extern RailtypeInfo _railtypes[RAILTYPE_END];

   143

	assert(railtype < RAILTYPE_END);

   144

	return &_railtypes[railtype];

   145

}

   146

   147

/**

   148

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

   149

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

   150

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

   151

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

   152

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

   153

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

   154

 */

   155

static inline bool IsCompatibleRail(RailType enginetype, RailType tiletype)

   156

{

   157

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

   158

}

   159

   160

/**

   161

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

   162

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

   163

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

   164

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

   165

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

   166

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

   167

 */

   168

static inline bool HasPowerOnRail(RailType enginetype, RailType tiletype)

   169

{

   170

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

   171

}

   172

   173

   174

extern int _railtype_cost_multiplier[RAILTYPE_END];

   175

extern const int _default_railtype_cost_multiplier[RAILTYPE_END];

   176

   177

/**

   178

 * Returns the cost of building the specified railtype.

   179

 * @param railtype The railtype being built.

   180

 * @return The cost multiplier.

   181

 */

   182

static inline Money RailBuildCost(RailType railtype)

   183

{

   184

	assert(railtype < RAILTYPE_END);

   185

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

   186

}

   187

   188

/**

   189

 * Calculates the cost of rail conversion

   190

 * @param from The railtype we are converting from

   191

 * @param to   The railtype we are converting to

   192

 * @return Cost per TrackBit

   193

 */

   194

static inline Money RailConvertCost(RailType from, RailType to)

   195

{

   196

	/* rail -> el. rail

   197

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

   198

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

   199

	 */

   200

	if (HasPowerOnRail(from, to)) {

   201

		return ((RailBuildCost(to) - RailBuildCost(from)) * 5) >> 2;

   202

	}

   203

   204

	/* el. rail -> rail

   205

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

   206

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

   207

	 */

   208

	if (HasPowerOnRail(to, from)) {

   209

		return (RailBuildCost(from) - RailBuildCost(to)) >> 2;

   210

	}

   211

   212

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

   213

	return RailBuildCost(to) + _price.remove_rail;

   214

}

   215

   216

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

   217

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

   218

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

   219

   220

/**

   221

 * Draws overhead wires and pylons for electric railways.

   222

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

   223

 * @see DrawCatenaryRailway

   224

 */

   225

void DrawCatenary(const TileInfo *ti);

   226

void DrawCatenaryOnTunnel(const TileInfo *ti);

   227

   228

Foundation GetRailFoundation(Slope tileh, TrackBits bits);

   229

   230

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

   231

   232

#endif /* RAIL_H */