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

#include "variables.h"

    12

    13

/**

    14

 * Enumeration for all possible railtypes.

    15

 *

    16

 * This enumeration defines all 4 possible railtypes.

    17

 */

    18

enum RailType {

    19

	RAILTYPE_BEGIN    = 0,          ///< Used for iterations

    20

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

    21

	RAILTYPE_ELECTRIC = 1,          ///< Electric rails

    22

	RAILTYPE_MONO     = 2,          ///< Monorail

    23

	RAILTYPE_MAGLEV   = 3,          ///< Maglev

    24

	RAILTYPE_END,                   ///< Used for iterations

    25

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

    26

};

    27

    28

typedef byte RailTypeMask;

    29

    30

/** Allow incrementing of Track variables */

    31

DECLARE_POSTFIX_INCREMENT(RailType);

    32

/** Define basic enum properties */

    33

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

    34

typedef TinyEnumT<RailType> RailTypeByte;

    35

    36

    37

/**

    38

 * These are used to specify a single track.

    39

 * Can be translated to a trackbit with TrackToTrackbit

    40

 */

    41

enum Track {

    42

	TRACK_BEGIN = 0,        ///< Used for iterations

    43

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

    44

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

    45

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

    46

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

    47

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

    48

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

    49

	TRACK_END,              ///< Used for iterations

    50

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

    51

};

    52

    53

/** Allow incrementing of Track variables */

    54

DECLARE_POSTFIX_INCREMENT(Track);

    55

/** Define basic enum properties */

    56

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

    57

typedef TinyEnumT<Track> TrackByte;

    58

    59

    60

/**

    61

 * Convert an Axis to the corresponding Track

    62

 * AXIS_X -> TRACK_X

    63

 * AXIS_Y -> TRACK_Y

    64

 * Uses the fact that they share the same internal encoding

    65

 *

    66

 * @param a the axis to convert

    67

 * @return the track corresponding to the axis

    68

 */

    69

static inline Track AxisToTrack(Axis a)

    70

{

    71

	return (Track)a;

    72

}

    73

    74

    75

/** Bitfield corresponding to Track */

    76

enum TrackBits {

    77

	TRACK_BIT_NONE    = 0U,                                                 ///< No track

    78

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

    79

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

    80

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

    81

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

    82

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

    83

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

    84

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

    85

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

    86

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

    87

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

    88

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

    89

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

    90

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

    91

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

    92

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

    93

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

    94

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

    95

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

    96

};

    97

    98

/** Define basic enum properties */

    99

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

   100

typedef TinyEnumT<TrackBits> TrackBitsByte;

   101

   102

DECLARE_ENUM_AS_BIT_SET(TrackBits);

   103

   104

/**

   105

 * Maps a Track to the corresponding TrackBits value

   106

 * @param track the track to convert

   107

 * @return the converted TrackBits value of the track

   108

 */

   109

static inline TrackBits TrackToTrackBits(Track track)

   110

{

   111

	return (TrackBits)(1 << track);

   112

}

   113

   114

/**

   115

 * Maps an Axis to the corresponding TrackBits value

   116

 * @param a the axis to convert

   117

 * @return the converted TrackBits value of the axis

   118

 */

   119

static inline TrackBits AxisToTrackBits(Axis a)

   120

{

   121

	return TrackToTrackBits(AxisToTrack(a));

   122

}

   123

   124

/**

   125

 * Returns a single horizontal/vertical trackbit, that is in a specific tile corner.

   126

 *

   127

 * @param corner The corner of a tile.

   128

 * @return The TrackBits of the track in the corner.

   129

 */

   130

static inline TrackBits CornerToTrackBits(Corner corner)

   131

{

   132

	extern const TrackBits _corner_to_trackbits[];

   133

	assert(IsValidCorner(corner));

   134

	return _corner_to_trackbits[corner];

   135

}

   136

   137

   138

/**

   139

 * Enumeration for tracks and directions.

   140

 *

   141

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

   142

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

   143

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

   144

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

   145

 * corner in the road vehicle controller.

   146

 */

   147

enum Trackdir {

   148

	TRACKDIR_BEGIN    =  0,         ///< Used for iterations

   149

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

   150

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

   151

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

   152

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

   153

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

   154

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

   155

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

   156

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

   157

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

   158

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

   159

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

   160

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

   161

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

   162

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

   163

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

   164

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

   165

	TRACKDIR_END,                   ///< Used for iterations

   166

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

   167

};

   168

   169

/** Define basic enum properties */

   170

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

   171

typedef TinyEnumT<Trackdir> TrackdirByte;

   172

   173

/**

   174

 * Enumeration of bitmasks for the TrackDirs

   175

 *

   176

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

   177

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

   178

 */

   179

enum TrackdirBits {

   180

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

   181

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

   182

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

   183

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

   184

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

   185

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

   186

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

   187

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

   188

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

   189

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

   190

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

   191

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

   192

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

   193

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

   194

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

   195

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

   196

};

   197

   198

/** Define basic enum properties */

   199

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

   200

typedef TinyEnumT<TrackdirBits> TrackdirBitsShort;

   201

DECLARE_ENUM_AS_BIT_SET(TrackdirBits);

   202

   203

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

   204

 */

   205

struct RailtypeInfo {

   206

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

   207

	 *  the ones used directly in the code */

   208

	struct {

   209

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

   210

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

   211

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

   212

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

   213

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

   214

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

   215

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

   216

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

   217

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

   218

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

   219

		SpriteID tunnel;       ///< tunnel sprites base

   220

	} base_sprites;

   221

   222

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

   223

	 * directly in the code are listed */

   224

	struct {

   225

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

   226

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

   227

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

   228

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

   229

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

   230

		SpriteID build_depot;        ///< button for building depots

   231

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

   232

		SpriteID convert_rail;       ///< button for converting rail

   233

	} gui_sprites;

   234

   235

	struct {

   236

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

   237

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

   238

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

   239

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

   240

		CursorID autorail;   ///< Cursor for autorail tool

   241

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

   242

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

   243

		CursorID convert;    ///< Cursor for converting track

   244

	} cursor;

   245

   246

	struct {

   247

		StringID toolbar_caption;

   248

	} strings;

   249

   250

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

   251

	SpriteID snow_offset;

   252

   253

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

   254

	RailTypeMask powered_railtypes;

   255

   256

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

   257

	RailTypeMask compatible_railtypes;

   258

   259

	/**

   260

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

   261

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

   262

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

   263

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

   264

	 *    the offset will fail.

   265

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

   266

	 */

   267

	SpriteID total_offset;

   268

   269

	/**

   270

	 * Bridge offset

   271

	 */

   272

	SpriteID bridge_offset;

   273

   274

	/**

   275

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

   276

	 */

   277

	byte custom_ground_offset;

   278

};

   279

   280

   281

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

   282

enum {

   283

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

   284

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

   285

};

   286

   287

/**

   288

 * Maps a Trackdir to the corresponding TrackdirBits value

   289

 * @param trackdir the track direction to convert

   290

 * @return the converted TrackdirBits value

   291

 */

   292

static inline TrackdirBits TrackdirToTrackdirBits(Trackdir trackdir)

   293

{

   294

	return (TrackdirBits)(1 << trackdir);

   295

}

   296

   297

/**

   298

 * Removes first Track from TrackBits and returns it

   299

 *

   300

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

   301

 * remove this bit from the parameter and returns the found

   302

 * bit as Track value. It returns INVALID_TRACK if the

   303

 * parameter was TRACK_BIT_NONE or INVALID_TRACK_BIT. This

   304

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

   305

 * tracks on a tile until the parameter becomes TRACK_BIT_NONE.

   306

 *

   307

 * @param tracks The value with the TrackBits

   308

 * @return The first Track from the TrackBits value

   309

 * @see FindFirstTrack

   310

 */

   311

static inline Track RemoveFirstTrack(TrackBits *tracks)

   312

{

   313

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

   314

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

   315

		ClrBitT(*tracks, first);

   316

		return first;

   317

	}

   318

	return INVALID_TRACK;

   319

}

   320

   321

/**

   322

 * Removes first Trackdir from TrackdirBits and returns it

   323

 *

   324

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

   325

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

   326

 * Trackdir value. It returns INVALID_TRACKDIR if the trackdirs is

   327

 * TRACKDIR_BIT_NONE or INVALID_TRACKDIR_BIT. This is basically used in a

   328

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

   329

 * reaches TRACKDIR_BIT_NONE.

   330

 *

   331

 * @param trackdirs The value with the TrackdirBits

   332

 * @return The first Trackdir from the TrackdirBits value

   333

 * @see FindFirstTrackdir

   334

 */

   335

static inline Trackdir RemoveFirstTrackdir(TrackdirBits *trackdirs)

   336

{

   337

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

   338

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

   339

		ClrBitT(*trackdirs, first);

   340

		return first;

   341

	}

   342

	return INVALID_TRACKDIR;

   343

}

   344

   345

/**

   346

 * Returns first Track from TrackBits or INVALID_TRACK

   347

 *

   348

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

   349

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

   350

 *

   351

 * @param tracks The TrackBits value

   352

 * @return The first Track found or INVALID_TRACK

   353

 * @see RemoveFirstTrack

   354

 */

   355

static inline Track FindFirstTrack(TrackBits tracks)

   356

{

   357

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

   358

}

   359

   360

/**

   361

 * Converts TrackBits to Track.

   362

 *

   363

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

   364

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

   365

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

   366

 *

   367

 * @param tracks The TrackBits value to convert

   368

 * @return The Track from the value or INVALID_TRACK

   369

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

   370

 */

   371

static inline Track TrackBitsToTrack(TrackBits tracks)

   372

{

   373

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

   374

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

   375

}

   376

   377

/**

   378

 * Returns first Trackdir from TrackdirBits or INVALID_TRACKDIR

   379

 *

   380

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

   381

 * INVALID_TRACKDIR if the value is TRACKDIR_BIT_NONE. The TrackdirBits must

   382

 * not be INVALID_TRACKDIR_BIT.

   383

 *

   384

 * @param trackdirs The TrackdirBits value

   385

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

   386

 * @pre trackdirs must not be INVALID_TRACKDIR_BIT

   387

 * @see RemoveFirstTrackdir

   388

 */

   389

static inline Trackdir FindFirstTrackdir(TrackdirBits trackdirs)

   390

{

   391

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

   392

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

   393

}

   394

   395

/**

   396

 * Checks if a Track is valid.

   397

 *

   398

 * @param track The value to check

   399

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

   400

 * @note Use this in an assert()

   401

 */

   402

static inline bool IsValidTrack(Track track)

   403

{

   404

	return track < TRACK_END;

   405

}

   406

   407

/**

   408

 * Checks if a Trackdir is valid.

   409

 *

   410

 * @param trackdir The value to check

   411

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

   412

 * @note Use this in an assert()

   413

 */

   414

static inline bool IsValidTrackdir(Trackdir trackdir)

   415

{

   416

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

   417

}

   418

   419

/*

   420

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

   421

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

   422

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

   423

 */

   424

   425

/**

   426

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

   427

 * direction along with the trackdir.

   428

 */

   429

static inline byte SignalAlongTrackdir(Trackdir trackdir)

   430

{

   431

	extern const byte _signal_along_trackdir[TRACKDIR_END];

   432

	return _signal_along_trackdir[trackdir];

   433

}

   434

   435

/**

   436

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

   437

 * direction against the trackdir.

   438

 */

   439

static inline byte SignalAgainstTrackdir(Trackdir trackdir)

   440

{

   441

	extern const byte _signal_against_trackdir[TRACKDIR_END];

   442

	return _signal_against_trackdir[trackdir];

   443

}

   444

   445

/**

   446

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

   447

 * be present on the given track.

   448

 */

   449

static inline byte SignalOnTrack(Track track)

   450

{

   451

	extern const byte _signal_on_track[TRACK_END];

   452

	return _signal_on_track[track];

   453

}

   454

   455

   456

/*

   457

 * Functions describing logical relations between Tracks, TrackBits, Trackdirs

   458

 * TrackdirBits, Direction and DiagDirections.

   459

 */

   460

   461

/**

   462

 * Maps a trackdir to the reverse trackdir.

   463

 *

   464

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

   465

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

   466

 *

   467

 * @param trackdir The Trackdir value

   468

 * @return The reverse trackdir

   469

 * @pre trackdir must not be INVALID_TRACKDIR

   470

 */

   471

static inline Trackdir ReverseTrackdir(Trackdir trackdir)

   472

{

   473

	assert(trackdir != INVALID_TRACKDIR);

   474

	return (Trackdir)(trackdir ^ 8);

   475

}

   476

   477

/**

   478

 * Returns the Track that a given Trackdir represents

   479

 *

   480

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

   481

 * returns it as a Track value.

   482

 *

   483

 * @param trackdir The trackdir value

   484

 * @return The Track which is used in the value

   485

 */

   486

static inline Track TrackdirToTrack(Trackdir trackdir)

   487

{

   488

	return (Track)(trackdir & 0x7);

   489

}

   490