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

    88

		case MP_TUNNELBRIDGE:

    89

			if (IsTunnel(t)) {

    90

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

    91

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

    92

				return AxisToTrackBits(DiagDirToAxis(GetTunnelDirection(t)));

    93

			} else {

    94

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

    95

				if (IsBridgeMiddle(t)) {

    96

					if (IsTransportUnderBridge(t) &&

    97

						GetTransportTypeUnderBridge(t) == TRANSPORT_RAIL) {

    98

						return GetRailBitsUnderBridge(t);

    99

					} else {

   100

						return 0;

   101

					}

   102

				} else {

   103

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

   104

   105

					return AxisToTrackBits(DiagDirToAxis(GetBridgeRampDirection(t)));

   106

				}

   107

			}

   108

   109

		case MP_STREET:

   110

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

   111

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

   112

			return GetCrossingRailBits(t);

   113

   114

		case MP_STATION:

   115

			if (!IsRailwayStation(t)) return 0;

   116

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

   117

			if (!IsStationTileElectrifiable(t)) return 0;

   118

			return TrackToTrackBits(GetRailStationTrack(t));

   119

   120

		default:

   121

			return 0;

   122

	}

   123

}

   124

   125

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

   126

  * @param tile The tile to analyse

   127

  * @param *tileh the tileh

   128

  */

   129

static void AdjustTileh(TileIndex tile, Slope *tileh)

   130

{

   131

	if (IsTileType(tile, MP_TUNNELBRIDGE)) {

   132

		if (IsTunnel(tile)) {

   133

			*tileh = SLOPE_FLAT;

   134

		} else {

   135

			if (IsBridgeRamp(tile)) {

   136

				if (*tileh != SLOPE_FLAT) {

   137

					*tileh = SLOPE_FLAT;

   138

				} else {

   139

					switch (GetBridgeRampDirection(tile)) {

   140

						case DIAGDIR_NE: *tileh = SLOPE_NE; break;

   141

						case DIAGDIR_SE: *tileh = SLOPE_SE; break;

   142

						case DIAGDIR_SW: *tileh = SLOPE_SW; break;

   143

						case DIAGDIR_NW: *tileh = SLOPE_NW; break;

   144

						default: break;

   145

					}

   146

				}

   147

			}

   148

		}

   149

	}

   150

}

   151

   152

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

   153

  * @param ti The Tileinfo to draw the tile for

   154

  */

   155

static void DrawCatenaryRailway(const TileInfo *ti)

   156

{

   157

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

   158

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

   159

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

   160

	TrackBits trackconfig[TS_END];

   161

	bool isflat[TS_END];

   162

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

   163

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

   164

   165

	TLG tlg = GetTLG(ti->tile);

   166

	byte PCPstatus = 0;

   167

	byte OverridePCP = 0;

   168

	byte PPPpreferred[DIAGDIR_END];

   169

	byte PPPallowed[DIAGDIR_END];

   170

	DiagDirection i;

   171

	Track t;

   172

   173

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

   174

	   We don't draw a pylon:

   175

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

   176

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

   177

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

   178

	      which have no middle tiles */

   179

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

   180

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

   181

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

   182

   183

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

   184

   185

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

   186

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

   187

		uint foundation = 0;

   188

		int k;

   189

   190

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

   191

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

   192

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

   193

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

   194

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

   195

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

   196

   197

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

   198

		PPPallowed[i] = AllowedPPPonPCP[i];

   199

   200

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

   201

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

   202

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

   203

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

   204

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

   205

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

   206

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

   207

				continue;

   208

			}

   209

   210

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

   211

			   (TrackSourceTile) */

   212

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

   213

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

   214

				   of the PCP for preferred/allowed determination*/

   215

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

   216

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

   217

   218

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

   219

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

   220

			}

   221

		}

   222

   223

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

   224

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

   225

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

   226

   227

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

   228

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

   229

   230

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

   231

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

   232

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

   233

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

   234

		}

   235

   236

		if (foundation != 0) {

   237

			if (foundation < 15) {

   238

				tileh[TS_NEIGHBOUR] = SLOPE_FLAT;

   239

			} else {

   240

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

   241

			}

   242

		}

   243

   244

		AdjustTileh(neighbour, &tileh[TS_NEIGHBOUR]);

   245

   246

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

   247

		   Delete the PCP if this is the case. */

   248

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

   249

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

   250

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

   251

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

   252

		}

   253

   254

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

   255

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

   256

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

   257

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

   258

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

   259

   260

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

   261

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

   262

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

   263

   264

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

   265

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

   266

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

   267

   268

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

   269

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

   270

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

   271

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

   272

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

   273

					}

   274

   275

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

   276

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

   277

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

   278

				}

   279

			}

   280

		}

   281

	}

   282

   283

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

   284

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

   285

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

   286

   287

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

   288

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

   289

   290

			const SortableSpriteStruct *sss;

   291

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

   292

   293

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

   294

					IsBridgeTile(ti->tile) &&

   295

					IsBridgeMiddle(ti->tile) &&

   296

					!(_display_opt & DO_TRANS_BUILDINGS) &&

   297

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

   298

			   ) return;

   299

   300

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

   301

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

   302

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

   303

   304

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

   305

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

   306

		}

   307

	}

   308

}

   309

   310

static void DrawCatenaryOnBridge(const TileInfo *ti)

   311

{

   312

	TileIndex end = GetSouthernBridgeEnd(ti->tile);

   313

	TileIndex start = GetOtherBridgeEnd(end);

   314

   315

	uint length = GetBridgeLength(start, end);

   316

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

   317

	uint height;

   318

   319

	const SortableSpriteStruct *sss;

   320

	Axis axis = GetBridgeAxis(ti->tile);

   321

	TLG tlg = GetTLG(ti->tile);

   322

   323

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

   324

   325

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

   326

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

   327

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

   328

		sss = &CatenarySpriteData[WIRE_X_FLAT_BOTH + offset];

   329

	} else {

   330

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

   331

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

   332

	}

   333

   334

	height = GetBridgeHeight(ti->tile);

   335

   336

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

   337

		sss->x_size, sss->y_size, sss->z_size, height + sss->z_offset

   338

	);

   339

   340

	/* Finished with wires, draw pylons */

   341

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

   342

	if (num % 2) {

   343

		if (axis == AXIS_X) {

   344

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

   345

		} else {

   346

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

   347

		}

   348

	}

   349

   350

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

   351

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

   352

		if (axis == AXIS_X) {

   353

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

   354

		} else {

   355

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

   356

		}

   357

	}

   358

}

   359

   360

void DrawCatenary(const TileInfo *ti)

   361

{

   362

	switch (GetTileType(ti->tile)) {

   363

		case MP_RAILWAY:

   364

			if (IsRailDepot(ti->tile)) {

   372

				return;

   373

			}

   374

			break;

   375

   376

		case MP_TUNNELBRIDGE:

   377

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

   378

			break;

   379

   380

		case MP_STREET:  break;

   381

		case MP_STATION: break;

   382

   383

		default: return;

   384

	}

   385

	DrawCatenaryRailway(ti);

   386

}