1

/* $Id$ */

     2

     3

#ifndef RAIL_MAP_H

     4

#define RAIL_MAP_H

     5

     6

#include "direction.h"

     7

#include "rail.h"

     8

#include "tile.h"

     9

    10

    11

enum RailTileType {

    12

	RAIL_TILE_NORMAL   = 0,

    13

	RAIL_TILE_SIGNALS  = 1,

    14

	RAIL_TILE_WAYPOINT = 2,

    15

	RAIL_TILE_DEPOT    = 3,

    16

};

    17

    18

static inline RailTileType GetRailTileType(TileIndex t)

    19

{

    20

	assert(IsTileType(t, MP_RAILWAY));

    21

	return (RailTileType)GB(_m[t].m5, 6, 2);

    22

}

    23

    24

/**

    25

 * Returns whether this is plain rails, with or without signals. Iow, if this

    26

 * tiles RailTileType is RAIL_TILE_NORMAL or RAIL_TILE_SIGNALS.

    27

 */

    28

static inline bool IsPlainRailTile(TileIndex tile)

    29

{

    30

	RailTileType rtt = GetRailTileType(tile);

    31

	return rtt == RAIL_TILE_NORMAL || rtt == RAIL_TILE_SIGNALS;

    32

}

    33

    34

/**

    35

 * Checks if a rail tile has signals.

    36

 */

    37

static inline bool HasSignals(TileIndex tile)

    38

{

    39

	return GetRailTileType(tile) == RAIL_TILE_SIGNALS;

    40

}

    41

    42

/**

    43

 * Add/remove the 'has signal' bit from the RailTileType

    44

 */

    45

static inline void SetHasSignals(TileIndex tile, bool signals)

    46

{

    47

	assert(IsPlainRailTile(tile));

    48

	SB(_m[tile].m5, 6, 1, signals);

    49

}

    50

    51

    52

static inline bool IsRailDepot(TileIndex t)

    53

{

    54

	return GetRailTileType(t) == RAIL_TILE_DEPOT;

    55

}

    56

    57

    58

static inline bool IsRailWaypoint(TileIndex t)

    59

{

    60

	return GetRailTileType(t) == RAIL_TILE_WAYPOINT;

    61

}

    62

    63

    64

static inline RailType GetRailType(TileIndex t)

    65

{

    66

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

    67

}

    68

    69

static inline void SetRailType(TileIndex t, RailType r)

    70

{

    71

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

    72

}

    73

    74

    75

static inline TrackBits GetTrackBits(TileIndex tile)

    76

{

    77

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

    78

}

    79

    80

static inline void SetTrackBits(TileIndex t, TrackBits b)

    81

{

    82

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

    83

}

    84

    85

/**

    86

 * Returns whether the given track is present on the given tile. Tile must be

    87

 * a plain rail tile (IsPlainRailTile()).

    88

 */

    89

static inline bool HasTrack(TileIndex tile, Track track)

    90

{

    91

	return HASBIT(GetTrackBits(tile), track);

    92

}

    93

    94

    95

static inline DiagDirection GetRailDepotDirection(TileIndex t)

    96

{

    97

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

    98

}

    99

   100

   101

static inline Axis GetWaypointAxis(TileIndex t)

   102

{

   103

	return (Axis)GB(_m[t].m5, 0, 1);

   104

}

   105

   106

static inline Track GetRailWaypointTrack(TileIndex t)

   107

{

   108

	return AxisToTrack(GetWaypointAxis(t));

   109

}

   110

   111

static inline TrackBits GetRailWaypointBits(TileIndex t)

   112

{

   113

	return TrackToTrackBits(GetRailWaypointTrack(t));

   114

}

   115

   116

static inline WaypointID GetWaypointIndex(TileIndex t)

   117

{

   118

	return (WaypointID)_m[t].m2;

   119

}

   120

   121

enum SignalType {

   122

	SIGTYPE_NORMAL  = 0, // normal signal

   123

	SIGTYPE_ENTRY   = 1, // presignal block entry

   124

	SIGTYPE_EXIT    = 2, // presignal block exit

   125

	SIGTYPE_COMBO   = 3  // presignal inter-block

   126

};

   127

   128

static inline SignalType GetSignalType(TileIndex t)

   129

{

   130

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   131

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

   132

}

   133

   134

static inline void SetSignalType(TileIndex t, SignalType s)

   135

{

   136

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   137

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

   138

}

   139

   140

static inline bool IsPresignalEntry(TileIndex t)

   141

{

   142

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

   143

}

   144

   145

static inline bool IsPresignalExit(TileIndex t)

   146

{

   147

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

   148

}

   149

   150

static inline void CycleSignalSide(TileIndex t, Track track)

   151

{

   152

	byte sig;

   153

	byte pos = 6;

   154

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

   155

   156

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

   157

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

   158

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

   159

}

   160

   161

   162

enum SignalVariant {

   163

	SIG_ELECTRIC  = 0,

   164

	SIG_SEMAPHORE = 1

   165

};

   166

   167

static inline SignalVariant GetSignalVariant(TileIndex t)

   168

{

   169

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

   170

}

   171

   172

static inline void SetSignalVariant(TileIndex t, SignalVariant v)

   173

{

   174

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

   175

}

   176

   177

static inline bool IsSignalPresent(TileIndex t, byte signalbit)

   178

{

   179

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

   180

}

   181

   182

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

   183

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

   184

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

   185

 */

   186

enum SignalState {

   187

	SIGNAL_STATE_RED   = 0,

   188

	SIGNAL_STATE_GREEN = 1,

   189

};

   190

   191

static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)

   192

{

   193

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

   194

}

   195

   196

   197

/**

   198

 * Checks for the presence of signals (either way) on the given track on the

   199

 * given rail tile.

   200

 */

   201

static inline bool HasSignalOnTrack(TileIndex tile, Track track)

   202

{

   203

	assert(IsValidTrack(track));

   204

	return

   205

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   206

		(_m[tile].m3 & SignalOnTrack(track)) != 0;

   207

}

   208

   209

/**

   210

 * Checks for the presence of signals along the given trackdir on the given

   211

 * rail tile.

   212

 *

   213

 * Along meaning if you are currently driving on the given trackdir, this is

   214

 * the signal that is facing us (for which we stop when it's red).

   215

 */

   216

static inline bool HasSignalOnTrackdir(TileIndex tile, Trackdir trackdir)

   217

{

   218

	assert (IsValidTrackdir(trackdir));

   219

	return

   220

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   221

		_m[tile].m3 & SignalAlongTrackdir(trackdir);

   222

}

   223

   224

/**

   225

 * Gets the state of the signal along the given trackdir.

   226

 *

   227

 * Along meaning if you are currently driving on the given trackdir, this is

   228

 * the signal that is facing us (for which we stop when it's red).

   229

 */

   230

static inline SignalState GetSignalStateByTrackdir(TileIndex tile, Trackdir trackdir)

   231

{

   232

	assert(IsValidTrackdir(trackdir));

   233

	assert(HasSignalOnTrack(tile, TrackdirToTrack(trackdir)));

   234

	return _m[tile].m2 & SignalAlongTrackdir(trackdir) ?

   235

		SIGNAL_STATE_GREEN : SIGNAL_STATE_RED;

   236

}

   237

   238

   239

/**

   240

 * Return the rail type of tile, or INVALID_RAILTYPE if this is no rail tile.

   241

 */

   242

RailType GetTileRailType(TileIndex tile);

   243

   244

   245

enum RailGroundType {

   246

	RAIL_GROUND_BARREN       =  0,

   247

	RAIL_GROUND_GRASS        =  1,

   248

	RAIL_GROUND_FENCE_NW     =  2,

   249

	RAIL_GROUND_FENCE_SE     =  3,

   250

	RAIL_GROUND_FENCE_SENW   =  4,

   251

	RAIL_GROUND_FENCE_NE     =  5,

   252

	RAIL_GROUND_FENCE_SW     =  6,

   253

	RAIL_GROUND_FENCE_NESW   =  7,

   254

	RAIL_GROUND_FENCE_VERT1  =  8,

   255

	RAIL_GROUND_FENCE_VERT2  =  9,

   256

	RAIL_GROUND_FENCE_HORIZ1 = 10,

   257

	RAIL_GROUND_FENCE_HORIZ2 = 11,

   258

	RAIL_GROUND_ICE_DESERT   = 12,

   259

};

   260

   261

static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)

   262

{

   263

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

   264

}

   265

   266

static inline RailGroundType GetRailGroundType(TileIndex t)

   267

{

   268

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

   269

}

   270

   271

static inline bool IsSnowRailGround(TileIndex t)

   272

{

   273

	return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;

   274

}

   275

   276

   277

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

   278

{

   279

	SetTileType(t, MP_RAILWAY);

   280

	SetTileOwner(t, o);

   281

	_m[t].m2 = 0;

   282

	_m[t].m3 = r;

   283

	_m[t].m4 = 0;

   284

	_m[t].m5 = RAIL_TILE_NORMAL << 6 | b;

   285

}

   286

   287

   288

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

   289

{

   290

	SetTileType(t, MP_RAILWAY);

   291

	SetTileOwner(t, o);

   292

	_m[t].m2 = 0;

   293

	_m[t].m3 = r;

   294

	_m[t].m4 = 0;

   295

	_m[t].m5 = RAIL_TILE_DEPOT << 6 | d;

   296

}

   297

   298

   299

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

   300

{

   301

	SetTileType(t, MP_RAILWAY);

   302

	SetTileOwner(t, o);

   303

	_m[t].m2 = index;

   304

	_m[t].m3 = r;

   305

	_m[t].m4 = 0;

   306

	_m[t].m5 = RAIL_TILE_WAYPOINT << 6 | a;

   307

}

   308

   309

#endif /* RAIL_MAP_H */