1

/* $Id$ */

     2

     3

#ifndef RAIL_MAP_H

     4

#define RAIL_MAP_H

     5

     6

#include "direction.h"

     7

#include "tile.h"

     8

     9

    10

typedef enum RailTileType {

    11

	RAIL_TYPE_NORMAL         = 0x0,

    12

	RAIL_TYPE_SIGNALS        = 0x40,

    13

	RAIL_TYPE_UNUSED         = 0x80, /* XXX: Maybe this could become waypoints? */

    14

	RAIL_TYPE_DEPOT_WAYPOINT = 0xC0, /* Is really depots and waypoints... */

    15

	RAIL_TILE_TYPE_MASK      = 0xC0

    16

} RailTileType;

    17

    18

static inline RailTileType GetRailTileType(TileIndex t)

    19

{

    20

	assert(IsTileType(t, MP_RAILWAY));

    21

	return _m[t].m5 & RAIL_TILE_TYPE_MASK;

    22

}

    23

    24

    25

/** These specify the subtype when the main rail type is

    26

 * RAIL_TYPE_DEPOT_WAYPOINT */

    27

typedef enum RailTileSubtypes {

    28

	RAIL_SUBTYPE_DEPOT    = 0x00,

    29

	RAIL_SUBTYPE_WAYPOINT = 0x04,

    30

	RAIL_SUBTYPE_MASK     = 0x3C

    31

} RailTileSubtype;

    32

    33

    34

typedef enum RailTypes {

    35

	RAILTYPE_RAIL   = 0,

    36

	RAILTYPE_MONO   = 1,

    37

	RAILTYPE_MAGLEV = 2,

    38

	RAILTYPE_END,

    39

	INVALID_RAILTYPE = 0xFF

    40

} RailType;

    41

    42

static inline RailType GetRailType(TileIndex t)

    43

{

    44

	return (RailType)GB(_m[t].m3, 0, 4);

    45

}

    46

    74

    75

/** These are used to specify a single track.

    76

 * Can be translated to a trackbit with TrackToTrackbit */

    77

typedef enum Track {

    78

	TRACK_X     = 0,

    79

	TRACK_Y     = 1,

    80

	TRACK_UPPER = 2,

    81

	TRACK_LOWER = 3,

    82

	TRACK_LEFT  = 4,

    83

	TRACK_RIGHT = 5,

    84

	TRACK_END,

    85

	INVALID_TRACK = 0xFF

    86

} Track;

    87

    88

    89

/** Bitfield corresponding to Track */

    90

typedef enum TrackBits {

    91

	TRACK_BIT_X     = 1U << TRACK_X,

    92

	TRACK_BIT_Y     = 1U << TRACK_Y,

    93

	TRACK_BIT_UPPER = 1U << TRACK_UPPER,

    94

	TRACK_BIT_LOWER = 1U << TRACK_LOWER,

    95

	TRACK_BIT_LEFT  = 1U << TRACK_LEFT,

    96

	TRACK_BIT_RIGHT = 1U << TRACK_RIGHT,

    97

	TRACK_BIT_MASK  = 0x3FU

    98

} TrackBits;

    99

   100

   101

static inline DiagDirection GetRailDepotDirection(TileIndex t)

   102

{

   103

	return (DiagDirection)GB(_m[t].m5, 0, 2);

   104

}

   105

   106

   107

static inline TrackBits GetRailWaypointBits(TileIndex t)

   108

{

   109

	return _m[t].m5 & 1 ? TRACK_BIT_Y : TRACK_BIT_X;

   110

}

   111

   112

   113

typedef enum SignalType {

   114

	SIGTYPE_NORMAL  = 0, // normal signal

   115

	SIGTYPE_ENTRY   = 1, // presignal block entry

   116

	SIGTYPE_EXIT    = 2, // presignal block exit

   117

	SIGTYPE_COMBO   = 3  // presignal inter-block

   118

} SignalType;

   119

   120

static inline SignalType GetSignalType(TileIndex t)

   121

{

   122

	assert(GetRailTileType(t) == RAIL_TYPE_SIGNALS);

   123

	return (SignalType)GB(_m[t].m4, 0, 2);

   124

}

   125

   126

static inline void SetSignalType(TileIndex t, SignalType s)

   127

{

   128

	assert(GetRailTileType(t) == RAIL_TYPE_SIGNALS);

   129

	SB(_m[t].m4, 0, 2, s);

   130

}

   131

   132

   133

typedef enum SignalVariant {

   134

	SIG_ELECTRIC  = 0,

   135

	SIG_SEMAPHORE = 1

   136

} SignalVariant;

   137

   138

static inline SignalVariant GetSignalVariant(TileIndex t)

   139

{

   140

	return (SignalVariant)GB(_m[t].m4, 2, 1);

   141

}

   142

   143

static inline void SetSignalVariant(TileIndex t, SignalVariant v)

   144

{

   145

	SB(_m[t].m4, 2, 1, v);

   146

}

   147

   148

   149

static inline void MakeRailNormal(TileIndex t, Owner o, TrackBits b, RailType r)

   150

{

   151

	SetTileType(t, MP_RAILWAY);

   152

	SetTileOwner(t, o);

   153

	_m[t].m2 = 0;

   154

	_m[t].m3 = r;

   155

	_m[t].m4 = 0;

   156

	_m[t].m5 = RAIL_TYPE_NORMAL | b;

   157

}

   158

   159

   160

static inline void MakeRailDepot(TileIndex t, Owner o, DiagDirection d, RailType r)

   161

{

   162

	SetTileType(t, MP_RAILWAY);

   163

	SetTileOwner(t, o);

   164

	_m[t].m2 = 0;

   165

	_m[t].m3 = r;

   166

	_m[t].m4 = 0;

   167

	_m[t].m5 = RAIL_TYPE_DEPOT_WAYPOINT | RAIL_SUBTYPE_DEPOT | d;

   168

}

   169

   170

   171

static inline void MakeRailWaypoint(TileIndex t, Owner o, Axis a, RailType r, uint index)

   172

{

   173

	SetTileType(t, MP_RAILWAY);

   174

	SetTileOwner(t, o);

   175

	_m[t].m2 = index;

   176

	_m[t].m3 = r;

   177

	_m[t].m4 = 0;

   178

	_m[t].m5 = RAIL_TYPE_DEPOT_WAYPOINT | RAIL_SUBTYPE_WAYPOINT | a;

   179

}

   180

   181

#endif