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

    64

{

    65

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

    66

}

    67

    68

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

    69

static inline RailType GetRailTypeCrossing(TileIndex t)

    70

{

    71

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

    72

}

    73

    74

static inline RailType GetRailTypeOnBridge(TileIndex t)

    75

{

    76

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

    77

}

    78

    79

static inline void SetRailType(TileIndex t, RailType r)

    80

{

    81

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

    82

}

    83

    84

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

    85

static inline void SetRailTypeCrossing(TileIndex t, RailType r)

    86

{

    87

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

    88

}

    89

    90

static inline void SetRailTypeOnBridge(TileIndex t, RailType r)

    91

{

    92

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

    93

}

    94

    95

    96

static inline TrackBits GetTrackBits(TileIndex tile)

    97

{

    98

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

    99

}

   100

   101

static inline void SetTrackBits(TileIndex t, TrackBits b)

   102

{

   103

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

   104

}

   105

   106

/**

   107

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

   108

 * a plain rail tile (IsPlainRailTile()).

   109

 */

   110

static inline bool HasTrack(TileIndex tile, Track track)

   111

{

   112

	return HASBIT(GetTrackBits(tile), track);

   113

}

   114

   115

   116

static inline DiagDirection GetRailDepotDirection(TileIndex t)

   117

{

   118

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

   119

}

   120

   121

static inline Track GetRailWaypointTrack(TileIndex t)

   122

{

   123

	return HASBIT(_m[t].m5, 0) ? TRACK_Y : TRACK_X;

   124

}

   125

   126

static inline TrackBits GetRailWaypointBits(TileIndex t)

   127

{

   128

	return _m[t].m5 & 1 ? TRACK_BIT_Y : TRACK_BIT_X;

   129

}

   130

   131

static inline void SetCustomWaypointSprite(TileIndex t)

   132

{

   133

	SETBIT(_m[t].m3, 4);

   134

}

   135

   136

static inline void ClearCustomWaypointSprite(TileIndex t)

   137

{

   138

	CLRBIT(_m[t].m3, 4);

   139

}

   140

   141

static inline bool IsCustomWaypoint(TileIndex t)

   142

{

   143

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

   144

}

   145

   146

static inline Axis GetWaypointAxis(TileIndex t)

   147

{

   148

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

   149

}

   150

   151

   152

typedef enum SignalType {

   153

	SIGTYPE_NORMAL  = 0, // normal signal

   154

	SIGTYPE_ENTRY   = 1, // presignal block entry

   155

	SIGTYPE_EXIT    = 2, // presignal block exit

   156

	SIGTYPE_COMBO   = 3  // presignal inter-block

   157

} SignalType;

   158

   159

static inline SignalType GetSignalType(TileIndex t)

   160

{

   161

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   162

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

   163

}

   164

   165

static inline void SetSignalType(TileIndex t, SignalType s)

   166

{

   167

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   168

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

   169

}

   170

   171

static inline bool IsPresignalEntry(TileIndex t)

   172

{

   173

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

   174

}

   175

   176

static inline bool IsPresignalExit(TileIndex t)

   177

{

   178

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

   179

}

   180

   181

static inline void CycleSignalSide(TileIndex t, Track track)

   182

{

   183

	byte sig;

   184

	byte pos = 6;

   185

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

   186

   187

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

   188

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

   189

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

   190

}

   191

   192

   193

typedef enum SignalVariant {

   194

	SIG_ELECTRIC  = 0,

   195

	SIG_SEMAPHORE = 1

   196

} SignalVariant;

   197

   198

static inline SignalVariant GetSignalVariant(TileIndex t)

   199

{

   200

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

   201

}

   202

   203

static inline void SetSignalVariant(TileIndex t, SignalVariant v)

   204

{

   205

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

   206

}

   207

   208

static inline bool IsSignalPresent(TileIndex t, byte signalbit)

   209

{

   210

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

   211

}

   212

   213

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

   214

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

   215

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

   216

 */

   217

typedef enum SignalStates {

   218

	SIGNAL_STATE_RED = 0,

   219

	SIGNAL_STATE_GREEN = 1,

   220

} SignalState;

   221

   222

static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)

   223

{

   224

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

   225

}

   226

   227

   228

/**

   229

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

   230

 * given rail tile.

   231

 */

   232

static inline bool HasSignalOnTrack(TileIndex tile, Track track)

   233

{

   234

	assert(IsValidTrack(track));

   235

	return

   236

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   237

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

   238

}

   239

   240

/**

   241

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

   242

 * rail tile.

   243

 *

   244

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

   245

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

   246

 */

   247

static inline bool HasSignalOnTrackdir(TileIndex tile, Trackdir trackdir)

   248

{

   249

	assert (IsValidTrackdir(trackdir));

   250

	return

   251

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   252

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

   253

}

   254

   255

/**

   256

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

   257

 *

   258

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

   259

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

   260

 */

   261

static inline SignalState GetSignalStateByTrackdir(TileIndex tile, Trackdir trackdir)

   262

{

   263

	assert(IsValidTrackdir(trackdir));

   264

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

   265

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

   266

		SIGNAL_STATE_GREEN : SIGNAL_STATE_RED;

   267

}

   268

   269

   270

/**

   271

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

   272

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

   273

 * the tile!

   274

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

   275

 * one tile.

   276

 */

   277

RailType GetTileRailType(TileIndex tile, Trackdir trackdir);

   278

   279

   280

typedef enum RailGroundType {

   281

	RAIL_MAP2LO_GROUND_MASK = 0xF,

   282

	RAIL_GROUND_BARREN = 0,

   283

	RAIL_GROUND_GRASS = 1,

   284

	RAIL_GROUND_FENCE_NW = 2,

   285

	RAIL_GROUND_FENCE_SE = 3,

   286

	RAIL_GROUND_FENCE_SENW = 4,

   287

	RAIL_GROUND_FENCE_NE = 5,

   288

	RAIL_GROUND_FENCE_SW = 6,

   289

	RAIL_GROUND_FENCE_NESW = 7,

   290

	RAIL_GROUND_FENCE_VERT1 = 8,

   291

	RAIL_GROUND_FENCE_VERT2 = 9,

   292

	RAIL_GROUND_FENCE_HORIZ1 = 10,

   293

	RAIL_GROUND_FENCE_HORIZ2 = 11,

   294

	RAIL_GROUND_ICE_DESERT = 12,

   295

} RailGroundType;

   296

   297

static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)

   298

{

   299

	if (GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT) {

   300

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

   301

		return;

   302

	}

   303

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

   304

}

   305

   306

static inline RailGroundType GetRailGroundType(TileIndex t)

   307

{

   308

	/* TODO Unify this */

   309

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

   310

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

   311

}

   312

   313

static inline bool IsBarrenRailGround(TileIndex t)

   314

{

   315

	return GetRailGroundType(t) == RAIL_GROUND_BARREN;

   316

}

   317

   318

static inline bool IsSnowRailGround(TileIndex t)

   319

{

   320

	return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;

   321

}

   322

   323

   324

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

   325

{

   326

	SetTileType(t, MP_RAILWAY);

   327

	SetTileOwner(t, o);

   328

	_m[t].m2 = 0;

   329

	_m[t].m3 = r;

   330

	_m[t].m4 = 0;

   331

	_m[t].m5 = RAIL_TILE_NORMAL | b;

   332

}

   333

   334

   335

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

   336

{

   337

	SetTileType(t, MP_RAILWAY);

   338

	SetTileOwner(t, o);

   339

	_m[t].m2 = 0;

   340

	_m[t].m3 = r;

   341

	_m[t].m4 = 0;

   342

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

   343

}

   344

   345

   346

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

   347

{

   348

	SetTileType(t, MP_RAILWAY);

   349

	SetTileOwner(t, o);

   350

	_m[t].m2 = index;

   351

	_m[t].m3 = r;

   352

	_m[t].m4 = 0;

   353

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

   354

}

   355

   356

#endif