openttd-ottdgrfs: comparison src/rail

equal deleted inserted replaced

-:5a9dc001e1ad
+:1c4a4a609f85
 #include "openttd.h"
 #include "bridge_map.h"
 #include "bridge.h"
 #include "cmd_helper.h"
 #include "debug.h"
-#include "functions.h"
+#include "tile_cmd.h"
 #include "rail_map.h"
 #include "road_map.h"
-#include "table/sprites.h"
-#include "table/strings.h"
-#include "map.h"
 #include "landscape.h"
-#include "tile.h"
 #include "town_map.h"
 #include "tunnel_map.h"
-#include "vehicle.h"
+#include "viewport_func.h"
-#include "viewport.h"
+#include "command_func.h"
-#include "command.h"
 #include "pathfind.h"
 #include "engine.h"
 #include "town.h"
-#include "sound.h"
 #include "station.h"
 #include "sprite.h"
 #include "depot.h"
 #include "waypoint.h"
-#include "window.h"
 #include "rail.h"
-#include "railtypes.h" // include table for railtypes
 #include "newgrf.h"
 #include "yapf/yapf.h"
 #include "newgrf_engine.h"
 #include "newgrf_callbacks.h"
 #include "newgrf_station.h"
 #include "train.h"
 #include "misc/autoptr.hpp"
+#include "variables.h"
 #include "autoslope.h"
 #include "transparency.h"
 #include "water.h"
+#include "tunnelbridge_map.h"
+#include "window_func.h"
+#include "vehicle_func.h"
+#include "sound_func.h"
+#include "signal_func.h"
+#include "table/sprites.h"
+#include "table/strings.h"
+#include "table/railtypes.h"
 const byte _track_sloped_sprites[14] = {
 	14, 15, 22, 13,
 	 0, 21, 17, 12,
 	23,  0, 18, 20,
 *               01abcdef => rail w/ signals
 *               10uuuuuu => unused
 *               11uuuudd => rail depot
 */
-/** Struct used in EnsureNoTrainOnTrack() */
-struct TrainOnTrackData {
+void *EnsureNoTrainOnTrackProc(Vehicle *v, void *data)
-	TileIndex tile;       ///< tile to check
+{
-	uint z;               ///< tile max Z
+	TrackBits rail_bits = *(TrackBits *)data;
-	TrackBits rail_bits;  ///< trackbits of interest
-};
+	if (v->type != VEH_TRAIN) return NULL;
-static void *EnsureNoTrainOnTrackProc(Vehicle *v, void *data)
+	if ((v->u.rail.track != rail_bits) && !TracksOverlap(v->u.rail.track | rail_bits)) return NULL;
-{
-	const TrainOnTrackData *info = (const TrainOnTrackData *)data;
-	if (v->tile != info->tile || v->type != VEH_TRAIN) return NULL;
-	if (v->z_pos > info->z) return NULL;
-	if ((v->u.rail.track != info->rail_bits) && !TracksOverlap(v->u.rail.track | info->rail_bits)) return NULL;
 	_error_message = VehicleInTheWayErrMsg(v);
 	return v;
 }
 * @param tile The tile.
 * @param track The track.
 */
 static bool EnsureNoTrainOnTrack(TileIndex tile, Track track)
 {
-	TrainOnTrackData info;
+	TrackBits rail_bits = TrackToTrackBits(track);
-	info.tile = tile;
+	return VehicleFromPos(tile, &rail_bits, &EnsureNoTrainOnTrackProc) == NULL;
-	info.z = GetTileMaxZ(tile);
-	info.rail_bits = TrackToTrackBits(track);
-	return VehicleFromPos(tile, &info, EnsureNoTrainOnTrackProc) == NULL;
 }
 static bool CheckTrackCombination(TileIndex tile, TrackBits to_build, uint flags)
 {
 	TrackBits current; // The current track layout
 	if ((f_new == FOUNDATION_INVALID) ||
 	    ((f_new != FOUNDATION_NONE) && (!_patches.build_on_slopes || _is_old_ai_player))
 	   ) return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
 	Foundation f_old = GetRailFoundation(tileh, existing);
-	return CommandCost(f_new != f_old ? _price.terraform : (Money)0);
+	return CommandCost(EXPENSES_CONSTRUCTION, f_new != f_old ? _price.terraform : (Money)0);
 }
 /* Validate functions for rail building */
 static inline bool ValParamTrackOrientation(Track track) {return IsValidTrack(track);}
 * @param p2 rail track to build
 */
 CommandCost CmdBuildSingleRail(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	Slope tileh;
-	RailType railtype;
+	RailType railtype = (RailType)p1;
-	Track track;
+	Track track = (Track)p2;
 	TrackBits trackbit;
-	CommandCost cost;
+	CommandCost cost(EXPENSES_CONSTRUCTION);
 	CommandCost ret;
-	if (!ValParamRailtype(p1) || !ValParamTrackOrientation((Track)p2)) return CMD_ERROR;
+	if (!ValParamRailtype(railtype) || !ValParamTrackOrientation(track)) return CMD_ERROR;
-	railtype = (RailType)p1;
-	track = (Track)p2;
 	tileh = GetTileSlope(tile, NULL);
 	trackbit = TrackToTrackBits(track);
-	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	switch (GetTileType(tile)) {
 		case MP_RAILWAY:
 			if (!CheckTrackCombination(tile, trackbit, flags) ||
 					!EnsureNoTrainOnTrack(tile, track)) {
 				if ((track == TRACK_X && road == ROAD_Y) ||
 						(track == TRACK_Y && road == ROAD_X)) {
 					if (flags & DC_EXEC) {
 						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));
+						UpdateLevelCrossing(tile, false);
 					}
 					break;
 				}
 			}
 			break;
 	}
 	if (flags & DC_EXEC) {
 		MarkTileDirtyByTile(tile);
-		SetSignalsOnBothDir(tile, track);
+		AddTrackToSignalBuffer(tile, track, _current_player);
 		YapfNotifyTrackLayoutChange(tile, track);
 	}
 	return cost.AddCost(RailBuildCost(railtype));
 }
 */
 CommandCost CmdRemoveSingleRail(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	Track track = (Track)p2;
 	TrackBits trackbit;
-	CommandCost cost(_price.remove_rail);
+	CommandCost cost(EXPENSES_CONSTRUCTION, _price.remove_rail );
 	bool crossing = false;
 	if (!ValParamTrackOrientation((Track)p2)) return CMD_ERROR;
 	trackbit = TrackToTrackBits(track);
-	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
+	/* Need to read tile owner now because it may change when the rail is removed
+	 * Also, in case of floods, _current_player != owner
+	 * There may be invalid tiletype even in exec run (when removing long track),
+	 * so do not call GetTileOwner(tile) in any case here */
+	Owner owner = INVALID_OWNER;
 	switch (GetTileType(tile)) {
 		case MP_ROAD: {
 			if (!IsLevelCrossing(tile) ||
 					GetCrossingRailBits(tile) != trackbit ||
 					!EnsureNoVehicleOnGround(tile)) {
 				return CMD_ERROR;
 			}
 			if (flags & DC_EXEC) {
+				owner = GetTileOwner(tile);
 				MakeRoadNormal(tile, GetCrossingRoadBits(tile), GetRoadTypes(tile), GetTownIndex(tile), GetRoadOwner(tile, ROADTYPE_ROAD), GetRoadOwner(tile, ROADTYPE_TRAM), GetRoadOwner(tile, ROADTYPE_HWAY));
 			}
 			break;
 		}
 			/* Charge extra to remove signals on the track, if they are there */
 			if (HasSignalOnTrack(tile, track))
 				cost.AddCost(DoCommand(tile, track, 0, flags, CMD_REMOVE_SIGNALS));
 			if (flags & DC_EXEC) {
+				owner = GetTileOwner(tile);
 				present ^= trackbit;
 				if (present == 0) {
 					if (GetRailGroundType(tile) == RAIL_GROUND_WATER) {
 						MakeShore(tile);
 					} else {
 		default: return CMD_ERROR;
 	}
 	if (flags & DC_EXEC) {
+		/* if we got that far, 'owner' variable is set correctly */
+		assert(IsValidPlayer(owner));
 		MarkTileDirtyByTile(tile);
 		if (crossing) {
 			/* crossing is set when only TRACK_BIT_X and TRACK_BIT_Y are set. As we
 			 * are removing one of these pieces, we'll need to update signals for
 			 * both directions explicitly, as after the track is removed it won't
 			 * 'connect' with the other piece. */
-			SetSignalsOnBothDir(tile, TRACK_X);
+			AddTrackToSignalBuffer(tile, TRACK_X, owner);
-			SetSignalsOnBothDir(tile, TRACK_Y);
+			AddTrackToSignalBuffer(tile, TRACK_Y, owner);
 			YapfNotifyTrackLayoutChange(tile, TRACK_X);
 			YapfNotifyTrackLayoutChange(tile, TRACK_Y);
 		} else {
-			SetSignalsOnBothDir(tile, track);
+			AddTrackToSignalBuffer(tile, track, owner);
 			YapfNotifyTrackLayoutChange(tile, track);
 		}
 	}
 	return cost;
 /**
 * Called from water_cmd if a non-flat rail-tile gets flooded and should be converted to shore.
 * The function floods the lower halftile, if the tile has a halftile foundation.
 *
 * @param t The tile to flood.
-*/
+* @return true if something was flooded.
-void FloodHalftile(TileIndex t)
+*/
-{
+bool FloodHalftile(TileIndex t)
-	if (GetRailGroundType(t) == RAIL_GROUND_WATER) return;
+{
+	bool flooded = false;
+	if (GetRailGroundType(t) == RAIL_GROUND_WATER) return flooded;
 	Slope tileh = GetTileSlope(t, NULL);
 	TrackBits rail_bits = GetTrackBits(t);
 	if (!IsSteepSlope(tileh) && HasSlopeHighestCorner(tileh)) {
 		TrackBits lower_track = CornerToTrackBits(OppositeCorner(GetHighestSlopeCorner(tileh)));
 		TrackBits to_remove = lower_track & rail_bits;
 		if (to_remove != 0) {
 			_current_player = OWNER_WATER;
-			if (CmdFailed(DoCommand(t, 0, FIND_FIRST_BIT(to_remove), DC_EXEC, CMD_REMOVE_SINGLE_RAIL))) return; // not yet floodable
+			if (CmdFailed(DoCommand(t, 0, FIND_FIRST_BIT(to_remove), DC_EXEC, CMD_REMOVE_SINGLE_RAIL))) return flooded; // not yet floodable
+			flooded = true;
 			rail_bits = rail_bits & ~to_remove;
 			if (rail_bits == 0) {
 				MakeShore(t);
 				MarkTileDirtyByTile(t);
-				return;
+				return flooded;
 			}
 		}
 		if (IsNonContinuousFoundation(GetRailFoundation(tileh, rail_bits))) {
+			flooded = true;
 			SetRailGroundType(t, RAIL_GROUND_WATER);
 			MarkTileDirtyByTile(t);
 		}
 	}
+	return flooded;
 }
 static const TileIndexDiffC _trackdelta[] = {
 	{ -1,  0 }, {  0,  1 }, { -1,  0 }, {  0,  1 }, {  1,  0 }, {  0,  1 },
 	{  0,  0 },
 * - p2 = (bit 4-6) - track-orientation, valid values: 0-5 (Track enum)
 * - p2 = (bit 7)   - 0 = build, 1 = remove tracks
 */
 static CommandCost CmdRailTrackHelper(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
-	CommandCost ret, total_cost;
+	CommandCost ret, total_cost(EXPENSES_CONSTRUCTION);
 	Track track = (Track)GB(p2, 4, 3);
 	Trackdir trackdir;
 	byte mode = HasBit(p2, 7);
 	RailType railtype = (RailType)GB(p2, 0, 4);
 	TileIndex end_tile;
 	if (!ValParamRailtype(railtype) || !ValParamTrackOrientation(track)) return CMD_ERROR;
 	if (p1 >= MapSize()) return CMD_ERROR;
 	end_tile = p1;
 	trackdir = TrackToTrackdir(track);
-	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	if (CmdFailed(ValidateAutoDrag(&trackdir, tile, end_tile))) return CMD_ERROR;
 	if (flags & DC_EXEC) SndPlayTileFx(SND_20_SPLAT_2, tile);
 * @todo When checking for the tile slope,
 * distingush between "Flat land required" and "land sloped in wrong direction"
 */
 CommandCost CmdBuildTrainDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
-	CommandCost cost;
 	Slope tileh;
-	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	/* check railtype and valid direction for depot (0 through 3), 4 in total */
-	if (!ValParamRailtype(p1)) return CMD_ERROR;
+	if (!ValParamRailtype((RailType)p1)) return CMD_ERROR;
 	tileh = GetTileSlope(tile, NULL);
 	DiagDirection dir = Extract<DiagDirection, 0>(p2);
 				!CanBuildDepotByTileh(dir, tileh)
 			)) {
 		return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);
 	}
-	cost = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
+	CommandCost cost = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 	if (CmdFailed(cost)) return CMD_ERROR;
 	if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
 	Depot *d = new Depot(tile);
 		MakeRailDepot(tile, _current_player, dir, (RailType)p1);
 		MarkTileDirtyByTile(tile);
 		d->town_index = ClosestTownFromTile(tile, (uint)-1)->index;
-		UpdateSignalsOnSegment(tile, dir);
+		AddSideToSignalBuffer(tile, INVALID_DIAGDIR, _current_player);
 		YapfNotifyTrackLayoutChange(tile, TrackdirToTrack(DiagdirToDiagTrackdir(dir)));
 		d_auto_delete.Detach();
 	}
 	return cost.AddCost(_price.build_train_depot);
 	}
 	/* you can not convert a signal if no signal is on track */
 	if (convert_signal && !HasSignalOnTrack(tile, track)) return CMD_ERROR;
-	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	if (!HasSignalOnTrack(tile, track)) {
 		/* build new signals */
-		cost = CommandCost(_price.build_signals);
+		cost = CommandCost(EXPENSES_CONSTRUCTION, _price.build_signals);
 	} else {
 		if (p2 != 0 && sigvar != GetSignalVariant(tile, track)) {
 			/* convert signals <-> semaphores */
-			cost = CommandCost(_price.build_signals + _price.remove_signals);
+			cost = CommandCost(EXPENSES_CONSTRUCTION, _price.build_signals + _price.remove_signals);
 		} else if (convert_signal) {
 			/* convert button pressed */
 			if (ctrl_pressed || GetSignalVariant(tile, track) != sigvar) {
 				/* convert electric <-> semaphore */
-				cost = CommandCost(_price.build_signals + _price.remove_signals);
+				cost = CommandCost(EXPENSES_CONSTRUCTION, _price.build_signals + _price.remove_signals);
 			} else {
 				/* it is free to change signal type: normal-pre-exit-combo */
 				cost = CommandCost();
 			}
 			SetPresentSignals(tile, (GetPresentSignals(tile) & ~SignalOnTrack(track)) | (p2 & SignalOnTrack(track)));
 			SetSignalVariant(tile, track, sigvar);
 		}
 		MarkTileDirtyByTile(tile);
-		SetSignalsOnBothDir(tile, track);
+		AddTrackToSignalBuffer(tile, track, _current_player);
 		YapfNotifyTrackLayoutChange(tile, track);
 	}
 	return cost;
 }
 			if (!IsLevelCrossing(tile)) return false;
 			signal_ctr += 2;
 			return true;
 		case MP_TUNNELBRIDGE: {
-			TileIndex orig_tile = tile;
+			TileIndex orig_tile = tile; // backup old value
-			/* Skip to end of tunnel or bridge */
-			if (IsBridge(tile)) {
+			if (GetTunnelBridgeTransportType(tile) != TRANSPORT_RAIL) return false;
-				if (GetBridgeTransportType(tile) != TRANSPORT_RAIL) return false;
+			if (GetTunnelBridgeDirection(tile) != TrackdirToExitdir(trackdir)) return false;
-				if (GetBridgeRampDirection(tile) != TrackdirToExitdir(trackdir)) return false;
-				tile = GetOtherBridgeEnd(tile);
+			/* Skip to end of tunnel or bridge
-			} else {
+			 * note that tile is a parameter by reference, so it must be updated */
-				if (GetTunnelTransportType(tile) != TRANSPORT_RAIL) return false;
+			tile = GetOtherTunnelBridgeEnd(tile);
-				if (GetTunnelDirection(tile) != TrackdirToExitdir(trackdir)) return false;
-				tile = GetOtherTunnelEnd(tile);
-			}
 			signal_ctr += 2 + DistanceMax(orig_tile, tile) * 2;
 			return true;
 		}
 		default: return false;
 * - p2 = (bit  6)    - 0 = selected stretch, 1 = auto fill
 * - p2 = (bit 24-31) - user defined signals_density
 */
 static CommandCost CmdSignalTrackHelper(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
-	CommandCost ret, total_cost;
+	CommandCost ret, total_cost(EXPENSES_CONSTRUCTION);
 	int signal_ctr;
 	byte signals;
 	bool error = true;
 	TileIndex end_tile;
 	TileIndex start_tile = tile;
 	if (p1 >= MapSize()) return CMD_ERROR;
 	end_tile = p1;
 	if (signal_density == 0 || signal_density > 20) return CMD_ERROR;
 	if (!IsTileType(tile, MP_RAILWAY)) return CMD_ERROR;
-	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	/* for vertical/horizontal tracks, double the given signals density
 	 * since the original amount will be too dense (shorter tracks) */
 	signal_density *= 2;
 	}
 	/* Only water can remove signals from anyone */
 	if (_current_player != OWNER_WATER && !CheckTileOwnership(tile)) return CMD_ERROR;
-	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	/* Do it? */
 	if (flags & DC_EXEC) {
 		SetPresentSignals(tile, GetPresentSignals(tile) & ~SignalOnTrack(track));
 		/* removed last signal from tile? */
 			SetSignalStates(tile, 0);
 			SetHasSignals(tile, false);
 			SetSignalVariant(tile, INVALID_TRACK, SIG_ELECTRIC); // remove any possible semaphores
 		}
-		SetSignalsOnBothDir(tile, track);
+		AddTrackToSignalBuffer(tile, track, GetTileOwner(tile));
 		YapfNotifyTrackLayoutChange(tile, track);
 		MarkTileDirtyByTile(tile);
 	}
-	return CommandCost(_price.remove_signals);
+	return CommandCost(EXPENSES_CONSTRUCTION, _price.remove_signals);
 }
 /** Remove signals on a stretch of track.
 * Stub for the unified signal builder/remover
 * @param tile start tile of drag
 CommandCost CmdRemoveSignalTrack(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	return CmdSignalTrackHelper(tile, flags, p1, SetBit(p2, 5)); // bit 5 is remove bit
 }
-typedef CommandCost DoConvertRailProc(TileIndex tile, RailType totype, bool exec);
+/** Update power of train under which is the railtype being converted */
 void *UpdateTrainPowerProc(Vehicle *v, void *data)
 {
 	/* Similiar checks as in TrainPowerChanged() */
-	if (v->type == VEH_TRAIN && v->tile == *(TileIndex*)data && !IsArticulatedPart(v)) {
+	if (v->type == VEH_TRAIN && !IsArticulatedPart(v)) {
 		const RailVehicleInfo *rvi = RailVehInfo(v->engine_type);
 		if (GetVehicleProperty(v, 0x0B, rvi->power) != 0) TrainPowerChanged(v->First());
 	}
 	return NULL;
 }
-/**
-* Switches the rail type.
-* Railtypes are stored on a per-tile basis, not on a per-track basis, so
-* all the tracks in the given tile will be converted.
-* @param tile        The tile on which the railtype is to be convert.
-* @param totype      The railtype we want to convert to
-* @param exec        Switches between test and execute mode
-* @return            The cost and state of the operation
-* @retval CMD_ERROR  An error occured during the operation.
-*/
-static CommandCost DoConvertRail(TileIndex tile, RailType totype, bool exec)
-{
-	/* change type. */
-	if (exec) {
-		SetRailType(tile, totype);
-		MarkTileDirtyByTile(tile);
-		/* notify YAPF about the track layout change */
-		TrackBits tracks = GetTrackBits(tile);
-		while (tracks != TRACK_BIT_NONE) {
-			YapfNotifyTrackLayoutChange(tile, RemoveFirstTrack(&tracks));
-		}
-		if (IsTileDepotType(tile, TRANSPORT_RAIL)) {
-			/* Update build vehicle window related to this depot */
-			InvalidateWindowData(WC_VEHICLE_DEPOT, tile);
-			InvalidateWindowData(WC_BUILD_VEHICLE, tile);
-		}
-		/* update power of train engines on this tile */
-		VehicleFromPos(tile, &tile, UpdateTrainPowerProc);
-	}
-	return CommandCost(RailBuildCost(totype) / 2);
-}
-extern CommandCost DoConvertStationRail(TileIndex tile, RailType totype, bool exec);
-extern CommandCost DoConvertStreetRail(TileIndex tile, RailType totype, bool exec);
-extern CommandCost 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
 */
 CommandCost CmdConvertRail(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
-	CommandCost ret, cost;
+	CommandCost cost(EXPENSES_CONSTRUCTION);
-	Money money;
+	RailType totype = (RailType)p2;
-	int ex;
-	int ey;
+	if (!ValParamRailtype(totype)) return CMD_ERROR;
-	int sx, sy, x, y;
-	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
-	if (!ValParamRailtype(p2)) return CMD_ERROR;
 	if (p1 >= MapSize()) return CMD_ERROR;
+	uint ex = TileX(tile);
+	uint ey = TileY(tile);
+	uint sx = TileX(p1);
+	uint sy = TileY(p1);
 	/* 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);
 	if (ey < sy) Swap(ey, sy);
-	money = GetAvailableMoneyForCommand();
+	_error_message = STR_1005_NO_SUITABLE_RAILROAD_TRACK; // by default, there is no track to convert
-	for (x = sx; x <= ex; ++x) {
+	for (uint x = sx; x <= ex; ++x) {
-		for (y = sy; y <= ey; ++y) {
+		for (uint y = sy; y <= ey; ++y) {
 			TileIndex tile = TileXY(x, y);
-			DoConvertRailProc *proc;
+			TileType tt = GetTileType(tile);
-			RailType totype = (RailType)p2;
+			/* Check if there is any track on tile */
-			switch (GetTileType(tile)) {
+			switch (tt) {
-				case MP_RAILWAY:      proc = DoConvertRail;             break;
+				case MP_RAILWAY:
-				case MP_STATION:      proc = DoConvertStationRail;      break;
+					break;
-				case MP_ROAD:         proc = DoConvertStreetRail;       break;
+				case MP_STATION:
-				case MP_TUNNELBRIDGE: proc = DoConvertTunnelBridgeRail; break;
+					if (!IsRailwayStation(tile)) continue;
+					break;
+				case MP_ROAD:
+					if (!IsLevelCrossing(tile)) continue;
+					break;
+				case MP_TUNNELBRIDGE:
+					if (GetTunnelBridgeTransportType(tile) != TRANSPORT_RAIL) continue;
+					break;
 				default: continue;
 			}
-			/* It is possible that 'type' is invalid when there is no rail on the tile,
+			/* Original railtype we are converting from */
-			 * but this situation will be detected in proc()
-			 */
 			RailType type = GetRailType(tile);
-			/* Not own tile or track is already converted */
+			/* Converting to the same type or converting 'hidden' elrail -> rail */
-			if ((!CheckTileOwnership(tile) || type == totype) ||
+			if (type == totype || (_patches.disable_elrails && totype == RAILTYPE_RAIL && type == RAILTYPE_ELECTRIC)) continue;
-				/* 'hidden' elrails can't be downgraded to normal rail when elrails are disabled */
-				(_patches.disable_elrails && totype == RAILTYPE_RAIL && type == RAILTYPE_ELECTRIC) ||
+			/* Trying to convert other's rail */
-				/* Vehicle on a tile while not converting Rail <-> ElRail */
+			if (!CheckTileOwnership(tile)) continue;
-				(!IsCompatibleRail(type, totype) && !EnsureNoVehicleOnGround(tile))) {
-					ret = CMD_ERROR;
+			/* Vehicle on the tile when not converting Rail <-> ElRail
-					continue;
+			 * Tunnels and bridges have special check later */
-			}
+			if (tt != MP_TUNNELBRIDGE) {
+				if (!IsCompatibleRail(type, totype) && !EnsureNoVehicleOnGround(tile)) continue;
-			ret = proc(tile, totype, false);
+				if (flags & DC_EXEC) { // we can safely convert, too
-			if (CmdFailed(ret)) continue;
+					SetRailType(tile, totype);
+					MarkTileDirtyByTile(tile);
-			if (flags & DC_EXEC) {
+					/* update power of train engines on this tile */
-				money -= ret.GetCost();
+					VehicleFromPos(tile, NULL, &UpdateTrainPowerProc);
-				if (money < 0) {
-					_additional_cash_required = ret.GetCost();
-					return cost;
 				}
-				proc(tile, totype, true);
+			}
-			}
-			cost.AddCost(ret);
+			switch (tt) {
-		}
+				case MP_RAILWAY:
-	}
+					switch (GetRailTileType(tile)) {
+						case RAIL_TILE_WAYPOINT:
-	return (cost.GetCost() == 0) ? ret : cost;
+							if (flags & DC_EXEC) {
+								/* notify YAPF about the track layout change */
+								YapfNotifyTrackLayoutChange(tile, AxisToTrack(GetWaypointAxis(tile)));
+							}
+							cost.AddCost(RailConvertCost(type, totype));
+							break;
+						case RAIL_TILE_DEPOT:
+							if (flags & DC_EXEC) {
+								/* notify YAPF about the track layout change */
+								YapfNotifyTrackLayoutChange(tile, AxisToTrack(DiagDirToAxis(GetRailDepotDirection(tile))));
+								/* Update build vehicle window related to this depot */
+								InvalidateWindowData(WC_VEHICLE_DEPOT, tile);
+								InvalidateWindowData(WC_BUILD_VEHICLE, tile);
+							}
+							cost.AddCost(RailConvertCost(type, totype));
+							break;
+						default: // RAIL_TILE_NORMAL, RAIL_TILE_SIGNALS
+							if (flags & DC_EXEC) {
+								/* notify YAPF about the track layout change */
+								TrackBits tracks = GetTrackBits(tile);
+								while (tracks != TRACK_BIT_NONE) {
+									YapfNotifyTrackLayoutChange(tile, RemoveFirstTrack(&tracks));
+								}
+							}
+							cost.AddCost(RailConvertCost(type, totype) * CountBits(GetTrackBits(tile)));
+							break;
+					}
+					break;
+				case MP_TUNNELBRIDGE: {
+					TileIndex endtile = GetOtherTunnelBridgeEnd(tile);
+					/* If both ends of tunnel/bridge are in the range, do not try to convert twice -
+					 * it would cause assert because of different test and exec runs */
+					if (endtile < tile && TileX(endtile) >= sx && TileX(endtile) <= ex &&
+							TileY(endtile) >= sy && TileY(endtile) <= ey) continue;
+					/* When not coverting rail <-> el. rail, any vehicle cannot be in tunnel/bridge */
+					if (!IsCompatibleRail(GetRailType(tile), totype) &&
+							GetVehicleTunnelBridge(tile, endtile) != NULL) continue;
+					if (flags & DC_EXEC) {
+						SetRailType(tile, totype);
+						SetRailType(endtile, totype);
+						VehicleFromPos(tile, NULL, &UpdateTrainPowerProc);
+						VehicleFromPos(endtile, NULL, &UpdateTrainPowerProc);
+						Track track = AxisToTrack(DiagDirToAxis(GetTunnelBridgeDirection(tile)));
+						YapfNotifyTrackLayoutChange(tile, track);
+						YapfNotifyTrackLayoutChange(endtile, track);
+						MarkTileDirtyByTile(tile);
+						MarkTileDirtyByTile(endtile);
+						if (IsBridge(tile)) {
+							TileIndexDiff delta = TileOffsByDiagDir(GetTunnelBridgeDirection(tile));
+							TileIndex t = tile + delta;
+							for (; t != endtile; t += delta) MarkTileDirtyByTile(t); // TODO encapsulate this into a function
+						}
+					}
+					cost.AddCost((DistanceManhattan(tile, endtile) + 1) * RailConvertCost(type, totype));
+				} break;
+				default: // MP_STATION, MP_ROAD
+					if (flags & DC_EXEC) {
+						Track track = (tt == MP_STATION) ? GetRailStationTrack(tile) : AxisToTrack(OtherAxis(GetCrossingRoadAxis(tile)));
+						YapfNotifyTrackLayoutChange(tile, track);
+					}
+					cost.AddCost(RailConvertCost(type, totype));
+					break;
+			}
+		}
+	}
+	return (cost.GetCost() == 0) ? CMD_ERROR : cost;
 }
 static CommandCost RemoveTrainDepot(TileIndex tile, uint32 flags)
 {
 	if (!CheckTileOwnership(tile) && _current_player != OWNER_WATER)
 	if (!EnsureNoVehicleOnGround(tile))
 		return CMD_ERROR;
 	if (flags & DC_EXEC) {
+		/* read variables before the depot is removed */
 		DiagDirection dir = GetRailDepotDirection(tile);
+		Owner owner = GetTileOwner(tile);
 		DoClearSquare(tile);
 		delete GetDepotByTile(tile);
-		UpdateSignalsOnSegment(tile, dir);
+		AddSideToSignalBuffer(tile, dir, owner);
 		YapfNotifyTrackLayoutChange(tile, TrackdirToTrack(DiagdirToDiagTrackdir(dir)));
 	}
-	return CommandCost(_price.remove_train_depot);
+	return CommandCost(EXPENSES_CONSTRUCTION, _price.remove_train_depot);
 }
 static CommandCost ClearTile_Track(TileIndex tile, byte flags)
 {
-	CommandCost cost;
+	CommandCost cost(EXPENSES_CONSTRUCTION);
 	CommandCost ret;
 	if (flags & DC_AUTO) {
 		if (!IsTileOwner(tile, _current_player))
 			return_cmd_error(STR_1024_AREA_IS_OWNED_BY_ANOTHER);
 				image += rti->total_offset;
 			} else {
 				image += relocation;
 			}
-			if (!IsTransparencySet(TO_BUILDINGS) && HasBit(image, PALETTE_MODIFIER_COLOR)) {
+			if (!(!HasBit(image, SPRITE_MODIFIER_OPAQUE) && IsTransparencySet(TO_BUILDINGS)) && HasBit(image, PALETTE_MODIFIER_COLOR)) {
 				pal = _drawtile_track_palette;
 			} else {
 				pal = dtss->pal;
 			}
 				AddSortableSpriteToDraw(
 					image, pal,
 					ti->x + dtss->delta_x, ti->y + dtss->delta_y,
 					dtss->size_x, dtss->size_y,
 					dtss->size_z, ti->z + dtss->delta_z,
-					IsTransparencySet(TO_BUILDINGS)
+					!HasBit(image, SPRITE_MODIFIER_OPAQUE) && IsTransparencySet(TO_BUILDINGS)
 				);
 			} else {
 				AddChildSpriteScreen(image, pal, dtss->delta_x, dtss->delta_y);
 			}
 		}
 {
 	uint32 offset = GetRailTypeInfo(railtype)->total_offset;
 	const DrawTileSprites* dts = &_waypoint_gfx_table[AXIS_X];
 	DrawTileSequence(x, y, dts->ground_sprite + offset, dts->seq, 0);
-}
-struct SetSignalsData {
-	int cur;
-	int cur_stack;
-	bool stop;
-	bool has_presignal;
-	/* presignal info */
-	int presignal_exits;
-	int presignal_exits_free;
-	/* 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 */
-	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? */
-	if (HasSignalOnTrack(tile, track)) {
-		if (HasSignalOnTrackdir(tile, ReverseTrackdir(trackdir))) {
-			/* 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. */
-			ssd->has_presignal |= IsPresignalEntry(tile, track);
-		}
-		if (HasSignalOnTrackdir(tile, trackdir) && IsPresignalExit(tile, track)) {
-			/* 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++;
-		}
-		return true;
-	} else if (IsTileDepotType(tile, TRANSPORT_RAIL)) {
-		return true; // don't look further if the tile is a depot
-	}
-	return false;
-}
-/* Struct to parse data from VehicleFromPos to SignalVehicleCheckProc */
-struct SignalVehicleCheckStruct {
-	TileIndex tile;
-	uint track;
-};
-static void *SignalVehicleCheckProc(Vehicle *v, void *data)
-{
-	const SignalVehicleCheckStruct* dest = (SignalVehicleCheckStruct*)data;
-	if (v->type != VEH_TRAIN) return NULL;
-	/* Wrong tile, or no train? Not a match */
-	if (v->tile != dest->tile) return NULL;
-	/* Are we on the same piece of track? */
-	if (dest->track & v->u.rail.track * 0x101) return v;
-	return NULL;
-}
-/* Special check for SetSignalsAfterProc, to see if there is a vehicle on this tile */
-static bool SignalVehicleCheck(TileIndex tile, uint track)
-{
-	SignalVehicleCheckStruct dest;
-	dest.tile = tile;
-	dest.track = track;
-	/* Locate vehicles in tunnels or on bridges */
-	if (IsTunnelTile(tile) || IsBridgeTile(tile)) {
-		TileIndex end;
-		DiagDirection direction;
-		if (IsTunnelTile(tile)) {
-			end = GetOtherTunnelEnd(tile);
-			direction = GetTunnelDirection(tile);
-		} else {
-			end = GetOtherBridgeEnd(tile);
-			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 */
-		if (VehicleFromPos(tile, &dest, SignalVehicleCheckProc) != NULL) return true;
-		/* 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 */
-		dest.track = 0x40;   //Vehicle inside a tunnel or on a bridge
-		if (VehicleFromPos(tile, &dest, SignalVehicleCheckProc) != NULL) return true;
-		if (VehicleFromPos(end, &dest, SignalVehicleCheckProc) != NULL) return true;
-		/* no vehicle found */
-		return false;
-	}
-	return VehicleFromPos(tile, &dest, SignalVehicleCheckProc) != NULL;
-}
-static void SetSignalsAfterProc(TrackPathFinder *tpf)
-{
-	SetSignalsData *ssd = (SetSignalsData*)tpf->userdata;
-	const TrackPathFinderLink* link;
-	uint offs;
-	uint i;
-	ssd->stop = false;
-	/* Go through all the PF tiles */
-	for (i = 0; i < lengthof(tpf->hash_head); i++) {
-		/* Empty hash item */
-		if (tpf->hash_head[i] == 0) continue;
-		/* If 0x8000 is not set, there is only 1 item */
-		if (!(tpf->hash_head[i] & 0x8000)) {
-			/* Check if there is a vehicle on this tile */
-			if (SignalVehicleCheck(tpf->hash_tile[i], tpf->hash_head[i])) {
-				ssd->stop = true;
-				return;
-			}
-		} else {
-			/* There are multiple items, where hash_tile points to the first item in the list */
-			offs = tpf->hash_tile[i];
-			do {
-				/* Find the next item */
-				link = PATHFIND_GET_LINK_PTR(tpf, offs);
-				/* Check if there is a vehicle on this tile */
-				if (SignalVehicleCheck(link->tile, link->flags)) {
-					ssd->stop = true;
-					return;
-				}
-				/* Goto the next item */
-			} while ((offs = link->next) != 0xFFFF);
-		}
-	}
-}
-static void ChangeSignalStates(SetSignalsData *ssd)
-{
-	int i;
-	/* thinking about presignals...
-	 * the presignal is green if,
-	 *   if no train is in the segment AND
-	 *   there is at least one green exit signal OR
-	 *   there are no exit signals in the segment */
-	/* 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]);
-		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, track)) {
-			int ex = ssd->presignal_exits, exfree = ssd->presignal_exits_free;
-			/* subtract for dual combo signals so they don't count themselves */
-			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 (ex && !exfree) goto make_red;
-		}
-		/* check if the signal is unaffected. */
-		if (ssd->stop) {
-make_red:
-			/* turn red */
-			if ((bit & signals) == 0) continue;
-		} else {
-			/* turn green */
-			if ((bit & signals) != 0) continue;
-		}
-		/* Update signals on the other side of this exit-combo signal; it changed. */
-		if (IsPresignalExit(tile, track)) {
-			if (ssd->cur_stack != NUM_SSD_STACK) {
-				ssd->next_tile[ssd->cur_stack] = tile;
-				ssd->next_dir[ssd->cur_stack] = TrackdirToExitdir(ssd->bit[i]);
-				ssd->cur_stack++;
-			} else {
-				DEBUG(misc, 0, "NUM_SSD_STACK too small"); /// @todo WTF is this???
-			}
-		}
-		/* it changed, so toggle it */
-		SetSignalStates(tile, signals ^ bit);
-		MarkTileDirtyByTile(tile);
-	}
-}
-bool UpdateSignalsOnSegment(TileIndex tile, DiagDirection direction)
-{
-	SetSignalsData ssd;
-	int result = -1;
-	ssd.cur_stack = 0;
-	for (;;) {
-		/* 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, 0, direction, SetSignalsEnumProc, SetSignalsAfterProc, &ssd);
-		ChangeSignalStates(&ssd);
-		/* 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 */
-			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 (ssd.cur_stack == 0) break;
-		/* 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;
-}
-void SetSignalsOnBothDir(TileIndex tile, byte track)
-{
-	static const DiagDirection _search_dir_1[] = {
-		DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE
-	};
-	static const DiagDirection _search_dir_2[] = {
-		DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE
-	};
-	UpdateSignalsOnSegment(tile, _search_dir_1[track]);
-	UpdateSignalsOnSegment(tile, _search_dir_2[track]);
 }
 static uint GetSlopeZ_Track(TileIndex tile, uint x, uint y)
 {
 	uint z;
 static const signed char _deltacoord_leaveoffset[8] = {
 	-1,  0,  1,  0, /* x */
 	 0,  1,  0, -1  /* y */
 };
-static uint32 VehicleEnter_Track(Vehicle *v, TileIndex tile, int x, int y)
+static VehicleEnterTileStatus VehicleEnter_Track(Vehicle *v, TileIndex tile, int x, int y)
 {
 	byte fract_coord;
 	byte fract_coord_leave;
 	DiagDirection dir;
 	int length;
 		case TRACK_BIT_LOWER: track_corner = CORNER_S; break;
 		case TRACK_BIT_RIGHT: track_corner = CORNER_E; break;
 		case TRACK_BIT_UPPER: track_corner = CORNER_N; break;
 		/* Surface slope must not be changed */
-		default: return (((z_old != z_new) || (tileh_old != tileh_new)) ? CMD_ERROR : _price.terraform);
+		default: return (((z_old != z_new) || (tileh_old != tileh_new)) ? CMD_ERROR : CommandCost(EXPENSES_CONSTRUCTION, _price.terraform));
 	}
 	/* The height of the track_corner must not be changed. The rest ensures GetRailFoundation() already. */
 	z_old += GetSlopeZInCorner((Slope)(tileh_old & ~SLOPE_HALFTILE_MASK), track_corner);
 	z_new += GetSlopeZInCorner((Slope)(tileh_new & ~SLOPE_HALFTILE_MASK), track_corner);
 	if (z_old != z_new) return CMD_ERROR;
-	CommandCost cost = CommandCost(_price.terraform);
+	CommandCost cost = CommandCost(EXPENSES_CONSTRUCTION, _price.terraform);
 	/* Make the ground dirty, if surface slope has changed */
 	if (tileh_old != tileh_new) {
 		if (GetRailGroundType(tile) == RAIL_GROUND_WATER) cost.AddCost(_price.clear_water);
 		if ((flags & DC_EXEC) != 0) SetRailGroundType(tile, RAIL_GROUND_BARREN);
 	}
 		/* Make the ground dirty */
 		if ((flags & DC_EXEC) != 0) SetRailGroundType(tile, RAIL_GROUND_BARREN);
 		/* allow terraforming */
-		return (was_water ? CommandCost(_price.clear_water) : CommandCost());
+		return CommandCost(EXPENSES_CONSTRUCTION, was_water ? _price.clear_water : (Money)0);
 	} else {
 		if (_patches.build_on_slopes && AutoslopeEnabled()) {
 			switch (GetRailTileType(tile)) {
 				case RAIL_TILE_WAYPOINT: {
 					CommandCost cost = TestAutoslopeOnRailTile(tile, flags, z_old, tileh_old, z_new, tileh_new, GetRailWaypointBits(tile));
 					if (!CmdFailed(cost)) return cost; // allow autoslope
 					break;
 				}
 				case RAIL_TILE_DEPOT:
-					if (AutoslopeCheckForEntranceEdge(tile, z_new, tileh_new, GetRailDepotDirection(tile))) return _price.terraform;
+					if (AutoslopeCheckForEntranceEdge(tile, z_new, tileh_new, GetRailDepotDirection(tile))) return CommandCost(EXPENSES_CONSTRUCTION, _price.terraform);
 					break;
 				default: NOT_REACHED();
 			}
 		}

branch	NewGRF_ports
changeset 6872	1c4a4a609f85
parent 6871	5a9dc001e1ad
child 6877	889301acc299