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

typedef enum RailTileType {

    12

	RAIL_TILE_NORMAL         = 0x0,

    13

	RAIL_TILE_SIGNALS        = 0x40,

    14

	RAIL_TILE_UNUSED         = 0x80, /* XXX: Maybe this could become waypoints? */

    15

	RAIL_TILE_DEPOT_WAYPOINT = 0xC0, /* Is really depots and waypoints... */

    16

	RAIL_TILE_TYPE_MASK      = 0xC0

    17

} RailTileType;

    18

    19

static inline RailTileType GetRailTileType(TileIndex t)

    20

{

    21

	assert(IsTileType(t, MP_RAILWAY) || IsTileType(t, MP_RAILWAY_BRIDGE));

    22

	return (RailTileType)(_m[t].m5 & RAIL_TILE_TYPE_MASK);

    23

}

    24

    25

/**

    26

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

    27

 * tiles RailTileType is RAIL_TILE_NORMAL or RAIL_TILE_SIGNALS.

    28

 */

    29

static inline bool IsPlainRailTile(TileIndex tile)

    30

{

    31

	RailTileType rtt = GetRailTileType(tile);

    32

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

    33

}

    34

    35

/**

    36

 * Checks if a rail tile has signals.

    37

 */

    38

static inline bool HasSignals(TileIndex tile)

    39

{

    40

	return GetRailTileType(tile) == RAIL_TILE_SIGNALS;

    41

}

    42

    43

    44

/** These specify the subtype when the main rail type is

    45

 * RAIL_TILE_DEPOT_WAYPOINT */

    46

typedef enum RailTileSubtypes {

    47

	RAIL_SUBTYPE_DEPOT    = 0x00,

    48

	RAIL_SUBTYPE_WAYPOINT = 0x04,

    49

	RAIL_SUBTYPE_MASK     = 0x3C

    50

} RailTileSubtype;

    51

    52

/**

    53

 * Returns the RailTileSubtype of a given rail tile with type

    54

 * RAIL_TILE_DEPOT_WAYPOINT

    55

 */

    56

static inline RailTileSubtype GetRailTileSubtype(TileIndex tile)

    57

{

    58

	assert(GetRailTileType(tile) == RAIL_TILE_DEPOT_WAYPOINT);

    59

	return (RailTileSubtype)(_m[tile].m5 & RAIL_SUBTYPE_MASK);

    60

}

    61

    62

    63

static inline bool IsRailDepot(TileIndex t)

    64

{

    65

	return

    66

		GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT &&

    67

		GetRailTileSubtype(t) == RAIL_SUBTYPE_DEPOT;

    68

}

    69

    70

    71

static inline bool IsRailWaypoint(TileIndex t)

    72

{

    73

	return

    74

		GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT &&

    75

		GetRailTileSubtype(t) == RAIL_SUBTYPE_WAYPOINT;

    76

}

    77

    78

    79

static inline RailType GetRailType(TileIndex t)

    80

{

    81

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

    82

}

    83

    84

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

    85

static inline RailType GetRailTypeCrossing(TileIndex t)

    86

{

    87

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

    88

}

    89

    90

static inline void SetRailType(TileIndex t, RailType r)

    91

{

    92

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

    93

}

    94

    95

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

    96

static inline void SetRailTypeCrossing(TileIndex t, RailType r)

    97

{

    98

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

    99

}

   100

   101

   102

static inline TrackBits GetTrackBits(TileIndex tile)

   103

{

   104

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

   105

}

   106

   107

static inline void SetTrackBits(TileIndex t, TrackBits b)

   108

{

   109

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

   110

}

   111

   112

/**

   113

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

   114

 * a plain rail tile (IsPlainRailTile()).

   115

 */

   116

static inline bool HasTrack(TileIndex tile, Track track)

   117

{

   118

	return HASBIT(GetTrackBits(tile), track);

   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 Axis GetWaypointAxis(TileIndex t)

   129

{

   130

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

   131

}

   132

   133

static inline Track GetRailWaypointTrack(TileIndex t)

   134

{

   135

	return AxisToTrack(GetWaypointAxis(t));

   136

}

   137

   138

static inline TrackBits GetRailWaypointBits(TileIndex t)

   139

{

   140

	return TrackToTrackBits(GetRailWaypointTrack(t));

   141

}

   142

   143

   144

typedef enum SignalType {

   145

	SIGTYPE_NORMAL  = 0, // normal signal

   146

	SIGTYPE_ENTRY   = 1, // presignal block entry

   147

	SIGTYPE_EXIT    = 2, // presignal block exit

   148

	SIGTYPE_COMBO   = 3  // presignal inter-block

   149

} SignalType;

   150

   151

static inline SignalType GetSignalType(TileIndex t)

   152

{

   153

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   154

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

   155

}

   156

   157

static inline void SetSignalType(TileIndex t, SignalType s)

   158

{

   159

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   160

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

   161

}

   162

   163

static inline bool IsPresignalEntry(TileIndex t)

   164

{

   165

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

   166

}

   167

   168

static inline bool IsPresignalExit(TileIndex t)

   169

{

   170

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

   171

}

   172

   173

static inline void CycleSignalSide(TileIndex t, Track track)

   174

{

   175

	byte sig;

   176

	byte pos = 6;

   177

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

   178

   179

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

   180

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

   181

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

   182

}

   183

   184

   185

typedef enum SignalVariant {

   186

	SIG_ELECTRIC  = 0,

   187

	SIG_SEMAPHORE = 1

   188

} SignalVariant;

   189

   190

static inline SignalVariant GetSignalVariant(TileIndex t)

   191

{

   192

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

   193

}

   194

   195

static inline void SetSignalVariant(TileIndex t, SignalVariant v)

   196

{

   197

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

   198

}

   199

   200

static inline bool IsSignalPresent(TileIndex t, byte signalbit)

   201

{

   202

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

   203

}

   204

   205

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

   206

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

   207

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

   208

 */

   209

typedef enum SignalStates {

   210

	SIGNAL_STATE_RED   = 0,

   211

	SIGNAL_STATE_GREEN = 1,

   212

} SignalState;

   213

   214

static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)

   215

{

   216

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

   217

}

   218

   219

   220

/**

   221

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

   222

 * given rail tile.

   223

 */

   224

static inline bool HasSignalOnTrack(TileIndex tile, Track track)

   225

{

   226

	assert(IsValidTrack(track));

   227

	return

   228

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   229

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

   230

}

   231

   232

/**

   233

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

   234

 * rail tile.

   235

 *

   236

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

   237

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

   238

 */

   239

static inline bool HasSignalOnTrackdir(TileIndex tile, Trackdir trackdir)

   240

{

   241

	assert (IsValidTrackdir(trackdir));

   242

	return

   243

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   244

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

   245

}

   246

   247

/**

   248

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

   249

 *

   250

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

   251

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

   252

 */

   253

static inline SignalState GetSignalStateByTrackdir(TileIndex tile, Trackdir trackdir)

   254

{

   255

	assert(IsValidTrackdir(trackdir));

   256

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

   257

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

   258

		SIGNAL_STATE_GREEN : SIGNAL_STATE_RED;

   259

}

   260

   261

   262

/**

   263

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

   264

 * Note that there is no check if the given trackdir is actually present on

   265

 * the tile!

   266

 * The given trackdir is used when there are (could be) multiple rail types on

   267

 * one tile.

   268

 */

   269

RailType GetTileRailType(TileIndex tile, Trackdir trackdir);

   270

   271

   272

typedef enum RailGroundType {

   273

	RAIL_GROUND_BARREN       =  0,

   274

	RAIL_GROUND_GRASS        =  1,

   275

	RAIL_GROUND_FENCE_NW     =  2,

   276

	RAIL_GROUND_FENCE_SE     =  3,

   277

	RAIL_GROUND_FENCE_SENW   =  4,

   278

	RAIL_GROUND_FENCE_NE     =  5,

   279

	RAIL_GROUND_FENCE_SW     =  6,

   280

	RAIL_GROUND_FENCE_NESW   =  7,

   281

	RAIL_GROUND_FENCE_VERT1  =  8,

   282

	RAIL_GROUND_FENCE_VERT2  =  9,

   283

	RAIL_GROUND_FENCE_HORIZ1 = 10,

   284

	RAIL_GROUND_FENCE_HORIZ2 = 11,

   285

	RAIL_GROUND_ICE_DESERT   = 12,

   286

} RailGroundType;

   287

   288

static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)

   289

{

   290

	if (GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT) {

   291

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

   292

		return;

   293

	}

   294

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

   295

}

   296

   297

static inline RailGroundType GetRailGroundType(TileIndex t)

   298

{

   299

	/* TODO Unify this */

   300

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

   301

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

   302

}

   303

   304

static inline bool IsSnowRailGround(TileIndex t)

   305

{

   306

	return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;

   307

}

   308

   309

   310

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

   311

{

   312

	SetTileType(t, MP_RAILWAY);

   313

	SetTileOwner(t, o);

   314

	_m[t].m2 = 0;

   315

	_m[t].m3 = r;

   316

	_m[t].m4 = 0;

   317

	_m[t].m5 = RAIL_TILE_NORMAL | b;

   318

}

   319

   320

   321

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

   322

{

   323

	SetTileType(t, MP_RAILWAY);

   324

	SetTileOwner(t, o);

   325

	_m[t].m2 = 0;

   326

	_m[t].m3 = r;

   327

	_m[t].m4 = 0;

   328

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

   329

}

   330

   331

   332

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

   333

{

   334

	SetTileType(t, MP_RAILWAY);

   335

	SetTileOwner(t, o);

   336

	_m[t].m2 = index;

   337

	_m[t].m3 = r;

   338

	_m[t].m4 = 0;

   339

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

   340

}

   341

   342

#endif /* RAIL_MAP_H */