1

/* $Id$ */

     2

/** @file elrail.c

     3

  This file deals with displaying wires and pylons for electric railways.

     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 bitmapped to a byte

    26

variable and are represented by the DiagDirection enum

    27

    28

Each track ends on two PCPs and thus requires one pylon on each end. However,

    29

there is one exception: Straight-and-level tracks only have one pylon every

    30

other tile.

    31

    32

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

    33

are merged using an OR operation (i. e. if one tile needs a PCP at the postion

    34

in question, both tiles get it).

    35

    36

<h4>Position Points</h4>

    37

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

    38

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

    39

it. PPPs are represented using the Direction enum. Each track bit has PPPs

    40

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

    41

some that are preferred (because the pylon would be rectangular to the track).

    42

    43

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

    44

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

    45

    46

  */

    47

    48

#include "stdafx.h"

    49

#include "openttd.h"

    50

#include "station_map.h"

    51

#include "tile.h"

    52

#include "viewport.h"

    53

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

    54

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

    55

#include "rail.h"

    56

#include "debug.h"

    57

#include "tunnel_map.h"

    58

#include "road_map.h"

    59

#include "bridge_map.h"

    60

#include "bridge.h"

    61

#include "rail_map.h"

    62

#include "table/sprites.h"

    63

#include "table/elrail_data.h"

    64

    65

static inline TLG GetTLG(TileIndex t)

    66

{

    67

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

    68

}

    69

    70

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

    71

  * returns track bits under the bridge

    72

  */

    73

static TrackBits GetRailTrackBitsUniversal(TileIndex t, byte *override)

    74

{

    75

	switch (GetTileType(t)) {

    76

		case MP_RAILWAY:

    77

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

    78

			switch (GetRailTileType(t)) {

    79

				case RAIL_TYPE_NORMAL: case RAIL_TYPE_SIGNALS:

    80

					return GetTrackBits(t);

    81

				case RAIL_TYPE_DEPOT_WAYPOINT:

    82

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

    83

				default:

    84

					return 0;

    85

			}

    86

			break;

    87

		case MP_TUNNELBRIDGE:

    88

			if (IsTunnel(t)) {

    89

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

    90

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

    91

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

    92

			} else {

    93

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

    94

				if (IsBridgeMiddle(t)) {

    95

					if (IsTransportUnderBridge(t) &&

    96

						GetTransportTypeUnderBridge(t) == TRANSPORT_RAIL) {

    97

						return GetRailBitsUnderBridge(t);

    98

					} else {

    99

						return 0;

   100

					}

   101

				} else {

   102

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

   103

   104

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

   105

				}

   106

			}

   107

		case MP_STREET:

   108

			if (GetRoadType(t) != ROAD_CROSSING) return 0;

   109

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

   110

			return GetCrossingRailBits(t);

   111

		case MP_STATION:

   112

			if (!IsRailwayStation(t)) return 0;

   113

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

   114

			return TrackToTrackBits(GetRailStationTrack(t));

   115

		default:

   116

			return 0;

   117

	}

   118

}

   119

   120

/** Corrects the tileh for certain tile types. Returns an effective tileh for the track on the tile.

   121

  * @param tile The tile to analyse

   122

  * @param *tileh the tileh

   123

  */

   124

static void AdjustTileh(TileIndex tile, uint *tileh)

   125

{

   126

	if (IsTunnelTile(tile)) *tileh = 0;

   127

	if (IsBridgeTile(tile) && IsBridgeRamp(tile)) {

   128

		if (*tileh != 0) {

   129

			*tileh = 0;

   130

		} else {

   131

			switch (GetBridgeRampDirection(tile)) {

   132

				case DIAGDIR_NE: *tileh = 12; break;

   133

				case DIAGDIR_SE: *tileh =  6; break;

   134

				case DIAGDIR_SW: *tileh =  3; break;

   135

				case DIAGDIR_NW: *tileh =  9; break;

   136

				default: break;

   137

			}

   138

		}

   139

	}

   140

}

   141

   142

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

   143

  * @param ti The Tileinfo to draw the tile for

   144

  */

   145

static void DrawCatenaryRailway(const TileInfo *ti)

   146

{

   147

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

   148

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

   149

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

   150

	TrackBits trackconfig[TS_END];

   151

	bool isflat[TS_END];

   152

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

   153

	uint tileh[TS_END] = {ti->tileh, 0};

   154

   155

	TLG tlg = GetTLG(ti->tile);

   156

	byte PCPstatus = 0;

   157

	byte OverridePCP = 0;

   158

	byte PPPpreferred[DIAGDIR_END];

   159

	byte PPPallowed[DIAGDIR_END];

   160

	DiagDirection i;

   161

	Track t;

   162

   163

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

   164

	   We don't draw a pylon:

   165

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

   166

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

   167

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

   168

	      which have no middle tiles */

   169

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

   170

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

   171

	isflat[TS_HOME] = trackconfig[TS_HOME] & (TRACK_BIT_HORZ | TRACK_BIT_VERT);

   172

   173

	AdjustTileh(ti->tile, &tileh[TS_HOME]);

   174

   175

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

   176

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

   177

		uint foundation = 0;

   178

		int k;

   179

   180

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

   181

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

   182

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

   183

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

   184

		if (IsTunnelTile(neighbour) && i != GetTunnelDirection(neighbour)) trackconfig[TS_NEIGHBOUR] = 0;

   185

		isflat[TS_NEIGHBOUR] = trackconfig[TS_NEIGHBOUR] & (TRACK_BIT_HORZ | TRACK_BIT_VERT);

   186

   187

		PPPpreferred[i] = 0xFF; /* We start with preferring everything (end-of-line in any direction) */

   188

		PPPallowed[i] = AllowedPPPonPCP[i];

   189

   190

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

   191

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

   192

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

   193

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

   194

			if (TrackSourceTile[i][k] == TS_NEIGHBOUR &&

   195

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

   196

			    GetBridgeRampDirection(neighbour) == ReverseDiagDir(i)

   197

			   ) continue;

   198

   199

			/* We check whether the track in question (k) is present in the tile

   200

			   (TrackSourceTile) */

   201

			if (HASBIT(trackconfig[TrackSourceTile[i][k]], TracksAtPCP[i][k])) {

   202

				/* track found, if track is in the neighbour tile, adjust the number

   203

				   of the PCP for preferred/allowed determination*/

   204

				DiagDirection PCPpos = (TrackSourceTile[i][k] == TS_HOME) ? i : ReverseDiagDir(i);

   205

				SETBIT(PCPstatus, i); /* This PCP is in use */

   206

   207

				PPPpreferred[i] &= PreferredPPPofTrackAtPCP[TracksAtPCP[i][k]][PCPpos];

   208

				PPPallowed[i] &= ~DisallowedPPPofTrackAtPCP[TracksAtPCP[i][k]][PCPpos];

   209

			}

   210

		}

   211

   212

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

   213

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

   214

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

   215

   216

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

   217

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

   218

   219

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

   220

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

   221

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

   222

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

   223

		}

   224

   225

		if (foundation != 0) {

   226

			if (foundation < 15) {

   227

				tileh[TS_NEIGHBOUR] = 0;

   228

			} else {

   229

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

   230

			}

   231

		}

   232

   233

		AdjustTileh(neighbour, &tileh[TS_NEIGHBOUR]);

   234

   235

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

   236

		   Delete the PCP if this is the case. */

   237

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

   238

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

   239

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

   240

				if (PPPpreferred[i] == IgnoredPCP[k][tlg][i]) CLRBIT(PCPstatus, i);

   241

		}

   242

   243

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

   244

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

   245

		   anything. Note that the preferred PPPs still contain the end-of-line markers.

   246

		   Remove those (simply by ANDing with allowed, since these markers are never allowed) */

   247

		if ( (PPPallowed[i] & PPPpreferred[i]) != 0) PPPallowed[i] &= PPPpreferred[i];

   248

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

   256

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

   257

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

   258

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

   259

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

   260

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

   261

					}

   262

   263

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

   264

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

   265

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

   266

				}

   267

			}

   268

		}

   269

	}

   270

   271

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

   272

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

   273

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

   274

   275

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

   276

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

   277

   278

			const SortableSpriteStruct *sss;

   279

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

   280

   281

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

   282

					IsBridgeTile(ti->tile) &&

   283

					IsBridgeMiddle(ti->tile) &&

   284

					!(_display_opt & DO_TRANS_BUILDINGS) &&

   285

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

   286

			   ) return;

   287

   288

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

   289

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

   290

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

   291

   292

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

   293

				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);

   294

		}

   295

	}

   296

}

   297

   298

static void DrawCatenaryOnBridge(const TileInfo *ti)

   299

{

   300

	TileIndex end = GetSouthernBridgeEnd(ti->tile);

   301

	TileIndex start = GetOtherBridgeEnd(end);

   302

   303

	uint length = GetBridgeLength(start, end);

   304

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

   305

   306

	const SortableSpriteStruct *sss;

   307

	Axis axis = GetBridgeAxis(ti->tile);

   308

	TLG tlg = GetTLG(ti->tile);

   309

   310

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

   311

   312

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

   313

		/* Draw the "short" wire on the southern end of the bridge

   314

		 * only needed if the length of the bridge is odd */

   315

		sss = &CatenarySpriteData[WIRE_X_FLAT_BOTH + offset];

   316

	} else {

   317

		/* Draw "long" wires on all other tiles of the bridge (one pylon every two tiles) */

   318

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

   319

	}

   320

   321

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

   322

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

   323

   324

	/* Finished with wires, draw pylons */

   325

	/* every other tile needs a pylon on the northern end */

   326

	if (num % 2) {

   327

		if (axis == AXIS_X) {

   328

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

   329

		} else {

   330

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

   331

		}

   332

	}

   333

   334

	/* need a pylon on the southern end of the bridge */

   335

	if (DistanceMax(ti->tile, start) == length) {

   336

		if (axis == AXIS_X) {

   337

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

   338

		} else {

   339

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

   340

		}

   341

	}

   342

}

   343

   344

void DrawCatenary(const TileInfo *ti)

   345

{

   346

	switch (GetTileType(ti->tile)) {

   347

		case MP_RAILWAY:

   348

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

   349

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

   350

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

   351

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

   352

				return;

   353

			}

   354

			/* Fall through */

   355

		case MP_TUNNELBRIDGE:

   356

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

   357

			/* Fall further */

   358

		case MP_STREET: case MP_STATION:

   359

			DrawCatenaryRailway(ti);

   360

			break;

   361

		default:

   362

			break;

   363

	}

   364

}

   365