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 tile rail tile and a rail waypoint?

    87

 * @param t the tile to get the information from

    88

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

    89

 */

    90

static inline bool IsRailWaypointTile(TileIndex t)

    91

{

    92

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

    93

}

    94

    95

/**

    96

 * Is this rail tile a rail depot?

    97

 * @param t the tile to get the information from

    98

 * @pre IsTileType(t, MP_RAILWAY)

    99

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

   100

 */

   101

static inline bool IsRailDepot(TileIndex t)

   102

{

   103

	return GetRailTileType(t) == RAIL_TILE_DEPOT;

   104

}

   105

   106

/**

   107

 * Is this tile rail tile and a rail depot?

   108

 * @param t the tile to get the information from

   109

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

   110

 */

   111

static inline bool IsRailDepotTile(TileIndex t)

   112

{

   113

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

   114

}

   115

   116

/**

   117

 * Gets the rail type of the given tile

   118

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

   119

 * @return the rail type of the tile

   120

 */

   121

static inline RailType GetRailType(TileIndex t)

   122

{

   123

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

   124

}

   125

   126

/**

   127

 * Sets the rail type of the given tile

   128

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

   129

 * @param r the new rail type for the tile

   130

 */

   131

static inline void SetRailType(TileIndex t, RailType r)

   132

{

   133

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

   134

}

   135

   136

   137

/**

   138

 * Gets the track bits of the given tile

   139

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

   140

 * @return the track bits of the tile

   141

 */

   142

static inline TrackBits GetTrackBits(TileIndex tile)

   143

{

   144

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

   145

}

   146

   147

/**

   148

 * Sets the track bits of the given tile

   149

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

   150

 * @param b the new track bits for the tile

   151

 */

   152

static inline void SetTrackBits(TileIndex t, TrackBits b)

   153

{

   154

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

   155

}

   156

   157

/**

   158

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

   159

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

   160

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

   161

 * @pre IsPlainRailTile(tile)

   162

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

   163

 */

   164

static inline bool HasTrack(TileIndex tile, Track track)

   165

{

   166

	return HasBit(GetTrackBits(tile), track);

   167

}

   168

   169

/**

   170

 * Returns the direction the depot is facing to

   171

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

   172

 * @pre IsRailDepotTile(t)

   173

 * @return the direction the depot is facing

   174

 */

   175

static inline DiagDirection GetRailDepotDirection(TileIndex t)

   176

{

   177

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

   178

}

   179

   180

/**

   181

 * Returns the track of a depot, ignoring direction

   182

 * @pre IsRailDepotTile(t)

   183

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

   184

 * @return the track of the depot

   185

 */

   186

static inline Track GetRailDepotTrack(TileIndex t)

   187

{

   188

	return DiagDirToDiagTrack(GetRailDepotDirection(t));

   189

}

   190

   191

   192

/**

   193

 * Returns the axis of the waypoint

   194

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

   195

 * @pre IsRailWaypointTile(t)

   196

 * @return the axis of the waypoint

   197

 */

   198

static inline Axis GetWaypointAxis(TileIndex t)

   199

{

   200

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

   201

}

   202

   203

/**

   204

 * Returns the track of the waypoint

   205

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

   206

 * @pre IsRailWaypointTile(t)

   207

 * @return the track of the waypoint

   208

 */

   209

static inline Track GetRailWaypointTrack(TileIndex t)

   210

{

   211

	return AxisToTrack(GetWaypointAxis(t));

   212

}

   213

   214

/**

   215

 * Returns the track bits of the waypoint

   216

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

   217

 * @pre IsRailWaypointTile(t)

   218

 * @return the track bits of the waypoint

   219

 */

   220

static inline TrackBits GetRailWaypointBits(TileIndex t)

   221

{

   222

	return TrackToTrackBits(GetRailWaypointTrack(t));

   223

}

   224

   225

/**

   226

 * Returns waypoint index (for the waypoint pool)

   227

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

   228

 * @pre IsRailWaypointTile(t)

   229

 * @return the waypoint index

   230

 */

   231

static inline WaypointID GetWaypointIndex(TileIndex t)

   232

{

   233

	return (WaypointID)_m[t].m2;

   234

}

   235

   236

   237

/**

   238

 * Returns the reserved track bits of the tile

   239

 * @pre IsPlainRailTile(t)

   240

 * @param t the tile to query

   241

 * @return the track bits

   242

 */

   243

static inline TrackBits GetTrackReservation(TileIndex t)

   244

{

   245

	assert(IsPlainRailTile(t));

   246

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

   247

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

   248

	if (track_b == 0) return TRACK_BIT_NONE;

   249

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

   250

}

   251

   252

/**

   253

 * Sets the reserved track bits of the tile

   254

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

   255

 * @param t the tile to change

   256

 * @param b the track bits

   257

 */

   258

static inline void SetTrackReservation(TileIndex t, TrackBits b)

   259

{

   260

	assert(IsPlainRailTile(t));

   261

	assert(b != INVALID_TRACK_BIT);

   262

	assert(!TracksOverlap(b));

   263

	Track track = RemoveFirstTrack(&b);

   264

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

   265

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

   266

}

   267

   268

/**

   269

 * Try to reserve a specific track on a tile

   270

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

   271

 * @param tile the tile

   272

 * @param t the rack to reserve

   273

 * @return true if successful

   274

 */

   275

static inline bool TryReserveTrack(TileIndex tile, Track t)

   276

{

   277

	assert(HasTrack(tile, t));

   278

	TrackBits bits = TrackToTrackBits(t);

   279

	TrackBits res = GetTrackReservation(tile);

   280

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

   281

	res |= bits;

   282

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

   283

	SetTrackReservation(tile, res);

   284

	return true;

   285

}

   286

   287

/**

   288

 * Lift the reservation of a specific track on a tile

   289

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

   290

 * @param tile the tile

   291

 * @param t the track to free

   292

 */

   293

static inline void UnreserveTrack(TileIndex tile, Track t)

   294

{

   295

	assert(HasTrack(tile, t));

   296

	TrackBits res = GetTrackReservation(tile);

   297

	res &= ~TrackToTrackBits(t);

   298

	SetTrackReservation(tile, res);

   299

}

   300

   301

/**

   302

 * Get the reservation state of the waypoint or depot

   303

 * @note Works for both waypoints and rail depots

   304

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

   305

 * @param t the waypoint/depot tile

   306

 * @return reservation state

   307

 */

   308

static inline bool GetDepotWaypointReservation(TileIndex t)

   309

{

   310

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

   311

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

   312

}

   313

   314

/**

   315

 * Set the reservation state of the waypoint or depot

   316

 * @note Works for both waypoints and rail depots

   317

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

   318

 * @param t the waypoint/depot tile

   319

 * @param b the reservation state

   320

 */

   321

static inline void SetDepotWaypointReservation(TileIndex t, bool b)

   322

{

   323

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

   324

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

   325

}

   326

   327

/**

   328

 * Get the reserved track bits for a waypoint

   329

 * @pre IsRailWaypoint(t)

   330

 * @param t the tile

   331

 * @return reserved track bits

   332

 */

   333

static inline TrackBits GetRailWaypointReservation(TileIndex t)

   334

{

   335

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

   336

}

   337

   338

/**

   339

 * Get the reserved track bits for a depot

   340

 * @pre IsRailDepot(t)

   341

 * @param t the tile

   342

 * @return reserved track bits

   343

 */

   344

static inline TrackBits GetRailDepotReservation(TileIndex t)

   345

{

   346

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

   347

}

   348

   349

   350

static inline bool IsPbsSignal(SignalType s)

   351

{

   352

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

   353

}

   354

   355

static inline SignalType GetSignalType(TileIndex t, Track track)

   356

{

   357

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   358

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

   359

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

   360

}

   361

   362

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

   363

{

   364

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   365

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

   366

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

   367

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

   368

}

   369

   370

static inline bool IsPresignalEntry(TileIndex t, Track track)

   371

{

   372

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

   373

}

   374

   375

static inline bool IsPresignalExit(TileIndex t, Track track)

   376

{

   377

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

   378

}

   379

   380

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

   381

static inline bool IsOnewaySignal(TileIndex t, Track track)

   382

{

   383

	return GetSignalType(t, track) != SIGTYPE_PBS;

   384

}

   385

   386

static inline void CycleSignalSide(TileIndex t, Track track)

   387

{

   388

	byte sig;

   389

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

   390

   391

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

   392

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

   393

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

   394

}

   395

   396

static inline SignalVariant GetSignalVariant(TileIndex t, Track track)

   397

{

   398

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

   399

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

   400

}

   401

   402

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

   403

{

   404

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

   405

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

   406

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

   407

}

   408

   409

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

   410

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

   411

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

   412

 */

   413

enum SignalState {

   414

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

   415

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

   416

};

   417

   418

/**

   419

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

   420

 * @param tile  the tile to set the states for

   421

 * @param state the new state

   422

 */

   423

static inline void SetSignalStates(TileIndex tile, uint state)

   424

{

   425

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

   426

}

   427

   428

/**

   429

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

   430

 * @param tile  the tile to set the states for

   431

 * @param state the new state

   432

 */

   433

static inline uint GetSignalStates(TileIndex tile)

   434

{

   435

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

   436

}

   437

   438

/**

   439

 * Get the state of a single signal

   440

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

   441

 * @param signalbit the signal

   442

 * @return the state of the signal

   443

 */

   444

static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)

   445

{

   446

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

   447

}

   448

   449

/**

   450

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

   451

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

   452

 * @param signals the signals that have to be present

   453

 */

   454

static inline void SetPresentSignals(TileIndex tile, uint signals)

   455

{

   456

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

   457

}

   458

   459

/**

   460

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

   461

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

   462

 * @return the signals that are present

   463

 */

   464

static inline uint GetPresentSignals(TileIndex tile)

   465

{

   466

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

   467

}

   468

   469

/**

   470

 * Checks whether the given signals is present

   471

 * @param t         the tile to check on

   472

 * @param signalbit the signal

   473

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

   474

 */

   475

static inline bool IsSignalPresent(TileIndex t, byte signalbit)

   476

{

   477

	return HasBit(GetPresentSignals(t), signalbit);

   478

}

   479

   480

/**

   481

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

   482

 * given rail tile.

   483

 */

   484

static inline bool HasSignalOnTrack(TileIndex tile, Track track)

   485

{

   486

	assert(IsValidTrack(track));

   487

	return