1

/* $Id$ */

     2

     3

/** @file rail.cpp */

     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

    18

    19

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

    20

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

    21

 * direction along with the trackdir */

    22

extern const byte _signal_along_trackdir[TRACKDIR_END] = {

    23

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

    24

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

    25

};

    26

    27

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

    28

 * direction against the trackdir */

    29

extern const byte _signal_against_trackdir[TRACKDIR_END] = {

    30

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

    31

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

    32

};

    33

    34

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

    35

 * be present on the given track */

    36

extern const byte _signal_on_track[] = {

    37

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

    38

};

    39

    40

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

    41

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

    42

 */

    43

extern const TrackdirBits _exitdir_reaches_trackdirs[] = {

    44

	TRACKDIR_BIT_X_NE | TRACKDIR_BIT_LOWER_E | TRACKDIR_BIT_LEFT_N,  /* DIAGDIR_NE */

    45

	TRACKDIR_BIT_Y_SE | TRACKDIR_BIT_LEFT_S  | TRACKDIR_BIT_UPPER_E, /* DIAGDIR_SE */

    46

	TRACKDIR_BIT_X_SW | TRACKDIR_BIT_UPPER_W | TRACKDIR_BIT_RIGHT_S, /* DIAGDIR_SW */

    47

	TRACKDIR_BIT_Y_NW | TRACKDIR_BIT_RIGHT_N | TRACKDIR_BIT_LOWER_W  /* DIAGDIR_NW */

    48

};

    49

    50

extern const Trackdir _next_trackdir[TRACKDIR_END] = {

    51

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

    52

	TRACKDIR_X_SW,  TRACKDIR_Y_NW,  TRACKDIR_LOWER_W, TRACKDIR_UPPER_W, TRACKDIR_RIGHT_N, TRACKDIR_LEFT_N

    53

};

    54

    55

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

    56

extern const TrackdirBits _track_crosses_trackdirs[TRACKDIR_END] = {

    57

	TRACKDIR_BIT_Y_SE     | TRACKDIR_BIT_Y_NW,                                                   /* TRACK_X     */

    58

	TRACKDIR_BIT_X_NE     | TRACKDIR_BIT_X_SW,                                                   /* TRACK_Y     */

    59

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

    60

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

    61

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

    62

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

    63

};

    64

    65

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

    66

extern const TrackBits _track_crosses_tracks[] = {

    67

	TRACK_BIT_Y,    /* TRACK_X     */

    68

	TRACK_BIT_X,    /* TRACK_Y     */

    69

	TRACK_BIT_VERT, /* TRACK_UPPER */

    70

	TRACK_BIT_VERT, /* TRACK_LOWER */

    71

	TRACK_BIT_HORZ, /* TRACK_LEFT  */

    72

	TRACK_BIT_HORZ  /* TRACK_RIGHT */

    73

};

    74

    75

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

    76

 * that trackdir */

    77

extern const DiagDirection _trackdir_to_exitdir[TRACKDIR_END] = {

    78

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

    79

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

    80

};

    81

    82

extern const Trackdir _track_exitdir_to_trackdir[][DIAGDIR_END] = {

    83

	{TRACKDIR_X_NE,     INVALID_TRACKDIR,  TRACKDIR_X_SW,     INVALID_TRACKDIR},

    84

	{INVALID_TRACKDIR,  TRACKDIR_Y_SE,     INVALID_TRACKDIR,  TRACKDIR_Y_NW},

    85

	{TRACKDIR_UPPER_E,  INVALID_TRACKDIR,  INVALID_TRACKDIR,  TRACKDIR_UPPER_W},

    86

	{INVALID_TRACKDIR,  TRACKDIR_LOWER_E,  TRACKDIR_LOWER_W,  INVALID_TRACKDIR},

    87

	{INVALID_TRACKDIR,  INVALID_TRACKDIR,  TRACKDIR_LEFT_S,   TRACKDIR_LEFT_N},

    88

	{TRACKDIR_RIGHT_N,  TRACKDIR_RIGHT_S,  INVALID_TRACKDIR,  INVALID_TRACKDIR}

    89

};

    90

    91

extern const Trackdir _track_enterdir_to_trackdir[][DIAGDIR_END] = {

    92

	{TRACKDIR_X_NE,     INVALID_TRACKDIR,  TRACKDIR_X_SW,     INVALID_TRACKDIR},

    93

	{INVALID_TRACKDIR,  TRACKDIR_Y_SE,     INVALID_TRACKDIR,  TRACKDIR_Y_NW},

    94

	{INVALID_TRACKDIR,  TRACKDIR_UPPER_E,  TRACKDIR_UPPER_W,  INVALID_TRACKDIR},

    95

	{TRACKDIR_LOWER_E,  INVALID_TRACKDIR,  INVALID_TRACKDIR,  TRACKDIR_LOWER_W},

    96

	{TRACKDIR_LEFT_N,   TRACKDIR_LEFT_S,   INVALID_TRACKDIR,  INVALID_TRACKDIR},

    97

	{INVALID_TRACKDIR,  INVALID_TRACKDIR,  TRACKDIR_RIGHT_S,  TRACKDIR_RIGHT_N}

    98

};

    99

   100

extern const Trackdir _track_direction_to_trackdir[][DIR_END] = {

   101

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

   102

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

   103

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

   104

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

   105

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

   106

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

   107

};

   108

   109

extern const Trackdir _dir_to_diag_trackdir[] = {

   110

	TRACKDIR_X_NE, TRACKDIR_Y_SE, TRACKDIR_X_SW, TRACKDIR_Y_NW,

   111

};

   112

   113

extern const TrackBits _corner_to_trackbits[] = {

   114

	TRACK_BIT_LEFT, TRACK_BIT_LOWER, TRACK_BIT_RIGHT, TRACK_BIT_UPPER,

   115

};

   116

   117

extern const TrackdirBits _uphill_trackdirs[] = {

   118

	TRACKDIR_BIT_NONE                    , ///<  0 SLOPE_FLAT

   119

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

   120

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

   121

	TRACKDIR_BIT_X_SW                    , ///<  3 SLOPE_SW

   122

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

   123

	TRACKDIR_BIT_NONE                    , ///<  5 SLOPE_EW

   124

	TRACKDIR_BIT_Y_SE                    , ///<  6 SLOPE_SE

   125

	TRACKDIR_BIT_NONE                    , ///<  7 SLOPE_WSE -> leveled

   126

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

   127

	TRACKDIR_BIT_Y_NW                    , ///<  9 SLOPE_NW

   128

	TRACKDIR_BIT_NONE                    , ///< 10 SLOPE_NS

   129

	TRACKDIR_BIT_NONE                    , ///< 11 SLOPE_NWS -> leveled

   130

	TRACKDIR_BIT_X_NE                    , ///< 12 SLOPE_NE

   131

	TRACKDIR_BIT_NONE                    , ///< 13 SLOPE_ENW -> leveled

   132

	TRACKDIR_BIT_NONE                    , ///< 14 SLOPE_SEN -> leveled

   133

	TRACKDIR_BIT_NONE                    , ///< 15 invalid

   134

	TRACKDIR_BIT_NONE                    , ///< 16 invalid

   135

	TRACKDIR_BIT_NONE                    , ///< 17 invalid

   136

	TRACKDIR_BIT_NONE                    , ///< 18 invalid

   137

	TRACKDIR_BIT_NONE                    , ///< 19 invalid

   138

	TRACKDIR_BIT_NONE                    , ///< 20 invalid

   139

	TRACKDIR_BIT_NONE                    , ///< 21 invalid

   140

	TRACKDIR_BIT_NONE                    , ///< 22 invalid

   141

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

   142

	TRACKDIR_BIT_NONE                    , ///< 24 invalid

   143

	TRACKDIR_BIT_NONE                    , ///< 25 invalid

   144

	TRACKDIR_BIT_NONE                    , ///< 26 invalid

   145

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

   146

	TRACKDIR_BIT_NONE                    , ///< 28 invalid

   147

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

   148

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

   149

};

   150

   151

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

   152

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

   153

const int _default_railtype_cost_multiplier[RAILTYPE_END] = {

   154

	8, 12, 16, 24,

   155

};

   156

int _railtype_cost_multiplier[RAILTYPE_END];

   157

   158

RailType GetTileRailType(TileIndex tile)

   159

{

   160

	switch (GetTileType(tile)) {

   161

		case MP_RAILWAY:

   162

			return GetRailType(tile);

   163

   164

		case MP_ROAD:

   165

			/* rail/road crossing */

   166

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

   167

			break;

   168

   169

		case MP_STATION:

   170

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

   171

			break;

   172

   173

		case MP_TUNNELBRIDGE:

   174

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

   175

			break;

   176

   177

		default:

   178

			break;

   179

	}

   180

	return INVALID_RAILTYPE;

   181

}

   182

   183

bool HasRailtypeAvail(const PlayerID p, const RailType railtype)

   184

{

   185

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

   186

}

   187

   188

bool ValParamRailtype(const RailType rail)

   189

{

   190

	return HasRailtypeAvail(_current_player, rail);

   191

}

   192

   193

RailType GetBestRailtype(const PlayerID p)

   194

{

   195

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

   196

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

   197

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

   198

	return RAILTYPE_RAIL;

   199

}

   200

   201

RailTypes GetPlayerRailtypes(PlayerID p)

   202

{

   203

	RailTypes rt = RAILTYPES_NONE;

   204

   205

	EngineID i;

   206

	FOR_ALL_ENGINEIDS_OF_TYPE(i, VEH_TRAIN) {

   207

		const Engine* e = GetEngine(i);

   208

		const EngineInfo *ei = EngInfo(i);

   209

   210

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

   211

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

   212

			const RailVehicleInfo *rvi = RailVehInfo(i);

   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

}