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

static inline Track GetRailWaypointTrack(TileIndex t)

   128

{

   129

	return HASBIT(_m[t].m5, 0) ? TRACK_Y : TRACK_X;

   130

}

   131

   132

static inline TrackBits GetRailWaypointBits(TileIndex t)

   133

{

   134

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

   135

}

   136

   137

static inline void SetCustomWaypointSprite(TileIndex t)

   138

{

   139

	SETBIT(_m[t].m3, 4);

   140

}

   141

   142

static inline void ClearCustomWaypointSprite(TileIndex t)

   143

{

   144

	CLRBIT(_m[t].m3, 4);

   145

}

   146

   147

   148

typedef enum SignalType {

   149

	SIGTYPE_NORMAL  = 0, // normal signal

   150

	SIGTYPE_ENTRY   = 1, // presignal block entry

   151

	SIGTYPE_EXIT    = 2, // presignal block exit

   152

	SIGTYPE_COMBO   = 3  // presignal inter-block

   153

} SignalType;

   154

   155

static inline SignalType GetSignalType(TileIndex t)

   156

{

   157

	assert(GetRailTileType(t) == RAIL_TYPE_SIGNALS);

   158

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

   159

}

   160

   161

static inline void SetSignalType(TileIndex t, SignalType s)

   162

{

   163

	assert(GetRailTileType(t) == RAIL_TYPE_SIGNALS);

   164

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

   165

}

   166

   167

   168

typedef enum SignalVariant {

   169

	SIG_ELECTRIC  = 0,

   170

	SIG_SEMAPHORE = 1

   171

} SignalVariant;

   172

   173

static inline SignalVariant GetSignalVariant(TileIndex t)

   174

{

   175

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

   176

}

   177

   178

static inline void SetSignalVariant(TileIndex t, SignalVariant v)

   179

{

   180

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

   181

}

   182

   183

   184

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

   185

{

   186

	SetTileType(t, MP_RAILWAY);

   187

	SetTileOwner(t, o);

   188

	_m[t].m2 = 0;

   189

	_m[t].m3 = r;

   190

	_m[t].m4 = 0;

   191

	_m[t].m5 = RAIL_TYPE_NORMAL | b;

   192

}

   193

   194

   195

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

   196

{

   197

	SetTileType(t, MP_RAILWAY);

   198

	SetTileOwner(t, o);

   199

	_m[t].m2 = 0;

   200

	_m[t].m3 = r;

   201

	_m[t].m4 = 0;

   202

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

   203

}

   204

   205

   206

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

   207

{

   208

	SetTileType(t, MP_RAILWAY);

   209

	SetTileOwner(t, o);

   210

	_m[t].m2 = index;

   211

	_m[t].m3 = r;

   212

	_m[t].m4 = 0;

   213

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

   214

}

   215

   216

#endif