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));

    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 RailType GetRailTypeOnBridge(TileIndex t)

    91

{

    92

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

    93

}

    94

    95

static inline void SetRailType(TileIndex t, RailType r)

    96

{

    97

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

    98

}

    99

   100

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

   101

static inline void SetRailTypeCrossing(TileIndex t, RailType r)

   102

{

   103

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

   104

}

   105

   106

static inline void SetRailTypeOnBridge(TileIndex t, RailType r)

   107

{

   108

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

   109

}

   110

   111

   112

static inline TrackBits GetTrackBits(TileIndex tile)

   113

{

   114

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

   115

}

   116

   117

static inline void SetTrackBits(TileIndex t, TrackBits b)

   118

{

   119

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

   120

}

   121

   122

/**

   123

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

   124

 * a plain rail tile (IsPlainRailTile()).

   125

 */

   126

static inline bool HasTrack(TileIndex tile, Track track)

   127

{

   128

	return HASBIT(GetTrackBits(tile), track);

   129

}

   130

   131

   132

static inline DiagDirection GetRailDepotDirection(TileIndex t)

   133

{

   134

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

   135

}

   136

   137

   138

static inline Axis GetWaypointAxis(TileIndex t)

   139

{

   140

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

   141

}

   142

   143

static inline Track GetRailWaypointTrack(TileIndex t)

   144

{

   145

	return AxisToTrack(GetWaypointAxis(t));

   146

}

   147

   148

static inline TrackBits GetRailWaypointBits(TileIndex t)

   149

{

   150

	return TrackToTrackBits(GetRailWaypointTrack(t));

   151

}

   152

   153

   154

typedef enum SignalType {

   155

	SIGTYPE_NORMAL  = 0, // normal signal

   156

	SIGTYPE_ENTRY   = 1, // presignal block entry

   157

	SIGTYPE_EXIT    = 2, // presignal block exit

   158

	SIGTYPE_COMBO   = 3  // presignal inter-block

   159

} SignalType;

   160

   161

static inline SignalType GetSignalType(TileIndex t)

   162

{

   163

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   164

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

   165

}

   166

   167

static inline void SetSignalType(TileIndex t, SignalType s)

   168

{

   169

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   170

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

   171

}

   172

   173

static inline bool IsPresignalEntry(TileIndex t)

   174

{

   175

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

   176

}

   177

   178

static inline bool IsPresignalExit(TileIndex t)

   179

{

   180

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

   181

}

   182

   183

static inline void CycleSignalSide(TileIndex t, Track track)

   184

{

   185

	byte sig;

   186

	byte pos = 6;

   187

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

   188

   189

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

   190

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

   191

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

   192

}

   193

   194

   195

typedef enum SignalVariant {

   196

	SIG_ELECTRIC  = 0,

   197

	SIG_SEMAPHORE = 1

   198

} SignalVariant;

   199

   200

static inline SignalVariant GetSignalVariant(TileIndex t)

   201

{

   202

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

   203

}

   204

   205

static inline void SetSignalVariant(TileIndex t, SignalVariant v)

   206

{

   207

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

   208

}

   209

   210

static inline bool IsSignalPresent(TileIndex t, byte signalbit)

   211

{

   212

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

   213

}

   214

   215

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

   216

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

   217

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

   218

 */

   219

typedef enum SignalStates {

   220

	SIGNAL_STATE_RED   = 0,

   221

	SIGNAL_STATE_GREEN = 1,

   222

} SignalState;

   223

   224

static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)

   225

{

   226

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

   227

}

   228

   229

   230

/**

   231

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

   232

 * given rail tile.

   233

 */

   234

static inline bool HasSignalOnTrack(TileIndex tile, Track track)

   235

{

   236

	assert(IsValidTrack(track));

   237

	return

   238

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   239

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

   240

}

   241

   242

/**

   243

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

   244

 * rail tile.

   245

 *

   246

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

   247

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

   248

 */

   249

static inline bool HasSignalOnTrackdir(TileIndex tile, Trackdir trackdir)

   250

{

   251

	assert (IsValidTrackdir(trackdir));

   252

	return

   253

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   254

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

   255

}

   256

   257

/**

   258

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

   259

 *

   260

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

   261

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

   262

 */

   263

static inline SignalState GetSignalStateByTrackdir(TileIndex tile, Trackdir trackdir)

   264

{

   265

	assert(IsValidTrackdir(trackdir));

   266

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

   267

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

   268

		SIGNAL_STATE_GREEN : SIGNAL_STATE_RED;

   269

}

   270

   271

   272

/**

   273

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

   274

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

   275

 * the tile!

   276

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

   277

 * one tile.

   278

 */

   279

RailType GetTileRailType(TileIndex tile, Trackdir trackdir);

   280

   281

   282

typedef enum RailGroundType {

   283

	RAIL_GROUND_BARREN       =  0,

   284

	RAIL_GROUND_GRASS        =  1,

   285

	RAIL_GROUND_FENCE_NW     =  2,

   286

	RAIL_GROUND_FENCE_SE     =  3,

   287

	RAIL_GROUND_FENCE_SENW   =  4,

   288

	RAIL_GROUND_FENCE_NE     =  5,

   289

	RAIL_GROUND_FENCE_SW     =  6,

   290

	RAIL_GROUND_FENCE_NESW   =  7,

   291

	RAIL_GROUND_FENCE_VERT1  =  8,

   292

	RAIL_GROUND_FENCE_VERT2  =  9,

   293

	RAIL_GROUND_FENCE_HORIZ1 = 10,

   294

	RAIL_GROUND_FENCE_HORIZ2 = 11,

   295

	RAIL_GROUND_ICE_DESERT   = 12,

   296

} RailGroundType;

   297

   298

static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)

   299

{

   300

	if (GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT) {

   301

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

   302

		return;

   303

	}

   304

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

   305

}

   306

   307

static inline RailGroundType GetRailGroundType(TileIndex t)

   308

{

   309

	/* TODO Unify this */

   310

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

   311

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

   312

}

   313

   314

static inline bool IsSnowRailGround(TileIndex t)

   315

{

   316

	return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;

   317

}

   318

   319

   320

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

   321

{

   322

	SetTileType(t, MP_RAILWAY);

   323

	SetTileOwner(t, o);

   324

	_m[t].m2 = 0;

   325

	_m[t].m3 = r;

   326

	_m[t].m4 = 0;

   327

	_m[t].m5 = RAIL_TILE_NORMAL | b;

   328

}

   329

   330

   331

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

   332

{

   333

	SetTileType(t, MP_RAILWAY);

   334

	SetTileOwner(t, o);

   335

	_m[t].m2 = 0;

   336

	_m[t].m3 = r;

   337

	_m[t].m4 = 0;

   338

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

   339

}

   340

   341

   342

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

   343

{

   344

	SetTileType(t, MP_RAILWAY);

   345

	SetTileOwner(t, o);

   346

	_m[t].m2 = index;

   347

	_m[t].m3 = r;

   348

	_m[t].m4 = 0;

   349

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

   350

}

   351

   352

#endif /* RAIL_MAP_H */