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 (

    95

					IsBridgeMiddle(t) &&

    96

					IsTransportUnderBridge(t) &&

    97

					GetTransportTypeUnderBridge(t) == TRANSPORT_RAIL) {

    98

					return GetRailBitsUnderBridge(t);

    99

				} else {

   100

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

   101

   102

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

   103

				}

   104

			}

   105

		case MP_STREET:

   106

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

   107

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

   108

			return GetCrossingRailBits(t);

   109

		case MP_STATION:

   110

			if (!IsRailwayStation(t)) return 0;

   111

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

   112

			return TrackToTrackBits(GetRailStationTrack(t));

   113

		default:

   114

			return 0;

   115

	}

   116

}

   117

   118

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

   119

  * @param tile The tile to analyse

   120

  * @param *tileh the tileh

   121

  */

   122

static void AdjustTileh(TileIndex tile, uint *tileh)

   123

{

   124

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

   125

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

   126

		if (*tileh != 0) {

   127

			*tileh = 0;

   128

		} else {

   129

			switch (GetBridgeRampDirection(tile)) {

   130

				case DIAGDIR_NE: *tileh = 12; break;

   131

				case DIAGDIR_SE: *tileh =  6; break;

   132

				case DIAGDIR_SW: *tileh =  3; break;

   133

				case DIAGDIR_NW: *tileh =  9; break;

   134

				default: break;

   135

			}

   136

		}

   137

	}

   138

}

   139

   140

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

   141

  * @param ti The Tileinfo to draw the tile for

   142

  */

   143

static void DrawCatenaryRailway(const TileInfo *ti)

   144

{

   145

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

   146

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

   147

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

   148

	TrackBits trackconfig[TS_END];

   149

	bool isflat[TS_END];

   150

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

   151

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

   152

   153

	TLG tlg = GetTLG(ti->tile);

   154

	byte PCPstatus = 0;

   155

	byte OverridePCP = 0;

   156

	byte PPPpreferred[DIAGDIR_END];

   157

	byte PPPallowed[DIAGDIR_END];

   158

	DiagDirection i;

   159

	Track t;

   160

   161

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

   162

	   We don't draw a pylon:

   163

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

   164

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

   165

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

   166

	      which have no middle tiles */

   167

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

   168

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

   169

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

   170

   171

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

   172

   173

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

   174

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

   175

		uint foundation = 0;

   176

		int k;

   177

   178

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

   179

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

   180

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

   181

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

   182

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

   183

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

   184

   185

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

   186

		PPPallowed[i] = AllowedPPPonPCP[i];

   187

   188

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

   189

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

   190

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

   191

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

   192

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

   193

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

   194

			    GetBridgeRampDirection(neighbour) == ReverseDiagDir(i)

   195

			   ) continue;

   196

   197

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

   198

			   (TrackSourceTile) */

   199

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

   200

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

   201

				   of the PCP for preferred/allowed determination*/

   202

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

   203

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

   204

   205

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

   206

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

   207

			}

   208

		}

   209

   210

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

   211

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

   212

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

   213

   214

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

   215

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

   216

   217

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

   218

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

   219

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

   220

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

   221

		}

   222

   223

		if (foundation != 0) {

   224

			if (foundation < 15) {

   225

				tileh[TS_NEIGHBOUR] = 0;

   226

			} else {

   227

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

   228

			}

   229

		}

   230

   231

		AdjustTileh(neighbour, &tileh[TS_NEIGHBOUR]);

   232

   233

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

   234

		   Delete the PCP if this is the case. */

   235

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

   236

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

   237

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

   238

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

   239

		}

   240

   241

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

   242

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

   243

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

   244

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

   245

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

   246

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

   254

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

   255

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

   256

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

   257

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

   258

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

   259

					}

   260

   261

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

   262

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

   263

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

   264

				}

   265

			}

   266

		}

   267

	}

   268

   269

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

   270

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

   271

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

   272

   273

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

   274

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

   275

   276

			const SortableSpriteStruct *sss;

   277

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

   278

   279

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

   280

					IsBridgeTile(ti->tile) &&

   281

					IsBridgeMiddle(ti->tile) &&

   282

					!(_display_opt & DO_TRANS_BUILDINGS) &&

   283

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

   284

			   ) return;

   285

   286

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

   287

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

   288

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

   289

   290

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

   291

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

   292

		}

   293

	}

   294

}

   295

   296

static void DrawCatenaryOnBridge(const TileInfo *ti)

   297

{

   298

	TileIndex end = GetSouthernBridgeEnd(ti->tile);

   299

	TileIndex start = GetOtherBridgeEnd(end);

   300

   301

	uint length = GetBridgeLength(start, end);

   302

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

   303

   304

	const SortableSpriteStruct *sss;

   305

	Axis axis = GetBridgeAxis(ti->tile);

   306

	TLG tlg = GetTLG(ti->tile);

   307

   308

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

   309

   310

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

   311

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

   312

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

   313

		sss = &CatenarySpriteData[WIRE_X_FLAT_BOTH + offset];

   314

	} else {

   315

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

   316

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

   317

	}

   318

   319

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

   320

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

   321

   322

	/* Finished with wires, draw pylons */

   323

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

   324

	if (num % 2) {

   325

		if (axis == AXIS_X) {

   326

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

   327

		} else {

   328

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

   329

		}

   330

	}

   331

   332

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

   333

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

   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

   342

void DrawCatenary(const TileInfo *ti)

   343

{

   344

	switch (GetTileType(ti->tile)) {

   345

		case MP_RAILWAY:

   346

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

   347

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

   348

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

   349

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

   350

				return;

   351

			}

   352

			/* Fall through */

   353

		case MP_TUNNELBRIDGE:

   354

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

   355

			/* Fall further */

   356

		case MP_STREET: case MP_STATION:

   357

			DrawCatenaryRailway(ti);

   358

			break;

   359

		default:

   360

			break;

   361

	}

   362

}

   363