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

typedef enum RailTypes {

    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

} RailType;

    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

typedef 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

} Track;

    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

typedef 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

} TrackBits;

    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

DECLARE_ENUM_AS_BIT_INDEX(Track, TrackBits);

    92

    93

/**

    94

 * Maps a Track to the corresponding TrackBits value

    95

 */

    96

static inline TrackBits TrackToTrackBits(Track track)

    97

{

    98

	return (TrackBits)(1 << track);

    99

}

   100

   101

   102

static inline TrackBits AxisToTrackBits(Axis a)

   103

{

   104

	return TrackToTrackBits(AxisToTrack(a));

   105

}

   106

   107

   108

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

   114

typedef enum Trackdirs {

   115

	TRACKDIR_BEGIN    =  0,

   116

	TRACKDIR_X_NE     =  0,

   117

	TRACKDIR_Y_SE     =  1,

   118

	TRACKDIR_UPPER_E  =  2,

   119

	TRACKDIR_LOWER_E  =  3,

   120

	TRACKDIR_LEFT_S   =  4,

   121

	TRACKDIR_RIGHT_S  =  5,

   124

	TRACKDIR_X_SW     =  8,

   125

	TRACKDIR_Y_NW     =  9,

   126

	TRACKDIR_UPPER_W  = 10,

   127

	TRACKDIR_LOWER_W  = 11,

   128

	TRACKDIR_LEFT_N   = 12,

   129

	TRACKDIR_RIGHT_N  = 13,

   132

	TRACKDIR_END,

   133

	INVALID_TRACKDIR  = 0xFF,

   134

} Trackdir;

   135

   136

/** Define basic enum properties */

   137

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

   138

typedef TinyEnumT<Trackdir> TrackdirByte;

   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

typedef enum TrackdirBits {

   143

	TRACKDIR_BIT_NONE     = 0x0000,

   144

	TRACKDIR_BIT_X_NE     = 0x0001,

   145

	TRACKDIR_BIT_Y_SE     = 0x0002,

   146

	TRACKDIR_BIT_UPPER_E  = 0x0004,

   147

	TRACKDIR_BIT_LOWER_E  = 0x0008,

   148

	TRACKDIR_BIT_LEFT_S   = 0x0010,

   149

	TRACKDIR_BIT_RIGHT_S  = 0x0020,

   150

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

   151

	TRACKDIR_BIT_X_SW     = 0x0100,

   152

	TRACKDIR_BIT_Y_NW     = 0x0200,

   153

	TRACKDIR_BIT_UPPER_W  = 0x0400,

   154

	TRACKDIR_BIT_LOWER_W  = 0x0800,

   155

	TRACKDIR_BIT_LEFT_N   = 0x1000,

   156

	TRACKDIR_BIT_RIGHT_N  = 0x2000,

   157

	TRACKDIR_BIT_MASK     = 0x3F3F,

   158

	INVALID_TRACKDIR_BIT  = 0xFFFF,

   159

} TrackdirBits;

   160

   161

/** Define basic enum properties */

   162

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

   163

typedef TinyEnumT<TrackdirBits> TrackdirBitsShort;

   164

DECLARE_ENUM_AS_BIT_SET(TrackdirBits);

   165

DECLARE_ENUM_AS_BIT_INDEX(Trackdir, TrackdirBits);

   166

   167

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

   168

 */

   169

typedef struct RailtypeInfo {

   170

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

   171

	 *  the ones used directly in the code */

   172

	struct {

   173

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

   174

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

   175

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

   176

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

   177

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

   178

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

   179

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

   180

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

   181

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

   182

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

   183

		SpriteID tunnel;       ///< tunnel sprites base

   184

	} base_sprites;

   185

   186

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

   187

	 * directly in the code are listed */

   188

	struct {

   189

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

   190

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

   191

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

   192

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

   193

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

   194

		SpriteID build_depot;        ///< button for building depots

   195

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

   196

		SpriteID convert_rail;       ///< button for converting rail

   197

	} gui_sprites;

   198

   199

	struct {

   200

		CursorID rail_ns;

   201

		CursorID rail_swne;

   202

		CursorID rail_ew;

   203

		CursorID rail_nwse;

   204

		CursorID autorail;

   205

		CursorID depot;

   206

		CursorID tunnel;

   207

		CursorID convert;

   208

	} cursor;

   209

   210

	struct {

   211

		StringID toolbar_caption;

   212

	} strings;

   213

   214

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

   215

	SpriteID snow_offset;

   216

   217

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

   218

	RailTypeMask powered_railtypes;

   219

   220

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

   221

	RailTypeMask compatible_railtypes;

   222

   223

	/**

   224

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

   225

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

   226

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

   227

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

   228

	 *    the offset will fail.<p>

   229

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

   230

	 */

   231

	SpriteID total_offset;

   232

   233

	/**

   234

	 * Bridge offset

   235

	 */

   236

	SpriteID bridge_offset;

   237

   238

	/**

   239

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

   240

	 */

   241

	byte custom_ground_offset;

   242

} RailtypeInfo;

   243

   244

extern RailtypeInfo _railtypes[RAILTYPE_END];

   245

   246

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

   247

enum {

   248

	NUM_SSD_ENTRY = 256, // max amount of blocks

   249

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

   250

};

   251

   252

/**

   253

 * Maps a Trackdir to the corresponding TrackdirBits value

   254

 */

   255

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

   256

   257

/**

   258

* Removes first Track from TrackBits and returns it

   259

*/

   260

static inline Track RemoveFirstTrack(TrackBits *tracks)

   261

{

   262

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

   263

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

   264

		*tracks = ClrBitT(*tracks, first);

   265

		return first;

   266

	}

   267

	return INVALID_TRACK;

   268

}

   269

   270

/**

   271

* Removes first Trackdir from TrackdirBits and returns it

   272

*/

   273

static inline Trackdir RemoveFirstTrackdir(TrackdirBits *trackdirs)

   274

{

   275

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

   276

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

   277

		*trackdirs = ClrBitT(*trackdirs, first);

   278

		return first;

   279

	}

   280

	return INVALID_TRACKDIR;

   281

}

   282

   283

/**

   284

* Returns first Track from TrackBits or INVALID_TRACK

   285

*/

   286

static inline Track FindFirstTrack(TrackBits tracks)

   287

{

   288

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

   289

}

   290

   291

/**

   292

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

   293

*/

   294

static inline Track TrackBitsToTrack(TrackBits tracks)

   295

{

   296

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

   297

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

   298

}

   299

   300

/**

   301

* Returns first Trackdir from TrackdirBits or INVALID_TRACKDIR

   302

*/

   303

static inline Trackdir FindFirstTrackdir(TrackdirBits trackdirs)

   304

{

   305

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

   306

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

   307

}

   308

   309

/**

   310

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

   311

 * them when convenient.

   312

 */

   313

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

   314

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

   315

   316

/**

   317

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

   318

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

   319

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

   320

 */

   321

   322

/**

   323

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

   324

 * direction along with the trackdir.

   325

 */

   326

extern const byte _signal_along_trackdir[TRACKDIR_END];

   327

static inline byte SignalAlongTrackdir(Trackdir trackdir) {return _signal_along_trackdir[trackdir];}

   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

	extern const byte _signal_against_trackdir[TRACKDIR_END];

   335

	return _signal_against_trackdir[trackdir];

   336

}

   337

   338

/**

   339

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

   340

 * be present on the given track.

   341

 */

   342

static inline byte SignalOnTrack(Track track) {

   343

	extern const byte _signal_on_track[TRACK_END];

   344

	return _signal_on_track[track];

   345

}

   346

   347

   348

/*

   349

 * Functions describing logical relations between Tracks, TrackBits, Trackdirs

   350

 * TrackdirBits, Direction and DiagDirections.

   351

 *

   352

 * TODO: Add #unndefs or something similar to remove the arrays used below

   353

 * from the global scope and expose direct uses of them.

   354

 */

   355

   356

/**

   357

 * Maps a trackdir to the reverse trackdir.

   358

 */

   359

static inline Trackdir ReverseTrackdir(Trackdir trackdir)

   360

{

   361

	assert(trackdir != INVALID_TRACKDIR);

   362

	return (Trackdir)(trackdir ^ 8);

   363

}

   364

   365

/**

   366

 * Returns the Track that a given Trackdir represents

   367

 */

   368

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

   369

   370

/**

   371

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

   372

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

   373

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

   374

 * in the future.

   375

 */

   376

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

   377

   378

/**

   379

 * Returns a TrackdirBit mask that contains the two TrackdirBits that

   380

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

   381

 */

   382

static inline TrackdirBits TrackToTrackdirBits(Track track)

   383

{

   384

	Trackdir td = TrackToTrackdir(track);

   385

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

   386

}

   387

   388

/**

   389

 * Discards all directional information from the given TrackdirBits. Any

   390

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

   391

 */

   392

static inline TrackBits TrackdirBitsToTrackBits(TrackdirBits bits)

   393

{

   394

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

   395

}

   396

   397

/**

   398

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

   399

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

   400

 * different (alternating) one for straight trackdirs

   401

 */

   402

static inline Trackdir NextTrackdir(Trackdir trackdir)

   403

{

   404

	extern const Trackdir _next_trackdir[TRACKDIR_END];

   405

	return _next_trackdir[trackdir];

   406

}

   407

   408

/**

   409

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

   410

 */

   411

static inline TrackBits TrackCrossesTracks(Track track)

   412

{

   413

	extern const TrackBits _track_crosses_tracks[TRACK_END];

   414

	return _track_crosses_tracks[track];

   415

}

   416

   417

/**

   418

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

   419

 * that trackdir.

   420

 */

   421

static inline DiagDirection TrackdirToExitdir(Trackdir trackdir)

   422

{

   423

	extern const DiagDirection _trackdir_to_exitdir[TRACKDIR_END];

   424

	return _trackdir_to_exitdir[trackdir];

   425

}

   426

   427

/**

   428

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

   429

 * with the exit in the given direction.

   430

 */

   431

static inline Trackdir TrackExitdirToTrackdir(Track track, DiagDirection diagdir)

   432

{

   433

	extern const Trackdir _track_exitdir_to_trackdir[TRACK_END][DIAGDIR_END];

   434

	return _track_exitdir_to_trackdir[track][diagdir];

   435

}

   436

   437

/**

   438

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

   439

 * with the exit in the given direction.

   440

 */

   441

static inline Trackdir TrackEnterdirToTrackdir(Track track, DiagDirection diagdir)

   442

{

   443

	extern const Trackdir _track_enterdir_to_trackdir[TRACK_END][DIAGDIR_END];

   444

	return _track_enterdir_to_trackdir[track][diagdir];

   445

}

   446

   447

/**

   448

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

   449

 * the track running in the given direction.

   450

 */

   451

static inline Trackdir TrackDirectionToTrackdir(Track track, Direction dir)

   452

{

   453

	extern const Trackdir _track_direction_to_trackdir[TRACK_END][DIR_END];

   454

	return _track_direction_to_trackdir[track][dir];

   455

}

   456

   457

/**

   458

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

   459

 * direction.

   460

 */

   461

static inline Trackdir DiagdirToDiagTrackdir(DiagDirection diagdir)

   462

{

   463

	extern const Trackdir _dir_to_diag_trackdir[DIAGDIR_END];

   464

	return _dir_to_diag_trackdir[diagdir];

   465

}

   466

   467

extern const TrackdirBits _exitdir_reaches_trackdirs[DIAGDIR_END];

   468

   469

/**

   470

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

   471

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

   472

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

   473

static inline TrackdirBits DiagdirReachesTrackdirs(DiagDirection diagdir) { return _exitdir_reaches_trackdirs[diagdir]; }

   474

   475

/**

   476

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

   477

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

   478

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

   479

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

   480

   481

/**

   482

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

   483

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

   484

 */

   485

static inline TrackdirBits TrackdirReachesTrackdirs(Trackdir trackdir) { return _exitdir_reaches_trackdirs[TrackdirToExitdir(trackdir)]; }

   486

/* Note that there is no direct table for this function (there used to be),

   487

 * but it uses two simpeler tables to achieve the result */

   488

   489

   490

/**

   491

 * Maps a trackdir to all trackdirs that make 90 deg turns with it.

   492

 */

   493

static inline TrackdirBits TrackdirCrossesTrackdirs(Trackdir trackdir) {