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

static inline bool IsCustomWaypoint(TileIndex t)

   148

{

   149

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

   150

}

   151

   152

static inline Axis GetWaypointAxis(TileIndex t)

   153

{

   154

	return HASBIT(_m[t].m5, 0) ? AXIS_Y : AXIS_X;

   155

}

   156

   157

   158

typedef enum SignalType {

   159

	SIGTYPE_NORMAL  = 0, // normal signal

   160

	SIGTYPE_ENTRY   = 1, // presignal block entry

   161

	SIGTYPE_EXIT    = 2, // presignal block exit

   162

	SIGTYPE_COMBO   = 3  // presignal inter-block

   163

} SignalType;

   164

   165

static inline SignalType GetSignalType(TileIndex t)

   166

{

   167

	assert(GetRailTileType(t) == RAIL_TYPE_SIGNALS);

   168

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

   169

}

   170

   171

static inline void SetSignalType(TileIndex t, SignalType s)

   172

{

   173

	assert(GetRailTileType(t) == RAIL_TYPE_SIGNALS);

   174

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

   175

}

   176

   177

static inline bool IsPresignalEntry(TileIndex t)

   178

{

   179

	return GetSignalType(t) == SIGTYPE_ENTRY || GetSignalType(t) == SIGTYPE_COMBO;

   180

}

   181

   182

static inline bool IsPresignalExit(TileIndex t)

   183

{

   184

	return GetSignalType(t) == SIGTYPE_EXIT || GetSignalType(t) == SIGTYPE_COMBO;

   185

}

   186

   187

static inline void CycleSignalSide(TileIndex t, Track track)

   188

{

   189

	byte sig;

   190

	byte pos = 6;

   191

	if (track == TRACK_LOWER || track == TRACK_RIGHT) pos = 4;

   192

   193

	sig = GB(_m[t].m3, pos, 2);

   194

	if (--sig == 0) sig = 3;

   195

	SB(_m[t].m3, pos, 2, sig);

   196

}

   197

   198

   199

typedef enum SignalVariant {

   200

	SIG_ELECTRIC  = 0,

   201

	SIG_SEMAPHORE = 1

   202

} SignalVariant;

   203

   204

static inline SignalVariant GetSignalVariant(TileIndex t)

   205

{

   206

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

   207

}

   208

   209

static inline void SetSignalVariant(TileIndex t, SignalVariant v)

   210

{

   211

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

   212

}

   213

   214

static inline bool IsSignalPresent(TileIndex t, byte signalbit)

   215

{

   216

	return HASBIT(_m[t].m3, signalbit + 4);

   217

}

   218

   219

/** These are states in which a signal can be. Currently these are only two, so

   220

 * simple boolean logic will do. But do try to compare to this enum instead of

   221

 * normal boolean evaluation, since that will make future additions easier.

   222

 */

   223

typedef enum SignalStates {

   224

	SIGNAL_STATE_RED = 0,

   225

	SIGNAL_STATE_GREEN = 1,

   226

} SignalState;

   227

   228

static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)

   229

{

   230

	return HASBIT(_m[t].m2, signalbit + 4);

   231

}

   232

   233

   234

typedef enum RailGroundType {

   235

	RAIL_MAP2LO_GROUND_MASK = 0xF,

   236

	RAIL_GROUND_BARREN = 0,

   237

	RAIL_GROUND_GRASS = 1,

   238

	RAIL_GROUND_FENCE_NW = 2,

   239

	RAIL_GROUND_FENCE_SE = 3,

   240

	RAIL_GROUND_FENCE_SENW = 4,

   241

	RAIL_GROUND_FENCE_NE = 5,

   242

	RAIL_GROUND_FENCE_SW = 6,

   243

	RAIL_GROUND_FENCE_NESW = 7,

   244

	RAIL_GROUND_FENCE_VERT1 = 8,

   245

	RAIL_GROUND_FENCE_VERT2 = 9,

   246

	RAIL_GROUND_FENCE_HORIZ1 = 10,

   247

	RAIL_GROUND_FENCE_HORIZ2 = 11,

   248

	RAIL_GROUND_ICE_DESERT = 12,

   249

} RailGroundType;

   250

   251

static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)

   252

{

   253

	if (GetRailTileType(t) == RAIL_TYPE_DEPOT_WAYPOINT) {

   254

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

   255

		return;

   256

	}

   257

	SB(_m[t].m2, 0, 4, rgt);

   258

}

   259

   260

static inline RailGroundType GetRailGroundType(TileIndex t)

   261

{

   262

	/* TODO Unify this */

   263

	if (GetRailTileType(t) == RAIL_TYPE_DEPOT_WAYPOINT) return GB(_m[t].m4, 0, 4);

   264

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

   265

}

   266

   267

static inline bool IsBarrenRailGround(TileIndex t)

   268

{

   269

	return GetRailGroundType(t) == RAIL_GROUND_BARREN;

   270

}

   271

   272

static inline bool IsSnowRailGround(TileIndex t)

   273

{

   274

	return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;

   275

}

   276

   277

   278

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

   279

{

   280

	SetTileType(t, MP_RAILWAY);

   281

	SetTileOwner(t, o);

   282

	_m[t].m2 = 0;

   283

	_m[t].m3 = r;

   284

	_m[t].m4 = 0;

   285

	_m[t].m5 = RAIL_TYPE_NORMAL | b;

   286

}

   287

   288

   289

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

   290

{

   291

	SetTileType(t, MP_RAILWAY);

   292

	SetTileOwner(t, o);

   293

	_m[t].m2 = 0;

   294

	_m[t].m3 = r;

   295

	_m[t].m4 = 0;

   296

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

   297

}

   298

   299

   300

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

   301

{

   302

	SetTileType(t, MP_RAILWAY);

   303

	SetTileOwner(t, o);

   304

	_m[t].m2 = index;

   305

	_m[t].m3 = r;

   306

	_m[t].m4 = 0;

   307

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

   308

}

   309

   310

#endif