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_TILE_NORMAL: case RAIL_TILE_SIGNALS:

    80

					return GetTrackBits(t);

    81

				case RAIL_TILE_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 (override != NULL && DistanceMax(t, GetOtherBridgeEnd(t)) > 1) {

    95

					*override = 1 << GetBridgeRampDirection(t);

    96

				}

    97

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

    98

			}

    99

		case MP_STREET:

   100

			if (GetRoadTileType(t) != ROAD_TILE_CROSSING) return 0;

   101

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

   102

			return GetCrossingRailBits(t);

   103

		case MP_STATION:

   104

			if (!IsRailwayStation(t)) return 0;

   105

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

   106

			if (!IsStationTileElectrifiable(t)) return 0;

   107

			return TrackToTrackBits(GetRailStationTrack(t));

   108

		default:

   109

			return 0;

   110

	}

   111

}

   112

   113

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

   114

  * @param tile The tile to analyse

   115

  * @param *tileh the tileh

   116

  */

   117

static void AdjustTileh(TileIndex tile, Slope* tileh)

   118

{

   119

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

   120

	if (IsBridgeTile(tile)) {

   121

		if (*tileh != SLOPE_FLAT) {

   122

			*tileh = SLOPE_FLAT;

   123

		} else {

   124

			switch (GetBridgeRampDirection(tile)) {

   125

				case DIAGDIR_NE: *tileh = SLOPE_NE; break;

   126

				case DIAGDIR_SE: *tileh = SLOPE_SE; break;

   127

				case DIAGDIR_SW: *tileh = SLOPE_SW; break;

   128

				case DIAGDIR_NW: *tileh = SLOPE_NW; break;

   129

				default: break;

   130

			}

   131

		}

   132

	}

   133

}

   134

   135

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

   136

  * @param ti The Tileinfo to draw the tile for

   137

  */

   138

static void DrawCatenaryRailway(const TileInfo *ti)

   139

{

   140

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

   141

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

   142

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

   143

	TrackBits trackconfig[TS_END];

   144

	bool isflat[TS_END];

   145

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

   146

	Slope tileh[TS_END] = { ti->tileh, SLOPE_FLAT };

   147

   148

	TLG tlg = GetTLG(ti->tile);

   149

	byte PCPstatus = 0;

   150

	byte OverridePCP = 0;

   151

	byte PPPpreferred[DIAGDIR_END];

   152

	byte PPPallowed[DIAGDIR_END];

   153

	DiagDirection i;

   154

	Track t;

   155

   156

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

   157

	   We don't draw a pylon:

   158

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

   159

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

   160

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

   161

	      which have no middle tiles */

   162

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

   163

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

   164

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

   165

   166

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

   167

   168

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

   169

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

   170

		uint foundation = 0;

   171

		int k;

   172

   173

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

   174

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

   175

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

   176

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

   177

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

   178

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

   179

   180

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

   181

		PPPallowed[i] = AllowedPPPonPCP[i];

   182

   183

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

   184

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

   185

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

   186

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

   187

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

   188

			    IsBridgeTile(neighbour) &&

   189

			    GetBridgeRampDirection(neighbour) == ReverseDiagDir(i)) {

   190

				continue;

   191

			}

   192

   193

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

   194

			   (TrackSourceTile) */

   195

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

   196

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

   197

				   of the PCP for preferred/allowed determination*/

   198

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

   199

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

   200

   201

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

   202

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

   203

			}

   204

		}

   205

   206

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

   207

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

   208

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

   209

   210

		/* A station is always "flat", so adjust the tileh accordingly */

   211

		if (IsTileType(neighbour, MP_STATION)) tileh[TS_NEIGHBOUR] = SLOPE_FLAT;

   212

   213

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

   214

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

   215

		if (IsBridgeTile(neighbour)) {

   216

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

   217

		}

   218

   219

		if (foundation != 0) {

   220

			if (foundation < 15) {

   221

				tileh[TS_NEIGHBOUR] = SLOPE_FLAT;

   222

			} else {

   223

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

   224

			}

   225

		}

   226

   227

		AdjustTileh(neighbour, &tileh[TS_NEIGHBOUR]);

   228

   229

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

   230

		   Delete the PCP if this is the case. */

   231

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

   232

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

   233

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

   234

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

   235

		}

   236

   237

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

   238

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

   239

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

   240

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

   241

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

   242

   243

		if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile)) {

   244

			Track bridgetrack = GetBridgeAxis(ti->tile) == AXIS_X ? TRACK_X : TRACK_Y;

   245

			uint height = GetBridgeHeight(GetNorthernBridgeEnd(ti->tile), GetBridgeAxis(ti->tile));

   246

   247

			if ((height <= TilePixelHeight(ti->tile) + TILE_HEIGHT) &&

   248

			(i == PCPpositions[bridgetrack][0] || i == PCPpositions[bridgetrack][1])) SETBIT(OverridePCP, i);

   249

		}

   250

   251

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

   252

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

   253

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

   254

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

   255

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

   256

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

   257

   258

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

   259

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

   260

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

   261

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

   262

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

   263

					}

   264

   265

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

   266

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

   267

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

   268

				}

   269

			}

   270

		}

   271

	}

   272

   273

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

   274

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

   275

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

   276

   277

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

   278

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

   279

   280

			const SortableSpriteStruct *sss;

   281

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

   282

   283

			if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile) && !(_display_opt & DO_TRANS_BUILDINGS)) {

   284

				uint height = GetBridgeHeight(GetNorthernBridgeEnd(ti->tile), GetBridgeAxis(ti->tile));

   285

   286

				if (height <= TilePixelHeight(ti->tile) + TILE_HEIGHT) return;

   287

			}

   288

   289

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

   290

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

   291

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

   292

   293

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

   294

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

   295

		}

   296

	}

   297

}

   298

   299

static void DrawCatenaryOnBridge(const TileInfo *ti)

   300

{

   301

	TileIndex end = GetSouthernBridgeEnd(ti->tile);

   302

	TileIndex start = GetOtherBridgeEnd(end);

   303

   304

	uint length = GetBridgeLength(start, end);

   305

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

   306

   307

	const SortableSpriteStruct *sss;

   308

	Axis axis = GetBridgeAxis(ti->tile);

   309

	TLG tlg = GetTLG(ti->tile);

   310

   311

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

   312

   313

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

   314

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

   315

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

   316

		sss = &CatenarySpriteData[WIRE_X_FLAT_BOTH + offset];

   317

	} else {

   318

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

   319

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

   320

	}

   321

   322

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

   323

			sss->x_size, sss->y_size, sss->z_size, GetBridgeHeight(end, axis) + sss->z_offset);

   324

   325

	/* Finished with wires, draw pylons */

   326

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

   327

	if (num % 2) {

   328

		if (axis == AXIS_X) {

   329

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

   330

		} else {

   331

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

   332

		}

   333

	}

   334

   335

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

   336

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

   337

		if (axis == AXIS_X) {

   338

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

   339

		} else {

   340

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

   341

		}

   342

	}

   343

}

   344

   345

void DrawCatenary(const TileInfo *ti)

   346

{

   347

	if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile)) {

   348

		TileIndex head = GetNorthernBridgeEnd(ti->tile);

   349

   350

		if (GetBridgeTransportType(head) == TRANSPORT_RAIL && GetRailType(head) == RAILTYPE_ELECTRIC) {

   351

			DrawCatenaryOnBridge(ti);

   352

		}

   353

	}

   354

	switch (GetTileType(ti->tile)) {

   355

		case MP_RAILWAY:

   356

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

   357

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

   358

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

   359

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

   360

				return;

   361

			}

   362

			/* Fall through */

   363

		case MP_TUNNELBRIDGE:

   364

		case MP_STREET:

   365

		case MP_STATION:

   366

			DrawCatenaryRailway(ti);

   367

			break;

   368

		default:

   369

			break;

   370

	}

   371

}

   372