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_ELECTRIC = 1,

    37

	RAILTYPE_MONO     = 2,

    38

	RAILTYPE_MAGLEV   = 3,

    39

	RAILTYPE_END,

    40

	INVALID_RAILTYPE = 0xFF

    41

} RailType;

    42

    43

typedef byte RailTypeMask;

    44

    45

static inline RailType GetRailType(TileIndex t)

    46

{

    47

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

    48

}

    49

    50

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

    51

static inline RailType GetRailTypeCrossing(TileIndex t)

    52

{

    53

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

    54

}

    55

    56

static inline RailType GetRailTypeOnBridge(TileIndex t)

    57

{

    58

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

    59

}

    60

    61

static inline void SetRailType(TileIndex t, RailType r)

    62

{

    63

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

    64

}

    65

    66

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

    67

static inline void SetRailTypeCrossing(TileIndex t, RailType r)

    68

{

    69

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

    70

}

    71

    72

static inline void SetRailTypeOnBridge(TileIndex t, RailType r)

    73

{

    74

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

    75

}

    76

    77

    78

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

    79

 * Can be translated to a trackbit with TrackToTrackbit */

    80

typedef enum Track {

    81

	TRACK_X     = 0,

    82

	TRACK_Y     = 1,

    83

	TRACK_UPPER = 2,

    84

	TRACK_LOWER = 3,

    85

	TRACK_LEFT  = 4,

    86

	TRACK_RIGHT = 5,

    87

	TRACK_END,

    88

	INVALID_TRACK = 0xFF

    89

} Track;

    90

    91

    92

/** Bitfield corresponding to Track */

    93

typedef enum TrackBits {

    94

	TRACK_BIT_X     = 1U << TRACK_X,

    95

	TRACK_BIT_Y     = 1U << TRACK_Y,

    96

	TRACK_BIT_UPPER = 1U << TRACK_UPPER,

    97

	TRACK_BIT_LOWER = 1U << TRACK_LOWER,

    98

	TRACK_BIT_LEFT  = 1U << TRACK_LEFT,

    99

	TRACK_BIT_RIGHT = 1U << TRACK_RIGHT,

   100

	TRACK_BIT_CROSS = TRACK_BIT_X     | TRACK_BIT_Y,

   101

	TRACK_BIT_HORZ  = TRACK_BIT_UPPER | TRACK_BIT_LOWER,

   102

	TRACK_BIT_VERT  = TRACK_BIT_LEFT  | TRACK_BIT_RIGHT,

   103

	TRACK_BIT_3WAY_NE = TRACK_BIT_X | TRACK_BIT_UPPER | TRACK_BIT_RIGHT,

   104

	TRACK_BIT_3WAY_SE = TRACK_BIT_Y | TRACK_BIT_LOWER | TRACK_BIT_RIGHT,

   105

	TRACK_BIT_3WAY_SW = TRACK_BIT_X | TRACK_BIT_LOWER | TRACK_BIT_LEFT,

   106

	TRACK_BIT_3WAY_NW = TRACK_BIT_Y | TRACK_BIT_UPPER | TRACK_BIT_LEFT,

   107

	TRACK_BIT_ALL   = TRACK_BIT_CROSS | TRACK_BIT_HORZ | TRACK_BIT_VERT,

   108

	TRACK_BIT_MASK  = 0x3FU

   109

} TrackBits;

   110

   111

static inline TrackBits GetTrackBits(TileIndex tile)

   112

{

   113

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

   114

}

   115

   116

static inline void SetTrackBits(TileIndex t, TrackBits b)

   117

{

   118

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

   119

}

   120

   121

   122

static inline DiagDirection GetRailDepotDirection(TileIndex t)

   123

{

   124

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

   125

}

   126

   127

   128

static inline TrackBits GetRailWaypointBits(TileIndex t)

   129

{

   130

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

   131

}

   132

   133

   134

typedef enum SignalType {

   135

	SIGTYPE_NORMAL  = 0, // normal signal

   136

	SIGTYPE_ENTRY   = 1, // presignal block entry

   137

	SIGTYPE_EXIT    = 2, // presignal block exit

   138

	SIGTYPE_COMBO   = 3  // presignal inter-block

   139

} SignalType;

   140

   141

static inline SignalType GetSignalType(TileIndex t)

   142

{

   143

	assert(GetRailTileType(t) == RAIL_TYPE_SIGNALS);

   144

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

   145

}

   146

   147

static inline void SetSignalType(TileIndex t, SignalType s)

   148

{

   149

	assert(GetRailTileType(t) == RAIL_TYPE_SIGNALS);

   150

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

   151

}

   152

   153

   154

typedef enum SignalVariant {

   155

	SIG_ELECTRIC  = 0,

   156

	SIG_SEMAPHORE = 1

   157

} SignalVariant;

   158

   159

static inline SignalVariant GetSignalVariant(TileIndex t)

   160

{

   161

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

   162

}

   163

   164

static inline void SetSignalVariant(TileIndex t, SignalVariant v)

   165

{

   166

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

   167

}

   168

   169

   170

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

   171

{

   172

	SetTileType(t, MP_RAILWAY);

   173

	SetTileOwner(t, o);

   174

	_m[t].m2 = 0;

   175

	_m[t].m3 = r;

   176

	_m[t].m4 = 0;

   177

	_m[t].m5 = RAIL_TYPE_NORMAL | b;

   178

}

   179

   180

   181

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

   182

{

   183

	SetTileType(t, MP_RAILWAY);

   184

	SetTileOwner(t, o);

   185

	_m[t].m2 = 0;

   186

	_m[t].m3 = r;

   187

	_m[t].m4 = 0;

   188

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

   189

}

   190

   191

   192

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

   193

{

   194

	SetTileType(t, MP_RAILWAY);

   195

	SetTileOwner(t, o);

   196

	_m[t].m2 = index;

   197

	_m[t].m3 = r;

   198

	_m[t].m4 = 0;

   199

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

   200

}

   201

   202

#endif