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,

    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

   109

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

   110

typedef enum Trackdirs {

   111

	TRACKDIR_BEGIN    =  0,

   112

	TRACKDIR_X_NE     =  0,

   113

	TRACKDIR_Y_SE     =  1,

   114

	TRACKDIR_UPPER_E  =  2,

   115

	TRACKDIR_LOWER_E  =  3,

   116

	TRACKDIR_LEFT_S   =  4,

   117

	TRACKDIR_RIGHT_S  =  5,

   118

	/* Note the two missing values here. This enables trackdir -> track

   119

	 * conversion by doing (trackdir & 7) */

   120

	TRACKDIR_X_SW     =  8,

   121

	TRACKDIR_Y_NW     =  9,

   122

	TRACKDIR_UPPER_W  = 10,

   123

	TRACKDIR_LOWER_W  = 11,

   124

	TRACKDIR_LEFT_N   = 12,

   125

	TRACKDIR_RIGHT_N  = 13,

   126

	TRACKDIR_END,

   127

	INVALID_TRACKDIR  = 0xFF,

   128

} Trackdir;

   129

   130

/** Define basic enum properties */

   131

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

   132

typedef TinyEnumT<Trackdir> TrackdirByte;

   133

   134

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

   135

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

   136

typedef enum TrackdirBits {

   137

	TRACKDIR_BIT_NONE     = 0x0000,

   138

	TRACKDIR_BIT_X_NE     = 0x0001,

   139

	TRACKDIR_BIT_Y_SE     = 0x0002,

   140

	TRACKDIR_BIT_UPPER_E  = 0x0004,

   141

	TRACKDIR_BIT_LOWER_E  = 0x0008,

   142

	TRACKDIR_BIT_LEFT_S   = 0x0010,

   143

	TRACKDIR_BIT_RIGHT_S  = 0x0020,

   144

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

   145

	TRACKDIR_BIT_X_SW     = 0x0100,

   146

	TRACKDIR_BIT_Y_NW     = 0x0200,

   147

	TRACKDIR_BIT_UPPER_W  = 0x0400,

   148

	TRACKDIR_BIT_LOWER_W  = 0x0800,

   149

	TRACKDIR_BIT_LEFT_N   = 0x1000,

   150

	TRACKDIR_BIT_RIGHT_N  = 0x2000,

   151

	TRACKDIR_BIT_MASK     = 0x3F3F,

   152

	INVALID_TRACKDIR_BIT  = 0xFFFF,

   153

} TrackdirBits;

   154

   155

/** Define basic enum properties */

   156

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

   157

typedef TinyEnumT<TrackdirBits> TrackdirBitsShort;

   158

DECLARE_ENUM_AS_BIT_SET(TrackdirBits);

   159

DECLARE_ENUM_AS_BIT_INDEX(Trackdir, TrackdirBits);

   160

   161

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

   162

 */

   163

typedef struct RailtypeInfo {

   164

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

   165

	 *  the ones used directly in the code */

   166

	struct {

   167

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

   168

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

   169

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

   170

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

   171

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

   172

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

   173

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

   174

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

   175

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

   176

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

   177

		SpriteID tunnel;       ///< tunnel sprites base

   178

	} base_sprites;

   179

   180

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

   181

	 * directly in the code are listed */

   182

	struct {

   183

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

   184

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

   185

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

   186

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

   187

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

   188

		SpriteID build_depot;        ///< button for building depots

   189

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

   190

		SpriteID convert_rail;       ///< button for converting rail

   191

	} gui_sprites;

   192

   193

	struct {

   194

		CursorID rail_ns;

   195

		CursorID rail_swne;

   196

		CursorID rail_ew;

   197

		CursorID rail_nwse;

   198

		CursorID autorail;

   199

		CursorID depot;

   200

		CursorID tunnel;

   201

		CursorID convert;

   202

	} cursor;

   203

   204

	struct {

   205

		StringID toolbar_caption;

   206

	} strings;

   207

   208

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

   209

	SpriteID snow_offset;

   210

   211

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

   212

	RailTypeMask powered_railtypes;

   213

   214

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

   215

	RailTypeMask compatible_railtypes;

   216

   217

	/**

   218

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

   219

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

   220

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

   221

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

   222

	 *    the offset will fail.<p>

   223

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

   224

	 */

   225

	SpriteID total_offset;

   226

   227

	/**

   228

	 * Bridge offset

   229

	 */

   230

	SpriteID bridge_offset;

   231

   232

	/**

   233

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

   234

	 */

   235

	byte custom_ground_offset;

   236

} RailtypeInfo;

   237

   238

extern RailtypeInfo _railtypes[RAILTYPE_END];

   239

   240

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

   241

enum {

   242

	NUM_SSD_ENTRY = 256, // max amount of blocks

   243

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

   244

};

   245

   246

/**

   247

 * Maps a Trackdir to the corresponding TrackdirBits value

   248

 */

   249

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

   250

   251

/**

   252

* Removes first Track from TrackBits and returns it

   253

*/

   254

static inline Track RemoveFirstTrack(TrackBits *tracks)

   255

{

   256

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

   257

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

   258

		*tracks = ClrBitT(*tracks, first);

   259

		return first;

   260

	}

   261

	return INVALID_TRACK;

   262

}

   263

   264

/**

   265

* Removes first Trackdir from TrackdirBits and returns it

   266

*/

   267

static inline Trackdir RemoveFirstTrackdir(TrackdirBits *trackdirs)

   268

{

   269

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

   270

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

   271

		*trackdirs = ClrBitT(*trackdirs, first);

   272

		return first;

   273

	}

   274

	return INVALID_TRACKDIR;

   275

}

   276

   277

/**

   278

* Returns first Track from TrackBits or INVALID_TRACK

   279

*/

   280

static inline Track FindFirstTrack(TrackBits tracks)

   281

{

   282

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

   283

}

   284

   285

/**

   286

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

   287

*/

   288

static inline Track TrackBitsToTrack(TrackBits tracks)

   289

{

   290

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

   291

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

   292

}

   293

   294

/**

   295

* Returns first Trackdir from TrackdirBits or INVALID_TRACKDIR

   296

*/

   297

static inline Trackdir FindFirstTrackdir(TrackdirBits trackdirs)

   298

{

   299

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

   300

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

   301

}

   302

   303

/**

   304

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

   305

 * them when convenient.

   306

 */

   307

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

   308

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

   309

   310

/**

   311

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

   312

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

   313

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

   314

 */

   315

   316

/**

   317

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

   318

 * direction along with the trackdir.

   319

 */

   320

extern const byte _signal_along_trackdir[TRACKDIR_END];

   321

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

   322

   323

/**

   324

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

   325

 * direction against the trackdir.

   326

 */

   327

static inline byte SignalAgainstTrackdir(Trackdir trackdir) {

   328

	extern const byte _signal_against_trackdir[TRACKDIR_END];

   329

	return _signal_against_trackdir[trackdir];

   330

}

   331

   332

/**

   333

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

   334

 * be present on the given track.

   335

 */

   336

static inline byte SignalOnTrack(Track track) {

   337

	extern const byte _signal_on_track[TRACK_END];

   338

	return _signal_on_track[track];

   339

}

   340

   341

   342

/*

   343

 * Functions describing logical relations between Tracks, TrackBits, Trackdirs

   344

 * TrackdirBits, Direction and DiagDirections.

   345

 *

   346

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

   347

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

   348

 */

   349

   350

/**

   351

 * Maps a trackdir to the reverse trackdir.

   352

 */

   353

static inline Trackdir ReverseTrackdir(Trackdir trackdir)

   354

{

   355

	assert(trackdir != INVALID_TRACKDIR);

   356

	return (Trackdir)(trackdir ^ 8);

   357

}

   358

   359

/**

   360

 * Returns the Track that a given Trackdir represents

   361

 */

   362

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

   363

   364

/**

   365

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

   366

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

   367

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

   368

 * in the future.

   369

 */

   370

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

   371

   372

/**

   373

 * Returns a TrackdirBit mask that contains the two TrackdirBits that

   374

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

   375

 */

   376

static inline TrackdirBits TrackToTrackdirBits(Track track)

   377

{

   378

	Trackdir td = TrackToTrackdir(track);

   379

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

   380

}

   381

   382

/**

   383

 * Discards all directional information from the given TrackdirBits. Any

   384

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

   385

 */

   386

static inline TrackBits TrackdirBitsToTrackBits(TrackdirBits bits)

   387

{

   388

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

   389

}

   390

   391

/**

   392

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

   393

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

   394

 * different (alternating) one for straight trackdirs

   395

 */

   396

static inline Trackdir NextTrackdir(Trackdir trackdir)

   397

{

   398

	extern const Trackdir _next_trackdir[TRACKDIR_END];

   399

	return _next_trackdir[trackdir];

   400

}

   401

   402

/**

   403

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

   404

 */

   405

static inline TrackBits TrackCrossesTracks(Track track)

   406

{

   407

	extern const TrackBits _track_crosses_tracks[TRACK_END];

   408

	return _track_crosses_tracks[track];

   409

}

   410

   411

/**

   412

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

   413

 * that trackdir.

   414

 */

   415

static inline DiagDirection TrackdirToExitdir(Trackdir trackdir)

   416

{

   417

	extern const DiagDirection _trackdir_to_exitdir[TRACKDIR_END];

   418

	return _trackdir_to_exitdir[trackdir];

   419

}

   420

   421

/**

   422

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

   423

 * with the exit in the given direction.

   424

 */

   425

static inline Trackdir TrackExitdirToTrackdir(Track track, DiagDirection diagdir)

   426

{

   427

	extern const Trackdir _track_exitdir_to_trackdir[TRACK_END][DIAGDIR_END];

   428

	return _track_exitdir_to_trackdir[track][diagdir];

   429

}

   430

   431

/**

   432

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

   433

 * with the exit in the given direction.

   434

 */

   435

static inline Trackdir TrackEnterdirToTrackdir(Track track, DiagDirection diagdir)

   436

{

   437

	extern const Trackdir _track_enterdir_to_trackdir[TRACK_END][DIAGDIR_END];

   438

	return _track_enterdir_to_trackdir[track][diagdir];

   439

}

   440

   441

/**

   442

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

   443

 * the track running in the given direction.

   444

 */

   445

static inline Trackdir TrackDirectionToTrackdir(Track track, Direction dir)

   446

{

   447

	extern const Trackdir _track_direction_to_trackdir[TRACK_END][DIR_END];

   448

	return _track_direction_to_trackdir[track][dir];

   449

}

   450

   451

/**

   452

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

   453

 * direction.

   454

 */

   455

static inline Trackdir DiagdirToDiagTrackdir(DiagDirection diagdir)

   456

{

   457

	extern const Trackdir _dir_to_diag_trackdir[DIAGDIR_END];

   458

	return _dir_to_diag_trackdir[diagdir];

   459

}

   460

   461

extern const TrackdirBits _exitdir_reaches_trackdirs[DIAGDIR_END];

   462

   463

/**

   464

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

   465

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

   466

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

   467

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

   468

   469

/**

   470

 * Returns all tracks 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 TrackBits DiagdirReachesTracks(DiagDirection diagdir) { return TrackdirBitsToTrackBits(DiagdirReachesTrackdirs(diagdir)); }

   474

   475

/**

   476

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

   477

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

   478

 */

   479

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

   480

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

   481

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

   482

   483

   484

/**

   485

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

   486

 */

   487

static inline TrackdirBits TrackdirCrossesTrackdirs(Trackdir trackdir) {

   488

	extern const TrackdirBits _track_crosses_trackdirs[TRACKDIR_END];

   489

	return _track_crosses_trackdirs[TrackdirToTrack(trackdir)];

   490

}

   491

   492

   493

/* Checks if a given Track is diagonal */