openttd-ottdgrfs: comparison src/rail

equal deleted inserted replaced

-:5a8b295aa345
+:4cc327ad39d5
 /* $Id$ */
+/** @file rail_cmd.cpp */
 #include "stdafx.h"
 #include "openttd.h"
 #include "bridge_map.h"
 #include "bridge.h"
 *               11uuuudd => rail depot
 */
 static bool CheckTrackCombination(TileIndex tile, TrackBits to_build, uint flags)
 {
-	TrackBits current; /* The current track layout */
+	TrackBits current; // The current track layout
-	TrackBits future; /* The track layout we want to build */
+	TrackBits future;  // The track layout we want to build
 	_error_message = STR_1001_IMPOSSIBLE_TRACK_COMBINATION;
 	if (!IsPlainRailTile(tile)) return false;
 	/* So, we have a tile with tracks on it (and possibly signals). Let's see
 }
 static const TrackBits _valid_tileh_slopes[][15] = {
-// set of normal ones
+/* set of normal ones */
 {
 	TRACK_BIT_ALL,
 	TRACK_BIT_RIGHT,
 	TRACK_BIT_UPPER,
 	TRACK_BIT_X,
 	TRACK_BIT_X,
 	TRACK_BIT_UPPER,
 	TRACK_BIT_RIGHT,
 },
-// allowed rail for an evenly raised platform
+/* allowed rail for an evenly raised platform */
 {
 	TRACK_BIT_NONE,
 	TRACK_BIT_LEFT,
 	TRACK_BIT_LOWER,
 	TRACK_BIT_Y | TRACK_BIT_LOWER | TRACK_BIT_LEFT,
 static uint32 CheckRailSlope(Slope tileh, TrackBits rail_bits, TrackBits existing, TileIndex tile)
 {
 	if (IsSteepSlope(tileh)) {
-		if (existing == 0) {
+		if (_patches.build_on_slopes && existing == 0) {
 			TrackBits valid = TRACK_BIT_CROSS | (HASBIT(1 << SLOPE_STEEP_W | 1 << SLOPE_STEEP_E, tileh) ? TRACK_BIT_VERT : TRACK_BIT_HORZ);
 			if (valid & rail_bits) return _price.terraform;
 		}
 	} else {
 		rail_bits |= existing;
-		// don't allow building on the lower side of a coast
+		/* don't allow building on the lower side of a coast */
 		if (IsTileType(tile, MP_WATER) &&
 				~_valid_tileh_slopes[1][tileh] & rail_bits) {
 			return_cmd_error(STR_3807_CAN_T_BUILD_ON_WATER);
 		}
-		// no special foundation
+		/* no special foundation */
 		if ((~_valid_tileh_slopes[0][tileh] & rail_bits) == 0)
 			return 0;
 		if ((~_valid_tileh_slopes[1][tileh] & rail_bits) == 0 || ( // whole tile is leveled up
 					(rail_bits == TRACK_BIT_X || rail_bits == TRACK_BIT_Y) &&
 /* Validate functions for rail building */
 static inline bool ValParamTrackOrientation(Track track) {return IsValidTrack(track);}
 /** Build a single piece of rail
 * @param tile tile  to build on
+* @param flags operation to perform
 * @param p1 railtype of being built piece (normal, mono, maglev)
 * @param p2 rail track to build
 */
 int32 CmdBuildSingleRail(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	switch (GetTileType(tile)) {
 		case MP_RAILWAY:
 			if (!CheckTrackCombination(tile, trackbit, flags) ||
-					!EnsureNoVehicle(tile)) {
+					!EnsureNoVehicleOnGround(tile)) {
 				return CMD_ERROR;
 			}
 			if (!IsTileOwner(tile, _current_player) ||
 					!IsCompatibleRail(GetRailType(tile), railtype)) {
-				// Get detailed error message
+				/* Get detailed error message */
 				return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 			}
 			ret = CheckRailSlope(tileh, trackbit, GetTrackBits(tile), tile);
 			if (CmdFailed(ret)) return ret;
 			if (!HASBIT(M(SLOPE_SEN) | M(SLOPE_ENW) | M(SLOPE_NWS) | M(SLOPE_NS) | M(SLOPE_WSE) | M(SLOPE_EW) | M(SLOPE_FLAT), tileh)) {
 				return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
 			}
 #undef M
-			if (!EnsureNoVehicle(tile)) return CMD_ERROR;
+			if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 			if (GetRoadTileType(tile) == ROAD_TILE_NORMAL) {
 				if (HasRoadWorks(tile)) return_cmd_error(STR_ROAD_WORKS_IN_PROGRESS);
-				if ((track == TRACK_X && GetRoadBits(tile) == ROAD_Y) ||
+				RoadTypes roadtypes = GetRoadTypes(tile);
-						(track == TRACK_Y && GetRoadBits(tile) == ROAD_X)) {
+				RoadBits road = GetRoadBits(tile, ROADTYPE_ROAD);
+				RoadBits tram = GetRoadBits(tile, ROADTYPE_TRAM);
+				switch (roadtypes) {
+					default: break;
+					case ROADTYPES_TRAM:
+						/* Tram crossings must always have road. */
+						SetRoadOwner(tile, ROADTYPE_ROAD, _current_player);
+						roadtypes |= ROADTYPES_ROAD;
+						break;
+					case ROADTYPES_ROADTRAM: if (road == tram) break;
+						/* FALL THROUGH */
+					case ROADTYPES_ROADHWAY: // Road and highway are incompatible in this case
+					case ROADTYPES_TRAMHWAY: // Tram and highway are incompatible in this case
+					case ROADTYPES_ALL:      // Also incompatible
+						return CMD_ERROR;
+				}
+				road |= tram | GetRoadBits(tile, ROADTYPE_HWAY);
+				if ((track == TRACK_X && road == ROAD_Y) ||
+						(track == TRACK_Y && road == ROAD_X)) {
 					if (flags & DC_EXEC) {
-						MakeRoadCrossing(tile, GetTileOwner(tile), _current_player, (track == TRACK_X ? AXIS_Y : AXIS_X), railtype, GetTownIndex(tile));
+						MakeRoadCrossing(tile, GetRoadOwner(tile, ROADTYPE_ROAD), GetRoadOwner(tile, ROADTYPE_TRAM), GetRoadOwner(tile, ROADTYPE_HWAY), _current_player, (track == TRACK_X ? AXIS_Y : AXIS_X), railtype, roadtypes, GetTownIndex(tile));
 					}
 					break;
 				}
 			}
 	return cost + _price.build_rail;
 }
 /** Remove a single piece of track
 * @param tile tile to remove track from
+* @param flags operation to perform
 * @param p1 unused
 * @param p2 rail orientation
 */
 int32 CmdRemoveSingleRail(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	switch (GetTileType(tile)) {
 		case MP_STREET: {
 			if (!IsLevelCrossing(tile) ||
 					GetCrossingRailBits(tile) != trackbit ||
 					(_current_player != OWNER_WATER && !CheckTileOwnership(tile)) ||
-					!EnsureNoVehicle(tile)) {
+					!EnsureNoVehicleOnGround(tile)) {
 				return CMD_ERROR;
 			}
 			if (flags & DC_EXEC) {
-				MakeRoadNormal(tile, GetCrossingRoadOwner(tile), GetCrossingRoadBits(tile), GetTownIndex(tile));
+				MakeRoadNormal(tile, GetCrossingRoadBits(tile), GetRoadTypes(tile), GetTownIndex(tile), GetRoadOwner(tile, ROADTYPE_ROAD), GetRoadOwner(tile, ROADTYPE_TRAM), GetRoadOwner(tile, ROADTYPE_HWAY));
 			}
 			break;
 		}
 		case MP_RAILWAY: {
 			TrackBits present;
 			if (!IsPlainRailTile(tile) ||
 					(_current_player != OWNER_WATER && !CheckTileOwnership(tile)) ||
-					!EnsureNoVehicle(tile)) {
+					!EnsureNoVehicleOnGround(tile)) {
 				return CMD_ERROR;
 			}
 			present = GetTrackBits(tile);
 			if ((present & trackbit) == 0) return CMD_ERROR;
 	int ey = TileY(end);
 	int dx, dy, trdx, trdy;
 	if (!ValParamTrackOrientation(TrackdirToTrack(*trackdir))) return CMD_ERROR;
-	// calculate delta x,y from start to end tile
+	/* calculate delta x,y from start to end tile */
 	dx = ex - x;
 	dy = ey - y;
-	// calculate delta x,y for the first direction
+	/* calculate delta x,y for the first direction */
 	trdx = _trackdelta[*trackdir].x;
 	trdy = _trackdelta[*trackdir].y;
 	if (!IsDiagonalTrackdir(*trackdir)) {
 		trdx += _trackdelta[*trackdir ^ 1].x;
 		trdy += _trackdelta[*trackdir ^ 1].y;
 	}
-	// validate the direction
+	/* validate the direction */
 	while (
 		(trdx <= 0 && dx > 0) ||
 		(trdx >= 0 && dx < 0) ||
 		(trdy <= 0 && dy > 0) ||
 		(trdy >= 0 && dy < 0)
 		} else { // other direction is invalid too, invalid drag
 			return CMD_ERROR;
 		}
 	}
-	// (for diagonal tracks, this is already made sure of by above test), but:
+	/* (for diagonal tracks, this is already made sure of by above test), but:
-	// for non-diagonal tracks, check if the start and end tile are on 1 line
+	 * for non-diagonal tracks, check if the start and end tile are on 1 line */
 	if (!IsDiagonalTrackdir(*trackdir)) {
 		trdx = _trackdelta[*trackdir].x;
 		trdy = _trackdelta[*trackdir].y;
 		if (abs(dx) != abs(dy) && abs(dx) + abs(trdy) != abs(dy) + abs(trdx))
 			return CMD_ERROR;
 	return 0;
 }
 /** Build a stretch of railroad tracks.
 * @param tile start tile of drag
+* @param flags operation to perform
 * @param p1 end tile of drag
 * @param p2 various bitstuffed elements
 * - p2 = (bit 0-3) - railroad type normal/maglev (0 = normal, 1 = mono, 2 = maglev)
 * - p2 = (bit 4-6) - track-orientation, valid values: 0-5 (Track enum)
 * - p2 = (bit 7)   - 0 = build, 1 = remove tracks
 		if (tile == end_tile) break;
 		tile += ToTileIndexDiff(_trackdelta[trackdir]);
-		// toggle railbit for the non-diagonal tracks
+		/* toggle railbit for the non-diagonal tracks */
 		if (!IsDiagonalTrackdir(trackdir)) ToggleBitT(trackdir, 0);
 	}
 	return (total_cost == 0) ? CMD_ERROR : total_cost;
 }
 /** Build rail on a stretch of track.
 * Stub for the unified rail builder/remover
+* @param tile start tile of drag
+* @param flags operation to perform
+* @param p1 end tile of drag
+* @param p2 various bitstuffed elements
+* - p2 = (bit 0-3) - railroad type normal/maglev (0 = normal, 1 = mono, 2 = maglev)
+* - p2 = (bit 4-6) - track-orientation, valid values: 0-5 (Track enum)
+* - p2 = (bit 7)   - 0 = build, 1 = remove tracks
 * @see CmdRailTrackHelper
 */
 int32 CmdBuildRailroadTrack(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	return CmdRailTrackHelper(tile, flags, p1, CLRBIT(p2, 7));
 }
 /** Build rail on a stretch of track.
 * Stub for the unified rail builder/remover
+* @param tile start tile of drag
+* @param flags operation to perform
+* @param p1 end tile of drag
+* @param p2 various bitstuffed elements
+* - p2 = (bit 0-3) - railroad type normal/maglev (0 = normal, 1 = mono, 2 = maglev)
+* - p2 = (bit 4-6) - track-orientation, valid values: 0-5 (Track enum)
+* - p2 = (bit 7)   - 0 = build, 1 = remove tracks
 * @see CmdRailTrackHelper
 */
 int32 CmdRemoveRailroadTrack(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	return CmdRailTrackHelper(tile, flags, p1, SETBIT(p2, 7));
 }
 /** Build a train depot
 * @param tile position of the train depot
+* @param flags operation to perform
 * @param p1 rail type
 * @param p2 bit 0..1 entrance direction (DiagDirection)
 *
 * @todo When checking for the tile slope,
 * distingush between "Flat land required" and "land sloped in wrong direction"
 /** Build signals, alternate between double/single, signal/semaphore,
 * pre/exit/combo-signals, and what-else not. If the rail piece does not
 * have any signals, bit 4 (cycle signal-type) is ignored
 * @param tile tile where to build the signals
+* @param flags operation to perform
 * @param p1 various bitstuffed elements
 * - p1 = (bit 0-2) - track-orientation, valid values: 0-5 (Track enum)
 * - p1 = (bit 3)   - 1 = override signal/semaphore, or pre/exit/combo signal (CTRL-toggle)
 * - p1 = (bit 4)   - 0 = signals, 1 = semaphores
 * @param p2 used for CmdBuildManySignals() to copy direction of first signal
 	Track track = (Track)GB(p1, 0, 3);
 	bool pre_signal = HASBIT(p1, 3);
 	SignalVariant sigvar = (pre_signal ^ HASBIT(p1, 4)) ? SIG_SEMAPHORE : SIG_ELECTRIC;
 	int32 cost;
-	if (!ValParamTrackOrientation(track) || !IsTileType(tile, MP_RAILWAY) || !EnsureNoVehicle(tile))
+	if (!ValParamTrackOrientation(track) || !IsTileType(tile, MP_RAILWAY) || !EnsureNoVehicleOnGround(tile))
 		return CMD_ERROR;
 	/* Protect against invalid signal copying */
 	if (p2 != 0 && (p2 & SignalOnTrack(track)) == 0) return CMD_ERROR;
 	}
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	if (!HasSignalOnTrack(tile, track)) {
-		// build new signals
+		/* build new signals */
 		cost = _price.build_signals;
 	} else {
-		if (p2 != 0 && sigvar != GetSignalVariant(tile)) {
+		if (p2 != 0 && sigvar != GetSignalVariant(tile, track)) {
-			// convert signals <-> semaphores
+			/* convert signals <-> semaphores */
 			cost = _price.build_signals + _price.remove_signals;
 		} else {
-			// it is free to change orientation/pre-exit-combo signals
+			/* it is free to change orientation/pre-exit-combo signals */
 			cost = 0;
 		}
 	}
 	if (flags & DC_EXEC) {
 		if (!HasSignals(tile)) {
-			// there are no signals at all on this tile yet
+			/* there are no signals at all on this tile yet */
 			SetHasSignals(tile, true);
-			_m[tile].m2 |= 0xF0;              // all signals are on
+			SetSignalStates(tile, 0xF); // all signals are on
-			_m[tile].m3 &= ~0xF0;          // no signals built by default
+			SetPresentSignals(tile, 0); // no signals built by default
-			SetSignalType(tile, SIGTYPE_NORMAL);
+			SetSignalType(tile, track, SIGTYPE_NORMAL);
-			SetSignalVariant(tile, sigvar);
+			SetSignalVariant(tile, track, sigvar);
 		}
 		if (p2 == 0) {
 			if (!HasSignalOnTrack(tile, track)) {
-				// build new signals
+				/* build new signals */
-				_m[tile].m3 |= SignalOnTrack(track);
+				SetPresentSignals(tile, GetPresentSignals(tile) | SignalOnTrack(track));
+				SetSignalType(tile, track, SIGTYPE_NORMAL);
+				SetSignalVariant(tile, track, sigvar);
 			} else {
 				if (pre_signal) {
-					// cycle between normal -> pre -> exit -> combo -> ...
+					/* cycle between normal -> pre -> exit -> combo -> ... */
-					SignalType type = GetSignalType(tile);
+					SignalType type = GetSignalType(tile, track);
-					SetSignalType(tile, type == SIGTYPE_COMBO ? SIGTYPE_NORMAL : (SignalType)(type + 1));
+					SetSignalType(tile, track, type == SIGTYPE_COMBO ? SIGTYPE_NORMAL : (SignalType)(type + 1));
 				} else {
 					CycleSignalSide(tile, track);
 				}
 			}
 		} else {
 			/* If CmdBuildManySignals is called with copying signals, just copy the
 			 * direction of the first signal given as parameter by CmdBuildManySignals */
-			_m[tile].m3 &= ~SignalOnTrack(track);
+			SetPresentSignals(tile, (GetPresentSignals(tile) & ~SignalOnTrack(track)) | (p2 & SignalOnTrack(track)));
-			_m[tile].m3 |= p2 & SignalOnTrack(track);
+			SetSignalVariant(tile, track, sigvar);
-			SetSignalVariant(tile, sigvar);
 		}
 		MarkTileDirtyByTile(tile);
 		SetSignalsOnBothDir(tile, track);
 		YapfNotifyTrackLayoutChange(tile, track);
 	return cost;
 }
 /** Build many signals by dragging; AutoSignals
 * @param tile start tile of drag
+* @param flags operation to perform
 * @param p1  end tile of drag
 * @param p2 various bitstuffed elements
 * - p2 = (bit  0- 2) - track-orientation, valid values: 0-5 (Track enum)
 * - p2 = (bit  3)    - 1 = override signal/semaphore, or pre/exit/combo signal (CTRL-toggle)
 * - p2 = (bit  4)    - 0 = signals, 1 = semaphores
 	if (CmdFailed(ValidateAutoDrag(&trackdir, tile, end_tile))) return CMD_ERROR;
 	track = TrackdirToTrack(trackdir); /* trackdir might have changed, keep track in sync */
-	// copy the signal-style of the first rail-piece if existing
+	/* copy the signal-style of the first rail-piece if existing */
 	if (HasSignals(tile)) {
-		signals = _m[tile].m3 & SignalOnTrack(track);
+		signals = GetPresentSignals(tile) & SignalOnTrack(track);
 		if (signals == 0) signals = SignalOnTrack(track); /* Can this actually occur? */
-		// copy signal/semaphores style (independent of CTRL)
+		/* copy signal/semaphores style (independent of CTRL) */
-		semaphores = GetSignalVariant(tile) != SIG_ELECTRIC;
+		semaphores = GetSignalVariant(tile, track) != SIG_ELECTRIC;
 	} else { // no signals exist, drag a two-way signal stretch
 		signals = SignalOnTrack(track);
 	}
 	/* signal_ctr         - amount of tiles already processed
 	 * signals    - is there a signal/semaphore on the first tile, copy its style (two-way/single-way)
 	 *              and convert all others to semaphore/signal
 	 * remove     - 1 remove signals, 0 build signals */
 	signal_ctr = total_cost = 0;
 	for (;;) {
-		// only build/remove signals with the specified density
+		/* only build/remove signals with the specified density */
 		if (signal_ctr % signal_density == 0) {
 			uint32 p1 = GB(TrackdirToTrack(trackdir), 0, 3);
 			SB(p1, 3, 1, mode);
 			SB(p1, 4, 1, semaphores);
 			ret = DoCommand(tile, p1, signals, flags, remove ? CMD_REMOVE_SIGNALS : CMD_BUILD_SIGNALS);
 		if (tile == end_tile) break;
 		tile += ToTileIndexDiff(_trackdelta[trackdir]);
 		signal_ctr++;
-		// toggle railbit for the non-diagonal tracks (|, -- tracks)
+		/* toggle railbit for the non-diagonal tracks (|, -- tracks) */
 		if (!IsDiagonalTrackdir(trackdir)) ToggleBitT(trackdir, 0);
 	}
 	return error ? CMD_ERROR : total_cost;
 }
 /** Build signals on a stretch of track.
 * Stub for the unified signal builder/remover
+* @param tile start tile of drag
+* @param flags operation to perform
+* @param p1  end tile of drag
+* @param p2 various bitstuffed elements
+* - p2 = (bit  0- 2) - track-orientation, valid values: 0-5 (Track enum)
+* - p2 = (bit  3)    - 1 = override signal/semaphore, or pre/exit/combo signal (CTRL-toggle)
+* - p2 = (bit  4)    - 0 = signals, 1 = semaphores
+* - p2 = (bit  5)    - 0 = build, 1 = remove signals
+* - p2 = (bit 24-31) - user defined signals_density
 * @see CmdSignalTrackHelper
 */
 int32 CmdBuildSignalTrack(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	return CmdSignalTrackHelper(tile, flags, p1, p2);
 }
 /** Remove signals
 * @param tile coordinates where signal is being deleted from
-* @param various bitstuffed elements, only track information is used
+* @param flags operation to perform
-* - p1 = (bit  0- 2) - track-orientation, valid values: 0-5 (Track enum)
+* @param p1 various bitstuffed elements, only track information is used
-* - p1 = (bit  3)    - override signal/semaphore, or pre/exit/combo signal (CTRL-toggle)
+*           - (bit  0- 2) - track-orientation, valid values: 0-5 (Track enum)
-* - p1 = (bit  4)    - 0 = signals, 1 = semaphores
+*           - (bit  3)    - override signal/semaphore, or pre/exit/combo signal (CTRL-toggle)
+*           - (bit  4)    - 0 = signals, 1 = semaphores
+* @param p2 unused
 */
 int32 CmdRemoveSingleSignal(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	Track track = (Track)GB(p1, 0, 3);
 	if (!ValParamTrackOrientation(track) ||
 			!IsTileType(tile, MP_RAILWAY) ||
-			!EnsureNoVehicle(tile) ||
+			!EnsureNoVehicleOnGround(tile) ||
 			!HasSignalOnTrack(tile, track)) {
 		return CMD_ERROR;
 	}
 	/* Only water can remove signals from anyone */
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	/* Do it? */
 	if (flags & DC_EXEC) {
-		_m[tile].m3 &= ~SignalOnTrack(track);
+		SetPresentSignals(tile, GetPresentSignals(tile) & ~SignalOnTrack(track));
 		/* removed last signal from tile? */
-		if (GB(_m[tile].m3, 4, 4) == 0) {
+		if (GetPresentSignals(tile) == 0) {
-			SB(_m[tile].m2, 4, 4, 0);
+			SetSignalStates(tile, 0);
 			SetHasSignals(tile, false);
-			SetSignalVariant(tile, SIG_ELECTRIC); // remove any possible semaphores
+			SetSignalVariant(tile, INVALID_TRACK, SIG_ELECTRIC); // remove any possible semaphores
 		}
 		SetSignalsOnBothDir(tile, track);
 		YapfNotifyTrackLayoutChange(tile, track);
 	return _price.remove_signals;
 }
 /** Remove signals on a stretch of track.
 * Stub for the unified signal builder/remover
+* @param tile start tile of drag
+* @param flags operation to perform
+* @param p1  end tile of drag
+* @param p2 various bitstuffed elements
+* - p2 = (bit  0- 2) - track-orientation, valid values: 0-5 (Track enum)
+* - p2 = (bit  3)    - 1 = override signal/semaphore, or pre/exit/combo signal (CTRL-toggle)
+* - p2 = (bit  4)    - 0 = signals, 1 = semaphores
+* - p2 = (bit  5)    - 0 = build, 1 = remove signals
+* - p2 = (bit 24-31) - user defined signals_density
 * @see CmdSignalTrackHelper
 */
 int32 CmdRemoveSignalTrack(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	return CmdSignalTrackHelper(tile, flags, p1, SETBIT(p2, 5)); // bit 5 is remove bit
 {
 	if (!CheckTileOwnership(tile)) return CMD_ERROR;
 	if (GetRailType(tile) == totype) return CMD_ERROR;
-	if (!EnsureNoVehicle(tile) && (!IsCompatibleRail(GetRailType(tile), totype) || IsPlainRailTile(tile))) return CMD_ERROR;
+	if (!EnsureNoVehicleOnGround(tile) && (!IsCompatibleRail(GetRailType(tile), totype) || IsPlainRailTile(tile))) return CMD_ERROR;
-	// 'hidden' elrails can't be downgraded to normal rail when elrails are disabled
+	/* 'hidden' elrails can't be downgraded to normal rail when elrails are disabled */
 	if (_patches.disable_elrails && totype == RAILTYPE_RAIL && GetRailType(tile) == RAILTYPE_ELECTRIC) return CMD_ERROR;
-	// change type.
+	/* change type. */
 	if (exec) {
 		SetRailType(tile, totype);
 		MarkTileDirtyByTile(tile);
-		// notify YAPF about the track layout change
+		/* notify YAPF about the track layout change */
 		TrackBits tracks = GetTrackBits(tile);
 		while (tracks != TRACK_BIT_NONE) {
 			YapfNotifyTrackLayoutChange(tile, RemoveFirstTrack(&tracks));
 		}
 extern int32 DoConvertTunnelBridgeRail(TileIndex tile, RailType totype, bool exec);
 /** Convert one rail type to the other. You can convert normal rail to
 * monorail/maglev easily or vice-versa.
 * @param tile end tile of rail conversion drag
+* @param flags operation to perform
 * @param p1 start tile of drag
 * @param p2 new railtype to convert to
 */
 int32 CmdConvertRail(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	if (!ValParamRailtype(p2)) return CMD_ERROR;
 	if (p1 >= MapSize()) return CMD_ERROR;
-	// make sure sx,sy are smaller than ex,ey
+	/* make sure sx,sy are smaller than ex,ey */
 	ex = TileX(tile);
 	ey = TileY(tile);
 	sx = TileX(p1);
 	sy = TileY(p1);
 	if (ex < sx) Swap(ex, sx);
 static int32 RemoveTrainDepot(TileIndex tile, uint32 flags)
 {
 	if (!CheckTileOwnership(tile) && _current_player != OWNER_WATER)
 		return CMD_ERROR;
-	if (!EnsureNoVehicle(tile))
+	if (!EnsureNoVehicleOnGround(tile))
 		return CMD_ERROR;
 	if (flags & DC_EXEC) {
 		DiagDirection dir = GetRailDepotDirection(tile);
 	}
 }
 #include "table/track_land.h"
-static void DrawSingleSignal(TileIndex tile, byte condition, uint image, uint pos)
+static void DrawSingleSignal(TileIndex tile, Track track, byte condition, uint image, uint pos)
 {
 	bool side = (_opt.road_side != 0) && _patches.signal_side;
 	static const Point SignalPositions[2][12] = {
 		{      /* Signals on the left side */
 		/*  LEFT      LEFT      RIGHT     RIGHT     UPPER     UPPER */
 	SpriteID sprite;
 	/* _signal_base is set by our NewGRF Action 5 loader. If it is 0 then we
 	 * just draw the standard signals, else we get the offset from _signal_base
 	 * and draw that sprite. All the signal sprites are loaded sequentially. */
-	if (_signal_base == 0 || (GetSignalType(tile) == 0 && GetSignalVariant(tile) == SIG_ELECTRIC)) {
+	if (_signal_base == 0 || (GetSignalType(tile, track) == SIGTYPE_NORMAL && GetSignalVariant(tile, track) == SIG_ELECTRIC)) {
-		sprite = SignalBase[side][GetSignalVariant(tile)][GetSignalType(tile)] + image + condition;
+		sprite = SignalBase[side][GetSignalVariant(tile, track)][GetSignalType(tile, track)] + image + condition;
 	} else {
-		sprite = _signal_base + (GetSignalType(tile) - 1) * 16 + GetSignalVariant(tile) * 64 + image + condition;
+		sprite = _signal_base + (GetSignalType(tile, track) - 1) * 16 + GetSignalVariant(tile, track) * 64 + image + condition;
 	}
 	AddSortableSpriteToDraw(sprite, PAL_NONE, x, y, 1, 1, 10, GetSlopeZ(x,y));
 }
 /**
 * Draw ground sprite and track bits
 * @param ti TileInfo
 * @param track TrackBits to draw
-* @param earth Draw as earth
-* @param snow Draw as snow
-* @param flat Always draw foundation
 */
 static void DrawTrackBits(TileInfo* ti, TrackBits track)
 {
 	const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));
 	SpriteID image;
 	SpriteID pal = PAL_NONE;
 	bool junction = false;
-	// Select the sprite to use.
+	/* Select the sprite to use. */
 	(image = rti->base_sprites.track_y, track == TRACK_BIT_Y) ||
 	(image++,                           track == TRACK_BIT_X) ||
 	(image++,                           track == TRACK_BIT_UPPER) ||
 	(image++,                           track == TRACK_BIT_LOWER) ||
 	(image++,                           track == TRACK_BIT_RIGHT) ||
 	if (ti->tileh != SLOPE_FLAT) {
 		uint foundation = GetRailFoundation(ti->tileh, track);
 		if (foundation != 0) DrawFoundation(ti, foundation);
-		// DrawFoundation() modifies ti.
+		/* DrawFoundation() modifies it.
-		// Default sloped sprites..
+		 * Default sloped sprites.. */
 		if (ti->tileh != SLOPE_FLAT)
 			image = _track_sloped_sprites[ti->tileh - 1] + rti->base_sprites.track_y;
 	}
 	switch (GetRailGroundType(ti->tile)) {
 		default: break;
 	}
 	DrawGroundSprite(image, pal);
-	// Draw track pieces individually for junction tiles
+	/* Draw track pieces individually for junction tiles */
 	if (junction) {
 		if (track & TRACK_BIT_X)     DrawGroundSprite(rti->base_sprites.single_y, PAL_NONE);
 		if (track & TRACK_BIT_Y)     DrawGroundSprite(rti->base_sprites.single_x, PAL_NONE);
 		if (track & TRACK_BIT_UPPER) DrawGroundSprite(rti->base_sprites.single_n, PAL_NONE);
 		if (track & TRACK_BIT_LOWER) DrawGroundSprite(rti->base_sprites.single_s, PAL_NONE);
 }
 static void DrawSignals(TileIndex tile, TrackBits rails)
 {
-#define MAYBE_DRAW_SIGNAL(x,y,z) if (IsSignalPresent(tile, x)) DrawSingleSignal(tile, GetSingleSignalState(tile, x), y - 0x4FB, z)
+#define MAYBE_DRAW_SIGNAL(x,y,z,t) if (IsSignalPresent(tile, x)) DrawSingleSignal(tile, t, GetSingleSignalState(tile, x), y - 0x4FB, z)
 	if (!(rails & TRACK_BIT_Y)) {
 		if (!(rails & TRACK_BIT_X)) {
 			if (rails & TRACK_BIT_LEFT) {
-				MAYBE_DRAW_SIGNAL(2, 0x509, 0);
+				MAYBE_DRAW_SIGNAL(2, 0x509, 0, TRACK_LEFT);
-				MAYBE_DRAW_SIGNAL(3, 0x507, 1);
+				MAYBE_DRAW_SIGNAL(3, 0x507, 1, TRACK_LEFT);
 			}
 			if (rails & TRACK_BIT_RIGHT) {
-				MAYBE_DRAW_SIGNAL(0, 0x509, 2);
+				MAYBE_DRAW_SIGNAL(0, 0x509, 2, TRACK_RIGHT);
-				MAYBE_DRAW_SIGNAL(1, 0x507, 3);
+				MAYBE_DRAW_SIGNAL(1, 0x507, 3, TRACK_RIGHT);
 			}
 			if (rails & TRACK_BIT_UPPER) {
-				MAYBE_DRAW_SIGNAL(3, 0x505, 4);
+				MAYBE_DRAW_SIGNAL(3, 0x505, 4, TRACK_UPPER);
-				MAYBE_DRAW_SIGNAL(2, 0x503, 5);
+				MAYBE_DRAW_SIGNAL(2, 0x503, 5, TRACK_UPPER);
 			}
 			if (rails & TRACK_BIT_LOWER) {
-				MAYBE_DRAW_SIGNAL(1, 0x505, 6);
+				MAYBE_DRAW_SIGNAL(1, 0x505, 6, TRACK_LOWER);
-				MAYBE_DRAW_SIGNAL(0, 0x503, 7);
+				MAYBE_DRAW_SIGNAL(0, 0x503, 7, TRACK_LOWER);
 			}
 		} else {
-			MAYBE_DRAW_SIGNAL(3, 0x4FB, 8);
+			MAYBE_DRAW_SIGNAL(3, 0x4FB, 8, TRACK_X);
-			MAYBE_DRAW_SIGNAL(2, 0x4FD, 9);
+			MAYBE_DRAW_SIGNAL(2, 0x4FD, 9, TRACK_X);
 		}
 	} else {
-		MAYBE_DRAW_SIGNAL(3, 0x4FF, 10);
+		MAYBE_DRAW_SIGNAL(3, 0x4FF, 10, TRACK_Y);
-		MAYBE_DRAW_SIGNAL(2, 0x501, 11);
+		MAYBE_DRAW_SIGNAL(2, 0x501, 11, TRACK_Y);
 	}
 }
 static void DrawTile_Track(TileInfo *ti)
 {
 	if (IsPlainRailTile(ti->tile)) {
 		TrackBits rails = GetTrackBits(ti->tile);
 		DrawTrackBits(ti, rails);
-		if (_display_opt & DO_FULL_DETAIL) DrawTrackDetails(ti);
+		if (HASBIT(_display_opt, DO_FULL_DETAIL)) DrawTrackDetails(ti);
 		if (HasSignals(ti->tile)) DrawSignals(ti->tile, rails);
 	} else {
-		// draw depot/waypoint
+		/* draw depot/waypoint */
 		const DrawTileSprites* dts;
 		const DrawTileSeqStruct* dtss;
 		uint32 relocation;
 		if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, ti->tileh);
 			relocation = rti->total_offset;
 			image = dts->ground_sprite;
 			if (image != SPR_FLAT_GRASS_TILE) image += rti->total_offset;
-			// adjust ground tile for desert
+			/* adjust ground tile for desert
-			// don't adjust for snow, because snow in depots looks weird
+			 * don't adjust for snow, because snow in depots looks weird */
 			if (IsSnowRailGround(ti->tile) && _opt.landscape == LT_TROPIC) {
 				if (image != SPR_FLAT_GRASS_TILE) {
 					image += rti->snow_offset; // tile with tracks
 				} else {
 					image = SPR_FLAT_SNOWY_TILE; // flat ground
 				}
 			}
 		} else {
-			// look for customization
+			/* look for customization */
 			byte stat_id = GetWaypointByTile(ti->tile)->stat_id;
 			const StationSpec *statspec = GetCustomStationSpec(STAT_CLASS_WAYP, stat_id);
 			if (statspec != NULL) {
-				// emulate station tile - open with building
+				/* emulate station tile - open with building */
 				const Station* st = ComposeWaypointStation(ti->tile);
 				uint gfx = 2;
 				if (HASBIT(statspec->callbackmask, CBM_CUSTOM_LAYOUT)) {
 					uint16 callback = GetStationCallback(CBID_STATION_SPRITE_LAYOUT, 0, 0, statspec, st, ti->tile);
 				} else {
 					goto default_waypoint;
 				}
 			} else {
 default_waypoint:
-				// There is no custom layout, fall back to the default graphics
+				/* There is no custom layout, fall back to the default graphics */
 				dts = &_waypoint_gfx_table[GetWaypointAxis(ti->tile)];
 				relocation = 0;
 				image = dts->ground_sprite + rti->total_offset;
 				if (IsSnowRailGround(ti->tile)) image += rti->snow_offset;
 			}
 				image += rti->total_offset;
 			} else {
 				image += relocation;
 			}
-			if (_display_opt & DO_TRANS_BUILDINGS) {
+			if (HASBIT(_transparent_opt, TO_BUILDINGS)) {
 				SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);
 				pal = PALETTE_TO_TRANSPARENT;
 			} else if (HASBIT(image, PALETTE_MODIFIER_COLOR)) {
 				pal = _drawtile_track_palette;
 			} else {
 	int cur;
 	int cur_stack;
 	bool stop;
 	bool has_presignal;
-	// presignal info
+	/* presignal info */
 	int presignal_exits;
 	int presignal_exits_free;
-	// these are used to keep track of the signals that change.
+	/* these are used to keep track of the signals that change. */
 	TrackdirByte bit[NUM_SSD_ENTRY];
 	TileIndex tile[NUM_SSD_ENTRY];
-	// these are used to keep track of the stack that modifies presignals recursively
+	/* these are used to keep track of the stack that modifies presignals recursively */
 	TileIndex next_tile[NUM_SSD_STACK];
 	DiagDirectionByte next_dir[NUM_SSD_STACK];
 };
 static bool SetSignalsEnumProc(TileIndex tile, void* data, Trackdir trackdir, uint length, byte* state)
 {
 	SetSignalsData* ssd = (SetSignalsData*)data;
+	Track track = TrackdirToTrack(trackdir);
 	if (!IsTileType(tile, MP_RAILWAY)) return false;
-	// the tile has signals?
+	/* the tile has signals? */
-	if (HasSignalOnTrack(tile, TrackdirToTrack(trackdir))) {
+	if (HasSignalOnTrack(tile, track)) {
 		if (HasSignalOnTrackdir(tile, ReverseTrackdir(trackdir))) {
-			// yes, add the signal to the list of signals
+			/* yes, add the signal to the list of signals */
 			if (ssd->cur != NUM_SSD_ENTRY) {
 				ssd->tile[ssd->cur] = tile; // remember the tile index
 				ssd->bit[ssd->cur] = trackdir; // and the controlling bit number
 				ssd->cur++;
 			}
-			// remember if this block has a presignal.
+			/* remember if this block has a presignal. */
-			ssd->has_presignal |= IsPresignalEntry(tile);
+			ssd->has_presignal |= IsPresignalEntry(tile, track);
 		}
-		if (HasSignalOnTrackdir(tile, trackdir) && IsPresignalExit(tile)) {
+		if (HasSignalOnTrackdir(tile, trackdir) && IsPresignalExit(tile, track)) {
-			// this is an exit signal that points out from the segment
+			/* this is an exit signal that points out from the segment */
 			ssd->presignal_exits++;
 			if (GetSignalStateByTrackdir(tile, trackdir) != SIGNAL_STATE_RED)
 				ssd->presignal_exits_free++;
 		}
 			direction = GetBridgeRampDirection(tile);
 		}
 		dest.track = 1 << (direction & 1); // get the trackbit the vehicle would have if it has not entered the tunnel yet (ie is still visible)
-		// check for a vehicle with that trackdir on the start tile of the tunnel
+		/* check for a vehicle with that trackdir on the start tile of the tunnel */
 		if (VehicleFromPos(tile, &dest, SignalVehicleCheckProc) != NULL) return true;
-		// check for a vehicle with that trackdir on the end tile of the tunnel
+		/* check for a vehicle with that trackdir on the end tile of the tunnel */
 		if (VehicleFromPos(end, &dest, SignalVehicleCheckProc) != NULL) return true;
-		// now check all tiles from start to end for a warping vehicle
+		/* now check all tiles from start to end for a warping vehicle
-		// NOTE: the hashes for tiles may overlap, so this could maybe be optimised a bit by not checking every tile?
+		 * NOTE: the hashes for tiles may overlap, so this could maybe be optimised a bit by not checking every tile? */
 		dest.track = 0x40;   //Vehicle inside a tunnel or on a bridge
 		for (; tile != end; tile += TileOffsByDiagDir(direction)) {
 			if (VehicleFromPos(tile, &dest, SignalVehicleCheckProc) != NULL)
 				return true;
 		}
-		// no vehicle found
+		/* no vehicle found */
 		return false;
 	}
 	return VehicleFromPos(tile, &dest, SignalVehicleCheckProc) != NULL;
 }
 static void ChangeSignalStates(SetSignalsData *ssd)
 {
 	int i;
-	// thinking about presignals...
+	/* thinking about presignals...
-	// the presignal is green if,
+	 * the presignal is green if,
-	//   if no train is in the segment AND
+	 *   if no train is in the segment AND
-	//   there is at least one green exit signal OR
+	 *   there is at least one green exit signal OR
-	//   there are no exit signals in the segment
+	 *   there are no exit signals in the segment */
-	// then mark the signals in the segment accordingly
+	/* then mark the signals in the segment accordingly */
 	for (i = 0; i != ssd->cur; i++) {
 		TileIndex tile = ssd->tile[i];
 		byte bit = SignalAgainstTrackdir(ssd->bit[i]);
-		uint16 m2 = _m[tile].m2;
+		uint signals = GetSignalStates(tile);
+		Track track = TrackdirToTrack(ssd->bit[i]);
-		// presignals don't turn green if there is at least one presignal exit and none are free
-		if (IsPresignalEntry(tile)) {
+		/* presignals don't turn green if there is at least one presignal exit and none are free */
+		if (IsPresignalEntry(tile, track)) {
 			int ex = ssd->presignal_exits, exfree = ssd->presignal_exits_free;
-			// subtract for dual combo signals so they don't count themselves
+			/* subtract for dual combo signals so they don't count themselves */
-			if (IsPresignalExit(tile) && HasSignalOnTrackdir(tile, ssd->bit[i])) {
+			if (IsPresignalExit(tile, track) && HasSignalOnTrackdir(tile, ssd->bit[i])) {
 				ex--;
 				if (GetSignalStateByTrackdir(tile, ssd->bit[i]) != SIGNAL_STATE_RED) exfree--;
 			}
-			// if we have exits and none are free, make red.
+			/* if we have exits and none are free, make red. */
 			if (ex && !exfree) goto make_red;
 		}
-		// check if the signal is unaffected.
+		/* check if the signal is unaffected. */
 		if (ssd->stop) {
 make_red:
-			// turn red
+			/* turn red */
-			if ((bit & m2) == 0) continue;
+			if ((bit & signals) == 0) continue;
 		} else {
-			// turn green
+			/* turn green */
-			if ((bit & m2) != 0) continue;
+			if ((bit & signals) != 0) continue;
 		}
 		/* Update signals on the other side of this exit-combo signal; it changed. */
-		if (IsPresignalExit(tile)) {
+		if (IsPresignalExit(tile, track)) {
 			if (ssd->cur_stack != NUM_SSD_STACK) {
 				ssd->next_tile[ssd->cur_stack] = tile;
 				ssd->next_dir[ssd->cur_stack] = _dir_from_track[ssd->bit[i]];
 				ssd->cur_stack++;
 			} else {
 				DEBUG(misc, 0, "NUM_SSD_STACK too small"); /// @todo WTF is this???
 			}
 		}
-		// it changed, so toggle it
+		/* it changed, so toggle it */
-		_m[tile].m2 = m2 ^ bit;
+		SetSignalStates(tile, signals ^ bit);
 		MarkTileDirtyByTile(tile);
 	}
 }
 	int result = -1;
 	ssd.cur_stack = 0;
 	for (;;) {
-		// go through one segment and update all signals pointing into that segment.
+		/* go through one segment and update all signals pointing into that segment. */
 		ssd.cur = ssd.presignal_exits = ssd.presignal_exits_free = 0;
 		ssd.has_presignal = false;
-		FollowTrack(tile, 0xC000 | TRANSPORT_RAIL, direction, SetSignalsEnumProc, SetSignalsAfterProc, &ssd);
+		FollowTrack(tile, 0xC000 | TRANSPORT_RAIL, 0, direction, SetSignalsEnumProc, SetSignalsAfterProc, &ssd);
 		ChangeSignalStates(&ssd);
-		// remember the result only for the first iteration.
+		/* remember the result only for the first iteration. */
 		if (result < 0) {
-			// stay in depot while segment is occupied or while all presignal exits are blocked
+			/* stay in depot while segment is occupied or while all presignal exits are blocked */
 			result = ssd.stop || (ssd.presignal_exits > 0 && ssd.presignal_exits_free == 0);
 		}
-		// if any exit signals were changed, we need to keep going to modify the stuff behind those.
+		/* if any exit signals were changed, we need to keep going to modify the stuff behind those. */
 		if (ssd.cur_stack == 0) break;
-		// one or more exit signals were changed, so we need to update another segment too.
+		/* one or more exit signals were changed, so we need to update another segment too. */
 		tile = ssd.next_tile[--ssd.cur_stack];
 		direction = ssd.next_dir[ssd.cur_stack];
 	}
 	return result != 0;
 	if (!IsPlainRailTile(tile)) return;
 	new_ground = RAIL_GROUND_GRASS;
-	if (old_ground != RAIL_GROUND_BARREN) { /* wait until bottom is green */
+	if (old_ground != RAIL_GROUND_BARREN) { // wait until bottom is green
 		/* determine direction of fence */
 		TrackBits rail = GetTrackBits(tile);
 		switch (rail) {
 			case TRACK_BIT_UPPER: new_ground = RAIL_GROUND_FENCE_HORIZ1; break;
 		MarkTileDirtyByTile(tile);
 	}
 }
-static uint32 GetTileTrackStatus_Track(TileIndex tile, TransportType mode)
+static uint32 GetTileTrackStatus_Track(TileIndex tile, TransportType mode, uint sub_mode)
 {
 	if (mode != TRANSPORT_RAIL) return 0;
 	switch (GetRailTileType(tile)) {
 		default: NOT_REACHED();
 			return (rails == TRACK_BIT_CROSS) ? ret | 0x40 : ret;
 		}
 		case RAIL_TILE_SIGNALS: {
 			uint32 ret = GetTrackBits(tile) * 0x101;
-			byte a;
+			byte a = GetPresentSignals(tile);
-			uint16 b;
+			uint b = GetSignalStates(tile);
-			a = _m[tile].m3;
-			b = _m[tile].m2;
 			b &= a;
 			/* When signals are not present (in neither
 			 * direction), we pretend them to be green. (So if
 			 * signals are only one way, the other way will
 			 * implicitely become `red' */
-			if ((a & 0xC0) == 0) b |= 0xC0;
+			if ((a & 0xC) == 0) b |= 0xC;
-			if ((a & 0x30) == 0) b |= 0x30;
+			if ((a & 0x3) == 0) b |= 0x3;
-			if ((b & 0x80) == 0) ret |= 0x10070000;
+			if ((b & 0x8) == 0) ret |= 0x10070000;
-			if ((b & 0x40) == 0) ret |= 0x07100000;
+			if ((b & 0x4) == 0) ret |= 0x07100000;
-			if ((b & 0x20) == 0) ret |= 0x20080000;
+			if ((b & 0x2) == 0) ret |= 0x20080000;
-			if ((b & 0x10) == 0) ret |= 0x08200000;
+			if ((b & 0x1) == 0) ret |= 0x08200000;
 			return ret;
 		}
 		case RAIL_TILE_DEPOT:    return AxisToTrackBits(DiagDirToAxis(GetRailDepotDirection(tile))) * 0x101;
 		case RAIL_TILE_NORMAL:
 			td->str = STR_1021_RAILROAD_TRACK;
 			break;
 		case RAIL_TILE_SIGNALS: {
-			const StringID signal_type[] = {
+			const StringID signal_type[4][4] = {
-				STR_RAILROAD_TRACK_WITH_NORMAL_SIGNALS,
+				{
-				STR_RAILROAD_TRACK_WITH_PRESIGNALS,
+					STR_RAILROAD_TRACK_WITH_NORMAL_SIGNALS,
-				STR_RAILROAD_TRACK_WITH_EXITSIGNALS,
+					STR_RAILROAD_TRACK_WITH_NORMAL_PRESIGNALS,
-				STR_RAILROAD_TRACK_WITH_COMBOSIGNALS
+					STR_RAILROAD_TRACK_WITH_NORMAL_EXITSIGNALS,
+					STR_RAILROAD_TRACK_WITH_NORMAL_COMBOSIGNALS
+				},
+				{
+					STR_RAILROAD_TRACK_WITH_NORMAL_PRESIGNALS,
+					STR_RAILROAD_TRACK_WITH_PRESIGNALS,
+					STR_RAILROAD_TRACK_WITH_PRE_EXITSIGNALS,
+					STR_RAILROAD_TRACK_WITH_PRE_COMBOSIGNALS
+				},
+				{
+					STR_RAILROAD_TRACK_WITH_NORMAL_EXITSIGNALS,
+					STR_RAILROAD_TRACK_WITH_PRE_EXITSIGNALS,
+					STR_RAILROAD_TRACK_WITH_EXITSIGNALS,
+					STR_RAILROAD_TRACK_WITH_EXIT_COMBOSIGNALS
+				},
+				{
+					STR_RAILROAD_TRACK_WITH_NORMAL_COMBOSIGNALS,
+					STR_RAILROAD_TRACK_WITH_PRE_COMBOSIGNALS,
+					STR_RAILROAD_TRACK_WITH_EXIT_COMBOSIGNALS,
+					STR_RAILROAD_TRACK_WITH_COMBOSIGNALS
+				}
 			};
-			td->str = signal_type[GetSignalType(tile)];
+			td->str = signal_type[GetSignalType(tile, TRACK_UPPER)][GetSignalType(tile, TRACK_LOWER)];
 			break;
 		}
 		case RAIL_TILE_DEPOT:
 			td->str = STR_1023_RAILROAD_TRAIN_DEPOT;
 	byte fract_coord;
 	byte fract_coord_leave;
 	DiagDirection dir;
 	int length;
-	// this routine applies only to trains in depot tiles
+	/* this routine applies only to trains in depot tiles */
 	if (v->type != VEH_TRAIN || !IsTileDepotType(tile, TRANSPORT_RAIL)) return VETSB_CONTINUE;
 	/* depot direction */
 	dir = GetRailDepotDirection(tile);

branch	NewGRF_ports
changeset 6719	4cc327ad39d5
parent 6694	a10a42eefd52
child 6720	35756db7e577