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_TILE_NORMAL         = 0x0,

    12

	RAIL_TILE_SIGNALS        = 0x40,

    13

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

    14

	RAIL_TILE_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 (RailTileType)(_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_TILE_NORMAL or RAIL_TILE_SIGNALS.

    27

 */

    28

static inline bool IsPlainRailTile(TileIndex tile)

    29

{

    30

	RailTileType rtt = GetRailTileType(tile);

    31

	return rtt == RAIL_TILE_NORMAL || rtt == RAIL_TILE_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_TILE_SIGNALS;

    40

}

    41

    42

    43

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

    44

 * RAIL_TILE_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_TILE_DEPOT_WAYPOINT

    54

 */

    55

static inline RailTileSubtype GetRailTileSubtype(TileIndex tile)

    56

{

    57

	assert(GetRailTileType(tile) == RAIL_TILE_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_NONE  = 0U,

   123

	TRACK_BIT_X     = 1U << TRACK_X,

   124

	TRACK_BIT_Y     = 1U << TRACK_Y,

   125

	TRACK_BIT_UPPER = 1U << TRACK_UPPER,

   126

	TRACK_BIT_LOWER = 1U << TRACK_LOWER,

   127

	TRACK_BIT_LEFT  = 1U << TRACK_LEFT,

   128

	TRACK_BIT_RIGHT = 1U << TRACK_RIGHT,

   129

	TRACK_BIT_CROSS = TRACK_BIT_X     | TRACK_BIT_Y,

   130

	TRACK_BIT_HORZ  = TRACK_BIT_UPPER | TRACK_BIT_LOWER,

   131

	TRACK_BIT_VERT  = TRACK_BIT_LEFT  | TRACK_BIT_RIGHT,

   132

	TRACK_BIT_3WAY_NE = TRACK_BIT_X | TRACK_BIT_UPPER | TRACK_BIT_RIGHT,

   133

	TRACK_BIT_3WAY_SE = TRACK_BIT_Y | TRACK_BIT_LOWER | TRACK_BIT_RIGHT,

   134

	TRACK_BIT_3WAY_SW = TRACK_BIT_X | TRACK_BIT_LOWER | TRACK_BIT_LEFT,

   135

	TRACK_BIT_3WAY_NW = TRACK_BIT_Y | TRACK_BIT_UPPER | TRACK_BIT_LEFT,

   136

	TRACK_BIT_ALL   = TRACK_BIT_CROSS | TRACK_BIT_HORZ | TRACK_BIT_VERT,

   137

	TRACK_BIT_MASK  = 0x3FU

   138

} TrackBits;

   139

   140

static inline TrackBits GetTrackBits(TileIndex tile)

   141

{

   142

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

   143

}

   144

   145

static inline void SetTrackBits(TileIndex t, TrackBits b)

   146

{

   147

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

   148

}

   149

   150

/**

   151

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

   152

 * a plain rail tile (IsPlainRailTile()).

   153

 */

   154

static inline bool HasTrack(TileIndex tile, Track track)

   155

{

   156

	return HASBIT(GetTrackBits(tile), track);

   157

}

   158

   159

   160

static inline DiagDirection GetRailDepotDirection(TileIndex t)

   161

{

   162

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

   163

}

   164

   165

static inline Track GetRailWaypointTrack(TileIndex t)

   166

{

   167

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

   168

}

   169

   170

static inline TrackBits GetRailWaypointBits(TileIndex t)

   171

{

   172

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

   173

}

   174

   175

static inline void SetCustomWaypointSprite(TileIndex t)

   176

{

   177

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

   178

}

   179

   180

static inline void ClearCustomWaypointSprite(TileIndex t)

   181

{

   182

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

   183

}

   184

   185

static inline bool IsCustomWaypoint(TileIndex t)

   186

{

   187

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

   188

}

   189

   190

static inline Axis GetWaypointAxis(TileIndex t)

   191

{

   192

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

   193

}

   194

   195

   196

typedef enum SignalType {

   197

	SIGTYPE_NORMAL  = 0, // normal signal

   198

	SIGTYPE_ENTRY   = 1, // presignal block entry

   199

	SIGTYPE_EXIT    = 2, // presignal block exit

   200

	SIGTYPE_COMBO   = 3  // presignal inter-block

   201

} SignalType;

   202

   203

static inline SignalType GetSignalType(TileIndex t)

   204

{

   205

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   206

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

   207

}

   208

   209

static inline void SetSignalType(TileIndex t, SignalType s)

   210

{

   211

	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);

   212

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

   213

}

   214

   215

static inline bool IsPresignalEntry(TileIndex t)

   216

{

   217

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

   218

}

   219

   220

static inline bool IsPresignalExit(TileIndex t)

   221

{

   222

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

   223

}

   224

   225

static inline void CycleSignalSide(TileIndex t, Track track)

   226

{

   227

	byte sig;

   228

	byte pos = 6;

   229

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

   230

   231

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

   232

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

   233

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

   234

}

   235

   236

   237

typedef enum SignalVariant {

   238

	SIG_ELECTRIC  = 0,

   239

	SIG_SEMAPHORE = 1

   240

} SignalVariant;

   241

   242

static inline SignalVariant GetSignalVariant(TileIndex t)

   243

{

   244

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

   245

}

   246

   247

static inline void SetSignalVariant(TileIndex t, SignalVariant v)

   248

{

   249

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

   250

}

   251

   252

static inline bool IsSignalPresent(TileIndex t, byte signalbit)

   253

{

   254

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

   255

}

   256

   257

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

   258

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

   259

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

   260

 */

   261

typedef enum SignalStates {

   262

	SIGNAL_STATE_RED = 0,

   263

	SIGNAL_STATE_GREEN = 1,

   264

} SignalState;

   265

   266

static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)

   267

{

   268

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

   269

}

   270

   271

   272

typedef enum RailGroundType {

   273

	RAIL_MAP2LO_GROUND_MASK = 0xF,

   274

	RAIL_GROUND_BARREN = 0,

   275

	RAIL_GROUND_GRASS = 1,

   276

	RAIL_GROUND_FENCE_NW = 2,

   277

	RAIL_GROUND_FENCE_SE = 3,

   278

	RAIL_GROUND_FENCE_SENW = 4,

   279

	RAIL_GROUND_FENCE_NE = 5,

   280

	RAIL_GROUND_FENCE_SW = 6,

   281

	RAIL_GROUND_FENCE_NESW = 7,

   282

	RAIL_GROUND_FENCE_VERT1 = 8,

   283

	RAIL_GROUND_FENCE_VERT2 = 9,

   284

	RAIL_GROUND_FENCE_HORIZ1 = 10,

   285

	RAIL_GROUND_FENCE_HORIZ2 = 11,

   286

	RAIL_GROUND_ICE_DESERT = 12,

   287

} RailGroundType;

   288

   289

static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)

   290

{

   291

	if (GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT) {

   292

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

   293

		return;

   294

	}

   295

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

   296

}

   297

   298

static inline RailGroundType GetRailGroundType(TileIndex t)

   299

{

   300

	/* TODO Unify this */

   301

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

   302

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

   303

}

   304

   305

static inline bool IsBarrenRailGround(TileIndex t)

   306

{

   307

	return GetRailGroundType(t) == RAIL_GROUND_BARREN;

   308

}

   309

   310

static inline bool IsSnowRailGround(TileIndex t)

   311

{

   312

	return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;

   313

}

   314

   315

   316

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

   317

{

   318

	SetTileType(t, MP_RAILWAY);

   319

	SetTileOwner(t, o);

   320

	_m[t].m2 = 0;

   321

	_m[t].m3 = r;

   322

	_m[t].m4 = 0;

   323

	_m[t].m5 = RAIL_TILE_NORMAL | b;

   324

}

   325

   326

   327

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

   328

{

   329

	SetTileType(t, MP_RAILWAY);

   330

	SetTileOwner(t, o);

   331

	_m[t].m2 = 0;

   332

	_m[t].m3 = r;

   333

	_m[t].m4 = 0;

   334

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

   335

}

   336

   337

   338

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

   339

{

   340

	SetTileType(t, MP_RAILWAY);

   341

	SetTileOwner(t, o);

   342

	_m[t].m2 = index;

   343

	_m[t].m3 = r;

   344

	_m[t].m4 = 0;

   345

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

   346

}

   347

   348

#endif