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 (GetRoadType(t) != ROAD_CROSSING) return 0;

   105

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

   106

			return GetCrossingRailBits(t);

   107

		case MP_STATION:

   108

			if (!IsRailwayStation(t)) return 0;

   109

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

   110

			return TrackToTrackBits(GetRailStationTrack(t));

   111

		default:

   112

			return 0;

   113

	}

   114

}

   115

   116

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

   117

  * @param ti The Tileinfo to draw the tile for

   118

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

   119

  */

   120

static void DrawCatenaryRailway(const TileInfo *ti)

   121

{

   122

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

   123

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

   124

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

   125

	TrackBits trackconfig[TS_END];

   126

	bool isflat[TS_END];

   127

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

   128

	uint tileh[TS_END];

   129

   130

	TLG tlg = GetTLG(ti->tile);

   131

	byte PCPstatus = 0;

   132

	byte OverridePCP = 0;

   133

	byte PPPpreferred[DIAGDIR_END];

   134

	byte PPPallowed[DIAGDIR_END];

   135

	byte PPPbuffer[DIAGDIR_END];

   136

	DiagDirection i;

   137

	Track t;

   138

   139

	tileh[0] = ti->tileh;

   140

	tileh[1] = 0;

   141

   142

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

   143

	PPPallowed[0] = AllowedPPPonPCP[0];

   144

	PPPallowed[1] = AllowedPPPonPCP[1];

   145

	PPPallowed[2] = AllowedPPPonPCP[2];

   146

	PPPallowed[3] = AllowedPPPonPCP[3];

   147

   148

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

   149

	   We don't draw a pylon:

   150

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

   151

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

   152

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

   153

	      which have no middle tiles */

   154

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

   155

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

   156

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

   157

   158

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

   159

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

   160

		if (tileh[TS_HOME] != 0) {

   161

			tileh[TS_HOME] = 0;

   162

		} else {

   163

			switch (GetBridgeRampDirection(ti->tile)) {

   164

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

   165

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

   166

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

   167

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

   168

				default: break;

   169

			}

   170

		}

   171

	}

   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

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

   183

   184

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

   185

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

   186

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

   187

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

   188

			if (

   189

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

   190

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

   191

					GetBridgeRampDirection(neighbour) == ReverseDiagDir(i)

   192

			   ) continue;

   193

   194

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

   195

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

   196

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

   197

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

   198

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

   199

			}

   200

		}

   201

   202

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

   203

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

   204

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

   205

   206

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

   207

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

   208

   209

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

   210

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

   211

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

   212

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

   213

		}

   214

   215

		if (foundation != 0) {

   216

			if (foundation < 15) {

   217

				tileh[TS_NEIGHBOUR] = 0;

   218

			} else {

   219

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

   220

			}

   221

		}

   222

   223

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

   224

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

   225

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

   226

			if (tileh[TS_NEIGHBOUR] != 0) {

   227

				tileh[TS_NEIGHBOUR] = 0;

   228

			} else {

   229

				switch (GetBridgeRampDirection(neighbour)) {

   230

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

   231

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

   232

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

   233

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

   234

					default: break;

   235

				}

   236

			}

   237

		}

   238

   239

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

   240

		   Delete the PCP if this is the case. */

   241

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

   242

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

   243

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

   244

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

   245

		}

   246

   247

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

   248

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

   249

		   anything */

   250

		if (PPPpreferred[i] != 0) {

   251

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

   252

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

   253

			   cancles them out */

   254

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

   255

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

   256

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

   257

		} else {

   258

			PPPbuffer[i] = PPPallowed[i];

   259

		}

   260

   261

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

   262

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

   263

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

   264

				if (HASBIT(PPPbuffer[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)

   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(!IsSteepTileh(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, 15), ti->y + min(sss->y_offset, 15)) + sss->z_offset);

   306

		}

   307

	}

   308

}

   309

   310

static void DrawCatenaryOnBridge(const TileInfo *ti)

   311

{

   316

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

   318

	const SortableSpriteStruct *sss;

   319

	Axis axis = GetBridgeAxis(ti->tile);

   320

	TLG tlg = GetTLG(ti->tile);

   321

   322

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

   323

   324

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

   327

		sss = &CatenarySpriteData[WIRE_X_FLAT_BOTH + offset];

   328

	} else {

   330

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

   331

	}

   332

   338

	if (num % 2) {

   339

		if (axis == AXIS_X) {

   340

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

   341

		} else {

   342

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

   343

		}

   344

	}

   345

   348

		if (axis == AXIS_X) {

   349

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

   350

		} else {

   351

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

   352

		}

   353

	}

   354

}

   355

   356

void DrawCatenary(const TileInfo *ti)

   357

{

   358

	switch (GetTileType(ti->tile)) {

   359

		case MP_RAILWAY:

   360

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

   361

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

   362

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

   363

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

   364

				return;

   365

			}

   366

			/* Fall through */

   367

		case MP_TUNNELBRIDGE:

   368

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

   369

			/* Fall further */

   370

		case MP_STREET: case MP_STATION:

   371

			DrawCatenaryRailway(ti);

   372

			break;

   373

		default:

   374

			break;

   375

	}

   376

}

   377