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

#include "signal_type.h"

    14

#include "waypoint_type.h"

    15

    16

    17

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

    18

enum RailTileType {

    19

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

    20

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

    21

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

    22

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

    23

};

    24

    25

/**

    26

 * Returns the RailTileType (normal with or without signals,

    27

 * waypoint or depot).

    28

 * @param t the tile to get the information from

    29

 * @pre IsTileType(t, MP_RAILWAY)

    30

 * @return the RailTileType

    31

 */

    32

static inline RailTileType GetRailTileType(TileIndex t)

    33

{

    34

	assert(IsTileType(t, MP_RAILWAY));

    35

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

    36

}

    37

    38

/**

    39

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

    40

 * tiles RailTileType is RAIL_TILE_NORMAL or RAIL_TILE_SIGNALS.

    41

 * @param t the tile to get the information from

    42

 * @pre IsTileType(t, MP_RAILWAY)

    43

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

    44

 */

    45

static inline bool IsPlainRailTile(TileIndex t)

    46

{

    47

	RailTileType rtt = GetRailTileType(t);

    48

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

    49

}

    50

    51

/**

    52

 * Checks if a rail tile has signals.

    53

 * @param t the tile to get the information from

    54

 * @pre IsTileType(t, MP_RAILWAY)

    55

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

    56

 */

    57

static inline bool HasSignals(TileIndex t)

    58

{

    59

	return GetRailTileType(t) == RAIL_TILE_SIGNALS;

    60

}

    61

    62

/**

    63

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

    64

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

    65

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

    66

 * @pre IsPlainRailTile(tile)

    67

 */

    68

static inline void SetHasSignals(TileIndex tile, bool signals)

    69

{

    70

	assert(IsPlainRailTile(tile));

    71

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

    72

}

    73

    74

/**

    75

 * Is this rail tile a rail waypoint?

    76

 * @param t the tile to get the information from

    77

 * @pre IsTileType(t, MP_RAILWAY)

    78

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

    79

 */

    80

static inline bool IsRailWaypoint(TileIndex t)

    81

{

    82

	return GetRailTileType(t) == RAIL_TILE_WAYPOINT;

    83

}

    84

    85

/**

    86

 * Is this rail tile a rail depot?

    87

 * @param t the tile to get the information from

    88

 * @pre IsTileType(t, MP_RAILWAY)

    89

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

    90

 */

    91

static inline bool IsRailDepot(TileIndex t)

    92

{

    93

	return GetRailTileType(t) == RAIL_TILE_DEPOT;

    94

}

    95

    96

/**

    97

 * Is this tile rail tile and a rail depot?

    98

 * @param t the tile to get the information from

    99

 * @pre IsTileType(t, MP_RAILWAY)

   100

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

   101

 */

   102

static inline bool IsRailDepotTile(TileIndex t)

   103

{

   104

	return IsTileType(t, MP_RAILWAY) && IsRailDepot(t);

   105

}

   106

   107

/**

   108

 * Gets the rail type of the given tile

   109

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

   110

 * @return the rail type of the tile

   111

 */

   112

static inline RailType GetRailType(TileIndex t)

   113

{

   114

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

   115

}

   116

   117

/**

   118

 * Sets the rail type of the given tile

   119

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

   120

 * @param r the new rail type for the tile

   121

 */

   122

static inline void SetRailType(TileIndex t, RailType r)

   123

{

   124

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

   125

}

   126

   127

   128

/**

   129

 * Gets the track bits of the given tile

   130

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

   131

 * @return the track bits of the tile

   132

 */

   133

static inline TrackBits GetTrackBits(TileIndex tile)

   134

{

   135

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

   136

}

   137

   138

/**

   139

 * Sets the track bits of the given tile

   140

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

   141

 * @param b the new track bits for the tile

   142

 */

   143

static inline void SetTrackBits(TileIndex t, TrackBits b)

   144

{

   145

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

   146

}

   147

   148

/**

   149

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

   150

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

   151

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

   152

 * @pre IsPlainRailTile(tile)

   153

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

   154

 */

   155

static inline bool HasTrack(TileIndex tile, Track track)

   156

{

   157

	return HasBit(GetTrackBits(tile), track);

   158

}

   159

   160

/**

   161

 * Returns the direction the depot is facing to

   162

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

   163

 * @pre IsRailDepotTile(t)

   164

 * @return the direction the depot is facing

   165

 */

   166

static inline DiagDirection GetRailDepotDirection(TileIndex t)

   167

{

   168

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

   169

}

   170

   171

/**

   172

 * Returns the track of a depot, ignoring direction

   173

 * @pre IsRailDepotTile(t)

   174

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

   175

 * @return the track of the depot

   176

 */

   177

static inline Track GetRailDepotTrack(TileIndex t)

   178

{

   179

	return DiagDirToDiagTrack(GetRailDepotDirection(t));

   180

}

   181

   182

   183

/**

   184

 * Returns the axis of the waypoint

   185

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

   186

 * @pre IsRailWaypointTile(t)

   187

 * @return the axis of the waypoint

   188

 */

   189

static inline Axis GetWaypointAxis(TileIndex t)

   190

{

   191

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

   192

}

   193

   194

/**

   195

 * Returns the track of the waypoint

   196

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

   197

 * @pre IsRailWaypointTile(t)

   198

 * @return the track of the waypoint

   199

 */

   200

static inline Track GetRailWaypointTrack(TileIndex t)

   201

{

   202

	return AxisToTrack(GetWaypointAxis(t));

   203

}

   204

   205

/**

   206

 * Returns the track bits of the waypoint

   207

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

   208

 * @pre IsRailWaypointTile(t)

   209

 * @return the track bits of the waypoint

   210

 */

   211

static inline TrackBits GetRailWaypointBits(TileIndex t)

   212

{

   213

	return TrackToTrackBits(GetRailWaypointTrack(t));

   214

}

   215

   216

/**

   217

 * Returns waypoint index (for the waypoint pool)

   218

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

   219

 * @pre IsRailWaypointTile(t)

   220

 * @return the waypoint index

   221

 */

   222

static inline WaypointID GetWaypointIndex(TileIndex t)

   223

{

   224

	return (WaypointID)_m[t].m2;

   225

}

   226

   227

static inline SignalType GetSignalType(TileIndex t, Track track)

   228

{

   229

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   230

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

   231

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

   232

}

   233

   234

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

   235

{

   236

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   237

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

   238

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

   239

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

   240

}

   241

   242

static inline bool IsPresignalEntry(TileIndex t, Track track)

   243

{

   244

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

   245

}

   246

   247

static inline bool IsPresignalExit(TileIndex t, Track track)

   248

{

   249

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

   250

}

   251

   252

static inline void CycleSignalSide(TileIndex t, Track track)

   253

{

   254

	byte sig;

   255

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

   256

   257

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

   258

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

   259

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

   260

}

   261

   262

static inline SignalVariant GetSignalVariant(TileIndex t, Track track)

   263

{

   264

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

   265

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

   266

}

   267

   268

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

   269

{

   270

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

   271

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

   272

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

   273

}

   274

   275

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

   276

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

   277

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

   278

 */

   279

enum SignalState {

   280

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

   281

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

   282

};

   283

   284

/**

   285

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

   286

 * @param tile  the tile to set the states for

   287

 * @param state the new state

   288

 */

   289

static inline void SetSignalStates(TileIndex tile, uint state)

   290

{

   291

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

   292

}

   293

   294

/**

   295

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

   296

 * @param tile  the tile to set the states for

   297

 * @param state the new state

   298

 */

   299

static inline uint GetSignalStates(TileIndex tile)

   300

{

   301

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

   302

}

   303

   304

/**

   305

 * Get the state of a single signal

   306

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

   307

 * @param signalbit the signal

   308

 * @return the state of the signal

   309

 */

   310

static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)

   311

{

   312

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

   313

}

   314

   315

/**

   316

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

   317

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

   318

 * @param signals the signals that have to be present

   319

 */

   320

static inline void SetPresentSignals(TileIndex tile, uint signals)

   321

{

   322

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

   323

}

   324

   325

/**

   326

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

   327

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

   328

 * @return the signals that are present

   329

 */

   330

static inline uint GetPresentSignals(TileIndex tile)

   331

{

   332

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

   333

}

   334

   335

/**

   336

 * Checks whether the given signals is present

   337

 * @param t         the tile to check on

   338

 * @param signalbit the signal

   339

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

   340

 */

   341

static inline bool IsSignalPresent(TileIndex t, byte signalbit)

   342

{

   343

	return HasBit(GetPresentSignals(t), signalbit);

   344

}

   345

   346

/**

   347

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

   348

 * given rail tile.

   349

 */

   350

static inline bool HasSignalOnTrack(TileIndex tile, Track track)

   351

{

   352

	assert(IsValidTrack(track));

   353

	return

   354

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   355

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

   356

}

   357

   358

/**

   359

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

   360

 * rail tile.

   361

 *

   362

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

   363

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

   364

 */

   365

static inline bool HasSignalOnTrackdir(TileIndex tile, Trackdir trackdir)

   366

{

   367

	assert (IsValidTrackdir(trackdir));

   368

	return

   369

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   370

		GetPresentSignals(tile) & SignalAlongTrackdir(trackdir);

   371

}

   372

   373

/**

   374

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

   375

 *

   376

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

   377

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

   378

 */

   379

static inline SignalState GetSignalStateByTrackdir(TileIndex tile, Trackdir trackdir)

   380

{

   381

	assert(IsValidTrackdir(trackdir));

   382

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

   383

	return GetSignalStates(tile) & SignalAlongTrackdir(trackdir) ?

   384

		SIGNAL_STATE_GREEN : SIGNAL_STATE_RED;

   385

}

   386

   387

/**

   388

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

   389

 */

   390

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

   391

{

   392

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

   393

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

   394

	} else {

   395

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

   396

	}

   397

}

   398

   399

   400

/**

   401

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

   402

 */

   403

RailType GetTileRailType(TileIndex tile);

   404

   405

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

   406

enum RailGroundType {

   407

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

   408

	RAIL_GROUND_GRASS        =  1, ///< Grassy

   409

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

   410

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

   411

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

   412

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

   413

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

   414

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

   415

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

   416

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

   417

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

   418

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

   419

	RAIL_GROUND_ICE_DESERT   = 12, ///< Icy or sandy

   420

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

   421

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

   422

};

   423

   424

static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)

   425

{

   426

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

   427

}

   428

   429

static inline RailGroundType GetRailGroundType(TileIndex t)

   430

{

   431

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

   432

}

   433

   434

static inline bool IsSnowRailGround(TileIndex t)

   435

{

   436

	return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;

   437

}

   438

   439

   440

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

   441

{

   442

	SetTileType(t, MP_RAILWAY);

   443

	SetTileOwner(t, o);

   444

	_m[t].m2 = 0;

   445

	_m[t].m3 = r;

   446

	_m[t].m4 = 0;

   447

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

   448

}

   449

   450

   451

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

   452

{

   453

	SetTileType(t, MP_RAILWAY);

   454

	SetTileOwner(t, o);

   455

	_m[t].m2 = 0;

   456

	_m[t].m3 = r;

   457

	_m[t].m4 = 0;

   458

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

   459

}

   460

   461

   462

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

   463

{

   464

	SetTileType(t, MP_RAILWAY);

   465

	SetTileOwner(t, o);

   466

	_m[t].m2 = index;

   467

	_m[t].m3 = r;

   468

	_m[t].m4 = 0;

   469

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

   470

}

   471

   472

#endif /* RAIL_MAP_H */