(svn r4150) -Feature: Merged elrails into trunk. Thanks to Tron for lots of code and proofreading, thanks to peter1138 for another lot of code and ideas.

BUGS

@@ -0,0 +1,7 @@
+/* $Id */
+
+KNOWN BUGS / PROBLEMS:
+
+Normal and elrail depots look the same. Use 'X' (transparent buildings)
+   to distinguish between them
+Missing curors / icons for construction (currently using the conventional ones)

Makefile

@@ -630,6 +630,7 @@ SRCS += dock_gui.c
 SRCS += driver.c
 SRCS += dummy_land.c
 SRCS += economy.c
+SRCS += elrail.c
 SRCS += engine.c
 SRCS += engine_gui.c
 SRCS += fileio.c

ai/default/default.c

@@ -126,7 +126,7 @@ static void AiStateVehLoop(Player *p)
 	p->ai.state_counter = 0;
 }
 
-static EngineID AiChooseTrainToBuild(byte railtype, int32 money, byte flag, TileIndex tile)
+static EngineID AiChooseTrainToBuild(RailType railtype, int32 money, byte flag, TileIndex tile)
 {
 	EngineID best_veh_index = INVALID_ENGINE;
 	byte best_veh_score = 0;
@@ -137,7 +137,7 @@ static EngineID AiChooseTrainToBuild(byte railtype, int32 money, byte flag, Tile
 		const RailVehicleInfo *rvi = RailVehInfo(i);
 		const Engine* e = GetEngine(i);
 
-		if (e->railtype != railtype ||
+		if (!IsCompatibleRail(e->railtype, railtype) ||
 				rvi->flags & RVI_WAGON ||
 				(rvi->flags & RVI_MULTIHEAD && flag & 1) ||
 				!HASBIT(e->player_avail, _current_player) ||
@@ -2321,6 +2321,41 @@ static StationID AiGetStationIdByDef(TileIndex tile, int id)
 	return GetStationIndex(TILE_ADD(tile, ToTileIndexDiff(p->tileoffs)));
 }
 
+static EngineID AiFindBestWagon(CargoID cargo, RailType railtype)
+{
+	EngineID best_veh_index = INVALID_ENGINE;
+	EngineID i;
+	uint16 best_capacity = 0;
+	uint16 best_speed    = 0;
+	uint speed;
+
+	for (i = 0; i < NUM_TRAIN_ENGINES; i++) {
+		const RailVehicleInfo *rvi = RailVehInfo(i);
+		const Engine* e = GetEngine(i);
+
+		if (!IsCompatibleRail(e->railtype, railtype) ||
+				!(rvi->flags & RVI_WAGON) ||
+				!HASBIT(e->player_avail, _current_player)) {
+			continue;
+		}
+
+		if (rvi->cargo_type != cargo) {
+			continue;
+		}
+
+		/* max_speed of 0 indicates no speed limit */
+		speed = rvi->max_speed == 0 ? 0xFFFF : rvi->max_speed;
+
+		if (rvi->capacity >= best_capacity && speed >= best_speed) {
+			best_capacity = rvi->capacity;
+			best_speed    = best_speed;
+			best_veh_index = i;
+		}
+	}
+
+	return best_veh_index;
+}
+
 static void AiStateBuildRailVeh(Player *p)
 {
 	const AiDefaultBlockData *ptr;
@@ -2337,10 +2372,14 @@ static void AiStateBuildRailVeh(Player *p)
 
 	tile = TILE_ADD(p->ai.src.use_tile, ToTileIndexDiff(ptr->tileoffs));
 
+
 	cargo = p->ai.cargo_type;
 	for (i = 0;;) {
 		if (p->ai.wagon_list[i] == INVALID_VEHICLE) {
-			veh = _cargoc.ai_railwagon[p->ai.railtype_to_use][cargo];
+			veh = AiFindBestWagon(cargo, p->ai.railtype_to_use);
+			/* veh will return INVALID_ENGINE if no suitable wagon is available.
+			 * We shall treat this in the same way as having no money */
+			if (veh == INVALID_ENGINE) goto handle_nocash;
 			cost = DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE);
 			if (CmdFailed(cost)) goto handle_nocash;
 			p->ai.wagon_list[i] = _new_wagon_id;

bridge.h

@@ -22,4 +22,6 @@ typedef struct Bridge {
 extern const Bridge orig_bridge[MAX_BRIDGES];
 extern Bridge _bridge[MAX_BRIDGES];
 
+uint GetBridgeFoundation(uint tileh, Axis axis);
+
 #endif /* BRIDGE_H */

bridge_map.h

@@ -127,6 +127,7 @@ TileIndex GetSouthernBridgeEnd(TileIndex t);
  */
 TileIndex GetOtherBridgeEnd(TileIndex);
 
+uint GetBridgeHeight(TileIndex t);
 
 static inline void SetClearUnderBridge(TileIndex t)
 {

docs/landscape.html

@@ -129,7 +129,7 @@ m5 bit 7 clear: railway track
 <tr><td nowrap valign=top><tt>B</tt>&nbsp; </td><td align=left>fence on the N side (track in the S corner)</td></tr>
 <tr><td nowrap valign=top><tt>C</tt>&nbsp; </td><td align=left>on snow or desert</td></tr>
 </table></li>
-<li>m3 bits 0..3 = <a name="TrackType">track type</a>: <tt>0</tt> - conventional railway, <tt>1</tt> - monorail, <tt>2</tt> - maglev
+<li>m3 bits 0..3 = <a name="TrackType">track type</a>: <tt>0</tt> - conventional railway, <tt>1</tt> - electrified railway, <tt>2</tt> - monorail, <tt>3</tt> - maglev
 </ul>
 m5 bits 7 and 6 set: railway depot / checkpoints
 <ul>

elrail.c

@@ -0,0 +1,352 @@
+/* $Id$ */
+/** @file elrail.c
+  * This file deals with displaying wires and pylons for electric railway systems.
+<h2>Basics</h2>
+
+<h3>Tile Types</h3>
+
+We have two different types of tiles in the drawing code:
+Normal Railway Tiles (NRTs) which can have more than one track on it, and
+Special Railways tiles (SRTs) which have only one track (like crossings, depots
+stations, etc).
+
+<h3>Location Categories</h3>
+
+All tiles are categorized into three location groups (TLG):
+Group 0: Tiles with both an even X coordinate and an even Y coordinate
+Group 1: Tiles with an even X and an odd Y coordinate
+Group 2: Tiles with an odd X and an even Y coordinate
+Group 3: Tiles with both an odd X and Y coordnate.
+
+<h3>Pylon Points</h3>
+<h4>Control Points</h4>
+A Pylon Control Point (PCP) is a position where a wire (or rather two)
+is mounted onto a pylon.
+Each NRT does contain 4 PCPs which are mapped to a byte
+variable and are represented by the DiagDirection enum:
+
+A wire that ends on the PCP has a dark ending, otherwise the end is bright.<p>
+
+Now on each edge there are two PCPs: One from each adjacent tile. Both PCPs are merged
+using an OR matrix (i. e. if one tile needs a PCP at the postion in question, both
+tiles get it).
+
+<h4>Position Points</h4>
+A Pylon Position Point (PPP) is a position where a pylon is located on the ground.
+Each PCP owns 8 in (45 degree steps) PPPs that are located around it. PPPs are numbered
+0 to 7 with 0 starting north and numbering in clockwise direction. Each track bit has PPPs
+that are impossible (because the pylon would be situated on the track), preferred (because
+the pylon would be rectangular to the track). PPPs are represented by the Direction enum.
+
+<img src="../../elrail_tile.png">
+<img src="../../elrail_track.png">
+
+  */
+
+#include "stdafx.h"
+#include "openttd.h"
+#include "tile.h"
+#include "viewport.h"
+#include "functions.h" /* We should REALLY get rid of this goddamn file, as it is butt-ugly */
+#include "variables.h" /* ... same here */
+#include "rail.h"
+#include "debug.h"
+#include "tunnel_map.h"
+#include "road_map.h"
+#include "bridge_map.h"
+#include "bridge.h"
+#include "rail_map.h"
+#include "table/sprites.h"
+#include "table/elrail_data.h"
+
+static inline TLG GetTLG(TileIndex t)
+{
+	return (HASBIT(TileX(t), 0) << 1) + HASBIT(TileY(t), 0);
+}
+
+/** Finds which Rail Bits are present on a given tile. For bridge tiles,
+  * returns track bits under the bridge
+  */
+static TrackBits GetRailTrackBitsUniversal(TileIndex t, byte *override)
+{
+	switch (GetTileType(t)) {
+		case MP_RAILWAY:
+			if (GetRailType(t) != RAILTYPE_ELECTRIC) return 0;
+			switch (GetRailTileType(t)) {
+				case RAIL_TYPE_NORMAL: case RAIL_TYPE_SIGNALS:
+					return GetTrackBits(t);
+				default:
+					return 0;
+			}
+			break;
+		case MP_TUNNELBRIDGE:
+			if (IsTunnel(t)) {
+				if (GetRailType(t) != RAILTYPE_ELECTRIC) return 0;
+				if (override != NULL) *override = 1 << GetTunnelDirection(t);
+				return (_m[t].m5 & 1) ? TRACK_BIT_Y : TRACK_BIT_X;
+			} else {
+				if (GetRailType(t) != RAILTYPE_ELECTRIC) return 0;
+				if (
+					IsBridgeMiddle(t) &&
+					IsTransportUnderBridge(t) &&
+					GetTransportTypeUnderBridge(t) == TRANSPORT_RAIL) {
+					return GetRailBitsUnderBridge(t);
+				} else {
+					if (override != NULL && DistanceMax(t, GetOtherBridgeEnd(t)) > 1) *override = 1 << GetBridgeRampDirection(t);
+
+					return GetBridgeAxis(t) == AXIS_X ? TRACK_BIT_X : TRACK_BIT_Y;
+				}
+			}
+		case MP_STREET:
+			if ((_m[t].m4 & 0xF) != RAILTYPE_ELECTRIC) return 0;
+			return GetCrossingRailBits(t);
+		case MP_STATION:
+			if (GetRailType(t) != RAILTYPE_ELECTRIC) return 0;
+			return _m[t].m5 & 1 ? TRACK_BIT_Y : TRACK_BIT_X;
+		default:
+			return 0;
+	}
+}
+
+/** Draws wires and, if required, pylons on a given tile
+  * @param ti The Tileinfo to draw the tile for
+  * @todo Currently, each pylon is drawn twice (once for each neighbouring tiles use OwnedPPPonPCP for this)
+  */
+static void DrawCatenaryRailway(const TileInfo *ti)
+{
+	/* Pylons are placed on a tile edge, so we need to take into account
+	   the track configuration of 2 adjacent tiles. trackconfig[0] stores the
+	   current tile (home tile) while [1] holds the neighbour */
+	TrackBits trackconfig[TS_END];
+	bool isflat[TS_END];
+	/* Note that ti->tileh has already been adjusted for Foundations */
+	uint tileh[TS_END] = {ti->tileh, 0};
+
+	TLG tlg = GetTLG(ti->tile);
+	byte PCPstatus = 0;
+	byte OverridePCP = 0;
+	byte PPPpreferred[DIAGDIR_END] = {0xFF, 0xFF, 0xFF, 0xFF};
+	byte PPPallowed[DIAGDIR_END] = {AllowedPPPonPCP[0], AllowedPPPonPCP[1], AllowedPPPonPCP[2], AllowedPPPonPCP[3]};
+	byte PPPbuffer[DIAGDIR_END];
+	DiagDirection i;
+	Track t;
+
+	/* Find which rail bits are present, and select the override points.
+	   We don't draw a pylon:
+	   1) INSIDE a tunnel (we wouldn't see it anyway)
+	   2) on the "far" end of a bridge head (the one that connects to bridge middle),
+	      because that one is drawn on the bridge. Exception is for length 0 bridges
+	      which have no middle tiles */
+	trackconfig[TS_HOME] = GetRailTrackBitsUniversal(ti->tile, &OverridePCP);
+	/* If a track bit is present that is not in the main direction, the track is level */
+	isflat[TS_HOME] = trackconfig[TS_HOME] & (TRACK_BIT_UPPER | TRACK_BIT_LOWER | TRACK_BIT_LEFT | TRACK_BIT_RIGHT);
+
+	if (IsTunnelTile(ti->tile)) tileh[TS_HOME] = 0;
+	if (IsBridgeTile(ti->tile) && IsBridgeRamp(ti->tile)) {
+		if (tileh[TS_HOME] != 0) {
+			tileh[TS_HOME] = 0;
+		} else {
+			switch (GetBridgeRampDirection(ti->tile)) {
+				case DIAGDIR_NE: tileh[TS_HOME] = 12; break;
+				case DIAGDIR_SE: tileh[TS_HOME] =  6; break;
+				case DIAGDIR_SW: tileh[TS_HOME] =  3; break;
+				case DIAGDIR_NW: tileh[TS_HOME] =  9; break;
+				default: break;
+			}
+		}
+	}
+
+	for (i = DIAGDIR_NE; i < DIAGDIR_END; i++) {
+		extern const TileIndexDiffC _tileoffs_by_dir[];
+		TileIndex neighbour = ti->tile + TileOffsByDir(i);
+		uint foundation = 0;
+		int k;
+
+		/* Here's one of the main headaches. GetTileSlope does not correct for possibly
+		   existing foundataions, so we do have to do that manually later on.*/
+		tileh[TS_NEIGHBOUR] = GetTileSlope(neighbour, NULL);
+		trackconfig[TS_NEIGHBOUR] = GetRailTrackBitsUniversal(neighbour, NULL);
+		isflat[TS_NEIGHBOUR] = trackconfig[TS_NEIGHBOUR] & (TRACK_BIT_UPPER | TRACK_BIT_LOWER | TRACK_BIT_LEFT | TRACK_BIT_RIGHT);
+
+		/* We cycle through all the existing tracks at a PCP and see what
+		   PPPs we want to have, or may not have at all */
+		for (k = 0; k < TRACKS_AT_PCP; k++) {
+			/* Next to us, we have a bridge head, don't worry about that one, if it shows away from us */
+			if (
+					trackorigin[i][k] == TS_NEIGHBOUR &&
+					IsBridgeTile(neighbour) && IsBridgeRamp(neighbour) &&
+					GetBridgeRampDirection(neighbour) == ReverseDiagDir(i)
+			   ) continue;
+
+			if (HASBIT(trackconfig[trackorigin[i][k]], PPPtracks[i][k])) {
+				DiagDirection PCPpos = (trackorigin[i][k] == 0) ? i : ReverseDiagDir(i);
+				PCPstatus |= 1 << i; /* This PCP is in use */
+				PPPpreferred[i] &= PreferredPPPofTrackBitAtPCP[PPPtracks[i][k]][PCPpos];
+				PPPallowed[i] &= ~DisallowedPPPofTrackBitAtPCP[PPPtracks[i][k]][PCPpos];
+			}
+		}
+
+		/* Deactivate all PPPs if PCP is not used */
+		PPPpreferred[i] *= HASBIT(PCPstatus, i);
+		PPPallowed[i] *= HASBIT(PCPstatus, i);
+
+		/* Station on a non-flat tile means foundation. add one height level and adjust tileh */
+		if (IsTileType(neighbour, MP_STATION) && tileh[TS_NEIGHBOUR] != 0) tileh[TS_NEIGHBOUR] = 0;
+
+		/* Read the foundataions if they are present, and adjust the tileh */
+		if (IsTileType(neighbour, MP_RAILWAY)) foundation = GetRailFoundation(tileh[TS_NEIGHBOUR], trackconfig[TS_NEIGHBOUR]);
+		if (IsBridgeTile(neighbour) && IsBridgeRamp(neighbour)) foundation = GetBridgeFoundation(tileh[TS_NEIGHBOUR], GetBridgeAxis(neighbour));
+		if (foundation != 0) {
+			if (foundation < 15) {
+				tileh[TS_NEIGHBOUR] = 0;
+			} else {
+				tileh[TS_NEIGHBOUR] = _inclined_tileh[foundation - 15];
+			}
+		}
+
+		/* Convert the real tileh into a pseudo-tileh for the track */
+		if (IsTunnelTile(neighbour)) tileh[TS_NEIGHBOUR] = 0;
+		if (IsBridgeTile(neighbour) && IsBridgeRamp(neighbour)) {
+			if (tileh[TS_NEIGHBOUR] != 0) {
+				tileh[TS_NEIGHBOUR] = 0;
+			} else {
+				switch (GetBridgeRampDirection(neighbour)) {
+					case DIAGDIR_NE: tileh[TS_NEIGHBOUR] = 12; break;
+					case DIAGDIR_SE: tileh[TS_NEIGHBOUR] =  6; break;
+					case DIAGDIR_SW: tileh[TS_NEIGHBOUR] =  3; break;
+					case DIAGDIR_NW: tileh[TS_NEIGHBOUR] =  9; break;
+					default: break;
+				}
+			}
+		}
+
+		/* If we have a straight (and level) track, we want a pylon only every 2 tiles
+		   Delete the PCP if this is the case. */
+		/* Level means that the slope is the same, or the track is flat */
+		if (tileh[TS_HOME] == tileh[TS_NEIGHBOUR] || (isflat[TS_HOME] && isflat[TS_NEIGHBOUR])) {
+			for (k = 0; k < NUM_IGNORE_GROUPS; k++)
+				if (PPPpreferred[i] == IgnoredPCP[k][tlg][i]) PCPstatus &= ~(1 << i);
+		}
+
+		/* Now decide where we draw our tiles. First try the preferred PPPs, but they may not exist.
+		   In that case, we try the any of the allowed ones. if they don't exist either, don't draw
+		   anything */
+		if (PPPpreferred[i] != 0) {
+			/* Some of the preferred PPPs (the ones in direct extension of the track bit)
+			   have been used as an "end of line" marker. As these are not ALLOWED, this operation
+			   cancles them out */
+			PPPbuffer[i] = PPPpreferred[i] & PPPallowed[i];
+			/* We haven't any buffer yet, so try something else. Fixes 90° curves */
+			if (PPPbuffer[i] == 0) PPPbuffer[i] = PPPallowed[i];
+		} else {
+			PPPbuffer[i] = PPPallowed[i];
+		}
+
+		if (PPPbuffer[i] != 0 && HASBIT(PCPstatus, i) && !HASBIT(OverridePCP, i)) {
+			for (k = 0; k < DIR_END; k++) {
+				byte temp = PPPorder[i][GetTLG(ti->tile)][k];
+				if (HASBIT(PPPbuffer[i], temp)) {
+					uint x  = ti->x + x_pcp_offsets[i] + x_ppp_offsets[temp];
+					uint y  = ti->y + y_pcp_offsets[i] + y_ppp_offsets[temp];
+
+					/* Don't build the pylon if it would be outside the tile */
+					if (!HASBIT(OwnedPPPonPCP[i], temp)) {
+						/* We have a neighour that will draw it, bail out */
+						if (trackconfig[TS_NEIGHBOUR] != 0) break;
+						continue; /* No neighbour, go looking for a better position */
+					}
+
+					AddSortableSpriteToDraw(pylons_normal[temp], x, y, 1, 1, 10,
+							GetSlopeZ(ti->x + x_pcp_offsets[i], ti->y + y_pcp_offsets[i]));
+					break; /* We already have drawn a pylon, bail out */
+				}
+			}
+		}
+	}
+
+	/* Drawing of pylons is finished, now draw the wires */
+	for (t = 0; t < TRACK_END; t++) {
+		if (HASBIT(trackconfig[TS_HOME], t)) {
+
+			byte PCPconfig = HASBIT(PCPstatus, PCPpositions[t][0]) +
+				(HASBIT(PCPstatus, PCPpositions[t][1]) << 1);
+
+			const SortableSpriteStruct *sss;
+			int tileh_selector = !(tileh[TS_HOME] % 3) * tileh[TS_HOME] / 3; /* tileh for the slopes, 0 otherwise */
+
+			if ( /* We are not drawing a wire under a low bridge */
+					IsBridgeTile(ti->tile) &&
+					IsBridgeMiddle(ti->tile) &&
+					!(_display_opt & DO_TRANS_BUILDINGS) &&
+					GetBridgeHeight(t) <= TilePixelHeight(t)
+			   ) return;
+
+			assert(PCPconfig != 0); /* We have a pylon on neither end of the wire, that doesn't work (since we have no sprites for that) */
+			assert(!IsSteepTileh(tileh[TS_HOME]));
+			sss = &CatenarySpriteData[Wires[tileh_selector][t][PCPconfig]];
+
+			AddSortableSpriteToDraw( sss->image, ti->x + sss->x_offset, ti->y + sss->y_offset,
+				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);
+		}
+	}
+}
+
+static void DrawCatenaryOnBridge(const TileInfo *ti)
+{
+	TileIndex start = GetOtherBridgeEnd(GetSouthernBridgeEnd(ti->tile));
+	uint length = GetBridgeLength(GetSouthernBridgeEnd(ti->tile), GetOtherBridgeEnd(GetSouthernBridgeEnd(ti->tile)));
+	uint num = DistanceMax(ti->tile, start);
+	const SortableSpriteStruct *sss;
+	Axis axis = GetBridgeAxis(ti->tile);
+	TLG tlg = GetTLG(ti->tile);
+
+	CatenarySprite offset = axis == AXIS_X ? 0 : WIRE_Y_FLAT_BOTH - WIRE_X_FLAT_BOTH;
+
+	if ((length % 2) && num == length) {
+		sss = &CatenarySpriteData[WIRE_X_FLAT_BOTH + offset];
+	} else {
+		sss = &CatenarySpriteData[WIRE_X_FLAT_SW + (num % 2) + offset];
+	}
+
+	if (num % 2) {
+		if (axis == AXIS_X) {
+			AddSortableSpriteToDraw( pylons_bridge[0 + HASBIT(tlg, 0)], ti->x, ti->y + 4 + 8 * HASBIT(tlg, 0), 1, 1, 10, GetBridgeHeight(ti->tile) + 8);
+		} else {
+			AddSortableSpriteToDraw( pylons_bridge[2 + HASBIT(tlg, 1)], ti->x + 4 + 8 * HASBIT(tlg, 1), ti->y, 1, 1, 10, GetBridgeHeight(ti->tile) + 8);
+		}
+	}
+
+	if (DistanceMax(ti->tile, start) == length) { /* need a pylon here (the southern end) */
+		if (axis == AXIS_X) {
+			AddSortableSpriteToDraw( pylons_bridge[0 + HASBIT(tlg, 0)], ti->x + 16, ti->y + 4 + 8 * HASBIT(tlg, 0), 1, 1, 10, GetBridgeHeight(ti->tile) + 8);
+		} else {
+			AddSortableSpriteToDraw( pylons_bridge[2 + HASBIT(tlg, 1)], ti->x + 4 + 8 * HASBIT(tlg, 1), ti->y + 16, 1, 1, 10, GetBridgeHeight(ti->tile) + 8);
+		}
+	}
+
+	AddSortableSpriteToDraw( sss->image, ti->x + sss->x_offset, ti->y + sss->y_offset,
+			sss->x_size, sss->y_size, sss->z_size, GetBridgeHeight(ti->tile) + sss->z_offset + 8);
+}
+
+void DrawCatenary(const TileInfo *ti)
+{
+	switch (GetTileType(ti->tile)) {
+		case MP_RAILWAY:
+			if (GetRailTileType(ti->tile) == RAIL_TYPE_DEPOT_WAYPOINT && GetRailTileSubtype(ti->tile) == RAIL_SUBTYPE_DEPOT) {
+				const SortableSpriteStruct *sss = &CatenarySpriteData[WIRE_DEPOT_SW + ReverseDiagDir(GetRailDepotDirection(ti->tile))];
+				AddSortableSpriteToDraw( sss->image, ti->x + sss->x_offset, ti->y + sss->y_offset,
+					sss->x_size, sss->y_size, sss->z_size, GetSlopeZ(ti->x, ti->y) + sss->z_offset);
+				return;
+			}
+			/* Fall through */
+		case MP_TUNNELBRIDGE:
+			if (IsBridgeTile(ti->tile) && IsBridgeMiddle(ti->tile) && GetRailTypeOnBridge(ti->tile) == RAILTYPE_ELECTRIC) DrawCatenaryOnBridge(ti);
+			/* Fall further */
+		case MP_STREET: case MP_STATION:
+			DrawCatenaryRailway(ti);
+			break;
+		default:
+			break;
+	}
+}
+

engine_gui.c

@@ -20,9 +20,10 @@ static StringID GetEngineCategoryName(EngineID engine)
 {
 	if (engine < NUM_TRAIN_ENGINES) {
 		switch (GetEngine(engine)->railtype) {
-			case RAILTYPE_RAIL:   return STR_8102_RAILROAD_LOCOMOTIVE;
+			case RAILTYPE_RAIL:     return STR_8102_RAILROAD_LOCOMOTIVE;
-			case RAILTYPE_MONO:   return STR_8106_MONORAIL_LOCOMOTIVE;
+			case RAILTYPE_ELECTRIC: return STR_8102_RAILROAD_LOCOMOTIVE;
-			case RAILTYPE_MAGLEV: return STR_8107_MAGLEV_LOCOMOTIVE;
+			case RAILTYPE_MONO:     return STR_8106_MONORAIL_LOCOMOTIVE;
+			case RAILTYPE_MAGLEV:   return STR_8107_MAGLEV_LOCOMOTIVE;
 		}
 	}
 

gfxinit.c

@@ -358,6 +358,9 @@ static void LoadSpriteTables(void)
 	load_index = SPR_AUTORAIL_BASE;
 	load_index += LoadGrfFile("autorail.grf", load_index, i++);
 
+	assert(load_index == SPR_ELRAIL_BASE);
+	load_index += LoadGrfFile("elrailsw.grf", load_index, i++);
+
 	assert(load_index == SPR_2CCMAP_BASE);
 	load_index += LoadGrfFile("2ccmap.grf", load_index, i++);
 

lang/english.txt

@@ -1443,6 +1443,7 @@ STR_1005_NO_SUITABLE_RAILROAD_TRACK                             :{WHITE}No suita
 STR_1007_ALREADY_BUILT                                          :{WHITE}...already built
 STR_1008_MUST_REMOVE_RAILROAD_TRACK                             :{WHITE}Must remove railway track first
 STR_100A_RAILROAD_CONSTRUCTION                                  :{WHITE}Railway Construction
+STR_TITLE_ELRAIL_CONSTRUCTION                                   :{WHITE}Electrified Railway Construction
 STR_100B_MONORAIL_CONSTRUCTION                                  :{WHITE}Monorail Construction
 STR_100C_MAGLEV_CONSTRUCTION                                    :{WHITE}MagLev Construction
 STR_100D_SELECT_RAIL_BRIDGE                                     :{WHITE}Select Rail Bridge
@@ -1454,6 +1455,7 @@ STR_1012_CAN_T_REMOVE_RAILROAD_TRACK                            :{WHITE}Can't re
 STR_1013_CAN_T_REMOVE_SIGNALS_FROM                              :{WHITE}Can't remove signals from here...
 STR_1014_TRAIN_DEPOT_ORIENTATION                                :{WHITE}Train Depot Orientation
 STR_1015_RAILROAD_CONSTRUCTION                                  :Railway construction
+STR_TOOLB_ELRAIL_CONSTRUCTION                                   :Electrified Railway construction
 STR_1016_MONORAIL_CONSTRUCTION                                  :Monorail construction
 STR_1017_MAGLEV_CONSTRUCTION                                    :MagLev construction
 STR_1018_BUILD_RAILROAD_TRACK                                   :{BLACK}Build railway track
@@ -2410,6 +2412,7 @@ STR_8819_TRAIN_TOO_LONG                                         :{WHITE}Train to
 STR_881A_TRAINS_CAN_ONLY_BE_ALTERED                             :{WHITE}Trains can only be altered when stopped inside a depot
 STR_881B_TRAINS                                                 :{WHITE}{COMPANY} - {COMMA} Train{P "" s}
 STR_881C_NEW_RAIL_VEHICLES                                      :{WHITE}New Rail Vehicles
+STR_NEW_ELRAIL_VEHICLES                                         :{WHITE}New Electric Rail Vehicles
 STR_881D_NEW_MONORAIL_VEHICLES                                  :{WHITE}New Monorail Vehicles
 STR_881E_NEW_MAGLEV_VEHICLES                                    :{WHITE}New Maglev Vehicles
 STR_881F_BUILD_VEHICLE                                          :{BLACK}Build Vehicle
@@ -2810,6 +2813,7 @@ STR_SIGN_LIST_CAPTION                                           :{WHITE}Sign Lis
 ############ Lists rail types
 
 STR_RAIL_VEHICLES                                               :Rail Vehicles
+STR_ELRAIL_VEHICLES                                             :Electrified Rail Vehicles
 STR_MONORAIL_VEHICLES                                           :Monorail Vehicles
 STR_MAGLEV_VEHICLES                                             :Maglev Vehicles
 

misc.c

@@ -401,8 +401,6 @@ typedef struct LandscapePredefVar {
 	byte transit_days_table_1[NUM_CARGO];
 	byte transit_days_table_2[NUM_CARGO];
 
-	byte railwagon_by_cargo[3][NUM_CARGO];
-
 	byte road_veh_by_cargo_start[NUM_CARGO];
 	byte road_veh_by_cargo_count[NUM_CARGO];
 } LandscapePredefVar;
@@ -419,7 +417,6 @@ void InitializeLandscapeVariables(bool only_constants)
 
 	lpd = &_landscape_predef_var[_opt.landscape];
 
-	memcpy(_cargoc.ai_railwagon, lpd->railwagon_by_cargo, sizeof(lpd->railwagon_by_cargo));
 	memcpy(_cargoc.ai_roadveh_start, lpd->road_veh_by_cargo_start,sizeof(lpd->road_veh_by_cargo_start));
 	memcpy(_cargoc.ai_roadveh_count, lpd->road_veh_by_cargo_count,sizeof(lpd->road_veh_by_cargo_count));
 

newgrf.c

@@ -355,6 +355,9 @@ static bool RailVehicleChangeInfo(uint engine, int numinfo, int prop, byte **buf
 					engclass = 0;
 				} else if (traction <= 0x27) {
 					engclass = 1;
+				} else if (traction <= 0x31) {
+					engclass = 2;
+					ei[i].railtype = RAILTYPE_ELECTRIC;
 				} else if (traction <= 0x41) {
 					engclass = 2;
 				} else {
@@ -2309,12 +2312,8 @@ static void InitializeGRFSpecial(void)
 	                   | (1 << 0x18)  /* newrvs */
 	                   | (1 << 0x19)  /* newships */
 	                   | (1 << 0x1A)  /* newplanes */
-	                   | (_patches.signal_side ? (1 << 0x1B) : 0);          /* signalsontrafficside */
+	                   | (_patches.signal_side ? (1 << 0x1B) : 0)           /* signalsontrafficside */
-	                   /* Uncomment following if you want to fool the GRF file.
+	                   | (1 << 0x1C); /* electrifiedrailway */
-	                    * Some GRF files will refuse to load without this
-	                    * but you can still squeeze something from them even
-	                    * without the support - i.e. USSet. --pasky */
-			               //| (1 << 0x1C); /* electrifiedrailway */
 
 	_ttdpatch_flags[2] = (_patches.build_on_slopes ? (1 << 0x0D) : 0)       /* buildonslopes */
 	                   | (_patches.build_on_slopes ? (1 << 0x15) : 0)       /* buildoncoasts */

npf.c

@@ -587,7 +587,7 @@ static void NPFFollowTrack(AyStar* aystar, OpenListNode* current)
 	/* check correct rail type (mono, maglev, etc) */
 	if (type == TRANSPORT_RAIL) {
 		RailType dst_type = GetTileRailType(dst_tile, src_trackdir);
-		if (!IsCompatibleRail(aystar->user_data[NPF_RAILTYPE], dst_type))
+		if (!HASBIT(aystar->user_data[NPF_RAILTYPES], dst_type))
 			return;
 	}
 
@@ -661,7 +661,7 @@ static void NPFFollowTrack(AyStar* aystar, OpenListNode* current)
  * multiple targets that are spread around, we should perform a breadth first
  * search by specifiying CalcZero as our heuristic.
  */
-static NPFFoundTargetData NPFRouteInternal(AyStarNode* start1, AyStarNode* start2, NPFFindStationOrTileData* target, AyStar_EndNodeCheck target_proc, AyStar_CalculateH heuristic_proc, TransportType type, Owner owner, RailType railtype, uint reverse_penalty)
+static NPFFoundTargetData NPFRouteInternal(AyStarNode* start1, AyStarNode* start2, NPFFindStationOrTileData* target, AyStar_EndNodeCheck target_proc, AyStar_CalculateH heuristic_proc, TransportType type, Owner owner, RailTypeMask railtypes, uint reverse_penalty)
 {
 	int r;
 	NPFFoundTargetData result;
@@ -703,7 +703,7 @@ static NPFFoundTargetData NPFRouteInternal(AyStarNode* start1, AyStarNode* start
 	/* Initialize user_data */
 	_npf_aystar.user_data[NPF_TYPE] = type;
 	_npf_aystar.user_data[NPF_OWNER] = owner;
-	_npf_aystar.user_data[NPF_RAILTYPE] = railtype;
+	_npf_aystar.user_data[NPF_RAILTYPES] = railtypes;
 
 	/* GO! */
 	r = AyStarMain_Main(&_npf_aystar);
@@ -721,7 +721,7 @@ static NPFFoundTargetData NPFRouteInternal(AyStarNode* start1, AyStarNode* start
 	return result;
 }
 
-NPFFoundTargetData NPFRouteToStationOrTileTwoWay(TileIndex tile1, Trackdir trackdir1, TileIndex tile2, Trackdir trackdir2, NPFFindStationOrTileData* target, TransportType type, Owner owner, RailType railtype)
+NPFFoundTargetData NPFRouteToStationOrTileTwoWay(TileIndex tile1, Trackdir trackdir1, TileIndex tile2, Trackdir trackdir2, NPFFindStationOrTileData* target, TransportType type, Owner owner, RailTypeMask railtypes)
 {
 	AyStarNode start1;
 	AyStarNode start2;
@@ -735,15 +735,15 @@ NPFFoundTargetData NPFRouteToStationOrTileTwoWay(TileIndex tile1, Trackdir track
 	start2.direction = trackdir2;
 	start2.user_data[NPF_TRACKDIR_CHOICE] = INVALID_TRACKDIR;
 
-	return NPFRouteInternal(&start1, (IsValidTile(tile2) ? &start2 : NULL), target, NPFFindStationOrTile, NPFCalcStationOrTileHeuristic, type, owner, railtype, 0);
+	return NPFRouteInternal(&start1, (IsValidTile(tile2) ? &start2 : NULL), target, NPFFindStationOrTile, NPFCalcStationOrTileHeuristic, type, owner, railtypes, 0);
 }
 
-NPFFoundTargetData NPFRouteToStationOrTile(TileIndex tile, Trackdir trackdir, NPFFindStationOrTileData* target, TransportType type, Owner owner, RailType railtype)
+NPFFoundTargetData NPFRouteToStationOrTile(TileIndex tile, Trackdir trackdir, NPFFindStationOrTileData* target, TransportType type, Owner owner, RailTypeMask railtypes)
 {
-	return NPFRouteToStationOrTileTwoWay(tile, trackdir, INVALID_TILE, 0, target, type, owner, railtype);
+	return NPFRouteToStationOrTileTwoWay(tile, trackdir, INVALID_TILE, 0, target, type, owner, railtypes);
 }
 
-NPFFoundTargetData NPFRouteToDepotBreadthFirstTwoWay(TileIndex tile1, Trackdir trackdir1, TileIndex tile2, Trackdir trackdir2, TransportType type, Owner owner, RailType railtype, uint reverse_penalty)
+NPFFoundTargetData NPFRouteToDepotBreadthFirstTwoWay(TileIndex tile1, Trackdir trackdir1, TileIndex tile2, Trackdir trackdir2, TransportType type, Owner owner, RailTypeMask railtypes, uint reverse_penalty)
 {
 	AyStarNode start1;
 	AyStarNode start2;
@@ -759,15 +759,15 @@ NPFFoundTargetData NPFRouteToDepotBreadthFirstTwoWay(TileIndex tile1, Trackdir t
 
 	/* perform a breadth first search. Target is NULL,
 	 * since we are just looking for any depot...*/
-	return NPFRouteInternal(&start1, (IsValidTile(tile2) ? &start2 : NULL), NULL, NPFFindDepot, NPFCalcZero, type, owner, railtype, reverse_penalty);
+	return NPFRouteInternal(&start1, (IsValidTile(tile2) ? &start2 : NULL), NULL, NPFFindDepot, NPFCalcZero, type, owner, railtypes, reverse_penalty);
 }
 
-NPFFoundTargetData NPFRouteToDepotBreadthFirst(TileIndex tile, Trackdir trackdir, TransportType type, Owner owner, RailType railtype)
+NPFFoundTargetData NPFRouteToDepotBreadthFirst(TileIndex tile, Trackdir trackdir, TransportType type, Owner owner, RailTypeMask railtypes)
 {
-	return NPFRouteToDepotBreadthFirstTwoWay(tile, trackdir, INVALID_TILE, 0, type, owner, railtype, 0);
+	return NPFRouteToDepotBreadthFirstTwoWay(tile, trackdir, INVALID_TILE, 0, type, owner, railtypes, 0);
 }
 
-NPFFoundTargetData NPFRouteToDepotTrialError(TileIndex tile, Trackdir trackdir, TransportType type, Owner owner, RailType railtype)
+NPFFoundTargetData NPFRouteToDepotTrialError(TileIndex tile, Trackdir trackdir, TransportType type, Owner owner, RailTypeMask railtypes)
 {
 	/* Okay, what we're gonna do. First, we look at all depots, calculate
 	 * the manhatten distance to get to each depot. We then sort them by

npf.h

@@ -38,7 +38,7 @@ typedef struct NPFFindStationOrTileData { /* Meant to be stored in AyStar.target
 enum { /* Indices into AyStar.userdata[] */
 	NPF_TYPE = 0, /* Contains a TransportTypes value */
 	NPF_OWNER, /* Contains an Owner value */
-	NPF_RAILTYPE, /* Contains the RailType value of the engine when NPF_TYPE == TRANSPORT_RAIL. Unused otherwise. */
+	NPF_RAILTYPES, /* Contains a bitmask the compatible RailTypes of the engine when NPF_TYPE == TRANSPORT_RAIL. Unused otherwise. */
 };
 
 enum { /* Indices into AyStarNode.userdata[] */
@@ -64,28 +64,28 @@ typedef struct NPFFoundTargetData { /* Meant to be stored in AyStar.userpath */
 /* Will search from the given tile and direction, for a route to the given
  * station for the given transport type. See the declaration of
  * NPFFoundTargetData above for the meaning of the result. */
-NPFFoundTargetData NPFRouteToStationOrTile(TileIndex tile, Trackdir trackdir, NPFFindStationOrTileData* target, TransportType type, Owner owner, RailType railtype);
+NPFFoundTargetData NPFRouteToStationOrTile(TileIndex tile, Trackdir trackdir, NPFFindStationOrTileData* target, TransportType type, Owner owner, RailTypeMask railtypes);
 
 /* Will search as above, but with two start nodes, the second being the
  * reverse. Look at the NPF_FLAG_REVERSE flag in the result node to see which
  * direction was taken (NPFGetBit(result.node, NPF_FLAG_REVERSE)) */
-NPFFoundTargetData NPFRouteToStationOrTileTwoWay(TileIndex tile1, Trackdir trackdir1, TileIndex tile2, Trackdir trackdir2, NPFFindStationOrTileData* target, TransportType type, Owner owner, RailType railtype);
+NPFFoundTargetData NPFRouteToStationOrTileTwoWay(TileIndex tile1, Trackdir trackdir1, TileIndex tile2, Trackdir trackdir2, NPFFindStationOrTileData* target, TransportType type, Owner owner, RailTypeMask railtypes);
 
 /* Will search a route to the closest depot. */
 
 /* Search using breadth first. Good for little track choice and inaccurate
  * heuristic, such as railway/road.*/
-NPFFoundTargetData NPFRouteToDepotBreadthFirst(TileIndex tile, Trackdir trackdir, TransportType type, Owner owner, RailType railtype);
+NPFFoundTargetData NPFRouteToDepotBreadthFirst(TileIndex tile, Trackdir trackdir, TransportType type, Owner owner, RailTypeMask railtypes);
 /* Same as above but with two start nodes, the second being the reverse. Call
  * NPFGetBit(result.node, NPF_FLAG_REVERSE) to see from which node the path
  * orginated. All pathfs from the second node will have the given
  * reverse_penalty applied (NPF_TILE_LENGTH is the equivalent of one full
  * tile).
  */
-NPFFoundTargetData NPFRouteToDepotBreadthFirstTwoWay(TileIndex tile1, Trackdir trackdir1, TileIndex tile2, Trackdir trackdir2, TransportType type, Owner owner, RailType railtype, uint reverse_penalty);
+NPFFoundTargetData NPFRouteToDepotBreadthFirstTwoWay(TileIndex tile1, Trackdir trackdir1, TileIndex tile2, Trackdir trackdir2, TransportType type, Owner owner, RailTypeMask railtypes, uint reverse_penalty);
 /* Search by trying each depot in order of Manhattan Distance. Good for lots
  * of choices and accurate heuristics, such as water. */
-NPFFoundTargetData NPFRouteToDepotTrialError(TileIndex tile, Trackdir trackdir, TransportType type, Owner owner, RailType railtype);
+NPFFoundTargetData NPFRouteToDepotTrialError(TileIndex tile, Trackdir trackdir, TransportType type, Owner owner, RailTypeMask railtypes);
 
 void NPFFillWithOrderData(NPFFindStationOrTileData* fstd, Vehicle* v);
 

openttd.c

@@ -1238,6 +1238,75 @@ bool AfterLoadGame(void)
 		}
 	}
 
+	/* Elrails got added in rev 24 */
+	if (CheckSavegameVersion(24)) {
+		Vehicle* v;
+		uint i;
+		TileIndex t;
+		bool make_elrail = false;
+
+		for (i = 0; i < lengthof(_engines); i++) {
+			Engine* e = GetEngine(i);
+			if (e->type == VEH_Train &&
+					(e->railtype != RAILTYPE_RAIL || RailVehInfo(i)->engclass == 2)) {
+				e->railtype++;
+			}
+		}
+
+		FOR_ALL_VEHICLES(v) {
+			if (v->type == VEH_Train) {
+				RailType rt = GetEngine(v->engine_type)->railtype;
+
+				v->u.rail.railtype = rt;
+				if (rt == RAILTYPE_ELECTRIC) make_elrail = true;
+			}
+		}
+
+		/* .. so we convert the entire map from normal to elrail (so maintain "fairness") */
+		for (t = 0; t < MapSize(); t++) {
+			switch (GetTileType(t)) {
+				case MP_RAILWAY:
+					if (GetRailType(t) > RAILTYPE_RAIL || make_elrail) AB(_m[t].m3, 0, 4, 1);
+					break;
+
+				case MP_STREET:
+					if (IsLevelCrossing(t) && (GetRailTypeCrossing(t) > RAILTYPE_RAIL || make_elrail)) AB(_m[t].m4, 0, 4, 1);
+					break;
+
+				case MP_STATION:
+					if (_m[t].m5 < 8 && (GB(_m[t].m3, 0, 4) > RAILTYPE_RAIL || make_elrail)) AB(_m[t].m3, 0, 4, 1);
+					break;
+
+				case MP_TUNNELBRIDGE:
+					if (GB(_m[t].m5, 4, 4) == 0) { // tunnel?
+						if (GB(_m[t].m5, 2, 2) == 0) { // railway tunnel?
+							if (GB(_m[t].m3, 0, 4) > RAILTYPE_RAIL || make_elrail) AB(_m[t].m3, 0, 4, 1);
+						}
+					} else {
+						if (GB(_m[t].m5, 1, 2) == 0) { // railway bridge?
+							if (GB(_m[t].m5, 6, 1) == 0) { // bridge ending?
+								if (GB(_m[t].m3, 0, 4) > RAILTYPE_RAIL || make_elrail) AB(_m[t].m3, 0, 4, 1);
+							} else {
+								if (GB(_m[t].m3, 4, 4) > RAILTYPE_RAIL || make_elrail) AB(_m[t].m3, 4, 4, 1);
+							}
+						}
+						if ((_m[t].m5 & 0xF8) == 0xE0) { // bridge middle part with rails below?
+							if (GB(_m[t].m3, 0, 4) > RAILTYPE_RAIL || make_elrail) AB(_m[t].m3, 0, 4, 1);
+						}
+					}
+					break;
+
+				default:
+					break;
+			}
+		}
+
+		FOR_ALL_VEHICLES(v) {
+			if (v->type == VEH_Train && (IsFrontEngine(v) || IsFreeWagon(v))) TrainConsistChanged(v);
+		}
+
+	}
+
 	/* In version 16.1 of the savegame a player can decide if trains, which get
 	 * replaced, shall keep their old length. In all prior versions, just default
 	 * to false */

openttd.dsp

@@ -209,6 +209,10 @@ SOURCE=.\economy.c
 # End Source File
 # Begin Source File
 
+SOURCE=.\elrail.c
+# End Source File
+# Begin Source File
+
 SOURCE=.\engine.c
 # End Source File
 # Begin Source File

openttd.vcproj

@@ -214,6 +214,9 @@
 			<File
 				RelativePath=".\economy.c">
 			</File>
+			<File
+				RelativePath=".\elrail.c">
+			</File>
 			<File
 				RelativePath=".\engine.c">
 			</File>

pathfind.c

@@ -454,7 +454,8 @@ typedef struct {
 	void *userdata;
 	TileIndex dest;
 
-	byte tracktype;
+	TransportType tracktype;
+	RailTypeMask railtypes;
 	uint maxlength;
 
 	HashLink *new_link;
@@ -791,6 +792,11 @@ start_at:
 			 * bits, not just reachable ones, to prevent infinite loops. */
 			if (bits == 0 || TracksOverlap(allbits)) break;
 
+			if (!HASBIT(tpf->railtypes, GetRailType(tile))) {
+				bits = 0;
+				break;
+			}
+
 			/* If we reach here, the tile has exactly one track, and this
 			 track is reachable => Rail segment continues */
 
@@ -926,14 +932,15 @@ start_at:
 
 
 // new pathfinder for trains. better and faster.
-void NewTrainPathfind(TileIndex tile, TileIndex dest, DiagDirection direction, NTPEnumProc* enum_proc, void* data)
+void NewTrainPathfind(TileIndex tile, TileIndex dest, RailTypeMask railtypes, DiagDirection direction, NTPEnumProc* enum_proc, void* data)
 {
 	NewTrackPathFinder tpf;
 
 	tpf.dest = dest;
 	tpf.userdata = data;
 	tpf.enum_proc = enum_proc;
-	tpf.tracktype = 0;
+	tpf.tracktype = TRANSPORT_RAIL;
+	tpf.railtypes = railtypes;
 	tpf.maxlength = min(_patches.pf_maxlength * 3, 10000);
 	tpf.nstack = 0;
 	tpf.new_link = tpf.links;

pathfind.h

@@ -68,6 +68,6 @@ typedef struct {
 } FindLengthOfTunnelResult;
 FindLengthOfTunnelResult FindLengthOfTunnel(TileIndex tile, DiagDirection direction);
 
-void NewTrainPathfind(TileIndex tile, TileIndex dest, DiagDirection direction, NTPEnumProc* enum_proc, void* data);
+void NewTrainPathfind(TileIndex tile, TileIndex dest, RailTypeMask railtypes, DiagDirection direction, NTPEnumProc* enum_proc, void* data);
 
 #endif /* PATHFIND_H */

player.h

@@ -248,6 +248,7 @@ static inline RailType GetBestRailtype(const Player* p)
 {
 	if (HasRailtypeAvail(p, RAILTYPE_MAGLEV)) return RAILTYPE_MAGLEV;
 	if (HasRailtypeAvail(p, RAILTYPE_MONO)) return RAILTYPE_MONO;
+	if (HasRailtypeAvail(p, RAILTYPE_ELECTRIC)) return RAILTYPE_ELECTRIC;
 	return RAILTYPE_RAIL;
 }
 

rail.h

@@ -9,7 +9,6 @@
 #include "rail_map.h"
 #include "tile.h"
 
-
 /** These are a combination of tracks and directions. Values are 0-5 in one
 direction (corresponding to the Track enum) and 8-13 in the other direction. */
 typedef enum Trackdirs {
@@ -110,8 +109,11 @@ typedef struct RailtypeInfo {
 	/** sprite number difference between a piece of track on a snowy ground and the corresponding one on normal ground */
 	SpriteID snow_offset;
 
-	/** bitmask to the OTHER railtypes that can be used by an engine of THIS railtype */
+	/** bitmask to the OTHER railtypes on which an engine of THIS railtype generates power */
-	byte compatible_railtypes;
+	RailTypeMask powered_railtypes;
+
+	/** bitmask to the OTHER railtypes on which an engine of THIS railtype can physically travel */
+	RailTypeMask compatible_railtypes;
 
 	/**
 	 * Offset between the current railtype and normal rail. This means that:<p>
@@ -478,6 +480,11 @@ static inline bool IsCompatibleRail(RailType enginetype, RailType tiletype)
 	return HASBIT(GetRailTypeInfo(enginetype)->compatible_railtypes, tiletype);
 }
 
+static inline bool HasPowerOnRail(RailType enginetype, RailType tiletype)
+{
+	return HASBIT(GetRailTypeInfo(enginetype)->powered_railtypes, tiletype);
+}
+
 /**
  * Checks if the given tracks overlap, ie form a crossing. Basically this
  * means when there is more than one track on the tile, exept when there are
@@ -497,4 +504,13 @@ static inline bool TracksOverlap(TrackBits bits)
 
 void DrawTrainDepotSprite(int x, int y, int image, RailType railtype);
 void DrawDefaultWaypointSprite(int x, int y, RailType railtype);
+
+/**
+ * Draws overhead wires and pylons for electric railways.
+ * @param ti The TileInfo struct of the tile being drawn
+ * @see DrawCatenaryRailway
+ */
+void DrawCatenary(const TileInfo *ti);
+
+uint GetRailFoundation(uint tileh, uint bits);
 #endif /* RAIL_H */

rail_cmd.c

@@ -896,11 +896,13 @@ int32 CmdRemoveSignalTrack(int x, int y, uint32 flags, uint32 p1, uint32 p2)
 	return CmdSignalTrackHelper(x, y, flags, p1, SETBIT(p2, 0));
 }
 
-typedef int32 DoConvertRailProc(TileIndex tile, uint totype, bool exec);
+typedef int32 DoConvertRailProc(TileIndex tile, RailType totype, bool exec);
 
-static int32 DoConvertRail(TileIndex tile, uint totype, bool exec)
+static int32 DoConvertRail(TileIndex tile, RailType totype, bool exec)
 {
-	if (!CheckTileOwnership(tile) || !EnsureNoVehicle(tile)) return CMD_ERROR;
+	if (!CheckTileOwnership(tile)) return CMD_ERROR;
+
+	if (!EnsureNoVehicle(tile) && (!IsCompatibleRail(GetRailType(tile), totype) || IsPlainRailTile(tile))) return CMD_ERROR;
 
 	// tile is already of requested type?
 	if (GetRailType(tile) == totype) return CMD_ERROR;
@@ -1297,6 +1299,9 @@ static void DrawTrackBits(TileInfo* ti, TrackBits track, bool earth, bool snow,
 		if (track & TRACK_BIT_LEFT)  DrawGroundSprite(rti->base_sprites.single_w);
 		if (track & TRACK_BIT_RIGHT) DrawGroundSprite(rti->base_sprites.single_e);
 	}
+
+	if (GB(_m[ti->tile].m3, 0, 4) == RAILTYPE_ELECTRIC) DrawCatenary(ti);
+
 }
 
 static void DrawTile_Track(TileInfo *ti)
@@ -1388,6 +1393,8 @@ static void DrawTile_Track(TileInfo *ti)
 
 				DrawGroundSprite(image);
 
+				if (GetRailType(ti->tile) == RAILTYPE_ELECTRIC) DrawCatenary(ti);
+
 				foreach_draw_tile_seq(seq, cust->seq) {
 					DrawSpecialBuilding(
 						seq->image + relocation, 0, ti,
@@ -1420,6 +1427,8 @@ static void DrawTile_Track(TileInfo *ti)
 
 		DrawGroundSprite(image);
 
+		if (GetRailType(ti->tile) == RAILTYPE_ELECTRIC) DrawCatenary(ti);
+
 		for (; drss->image != 0; drss++) {
 			DrawSpecialBuilding(
 				drss->image, type < 4 ? rti->total_offset : 0, ti,

rail_map.h

@@ -32,13 +32,16 @@ typedef enum RailTileSubtypes {
 
 
 typedef enum RailTypes {
-	RAILTYPE_RAIL   = 0,
+	RAILTYPE_RAIL     = 0,
-	RAILTYPE_MONO   = 1,
+	RAILTYPE_ELECTRIC = 1,
-	RAILTYPE_MAGLEV = 2,
+	RAILTYPE_MONO     = 2,
+	RAILTYPE_MAGLEV   = 3,
 	RAILTYPE_END,
 	INVALID_RAILTYPE = 0xFF
 } RailType;
 
+typedef byte RailTypeMask;
+
 static inline RailType GetRailType(TileIndex t)
 {
 	return (RailType)GB(_m[t].m3, 0, 4);

railtypes.h

@@ -40,8 +40,11 @@ const RailtypeInfo _railtypes[] = {
 		/* Offset of snow tiles */
 		SPR_RAIL_SNOW_OFFSET,
 
+		/* Powered railtypes */
+		1 << RAILTYPE_RAIL | 1 << RAILTYPE_ELECTRIC,
+
 		/* Compatible railtypes */
-		(1 << RAILTYPE_RAIL),
+		1 << RAILTYPE_RAIL | 1 << RAILTYPE_ELECTRIC,
 
 		/* main offset */
 		0,
@@ -50,6 +53,56 @@ const RailtypeInfo _railtypes[] = {
 		0,
 	},
 
+	/** Electrified railway */
+	{ /* Main Sprites */
+		{ SPR_RAIL_TRACK_Y, SPR_RAIL_TRACK_N_S, SPR_RAIL_TRACK_BASE, SPR_RAIL_SINGLE_Y, SPR_RAIL_SINGLE_X,
+			SPR_RAIL_SINGLE_NORTH, SPR_RAIL_SINGLE_SOUTH, SPR_RAIL_SINGLE_EAST, SPR_RAIL_SINGLE_WEST,
+			SPR_CROSSING_OFF_X_RAIL,
+			SPR_TUNNEL_ENTRY_REAR_RAIL
+		},
+
+		/* GUI sprites */
+		{
+			SPR_BUILD_NS_ELRAIL,
+			SPR_BUILD_X_ELRAIL,
+			SPR_BUILD_EW_ELRAIL,
+			SPR_BUILD_Y_ELRAIL,
+			SPR_OPENTTD_BASE + 0,
+			0x50E,
+			SPR_BUILD_TUNNEL_ELRAIL,
+			SPR_IMG_CONVERT_RAIL
+		},
+
+		{
+			SPR_CURSOR_NS_ELRAIL,
+			SPR_CURSOR_SWNE_ELRAIL,
+			SPR_CURSOR_EW_ELRAIL,
+			SPR_CURSOR_NWSE_ELRAIL,
+			SPR_CURSOR_AUTORAIL,
+			SPR_CURSOR_RAIL_DEPOT,
+			SPR_CURSOR_TUNNEL_ELRAIL,
+			SPR_CURSOR_CONVERT_RAIL
+		},
+
+		/* strings */
+		{ STR_TITLE_ELRAIL_CONSTRUCTION },
+
+		/* Offset of snow tiles */
+		SPR_RAIL_SNOW_OFFSET,
+
+		/* Powered railtypes */
+		1 << RAILTYPE_ELECTRIC,
+
+		/* Compatible railtypes */
+		1 << RAILTYPE_ELECTRIC | 1 << RAILTYPE_RAIL,
+
+		/* main offset */
+		0,
+
+		/* bridge offset */
+		0
+	},
+
 	/** Monorail */
 	{ /* Main Sprites */
 		{ SPR_MONO_TRACK_Y, SPR_MONO_TRACK_N_S, SPR_MONO_TRACK_BASE, SPR_MONO_SINGLE_Y, SPR_MONO_SINGLE_X,
@@ -83,8 +136,11 @@ const RailtypeInfo _railtypes[] = {
 		/* Offset of snow tiles */
 		SPR_MONO_SNOW_OFFSET,
 
+		/* Powered railtypes */
+		1 << RAILTYPE_MONO,
+
 		/* Compatible Railtypes */
-		(1 << RAILTYPE_MONO),
+		1 << RAILTYPE_MONO,
 
 		/* main offset */
 		82,
@@ -126,8 +182,11 @@ const RailtypeInfo _railtypes[] = {
 		/* Offset of snow tiles */
 		SPR_MGLV_SNOW_OFFSET,
 
+		/* Powered railtypes */
+		1 << RAILTYPE_MAGLEV,
+
 		/* Compatible Railtypes */
-		(1 << RAILTYPE_MAGLEV),
+		1 << RAILTYPE_MAGLEV,
 
 		/* main offset */
 		164,

road_cmd.c

@@ -787,6 +787,7 @@ static void DrawTile_Road(TileInfo *ti)
 			}
 
 			DrawGroundSprite(image);
+			if (GB(_m[ti->tile].m4, 0, 4) == RAILTYPE_ELECTRIC) DrawCatenary(ti);
 			break;
 		}
 

saveload.c

@@ -30,7 +30,7 @@
 #include "variables.h"
 #include <setjmp.h>
 
-const uint16 SAVEGAME_VERSION = 23;
+const uint16 SAVEGAME_VERSION = 24;
 uint16 _sl_version;       /// the major savegame version identifier
 byte   _sl_minor_version; /// the minor savegame version, DO NOT USE!
 

station_cmd.c

@@ -1959,6 +1959,8 @@ static void DrawTile_Station(TileInfo *ti)
 	// but this is something else. If AI builds station with 114 it looks all weird
 	DrawGroundSprite(image);
 
+	if (GB(_m[ti->tile].m3, 0, 4) == RAILTYPE_ELECTRIC) DrawCatenary(ti);
+
 	foreach_draw_tile_seq(dtss, t->seq) {
 		image = dtss->image + relocation;
 		image += offset;

table/elrail_data.h

@@ -0,0 +1,362 @@
+/* $Id */
+/** @file elrail_data.h Stores all the data for overhead wire and pylon drawing. @see elrail.c */
+
+#ifndef ELRAIL_DATA_H
+#define ELRAIL_DATA_H
+
+/** Tile Location group. This defines whether the X and or Y coordinate of a tile is even */
+typedef enum TLG {
+	XEVEN_YEVEN = 0,
+	XEVEN_YODD  = 1,
+	XODD_YEVEN  = 2,
+	XODD_YODD   = 3,
+	TLG_END
+} TLG;
+
+/** When determining the pylon configuration on the edge, two tiles are taken into account:
+  * the tile being drawn itself (the home tile, the one in ti->tile), and the neighbouring tile
+  */
+typedef enum {
+	TS_HOME      = 0,
+	TS_NEIGHBOUR = 1,
+
+	TS_END
+} TileSource;
+
+enum {
+	TRACKS_AT_PCP = 6
+};
+
+/** Which PPPs are possible at all on a given PCP */
+static byte AllowedPPPonPCP[DIAGDIR_END] = {
+	1 << DIR_N | 1 << DIR_E | 1 << DIR_SE | 1 << DIR_S | 1 << DIR_W | 1 << DIR_NW,
+	1 << DIR_N | 1 << DIR_NE | 1 << DIR_E | 1 << DIR_S | 1 << DIR_SW | 1 << DIR_W,
+	1 << DIR_N | 1 << DIR_E | 1 << DIR_SE | 1 << DIR_S | 1 << DIR_W | 1 << DIR_NW,
+	1 << DIR_N | 1 << DIR_NE | 1 << DIR_E | 1 << DIR_S | 1 << DIR_SW | 1 << DIR_W,
+};
+
+/** Which of the PPPs are inside the tile. For the two PPPs on the tile border the following system is used:
+  if you rotate the PCP so that it is in the north, the eastern PPP belongs to the tile. */
+static byte OwnedPPPonPCP[DIAGDIR_END] = {
+	1 << DIR_SE | 1 << DIR_S | 1 << DIR_SW | 1 << DIR_W,
+	1 << DIR_N | 1 << DIR_SW | 1 << DIR_W | 1 << DIR_NW,
+	1 << DIR_N | 1 << DIR_NE | 1 << DIR_E | 1 << DIR_NW,
+	1 << DIR_NE | 1 << DIR_E | 1 << DIR_SE | 1 << DIR_S
+};
+
+/** Preferred points of each trackbit. Those are the ones perpendicular to the track, plus the point in
+  extension of the track (to mark end-of-track).*/
+static byte PreferredPPPofTrackBitAtPCP[TRACK_END][DIAGDIR_END] = {
+	{1 << DIR_NE | 1 << DIR_SE | 1 << DIR_NW, 0xFF, 1 << DIR_SE | 1 << DIR_SW | 1 << DIR_NW, 0xFF }, /* X */
+	{0xFF, 1 << DIR_NE | 1 << DIR_SE | 1 << DIR_SW, 0xFF, 1 << DIR_SW | 1 << DIR_NW | 1 << DIR_NE }, /* Y */
+	{1 << DIR_E | 1 << DIR_N | 1 << DIR_S, 0xFF, 0xFF, 1 << DIR_W | 1 << DIR_N | 1 << DIR_S},        /* UPPER */
+	{0xFF, 1 << DIR_E | 1 << DIR_N | 1 << DIR_S, 1 << DIR_W | 1 << DIR_N | 1 << DIR_S, 0xFF},        /* LOWER */
+	{0xFF, 0xFF, 1 << DIR_S | 1 << DIR_E | 1 << DIR_W, 1 << DIR_N | 1 << DIR_E | 1 << DIR_W},        /* LEFT */
+	{1 << DIR_N | 1 << DIR_E | 1 << DIR_W, 1 << DIR_S | 1 << DIR_E | 1 << DIR_W, 0xFF, 0xFF},        /* RIGHT */
+};
+
+#define NUM_IGNORE_GROUPS 3
+/** In case we have a staight line, we place pylon only every two tiles, so there are certain tiles
+  which we ignore. A straight line is found if we have exactly two preferred points.*/
+static byte IgnoredPCP[NUM_IGNORE_GROUPS][TLG_END][DIAGDIR_END] = {
+	{
+		{1 << DIR_N  | 1 << DIR_S , 1 << DIR_NE | 1 << DIR_SW, 1 << DIR_NW | 1 << DIR_SE, 1 << DIR_W  | 1 << DIR_E},
+		{0xFF , 1 << DIR_E | 1 << DIR_W, 1 << DIR_NW | 1 << DIR_SE, 1 << DIR_NE | 1 << DIR_SW},
+		{1 << DIR_NW | 1 << DIR_SE, 1 << DIR_NE | 1 << DIR_SW, 1 << DIR_N  | 1 << DIR_S , 0xFF},
+		{1 << DIR_NW | 1 << DIR_SE, 0xFF , 0xFF, 1 << DIR_NE | 1 << DIR_SW}
+	},
+	{
+		{1 << DIR_E | 1 << DIR_W, 1 << DIR_N | 1 << DIR_S, 0xFF, 1 << DIR_E | 1 << DIR_W},
+		{0xFF, 0xFF, 1 << DIR_N | 1 << DIR_S, 1 << DIR_N | 1 << DIR_S},
+		{0xFF, 1 << DIR_E | 1 << DIR_W, 1 << DIR_E | 1 << DIR_W, 1 << DIR_N | 1 << DIR_S},
+		{1 << DIR_N | 1 << DIR_S, 1 << DIR_N | 1 << DIR_S, 0xFF, 1 << DIR_E | 1 << DIR_W}
+	},
+	{
+		{0xFF, 0xFF, 0xFF, 0xFF},
+		{0xFF, 0xFF, 1 << DIR_E | 1 << DIR_W, 0xFF},
+		{0xFF, 0xFF, 0xFF, 0xFF},
+		{1 << DIR_E | 1 << DIR_W, 0xFF, 0xFF, 0xFF}
+	}
+};
+
+/** Which pylons can definately NOT be built */
+static byte DisallowedPPPofTrackBitAtPCP[TRACK_END][DIAGDIR_END] = {
+	{1 << DIR_SW | 1 << DIR_NE, 0,           1 << DIR_SW | 1 << DIR_NE, 0          }, /* X */
+	{0,           1 << DIR_NW | 1 << DIR_SE, 0,           1 << DIR_NW | 1 << DIR_SE}, /* Y */
+	{1 << DIR_W | 1 << DIR_E,  0,           0,           1 << DIR_W | 1 << DIR_E }, /* UPPER */
+	{0,           1 << DIR_W | 1 << DIR_E,  1 << DIR_W | 1 << DIR_E,  0          }, /* LOWER */
+	{0,           0,           1 << DIR_S | 1 << DIR_N,  1 << DIR_N | 1 << DIR_S }, /* LEFT */
+	{1 << DIR_S | 1 << DIR_N,  1 << DIR_S | 1 << DIR_N,  0,           0,         }, /* RIGHT */
+};
+
+typedef struct {
+	SpriteID image;
+	int8 x_offset;
+	int8 y_offset;
+	int8 x_size;
+	int8 y_size;
+	int8 z_size;
+	int8 z_offset;
+} SortableSpriteStruct;
+
+enum {
+	/** Distance between wire and rail */
+	ELRAIL_ELEVATION = 8,
+	/** Corrects an off-by-one error in some places (tileh 12 and 9) (TODO -- find source of error) */
+	ELRAIL_ELEV_CORR = ELRAIL_ELEVATION + 1,
+	/** Wires that a draw one level higher than the north corner. */
+	ELRAIL_ELEVRAISE = ELRAIL_ELEVATION + TILE_HEIGHT
+};
+
+static const SortableSpriteStruct CatenarySpriteData[] = {
+/* X direction */
+	/* Flat tiles: */
+		/* Wires */
+	{ SPR_WIRE_X_SW,          0,  8, 16,  1,  1, ELRAIL_ELEVATION }, //! 0: Wire in X direction, pylon on the SW end only
+	{ SPR_WIRE_X_NE,          0,  8, 16,  1,  1, ELRAIL_ELEVATION }, //! 1: Wire in X direction, pylon on the NE end
+	{ SPR_WIRE_X_SHORT,       0,  8, 16,  1,  1, ELRAIL_ELEVATION }, //! 2: Wire in X direction, pylon on both ends
+
+	/* "up" tiles */
+		/* Wires */
+	{ SPR_WIRE_X_SW_UP,       0,  8, 16,  8,  1, ELRAIL_ELEVRAISE }, //! 3: Wire in X pitch up, pylon on the SW end only
+	{ SPR_WIRE_X_NE_UP,       0,  8, 16,  8,  1, ELRAIL_ELEVRAISE }, //! 4: Wire in X pitch up, pylon on the NE end
+	{ SPR_WIRE_X_SHORT_UP,    0,  8, 16,  8,  1, ELRAIL_ELEVRAISE }, //! 5: Wire in X pitch up, pylon on both ends
+
+	/* "down" tiles */
+		/* Wires */
+	{ SPR_WIRE_X_SW_DOWN,     0,  8, 16,  8,  1, ELRAIL_ELEV_CORR }, //! 6: Wire in X pitch down, pylon on the SW end
+	{ SPR_WIRE_X_NE_DOWN,     0,  8, 16,  8,  1, ELRAIL_ELEV_CORR }, //! 7: Wire in X pitch down, pylon on the NE end
+	{ SPR_WIRE_X_SHORT_DOWN,  0,  8, 16,  8,  1, ELRAIL_ELEV_CORR }, //! 8: Wire in X pitch down, pylon on both ends
+
+
+/* Y direction */
+	/* Flat tiles: */
+		/* Wires */
+	{ SPR_WIRE_Y_SE,          8,  0,  1, 16,  1, ELRAIL_ELEVATION }, //! 9: Wire in Y direction, pylon on the SE end only
+	{ SPR_WIRE_Y_NW,          8,  0,  1, 16,  1, ELRAIL_ELEVATION }, //!10: Wire in Y direction, pylon on the NW end
+	{ SPR_WIRE_Y_SHORT,       8,  0,  1, 16,  1, ELRAIL_ELEVATION }, //!11: Wire in Y direction, pylon on both ends
+
+	/* "up" tiles */
+		/* Wires */
+	{ SPR_WIRE_Y_SE_UP,       8,  0,  8, 16,  1, ELRAIL_ELEVRAISE }, //!12: Wire in Y pitch up, pylon on the SE end only
+	{ SPR_WIRE_Y_NW_UP,       8,  0,  8, 16,  1, ELRAIL_ELEVRAISE }, //!13: Wire in Y pitch up, pylon on the NW end
+	{ SPR_WIRE_Y_SHORT_UP,    8,  0,  8, 16,  1, ELRAIL_ELEVRAISE }, //!14: Wire in Y pitch up, pylon on both ends
+
+	/* "down" tiles */
+		/* Wires */
+	{ SPR_WIRE_Y_SE_DOWN,     8,  0,  8, 16,  1, ELRAIL_ELEV_CORR }, //!15: Wire in Y pitch down, pylon on the SE end
+	{ SPR_WIRE_Y_NW_DOWN,     8,  0,  8, 16,  1, ELRAIL_ELEV_CORR }, //!16: Wire in Y pitch down, pylon on the NW end
+	{ SPR_WIRE_Y_SHORT_DOWN,  8,  0,  8, 16,  1, ELRAIL_ELEV_CORR }, //!17: Wire in Y pitch down, pylon on both ends
+
+/* NS Direction */
+	{ SPR_WIRE_NS_SHORT,      8,  0,  8,  8,  1, ELRAIL_ELEVATION }, //!18: LEFT  trackbit wire, pylon on both ends
+	{ SPR_WIRE_NS_SHORT,      0,  8,  8,  8,  1, ELRAIL_ELEVATION }, //!19: RIGHT trackbit wire, pylon on both ends
+
+	{ SPR_WIRE_NS_N,          8,  0,  8,  8,  1, ELRAIL_ELEVATION }, //!20: LEFT  trackbit wire, pylon on N end
+	{ SPR_WIRE_NS_N,          0,  8,  8,  8,  1, ELRAIL_ELEVATION }, //!21: RIGHT trackbit wire, pylon on N end
+
+	{ SPR_WIRE_NS_S,          8,  0,  8,  8,  1, ELRAIL_ELEVATION }, //!22: LEFT  trackbit wire, pylon on S end
+	{ SPR_WIRE_NS_S,          0,  8,  8,  8,  1, ELRAIL_ELEVATION }, //!23: RIGHT trackbit wire, pylon on S end
+
+/* EW Direction */
+	{ SPR_WIRE_EW_SHORT,      8,  0,  8,  8,  1, ELRAIL_ELEVATION }, //!24: UPPER trackbit wire, pylon on both ends
+	{ SPR_WIRE_EW_SHORT,     16,  8,  8,  8,  1, ELRAIL_ELEVATION }, //!25: LOWER trackbit wire, pylon on both ends
+
+	{ SPR_WIRE_EW_W,          8,  0,  8,  8,  1, ELRAIL_ELEVATION }, //!28: UPPER trackbit wire, pylon on both ends
+	{ SPR_WIRE_EW_W,         16,  8,  8,  8,  1, ELRAIL_ELEVATION }, //!29: LOWER trackbit wire, pylon on both ends
+
+	{ SPR_WIRE_EW_E,          8,  0,  8,  8,  1, ELRAIL_ELEVATION }, //!32: UPPER trackbit wire, pylon on both ends
+	{ SPR_WIRE_EW_E,         16,  8,  8,  8,  1, ELRAIL_ELEVATION }, //!33: LOWER trackbit wire, pylon on both ends
+
+/* Depots */
+	{ SPR_WIRE_DEPOT_SW,      0,  8,  8,  1,  1, ELRAIL_ELEVATION }, //!36: Wire for SW depot exit
+	{ SPR_WIRE_DEPOT_NW,      8,  0,  1,  8,  1, ELRAIL_ELEVATION }, //!37: Wire for NW depot exit
+	{ SPR_WIRE_DEPOT_NE,      0,  8,  8,  1,  1, ELRAIL_ELEVATION }, //!38: Wire for NE depot exit
+	{ SPR_WIRE_DEPOT_SE,      8,  0,  1,  8,  1, ELRAIL_ELEVATION }, //!39: Wire for SE depot exit
+};
+
+/** Refers to a certain element of the catenary.
+  * Identifiers for Wires:
+  * <ol><li>Direction of the wire</li>
+  * <li>Slope of the tile for diagonals, placement inside the track for horiz/vertical pieces</li>
+  * <li>Place where a pylon shoule be</li></ol>
+  * Identifiers for Pylons:
+  * <ol><li>Direction of the wire</li>
+  * <li>Slope of the tile</li>
+  * <li>Position of the Pylon relative to the track</li>
+  * <li>Position of the Pylon inside the tile</li></ol>
+  */
+typedef enum {
+	WIRE_X_FLAT_SW,
+	WIRE_X_FLAT_NE,
+	WIRE_X_FLAT_BOTH,
+
+	WIRE_X_UP_SW,
+	WIRE_X_UP_NE,
+	WIRE_X_UP_BOTH,
+
+	WIRE_X_DOWN_SW,
+	WIRE_X_DOWN_NE,
+	WIRE_X_DOWN_BOTH,
+
+	WIRE_Y_FLAT_SE,
+	WIRE_Y_FLAT_NW,
+	WIRE_Y_FLAT_BOTH,
+
+	WIRE_Y_UP_SE,
+	WIRE_Y_UP_NW,
+	WIRE_Y_UP_BOTH,
+
+	WIRE_Y_DOWN_SE,
+	WIRE_Y_DOWN_NW,
+	WIRE_Y_DOWN_BOTH,
+
+	WIRE_NS_W_BOTH,
+	WIRE_NS_E_BOTH,
+
+	WIRE_NS_W_N,
+	WIRE_NS_E_N,
+
+	WIRE_NS_W_S,
+	WIRE_NS_E_S,
+
+	WIRE_EW_N_BOTH,
+	WIRE_EW_S_BOTH,
+
+	WIRE_EW_N_W,
+	WIRE_EW_S_W,
+
+	WIRE_EW_N_E,
+	WIRE_EW_S_E,
+
+	WIRE_DEPOT_SW,
+	WIRE_DEPOT_NW,
+	WIRE_DEPOT_NE,
+	WIRE_DEPOT_SE,
+
+	INVALID_CATENARY = 0xFF
+} CatenarySprite;
+
+/* This array stores which track bits can meet at a tile edge */
+static const Track PPPtracks[DIAGDIR_END][TRACKS_AT_PCP] = {
+	{TRACK_X, TRACK_X, TRACK_UPPER, TRACK_LOWER, TRACK_LEFT, TRACK_RIGHT},
+	{TRACK_Y, TRACK_Y, TRACK_UPPER, TRACK_LOWER, TRACK_LEFT, TRACK_RIGHT},
+	{TRACK_X, TRACK_X, TRACK_UPPER, TRACK_LOWER, TRACK_LEFT, TRACK_RIGHT},
+	{TRACK_Y, TRACK_Y, TRACK_UPPER, TRACK_LOWER, TRACK_LEFT, TRACK_RIGHT},
+};
+
+/* takes each of the 8 track bits from the array above and
+   assigns it to the home tile or neighbour tile */
+static const TileSource trackorigin[DIAGDIR_END][TRACKS_AT_PCP] = {
+	{TS_HOME, TS_NEIGHBOUR, TS_HOME     , TS_NEIGHBOUR, TS_NEIGHBOUR, TS_HOME     },
+	{TS_HOME, TS_NEIGHBOUR, TS_NEIGHBOUR, TS_HOME     , TS_NEIGHBOUR, TS_HOME     },
+	{TS_HOME, TS_NEIGHBOUR, TS_NEIGHBOUR, TS_HOME     , TS_HOME     , TS_NEIGHBOUR},
+	{TS_HOME, TS_NEIGHBOUR, TS_HOME     , TS_NEIGHBOUR, TS_HOME     , TS_NEIGHBOUR},
+};
+
+/* Several PPPs maybe exist, here they are sorted in order of preference. */
+static const Direction PPPorder[DIAGDIR_END][TLG_END][DIR_END] = {    /*  X  -  Y  */
+	{   /* PCP 0 */
+		{DIR_NE, DIR_NW, DIR_SE, DIR_SW, DIR_N, DIR_E, DIR_S, DIR_W}, /* evn - evn */
+		{DIR_NE, DIR_SE, DIR_SW, DIR_NW, DIR_S, DIR_W, DIR_N, DIR_E}, /* evn - odd */
+		{DIR_SW, DIR_NW, DIR_NE, DIR_SE, DIR_S, DIR_W, DIR_N, DIR_E}, /* odd - evn */
+		{DIR_SW, DIR_SE, DIR_NE, DIR_NW, DIR_N, DIR_E, DIR_S, DIR_W}, /* odd - odd */
+	}, {/* PCP 1 */
+		{DIR_NE, DIR_NW, DIR_SE, DIR_SW, DIR_S, DIR_E, DIR_N, DIR_W}, /* evn - evn */
+		{DIR_NE, DIR_SE, DIR_SW, DIR_NW, DIR_N, DIR_W, DIR_S, DIR_E}, /* evn - odd */
+		{DIR_SW, DIR_NW, DIR_NE, DIR_SE, DIR_N, DIR_W, DIR_S, DIR_E}, /* odd - evn */
+		{DIR_SW, DIR_SE, DIR_NE, DIR_NW, DIR_S, DIR_E, DIR_N, DIR_W}, /* odd - odd */
+	}, {/* PCP 2 */
+		{DIR_NE, DIR_NW, DIR_SE, DIR_SW, DIR_S, DIR_W, DIR_N, DIR_E}, /* evn - evn */
+		{DIR_NE, DIR_SE, DIR_SW, DIR_NW, DIR_N, DIR_E, DIR_S, DIR_W}, /* evn - odd */
+		{DIR_SW, DIR_NW, DIR_NE, DIR_SE, DIR_N, DIR_E, DIR_S, DIR_W}, /* odd - evn */
+		{DIR_SW, DIR_SE, DIR_NE, DIR_NW, DIR_S, DIR_W, DIR_N, DIR_E}, /* odd - odd */
+	}, {/* PCP 3 */
+		{DIR_NE, DIR_NW, DIR_SE, DIR_SW, DIR_N, DIR_W, DIR_S, DIR_E}, /* evn - evn */
+		{DIR_NE, DIR_SE, DIR_SW, DIR_NW, DIR_S, DIR_E, DIR_N, DIR_W}, /* evn - odd */
+		{DIR_SW, DIR_NW, DIR_NE, DIR_SE, DIR_S, DIR_E, DIR_N, DIR_W}, /* odd - evn */
+		{DIR_SW, DIR_SE, DIR_NE, DIR_NW, DIR_N, DIR_W, DIR_S, DIR_E}, /* odd - odd */
+	}
+};
+/* Geometric placement of the PCP relative to the tile origin */
+static const char x_pcp_offsets[DIAGDIR_END] = {0,  8, 15, 8};
+static const char y_pcp_offsets[DIAGDIR_END] = {8, 15,  8, 0};
+/* Geometric placement of the PPP relative to the PCP*/
+static const char x_ppp_offsets[DIR_END] = {-3, -4, -3,  0, +3, +4, +3,  0};
+static const char y_ppp_offsets[DIR_END] = {-3,  0, +3, +4, +3,  0, -3, -4};
+/* The type of pylon to draw at each PPP */
+static const SpriteID pylons_normal[] = {
+	SPR_PYLON_EW_N,
+	SPR_PYLON_Y_NE,
+	SPR_PYLON_NS_E,
+	SPR_PYLON_X_SE,
+	SPR_PYLON_EW_S,
+	SPR_PYLON_Y_SW,
+	SPR_PYLON_NS_W,
+	SPR_PYLON_X_NW
+};
+
+static const SpriteID pylons_bridge[] = {
+	SPR_PYLON_X_NW,
+	SPR_PYLON_X_SE,
+	SPR_PYLON_Y_NE,
+	SPR_PYLON_Y_SW
+};
+
+/* Maps a track bit onto two PCP positions */
+static const byte PCPpositions[TRACK_END][2] = {
+	{0, 2}, /* X */
+	{1, 3}, /* Y */
+	{3, 0}, /* UPPER */
+	{1, 2}, /* LOWER */
+	{2, 3}, /* LEFT */
+	{0, 1}, /* RIGHT */
+};
+
+/* Selects a Wire (with white and grey ends) depending on whether:
+   a) none (should never happen)
+   b) the first
+   c) the second
+   d) both
+   PCP exists.*/
+static const CatenarySprite Wires[5][TRACK_END][4] = {
+	{ /* Tileh == 0 */
+		{INVALID_CATENARY, WIRE_X_FLAT_NE, WIRE_X_FLAT_SW, WIRE_X_FLAT_BOTH},
+		{INVALID_CATENARY, WIRE_Y_FLAT_SE, WIRE_Y_FLAT_NW, WIRE_Y_FLAT_BOTH},
+		{INVALID_CATENARY, WIRE_EW_N_W, WIRE_EW_N_E, WIRE_EW_N_BOTH},
+		{INVALID_CATENARY, WIRE_EW_S_E, WIRE_EW_S_W, WIRE_EW_S_BOTH},
+		{INVALID_CATENARY, WIRE_NS_W_S, WIRE_NS_W_N, WIRE_NS_W_BOTH},
+		{INVALID_CATENARY, WIRE_NS_E_N, WIRE_NS_E_S, WIRE_NS_E_BOTH},
+	}, { /* Tileh == 3 */
+		{INVALID_CATENARY, WIRE_X_UP_NE, WIRE_X_UP_SW, WIRE_X_UP_BOTH},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+	}, { /* Tileh == 6 */
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, WIRE_Y_UP_SE, WIRE_Y_UP_NW, WIRE_Y_UP_BOTH},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+	}, { /* Tileh == 9 */
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, WIRE_Y_DOWN_SE, WIRE_Y_DOWN_NW, WIRE_Y_DOWN_BOTH},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+	}, { /* Tileh == 12 */
+		{INVALID_CATENARY, WIRE_X_DOWN_NE, WIRE_X_DOWN_SW, WIRE_X_DOWN_BOTH},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+		{INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY, INVALID_CATENARY},
+	}
+};
+
+#endif /* ELRAIL_DATA_H */
+

table/engines.h

@@ -27,11 +27,13 @@
 
 // Rail types
 // R = Conventional railway
+// E = Electrified railway
 // M = Monorail
 // L = MagLev
 #define R 0
-#define M 1
+#define E 1
-#define L 2
+#define M 2
+#define L 3
 // Climates
 // T = Temperate
 // A = Arctic
@@ -65,10 +67,10 @@ const EngineInfo orig_engine_info[] = {
 	MK( 20454,  20,  22,  30, R,   A|S  ), /*  20 Turner Turbo (Diesel) */
 	MK( 16071,  20,  22,  30, R,   A|S  ), /*  21 MJS 1000 (Diesel) */
 	MK( 20820,  20,  20,  25, R, T      ), /*  22 SH '125' (Diesel) */
-	MK( 16437,  20,  23,  30, R, T      ), /*  23 SH '30' (Electric) */
+	MK( 16437,  20,  23,  30, E, T      ), /*  23 SH '30' (Electric) */
-	MK( 19359,  20,  23,  80, R, T      ), /*  24 SH '40' (Electric) */
+	MK( 19359,  20,  23,  80, E, T      ), /*  24 SH '40' (Electric) */
-	MK( 23376,  20,  25,  30, R, T      ), /*  25 'T.I.M.' (Electric) */
+	MK( 23376,  20,  25,  30, E, T      ), /*  25 'T.I.M.' (Electric) */
-	MK( 26298,  20,  25,  50, R, T      ), /*  26 'AsiaStar' (Electric) */
+	MK( 26298,  20,  25,  50, E, T      ), /*  26 'AsiaStar' (Electric) */
 	MW(  1827,  20,  20,  50, R, T|A|S|Y), /*  27 Passenger Carriage */
 	MW(  1827,  20,  20,  50, R, T|A|S|Y), /*  28 Mail Van */
 	MW(  1827,  20,  20,  50, R, T|A    ), /*  29 Coal Truck */
@@ -306,6 +308,7 @@ const EngineInfo orig_engine_info[] = {
 #undef L
 #undef M
 #undef R
+#undef E
 
 /** Writes the properties of a rail vehicle into the RailVehicleInfo struct.
  * @see RailVehicleInfo

table/landscape_const.h

@@ -42,13 +42,6 @@ static const LandscapePredefVar _landscape_predef_var[4] = {
 			24, 255, 90, 255, 18, 28, 40, 255, 255, 255, 32, 30,
 		},
 
-		/* normal railveh by cargo */
-		{
-			{27, 29, 28, 30, 31, 32, 33, 34, 35, 36, 37, 38},
-			{57, 59, 58, 60, 61, 62, 63, 64, 65, 66, 67, 68},
-			{89, 91, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100}
-		},
-
 		/* normal road veh by cargo start & count */
 		{116, 123, 126, 132, 135, 138, 141, 144, 147, 150, 153, 156},
 		{7, 3, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3}
@@ -95,14 +88,6 @@ static const LandscapePredefVar _landscape_predef_var[4] = {
 			24, 255, 90, 255, 18, 28, 40, 255, 255, 60, 40, 30
 		},
 
-		/* hilly railveh by cargo */
-		{
-			{27, 29, 28, 30, 31, 32, 33, 34, 35, 39, 37, 38},
-			{57, 59, 58, 60, 61, 62, 63, 64, 65, 69, 67, 68},
-			{89, 91, 90, 92, 93, 94, 95, 96, 97, 101, 99, 100}
-		},
-
-
 		/* hilly road veh by cargo start & count */
 		{116, 123, 126, 132, 135, 138, 141, 144, 147, 159, 153, 156},
 		{7, 3, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3},
@@ -150,13 +135,6 @@ static const LandscapePredefVar _landscape_predef_var[4] = {
 			24, 20, 90, 255, 15, 28, 40, 255, 255, 80, 255, 30
 		},
 
-		/* desert railveh by cargo */
-		{
-			{27, 43, 28, 30, 42, 32, 33, 34, 40, 41, 37, 38},
-			{57, 73, 58, 60, 72, 62, 63, 64, 70, 71, 67, 68},
-			{89, 105, 90, 92, 104, 94, 95, 96, 102, 103, 99, 100}
-		},
-
 		/* desert road veh by cargo start & count */
 		{116, 171, 126, 132, 168, 138, 141, 144, 162, 165, 153, 156},
 		{7, 3, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3}
@@ -203,13 +181,6 @@ static const LandscapePredefVar _landscape_predef_var[4] = {
 			24, 255, 90, 255, 30, 40, 60, 75, 25, 80, 255, 50
 		},
 
-		/* candy railveh by cargo */
-		{
-			{27, 44, 28, 50, 51, 49, 46, 48, 45, 47, 53, 52},
-			{57, 74, 58, 80, 81, 79, 76, 78, 75, 77, 83, 82},
-			{89, 106, 90, 112, 113, 111, 108, 110, 107, 109, 115, 114}
-		},
-
 		/* candy road veh by cargo start & count */
 		{116, 174, 126, 186, 192, 189, 183, 177, 180, 201, 198, 195},
 		{7, 3, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3}

table/sprites.h

@@ -51,7 +51,8 @@ enum Sprites {
 	SPR_CANALS_BASE   = 5382,
 	SPR_SLOPES_BASE   = SPR_CANALS_BASE + 70,
 	SPR_AUTORAIL_BASE = SPR_SLOPES_BASE + 78,
-	SPR_2CCMAP_BASE   = SPR_AUTORAIL_BASE + 55,
+	SPR_ELRAIL_BASE   = SPR_AUTORAIL_BASE + 55,
+	SPR_2CCMAP_BASE   = SPR_ELRAIL_BASE + 53,
 	SPR_OPENTTD_BASE  = SPR_2CCMAP_BASE + 256,
 
 	SPR_BLOT = SPR_OPENTTD_BASE + 29, // colored circle (mainly used as vehicle profit marker and for sever compatibility)
@@ -206,6 +207,54 @@ enum Sprites {
 	OFFSET_TILEH_13             = 19,
 	OFFSET_TILEH_14             = 16,
 
+	/* Elrail stuff */
+	/* Wires. First identifier is the direction of the track, second is the required placement of the pylon.
+	   "short" denotes a wire that requires a pylon on each end. Third identifier is the direction of the slope
+	   (in positive coordinate direction) */
+	SPR_WIRE_X_SHORT = SPR_ELRAIL_BASE + 3,
+	SPR_WIRE_Y_SHORT = SPR_ELRAIL_BASE + 4,
+	SPR_WIRE_EW_SHORT = SPR_ELRAIL_BASE + 5,
+	SPR_WIRE_NS_SHORT = SPR_ELRAIL_BASE + 6,
+	SPR_WIRE_X_SHORT_DOWN = SPR_ELRAIL_BASE + 7,
+	SPR_WIRE_Y_SHORT_UP = SPR_ELRAIL_BASE + 8,
+	SPR_WIRE_X_SHORT_UP = SPR_ELRAIL_BASE + 9,
+	SPR_WIRE_Y_SHORT_DOWN = SPR_ELRAIL_BASE + 10,
+
+	SPR_WIRE_X_SW = SPR_ELRAIL_BASE + 11,
+	SPR_WIRE_Y_SE = SPR_ELRAIL_BASE + 12,
+	SPR_WIRE_EW_E = SPR_ELRAIL_BASE + 13,
+	SPR_WIRE_NS_S = SPR_ELRAIL_BASE + 14,
+	SPR_WIRE_X_SW_DOWN = SPR_ELRAIL_BASE + 15,
+	SPR_WIRE_Y_SE_UP = SPR_ELRAIL_BASE + 16,
+	SPR_WIRE_X_SW_UP = SPR_ELRAIL_BASE + 17,
+	SPR_WIRE_Y_SE_DOWN = SPR_ELRAIL_BASE + 18,
+
+	SPR_WIRE_X_NE = SPR_ELRAIL_BASE + 19,
+	SPR_WIRE_Y_NW = SPR_ELRAIL_BASE + 20,
+	SPR_WIRE_EW_W = SPR_ELRAIL_BASE + 21,
+	SPR_WIRE_NS_N = SPR_ELRAIL_BASE + 22,
+	SPR_WIRE_X_NE_DOWN = SPR_ELRAIL_BASE + 23,
+	SPR_WIRE_Y_NW_UP = SPR_ELRAIL_BASE + 24,
+	SPR_WIRE_X_NE_UP = SPR_ELRAIL_BASE + 25,
+	SPR_WIRE_Y_NW_DOWN = SPR_ELRAIL_BASE + 26,
+
+	/* Tunnel entries */
+	SPR_WIRE_DEPOT_SW = SPR_ELRAIL_BASE + 27,
+	SPR_WIRE_DEPOT_NW = SPR_ELRAIL_BASE + 28,
+	SPR_WIRE_DEPOT_NE = SPR_ELRAIL_BASE + 29,
+	SPR_WIRE_DEPOT_SE = SPR_ELRAIL_BASE + 30,
+
+
+	/* Pylons, first identifier is the direction of the track, second the placement relative to the track */
+	SPR_PYLON_Y_NE = SPR_ELRAIL_BASE + 31,
+	SPR_PYLON_Y_SW = SPR_ELRAIL_BASE + 32,
+	SPR_PYLON_X_NW = SPR_ELRAIL_BASE + 33,
+	SPR_PYLON_X_SE = SPR_ELRAIL_BASE + 34,
+	SPR_PYLON_EW_N = SPR_ELRAIL_BASE + 35,
+	SPR_PYLON_EW_S = SPR_ELRAIL_BASE + 36,
+	SPR_PYLON_NS_W = SPR_ELRAIL_BASE + 37,
+	SPR_PYLON_NS_E = SPR_ELRAIL_BASE + 38,
+
 	/* sprites for airports and airfields*/
 	/* Small airports are AIRFIELD, everything else is AIRPORT */
 	SPR_HELIPORT                    = 2633,
@@ -955,6 +1004,13 @@ enum Sprites {
 	SPR_BUBBLE_ABSORB_3 = 4761,
 	SPR_BUBBLE_ABSORB_4 = 4762,
 
+	/* Electrified rail build menu */
+	SPR_BUILD_NS_ELRAIL = SPR_ELRAIL_BASE + 39,
+	SPR_BUILD_X_ELRAIL  = SPR_ELRAIL_BASE + 40,
+	SPR_BUILD_EW_ELRAIL = SPR_ELRAIL_BASE + 41,
+	SPR_BUILD_Y_ELRAIL  = SPR_ELRAIL_BASE + 42,
+	SPR_BUILD_TUNNEL_ELRAIL = SPR_ELRAIL_BASE + 47,
+
 	/* road_gui.c */
 	SPR_IMG_ROAD_NW       = 1309,
 	SPR_IMG_ROAD_NE       = 1310,
@@ -1034,9 +1090,15 @@ typedef enum CursorSprites {
 	SPR_CURSOR_EW_MAGLEV      = 1273,
 	SPR_CURSOR_NWSE_MAGLEV    = 1274,
 
+	SPR_CURSOR_NS_ELRAIL      = SPR_ELRAIL_BASE + 43,
+	SPR_CURSOR_SWNE_ELRAIL    = SPR_ELRAIL_BASE + 44,
+	SPR_CURSOR_EW_ELRAIL      = SPR_ELRAIL_BASE + 45,
+	SPR_CURSOR_NWSE_ELRAIL    = SPR_ELRAIL_BASE + 46,
+
 	SPR_CURSOR_RAIL_STATION   = 1300,
 
 	SPR_CURSOR_TUNNEL_RAIL    = 2434,
+	SPR_CURSOR_TUNNEL_ELRAIL  = SPR_ELRAIL_BASE + 48,
 	SPR_CURSOR_TUNNEL_MONO    = 2435,
 	SPR_CURSOR_TUNNEL_MAGLEV  = 2436,
 

train_cmd.c

@@ -71,6 +71,46 @@ static void TrainCargoChanged(Vehicle* v)
 	v->u.rail.cached_weight = weight;
 }
 
+/**
+ * Recalculates the cached total power of a train. Should be called when the consist is changed
+ * @param v First vehicle of the consist.
+ */
+void TrainPowerChanged(Vehicle* v)
+{
+	const RailVehicleInfo *rvi_v = RailVehInfo(v->engine_type);
+	Vehicle* u;
+	uint32 power = 0;
+
+	for (u = v; u != NULL; u = u->next) {
+		const RailVehicleInfo *rvi_u;
+		bool engine_has_power = true;
+		bool wagon_has_power = true;
+
+		/* Power is not added for articulated parts */
+		if (IsArticulatedPart(u)) continue;
+
+		if (IsBridgeTile(u->tile) && IsBridgeMiddle(u->tile) && DiagDirToAxis(DirToDiagDir(u->direction)) == GetBridgeAxis(u->tile)) {
+			if (!HasPowerOnRail(u->u.rail.railtype, GetRailTypeOnBridge(u->tile))) engine_has_power = false;
+			if (!HasPowerOnRail(v->u.rail.railtype, GetRailTypeOnBridge(u->tile))) wagon_has_power = false;
+		} else {
+			if (!HasPowerOnRail(u->u.rail.railtype, GetRailType(u->tile))) engine_has_power = false;
+			if (!HasPowerOnRail(v->u.rail.railtype, GetRailType(u->tile))) wagon_has_power = false;
+		}
+
+		rvi_u = RailVehInfo(u->engine_type);
+
+		if (engine_has_power) power += rvi_u->power;
+		if (HASBIT(u->u.rail.flags, VRF_POWEREDWAGON) && (wagon_has_power)) {
+			power += rvi_v->pow_wag_power;
+		}
+	}
+
+	if (v->u.rail.cached_power != power) {
+		v->u.rail.cached_power = power;
+		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
+	}
+}
+
 /**
  * Recalculates the cached stuff of a train. Should be called each time a vehicle is added
  * to/removed from the chain, and when the game is loaded.
@@ -82,7 +122,6 @@ void TrainConsistChanged(Vehicle* v)
 	const RailVehicleInfo *rvi_v;
 	Vehicle *u;
 	uint16 max_speed = 0xFFFF;
-	uint32 power = 0;
 	EngineID first_engine;
 
 	assert(v->type == VEH_Train);
@@ -92,6 +131,7 @@ void TrainConsistChanged(Vehicle* v)
 	rvi_v = RailVehInfo(v->engine_type);
 	first_engine = IsFrontEngine(v) ? v->engine_type : INVALID_ENGINE;
 	v->u.rail.cached_total_length = 0;
+	v->u.rail.compatible_railtypes = 0;
 
 	for (u = v; u != NULL; u = u->next) {
 		const RailVehicleInfo *rvi_u = RailVehInfo(u->engine_type);
@@ -102,6 +142,7 @@ void TrainConsistChanged(Vehicle* v)
 
 		// update the 'first engine'
 		u->u.rail.first_engine = (v == u) ? INVALID_ENGINE : first_engine;
+		u->u.rail.railtype = GetEngine(u->engine_type)->railtype;
 
 		if (rvi_u->visual_effect != 0) {
 			u->u.rail.cached_vis_effect = rvi_u->visual_effect;
@@ -119,9 +160,6 @@ void TrainConsistChanged(Vehicle* v)
 		}
 
 		if (!IsArticulatedPart(u)) {
-			// power is the sum of the powers of all engines and powered wagons in the consist
-			power += rvi_u->power;
-
 			// check if its a powered wagon
 			CLRBIT(u->u.rail.flags, VRF_POWEREDWAGON);
 			if ((rvi_v->pow_wag_power != 0) && (rvi_u->flags & RVI_WAGON) && UsesWagonOverride(u)) {
@@ -135,10 +173,15 @@ void TrainConsistChanged(Vehicle* v)
 				if (u->u.rail.cached_vis_effect < 0x40) {
 					/* wagon is powered */
 					SETBIT(u->u.rail.flags, VRF_POWEREDWAGON); // cache 'powered' status
-					power += rvi_v->pow_wag_power;
 				}
 			}
 
+			/* Do not count powered wagons for the compatible railtypes, as wagons always
+			   have railtype normal */
+			if (rvi_u->power > 0) {
+				v->u.rail.compatible_railtypes |= GetRailTypeInfo(u->u.rail.railtype)->powered_railtypes;
+			}
+
 			// max speed is the minimum of the speed limits of all vehicles in the consist
 			if (!(rvi_u->flags & RVI_WAGON) || _patches.wagon_speed_limits)
 				if (rvi_u->max_speed != 0 && !UsesWagonOverride(u))
@@ -159,7 +202,8 @@ void TrainConsistChanged(Vehicle* v)
 
 	// store consist weight/max speed in cache
 	v->u.rail.cached_max_speed = max_speed;
-	v->u.rail.cached_power = power;
+
+	TrainPowerChanged(v);
 
 	// recalculate cached weights too (we do this *after* the rest, so it is known which wagons are powered and need extra weight added)
 	TrainCargoChanged(v);
@@ -333,6 +377,7 @@ static int GetTrainAcceleration(Vehicle *v, bool mode)
 	if (speed > 0) {
 		switch (v->u.rail.railtype) {
 			case RAILTYPE_RAIL:
+			case RAILTYPE_ELECTRIC:
 			case RAILTYPE_MONO:
 				force = power / speed; //[N]
 				force *= 22;
@@ -1468,6 +1513,9 @@ static void ReverseTrainSwapVeh(Vehicle *v, int l, int r)
 
 		VehicleEnterTile(a, a->tile, a->x_pos, a->y_pos);
 	}
+
+	/* Update train's power incase tiles were different rail type */
+	TrainPowerChanged(v);
 }
 
 /* Check if the vehicle is a train and is on the tile we are testing */
@@ -1786,7 +1834,7 @@ static TrainFindDepotData FindClosestTrainDepot(Vehicle *v)
 		Trackdir trackdir_rev = ReverseTrackdir(GetVehicleTrackdir(last));
 
 		assert (trackdir != INVALID_TRACKDIR);
-		ftd = NPFRouteToDepotBreadthFirstTwoWay(v->tile, trackdir, last->tile, trackdir_rev, TRANSPORT_RAIL, v->owner, v->u.rail.railtype, NPF_INFINITE_PENALTY);
+		ftd = NPFRouteToDepotBreadthFirstTwoWay(v->tile, trackdir, last->tile, trackdir_rev, TRANSPORT_RAIL, v->owner, v->u.rail.compatible_railtypes, NPF_INFINITE_PENALTY);
 		if (ftd.best_bird_dist == 0) {
 			/* Found target */
 			tfdd.tile = ftd.node.tile;
@@ -1805,7 +1853,7 @@ static TrainFindDepotData FindClosestTrainDepot(Vehicle *v)
 		if (!(v->direction & 1) && v->u.rail.track != _state_dir_table[i]) {
 			i = ChangeDiagDir(i, DIAGDIRDIFF_90LEFT);
 		}
-		NewTrainPathfind(tile, 0, i, (NTPEnumProc*)NtpCallbFindDepot, &tfdd);
+		NewTrainPathfind(tile, 0, v->u.rail.compatible_railtypes, i, (NTPEnumProc*)NtpCallbFindDepot, &tfdd);
 		if (tfdd.best_length == (uint)-1){
 			tfdd.reverse = true;
 			// search in backwards direction
@@ -1813,7 +1861,7 @@ static TrainFindDepotData FindClosestTrainDepot(Vehicle *v)
 			if (!(v->direction & 1) && v->u.rail.track != _state_dir_table[i]) {
 				i = ChangeDiagDir(i, DIAGDIRDIFF_90LEFT);
 			}
-			NewTrainPathfind(tile, 0, i, (NTPEnumProc*)NtpCallbFindDepot, &tfdd);
+			NewTrainPathfind(tile, 0, v->u.rail.compatible_railtypes, i, (NTPEnumProc*)NtpCallbFindDepot, &tfdd);
 		}
 	}
 
@@ -1899,7 +1947,7 @@ static void HandleLocomotiveSmokeCloud(const Vehicle* v)
 		// no smoke?
 		if ((RailVehInfo(engtype)->flags & RVI_WAGON && effect_type == 0) ||
 				disable_effect ||
-				GetEngine(engtype)->railtype > RAILTYPE_RAIL ||
+				GetEngine(engtype)->railtype > RAILTYPE_ELECTRIC ||
 				v->vehstatus & VS_HIDDEN ||
 				v->u.rail.track & 0xC0) {
 			continue;
@@ -1961,6 +2009,7 @@ static void TrainPlayLeaveStationSound(const Vehicle* v)
 
 	switch (GetEngine(engtype)->railtype) {
 		case RAILTYPE_RAIL:
+		case RAILTYPE_ELECTRIC:
 			SndPlayVehicleFx(sfx[RailVehInfo(engtype)->engclass], v);
 			break;
 
@@ -2112,7 +2161,7 @@ static byte ChooseTrainTrack(Vehicle* v, TileIndex tile, DiagDirection enterdir,
 		trackdir = GetVehicleTrackdir(v);
 		assert(trackdir != 0xff);
 
-		ftd = NPFRouteToStationOrTile(tile - TileOffsByDir(enterdir), trackdir, &fstd, TRANSPORT_RAIL, v->owner, v->u.rail.railtype);
+		ftd = NPFRouteToStationOrTile(tile - TileOffsByDir(enterdir), trackdir, &fstd, TRANSPORT_RAIL, v->owner, v->u.rail.compatible_railtypes);
 
 		if (ftd.best_trackdir == 0xff) {
 			/* We are already at our target. Just do something */
@@ -2136,7 +2185,7 @@ static byte ChooseTrainTrack(Vehicle* v, TileIndex tile, DiagDirection enterdir,
 		fd.best_track = 0xFF;
 
 		NewTrainPathfind(tile - TileOffsByDir(enterdir), v->dest_tile,
-			enterdir, (NTPEnumProc*)NtpCallbFindStation, &fd);
+			v->u.rail.compatible_railtypes, enterdir, (NTPEnumProc*)NtpCallbFindStation, &fd);
 
 		if (fd.best_track == 0xff) {
 			// blaha
@@ -2190,7 +2239,7 @@ static bool CheckReverseTrain(Vehicle *v)
 		assert(trackdir != 0xff);
 		assert(trackdir_rev != 0xff);
 
-		ftd = NPFRouteToStationOrTileTwoWay(v->tile, trackdir, last->tile, trackdir_rev, &fstd, TRANSPORT_RAIL, v->owner, v->u.rail.railtype);
+		ftd = NPFRouteToStationOrTileTwoWay(v->tile, trackdir, last->tile, trackdir_rev, &fstd, TRANSPORT_RAIL, v->owner, v->u.rail.compatible_railtypes);
 		if (ftd.best_bird_dist != 0) {
 			/* We didn't find anything, just keep on going straight ahead */
 			reverse_best = false;
@@ -2206,7 +2255,7 @@ static bool CheckReverseTrain(Vehicle *v)
 			fd.best_bird_dist = (uint)-1;
 			fd.best_track_dist = (uint)-1;
 
-			NewTrainPathfind(v->tile, v->dest_tile, reverse ^ i, (NTPEnumProc*)NtpCallbFindStation, &fd);
+			NewTrainPathfind(v->tile, v->dest_tile, v->u.rail.compatible_railtypes, reverse ^ i, (NTPEnumProc*)NtpCallbFindStation, &fd);
 
 			if (best_track != -1) {
 				if (best_bird_dist != 0) {
@@ -2575,7 +2624,7 @@ static bool CheckCompatibleRail(const Vehicle *v, TileIndex tile)
 	return
 		IsTileOwner(tile, v->owner) && (
 			!IsFrontEngine(v) ||
-			IsCompatibleRail(v->u.rail.railtype, GetRailType(tile))
+			HASBIT(v->u.rail.compatible_railtypes, GetRailType(tile))
 		);
 }
 
@@ -2585,9 +2634,10 @@ typedef struct {
 	byte z_down; // fraction to remove when moving down
 } RailtypeSlowdownParams;
 
-static const RailtypeSlowdownParams _railtype_slowdown[3] = {
+static const RailtypeSlowdownParams _railtype_slowdown[] = {
 	// normal accel
 	{256/4, 256/2, 256/4, 2}, // normal
+	{256/4, 256/2, 256/4, 2}, // electrified
 	{256/4, 256/2, 256/4, 2}, // monorail
 	{0,     256/2, 256/4, 2}, // maglev
 };
@@ -2873,6 +2923,11 @@ static void TrainController(Vehicle *v)
 
 				if (!(r&0x4)) {
 					v->tile = gp.new_tile;
+
+					if (GetTileRailType(gp.new_tile, chosen_track) != GetTileRailType(gp.old_tile, v->u.rail.track)) {
+						TrainPowerChanged(GetFirstVehicleInChain(v));
+					}
+
 					v->u.rail.track = chosen_track;
 					assert(v->u.rail.track);
 				}

train_gui.c

@@ -177,7 +177,7 @@ static void engine_drawing_loop(int *x, int *y, int *pos, int *sel,
 		const Engine *e = GetEngine(i);
 		const RailVehicleInfo *rvi = RailVehInfo(i);
 
-		if (!IsCompatibleRail(e->railtype, railtype) || !(rvi->flags & RVI_WAGON) != is_engine ||
+		if (!HasPowerOnRail(e->railtype, railtype) || !(rvi->flags & RVI_WAGON) != is_engine ||
 				!HASBIT(e->player_avail, _local_player))
 			continue;
 
@@ -208,7 +208,7 @@ static void NewRailVehicleWndProc(Window *w, WindowEvent *e)
 
 			for (i = 0; i < NUM_TRAIN_ENGINES; i++) {
 				const Engine *e = GetEngine(i);
-				if (IsCompatibleRail(e->railtype, railtype)
+				if (HasPowerOnRail(e->railtype, railtype)
 				    && HASBIT(e->player_avail, _local_player))
 					count++;
 			}

tunnelbridge_cmd.c

@@ -799,9 +799,9 @@ int32 DoConvertTunnelBridgeRail(TileIndex tile, uint totype, bool exec)
 
 
 // fast routine for getting the height of a middle bridge tile. 'tile' MUST be a middle bridge tile.
-static uint GetBridgeHeight(const TileInfo *ti)
+uint GetBridgeHeight(TileIndex t)
 {
-	TileIndex tile = GetSouthernBridgeEnd(ti->tile);
+	TileIndex tile = GetSouthernBridgeEnd(t);
 
 	/* Return the height there (the height of the NORTH CORNER)
 	 * If the end of the bridge is on a tileh 7 (all raised, except north corner),
@@ -930,6 +930,7 @@ static void DrawTile_TunnelBridge(TileInfo *ti)
 
 		image += GetTunnelDirection(ti->tile) * 2;
 		DrawGroundSprite(image);
+		if (GB(_m[ti->tile].m3, 0, 3) == RAILTYPE_ELECTRIC) DrawCatenary(ti);
 
 		AddSortableSpriteToDraw(image+1, ti->x + 15, ti->y + 15, 1, 1, 8, (byte)ti->z);
 	} else if (IsBridge(ti->tile)) { // XXX is this necessary?
@@ -973,6 +974,8 @@ static void DrawTile_TunnelBridge(TileInfo *ti)
 				DrawGroundSprite(SPR_FLAT_SNOWY_TILE + _tileh_to_sprite[ti->tileh]);
 			}
 
+			if (GB(_m[ti->tile].m3, 0, 3) == RAILTYPE_ELECTRIC) DrawCatenary(ti);
+
 			// draw ramp
 			if (_display_opt & DO_TRANS_BUILDINGS) MAKE_TRANSPARENT(image);
 			AddSortableSpriteToDraw(image, ti->x, ti->y, 16, 16, 7, ti->z);
@@ -1029,7 +1032,7 @@ static void DrawTile_TunnelBridge(TileInfo *ti)
 			// get bridge sprites
 			b = GetBridgeSpriteTable(GetBridgeType(ti->tile), GetBridgePiece(ti->tile)) + base_offset;
 
-			z = GetBridgeHeight(ti) + 5;
+			z = GetBridgeHeight(ti->tile) + 5;
 
 			// draw rail or road component
 			image = b[0];
@@ -1054,6 +1057,8 @@ static void DrawTile_TunnelBridge(TileInfo *ti)
 				if (image & SPRITE_MASK) AddSortableSpriteToDraw(image, x, y, 1, 16, 0x28, z);
 			}
 
+			if (GetRailType(ti->tile) == RAILTYPE_ELECTRIC || GetRailTypeOnBridge(ti->tile) == RAILTYPE_ELECTRIC) DrawCatenary(ti);
+
 			if (ti->z + 5 == z) {
 				// draw poles below for small bridges
 				image = b[2];
@@ -1107,7 +1112,7 @@ static uint GetSlopeZ_TunnelBridge(const TileInfo* ti)
 				if (_get_z_hint >= z + 8) return _get_z_hint;
 
 				// actually on the bridge, but not yet in the shared area.
-				if (!IS_INT_INSIDE(x, 5, 10 + 1)) return GetBridgeHeight(ti) + 8;
+				if (!IS_INT_INSIDE(x, 5, 10 + 1)) return GetBridgeHeight(ti->tile) + 8;
 
 				// in the shared area, assume that we're below the bridge, cause otherwise the hint would've caught it.
 				// if rail or road below then it means it's possibly build on slope below the bridge.

variables.h

@@ -345,7 +345,6 @@ typedef struct {
 	SpriteID sprites[NUM_CARGO];
 	byte transit_days_1[NUM_CARGO];
 	byte transit_days_2[NUM_CARGO];
-	byte ai_railwagon[3][NUM_CARGO];
 	byte ai_roadveh_start[NUM_CARGO];
 	byte ai_roadveh_count[NUM_CARGO];
 } CargoConst;

vehicle.c

@@ -218,6 +218,10 @@ void AfterLoadVehicles(void)
 
 	FOR_ALL_VEHICLES(v) {
 		v->first = NULL;
+		if (v->type == VEH_Train) v->u.rail.first_engine = INVALID_ENGINE;
+	}
+
+	FOR_ALL_VEHICLES(v) {
 		if (v->type == VEH_Train && (IsFrontEngine(v) || IsFreeWagon(v)))
 			TrainConsistChanged(v);
 	}

vehicle.h

@@ -72,6 +72,7 @@ typedef struct VehicleRail {
 	byte track;
 	byte force_proceed;
 	byte railtype;
+	RailTypeMask compatible_railtypes;
 
 	byte flags;
 
@@ -307,6 +308,7 @@ UnitID GetFreeUnitNumber(byte type);
 int LoadUnloadVehicle(Vehicle *v);
 
 void TrainConsistChanged(Vehicle *v);
+void TrainPowerChanged(Vehicle *v);
 int32 GetTrainRunningCost(const Vehicle *v);
 
 int CheckTrainStoppedInDepot(const Vehicle *v);

vehicle_gui.c

@@ -76,6 +76,7 @@ const StringID _vehicle_sort_listing[] = {
 
 static const StringID _rail_types_list[] = {
 	STR_RAIL_VEHICLES,
+	STR_ELRAIL_VEHICLES,
 	STR_MONORAIL_VEHICLES,
 	STR_MAGLEV_VEHICLES,
 	INVALID_STRING_ID
@@ -450,7 +451,7 @@ static int CDECL VehicleValueSorter(const void *a, const void *b)
  *	if used compined with show_cars set to false, it will work as intended. Replace window do it like that
  *  this was a big hack even before show_outdated was added. Stupid newgrf :p										*/
 static void train_engine_drawing_loop(int *x, int *y, int *pos, int *sel, EngineID *selected_id, RailType railtype,
-	uint8 lines_drawn, bool is_engine, bool show_cars, bool show_outdated)
+	uint8 lines_drawn, bool is_engine, bool show_cars, bool show_outdated, bool show_compatible)
 {
 	EngineID j;
 	byte colour;
@@ -472,7 +473,9 @@ static void train_engine_drawing_loop(int *x, int *y, int *pos, int *sel, Engine
 
 		colour = *sel == 0 ? 0xC : 0x10;
 		if (!(ENGINE_AVAILABLE && show_outdated && RailVehInfo(i)->power && e->railtype == railtype)) {
-			if (e->railtype != railtype || !(rvi->flags & RVI_WAGON) != is_engine ||
+			if ((!HasPowerOnRail(e->railtype, railtype) && show_compatible)
+				|| (e->railtype != railtype && !show_compatible)
+				|| !(rvi->flags & RVI_WAGON) != is_engine ||
 				!HASBIT(e->player_avail, _local_player))
 				continue;
 		} /*else {
@@ -522,16 +525,15 @@ static void SetupScrollStuffForReplaceWindow(Window *w)
 				const Engine* e = GetEngine(eid);
 				const EngineInfo* info = &_engine_info[eid];
 
+				// left window contains compatible engines while right window only contains engines of the selected type
 				if (ENGINE_AVAILABLE && (
 							(RailVehInfo(eid)->power != 0 && WP(w, replaceveh_d).wagon_btnstate) ||
-							(RailVehInfo(eid)->power == 0 && !WP(w, replaceveh_d).wagon_btnstate)
+							(RailVehInfo(eid)->power == 0 && !WP(w, replaceveh_d).wagon_btnstate))) {
-						) &&
+					if (HasPowerOnRail(e->railtype, railtype) && (_player_num_engines[eid] > 0 || EngineHasReplacementForPlayer(p, eid))) {
-						e->railtype == railtype) {
-					if (_player_num_engines[eid] > 0 || EngineHasReplacementForPlayer(p, eid)) {
 						if (sel[0] == count) selected_id[0] = eid;
 						count++;
 					}
-					if (HASBIT(e->player_avail, _local_player)) {
+					if (e->railtype == railtype && HASBIT(e->player_avail, _local_player)) {
 						if (sel[1] == count2) selected_id[1] = eid;
 						count2++;
 					}
@@ -647,12 +649,12 @@ static void DrawEngineArrayInReplaceWindow(Window *w, int x, int y, int x2, int
 			* engines to get more types.. Stays here until we have our own format
 			* then it is exit!!! */
 			if (WP(w,replaceveh_d).wagon_btnstate) {
-				train_engine_drawing_loop(&x, &y, &pos, &sel[0], &selected_id[0], railtype, w->vscroll.cap, true, false, true); // True engines
+				train_engine_drawing_loop(&x, &y, &pos, &sel[0], &selected_id[0], railtype, w->vscroll.cap, true, false, true, true); // True engines
-				train_engine_drawing_loop(&x2, &y2, &pos2, &sel[1], &selected_id[1], railtype, w->vscroll.cap, true, false, false); // True engines
+				train_engine_drawing_loop(&x2, &y2, &pos2, &sel[1], &selected_id[1], railtype, w->vscroll.cap, true, false, false, false); // True engines
-				train_engine_drawing_loop(&x2, &y2, &pos2, &sel[1], &selected_id[1], railtype, w->vscroll.cap, false, false, false); // Feeble wagons
+				train_engine_drawing_loop(&x2, &y2, &pos2, &sel[1], &selected_id[1], railtype, w->vscroll.cap, false, false, false, false); // Feeble wagons
 			} else {
-				train_engine_drawing_loop(&x, &y, &pos, &sel[0], &selected_id[0], railtype, w->vscroll.cap, false, true, true);
+				train_engine_drawing_loop(&x, &y, &pos, &sel[0], &selected_id[0], railtype, w->vscroll.cap, false, true, true, true);
-				train_engine_drawing_loop(&x2, &y2, &pos2, &sel[1], &selected_id[1], railtype, w->vscroll.cap, false, true, false);
+				train_engine_drawing_loop(&x2, &y2, &pos2, &sel[1], &selected_id[1], railtype, w->vscroll.cap, false, true, false, true);
 			}
 			break;
 		}