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

enum RailType {

    13

	RAILTYPE_BEGIN    = 0,

    14

	RAILTYPE_RAIL     = 0,

    15

	RAILTYPE_ELECTRIC = 1,

    16

	RAILTYPE_MONO     = 2,

    17

	RAILTYPE_MAGLEV   = 3,

    18

	RAILTYPE_END,

    19

	INVALID_RAILTYPE  = 0xFF

    20

};

    21

    22

typedef byte RailTypeMask;

    23

    24

/** Allow incrementing of Track variables */

    25

DECLARE_POSTFIX_INCREMENT(RailType);

    26

/** Define basic enum properties */

    27

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

    28

typedef TinyEnumT<RailType> RailTypeByte;

    29

    30

    31

/** These are used to specify a single track.

    32

 * Can be translated to a trackbit with TrackToTrackbit */

    33

enum Track {

    34

	TRACK_BEGIN = 0,

    35

	TRACK_X     = 0,

    36

	TRACK_Y     = 1,

    37

	TRACK_UPPER = 2,

    38

	TRACK_LOWER = 3,

    39

	TRACK_LEFT  = 4,

    40

	TRACK_RIGHT = 5,

    41

	TRACK_END,

    42

	INVALID_TRACK = 0xFF

    43

};

    44

    45

/** Allow incrementing of Track variables */

    46

DECLARE_POSTFIX_INCREMENT(Track);

    47

/** Define basic enum properties */

    48

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

    49

typedef TinyEnumT<Track> TrackByte;

    50

    51

    52

/** Convert an Axis to the corresponding Track

    53

 * AXIS_X -> TRACK_X

    54

 * AXIS_Y -> TRACK_Y

    55

 * Uses the fact that they share the same internal encoding

    56

 */

    57

static inline Track AxisToTrack(Axis a)

    58

{

    59

	return (Track)a;

    60

}

    61

    62

    63

/** Bitfield corresponding to Track */

    64

enum TrackBits {

    65

	TRACK_BIT_NONE    = 0U,

    66

	TRACK_BIT_X       = 1U << TRACK_X,

    67

	TRACK_BIT_Y       = 1U << TRACK_Y,

    68

	TRACK_BIT_UPPER   = 1U << TRACK_UPPER,

    69

	TRACK_BIT_LOWER   = 1U << TRACK_LOWER,

    70

	TRACK_BIT_LEFT    = 1U << TRACK_LEFT,

    71

	TRACK_BIT_RIGHT   = 1U << TRACK_RIGHT,

    72

	TRACK_BIT_CROSS   = TRACK_BIT_X     | TRACK_BIT_Y,

    73

	TRACK_BIT_HORZ    = TRACK_BIT_UPPER | TRACK_BIT_LOWER,

    74

	TRACK_BIT_VERT    = TRACK_BIT_LEFT  | TRACK_BIT_RIGHT,

    75

	TRACK_BIT_3WAY_NE = TRACK_BIT_X     | TRACK_BIT_UPPER | TRACK_BIT_RIGHT,

    76

	TRACK_BIT_3WAY_SE = TRACK_BIT_Y     | TRACK_BIT_LOWER | TRACK_BIT_RIGHT,

    77

	TRACK_BIT_3WAY_SW = TRACK_BIT_X     | TRACK_BIT_LOWER | TRACK_BIT_LEFT,

    78

	TRACK_BIT_3WAY_NW = TRACK_BIT_Y     | TRACK_BIT_UPPER | TRACK_BIT_LEFT,

    79

	TRACK_BIT_ALL     = TRACK_BIT_CROSS | TRACK_BIT_HORZ  | TRACK_BIT_VERT,

    80

	TRACK_BIT_MASK    = 0x3FU,

    81

	TRACK_BIT_WORMHOLE = 0x40U,

    82

	TRACK_BIT_DEPOT   = 0x80U,

    83

	INVALID_TRACK_BIT = 0xFF

    84

};

    85

    86

/** Define basic enum properties */

    87

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

    88

typedef TinyEnumT<TrackBits> TrackBitsByte;

    89

    90

DECLARE_ENUM_AS_BIT_SET(TrackBits);

    91

    92

/**

    93

 * Maps a Track to the corresponding TrackBits value

    94

 */

    95

static inline TrackBits TrackToTrackBits(Track track)

    96

{

    97

	return (TrackBits)(1 << track);

    98

}

    99

   100

   101

static inline TrackBits AxisToTrackBits(Axis a)

   102

{

   103

	return TrackToTrackBits(AxisToTrack(a));

   104

}

   105

   106

   107

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

   108

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

   109

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

   110

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

   111

 * corner in the road vehicle controller.

   112

 */

   113

enum Trackdir {

   114

	TRACKDIR_BEGIN    =  0,

   115

	TRACKDIR_X_NE     =  0,

   116

	TRACKDIR_Y_SE     =  1,

   117

	TRACKDIR_UPPER_E  =  2,

   118

	TRACKDIR_LOWER_E  =  3,

   119

	TRACKDIR_LEFT_S   =  4,

   120

	TRACKDIR_RIGHT_S  =  5,

   121

	TRACKDIR_RVREV_NE =  6,

   122

	TRACKDIR_RVREV_SE =  7,

   123

	TRACKDIR_X_SW     =  8,

   124

	TRACKDIR_Y_NW     =  9,

   125

	TRACKDIR_UPPER_W  = 10,

   126

	TRACKDIR_LOWER_W  = 11,

   127

	TRACKDIR_LEFT_N   = 12,

   128

	TRACKDIR_RIGHT_N  = 13,

   129

	TRACKDIR_RVREV_SW = 14,

   130

	TRACKDIR_RVREV_NW = 15,

   131

	TRACKDIR_END,

   132

	INVALID_TRACKDIR  = 0xFF,

   133

};

   134

   135

/** Define basic enum properties */

   136

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

   137

typedef TinyEnumT<Trackdir> TrackdirByte;

   138

   139

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

   140

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

   141

enum TrackdirBits {

   142

	TRACKDIR_BIT_NONE     = 0x0000,

   143

	TRACKDIR_BIT_X_NE     = 0x0001,

   144

	TRACKDIR_BIT_Y_SE     = 0x0002,

   145

	TRACKDIR_BIT_UPPER_E  = 0x0004,

   146

	TRACKDIR_BIT_LOWER_E  = 0x0008,

   147

	TRACKDIR_BIT_LEFT_S   = 0x0010,

   148

	TRACKDIR_BIT_RIGHT_S  = 0x0020,

   149

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

   150

	TRACKDIR_BIT_X_SW     = 0x0100,

   151

	TRACKDIR_BIT_Y_NW     = 0x0200,

   152

	TRACKDIR_BIT_UPPER_W  = 0x0400,

   153

	TRACKDIR_BIT_LOWER_W  = 0x0800,

   154

	TRACKDIR_BIT_LEFT_N   = 0x1000,

   155

	TRACKDIR_BIT_RIGHT_N  = 0x2000,

   156

	TRACKDIR_BIT_MASK     = 0x3F3F,

   157

	INVALID_TRACKDIR_BIT  = 0xFFFF,

   158

};

   159

   160

/** Define basic enum properties */

   161

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

   162

typedef TinyEnumT<TrackdirBits> TrackdirBitsShort;

   163

DECLARE_ENUM_AS_BIT_SET(TrackdirBits);

   164

   165

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

   166

 */

   167

struct RailtypeInfo {

   168

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

   169

	 *  the ones used directly in the code */

   170

	struct {

   171

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

   172

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

   173

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

   174

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

   175

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

   176

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

   177

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

   178

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

   179

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

   180

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

   181

		SpriteID tunnel;       ///< tunnel sprites base

   182

	} base_sprites;

   183

   184

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

   185

	 * directly in the code are listed */

   186

	struct {

   187

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

   188

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

   189

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

   190

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

   191

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

   192

		SpriteID build_depot;        ///< button for building depots

   193

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

   194

		SpriteID convert_rail;       ///< button for converting rail

   195

	} gui_sprites;

   196

   197

	struct {

   198

		CursorID rail_ns;

   199

		CursorID rail_swne;

   200

		CursorID rail_ew;

   201

		CursorID rail_nwse;

   202

		CursorID autorail;

   203

		CursorID depot;

   204

		CursorID tunnel;

   205

		CursorID convert;

   206

	} cursor;

   207

   208

	struct {

   209

		StringID toolbar_caption;

   210

	} strings;

   211

   212

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

   213

	SpriteID snow_offset;

   214

   215

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

   216

	RailTypeMask powered_railtypes;

   217

   218

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

   219

	RailTypeMask compatible_railtypes;

   220

   221

	/**

   222

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

   223

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

   224

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

   225

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

   226

	 *    the offset will fail.

   227

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

   228

	 */

   229

	SpriteID total_offset;

   230

   231

	/**

   232

	 * Bridge offset

   233

	 */

   234

	SpriteID bridge_offset;

   235

   236

	/**

   237

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

   238

	 */

   239

	byte custom_ground_offset;

   240

};

   241

   242

   243

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

   244

enum {

   245

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

   246

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

   247

};

   248

   249

/**

   250

 * Maps a Trackdir to the corresponding TrackdirBits value

   251

 */

   252

static inline TrackdirBits TrackdirToTrackdirBits(Trackdir trackdir) { return (TrackdirBits)(1 << trackdir); }

   253

   254

/**

   255

* Removes first Track from TrackBits and returns it

   256

*/

   257

static inline Track RemoveFirstTrack(TrackBits *tracks)

   258

{

   259

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

   260

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

   261

		ClrBitT(*tracks, first);

   262

		return first;

   263

	}

   264

	return INVALID_TRACK;

   265

}

   266

   267

/**

   268

* Removes first Trackdir from TrackdirBits and returns it

   269

*/

   270

static inline Trackdir RemoveFirstTrackdir(TrackdirBits *trackdirs)

   271

{

   272

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

   273

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

   274

		ClrBitT(*trackdirs, first);

   275

		return first;

   276

	}

   277

	return INVALID_TRACKDIR;

   278

}

   279

   280

/**

   281

* Returns first Track from TrackBits or INVALID_TRACK

   282

*/

   283

static inline Track FindFirstTrack(TrackBits tracks)

   284

{

   285

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

   286

}

   287

   288

/**

   289

* Converts TrackBits to Track. TrackBits must contain just one Track or INVALID_TRACK_BIT!

   290

*/

   291

static inline Track TrackBitsToTrack(TrackBits tracks)

   292

{

   293

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

   294

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

   295

}

   296

   297

/**

   298

* Returns first Trackdir from TrackdirBits or INVALID_TRACKDIR

   299

*/

   300

static inline Trackdir FindFirstTrackdir(TrackdirBits trackdirs)

   301

{

   302

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

   303

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

   304

}

   305

   306

/**

   307

 * These functions check the validity of Tracks and Trackdirs. assert against

   308

 * them when convenient.

   309

 */

   310

static inline bool IsValidTrack(Track track) { return track < TRACK_END; }

   311

static inline bool IsValidTrackdir(Trackdir trackdir) { return (TrackdirToTrackdirBits(trackdir) & TRACKDIR_BIT_MASK) != 0; }

   312

   313

/**

   314

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

   315

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

   316

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

   317

 */

   318

   319

/**

   320

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

   321

 * direction along with the trackdir.

   322

 */

   323

static inline byte SignalAlongTrackdir(Trackdir trackdir)

   324

{

   325

	extern const byte _signal_along_trackdir[TRACKDIR_END];

   326

	return _signal_along_trackdir[trackdir];

   327

}

   328

   329

/**

   330

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

   331

 * direction against the trackdir.

   332

 */

   333

static inline byte SignalAgainstTrackdir(Trackdir trackdir)

   334

{

   335

	extern const byte _signal_against_trackdir[TRACKDIR_END];

   336

	return _signal_against_trackdir[trackdir];

   337

}

   338

   339

/**

   340

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

   341

 * be present on the given track.

   342

 */

   343

static inline byte SignalOnTrack(Track track)

   344

{

   345

	extern const byte _signal_on_track[TRACK_END];

   346

	return _signal_on_track[track];

   347

}

   348

   349

   350

/*

   351

 * Functions describing logical relations between Tracks, TrackBits, Trackdirs

   352

 * TrackdirBits, Direction and DiagDirections.

   353

 */

   354

   355

/**

   356

 * Maps a trackdir to the reverse trackdir.

   357

 */

   358

static inline Trackdir ReverseTrackdir(Trackdir trackdir)

   359

{

   360

	assert(trackdir != INVALID_TRACKDIR);

   361

	return (Trackdir)(trackdir ^ 8);

   362

}

   363

   364

/**

   365

 * Returns the Track that a given Trackdir represents

   366

 */

   367

static inline Track TrackdirToTrack(Trackdir trackdir) { return (Track)(trackdir & 0x7); }

   368

   369

/**

   370

 * Returns a Trackdir for the given Track. Since every Track corresponds to

   371

 * two Trackdirs, we choose the one which points between NE and S.

   372

 * Note that the actual implementation is quite futile, but this might change

   373

 * in the future.

   374

 */

   375

static inline Trackdir TrackToTrackdir(Track track) { return (Trackdir)track; }

   376

   377

/**

   378

 * Returns a TrackdirBit mask that contains the two TrackdirBits that

   379

 * correspond with the given Track (one for each direction).

   380

 */

   381

static inline TrackdirBits TrackToTrackdirBits(Track track)

   382

{

   383

	Trackdir td = TrackToTrackdir(track);

   384

	return (TrackdirBits)(TrackdirToTrackdirBits(td) | TrackdirToTrackdirBits(ReverseTrackdir(td)));

   385

}

   386

   387

/**

   388

 * Discards all directional information from the given TrackdirBits. Any

   389

 * Track which is present in either direction will be present in the result.

   390

 */

   391

static inline TrackBits TrackdirBitsToTrackBits(TrackdirBits bits)

   392

{

   393

	return (TrackBits)((bits | (bits >> 8)) & TRACK_BIT_MASK);

   394

}

   395

   396

/**

   397

 * Maps a trackdir to the trackdir that you will end up on if you go straight

   398

 * ahead. This will be the same trackdir for diagonal trackdirs, but a

   399

 * different (alternating) one for straight trackdirs

   400

 */

   401

static inline Trackdir NextTrackdir(Trackdir trackdir)

   402

{

   403

	extern const Trackdir _next_trackdir[TRACKDIR_END];

   404

	return _next_trackdir[trackdir];

   405

}

   406

   407

/**

   408

 * Maps a track to all tracks that make 90 deg turns with it.

   409

 */

   410

static inline TrackBits TrackCrossesTracks(Track track)

   411

{

   412

	extern const TrackBits _track_crosses_tracks[TRACK_END];

   413

	return _track_crosses_tracks[track];

   414

}

   415

   416

/**

   417

 * Maps a trackdir to the (4-way) direction the tile is exited when following

   418

 * that trackdir.

   419

 */

   420

static inline DiagDirection TrackdirToExitdir(Trackdir trackdir)

   421

{

   422

	extern const DiagDirection _trackdir_to_exitdir[TRACKDIR_END];

   423

	return _trackdir_to_exitdir[trackdir];

   424

}

   425

   426

/**

   427

 * Maps a track and an (4-way) dir to the trackdir that represents the track

   428

 * with the exit in the given direction.

   429

 */

   430

static inline Trackdir TrackExitdirToTrackdir(Track track, DiagDirection diagdir)

   431

{

   432

	extern const Trackdir _track_exitdir_to_trackdir[TRACK_END][DIAGDIR_END];

   433

	return _track_exitdir_to_trackdir[track][diagdir];

   434

}

   435

   436

/**

   437

 * Maps a track and an (4-way) dir to the trackdir that represents the track

   438

 * with the exit in the given direction.

   439

 */

   440

static inline Trackdir TrackEnterdirToTrackdir(Track track, DiagDirection diagdir)

   441

{

   442

	extern const Trackdir _track_enterdir_to_trackdir[TRACK_END][DIAGDIR_END];

   443

	return _track_enterdir_to_trackdir[track][diagdir];

   444

}

   445

   446

/**

   447

 * Maps a track and a full (8-way) direction to the trackdir that represents

   448

 * the track running in the given direction.

   449

 */

   450

static inline Trackdir TrackDirectionToTrackdir(Track track, Direction dir)

   451

{

   452

	extern const Trackdir _track_direction_to_trackdir[TRACK_END][DIR_END];

   453

	return _track_direction_to_trackdir[track][dir];

   454

}

   455

   456

/**

   457

 * Maps a (4-way) direction to the diagonal trackdir that runs in that

   458

 * direction.

   459

 */

   460

static inline Trackdir DiagdirToDiagTrackdir(DiagDirection diagdir)

   461

{

   462

	extern const Trackdir _dir_to_diag_trackdir[DIAGDIR_END];

   463

	return _dir_to_diag_trackdir[diagdir];

   464

}

   465

   466

/**

   467

 * Returns all trackdirs that can be reached when entering a tile from a given

   468

 * (diagonal) direction. This will obviously include 90 degree turns, since no

   469

 * information is available about the exact angle of entering */

   470

static inline TrackdirBits DiagdirReachesTrackdirs(DiagDirection diagdir)

   471

{

   472

	extern const TrackdirBits _exitdir_reaches_trackdirs[DIAGDIR_END];

   473

	return _exitdir_reaches_trackdirs[diagdir];

   474

}

   475

   476

/**

   477

 * Returns all tracks that can be reached when entering a tile from a given

   478

 * (diagonal) direction. This will obviously include 90 degree turns, since no

   479

 * information is available about the exact angle of entering */

   480

static inline TrackBits DiagdirReachesTracks(DiagDirection diagdir) { return TrackdirBitsToTrackBits(DiagdirReachesTrackdirs(diagdir)); }

   481

   482

/**

   483

 * Maps a trackdir to the trackdirs that can be reached from it (ie, when

   484

 * entering the next tile. This will include 90 degree turns!

   485

 */

   486

static inline TrackdirBits TrackdirReachesTrackdirs(Trackdir trackdir)

   487

{

   488

	extern const TrackdirBits _exitdir_reaches_trackdirs[DIAGDIR_END];

   489

	return _exitdir_reaches_trackdirs[TrackdirToExitdir(trackdir)];

   490

}

   491