1

/* $Id$ */

     2

     3

/** @file rail.h */

     4

     5

#ifndef RAIL_H

     6

#define RAIL_H

     7

     8

#include "gfx.h"

     9

#include "direction.h"

    10

#include "tile.h"

    11

    12

/**

    13

 * Enumeration for all possible railtypes.

    14

 *

    15

 * This enumeration defines all 4 possible railtypes.

    16

 */

    17

enum RailType {

    18

	RAILTYPE_BEGIN    = 0,          ///< Used for iterations

    19

	RAILTYPE_RAIL     = 0,          ///< Standard non-electric rails

    20

	RAILTYPE_ELECTRIC = 1,          ///< Electric rails

    21

	RAILTYPE_MONO     = 2,          ///< Monorail

    22

	RAILTYPE_MAGLEV   = 3,          ///< Maglev

    23

	RAILTYPE_END,                   ///< Used for iterations

    24

	INVALID_RAILTYPE  = 0xFF        ///< Flag for invalid railtype

    25

};

    26

    27

typedef byte RailTypeMask;

    28

    29

/** Allow incrementing of Track variables */

    30

DECLARE_POSTFIX_INCREMENT(RailType);

    31

/** Define basic enum properties */

    32

template <> struct EnumPropsT<RailType> : MakeEnumPropsT<RailType, byte, RAILTYPE_BEGIN, RAILTYPE_END, INVALID_RAILTYPE> {};

    33

typedef TinyEnumT<RailType> RailTypeByte;

    34

    35

    36

/**

    37

 * These are used to specify a single track.

    38

 * Can be translated to a trackbit with TrackToTrackbit

    39

 */

    40

enum Track {

    41

	TRACK_BEGIN = 0,        ///< Used for iterations

    42

	TRACK_X     = 0,        ///< Track along the x-axis (north-east to south-west)

    43

	TRACK_Y     = 1,        ///< Track along the y-axis (north-west to south-east)

    44

	TRACK_UPPER = 2,        ///< Track in the upper corner of the tile (north)

    45

	TRACK_LOWER = 3,        ///< Track in the lower corner of the tile (south)

    46

	TRACK_LEFT  = 4,        ///< Track in the left corner of the tile (west)

    47

	TRACK_RIGHT = 5,        ///< Track in the right corner of the tile (east)

    48

	TRACK_END,              ///< Used for iterations

    49

	INVALID_TRACK = 0xFF    ///< Flag for an invalid track

    50

};

    51

    52

/** Allow incrementing of Track variables */

    53

DECLARE_POSTFIX_INCREMENT(Track);

    54

/** Define basic enum properties */

    55

template <> struct EnumPropsT<Track> : MakeEnumPropsT<Track, byte, TRACK_BEGIN, TRACK_END, INVALID_TRACK> {};

    56

typedef TinyEnumT<Track> TrackByte;

    57

    58

    59

/**

    60

 * Convert an Axis to the corresponding Track

    61

 * AXIS_X -> TRACK_X

    62

 * AXIS_Y -> TRACK_Y

    63

 * Uses the fact that they share the same internal encoding

    64

 *

    65

 * @param a the axis to convert

    66

 * @return the track corresponding to the axis

    67

 */

    68

static inline Track AxisToTrack(Axis a)

    69

{

    70

	return (Track)a;

    71

}

    72

    73

    74

/** Bitfield corresponding to Track */

    75

enum TrackBits {

    76

	TRACK_BIT_NONE    = 0U,                                                 ///< No track

    77

	TRACK_BIT_X       = 1U << TRACK_X,                                      ///< X-axis track

    78

	TRACK_BIT_Y       = 1U << TRACK_Y,                                      ///< Y-axis track

    79

	TRACK_BIT_UPPER   = 1U << TRACK_UPPER,                                  ///< Upper track

    80

	TRACK_BIT_LOWER   = 1U << TRACK_LOWER,                                  ///< Lower track

    81

	TRACK_BIT_LEFT    = 1U << TRACK_LEFT,                                   ///< Left track

    82

	TRACK_BIT_RIGHT   = 1U << TRACK_RIGHT,                                  ///< Right track

    83

	TRACK_BIT_CROSS   = TRACK_BIT_X     | TRACK_BIT_Y,                      ///< X-Y-axis cross

    84

	TRACK_BIT_HORZ    = TRACK_BIT_UPPER | TRACK_BIT_LOWER,                  ///< Upper and lower track

    85

	TRACK_BIT_VERT    = TRACK_BIT_LEFT  | TRACK_BIT_RIGHT,                  ///< Left and right track

    86

	TRACK_BIT_3WAY_NE = TRACK_BIT_X     | TRACK_BIT_UPPER | TRACK_BIT_RIGHT,///< "Arrow" to the north-east

    87

	TRACK_BIT_3WAY_SE = TRACK_BIT_Y     | TRACK_BIT_LOWER | TRACK_BIT_RIGHT,///< "Arrow" to the south-east

    88

	TRACK_BIT_3WAY_SW = TRACK_BIT_X     | TRACK_BIT_LOWER | TRACK_BIT_LEFT, ///< "Arrow" to the south-west

    89

	TRACK_BIT_3WAY_NW = TRACK_BIT_Y     | TRACK_BIT_UPPER | TRACK_BIT_LEFT, ///< "Arrow" to the north-west

    90

	TRACK_BIT_ALL     = TRACK_BIT_CROSS | TRACK_BIT_HORZ  | TRACK_BIT_VERT, ///< All possible tracks

    91

	TRACK_BIT_MASK    = 0x3FU,                                              ///< Bitmask for the first 6 bits

    92

	TRACK_BIT_WORMHOLE = 0x40U,                                             ///< Bitflag for a wormhole (used for tunnels)

    93

	TRACK_BIT_DEPOT   = 0x80U,                                              ///< Bitflag for a depot

    94

	INVALID_TRACK_BIT = 0xFF                                                ///< Flag for an invalid trackbits value

    95

};

    96

    97

/** Define basic enum properties */

    98

template <> struct EnumPropsT<TrackBits> : MakeEnumPropsT<TrackBits, byte, TRACK_BIT_NONE, TRACK_BIT_ALL, INVALID_TRACK_BIT> {};

    99

typedef TinyEnumT<TrackBits> TrackBitsByte;

   100

   101

DECLARE_ENUM_AS_BIT_SET(TrackBits);

   102

   103

/**

   104

 * Maps a Track to the corresponding TrackBits value

   105

 * @param track the track to convert

   106

 * @return the converted TrackBits value of the track

   107

 */

   108

static inline TrackBits TrackToTrackBits(Track track)

   109

{

   110

	return (TrackBits)(1 << track);

   111

}

   112

   113

/**

   114

 * Maps an Axis to the corresponding TrackBits value

   115

 * @param a the axis to convert

   116

 * @return the converted TrackBits value of the axis

   117

 */

   118

static inline TrackBits AxisToTrackBits(Axis a)

   119

{

   120

	return TrackToTrackBits(AxisToTrack(a));

   121

}

   122

   123

   124

/**

   125

 * Enumeration for tracks and directions.

   126

 *

   127

 * These are a combination of tracks and directions. Values are 0-5 in one

   128

 * direction (corresponding to the Track enum) and 8-13 in the other direction.

   129

 * 6, 7, 14 and 15 are used to encode the reversing of road vehicles. Those

   130

 * reversing track dirs are not considered to be 'valid' except in a small

   131

 * corner in the road vehicle controller.

   132

 */

   133

enum Trackdir {

   134

	TRACKDIR_BEGIN    =  0,         ///< Used for iterations

   135

	TRACKDIR_X_NE     =  0,         ///< X-axis and direction to north-east

   136

	TRACKDIR_Y_SE     =  1,         ///< Y-axis and direction to south-east

   137

	TRACKDIR_UPPER_E  =  2,         ///< Upper track and direction to east

   138

	TRACKDIR_LOWER_E  =  3,         ///< Lower track and direction to east

   139

	TRACKDIR_LEFT_S   =  4,         ///< Left track and direction to south

   140

	TRACKDIR_RIGHT_S  =  5,         ///< Right track and direction to south

   141

	TRACKDIR_RVREV_NE =  6,         ///< (Road vehicle) reverse direction north-east

   142

	TRACKDIR_RVREV_SE =  7,         ///< (Road vehicle) reverse direction south-east

   143

	TRACKDIR_X_SW     =  8,         ///< X-axis and direction to south-west

   144

	TRACKDIR_Y_NW     =  9,         ///< Y-axis and direction to north-west

   145

	TRACKDIR_UPPER_W  = 10,         ///< Upper track and direction to west

   146

	TRACKDIR_LOWER_W  = 11,         ///< Lower track and direction to west

   147

	TRACKDIR_LEFT_N   = 12,         ///< Left track and direction to north

   148

	TRACKDIR_RIGHT_N  = 13,         ///< Right track and direction to north

   149

	TRACKDIR_RVREV_SW = 14,         ///< (Road vehicle) reverse direction south-west

   150

	TRACKDIR_RVREV_NW = 15,         ///< (Road vehicle) reverse direction north-west

   151

	TRACKDIR_END,                   ///< Used for iterations

   152

	INVALID_TRACKDIR  = 0xFF,       ///< Flag for an invalid trackdir

   153

};

   154

   155

/** Define basic enum properties */

   156

template <> struct EnumPropsT<Trackdir> : MakeEnumPropsT<Trackdir, byte, TRACKDIR_BEGIN, TRACKDIR_END, INVALID_TRACKDIR> {};

   157

typedef TinyEnumT<Trackdir> TrackdirByte;

   158

   159

/**

   160

 * Enumeration of bitmasks for the TrackDirs

   161

 *

   162

 * These are a combination of tracks and directions. Values are 0-5 in one

   163

 * direction (corresponding to the Track enum) and 8-13 in the other direction.

   164

 */

   165

enum TrackdirBits {

   166

	TRACKDIR_BIT_NONE     = 0x0000, ///< No track build

   167

	TRACKDIR_BIT_X_NE     = 0x0001, ///< Track x-axis, direction north-east

   168

	TRACKDIR_BIT_Y_SE     = 0x0002, ///< Track y-axis, direction south-east

   169

	TRACKDIR_BIT_UPPER_E  = 0x0004, ///< Track upper, direction east

   170

	TRACKDIR_BIT_LOWER_E  = 0x0008, ///< Track lower, direction east

   171

	TRACKDIR_BIT_LEFT_S   = 0x0010, ///< Track left, direction south

   172

	TRACKDIR_BIT_RIGHT_S  = 0x0020, ///< Track right, direction south

   173

	/* Again, note the two missing values here. This enables trackdir -> track conversion by doing (trackdir & 0xFF) */

   174

	TRACKDIR_BIT_X_SW     = 0x0100, ///< Track x-axis, direction south-west

   175

	TRACKDIR_BIT_Y_NW     = 0x0200, ///< Track y-axis, direction north-west

   176

	TRACKDIR_BIT_UPPER_W  = 0x0400, ///< Track upper, direction west

   177

	TRACKDIR_BIT_LOWER_W  = 0x0800, ///< Track lower, direction west

   178

	TRACKDIR_BIT_LEFT_N   = 0x1000, ///< Track left, direction north

   179

	TRACKDIR_BIT_RIGHT_N  = 0x2000, ///< Track right, direction north

   180

	TRACKDIR_BIT_MASK     = 0x3F3F, ///< Bitmask for bit-operations

   181

	INVALID_TRACKDIR_BIT  = 0xFFFF, ///< Flag for an invalid trackdirbit value

   182

};

   183

   184

/** Define basic enum properties */

   185

template <> struct EnumPropsT<TrackdirBits> : MakeEnumPropsT<TrackdirBits, uint16, TRACKDIR_BIT_NONE, TRACKDIR_BIT_MASK, INVALID_TRACKDIR_BIT> {};

   186

typedef TinyEnumT<TrackdirBits> TrackdirBitsShort;

   187

DECLARE_ENUM_AS_BIT_SET(TrackdirBits);

   188

   189

/** This struct contains all the info that is needed to draw and construct tracks.

   190

 */

   191

struct RailtypeInfo {

   192

	/** Struct containing the main sprites. @note not all sprites are listed, but only

   193

	 *  the ones used directly in the code */

   194

	struct {

   195

		SpriteID track_y;      ///< single piece of rail in Y direction, with ground

   196

		SpriteID track_ns;     ///< two pieces of rail in North and South corner (East-West direction)

   197

		SpriteID ground;       ///< ground sprite for a 3-way switch

   198

		SpriteID single_y;     ///< single piece of rail in Y direction, without ground

   199

		SpriteID single_x;     ///< single piece of rail in X direction

   200

		SpriteID single_n;     ///< single piece of rail in the northern corner

   201

		SpriteID single_s;     ///< single piece of rail in the southern corner

   202

		SpriteID single_e;     ///< single piece of rail in the eastern corner

   203

		SpriteID single_w;     ///< single piece of rail in the western corner

   204

		SpriteID crossing;     ///< level crossing, rail in X direction

   205

		SpriteID tunnel;       ///< tunnel sprites base

   206

	} base_sprites;

   207

   208

	/** struct containing the sprites for the rail GUI. @note only sprites referred to

   209

	 * directly in the code are listed */

   210

	struct {

   211

		SpriteID build_ns_rail;      ///< button for building single rail in N-S direction

   212

		SpriteID build_x_rail;       ///< button for building single rail in X direction

   213

		SpriteID build_ew_rail;      ///< button for building single rail in E-W direction

   214

		SpriteID build_y_rail;       ///< button for building single rail in Y direction

   215

		SpriteID auto_rail;          ///< button for the autorail construction

   216

		SpriteID build_depot;        ///< button for building depots

   217

		SpriteID build_tunnel;       ///< button for building a tunnel

   218

		SpriteID convert_rail;       ///< button for converting rail

   219

	} gui_sprites;

   220

   221

	struct {

   222

		CursorID rail_ns;    ///< Cursor for building rail in N-S direction

   223

		CursorID rail_swne;  ///< Cursor for building rail in X direction

   224

		CursorID rail_ew;    ///< Cursor for building rail in E-W direction

   225

		CursorID rail_nwse;  ///< Cursor for building rail in Y direction

   226

		CursorID autorail;   ///< Cursor for autorail tool

   227

		CursorID depot;      ///< Cursor for building a depot

   228

		CursorID tunnel;     ///< Cursor for building a tunnel

   229

		CursorID convert;    ///< Cursor for converting track

   230

	} cursor;

   231

   232

	struct {

   233

		StringID toolbar_caption;

   234

	} strings;

   235

   236

	/** sprite number difference between a piece of track on a snowy ground and the corresponding one on normal ground */

   237

	SpriteID snow_offset;

   238

   239

	/** bitmask to the OTHER railtypes on which an engine of THIS railtype generates power */

   240

	RailTypeMask powered_railtypes;

   241

   242

	/** bitmask to the OTHER railtypes on which an engine of THIS railtype can physically travel */

   243

	RailTypeMask compatible_railtypes;

   244

   245

	/**

   246

	 * Offset between the current railtype and normal rail. This means that:<p>

   247

	 * 1) All the sprites in a railset MUST be in the same order. This order

   248

	 *    is determined by normal rail. Check sprites 1005 and following for this order<p>

   249

	 * 2) The position where the railtype is loaded must always be the same, otherwise

   250

	 *    the offset will fail.

   251

	 * @note: Something more flexible might be desirable in the future.

   252

	 */

   253

	SpriteID total_offset;

   254

   255

	/**

   256

	 * Bridge offset

   257

	 */

   258

	SpriteID bridge_offset;

   259

   260

	/**

   261

	 * Offset to add to ground sprite when drawing custom waypoints / stations

   262

	 */

   263

	byte custom_ground_offset;

   264

};

   265

   266

   267

/** these are the maximums used for updating signal blocks, and checking if a depot is in a pbs block */

   268

enum {

   269

	NUM_SSD_ENTRY = 256, ///< max amount of blocks

   270

	NUM_SSD_STACK =  32, ///< max amount of blocks to check recursively

   271

};

   272

   273

/**

   274

 * Maps a Trackdir to the corresponding TrackdirBits value

   275

 * @param trackdir the track direction to convert

   276

 * @return the converted TrackdirBits value

   277

 */

   278

static inline TrackdirBits TrackdirToTrackdirBits(Trackdir trackdir)

   279

{

   280

	return (TrackdirBits)(1 << trackdir);

   281

}

   282

   283

/**

   284

 * Removes first Track from TrackBits and returns it

   285

 *

   286

 * This function searchs for the first bit in the TrackBits,

   287

 * remove this bit from the parameter and returns the found

   288

 * bit as Track value. It returns INVALID_TRACK if the

   289

 * parameter was TRACK_BIT_NONE or INVALID_TRACK_BIT. This

   290

 * is basically used in while-loops to get up to 6 possible

   291

 * tracks on a tile until the parameter becomes TRACK_BIT_NONE.

   292

 *

   293

 * @param tracks The value with the TrackBits

   294

 * @return The first Track from the TrackBits value

   295

 * @see FindFirstTrack

   296

 */

   297

static inline Track RemoveFirstTrack(TrackBits *tracks)

   298

{

   299

	if (*tracks != TRACK_BIT_NONE && *tracks != INVALID_TRACK_BIT) {

   300

		Track first = (Track)FIND_FIRST_BIT(*tracks);

   301

		ClrBitT(*tracks, first);

   302

		return first;

   303

	}

   304

	return INVALID_TRACK;

   305

}

   306

   307

/**

   308

 * Removes first Trackdir from TrackdirBits and returns it

   309

 *

   310

 * This function searchs for the first bit in the TrackdirBits parameter,

   311

 * remove this bit from the parameter and returns the fnound bit as

   312

 * Trackdir value. It returns INVALID_TRACKDIR if the trackdirs is

   313

 * TRACKDIR_BIT_NONE or INVALID_TRACKDIR_BIT. This is basically used in a

   314

 * while-loop to get all track-directions step by step until the value

   315

 * reaches TRACKDIR_BIT_NONE.

   316

 *

   317

 * @param trackdirs The value with the TrackdirBits

   318

 * @return The first Trackdir from the TrackdirBits value

   319

 * @see FindFirstTrackdir

   320

 */

   321

static inline Trackdir RemoveFirstTrackdir(TrackdirBits *trackdirs)

   322

{

   323

	if (*trackdirs != TRACKDIR_BIT_NONE && *trackdirs != INVALID_TRACKDIR_BIT) {

   324

		Trackdir first = (Trackdir)FindFirstBit2x64(*trackdirs);

   325

		ClrBitT(*trackdirs, first);

   326

		return first;

   327

	}

   328

	return INVALID_TRACKDIR;

   329

}

   330

   331

/**

   332

 * Returns first Track from TrackBits or INVALID_TRACK

   333

 *

   334

 * This function returns the first Track found in the TrackBits value as Track-value.

   335

 * It returns INVALID_TRACK if the parameter is TRACK_BIT_NONE or INVALID_TRACK_BIT.

   336

 *

   337

 * @param tracks The TrackBits value

   338

 * @return The first Track found or INVALID_TRACK

   339

 * @see RemoveFirstTrack

   340

 */

   341

static inline Track FindFirstTrack(TrackBits tracks)

   342

{

   343

	return (tracks != TRACK_BIT_NONE && tracks != INVALID_TRACK_BIT) ? (Track)FIND_FIRST_BIT(tracks) : INVALID_TRACK;

   344

}

   345

   346

/**

   347

 * Converts TrackBits to Track.

   348

 *

   349

 * This function converts a TrackBits value to a Track value. As it

   350

 * is not possible to convert two or more tracks to one track the

   351

 * parameter must contain only one track or be the INVALID_TRACK_BIT value.

   352

 *

   353

 * @param tracks The TrackBits value to convert

   354

 * @return The Track from the value or INVALID_TRACK

   355

 * @pre tracks must contains only one Track or be INVALID_TRACK_BIT

   356

 */

   357

static inline Track TrackBitsToTrack(TrackBits tracks)

   358

{

   359

	assert(tracks == INVALID_TRACK_BIT || (tracks != TRACK_BIT_NONE && KILL_FIRST_BIT(tracks & TRACK_BIT_MASK) == 0));

   360

	return tracks != INVALID_TRACK_BIT ? (Track)FIND_FIRST_BIT(tracks & TRACK_BIT_MASK) : INVALID_TRACK;

   361

}

   362

   363

/**

   364

 * Returns first Trackdir from TrackdirBits or INVALID_TRACKDIR

   365

 *

   366

 * This function returns the first Trackdir in the given TrackdirBits value or

   367

 * INVALID_TRACKDIR if the value is TRACKDIR_BIT_NONE. The TrackdirBits must

   368

 * not be INVALID_TRACKDIR_BIT.

   369

 *

   370

 * @param trackdirs The TrackdirBits value

   371

 * @return The first Trackdir from the TrackdirBits or INVALID_TRACKDIR on TRACKDIR_BIT_NONE.

   372

 * @pre trackdirs must not be INVALID_TRACKDIR_BIT

   373

 * @see RemoveFirstTrackdir

   374

 */

   375

static inline Trackdir FindFirstTrackdir(TrackdirBits trackdirs)

   376

{

   377

	assert((trackdirs & ~TRACKDIR_BIT_MASK) == TRACKDIR_BIT_NONE);

   378

	return (trackdirs != TRACKDIR_BIT_NONE) ? (Trackdir)FindFirstBit2x64(trackdirs) : INVALID_TRACKDIR;

   379

}

   380

   381

/**

   382

 * Checks if a Track is valid.

   383

 *

   384

 * @param track The value to check

   385

 * @return true if the given value is a valid track.

   386

 * @note Use this in an assert()

   387

 */

   388

static inline bool IsValidTrack(Track track)

   389

{

   390

	return track < TRACK_END;

   391

}

   392

   393

/**

   394

 * Checks if a Trackdir is valid.

   395

 *

   396

 * @param trackdir The value to check

   397

 * @return true if the given valie is a valid Trackdir

   398

 * @note Use this in an assert()

   399

 */

   400

static inline bool IsValidTrackdir(Trackdir trackdir)

   401

{

   402

	return (TrackdirToTrackdirBits(trackdir) & TRACKDIR_BIT_MASK) != 0;

   403

}

   404

   405

/*

   406

 * Functions to map tracks to the corresponding bits in the signal

   407

 * presence/status bytes in the map. You should not use these directly, but

   408

 * wrapper functions below instead. XXX: Which are these?

   409

 */

   410

   411

/**

   412

 * Maps a trackdir to the bit that stores its status in the map arrays, in the

   413

 * direction along with the trackdir.

   414

 */

   415

static inline byte SignalAlongTrackdir(Trackdir trackdir)

   416

{

   417

	extern const byte _signal_along_trackdir[TRACKDIR_END];

   418

	return _signal_along_trackdir[trackdir];

   419

}

   420

   421

/**

   422

 * Maps a trackdir to the bit that stores its status in the map arrays, in the

   423

 * direction against the trackdir.

   424

 */

   425

static inline byte SignalAgainstTrackdir(Trackdir trackdir)

   426

{

   427

	extern const byte _signal_against_trackdir[TRACKDIR_END];

   428

	return _signal_against_trackdir[trackdir];

   429

}

   430

   431

/**

   432

 * Maps a Track to the bits that store the status of the two signals that can

   433

 * be present on the given track.

   434

 */

   435

static inline byte SignalOnTrack(Track track)

   436

{

   437

	extern const byte _signal_on_track[TRACK_END];

   438

	return _signal_on_track[track];

   439

}

   440

   441

   442

/*

   443

 * Functions describing logical relations between Tracks, TrackBits, Trackdirs

   444

 * TrackdirBits, Direction and DiagDirections.

   445

 */

   446

   447

/**

   448

 * Maps a trackdir to the reverse trackdir.

   449

 *

   450

 * Returns the reverse trackdir of a Trackdir value. The reverse trackdir

   451

 * is the same track with the other direction on it.

   452

 *

   453

 * @param trackdir The Trackdir value

   454

 * @return The reverse trackdir

   455

 * @pre trackdir must not be INVALID_TRACKDIR

   456

 */

   457

static inline Trackdir ReverseTrackdir(Trackdir trackdir)

   458

{

   459

	assert(trackdir != INVALID_TRACKDIR);

   460

	return (Trackdir)(trackdir ^ 8);

   461

}

   462

   463

/**

   464

 * Returns the Track that a given Trackdir represents

   465

 *

   466

 * This function filters the Track which is used in the Trackdir value and

   467

 * returns it as a Track value.

   468

 *

   469

 * @param trackdir The trackdir value

   470

 * @return The Track which is used in the value

   471

 */

   472

static inline Track TrackdirToTrack(Trackdir trackdir)

   473

{

   474

	return (Track)(trackdir & 0x7);

   475

}

   476

   477

/**

   478

 * Returns a Trackdir for the given Track

   479

 *

   480

 * Since every Track corresponds to two Trackdirs, we choose the

   481

 * one which points between NE and S. Note that the actual

   482

 * implementation is quite futile, but this might change

   483

 * in the future.

   484

 *

   485

 * @param track The given Track

   486

 * @return The Trackdir from the given Track

   487

 */

   488

static inline Trackdir TrackToTrackdir(Track track)

   489

{

   490

	return (Trackdir)track;