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

   228

/**

   229

 * Returns the reserved track bits of the tile

   230

 * @pre IsPlainRailTile(t)

   231

 * @param t the tile to query

   232

 * @return the track bits

   233

 */

   234

static inline TrackBits GetTrackReservation(TileIndex t)

   235

{

   236

	assert(IsPlainRailTile(t));

   237

	byte track_b = GB(_m[t].m2, 8, 3);

   238

	Track track = (Track)(track_b - 1);    // map array saves Track+1

   239

	if (track_b == 0) return TRACK_BIT_NONE;

   240

	return (TrackBits)(TrackToTrackBits(track) | (HasBit(_m[t].m2, 11) ? TrackToTrackBits(TrackToOppositeTrack(track)) : 0));

   241

}

   242

   243

/**

   244

 * Sets the reserved track bits of the tile

   245

 * @pre IsPlainRailTile(t) && !TracksOverlap(b)

   246

 * @param t the tile to change

   247

 * @param b the track bits

   248

 */

   249

static inline void SetTrackReservation(TileIndex t, TrackBits b)

   250

{

   251

	assert(IsPlainRailTile(t));

   252

	assert(b != INVALID_TRACK_BIT);

   253

	assert(!TracksOverlap(b));

   254

	Track track = RemoveFirstTrack(&b);

   255

	SB(_m[t].m2, 8, 3, track == INVALID_TRACK ? 0 : track+1);

   256

	SB(_m[t].m2, 11, 1, (byte)(b != TRACK_BIT_NONE));

   257

}

   258

   259

/**

   260

 * Try to reserve a specific track on a tile

   261

 * @pre IsPlainRailTile(t) && HasTrack(tile, t)

   262

 * @param tile the tile

   263

 * @param t the rack to reserve

   264

 * @return true if successful

   265

 */

   266

static inline bool TryReserveTrack(TileIndex tile, Track t)

   267

{

   268

	assert(HasTrack(tile, t));

   269

	TrackBits bits = TrackToTrackBits(t);

   270

	TrackBits res = GetTrackReservation(tile);

   271

	if ((res & bits) != TRACK_BIT_NONE) return false;  // already reserved

   272

	res |= bits;

   273

	if (TracksOverlap(res)) return false;  // crossing reservation present

   274

	SetTrackReservation(tile, res);

   275

	return true;

   276

}

   277

   278

/**

   279

 * Lift the reservation of a specific track on a tile

   280

 * @pre IsPlainRailTile(t) && HasTrack(tile, t)

   281

 * @param tile the tile

   282

 * @param t the track to free

   283

 */

   284

static inline void UnreserveTrack(TileIndex tile, Track t)

   285

{

   286

	assert(HasTrack(tile, t));

   287

	TrackBits res = GetTrackReservation(tile);

   288

	res &= ~TrackToTrackBits(t);

   289

	SetTrackReservation(tile, res);

   290

}

   291

   292

/**

   293

 * Get the reservation state of the waypoint or depot

   294

 * @note Works for both waypoints and rail depots

   295

 * @pre IsRailWaypoint(t) || IsRailDepot(t)

   296

 * @param t the waypoint/depot tile

   297

 * @return reservation state

   298

 */

   299

static inline bool GetDepotWaypointReservation(TileIndex t)

   300

{

   301

	assert(IsRailWaypoint(t) || IsRailDepot(t));

   302

	return HasBit(_m[t].m5, 4);

   303

}

   304

   305

/**

   306

 * Set the reservation state of the waypoint or depot

   307

 * @note Works for both waypoints and rail depots

   308

 * @pre IsRailWaypoint(t) || IsRailDepot(t)

   309

 * @param t the waypoint/depot tile

   310

 * @param b the reservation state

   311

 */

   312

static inline void SetDepotWaypointReservation(TileIndex t, bool b)

   313

{

   314

	assert(IsRailWaypoint(t) || IsRailDepot(t));

   315

	SB(_m[t].m5, 4, 1, (byte)b);

   316

}

   317

   318

/**

   319

 * Get the reserved track bits for a waypoint

   320

 * @pre IsRailWaypoint(t)

   321

 * @param t the tile

   322

 * @return reserved track bits

   323

 */

   324

static inline TrackBits GetRailWaypointReservation(TileIndex t)

   325

{

   326

	return GetDepotWaypointReservation(t) ? GetRailWaypointBits(t) : TRACK_BIT_NONE;

   327

}

   328

   329

/**

   330

 * Get the reserved track bits for a depot

   331

 * @pre IsRailDepot(t)

   332

 * @param t the tile

   333

 * @return reserved track bits

   334

 */

   335

static inline TrackBits GetRailDepotReservation(TileIndex t)

   336

{

   337

	return GetDepotWaypointReservation(t) ? TrackToTrackBits(GetRailDepotTrack(t)) : TRACK_BIT_NONE;

   338

}

   339

   340

   341

static inline bool IsPbsSignal(SignalType s)

   342

{

   343

	return s == SIGTYPE_PBS || s == SIGTYPE_PBS_ONEWAY;

   344

}

   345

   346

static inline SignalType GetSignalType(TileIndex t, Track track)

   347

{

   348

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   349

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

   350

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

   351

}

   352

   353

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

   354

{

   355

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   356

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

   357

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

   358

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

   359

}

   360

   361

static inline bool IsPresignalEntry(TileIndex t, Track track)

   362

{

   363

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

   364

}

   365

   366

static inline bool IsPresignalExit(TileIndex t, Track track)

   367

{

   368

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

   369

}

   370

   371

/** One-way signals can't be passed the 'wrong' way. */

   372

static inline bool IsOnewaySignal(TileIndex t, Track track)

   373

{

   374

	return GetSignalType(t, track) != SIGTYPE_PBS;

   375

}

   376

   377

static inline void CycleSignalSide(TileIndex t, Track track)

   378

{

   379

	byte sig;

   380

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

   381

   382

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

   383

	if (--sig == 0) sig = IsPbsSignal(GetSignalType(t, track)) ? 2 : 3;

   384

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

   385

}

   386

   387

static inline SignalVariant GetSignalVariant(TileIndex t, Track track)

   388

{

   389

	byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 7 : 3;

   390

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

   391

}

   392

   393

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

   394

{

   395

	byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 7 : 3;

   396

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

   397

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

   398

}

   399

   400

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

   401

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

   402

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

   403

 */

   404

enum SignalState {

   405

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

   406

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

   407

};

   408

   409

/**

   410

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

   411

 * @param tile  the tile to set the states for

   412

 * @param state the new state

   413

 */

   414

static inline void SetSignalStates(TileIndex tile, uint state)

   415

{

   416

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

   417

}

   418

   419

/**

   420

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

   421

 * @param tile  the tile to set the states for

   422

 * @param state the new state

   423

 */

   424

static inline uint GetSignalStates(TileIndex tile)

   425

{

   426

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

   427

}

   428

   429

/**

   430

 * Get the state of a single signal

   431

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

   432

 * @param signalbit the signal

   433

 * @return the state of the signal

   434

 */

   435

static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)

   436

{

   437

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

   438

}

   439

   440

/**

   441

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

   442

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

   443

 * @param signals the signals that have to be present

   444

 */

   445

static inline void SetPresentSignals(TileIndex tile, uint signals)

   446

{

   447

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

   448

}

   449

   450

/**

   451

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

   452

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

   453

 * @return the signals that are present

   454

 */

   455

static inline uint GetPresentSignals(TileIndex tile)

   456

{

   457

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

   458

}

   459

   460

/**

   461

 * Checks whether the given signals is present

   462

 * @param t         the tile to check on

   463

 * @param signalbit the signal

   464

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

   465

 */

   466

static inline bool IsSignalPresent(TileIndex t, byte signalbit)

   467

{

   468

	return HasBit(GetPresentSignals(t), signalbit);

   469

}

   470

   471

/**

   472

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

   473

 * given rail tile.

   474

 */

   475

static inline bool HasSignalOnTrack(TileIndex tile, Track track)

   476

{

   477

	assert(IsValidTrack(track));

   478

	return

   479

		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&

   480

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

   481

}

   482

   483

/**

   484

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

   485

 * rail tile.

   486

 *

   487

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

   488