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

   136

   137

/**

   138

 * Enumeration for tracks and directions.

   139

 *

   140

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

   141

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

   142

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

   143

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

   144

 * corner in the road vehicle controller.

   145

 */

   146

enum Trackdir {

   147

	TRACKDIR_BEGIN    =  0,         ///< Used for iterations

   148

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

   149

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

   150

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

   151

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

   152

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

   153

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

   154

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

   155

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

   156

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

   157

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

   158

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

   159

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

   160

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

   161

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

   162

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

   163

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

   164

	TRACKDIR_END,                   ///< Used for iterations

   165

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

   166

};

   167

   168

/** Define basic enum properties */

   169

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

   170

typedef TinyEnumT<Trackdir> TrackdirByte;

   171

   172

/**

   173

 * Enumeration of bitmasks for the TrackDirs

   174

 *

   175

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

   176

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

   177

 */

   178

enum TrackdirBits {

   179

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

   180

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

   181

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

   182

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

   183

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

   184

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

   185

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

   186

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

   187

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

   188

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

   189

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

   190

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

   191

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

   192

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

   193

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

   194

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

   195

};

   196

   197

/** Define basic enum properties */

   198

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

   199

typedef TinyEnumT<TrackdirBits> TrackdirBitsShort;

   200

DECLARE_ENUM_AS_BIT_SET(TrackdirBits);

   201

   202

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

   203

 */

   204

struct RailtypeInfo {

   205

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

   206

	 *  the ones used directly in the code */

   207

	struct {

   208

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

   209

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

   210

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

   211

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

   212

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

   213

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

   214

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

   215

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

   216

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

   217

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

   218

		SpriteID tunnel;       ///< tunnel sprites base

   219

	} base_sprites;

   220

   221

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

   222

	 * directly in the code are listed */

   223

	struct {

   224

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

   225

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

   226

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

   227

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

   228

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

   229

		SpriteID build_depot;        ///< button for building depots

   230

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

   231

		SpriteID convert_rail;       ///< button for converting rail

   232

	} gui_sprites;

   233

   234

	struct {

   235

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

   236

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

   237

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

   238

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

   239

		CursorID autorail;   ///< Cursor for autorail tool

   240

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

   241

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

   242

		CursorID convert;    ///< Cursor for converting track

   243

	} cursor;

   244

   245

	struct {

   246

		StringID toolbar_caption;

   247

	} strings;

   248

   249

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

   250

	SpriteID snow_offset;

   251

   252

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

   253

	RailTypeMask powered_railtypes;

   254

   255

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

   256

	RailTypeMask compatible_railtypes;

   257

   258

	/**

   259

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

   260

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

   261

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

   262

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

   263

	 *    the offset will fail.

   264

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

   265

	 */

   266

	SpriteID total_offset;

   267

   268

	/**

   269

	 * Bridge offset

   270

	 */

   271

	SpriteID bridge_offset;

   272

   273

	/**

   274

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

   275

	 */

   276

	byte custom_ground_offset;

   277

};

   278

   279

   280

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

   281

enum {

   282

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

   283

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

   284

};

   285

   286

/**

   287

 * Maps a Trackdir to the corresponding TrackdirBits value

   288

 * @param trackdir the track direction to convert

   289

 * @return the converted TrackdirBits value

   290

 */

   291

static inline TrackdirBits TrackdirToTrackdirBits(Trackdir trackdir)

   292

{

   293

	return (TrackdirBits)(1 << trackdir);

   294

}

   295

   296

/**

   297

 * Removes first Track from TrackBits and returns it

   298

 *

   299

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

   300

 * remove this bit from the parameter and returns the found

   301

 * bit as Track value. It returns INVALID_TRACK if the

   302

 * parameter was TRACK_BIT_NONE or INVALID_TRACK_BIT. This

   303

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

   304

 * tracks on a tile until the parameter becomes TRACK_BIT_NONE.

   305

 *

   306

 * @param tracks The value with the TrackBits

   307

 * @return The first Track from the TrackBits value

   308

 * @see FindFirstTrack

   309

 */

   310

static inline Track RemoveFirstTrack(TrackBits *tracks)

   311

{

   312

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

   313

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

   314

		ClrBitT(*tracks, first);

   315

		return first;

   316

	}

   317

	return INVALID_TRACK;

   318

}

   319

   320

/**

   321

 * Removes first Trackdir from TrackdirBits and returns it

   322

 *

   323

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

   324

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

   325

 * Trackdir value. It returns INVALID_TRACKDIR if the trackdirs is

   326

 * TRACKDIR_BIT_NONE or INVALID_TRACKDIR_BIT. This is basically used in a

   327

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

   328

 * reaches TRACKDIR_BIT_NONE.

   329

 *

   330

 * @param trackdirs The value with the TrackdirBits

   331

 * @return The first Trackdir from the TrackdirBits value

   332

 * @see FindFirstTrackdir

   333

 */

   334

static inline Trackdir RemoveFirstTrackdir(TrackdirBits *trackdirs)

   335

{

   336

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

   337

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

   338

		ClrBitT(*trackdirs, first);

   339

		return first;

   340

	}

   341

	return INVALID_TRACKDIR;

   342

}

   343

   344

/**

   345

 * Returns first Track from TrackBits or INVALID_TRACK

   346

 *

   347

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

   348

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

   349

 *

   350

 * @param tracks The TrackBits value

   351

 * @return The first Track found or INVALID_TRACK

   352

 * @see RemoveFirstTrack

   353

 */

   354

static inline Track FindFirstTrack(TrackBits tracks)

   355

{

   356

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

   357

}

   358

   359

/**

   360

 * Converts TrackBits to Track.

   361

 *

   362

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

   363

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

   364

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

   365

 *

   366

 * @param tracks The TrackBits value to convert

   367

 * @return The Track from the value or INVALID_TRACK

   368

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

   369

 */

   370

static inline Track TrackBitsToTrack(TrackBits tracks)

   371

{

   372

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

   373

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

   374

}

   375

   376

/**

   377

 * Returns first Trackdir from TrackdirBits or INVALID_TRACKDIR

   378

 *

   379

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

   380

 * INVALID_TRACKDIR if the value is TRACKDIR_BIT_NONE. The TrackdirBits must

   381

 * not be INVALID_TRACKDIR_BIT.

   382

 *

   383

 * @param trackdirs The TrackdirBits value

   384

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

   385

 * @pre trackdirs must not be INVALID_TRACKDIR_BIT

   386

 * @see RemoveFirstTrackdir

   387

 */

   388

static inline Trackdir FindFirstTrackdir(TrackdirBits trackdirs)

   389

{

   390

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

   391

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

   392

}

   393

   394

/**

   395

 * Checks if a Track is valid.

   396

 *

   397

 * @param track The value to check

   398

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

   399

 * @note Use this in an assert()

   400

 */

   401

static inline bool IsValidTrack(Track track)

   402

{

   403

	return track < TRACK_END;

   404

}

   405

   406

/**

   407

 * Checks if a Trackdir is valid.

   408

 *

   409

 * @param trackdir The value to check

   410

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

   411

 * @note Use this in an assert()

   412

 */

   413

static inline bool IsValidTrackdir(Trackdir trackdir)

   414

{

   415

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

   416

}

   417

   418

/*

   419

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

   420

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

   421

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

   422

 */

   423

   424

/**

   425

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

   426

 * direction along with the trackdir.

   427

 */

   428

static inline byte SignalAlongTrackdir(Trackdir trackdir)

   429

{

   430

	extern const byte _signal_along_trackdir[TRACKDIR_END];

   431

	return _signal_along_trackdir[trackdir];

   432

}

   433

   434

/**

   435

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

   436

 * direction against the trackdir.

   437

 */

   438

static inline byte SignalAgainstTrackdir(Trackdir trackdir)

   439

{

   440

	extern const byte _signal_against_trackdir[TRACKDIR_END];

   441

	return _signal_against_trackdir[trackdir];

   442

}

   443

   444

/**

   445

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

   446

 * be present on the given track.

   447

 */

   448

static inline byte SignalOnTrack(Track track)

   449

{

   450

	extern const byte _signal_on_track[TRACK_END];

   451

	return _signal_on_track[track];

   452

}

   453

   454

   455

/*

   456

 * Functions describing logical relations between Tracks, TrackBits, Trackdirs

   457

 * TrackdirBits, Direction and DiagDirections.

   458

 */

   459

   460

/**

   461

 * Maps a trackdir to the reverse trackdir.

   462

 *

   463

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

   464

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

   465

 *

   466

 * @param trackdir The Trackdir value

   467

 * @return The reverse trackdir

   468

 * @pre trackdir must not be INVALID_TRACKDIR

   469

 */

   470

static inline Trackdir ReverseTrackdir(Trackdir trackdir)

   471

{

   472

	assert(trackdir != INVALID_TRACKDIR);

   473

	return (Trackdir)(trackdir ^ 8);

   474

}

   475

   476

/**

   477

 * Returns the Track that a given Trackdir represents

   478

 *

   479

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

   480

 * returns it as a Track value.

   481

 *

   482

 * @param trackdir The trackdir value

   483

 * @return The Track which is used in the value

   484

 */

   485

static inline Track TrackdirToTrack(Trackdir trackdir)

   486

{

   487

	return (Track)(trackdir & 0x7);

   488

}

   489

   490

/**