1

/* $Id$ */

     2

     3

/** @file rail.h */

     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 "variables.h"

    16

    17

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

    18

 */

    19

struct RailtypeInfo {

    20

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

    21

	 *  the ones used directly in the code */

    22

	struct {

    23

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

    24

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

    25

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

    26

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

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

		SpriteID tunnel;       ///< tunnel sprites base

    34

	} base_sprites;

    35

    36

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

    37

	 * directly in the code are listed */

    38

	struct {

    39

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

    40

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

    41

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

    42

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

    43

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

    44

		SpriteID build_depot;        ///< button for building depots

    45

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

    46

		SpriteID convert_rail;       ///< button for converting rail

    47

	} gui_sprites;

    48

    49

	struct {

    50

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

    51

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

    52

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

    53

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

    54

		CursorID autorail;   ///< Cursor for autorail tool

    55

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

    56

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

    57

		CursorID convert;    ///< Cursor for converting track

    58

	} cursor;

    59

    60

	struct {

    61

		StringID toolbar_caption;

    62

	} strings;

    63

    64

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

    65

	SpriteID snow_offset;

    66

    67

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

    68

	RailTypeMask powered_railtypes;

    69

    70

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

    71

	RailTypeMask compatible_railtypes;

    72

    73

	/**

    74

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

    75

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

    76

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

    77

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

    78

	 *    the offset will fail.

    79

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

    80

	 */

    81

	SpriteID total_offset;

    82

    83

	/**

    84

	 * Bridge offset

    85

	 */

    86

	SpriteID bridge_offset;

    87

    88

	/**

    89

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

    90

	 */

    91

	byte custom_ground_offset;

    92

};

    93

    94

    95

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

    96

enum {

    97

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

    98

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

    99

};

   100

   101

   102

   103

/**

   104

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

   105

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

   106

 * @return The pointer to the RailtypeInfo

   107

 */

   108

static inline const RailtypeInfo *GetRailTypeInfo(RailType railtype)

   109

{

   110

	extern RailtypeInfo _railtypes[RAILTYPE_END];

   111

	assert(railtype < RAILTYPE_END);

   112

	return &_railtypes[railtype];

   113

}

   114

   115

/**

   116

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

   117

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

   118

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

   119

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

   120

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

   121

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

   122

 */

   123

static inline bool IsCompatibleRail(RailType enginetype, RailType tiletype)

   124

{

   125

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

   126

}

   127

   128

/**

   129

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

   130

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

   131

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

   132

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

   133

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

   134

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

   135

 */

   136

static inline bool HasPowerOnRail(RailType enginetype, RailType tiletype)

   137

{

   138

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

   139

}

   140

   141

   142

extern int _railtype_cost_multiplier[RAILTYPE_END];

   143

extern const int _default_railtype_cost_multiplier[RAILTYPE_END];

   144

   145

/**

   146

 * Returns the cost of building the specified railtype.

   147

 * @param railtype The railtype being built.

   148

 * @return The cost multiplier.

   149

 */

   150

static inline Money RailBuildCost(RailType railtype)

   151

{

   152

	assert(railtype < RAILTYPE_END);

   153

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

   154

}

   155

   156

/**

   157

 * Calculates the cost of rail conversion

   158

 * @param from The railtype we are converting from

   159

 * @param to   The railtype we are converting to

   160

 * @return Cost per TrackBit

   161

 */

   162

static inline Money RailConvertCost(RailType from, RailType to)

   163

{

   164

	/* rail -> el. rail

   165

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

   166

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

   167

	 */

   168

	if (HasPowerOnRail(from, to)) {

   169

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

   170

	}

   171

   172

	/* el. rail -> rail

   173

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

   174

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

   175

	 */

   176

	if (HasPowerOnRail(to, from)) {

   177

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

   178

	}

   179

   180

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

   181

	return RailBuildCost(to) + _price.remove_rail;

   182

}

   183

   184

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

   185

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

   186

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

   187

   188

/**

   189

 * Draws overhead wires and pylons for electric railways.

   190

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

   191

 * @see DrawCatenaryRailway

   192

 */

   193

void DrawCatenary(const TileInfo *ti);

   194

void DrawCatenaryOnTunnel(const TileInfo *ti);

   195

   196

Foundation GetRailFoundation(Slope tileh, TrackBits bits);

   197

   198

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

   199

   200

#endif /* RAIL_H */