1

/* $Id$ */

     2

/** @file elrail.c

     3

  * This file deals with displaying wires and pylons for electric railway systems.

     4

<h2>Basics</h2>

     5

     6

<h3>Tile Types</h3>

     7

     8

We have two different types of tiles in the drawing code:

     9

Normal Railway Tiles (NRTs) which can have more than one track on it, and

    10

Special Railways tiles (SRTs) which have only one track (like crossings, depots

    11

stations, etc).

    12

    13

<h3>Location Categories</h3>

    14

    15

All tiles are categorized into three location groups (TLG):

    16

Group 0: Tiles with both an even X coordinate and an even Y coordinate

    17

Group 1: Tiles with an even X and an odd Y coordinate

    18

Group 2: Tiles with an odd X and an even Y coordinate

    19

Group 3: Tiles with both an odd X and Y coordnate.

    20

    21

<h3>Pylon Points</h3>

    22

<h4>Control Points</h4>

    23

A Pylon Control Point (PCP) is a position where a wire (or rather two)

    24

is mounted onto a pylon.

    25

Each NRT does contain 4 PCPs which are mapped to a byte

    26

variable and are represented by the DiagDirection enum:

    27

    28

A wire that ends on the PCP has a dark ending, otherwise the end is bright.<p>

    29

    30

Now on each edge there are two PCPs: One from each adjacent tile. Both PCPs are merged

    31

using an OR matrix (i. e. if one tile needs a PCP at the postion in question, both

    32

tiles get it).

    33

    34

<h4>Position Points</h4>

    35

A Pylon Position Point (PPP) is a position where a pylon is located on the ground.

    36

Each PCP owns 8 in (45 degree steps) PPPs that are located around it. PPPs are numbered

    37

0 to 7 with 0 starting north and numbering in clockwise direction. Each track bit has PPPs

    38

that are impossible (because the pylon would be situated on the track), preferred (because

    39

the pylon would be rectangular to the track). PPPs are represented by the Direction enum.

    40

    41

<img src="../../elrail_tile.png">

    42

<img src="../../elrail_track.png">

    43

    44

  */

    45

    46

#include "stdafx.h"

    47

#include "openttd.h"

    48

#include "station_map.h"

    49

#include "tile.h"

    50

#include "viewport.h"

    51

#include "functions.h" /* We should REALLY get rid of this goddamn file, as it is butt-ugly */

    52

#include "variables.h" /* ... same here */

    53

#include "rail.h"

    54

#include "debug.h"

    55

#include "tunnel_map.h"

    56

#include "road_map.h"

    57

#include "bridge_map.h"

    58

#include "bridge.h"

    59

#include "rail_map.h"

    60

#include "table/sprites.h"

    61

#include "table/elrail_data.h"

    62

    63

static inline TLG GetTLG(TileIndex t)

    64

{

    65

	return (HASBIT(TileX(t), 0) << 1) + HASBIT(TileY(t), 0);

    66

}

    67

    68

/** Finds which Rail Bits are present on a given tile. For bridge tiles,

    69

  * returns track bits under the bridge

    70

  */

    71

static TrackBits GetRailTrackBitsUniversal(TileIndex t, byte *override)

    72

{

    73

	switch (GetTileType(t)) {

    74

		case MP_RAILWAY:

    75

			if (GetRailType(t) != RAILTYPE_ELECTRIC) return 0;

    76

			switch (GetRailTileType(t)) {

    77

				case RAIL_TYPE_NORMAL: case RAIL_TYPE_SIGNALS:

    78

					return GetTrackBits(t);

    79

				case RAIL_TYPE_DEPOT_WAYPOINT:

    80

					if (GetRailTileSubtype(t) == RAIL_SUBTYPE_WAYPOINT) return GetRailWaypointBits(t);

    81

				default:

    82

					return 0;

    83

			}

    84

			break;

    85

		case MP_TUNNELBRIDGE:

    86

			if (IsTunnel(t)) {

    87

				if (GetRailType(t) != RAILTYPE_ELECTRIC) return 0;

    88

				if (override != NULL) *override = 1 << GetTunnelDirection(t);

    89

				return DiagDirToAxis(GetTunnelDirection(t)) == AXIS_X ? TRACK_BIT_X : TRACK_BIT_Y;

    90

			} else {

    91

				if (GetRailType(t) != RAILTYPE_ELECTRIC) return 0;

    92

				if (

    93

					IsBridgeMiddle(t) &&

    94

					IsTransportUnderBridge(t) &&

    95

					GetTransportTypeUnderBridge(t) == TRANSPORT_RAIL) {

    96

					return GetRailBitsUnderBridge(t);

    97

				} else {

    98

					if (override != NULL && DistanceMax(t, GetOtherBridgeEnd(t)) > 1) *override = 1 << GetBridgeRampDirection(t);

    99

   100

					return DiagDirToAxis(GetBridgeRampDirection(t)) == AXIS_X ? TRACK_BIT_X : TRACK_BIT_Y;

   101

				}

   102

			}

   103

		case MP_STREET:

   104

			if (GetRailTypeCrossing(t) != RAILTYPE_ELECTRIC) return 0;

   105

			return GetCrossingRailBits(t);

   106

		case MP_STATION:

   107

			if (GetRailType(t) != RAILTYPE_ELECTRIC) return 0;

   108

			return TrackToTrackBits(GetRailStationTrack(t));

   109

		default:

   110

			return 0;

   111

	}

   112

}

   113

   114

/** Draws wires and, if required, pylons on a given tile

   115

  * @param ti The Tileinfo to draw the tile for

   116

  * @todo Currently, each pylon is drawn twice (once for each neighbouring tiles use OwnedPPPonPCP for this)

   117

  */

   118

static void DrawCatenaryRailway(const TileInfo *ti)

   119

{

   120

	/* Pylons are placed on a tile edge, so we need to take into account

   121

	   the track configuration of 2 adjacent tiles. trackconfig[0] stores the

   122

	   current tile (home tile) while [1] holds the neighbour */

   123

	TrackBits trackconfig[TS_END];

   124

	bool isflat[TS_END];

   125

	/* Note that ti->tileh has already been adjusted for Foundations */

   126

	uint tileh[TS_END];

   127

   128

	TLG tlg = GetTLG(ti->tile);

   129

	byte PCPstatus = 0;

   130

	byte OverridePCP = 0;

   131

	byte PPPpreferred[DIAGDIR_END];

   132

	byte PPPallowed[DIAGDIR_END];

   133

	byte PPPbuffer[DIAGDIR_END];

   134

	DiagDirection i;

   135

	Track t;

   136

   137

	tileh[0] = ti->tileh;

   138

	tileh[1] = 0;

   139

   140

	PPPpreferred[0] = PPPpreferred[1] = PPPpreferred[2] = PPPpreferred[3] = 0xFF;

   141

	PPPallowed[0] = AllowedPPPonPCP[0];

   142

	PPPallowed[1] = AllowedPPPonPCP[1];

   143

	PPPallowed[2] = AllowedPPPonPCP[2];

   144

	PPPallowed[3] = AllowedPPPonPCP[3];

   145

   146

	/* Find which rail bits are present, and select the override points.

   147

	   We don't draw a pylon:

   148

	   1) INSIDE a tunnel (we wouldn't see it anyway)

   149

	   2) on the "far" end of a bridge head (the one that connects to bridge middle),

   150

	      because that one is drawn on the bridge. Exception is for length 0 bridges

   151

	      which have no middle tiles */

   152

	trackconfig[TS_HOME] = GetRailTrackBitsUniversal(ti->tile, &OverridePCP);

   153

	/* If a track bit is present that is not in the main direction, the track is level */

   154

	isflat[TS_HOME] = trackconfig[TS_HOME] & (TRACK_BIT_UPPER | TRACK_BIT_LOWER | TRACK_BIT_LEFT | TRACK_BIT_RIGHT);

   155

   156

	if (IsTunnelTile(ti->tile)) tileh[TS_HOME] = 0;

   157

	if (IsBridgeTile(ti->tile) && IsBridgeRamp(ti->tile)) {

   158

		if (tileh[TS_HOME] != 0) {

   159

			tileh[TS_HOME] = 0;

   160

		} else {

   161

			switch (GetBridgeRampDirection(ti->tile)) {

   162

				case DIAGDIR_NE: tileh[TS_HOME] = 12; break;

   163

				case DIAGDIR_SE: tileh[TS_HOME] =  6; break;

   164

				case DIAGDIR_SW: tileh[TS_HOME] =  3; break;

   165

				case DIAGDIR_NW: tileh[TS_HOME] =  9; break;

   166

				default: break;

   167

			}

   168

		}

   169

	}

   170

   171

	for (i = DIAGDIR_NE; i < DIAGDIR_END; i++) {

   172

		TileIndex neighbour = ti->tile + TileOffsByDir(i);

   173

		uint foundation = 0;

   174

		int k;

   175

   176

		/* Here's one of the main headaches. GetTileSlope does not correct for possibly

   177

		   existing foundataions, so we do have to do that manually later on.*/

   178

		tileh[TS_NEIGHBOUR] = GetTileSlope(neighbour, NULL);

   179

		trackconfig[TS_NEIGHBOUR] = GetRailTrackBitsUniversal(neighbour, NULL);

   180

		isflat[TS_NEIGHBOUR] = trackconfig[TS_NEIGHBOUR] & (TRACK_BIT_UPPER | TRACK_BIT_LOWER | TRACK_BIT_LEFT | TRACK_BIT_RIGHT);

   181

   182

		/* We cycle through all the existing tracks at a PCP and see what

   183

		   PPPs we want to have, or may not have at all */

   184

		for (k = 0; k < TRACKS_AT_PCP; k++) {

   185

			/* Next to us, we have a bridge head, don't worry about that one, if it shows away from us */

   186

			if (

   187

					trackorigin[i][k] == TS_NEIGHBOUR &&

   188

					IsBridgeTile(neighbour) && IsBridgeRamp(neighbour) &&

   189

					GetBridgeRampDirection(neighbour) == ReverseDiagDir(i)

   190

			   ) continue;

   191

   192

			if (HASBIT(trackconfig[trackorigin[i][k]], PPPtracks[i][k])) {

   193

				DiagDirection PCPpos = (trackorigin[i][k] == 0) ? i : ReverseDiagDir(i);

   194

				PCPstatus |= 1 << i; /* This PCP is in use */

   195

				PPPpreferred[i] &= PreferredPPPofTrackBitAtPCP[PPPtracks[i][k]][PCPpos];

   196

				PPPallowed[i] &= ~DisallowedPPPofTrackBitAtPCP[PPPtracks[i][k]][PCPpos];

   197

			}

   198

		}

   199

   200

		/* Deactivate all PPPs if PCP is not used */

   201

		PPPpreferred[i] *= HASBIT(PCPstatus, i);

   202

		PPPallowed[i] *= HASBIT(PCPstatus, i);

   203

   204

		/* Station on a non-flat tile means foundation. add one height level and adjust tileh */

   205

		if (IsTileType(neighbour, MP_STATION) && tileh[TS_NEIGHBOUR] != 0) tileh[TS_NEIGHBOUR] = 0;

   206

   207

		/* Read the foundataions if they are present, and adjust the tileh */

   208

		if (IsTileType(neighbour, MP_RAILWAY)) foundation = GetRailFoundation(tileh[TS_NEIGHBOUR], trackconfig[TS_NEIGHBOUR]);

   209

		if (IsBridgeTile(neighbour) && IsBridgeRamp(neighbour)) {

   210

			foundation = GetBridgeFoundation(tileh[TS_NEIGHBOUR], DiagDirToAxis(GetBridgeRampDirection(neighbour)));

   211

		}

   212

   213

		if (foundation != 0) {

   214

			if (foundation < 15) {

   215

				tileh[TS_NEIGHBOUR] = 0;

   216

			} else {

   217

				tileh[TS_NEIGHBOUR] = _inclined_tileh[foundation - 15];

   218

			}

   219

		}

   220

   221

		/* Convert the real tileh into a pseudo-tileh for the track */

   222

		if (IsTunnelTile(neighbour)) tileh[TS_NEIGHBOUR] = 0;

   223

		if (IsBridgeTile(neighbour) && IsBridgeRamp(neighbour)) {

   224

			if (tileh[TS_NEIGHBOUR] != 0) {

   225

				tileh[TS_NEIGHBOUR] = 0;

   226

			} else {

   227

				switch (GetBridgeRampDirection(neighbour)) {

   228

					case DIAGDIR_NE: tileh[TS_NEIGHBOUR] = 12; break;

   229

					case DIAGDIR_SE: tileh[TS_NEIGHBOUR] =  6; break;

   230

					case DIAGDIR_SW: tileh[TS_NEIGHBOUR] =  3; break;

   231

					case DIAGDIR_NW: tileh[TS_NEIGHBOUR] =  9; break;

   232

					default: break;

   233

				}

   234

			}

   235

		}

   236

   237

		/* If we have a straight (and level) track, we want a pylon only every 2 tiles

   238

		   Delete the PCP if this is the case. */

   239

		/* Level means that the slope is the same, or the track is flat */

   240

		if (tileh[TS_HOME] == tileh[TS_NEIGHBOUR] || (isflat[TS_HOME] && isflat[TS_NEIGHBOUR])) {

   241

			for (k = 0; k < NUM_IGNORE_GROUPS; k++)

   242

				if (PPPpreferred[i] == IgnoredPCP[k][tlg][i]) PCPstatus &= ~(1 << i);

   243

		}

   244

   245

		/* Now decide where we draw our tiles. First try the preferred PPPs, but they may not exist.

   246

		   In that case, we try the any of the allowed ones. if they don't exist either, don't draw

   247

		   anything */

   248

		if (PPPpreferred[i] != 0) {

   249

			/* Some of the preferred PPPs (the ones in direct extension of the track bit)

   250

			   have been used as an "end of line" marker. As these are not ALLOWED, this operation

   251

			   cancles them out */

   252

			PPPbuffer[i] = PPPpreferred[i] & PPPallowed[i];

   253

			/* We haven't any buffer yet, so try something else. Fixes 90° curves */

   254

			if (PPPbuffer[i] == 0) PPPbuffer[i] = PPPallowed[i];

   255

		} else {

   256

			PPPbuffer[i] = PPPallowed[i];

   257

		}

   258

   259

		if (PPPbuffer[i] != 0 && HASBIT(PCPstatus, i) && !HASBIT(OverridePCP, i)) {

   260

			for (k = 0; k < DIR_END; k++) {

   261

				byte temp = PPPorder[i][GetTLG(ti->tile)][k];

   262

				if (HASBIT(PPPbuffer[i], temp)) {

   263

					uint x  = ti->x + x_pcp_offsets[i] + x_ppp_offsets[temp];

   264

					uint y  = ti->y + y_pcp_offsets[i] + y_ppp_offsets[temp];

   265

   266

					/* Don't build the pylon if it would be outside the tile */

   267

					if (!HASBIT(OwnedPPPonPCP[i], temp)) {

   268

						/* We have a neighour that will draw it, bail out */

   269

						if (trackconfig[TS_NEIGHBOUR] != 0) break;

   270

						continue; /* No neighbour, go looking for a better position */

   271

					}

   272

   273

					AddSortableSpriteToDraw(pylons_normal[temp], x, y, 1, 1, 10,

   274

							GetSlopeZ(ti->x + x_pcp_offsets[i], ti->y + y_pcp_offsets[i]));

   275

					break; /* We already have drawn a pylon, bail out */

   276

				}

   277

			}

   278

		}

   279

	}

   280

   281

	/* Drawing of pylons is finished, now draw the wires */

   282

	for (t = 0; t < TRACK_END; t++) {

   283

		if (HASBIT(trackconfig[TS_HOME], t)) {

   284

   285

			byte PCPconfig = HASBIT(PCPstatus, PCPpositions[t][0]) +

   286

				(HASBIT(PCPstatus, PCPpositions[t][1]) << 1);

   287

   288

			const SortableSpriteStruct *sss;

   289

			int tileh_selector = !(tileh[TS_HOME] % 3) * tileh[TS_HOME] / 3; /* tileh for the slopes, 0 otherwise */

   290

   291

			if ( /* We are not drawing a wire under a low bridge */

   292

					IsBridgeTile(ti->tile) &&

   293

					IsBridgeMiddle(ti->tile) &&

   294

					!(_display_opt & DO_TRANS_BUILDINGS) &&

   295

					GetBridgeHeight(ti->tile) <= TilePixelHeight(ti->tile)

   296

			   ) return;

   297

   298

			assert(PCPconfig != 0); /* We have a pylon on neither end of the wire, that doesn't work (since we have no sprites for that) */

   299

			assert(!IsSteepTileh(tileh[TS_HOME]));

   300

			sss = &CatenarySpriteData[Wires[tileh_selector][t][PCPconfig]];

   301

   302

			AddSortableSpriteToDraw( sss->image, ti->x + sss->x_offset, ti->y + sss->y_offset,

   303

				sss->x_size, sss->y_size, sss->z_size, GetSlopeZ(ti->x + min(sss->x_offset, 15), ti->y + min(sss->y_offset, 15)) + sss->z_offset);

   304

		}

   305

	}

   306

}

   307

   308

static void DrawCatenaryOnBridge(const TileInfo *ti)

   309

{

   310

	TileIndex start = GetOtherBridgeEnd(GetSouthernBridgeEnd(ti->tile));

   311

	uint length = GetBridgeLength(GetSouthernBridgeEnd(ti->tile), GetOtherBridgeEnd(GetSouthernBridgeEnd(ti->tile)));

   312

	uint num = DistanceMax(ti->tile, start);

   313

	const SortableSpriteStruct *sss;

   314

	Axis axis = GetBridgeAxis(ti->tile);

   315

	TLG tlg = GetTLG(ti->tile);

   316

   317

	CatenarySprite offset = axis == AXIS_X ? 0 : WIRE_Y_FLAT_BOTH - WIRE_X_FLAT_BOTH;

   318

   319

	if ((length % 2) && num == length) {

   320

		sss = &CatenarySpriteData[WIRE_X_FLAT_BOTH + offset];

   321

	} else {

   322

		sss = &CatenarySpriteData[WIRE_X_FLAT_SW + (num % 2) + offset];

   323

	}

   324

   325

	if (num % 2) {

   326

		if (axis == AXIS_X) {

   327

			AddSortableSpriteToDraw( pylons_bridge[0 + HASBIT(tlg, 0)], ti->x, ti->y + 4 + 8 * HASBIT(tlg, 0), 1, 1, 10, GetBridgeHeight(ti->tile) + 8);

   328

		} else {

   329

			AddSortableSpriteToDraw( pylons_bridge[2 + HASBIT(tlg, 1)], ti->x + 4 + 8 * HASBIT(tlg, 1), ti->y, 1, 1, 10, GetBridgeHeight(ti->tile) + 8);

   330

		}

   331

	}

   332

   333

	if (DistanceMax(ti->tile, start) == length) { /* need a pylon here (the southern end) */

   334

		if (axis == AXIS_X) {

   335

			AddSortableSpriteToDraw( pylons_bridge[0 + HASBIT(tlg, 0)], ti->x + 16, ti->y + 4 + 8 * HASBIT(tlg, 0), 1, 1, 10, GetBridgeHeight(ti->tile) + 8);

   336

		} else {

   337

			AddSortableSpriteToDraw( pylons_bridge[2 + HASBIT(tlg, 1)], ti->x + 4 + 8 * HASBIT(tlg, 1), ti->y + 16, 1, 1, 10, GetBridgeHeight(ti->tile) + 8);

   338

		}

   339

	}

   340

   341

	AddSortableSpriteToDraw( sss->image, ti->x + sss->x_offset, ti->y + sss->y_offset,

   342

			sss->x_size, sss->y_size, sss->z_size, GetBridgeHeight(ti->tile) + sss->z_offset + 8);

   343

}

   344

   345

void DrawCatenary(const TileInfo *ti)

   346

{

   347

	switch (GetTileType(ti->tile)) {

   348

		case MP_RAILWAY:

   349

			if (GetRailTileType(ti->tile) == RAIL_TYPE_DEPOT_WAYPOINT && GetRailTileSubtype(ti->tile) == RAIL_SUBTYPE_DEPOT) {

   350

				const SortableSpriteStruct *sss = &CatenarySpriteData[WIRE_DEPOT_SW + ReverseDiagDir(GetRailDepotDirection(ti->tile))];

   351

				AddSortableSpriteToDraw( sss->image, ti->x + sss->x_offset, ti->y + sss->y_offset,

   352

					sss->x_size, sss->y_size, sss->z_size, GetSlopeZ(ti->x, ti->y) + sss->z_offset);

   353

				return;

   354

			}

   355

			/* Fall through */

   356

		case MP_TUNNELBRIDGE:

   357

			if (IsBridgeTile(ti->tile) && IsBridgeMiddle(ti->tile) && GetRailTypeOnBridge(ti->tile) == RAILTYPE_ELECTRIC) DrawCatenaryOnBridge(ti);

   358

			/* Fall further */

   359

		case MP_STREET: case MP_STATION:

   360

			DrawCatenaryRailway(ti);

   361

			break;

   362

		default:

   363

			break;

   364

	}

   365

}

   366