1

/* $Id$ */

     2

     3

#ifndef RAIL_MAP_H

     4

#define RAIL_MAP_H

     5

     6

#include "direction.h"

     7

#include "tile.h"

     8

     9

    10

typedef enum RailTileType {

    11

	RAIL_TYPE_NORMAL         = 0x0,

    12

	RAIL_TYPE_SIGNALS        = 0x40,

    13

	RAIL_TYPE_UNUSED         = 0x80, /* XXX: Maybe this could become waypoints? */

    14

	RAIL_TYPE_DEPOT_WAYPOINT = 0xC0, /* Is really depots and waypoints... */

    15

	RAIL_TILE_TYPE_MASK      = 0xC0

    16

} RailTileType;

    17

    18

static inline RailTileType GetRailTileType(TileIndex t)

    19

{

    20

	assert(IsTileType(t, MP_RAILWAY));

    21

	return _m[t].m5 & RAIL_TILE_TYPE_MASK;

    22

}

    23

    24

/**

    25

 * Returns whether this is plain rails, with or without signals. Iow, if this

    26

 * tiles RailTileType is RAIL_TYPE_NORMAL or RAIL_TYPE_SIGNALS.

    27

 */

    28

static inline bool IsPlainRailTile(TileIndex tile)

    29

{

    30

	RailTileType rtt = GetRailTileType(tile);

    31

	return rtt == RAIL_TYPE_NORMAL || rtt == RAIL_TYPE_SIGNALS;

    32

}

    33

    34

/**

    35

 * Checks if a rail tile has signals.

    36

 */

    37

static inline bool HasSignals(TileIndex tile)

    38

{

    39

	return GetRailTileType(tile) == RAIL_TYPE_SIGNALS;

    40

}

    41

    42

    43

/** These specify the subtype when the main rail type is

    44

 * RAIL_TYPE_DEPOT_WAYPOINT */

    45

typedef enum RailTileSubtypes {

    46

	RAIL_SUBTYPE_DEPOT    = 0x00,

    47

	RAIL_SUBTYPE_WAYPOINT = 0x04,

    48

	RAIL_SUBTYPE_MASK     = 0x3C

    49

} RailTileSubtype;

    50

    51

/**

    52

 * Returns the RailTileSubtype of a given rail tile with type

    53

 * RAIL_TYPE_DEPOT_WAYPOINT

    54

 */

    55

static inline RailTileSubtype GetRailTileSubtype(TileIndex tile)

    56

{

    57

	assert(GetRailTileType(tile) == RAIL_TYPE_DEPOT_WAYPOINT);

    58

	return (RailTileSubtype)(_m[tile].m5 & RAIL_SUBTYPE_MASK);

    59

}

    60

    61

    62

typedef enum RailTypes {

    63

	RAILTYPE_RAIL     = 0,

    64

	RAILTYPE_ELECTRIC = 1,

    65

	RAILTYPE_MONO     = 2,

    66

	RAILTYPE_MAGLEV   = 3,

    67

	RAILTYPE_END,

    68

	INVALID_RAILTYPE = 0xFF

    69

} RailType;

    70

    71

typedef byte RailTypeMask;

    72

    73

static inline RailType GetRailType(TileIndex t)

    74

{

    75

	return (RailType)GB(_m[t].m3, 0, 4);

    76

}

    77

    78

// TODO remove this by moving to the same bits as GetRailType()

    79

static inline RailType GetRailTypeCrossing(TileIndex t)

    80

{

    81

	return (RailType)GB(_m[t].m4, 0, 4);

    82

}

    83

    84

static inline RailType GetRailTypeOnBridge(TileIndex t)

    85

{

    86

	return (RailType)GB(_m[t].m3, 4, 4);

    87

}

    88

    89

static inline void SetRailType(TileIndex t, RailType r)

    90

{

    91

	SB(_m[t].m3, 0, 4, r);

    92

}

    93

    94

// TODO remove this by moving to the same bits as SetRailType()

    95

static inline void SetRailTypeCrossing(TileIndex t, RailType r)

    96

{

    97

	SB(_m[t].m4, 0, 4, r);

    98

}

    99

   100

static inline void SetRailTypeOnBridge(TileIndex t, RailType r)

   101

{

   102

	SB(_m[t].m3, 4, 4, r);

   103

}

   104

   105

   106

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

   107

 * Can be translated to a trackbit with TrackToTrackbit */

   108

typedef enum Track {

   109

	TRACK_X     = 0,

   110

	TRACK_Y     = 1,

   111

	TRACK_UPPER = 2,

   112

	TRACK_LOWER = 3,

   113

	TRACK_LEFT  = 4,

   114

	TRACK_RIGHT = 5,

   115

	TRACK_END,

   116

	INVALID_TRACK = 0xFF

   117

} Track;

   118

   119

   120

/** Bitfield corresponding to Track */

   121

typedef enum TrackBits {

   122

	TRACK_BIT_X     = 1U << TRACK_X,

   123

	TRACK_BIT_Y     = 1U << TRACK_Y,

   124

	TRACK_BIT_UPPER = 1U << TRACK_UPPER,

   125

	TRACK_BIT_LOWER = 1U << TRACK_LOWER,

   126

	TRACK_BIT_LEFT  = 1U << TRACK_LEFT,

   127

	TRACK_BIT_RIGHT = 1U << TRACK_RIGHT,

   128

	TRACK_BIT_CROSS = TRACK_BIT_X     | TRACK_BIT_Y,

   129

	TRACK_BIT_HORZ  = TRACK_BIT_UPPER | TRACK_BIT_LOWER,

   130

	TRACK_BIT_VERT  = TRACK_BIT_LEFT  | TRACK_BIT_RIGHT,

   131

	TRACK_BIT_3WAY_NE = TRACK_BIT_X | TRACK_BIT_UPPER | TRACK_BIT_RIGHT,

   132

	TRACK_BIT_3WAY_SE = TRACK_BIT_Y | TRACK_BIT_LOWER | TRACK_BIT_RIGHT,

   133

	TRACK_BIT_3WAY_SW = TRACK_BIT_X | TRACK_BIT_LOWER | TRACK_BIT_LEFT,

   134

	TRACK_BIT_3WAY_NW = TRACK_BIT_Y | TRACK_BIT_UPPER | TRACK_BIT_LEFT,

   135

	TRACK_BIT_ALL   = TRACK_BIT_CROSS | TRACK_BIT_HORZ | TRACK_BIT_VERT,

   136

	TRACK_BIT_MASK  = 0x3FU

   137

} TrackBits;

   138

   139

static inline TrackBits GetTrackBits(TileIndex tile)

   140

{

   141

	return (TrackBits)GB(_m[tile].m5, 0, 6);

   142

}

   143

   144

static inline void SetTrackBits(TileIndex t, TrackBits b)

   145

{

   146

	SB(_m[t].m5, 0, 6, b);

   147

}

   148

   149

/**

   150

 * Returns whether the given track is present on the given tile. Tile must be

   151

 * a plain rail tile (IsPlainRailTile()).

   152

 */

   153

static inline bool HasTrack(TileIndex tile, Track track)

   154

{

   155

	return HASBIT(GetTrackBits(tile), track);

   156

}

   157

   158

   159

static inline DiagDirection GetRailDepotDirection(TileIndex t)

   160

{

   161

	return (DiagDirection)GB(_m[t].m5, 0, 2);

   162

}

   163

   164

static inline Track GetRailWaypointTrack(TileIndex t)

   165

{

   166

	return HASBIT(_m[t].m5, 0) ? TRACK_Y : TRACK_X;

   167

}

   168

   169

static inline TrackBits GetRailWaypointBits(TileIndex t)

   170

{

   171

	return _m[t].m5 & 1 ? TRACK_BIT_Y : TRACK_BIT_X;

   172

}

   173

   174

static inline void SetCustomWaypointSprite(TileIndex t)

   175

{

   176

	SETBIT(_m[t].m3, 4);

   177

}

   178

   179

static inline void ClearCustomWaypointSprite(TileIndex t)

   180

{

   181

	CLRBIT(_m[t].m3, 4);

   182

}

   183

   184

static inline bool IsCustomWaypoint(TileIndex t)

   185

{

   186

	return HASBIT(_m[t].m3, 4);

   187

}

   188

   189

static inline Axis GetWaypointAxis(TileIndex t)

   190

{

   191

	return HASBIT(_m[t].m5, 0) ? AXIS_Y : AXIS_X;

   192

}

   193

   194

   195

typedef enum SignalType {

   196

	SIGTYPE_NORMAL  = 0, // normal signal

   197

	SIGTYPE_ENTRY   = 1, // presignal block entry

   198

	SIGTYPE_EXIT    = 2, // presignal block exit

   199

	SIGTYPE_COMBO   = 3  // presignal inter-block

   200

} SignalType;

   201

   202

static inline SignalType GetSignalType(TileIndex t)

   203

{

   204

	assert(GetRailTileType(t) == RAIL_TYPE_SIGNALS);

   205

	return (SignalType)GB(_m[t].m4, 0, 2);

   206

}

   207

   208

static inline void SetSignalType(TileIndex t, SignalType s)

   209

{

   210

	assert(GetRailTileType(t) == RAIL_TYPE_SIGNALS);

   211

	SB(_m[t].m4, 0, 2, s);

   212

}

   213

   214

static inline bool IsPresignalEntry(TileIndex t)

   215

{

   216

	return GetSignalType(t) == SIGTYPE_ENTRY || GetSignalType(t) == SIGTYPE_COMBO;

   217

}

   218

   219

static inline bool IsPresignalExit(TileIndex t)

   220

{

   221

	return GetSignalType(t) == SIGTYPE_EXIT || GetSignalType(t) == SIGTYPE_COMBO;

   222

}

   223

   224

static inline void CycleSignalSide(TileIndex t, Track track)

   225

{

   226

	byte sig;

   227

	byte pos = 6;

   228

	if (track == TRACK_LOWER || track == TRACK_RIGHT) pos = 4;

   229

   230

	sig = GB(_m[t].m3, pos, 2);

   231

	if (--sig == 0) sig = 3;

   232

	SB(_m[t].m3, pos, 2, sig);

   233

}

   234

   235

   236

typedef enum SignalVariant {

   237

	SIG_ELECTRIC  = 0,

   238

	SIG_SEMAPHORE = 1

   239

} SignalVariant;

   240

   241

static inline SignalVariant GetSignalVariant(TileIndex t)

   242

{

   243

	return (SignalVariant)GB(_m[t].m4, 2, 1);

   244

}

   245

   246

static inline void SetSignalVariant(TileIndex t, SignalVariant v)

   247

{

   248

	SB(_m[t].m4, 2, 1, v);

   249

}

   250

   251

static inline bool IsSignalPresent(TileIndex t, byte signalbit)

   252

{

   253

	return HASBIT(_m[t].m3, signalbit + 4);

   254

}

   255

   256

/** These are states in which a signal can be. Currently these are only two, so

   257

 * simple boolean logic will do. But do try to compare to this enum instead of

   258

 * normal boolean evaluation, since that will make future additions easier.

   259

 */

   260

typedef enum SignalStates {

   261

	SIGNAL_STATE_RED = 0,

   262

	SIGNAL_STATE_GREEN = 1,

   263

} SignalState;

   264

   265

static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)

   266

{

   267

	return HASBIT(_m[t].m2, signalbit + 4);

   268

}

   269

   270

   271

typedef enum RailGroundType {

   272

	RAIL_MAP2LO_GROUND_MASK = 0xF,

   273

	RAIL_GROUND_BARREN = 0,

   274

	RAIL_GROUND_GRASS = 1,

   275

	RAIL_GROUND_FENCE_NW = 2,

   276

	RAIL_GROUND_FENCE_SE = 3,

   277

	RAIL_GROUND_FENCE_SENW = 4,

   278

	RAIL_GROUND_FENCE_NE = 5,

   279

	RAIL_GROUND_FENCE_SW = 6,

   280

	RAIL_GROUND_FENCE_NESW = 7,

   281

	RAIL_GROUND_FENCE_VERT1 = 8,

   282

	RAIL_GROUND_FENCE_VERT2 = 9,

   283

	RAIL_GROUND_FENCE_HORIZ1 = 10,

   284

	RAIL_GROUND_FENCE_HORIZ2 = 11,

   285

	RAIL_GROUND_ICE_DESERT = 12,

   286

} RailGroundType;

   287

   288

static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)

   289

{

   290

	if (GetRailTileType(t) == RAIL_TYPE_DEPOT_WAYPOINT) {

   291

		SB(_m[t].m4, 0, 4, rgt);

   292

		return;

   293

	}

   294

	SB(_m[t].m2, 0, 4, rgt);

   295

}

   296

   297

static inline RailGroundType GetRailGroundType(TileIndex t)

   298

{

   299

	/* TODO Unify this */

   300

	if (GetRailTileType(t) == RAIL_TYPE_DEPOT_WAYPOINT) return GB(_m[t].m4, 0, 4);

   301

	return GB(_m[t].m2, 0, 4);

   302

}

   303

   304

static inline bool IsBarrenRailGround(TileIndex t)

   305

{

   306

	return GetRailGroundType(t) == RAIL_GROUND_BARREN;

   307

}

   308

   309

static inline bool IsSnowRailGround(TileIndex t)

   310

{

   311

	return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;

   312

}

   313

   314

   315

static inline void MakeRailNormal(TileIndex t, Owner o, TrackBits b, RailType r)

   316

{

   317

	SetTileType(t, MP_RAILWAY);

   318

	SetTileOwner(t, o);

   319

	_m[t].m2 = 0;

   320

	_m[t].m3 = r;

   321

	_m[t].m4 = 0;

   322

	_m[t].m5 = RAIL_TYPE_NORMAL | b;

   323

}

   324

   325

   326

static inline void MakeRailDepot(TileIndex t, Owner o, DiagDirection d, RailType r)

   327

{

   328

	SetTileType(t, MP_RAILWAY);

   329

	SetTileOwner(t, o);

   330

	_m[t].m2 = 0;

   331

	_m[t].m3 = r;

   332

	_m[t].m4 = 0;

   333

	_m[t].m5 = RAIL_TYPE_DEPOT_WAYPOINT | RAIL_SUBTYPE_DEPOT | d;

   334

}

   335

   336

   337

static inline void MakeRailWaypoint(TileIndex t, Owner o, Axis a, RailType r, uint index)

   338

{

   339

	SetTileType(t, MP_RAILWAY);

   340

	SetTileOwner(t, o);

   341

	_m[t].m2 = index;

   342

	_m[t].m3 = r;

   343

	_m[t].m4 = 0;

   344

	_m[t].m5 = RAIL_TYPE_DEPOT_WAYPOINT | RAIL_SUBTYPE_WAYPOINT | a;

   345

}

   346

   347

#endif