1

/* $Id$ */

     2

     3

/** @file rail_map.h Hides the direct accesses to the map array with map accessors */

     4

     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

/** Different types of Rail-related tiles */

    14

enum RailTileType {

    15

	RAIL_TILE_NORMAL   = 0, ///< Normal rail tile without signals

    16

	RAIL_TILE_SIGNALS  = 1, ///< Normal rail tile with signals

    17

	RAIL_TILE_WAYPOINT = 2, ///< Waypoint (X or Y direction)

    18

	RAIL_TILE_DEPOT    = 3, ///< Depot (one entrance)

    19

};

    20

    21

/**

    22

 * Returns the RailTileType (normal with or without signals,

    23

 * waypoint or depot).

    24

 * @param t the tile to get the information from

    25

 * @pre IsTileType(t, MP_RAILWAY)

    26

 * @return the RailTileType

    27

 */

    28

static inline RailTileType GetRailTileType(TileIndex t)

    29

{

    30

	assert(IsTileType(t, MP_RAILWAY));

    31

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

    32

}

    33

    34

/**

    35

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

    36

 * tiles RailTileType is RAIL_TILE_NORMAL or RAIL_TILE_SIGNALS.

    37

 * @param t the tile to get the information from

    38

 * @pre IsTileType(t, MP_RAILWAY)

    39

 * @return true if and only if the tile is normal rail (with or without signals)

    40

 */

    41

static inline bool IsPlainRailTile(TileIndex t)

    42

{

    43

	RailTileType rtt = GetRailTileType(t);

    44

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

    45

}

    46

    47

/**

    48

 * Checks if a rail tile has signals.

    49

 * @param t the tile to get the information from

    50

 * @pre IsTileType(t, MP_RAILWAY)

    51

 * @return true if and only if the tile has signals

    52

 */

    53

static inline bool HasSignals(TileIndex t)

    54

{

    55

	return GetRailTileType(t) == RAIL_TILE_SIGNALS;

    56

}

    57

    58

/**

    59

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

    60

 * @param tile the tile to add/remove the signals to/from

    61

 * @param signals whether the rail tile should have signals or not

    62

 * @pre IsPlainRailTile(tile)

    63

 */

    64

static inline void SetHasSignals(TileIndex tile, bool signals)

    65

{

    66

	assert(IsPlainRailTile(tile));

    67

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

    68

}

    69

    70

/**

    71

 * Is this tile a rail depot?

    72

 * @param t the tile to get the information from

    73

 * @pre IsTileType(t, MP_RAILWAY)

    74

 * @return true if and only if the tile is a rail depot

    75

 */

    76

static inline bool IsRailDepot(TileIndex t)

    77

{

    78

	return GetRailTileType(t) == RAIL_TILE_DEPOT;

    79

}

    80

    81

/**

    82

 * Is this tile a rail waypoint?

    83

 * @param t the tile to get the information from

    84

 * @pre IsTileType(t, MP_RAILWAY)

    85

 * @return true if and only if the tile is a rail waypoint

    86

 */

    87

static inline bool IsRailWaypoint(TileIndex t)

    88

{

    89

	return GetRailTileType(t) == RAIL_TILE_WAYPOINT;

    90

}

    91

    92

    93

/**

    94

 * Gets the rail type of the given tile

    95

 * @param t the tile to get the rail type from

    96

 * @return the rail type of the tile

    97

 */

    98

static inline RailType GetRailType(TileIndex t)

    99

{

   100

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

   101

}

   102

   103

/**

   104

 * Sets the track bits of the given tile

   105

 * @param t the tile to set the track bits of

   106

 * @param r the new track bits for the tile

   107

 */

   108

static inline void SetRailType(TileIndex t, RailType r)

   109

{

   110

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

   111

}

   112

   113

   114

/**

   115

 * Gets the rail type of the given tile

   116

 * @param t the tile to get the rail type from

   117

 * @return the rail type of the tile

   118

 */

   119

static inline TrackBits GetTrackBits(TileIndex tile)

   120

{

   121

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

   122

}

   123

   124

/**

   125

 * Sets the track bits of the given tile

   126

 * @param t the tile to set the track bits of

   127

 * @param b the new track bits for the tile

   128

 */

   129

static inline void SetTrackBits(TileIndex t, TrackBits b)

   130

{

   131

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

   132

}

   133

   134

/**

   135

 * Returns whether the given track is present on the given tile.

   136

 * @param tile  the tile to check the track presence of

   137

 * @param track the track to search for on the tile

   138

 * @pre IsPlainRailTile(tile)

   139

 * @return true if and only if the given track exists on the tile

   140

 */

   141

static inline bool HasTrack(TileIndex tile, Track track)

   142

{

   143

	return HASBIT(GetTrackBits(tile), track);

   144

}

   145

   146

/**

   147

 * Returns the direction the depot is facing to

   148

 * @param t the tile to get the depot facing from

   149

 * @pre IsRailDepotTile(t)

   150

 * @return the direction the depot is facing

   151

 */

   152

static inline DiagDirection GetRailDepotDirection(TileIndex t)

   153

{

   154

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

   155

}

   156

   157

   158

/**

   159

 * Returns the axis of the waypoint

   160

 * @param t the tile to get the waypoint axis from

   161

 * @pre IsRailWaypointTile(t)

   162

 * @return the axis of the waypoint

   163

 */

   164

static inline Axis GetWaypointAxis(TileIndex t)

   165

{

   166

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

   167

}

   168

   169

/**

   170

 * Returns the track of the waypoint

   171

 * @param t the tile to get the waypoint track from

   172

 * @pre IsRailWaypointTile(t)

   173

 * @return the track of the waypoint

   174

 */

   175

static inline Track GetRailWaypointTrack(TileIndex t)

   176

{

   177

	return AxisToTrack(GetWaypointAxis(t));

   178

}

   179

   180

/**

   181

 * Returns the track bits of the waypoint

   182

 * @param t the tile to get the waypoint track bits from

   183

 * @pre IsRailWaypointTile(t)

   184

 * @return the track bits of the waypoint

   185

 */

   186

static inline TrackBits GetRailWaypointBits(TileIndex t)

   187

{

   188

	return TrackToTrackBits(GetRailWaypointTrack(t));

   189

}

   190

   191

/**

   192

 * Returns waypoint index (for the waypoint pool)

   193

 * @param t the tile to get the waypoint index from

   194

 * @pre IsRailWaypointTile(t)

   195

 * @return the waypoint index

   196

 */

   197

static inline WaypointID GetWaypointIndex(TileIndex t)

   198

{

   199

	return (WaypointID)_m[t].m2;

   200

}

   201

   202

/** Type of signal, i.e. how does the signal behave? */

   203

enum SignalType {

   204

	SIGTYPE_NORMAL  = 0, ///< normal signal

   205

	SIGTYPE_ENTRY   = 1, ///< presignal block entry

   206

	SIGTYPE_EXIT    = 2, ///< presignal block exit

   207

	SIGTYPE_COMBO   = 3  ///< presignal inter-block

   208

};

   209

   210

static inline SignalType GetSignalType(TileIndex t)

   211

{

   212

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   213

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

   214

}

   215

   216

static inline void SetSignalType(TileIndex t, SignalType s)

   217

{

   218

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   219

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

   220

}

   221

   222

static inline bool IsPresignalEntry(TileIndex t)

   223

{

   224

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

   225

}

   226

   227

static inline bool IsPresignalExit(TileIndex t)

   228

{

   229

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

   230

}

   231

   232

static inline void CycleSignalSide(TileIndex t, Track track)

   233

{

   234

	byte sig;

   235

	byte pos = 6;

   236

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

   237

   238

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

   239

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

   240

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

   241

}

   242

   243

/** Variant of the signal, i.e. how does the signal look? */

   244

enum SignalVariant {

   245

	SIG_ELECTRIC  = 0, ///< Light signal

   246

	SIG_SEMAPHORE = 1  ///< Old-fashioned semaphore signal

   247

};

   248

   249

static inline SignalVariant GetSignalVariant(TileIndex t)

   250

{

   251

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

   252

}

   253

   254

static inline void SetSignalVariant(TileIndex t, SignalVariant v)

   255

{

   256

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

   257

}

   258

   259

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

   260

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

   261

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

   262

 */

   263

enum SignalState {

   264

	SIGNAL_STATE_RED   = 0, ///< The signal is red

   265

	SIGNAL_STATE_GREEN = 1, ///< The signal is green

   266

};

   267

   294

static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)

   295

{

   297

}

   298

   329

   330

/**

   331

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

   332

 * given rail tile.

   333

 */

   334

static inline bool HasSignalOnTrack(TileIndex tile, Track track)

   335

{

   336

	assert(IsValidTrack(track));

   337

	return

   338

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   340

}

   341

   342

/**

   343

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

   344

 * rail tile.

   345

 *

   346

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

   347

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

   348

 */

   349

static inline bool HasSignalOnTrackdir(TileIndex tile, Trackdir trackdir)

   350

{

   351

	assert (IsValidTrackdir(trackdir));

   352

	return

   353

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   355

}

   356

   357

/**

   358

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

   359

 *

   360

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

   361

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

   362

 */

   363

static inline SignalState GetSignalStateByTrackdir(TileIndex tile, Trackdir trackdir)

   364

{

   365

	assert(IsValidTrackdir(trackdir));

   366

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

   368

		SIGNAL_STATE_GREEN : SIGNAL_STATE_RED;

   369

}

   370

   371

   372

/**

   373

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

   374

 */

   375

RailType GetTileRailType(TileIndex tile);

   376

   377

/** The ground 'under' the rail */

   378

enum RailGroundType {

   379

	RAIL_GROUND_BARREN       =  0, ///< Nothing (dirt)

   380

	RAIL_GROUND_GRASS        =  1, ///< Grassy

   381

	RAIL_GROUND_FENCE_NW     =  2, ///< Grass with a fence at the NW edge

   382

	RAIL_GROUND_FENCE_SE     =  3, ///< Grass with a fence at the SE edge

   383

	RAIL_GROUND_FENCE_SENW   =  4, ///< Grass with a fence at the NW and SE edges

   384

	RAIL_GROUND_FENCE_NE     =  5, ///< Grass with a fence at the NE edge

   385

	RAIL_GROUND_FENCE_SW     =  6, ///< Grass with a fence at the SW edge

   386

	RAIL_GROUND_FENCE_NESW   =  7, ///< Grass with a fence at the NE and SW edges

   387

	RAIL_GROUND_FENCE_VERT1  =  8, ///< Grass with a fence at the western side

   388

	RAIL_GROUND_FENCE_VERT2  =  9, ///< Grass with a fence at the eastern side

   389

	RAIL_GROUND_FENCE_HORIZ1 = 10, ///< Grass with a fence at the southern side

   390

	RAIL_GROUND_FENCE_HORIZ2 = 11, ///< Grass with a fence at the northern side

   391

	RAIL_GROUND_ICE_DESERT   = 12, ///< Icy or sandy

   392

};

   393

   394

static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)

   395

{

   396

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

   397

}

   398

   399

static inline RailGroundType GetRailGroundType(TileIndex t)

   400

{

   401

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

   402

}

   403

   404

static inline bool IsSnowRailGround(TileIndex t)

   405

{

   406

	return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;

   407

}

   408

   409

   410

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

   411

{

   412

	SetTileType(t, MP_RAILWAY);

   413

	SetTileOwner(t, o);

   414

	_m[t].m2 = 0;

   415

	_m[t].m3 = r;

   416

	_m[t].m4 = 0;

   417

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

   418

}

   419

   420

   421

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

   422

{

   423

	SetTileType(t, MP_RAILWAY);

   424

	SetTileOwner(t, o);

   425

	_m[t].m2 = 0;

   426

	_m[t].m3 = r;

   427

	_m[t].m4 = 0;

   428

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

   429

}

   430

   431

   432

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

   433

{

   434

	SetTileType(t, MP_RAILWAY);

   435

	SetTileOwner(t, o);

   436

	_m[t].m2 = index;

   437

	_m[t].m3 = r;

   438

	_m[t].m4 = 0;

   439

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

   440

}

   441

   442

#endif /* RAIL_MAP_H */