1

/* $Id$ */

     2

     3

/** @file rail.cpp Implementation of rail specific functions. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "bridge_map.h"

     8

#include "rail.h"

     9

#include "station_map.h"

    10

#include "tunnel_map.h"

    11

#include "tunnelbridge_map.h"

    12

#include "settings_type.h"

    13

#include "date_func.h"

    14

#include "player_func.h"

    15

#include "player_base.h"

    16

#include "engine_func.h"

    17

#include "engine_base.h"

    18

    19

    20

/* XXX: Below 3 tables store duplicate data. Maybe remove some? */

    21

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

    22

 * direction along with the trackdir */

    23

extern const byte _signal_along_trackdir[TRACKDIR_END] = {

    24

	0x8, 0x8, 0x8, 0x2, 0x4, 0x1, 0, 0,

    25

	0x4, 0x4, 0x4, 0x1, 0x8, 0x2

    26

};

    27

    28

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

    29

 * direction against the trackdir */

    30

extern const byte _signal_against_trackdir[TRACKDIR_END] = {

    31

	0x4, 0x4, 0x4, 0x1, 0x8, 0x2, 0, 0,

    32

	0x8, 0x8, 0x8, 0x2, 0x4, 0x1

    33

};

    34

    35

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

    36

 * be present on the given track */

    37

extern const byte _signal_on_track[] = {

    38

	0xC, 0xC, 0xC, 0x3, 0xC, 0x3

    39

};

    40

    41

/* Maps a diagonal direction to the all trackdirs that are connected to any

    42

 * track entering in this direction (including those making 90 degree turns)

    43

 */

    44

extern const TrackdirBits _exitdir_reaches_trackdirs[] = {

    45

	TRACKDIR_BIT_X_NE | TRACKDIR_BIT_LOWER_E | TRACKDIR_BIT_LEFT_N,  /* DIAGDIR_NE */

    46

	TRACKDIR_BIT_Y_SE | TRACKDIR_BIT_LEFT_S  | TRACKDIR_BIT_UPPER_E, /* DIAGDIR_SE */

    47

	TRACKDIR_BIT_X_SW | TRACKDIR_BIT_UPPER_W | TRACKDIR_BIT_RIGHT_S, /* DIAGDIR_SW */

    48

	TRACKDIR_BIT_Y_NW | TRACKDIR_BIT_RIGHT_N | TRACKDIR_BIT_LOWER_W  /* DIAGDIR_NW */

    49

};

    50

    51

extern const Trackdir _next_trackdir[TRACKDIR_END] = {

    52

	TRACKDIR_X_NE,  TRACKDIR_Y_SE,  TRACKDIR_LOWER_E, TRACKDIR_UPPER_E, TRACKDIR_RIGHT_S, TRACKDIR_LEFT_S, INVALID_TRACKDIR, INVALID_TRACKDIR,

    53

	TRACKDIR_X_SW,  TRACKDIR_Y_NW,  TRACKDIR_LOWER_W, TRACKDIR_UPPER_W, TRACKDIR_RIGHT_N, TRACKDIR_LEFT_N

    54

};

    55

    56

/* Maps a trackdir to all trackdirs that make 90 deg turns with it. */

    57

extern const TrackdirBits _track_crosses_trackdirs[TRACKDIR_END] = {

    58

	TRACKDIR_BIT_Y_SE     | TRACKDIR_BIT_Y_NW,                                                   /* TRACK_X     */

    59

	TRACKDIR_BIT_X_NE     | TRACKDIR_BIT_X_SW,                                                   /* TRACK_Y     */

    60

	TRACKDIR_BIT_RIGHT_N  | TRACKDIR_BIT_RIGHT_S  | TRACKDIR_BIT_LEFT_N  | TRACKDIR_BIT_LEFT_S,  /* TRACK_UPPER */

    61

	TRACKDIR_BIT_RIGHT_N  | TRACKDIR_BIT_RIGHT_S  | TRACKDIR_BIT_LEFT_N  | TRACKDIR_BIT_LEFT_S,  /* TRACK_LOWER */

    62

	TRACKDIR_BIT_UPPER_W  | TRACKDIR_BIT_UPPER_E  | TRACKDIR_BIT_LOWER_W | TRACKDIR_BIT_LOWER_E, /* TRACK_LEFT  */

    63

	TRACKDIR_BIT_UPPER_W  | TRACKDIR_BIT_UPPER_E  | TRACKDIR_BIT_LOWER_W | TRACKDIR_BIT_LOWER_E  /* TRACK_RIGHT */

    64

};

    65

    66

/* Maps a track to all tracks that make 90 deg turns with it. */

    67

extern const TrackBits _track_crosses_tracks[] = {

    68

	TRACK_BIT_Y,    /* TRACK_X     */

    69

	TRACK_BIT_X,    /* TRACK_Y     */

    70

	TRACK_BIT_VERT, /* TRACK_UPPER */

    71

	TRACK_BIT_VERT, /* TRACK_LOWER */

    72

	TRACK_BIT_HORZ, /* TRACK_LEFT  */

    73

	TRACK_BIT_HORZ  /* TRACK_RIGHT */

    74

};

    75

    76

/* Maps a trackdir to the (4-way) direction the tile is exited when following

    77

 * that trackdir */

    78

extern const DiagDirection _trackdir_to_exitdir[TRACKDIR_END] = {

    79

	DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_NE,

    80

	DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE,

    81

};

    82

    83

extern const Trackdir _track_exitdir_to_trackdir[][DIAGDIR_END] = {

    84

	{TRACKDIR_X_NE,     INVALID_TRACKDIR,  TRACKDIR_X_SW,     INVALID_TRACKDIR},

    85

	{INVALID_TRACKDIR,  TRACKDIR_Y_SE,     INVALID_TRACKDIR,  TRACKDIR_Y_NW},

    86

	{TRACKDIR_UPPER_E,  INVALID_TRACKDIR,  INVALID_TRACKDIR,  TRACKDIR_UPPER_W},

    87

	{INVALID_TRACKDIR,  TRACKDIR_LOWER_E,  TRACKDIR_LOWER_W,  INVALID_TRACKDIR},

    88

	{INVALID_TRACKDIR,  INVALID_TRACKDIR,  TRACKDIR_LEFT_S,   TRACKDIR_LEFT_N},

    89

	{TRACKDIR_RIGHT_N,  TRACKDIR_RIGHT_S,  INVALID_TRACKDIR,  INVALID_TRACKDIR}

    90

};

    91

    92

extern const Trackdir _track_enterdir_to_trackdir[][DIAGDIR_END] = {

    93

	{TRACKDIR_X_NE,     INVALID_TRACKDIR,  TRACKDIR_X_SW,     INVALID_TRACKDIR},

    94

	{INVALID_TRACKDIR,  TRACKDIR_Y_SE,     INVALID_TRACKDIR,  TRACKDIR_Y_NW},

    95

	{INVALID_TRACKDIR,  TRACKDIR_UPPER_E,  TRACKDIR_UPPER_W,  INVALID_TRACKDIR},

    96

	{TRACKDIR_LOWER_E,  INVALID_TRACKDIR,  INVALID_TRACKDIR,  TRACKDIR_LOWER_W},

    97

	{TRACKDIR_LEFT_N,   TRACKDIR_LEFT_S,   INVALID_TRACKDIR,  INVALID_TRACKDIR},

    98

	{INVALID_TRACKDIR,  INVALID_TRACKDIR,  TRACKDIR_RIGHT_S,  TRACKDIR_RIGHT_N}

    99

};

   100

   101

extern const Trackdir _track_direction_to_trackdir[][DIR_END] = {

   102

	{INVALID_TRACKDIR, TRACKDIR_X_NE,     INVALID_TRACKDIR, INVALID_TRACKDIR,  INVALID_TRACKDIR, TRACKDIR_X_SW,     INVALID_TRACKDIR, INVALID_TRACKDIR},

   103

	{INVALID_TRACKDIR, INVALID_TRACKDIR,  INVALID_TRACKDIR, TRACKDIR_Y_SE,     INVALID_TRACKDIR, INVALID_TRACKDIR,  INVALID_TRACKDIR, TRACKDIR_Y_NW},

   104

	{INVALID_TRACKDIR, INVALID_TRACKDIR,  TRACKDIR_UPPER_E, INVALID_TRACKDIR,  INVALID_TRACKDIR, INVALID_TRACKDIR,  TRACKDIR_UPPER_W, INVALID_TRACKDIR},

   105

	{INVALID_TRACKDIR, INVALID_TRACKDIR,  TRACKDIR_LOWER_E, INVALID_TRACKDIR,  INVALID_TRACKDIR, INVALID_TRACKDIR,  TRACKDIR_LOWER_W, INVALID_TRACKDIR},

   106

	{TRACKDIR_LEFT_N,  INVALID_TRACKDIR,  INVALID_TRACKDIR, INVALID_TRACKDIR,  TRACKDIR_LEFT_S,  INVALID_TRACKDIR,  INVALID_TRACKDIR, INVALID_TRACKDIR},

   107

	{TRACKDIR_RIGHT_N, INVALID_TRACKDIR,  INVALID_TRACKDIR, INVALID_TRACKDIR,  TRACKDIR_RIGHT_S, INVALID_TRACKDIR,  INVALID_TRACKDIR, INVALID_TRACKDIR}

   108

};

   109

   110

extern const Trackdir _dir_to_diag_trackdir[] = {

   111

	TRACKDIR_X_NE, TRACKDIR_Y_SE, TRACKDIR_X_SW, TRACKDIR_Y_NW,

   112

};

   113

   114

extern const TrackBits _corner_to_trackbits[] = {

   115

	TRACK_BIT_LEFT, TRACK_BIT_LOWER, TRACK_BIT_RIGHT, TRACK_BIT_UPPER,

   116

};

   117

   118

extern const TrackdirBits _uphill_trackdirs[] = {

   119

	TRACKDIR_BIT_NONE                    , ///<  0 SLOPE_FLAT

   120

	TRACKDIR_BIT_X_SW | TRACKDIR_BIT_Y_NW, ///<  1 SLOPE_W   -> inclined for diagonal track

   121

	TRACKDIR_BIT_X_SW | TRACKDIR_BIT_Y_SE, ///<  2 SLOPE_S   -> inclined for diagonal track

   122

	TRACKDIR_BIT_X_SW                    , ///<  3 SLOPE_SW

   123

	TRACKDIR_BIT_X_NE | TRACKDIR_BIT_Y_SE, ///<  4 SLOPE_E   -> inclined for diagonal track

   124

	TRACKDIR_BIT_NONE                    , ///<  5 SLOPE_EW

   125

	TRACKDIR_BIT_Y_SE                    , ///<  6 SLOPE_SE

   126

	TRACKDIR_BIT_NONE                    , ///<  7 SLOPE_WSE -> leveled

   127

	TRACKDIR_BIT_X_NE | TRACKDIR_BIT_Y_NW, ///<  8 SLOPE_N   -> inclined for diagonal track

   128

	TRACKDIR_BIT_Y_NW                    , ///<  9 SLOPE_NW

   129

	TRACKDIR_BIT_NONE                    , ///< 10 SLOPE_NS

   130

	TRACKDIR_BIT_NONE                    , ///< 11 SLOPE_NWS -> leveled

   131

	TRACKDIR_BIT_X_NE                    , ///< 12 SLOPE_NE

   132

	TRACKDIR_BIT_NONE                    , ///< 13 SLOPE_ENW -> leveled

   133

	TRACKDIR_BIT_NONE                    , ///< 14 SLOPE_SEN -> leveled

   134

	TRACKDIR_BIT_NONE                    , ///< 15 invalid

   135

	TRACKDIR_BIT_NONE                    , ///< 16 invalid

   136

	TRACKDIR_BIT_NONE                    , ///< 17 invalid

   137

	TRACKDIR_BIT_NONE                    , ///< 18 invalid

   138

	TRACKDIR_BIT_NONE                    , ///< 19 invalid

   139

	TRACKDIR_BIT_NONE                    , ///< 20 invalid

   140

	TRACKDIR_BIT_NONE                    , ///< 21 invalid

   141

	TRACKDIR_BIT_NONE                    , ///< 22 invalid

   142

	TRACKDIR_BIT_X_SW | TRACKDIR_BIT_Y_SE, ///< 23 SLOPE_STEEP_S -> inclined for diagonal track

   143

	TRACKDIR_BIT_NONE                    , ///< 24 invalid

   144

	TRACKDIR_BIT_NONE                    , ///< 25 invalid

   145

	TRACKDIR_BIT_NONE                    , ///< 26 invalid

   146

	TRACKDIR_BIT_X_SW | TRACKDIR_BIT_Y_NW, ///< 27 SLOPE_STEEP_W -> inclined for diagonal track

   147

	TRACKDIR_BIT_NONE                    , ///< 28 invalid

   148

	TRACKDIR_BIT_X_NE | TRACKDIR_BIT_Y_NW, ///< 29 SLOPE_STEEP_N -> inclined for diagonal track

   149

	TRACKDIR_BIT_X_NE | TRACKDIR_BIT_Y_SE, ///< 30 SLOPE_STEEP_E -> inclined for diagonal track

   150

};

   151

   152

/* The default multiplier for the cost of building different types of railway

   153

 * track, which will be divided by 8. Can be changed by newgrf files. */

   154

const int _default_railtype_cost_multiplier[RAILTYPE_END] = {

   155

	8, 12, 16, 24,

   156

};

   157

int _railtype_cost_multiplier[RAILTYPE_END];

   158

   159

RailType GetTileRailType(TileIndex tile)

   160

{

   161

	switch (GetTileType(tile)) {

   162

		case MP_RAILWAY:

   163

			return GetRailType(tile);

   164

   165

		case MP_ROAD:

   166

			/* rail/road crossing */

   167

			if (IsLevelCrossing(tile)) return GetRailType(tile);

   168

			break;

   169

   170

		case MP_STATION:

   171

			if (IsRailwayStationTile(tile)) return GetRailType(tile);

   172

			break;

   173

   174

		case MP_TUNNELBRIDGE:

   175

			if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL) return GetRailType(tile);

   176

			break;

   177

   178

		default:

   179

			break;

   180

	}

   181

	return INVALID_RAILTYPE;

   182

}

   183

   184

bool HasRailtypeAvail(const PlayerID p, const RailType railtype)

   185

{

   186

	return HasBit(GetPlayer(p)->avail_railtypes, railtype);

   187

}

   188

   189

bool ValParamRailtype(const RailType rail)

   190

{

   191

	return HasRailtypeAvail(_current_player, rail);

   192

}

   193

   194

RailType GetBestRailtype(const PlayerID p)

   195

{

   196

	if (HasRailtypeAvail(p, RAILTYPE_MAGLEV)) return RAILTYPE_MAGLEV;

   197

	if (HasRailtypeAvail(p, RAILTYPE_MONO)) return RAILTYPE_MONO;

   198

	if (HasRailtypeAvail(p, RAILTYPE_ELECTRIC)) return RAILTYPE_ELECTRIC;

   199

	return RAILTYPE_RAIL;

   200

}

   201

   202

RailTypes GetPlayerRailtypes(PlayerID p)

   203

{

   204

	RailTypes rt = RAILTYPES_NONE;

   205

   206

	Engine *e;

   207

	FOR_ALL_ENGINES_OF_TYPE(e, VEH_TRAIN) {

   208

		const EngineInfo *ei = &e->info;

   209

   210

		if (HasBit(ei->climates, _settings_game.game_creation.landscape) &&

   211

				(HasBit(e->player_avail, p) || _date >= e->intro_date + 365)) {

   212

			const RailVehicleInfo *rvi = &e->u.rail;

   213

   214

			if (rvi->railveh_type != RAILVEH_WAGON) {

   215

				assert(rvi->railtype < RAILTYPE_END);

   216

				SetBit(rt, rvi->railtype);

   217

			}

   218

		}

   219

	}

   220

   221

	return rt;

   222

}