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

    47

// TODO remove this by moving to the same bits as GetRailType()

    48

static inline RailType GetRailTypeCrossing(TileIndex t)

    49

{

    50

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

    51

}

    52

    53

static inline RailType GetRailTypeOnBridge(TileIndex t)

    54

{

    55

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

    56

}

    57

    58

static inline void SetRailType(TileIndex t, RailType r)

    59

{

    60

	SB(_m[t].m3, 0, 4, r);

    61

}

    62

    63

// TODO remove this by moving to the same bits as SetRailType()

    64

static inline void SetRailTypeCrossing(TileIndex t, RailType r)

    65

{

    66

	SB(_m[t].m4, 0, 4, r);

    67

}

    68

    69

static inline void SetRailTypeOnBridge(TileIndex t, RailType r)

    70

{

    71

	SB(_m[t].m3, 4, 4, r);

    72

}

    73

    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_CROSS = TRACK_BIT_X     | TRACK_BIT_Y,

    98

	TRACK_BIT_HORZ  = TRACK_BIT_UPPER | TRACK_BIT_LOWER,

    99

	TRACK_BIT_VERT  = TRACK_BIT_LEFT  | TRACK_BIT_RIGHT,

   100

	TRACK_BIT_3WAY_NE = TRACK_BIT_X | TRACK_BIT_UPPER | TRACK_BIT_RIGHT,

   101

	TRACK_BIT_3WAY_SE = TRACK_BIT_Y | TRACK_BIT_LOWER | TRACK_BIT_RIGHT,

   102

	TRACK_BIT_3WAY_SW = TRACK_BIT_X | TRACK_BIT_LOWER | TRACK_BIT_LEFT,

   103

	TRACK_BIT_3WAY_NW = TRACK_BIT_Y | TRACK_BIT_UPPER | TRACK_BIT_LEFT,

   104

	TRACK_BIT_ALL   = TRACK_BIT_CROSS | TRACK_BIT_HORZ | TRACK_BIT_VERT,

   105

	TRACK_BIT_MASK  = 0x3FU

   106

} TrackBits;

   107

   108

static inline TrackBits GetTrackBits(TileIndex tile)

   109

{

   110

	return (TrackBits)GB(_m[tile].m5, 0, 6);

   111

}

   112

   113

static inline void SetTrackBits(TileIndex t, TrackBits b)

   114

{

   115

	SB(_m[t].m5, 0, 6, b);

   116

}

   117

   118

   119

static inline DiagDirection GetRailDepotDirection(TileIndex t)

   120

{

   121

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

   122

}

   123

   124

   125

static inline TrackBits GetRailWaypointBits(TileIndex t)

   126

{

   127

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

   128

}

   129

   130

   131

typedef enum SignalType {

   132

	SIGTYPE_NORMAL  = 0, // normal signal

   133

	SIGTYPE_ENTRY   = 1, // presignal block entry

   134

	SIGTYPE_EXIT    = 2, // presignal block exit

   135

	SIGTYPE_COMBO   = 3  // presignal inter-block

   136

} SignalType;

   137

   138

static inline SignalType GetSignalType(TileIndex t)

   139

{

   140

	assert(GetRailTileType(t) == RAIL_TYPE_SIGNALS);

   141

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

   142

}

   143

   144

static inline void SetSignalType(TileIndex t, SignalType s)

   145

{

   146

	assert(GetRailTileType(t) == RAIL_TYPE_SIGNALS);

   147

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

   148

}

   149

   150

   151

typedef enum SignalVariant {

   152

	SIG_ELECTRIC  = 0,

   153

	SIG_SEMAPHORE = 1

   154

} SignalVariant;

   155

   156

static inline SignalVariant GetSignalVariant(TileIndex t)

   157

{

   158

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

   159

}

   160

   161

static inline void SetSignalVariant(TileIndex t, SignalVariant v)

   162

{

   163

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

   164

}

   165

   166

   167

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

   168

{

   169

	SetTileType(t, MP_RAILWAY);

   170

	SetTileOwner(t, o);

   171

	_m[t].m2 = 0;

   172

	_m[t].m3 = r;

   173

	_m[t].m4 = 0;

   174

	_m[t].m5 = RAIL_TYPE_NORMAL | b;

   175

}

   176

   177

   178

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

   179

{

   180

	SetTileType(t, MP_RAILWAY);

   181

	SetTileOwner(t, o);

   182

	_m[t].m2 = 0;

   183

	_m[t].m3 = r;

   184

	_m[t].m4 = 0;

   185

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

   186

}

   187

   188

   189

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

   190

{

   191

	SetTileType(t, MP_RAILWAY);

   192

	SetTileOwner(t, o);

   193

	_m[t].m2 = index;

   194

	_m[t].m3 = r;

   195

	_m[t].m4 = 0;

   196

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

   197

}

   198

   199

#endif