1

/* $Id$ */

     2

     3

/** @file rail.h */

     4

     5

#ifndef RAIL_H

     6

#define RAIL_H

     7

     8

#include "direction.h"

     9

#include "tile.h"

    10

    11

typedef enum RailTypes {

    13

	RAILTYPE_RAIL     = 0,

    14

	RAILTYPE_ELECTRIC = 1,

    15

	RAILTYPE_MONO     = 2,

    16

	RAILTYPE_MAGLEV   = 3,

    17

	RAILTYPE_END,

    18

	INVALID_RAILTYPE  = 0xFF

    19

} RailType;

    20

    21

typedef byte RailTypeMask;

    22

    29

    30

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

    31

 * Can be translated to a trackbit with TrackToTrackbit */

    32

typedef enum Track {

    34

	TRACK_X     = 0,

    35

	TRACK_Y     = 1,

    36

	TRACK_UPPER = 2,

    37

	TRACK_LOWER = 3,

    38

	TRACK_LEFT  = 4,

    39

	TRACK_RIGHT = 5,

    40

	TRACK_END,

    41

	INVALID_TRACK = 0xFF

    42

} Track;

    43

    50

    51

/** Convert an Axis to the corresponding Track

    52

 * AXIS_X -> TRACK_X

    53

 * AXIS_Y -> TRACK_Y

    54

 * Uses the fact that they share the same internal encoding

    55

 */

    56

static inline Track AxisToTrack(Axis a)

    57

{

    58

	return (Track)a;

    59

}

    60

    61

    62

/** Bitfield corresponding to Track */

    63

typedef enum TrackBits {

    64

	TRACK_BIT_NONE    = 0U,

    65

	TRACK_BIT_X       = 1U << TRACK_X,

    66

	TRACK_BIT_Y       = 1U << TRACK_Y,

    67

	TRACK_BIT_UPPER   = 1U << TRACK_UPPER,

    68

	TRACK_BIT_LOWER   = 1U << TRACK_LOWER,

    69

	TRACK_BIT_LEFT    = 1U << TRACK_LEFT,

    70

	TRACK_BIT_RIGHT   = 1U << TRACK_RIGHT,

    71

	TRACK_BIT_CROSS   = TRACK_BIT_X     | TRACK_BIT_Y,

    72

	TRACK_BIT_HORZ    = TRACK_BIT_UPPER | TRACK_BIT_LOWER,

    73

	TRACK_BIT_VERT    = TRACK_BIT_LEFT  | TRACK_BIT_RIGHT,

    74

	TRACK_BIT_3WAY_NE = TRACK_BIT_X     | TRACK_BIT_UPPER | TRACK_BIT_RIGHT,

    75

	TRACK_BIT_3WAY_SE = TRACK_BIT_Y     | TRACK_BIT_LOWER | TRACK_BIT_RIGHT,

    76

	TRACK_BIT_3WAY_SW = TRACK_BIT_X     | TRACK_BIT_LOWER | TRACK_BIT_LEFT,

    77

	TRACK_BIT_3WAY_NW = TRACK_BIT_Y     | TRACK_BIT_UPPER | TRACK_BIT_LEFT,

    78

	TRACK_BIT_ALL     = TRACK_BIT_CROSS | TRACK_BIT_HORZ  | TRACK_BIT_VERT,

    83

} TrackBits;

    84

    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

typedef enum Trackdirs {

   111

	TRACKDIR_X_NE     =  0,

   112

	TRACKDIR_Y_SE     =  1,

   113

	TRACKDIR_UPPER_E  =  2,

   114

	TRACKDIR_LOWER_E  =  3,

   115

	TRACKDIR_LEFT_S   =  4,

   116

	TRACKDIR_RIGHT_S  =  5,

   117

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

   118

	 * conversion by doing (trackdir & 7) */

   119

	TRACKDIR_X_SW     =  8,

   120

	TRACKDIR_Y_NW     =  9,

   121

	TRACKDIR_UPPER_W  = 10,

   122

	TRACKDIR_LOWER_W  = 11,

   123

	TRACKDIR_LEFT_N   = 12,

   124

	TRACKDIR_RIGHT_N  = 13,

   125

	TRACKDIR_END,

   126

	INVALID_TRACKDIR  = 0xFF,

   127

} Trackdir;

   128

   133

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

   134

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

   135

typedef enum TrackdirBits {

   136

	TRACKDIR_BIT_NONE     = 0x0000,

   137

	TRACKDIR_BIT_X_NE     = 0x0001,

   138

	TRACKDIR_BIT_Y_SE     = 0x0002,

   139

	TRACKDIR_BIT_UPPER_E  = 0x0004,

   140

	TRACKDIR_BIT_LOWER_E  = 0x0008,

   141

	TRACKDIR_BIT_LEFT_S   = 0x0010,

   142

	TRACKDIR_BIT_RIGHT_S  = 0x0020,

   143

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

   144

	TRACKDIR_BIT_X_SW     = 0x0100,

   145

	TRACKDIR_BIT_Y_NW     = 0x0200,

   146

	TRACKDIR_BIT_UPPER_W  = 0x0400,

   147

	TRACKDIR_BIT_LOWER_W  = 0x0800,

   148

	TRACKDIR_BIT_LEFT_N   = 0x1000,

   149

	TRACKDIR_BIT_RIGHT_N  = 0x2000,

   150

	TRACKDIR_BIT_MASK     = 0x3F3F,

   151

	INVALID_TRACKDIR_BIT  = 0xFFFF,

   152

} TrackdirBits;

   153

   160

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

   161

 */

   162

typedef struct RailtypeInfo {

   163

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

   164

	 *  the ones used directly in the code */

   165

	struct {

   166

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

   167

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

   168

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

   169

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

   170

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

   171

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

   172

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

   173

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

   174

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

   175

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

   176

		SpriteID tunnel;       ///< tunnel sprites base

   177

	} base_sprites;

   178

   179

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

   180

	 * directly in the code are listed */

   181

	struct {

   182

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

   183

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

   184

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

   185

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

   186

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

   187

		SpriteID build_depot;        ///< button for building depots

   188

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

   189

		SpriteID convert_rail;       ///< button for converting rail

   190

	} gui_sprites;

   191

   192

	struct {

   193

		CursorID rail_ns;

   194

		CursorID rail_swne;

   195

		CursorID rail_ew;

   196

		CursorID rail_nwse;

   197

		CursorID autorail;

   198

		CursorID depot;

   199

		CursorID tunnel;

   200

		CursorID convert;

   201

	} cursor;

   202

   203

	struct {

   204

		StringID toolbar_caption;

   205

	} strings;

   206

   207

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

   208

	SpriteID snow_offset;

   209

   210

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

   211

	RailTypeMask powered_railtypes;

   212

   213

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

   214

	RailTypeMask compatible_railtypes;

   215

   216

	/**

   217

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

   218

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

   219

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

   220

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

   221

	 *    the offset will fail.<p>

   222

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

   223

	 */

   224

	SpriteID total_offset;

   225

   226

	/**

   227

	 * Bridge offset

   228

	 */

   229

	SpriteID bridge_offset;

   230

   231

	/**

   232

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

   233

	 */

   234

	byte custom_ground_offset;

   235

} RailtypeInfo;

   236

   237

extern RailtypeInfo _railtypes[RAILTYPE_END];

   238

   239

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

   240

enum {

   241

	NUM_SSD_ENTRY = 256, // max amount of blocks

   242

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

   243

};

   244

   245

/**

   246

 * Maps a Trackdir to the corresponding TrackdirBits value

   247

 */

   248

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

   249

   250

/**

   303

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

   304

 * them when convenient.

   305

 */

   306

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

   307

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

   308

   309

/**

   310

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

   311

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

   312

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

   313

 */

   314

   315

/**

   316

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

   317

 * direction along with the trackdir.

   318

 */

   319

extern const byte _signal_along_trackdir[TRACKDIR_END];

   320

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

   321

   322

/**

   323

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

   324

 * direction against the trackdir.

   325

 */

   326

static inline byte SignalAgainstTrackdir(Trackdir trackdir) {

   327

	extern const byte _signal_against_trackdir[TRACKDIR_END];

   328

	return _signal_against_trackdir[trackdir];

   329

}

   330

   331

/**

   332

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

   333

 * be present on the given track.

   334

 */

   335

static inline byte SignalOnTrack(Track track) {

   336

	extern const byte _signal_on_track[TRACK_END];

   337

	return _signal_on_track[track];

   338

}

   339

   340

   341

/*

   342

 * Functions describing logical relations between Tracks, TrackBits, Trackdirs

   343

 * TrackdirBits, Direction and DiagDirections.

   344

 *

   345

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

   346

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

   347

 */

   348

   349

/**

   350

 * Maps a trackdir to the reverse trackdir.

   351

 */

   355

	return (Trackdir)(trackdir ^ 8);

   356

}

   357

   358

/**

   359

 * Returns the Track that a given Trackdir represents

   360

 */

   361

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

   362

   363

/**

   364

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

   365

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

   366

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

   367

 * in the future.

   368

 */

   369

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

   370

   371

/**

   372

 * Returns a TrackdirBit mask that contains the two TrackdirBits that

   373

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

   374

 */

   375

static inline TrackdirBits TrackToTrackdirBits(Track track)

   376

{

   377

	Trackdir td = TrackToTrackdir(track);

   378

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

   379

}

   380

   381

/**

   382

 * Discards all directional information from the given TrackdirBits. Any

   383

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

   384

 */

   385

static inline TrackBits TrackdirBitsToTrackBits(TrackdirBits bits)

   386

{

   387

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

   388

}

   389

   390

/**

   391

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

   392

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

   393

 * different (alternating) one for straight trackdirs

   394

 */

   395

static inline Trackdir NextTrackdir(Trackdir trackdir)

   396

{

   397

	extern const Trackdir _next_trackdir[TRACKDIR_END];

   398

	return _next_trackdir[trackdir];

   399

}

   400

   401

/**

   402

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

   403

 */

   404

static inline TrackBits TrackCrossesTracks(Track track)

   405

{

   406

	extern const TrackBits _track_crosses_tracks[TRACK_END];

   407

	return _track_crosses_tracks[track];

   408

}

   409

   410

/**

   411

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

   412

 * that trackdir.

   413

 */

   414

static inline DiagDirection TrackdirToExitdir(Trackdir trackdir)

   415

{

   416

	extern const DiagDirection _trackdir_to_exitdir[TRACKDIR_END];

   417

	return _trackdir_to_exitdir[trackdir];

   418

}

   419

   420

/**

   421

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

   422

 * with the exit in the given direction.

   423

 */

   424

static inline Trackdir TrackExitdirToTrackdir(Track track, DiagDirection diagdir)

   425

{

   426

	extern const Trackdir _track_exitdir_to_trackdir[TRACK_END][DIAGDIR_END];

   427

	return _track_exitdir_to_trackdir[track][diagdir];

   428

}

   429

   430

/**

   431

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

   432

 * with the exit in the given direction.

   433

 */

   434

static inline Trackdir TrackEnterdirToTrackdir(Track track, DiagDirection diagdir)

   435

{

   436

	extern const Trackdir _track_enterdir_to_trackdir[TRACK_END][DIAGDIR_END];

   437

	return _track_enterdir_to_trackdir[track][diagdir];

   438

}

   439

   440

/**

   441

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

   442

 * the track running in the given direction.

   443

 */

   444

static inline Trackdir TrackDirectionToTrackdir(Track track, Direction dir)

   445

{

   446

	extern const Trackdir _track_direction_to_trackdir[TRACK_END][DIR_END];

   447

	return _track_direction_to_trackdir[track][dir];

   448

}

   449

   450

/**

   451

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

   452

 * direction.

   453

 */

   454

static inline Trackdir DiagdirToDiagTrackdir(DiagDirection diagdir)

   455

{

   456

	extern const Trackdir _dir_to_diag_trackdir[DIAGDIR_END];

   457

	return _dir_to_diag_trackdir[diagdir];

   458

}

   459

   460

extern const TrackdirBits _exitdir_reaches_trackdirs[DIAGDIR_END];

   461

   462

/**

   463

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

   464

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

   465

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

   466

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

   467

   468

/**

   469

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

   470

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

   471

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

   472

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

   473

   474

/**

   475

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

   476

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

   477

 */

   478

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

   479

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

   480

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

   481

   482

   483

/**

   484

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

   485

 */

   486

static inline TrackdirBits TrackdirCrossesTrackdirs(Trackdir trackdir) {

   487

	extern const TrackdirBits _track_crosses_trackdirs[TRACKDIR_END];

   488

	return _track_crosses_trackdirs[TrackdirToTrack(trackdir)];

   489

}

   490

   491

   492

/* Checks if a given Track is diagonal */

   493

static inline bool IsDiagonalTrack(Track track) { return (track == TRACK_X) || (track == TRACK_Y); }

   494