1

/* $Id$ */

     2

     5

#ifndef RAIL_MAP_H

     6

#define RAIL_MAP_H

     7

     8

#include "direction.h"

     9

#include "rail.h"

    10

#include "tile.h"

    11

    12

    13

enum RailTileType {

    14

	RAIL_TILE_NORMAL   = 0,

    15

	RAIL_TILE_SIGNALS  = 1,

    16

	RAIL_TILE_WAYPOINT = 2,

    17

	RAIL_TILE_DEPOT    = 3,

    18

};

    19

    20

static inline RailTileType GetRailTileType(TileIndex t)

    21

{

    22

	assert(IsTileType(t, MP_RAILWAY));

    23

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

    24

}

    25

    26

/**

    27

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

    28

 * tiles RailTileType is RAIL_TILE_NORMAL or RAIL_TILE_SIGNALS.

    29

 */

    30

static inline bool IsPlainRailTile(TileIndex tile)

    31

{

    32

	RailTileType rtt = GetRailTileType(tile);

    33

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

    34

}

    35

    36

/**

    37

 * Checks if a rail tile has signals.

    38

 */

    39

static inline bool HasSignals(TileIndex tile)

    40

{

    41

	return GetRailTileType(tile) == RAIL_TILE_SIGNALS;

    42

}

    43

    44

/**

    45

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

    46

 */

    47

static inline void SetHasSignals(TileIndex tile, bool signals)

    48

{

    49

	assert(IsPlainRailTile(tile));

    50

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

    51

}

    52

    53

    54

static inline bool IsRailDepot(TileIndex t)

    55

{

    56

	return GetRailTileType(t) == RAIL_TILE_DEPOT;

    57

}

    58

    59

    60

static inline bool IsRailWaypoint(TileIndex t)

    61

{

    62

	return GetRailTileType(t) == RAIL_TILE_WAYPOINT;

    63

}

    64

    65

    66

static inline RailType GetRailType(TileIndex t)

    67

{

    68

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

    69

}

    70

    71

static inline void SetRailType(TileIndex t, RailType r)

    72

{

    73

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

    74

}

    75

    76

    77

static inline TrackBits GetTrackBits(TileIndex tile)

    78

{

    79

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

    80

}

    81

    82

static inline void SetTrackBits(TileIndex t, TrackBits b)

    83

{

    84

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

    85

}

    86

    87

/**

    88

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

    89

 * a plain rail tile (IsPlainRailTile()).

    90

 */

    91

static inline bool HasTrack(TileIndex tile, Track track)

    92

{

    93

	return HASBIT(GetTrackBits(tile), track);

    94

}

    95

    96

    97

static inline DiagDirection GetRailDepotDirection(TileIndex t)

    98

{

    99

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

   100

}

   101

   102

   103

static inline Axis GetWaypointAxis(TileIndex t)

   104

{

   105

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

   106

}

   107

   108

static inline Track GetRailWaypointTrack(TileIndex t)

   109

{

   110

	return AxisToTrack(GetWaypointAxis(t));

   111

}

   112

   113

static inline TrackBits GetRailWaypointBits(TileIndex t)

   114

{

   115

	return TrackToTrackBits(GetRailWaypointTrack(t));

   116

}

   117

   118

static inline WaypointID GetWaypointIndex(TileIndex t)

   119

{

   120

	return (WaypointID)_m[t].m2;

   121

}

   122

   123

enum SignalType {

   124

	SIGTYPE_NORMAL  = 0, // normal signal

   125

	SIGTYPE_ENTRY   = 1, // presignal block entry

   126

	SIGTYPE_EXIT    = 2, // presignal block exit

   127

	SIGTYPE_COMBO   = 3  // presignal inter-block

   128

};

   129

   130

static inline SignalType GetSignalType(TileIndex t)

   131

{

   132

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   133

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

   134

}

   135

   136

static inline void SetSignalType(TileIndex t, SignalType s)

   137

{

   138

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   139

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

   140

}

   141

   142

static inline bool IsPresignalEntry(TileIndex t)

   143

{

   144

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

   145

}

   146

   147

static inline bool IsPresignalExit(TileIndex t)

   148

{

   149

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

   150

}

   151

   152

static inline void CycleSignalSide(TileIndex t, Track track)

   153

{

   154

	byte sig;

   155

	byte pos = 6;

   156

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

   157

   158

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

   159

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

   160

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

   161

}

   162

   163

   164

enum SignalVariant {

   165

	SIG_ELECTRIC  = 0,

   166

	SIG_SEMAPHORE = 1

   167

};

   168

   169

static inline SignalVariant GetSignalVariant(TileIndex t)

   170

{

   171

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

   172

}

   173

   174

static inline void SetSignalVariant(TileIndex t, SignalVariant v)

   175

{

   176

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

   177

}

   178

   179

static inline bool IsSignalPresent(TileIndex t, byte signalbit)

   180

{

   181

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

   182

}

   183

   184

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

   185

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

   186

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

   187

 */

   188

enum SignalState {

   189

	SIGNAL_STATE_RED   = 0,

   190

	SIGNAL_STATE_GREEN = 1,

   191

};

   192

   193

static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)

   194

{

   195

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

   196

}

   197

   198

   199

/**

   200

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

   201

 * given rail tile.

   202

 */

   203

static inline bool HasSignalOnTrack(TileIndex tile, Track track)

   204

{

   205

	assert(IsValidTrack(track));

   206

	return

   207

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   208

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

   209

}

   210

   211

/**

   212

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

   213

 * rail tile.

   214

 *

   215

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

   216

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

   217

 */

   218

static inline bool HasSignalOnTrackdir(TileIndex tile, Trackdir trackdir)

   219

{

   220

	assert (IsValidTrackdir(trackdir));

   221

	return

   222

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   223

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

   224

}

   225

   226

/**

   227

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

   228

 *

   229

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

   230

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

   231

 */

   232

static inline SignalState GetSignalStateByTrackdir(TileIndex tile, Trackdir trackdir)

   233

{

   234

	assert(IsValidTrackdir(trackdir));

   235

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

   236

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

   237

		SIGNAL_STATE_GREEN : SIGNAL_STATE_RED;

   238

}

   239

   240

   241

/**

   242

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

   243

 */

   244

RailType GetTileRailType(TileIndex tile);

   245

   246

   247

enum RailGroundType {

   248

	RAIL_GROUND_BARREN       =  0,

   249

	RAIL_GROUND_GRASS        =  1,

   250

	RAIL_GROUND_FENCE_NW     =  2,

   251

	RAIL_GROUND_FENCE_SE     =  3,

   252

	RAIL_GROUND_FENCE_SENW   =  4,

   253

	RAIL_GROUND_FENCE_NE     =  5,

   254

	RAIL_GROUND_FENCE_SW     =  6,

   255

	RAIL_GROUND_FENCE_NESW   =  7,

   256

	RAIL_GROUND_FENCE_VERT1  =  8,

   257

	RAIL_GROUND_FENCE_VERT2  =  9,

   258

	RAIL_GROUND_FENCE_HORIZ1 = 10,

   259

	RAIL_GROUND_FENCE_HORIZ2 = 11,

   260

	RAIL_GROUND_ICE_DESERT   = 12,

   261

};

   262

   263

static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)

   264

{

   265

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

   266

}

   267

   268

static inline RailGroundType GetRailGroundType(TileIndex t)

   269

{

   270

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

   271

}

   272

   273

static inline bool IsSnowRailGround(TileIndex t)

   274

{

   275

	return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;

   276

}

   277

   278

   279

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

   280

{

   281

	SetTileType(t, MP_RAILWAY);

   282

	SetTileOwner(t, o);

   283

	_m[t].m2 = 0;

   284

	_m[t].m3 = r;

   285

	_m[t].m4 = 0;

   286

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

   287

}

   288

   289

   290

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

   291

{

   292

	SetTileType(t, MP_RAILWAY);

   293

	SetTileOwner(t, o);

   294

	_m[t].m2 = 0;

   295

	_m[t].m3 = r;

   296

	_m[t].m4 = 0;

   297

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

   298

}

   299

   300

   301

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

   302

{

   303

	SetTileType(t, MP_RAILWAY);

   304

	SetTileOwner(t, o);

   305

	_m[t].m2 = index;

   306

	_m[t].m3 = r;

   307

	_m[t].m4 = 0;

   308

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

   309

}

   310

   311

#endif /* RAIL_MAP_H */