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 "rail_type.h"

     9

#include "signal_func.h"

    10

#include "direction_func.h"

    11

#include "track_func.h"

    12

#include "tile_map.h"

    13

    14

    15

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

    16

enum RailTileType {

    17

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

    18

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

    19

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

    20

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

    21

};

    22

    23

/**

    24

 * Returns the RailTileType (normal with or without signals,

    25

 * waypoint or depot).

    26

 * @param t the tile to get the information from

    27

 * @pre IsTileType(t, MP_RAILWAY)

    28

 * @return the RailTileType

    29

 */

    30

static inline RailTileType GetRailTileType(TileIndex t)

    31

{

    32

	assert(IsTileType(t, MP_RAILWAY));

    33

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

    34

}

    35

    36

/**

    37

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

    38

 * tiles RailTileType is RAIL_TILE_NORMAL or RAIL_TILE_SIGNALS.

    39

 * @param t the tile to get the information from

    40

 * @pre IsTileType(t, MP_RAILWAY)

    41

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

    42

 */

    43

static inline bool IsPlainRailTile(TileIndex t)

    44

{

    45

	RailTileType rtt = GetRailTileType(t);

    46

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

    47

}

    48

    49

/**

    50

 * Checks if a rail tile has signals.

    51

 * @param t the tile to get the information from

    52

 * @pre IsTileType(t, MP_RAILWAY)

    53

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

    54

 */

    55

static inline bool HasSignals(TileIndex t)

    56

{

    57

	return GetRailTileType(t) == RAIL_TILE_SIGNALS;

    58

}

    59

    60

/**

    61

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

    62

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

    63

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

    64

 * @pre IsPlainRailTile(tile)

    65

 */

    66

static inline void SetHasSignals(TileIndex tile, bool signals)

    67

{

    68

	assert(IsPlainRailTile(tile));

    69

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

    70

}

    71

    72

/**

    73

 * Is this tile a rail depot?

    74

 * @param t the tile to get the information from

    75

 * @pre IsTileType(t, MP_RAILWAY)

    76

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

    77

 */

    78

static inline bool IsRailDepot(TileIndex t)

    79

{

    80

	return GetRailTileType(t) == RAIL_TILE_DEPOT;

    81

}

    82

    83

/**

    84

 * Is this tile a rail waypoint?

    85

 * @param t the tile to get the information from

    86

 * @pre IsTileType(t, MP_RAILWAY)

    87

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

    88

 */

    89

static inline bool IsRailWaypoint(TileIndex t)

    90

{

    91

	return GetRailTileType(t) == RAIL_TILE_WAYPOINT;

    92

}

    93

    94

    95

/**

    96

 * Gets the rail type of the given tile

    97

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

    98

 * @return the rail type of the tile

    99

 */

   100

static inline RailType GetRailType(TileIndex t)

   101

{

   102

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

   103

}

   104

   105

/**

   106

 * Sets the rail type of the given tile

   107

 * @param t the tile to set the rail type of

   108

 * @param r the new rail type for the tile

   109

 */

   110

static inline void SetRailType(TileIndex t, RailType r)

   111

{

   112

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

   113

}

   114

   115

   116

/**

   117

 * Gets the track bits of the given tile

   118

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

   119

 * @return the track bits of the tile

   120

 */

   121

static inline TrackBits GetTrackBits(TileIndex tile)

   122

{

   123

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

   124

}

   125

   126

/**

   127

 * Sets the track bits of the given tile

   128

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

   129

 * @param b the new track bits for the tile

   130

 */

   131

static inline void SetTrackBits(TileIndex t, TrackBits b)

   132

{

   133

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

   134

}

   135

   136

/**

   137

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

   138

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

   139

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

   140

 * @pre IsPlainRailTile(tile)

   141

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

   142

 */

   143

static inline bool HasTrack(TileIndex tile, Track track)

   144

{

   145

	return HasBit(GetTrackBits(tile), track);

   146

}

   147

   148

/**

   149

 * Returns the direction the depot is facing to

   150

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

   151

 * @pre IsRailDepotTile(t)

   152

 * @return the direction the depot is facing

   153

 */

   154

static inline DiagDirection GetRailDepotDirection(TileIndex t)

   155

{

   156

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

   157

}

   158

   159

   160

/**

   161

 * Returns the axis of the waypoint

   162

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

   163

 * @pre IsRailWaypointTile(t)

   164

 * @return the axis of the waypoint

   165

 */

   166

static inline Axis GetWaypointAxis(TileIndex t)

   167

{

   168

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

   169

}

   170

   171

/**

   172

 * Returns the track of the waypoint

   173

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

   174

 * @pre IsRailWaypointTile(t)

   175

 * @return the track of the waypoint

   176

 */

   177

static inline Track GetRailWaypointTrack(TileIndex t)

   178

{

   179

	return AxisToTrack(GetWaypointAxis(t));

   180

}

   181

   182

/**

   183

 * Returns the track bits of the waypoint

   184

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

   185

 * @pre IsRailWaypointTile(t)

   186

 * @return the track bits of the waypoint

   187

 */

   188

static inline TrackBits GetRailWaypointBits(TileIndex t)

   189

{

   190

	return TrackToTrackBits(GetRailWaypointTrack(t));

   191

}

   192

   193

/**

   194

 * Returns waypoint index (for the waypoint pool)

   195

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

   196

 * @pre IsRailWaypointTile(t)

   197

 * @return the waypoint index

   198

 */

   199

static inline WaypointID GetWaypointIndex(TileIndex t)

   200

{

   201

	return (WaypointID)_m[t].m2;

   202

}

   203

   204

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

   205

enum SignalType {

   206

	SIGTYPE_NORMAL  = 0, ///< normal signal

   207

	SIGTYPE_ENTRY   = 1, ///< presignal block entry

   208

	SIGTYPE_EXIT    = 2, ///< presignal block exit

   209

	SIGTYPE_COMBO   = 3  ///< presignal inter-block

   210

};

   211

   212

static inline SignalType GetSignalType(TileIndex t, Track track)

   213

{

   214

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   215

	byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 0;

   216

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

   217

}

   218

   219

static inline void SetSignalType(TileIndex t, Track track, SignalType s)

   220

{

   221

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   222

	byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 0;

   223

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

   224

	if (track == INVALID_TRACK) SB(_m[t].m2, 4, 2, s);

   225

}

   226

   227

static inline bool IsPresignalEntry(TileIndex t, Track track)

   228

{

   229

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

   230

}

   231

   232

static inline bool IsPresignalExit(TileIndex t, Track track)

   233

{

   234

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

   235

}

   236

   237

static inline void CycleSignalSide(TileIndex t, Track track)

   238

{

   239

	byte sig;

   240

	byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 6;

   241

   242

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

   243

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

   244

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

   245

}

   246

   247

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

   248

enum SignalVariant {

   249

	SIG_ELECTRIC  = 0, ///< Light signal

   250

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

   251

};

   252

   253

static inline SignalVariant GetSignalVariant(TileIndex t, Track track)

   254

{

   255

	byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 6 : 2;

   256

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

   257

}

   258

   259

static inline void SetSignalVariant(TileIndex t, Track track, SignalVariant v)

   260

{

   261

	byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 6 : 2;

   262

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

   263

	if (track == INVALID_TRACK) SB(_m[t].m2, 6, 1, v);

   264

}

   265

   266

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

   267

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

   268

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

   269

 */

   270

enum SignalState {

   271

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

   272

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

   273

};

   274

   275

/**

   276

 * Set the states of the signals (Along/AgainstTrackDir)

   277

 * @param tile  the tile to set the states for

   278

 * @param state the new state

   279

 */

   280

static inline void SetSignalStates(TileIndex tile, uint state)

   281

{

   282

	SB(_m[tile].m4, 4, 4, state);

   283

}

   284

   285

/**

   286

 * Set the states of the signals (Along/AgainstTrackDir)

   287

 * @param tile  the tile to set the states for

   288

 * @param state the new state

   289

 */

   290

static inline uint GetSignalStates(TileIndex tile)

   291

{

   292

	return GB(_m[tile].m4, 4, 4);

   293

}

   294

   295

/**

   296

 * Get the state of a single signal

   297

 * @param t         the tile to get the signal state for

   298

 * @param signalbit the signal

   299

 * @return the state of the signal

   300

 */

   301

static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)

   302

{

   303

	return (SignalState)HasBit(GetSignalStates(t), signalbit);

   304

}

   305

   306

/**

   307

 * Set whether the given signals are present (Along/AgainstTrackDir)

   308

 * @param tile    the tile to set the present signals for

   309

 * @param signals the signals that have to be present

   310

 */

   311

static inline void SetPresentSignals(TileIndex tile, uint signals)

   312

{

   313

	SB(_m[tile].m3, 4, 4, signals);

   314

}

   315

   316

/**

   317

 * Get whether the given signals are present (Along/AgainstTrackDir)

   318

 * @param tile the tile to get the present signals for

   319

 * @return the signals that are present

   320

 */

   321

static inline uint GetPresentSignals(TileIndex tile)

   322

{

   323

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

   324

}

   325

   326

/**

   327

 * Checks whether the given signals is present

   328

 * @param t         the tile to check on

   329

 * @param signalbit the signal

   330

 * @return true if and only if the signal is present

   331

 */

   332

static inline bool IsSignalPresent(TileIndex t, byte signalbit)

   333

{

   334

	return HasBit(GetPresentSignals(t), signalbit);

   335

}

   336

   337

/**

   338

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

   339

 * given rail tile.

   340

 */

   341

static inline bool HasSignalOnTrack(TileIndex tile, Track track)

   342

{

   343

	assert(IsValidTrack(track));

   344

	return

   345

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   346

		(GetPresentSignals(tile) & SignalOnTrack(track)) != 0;

   347

}

   348

   349

/**

   350

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

   351

 * rail tile.

   352

 *

   353

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

   354

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

   355

 */

   356

static inline bool HasSignalOnTrackdir(TileIndex tile, Trackdir trackdir)

   357

{

   358

	assert (IsValidTrackdir(trackdir));

   359

	return

   360

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   361

		GetPresentSignals(tile) & SignalAlongTrackdir(trackdir);

   362

}

   363

   364

/**

   365

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

   366

 *

   367

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

   368

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

   369

 */

   370

static inline SignalState GetSignalStateByTrackdir(TileIndex tile, Trackdir trackdir)

   371

{

   372

	assert(IsValidTrackdir(trackdir));

   373

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

   374

	return GetSignalStates(tile) & SignalAlongTrackdir(trackdir) ?

   375

		SIGNAL_STATE_GREEN : SIGNAL_STATE_RED;

   376

}

   377

   378

/**

   379

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

   380

 */

   381

static inline void SetSignalStateByTrackdir(TileIndex tile, Trackdir trackdir, SignalState state)

   382

{

   383

	if (state == SIGNAL_STATE_GREEN) { // set 1

   384

		SetSignalStates(tile, GetSignalStates(tile) | SignalAlongTrackdir(trackdir));

   385

	} else {

   386

		SetSignalStates(tile, GetSignalStates(tile) & ~SignalAlongTrackdir(trackdir));

   387

	}

   388

}

   389

   390

   391

/**

   392

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

   393

 */

   394

RailType GetTileRailType(TileIndex tile);

   395

   396

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

   397

enum RailGroundType {

   398

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

   399

	RAIL_GROUND_GRASS        =  1, ///< Grassy

   400

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

   401

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

   402

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

   403

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

   404

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

   405

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

   406

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

   407

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

   408

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

   409

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

   410

	RAIL_GROUND_ICE_DESERT   = 12, ///< Icy or sandy

   411

	RAIL_GROUND_WATER        = 13, ///< Grass with a fence and shore or water on the free halftile

   412

	RAIL_GROUND_HALF_SNOW    = 14, ///< Snow only on higher part of slope (steep or one corner raised)

   413

};

   414

   415

static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)

   416

{

   417

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

   418

}

   419

   420

static inline RailGroundType GetRailGroundType(TileIndex t)

   421

{

   422

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

   423

}

   424

   425

static inline bool IsSnowRailGround(TileIndex t)

   426

{

   427

	return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;

   428

}

   429

   430

   431

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

   432

{

   433

	SetTileType(t, MP_RAILWAY);

   434

	SetTileOwner(t, o);

   435

	_m[t].m2 = 0;

   436

	_m[t].m3 = r;

   437

	_m[t].m4 = 0;

   438

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

   439

}

   440

   441

   442

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

   443

{

   444

	SetTileType(t, MP_RAILWAY);

   445

	SetTileOwner(t, o);

   446

	_m[t].m2 = 0;

   447

	_m[t].m3 = r;

   448

	_m[t].m4 = 0;

   449

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

   450

}

   451

   452

   453

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

   454

{

   455

	SetTileType(t, MP_RAILWAY);

   456

	SetTileOwner(t, o);

   457

	_m[t].m2 = index;

   458

	_m[t].m3 = r;

   459

	_m[t].m4 = 0;

   460

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

   461

}

   462

   463

#endif /* RAIL_MAP_H */