openttd-ottdgrfs: comparison src/tunnelbridge

equal deleted inserted replaced

-:5a8b295aa345
+:4cc327ad39d5
 };
 Bridge _bridge[MAX_BRIDGES];
-// calculate the price factor for building a long bridge.
+/** calculate the price factor for building a long bridge.
-// basically the cost delta is 1,1, 1, 2,2, 3,3,3, 4,4,4,4, 5,5,5,5,5, 6,6,6,6,6,6,  7,7,7,7,7,7,7,  8,8,8,8,8,8,8,8,
+* basically the cost delta is 1,1, 1, 2,2, 3,3,3, 4,4,4,4, 5,5,5,5,5, 6,6,6,6,6,6,  7,7,7,7,7,7,7,  8,8,8,8,8,8,8,8,
+*/
 int CalcBridgeLenCostFactor(int x)
 {
 	int n;
 	int r;
 	}
 }
 #define M(x) (1 << (x))
 enum BridgeFoundation {
-	// foundation, whole tile is leveled up --> 3 corners raised
+	/* foundation, whole tile is leveled up --> 3 corners raised */
 	BRIDGE_FULL_LEVELED_FOUNDATION = M(SLOPE_WSE) | M(SLOPE_NWS) | M(SLOPE_ENW) | M(SLOPE_SEN),
-	// foundation, tile is partly leveled up --> 1 corner raised
+	/* foundation, tile is partly leveled up --> 1 corner raised */
 	BRIDGE_PARTLY_LEVELED_FOUNDATION = M(SLOPE_W) | M(SLOPE_S) | M(SLOPE_E) | M(SLOPE_N),
-	// no foundations (X,Y direction)
+	/* no foundations (X,Y direction) */
 	BRIDGE_NO_FOUNDATION = M(SLOPE_FLAT) | M(SLOPE_SW) | M(SLOPE_SE) | M(SLOPE_NW) | M(SLOPE_NE),
 	BRIDGE_HORZ_RAMP = (BRIDGE_PARTLY_LEVELED_FOUNDATION | BRIDGE_NO_FOUNDATION) & ~M(SLOPE_FLAT)
 };
 #undef M
 	return b->min_length <= bridge_len && bridge_len <= max;
 }
 /** Build a Bridge
 * @param end_tile end tile
+* @param flags type of operation
 * @param p1 packed start tile coords (~ dx)
 * @param p2 various bitstuffed elements
 * - p2 = (bit 0- 7) - bridge type (hi bh)
-* - p2 = (bit 8-..) - rail type. bit15 ((x>>8)&0x80) means road bridge.
+* - p2 = (bit 8-..) - rail type or road types.
+* - p2 = (bit 15  ) - set means road bridge.
 */
 int32 CmdBuildBridge(TileIndex end_tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	uint bridge_type;
 	RailType railtype;
+	RoadTypes roadtypes;
 	uint x;
 	uint y;
 	uint sx;
 	uint sy;
 	TileIndex tile_start;
 	/* unpack parameters */
 	bridge_type = GB(p2, 0, 8);
 	if (p1 >= MapSize()) return CMD_ERROR;
-	// type of bridge
+	/* type of bridge */
 	if (HASBIT(p2, 15)) {
 		railtype = INVALID_RAILTYPE; // road bridge
+		roadtypes = (RoadTypes)GB(p2, 8, 3);
+		if (!AreValidRoadTypes(roadtypes)) return CMD_ERROR;
 	} else {
 		if (!ValParamRailtype(GB(p2, 8, 8))) return CMD_ERROR;
 		railtype = (RailType)GB(p2, 8, 8);
+		roadtypes = ROADTYPES_NONE;
 	}
 	x = TileX(end_tile);
 	y = TileY(end_tile);
 	sx = TileX(p1);
 		tileh_end = SLOPE_FLAT;
 	}
 	if (z_start != z_end) return_cmd_error(STR_5009_LEVEL_LAND_OR_WATER_REQUIRED);
-	// Towns are not allowed to use bridges on slopes.
+	/* Towns are not allowed to use bridges on slopes. */
 	allow_on_slopes = (!_is_old_ai_player
 	                   && _current_player != OWNER_TOWN && _patches.build_on_slopes);
 	TransportType transport_type = railtype == INVALID_RAILTYPE ? TRANSPORT_ROAD : TRANSPORT_RAIL;
 		}
 		cost = (bridge_len + 1) * _price.clear_bridge; // The cost of clearing the current bridge.
 		replace_bridge = true;
 		replaced_bridge_type = GetBridgeType(tile_start);
+		/* Do not remove road types when upgrading a bridge */
+		roadtypes |= GetRoadTypes(tile_start);
 	} else {
 		/* Build a new bridge. */
 		/* Try and clear the start landscape */
 		ret = DoCommand(tile_start, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 		/* Try and clear the end landscape */
 		ret = DoCommand(tile_end, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 		if (CmdFailed(ret)) return ret;
 		cost += ret;
-		// false - end tile slope check
+		/* false - end tile slope check */
 		terraformcost = CheckBridgeSlopeSouth(direction, tileh_end);
 		if (CmdFailed(terraformcost) || (terraformcost != 0 && !allow_on_slopes))
 			return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
 		cost += terraformcost;
 	}
 		if (railtype != INVALID_RAILTYPE) {
 			MakeRailBridgeRamp(tile_start, owner, bridge_type, dir, railtype);
 			MakeRailBridgeRamp(tile_end,   owner, bridge_type, ReverseDiagDir(dir), railtype);
 		} else {
-			MakeRoadBridgeRamp(tile_start, owner, bridge_type, dir);
+			MakeRoadBridgeRamp(tile_start, owner, bridge_type, dir, roadtypes);
-			MakeRoadBridgeRamp(tile_end,   owner, bridge_type, ReverseDiagDir(dir));
+			MakeRoadBridgeRamp(tile_end,   owner, bridge_type, ReverseDiagDir(dir), roadtypes);
 		}
 		MarkTileDirtyByTile(tile_start);
 		MarkTileDirtyByTile(tile_end);
 	}
 	return cost;
 }
 /** Build Tunnel.
-* @param tile start tile of tunnel
+* @param start_tile start tile of tunnel
-* @param p1 railtype, 0x200 for road tunnel
+* @param flags type of operation
+* @param p1 railtype or roadtypes. bit 9 set means road tunnel
 * @param p2 unused
 */
 int32 CmdBuildTunnel(TileIndex start_tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	TileIndexDiff delta;
 	uint end_z;
 	int32 cost;
 	int32 ret;
 	_build_tunnel_endtile = 0;
+	if (!HASBIT(p1, 9)) {
-	if (p1 != 0x200 && !ValParamRailtype(p1)) return CMD_ERROR;
+		if (!ValParamRailtype(p1)) return CMD_ERROR;
+	} else if (!AreValidRoadTypes((RoadTypes)GB(p1, 0, 3))) {
+		return CMD_ERROR;
+	}
 	start_tileh = GetTileSlope(start_tile, &start_z);
 	switch (start_tileh) {
 		case SLOPE_SW: direction = DIAGDIR_SW; break;
 	}
 	/* Add the cost of the entrance */
 	cost += _price.build_tunnel + ret;
-	// if the command fails from here on we want the end tile to be highlighted
+	/* if the command fails from here on we want the end tile to be highlighted */
 	_build_tunnel_endtile = end_tile;
-	// slope of end tile must be complementary to the slope of the start tile
+	/* slope of end tile must be complementary to the slope of the start tile */
 	if (end_tileh != ComplementSlope(start_tileh)) {
 		ret = DoCommand(end_tile, end_tileh & start_tileh, 0, flags, CMD_TERRAFORM_LAND);
 		if (CmdFailed(ret)) return_cmd_error(STR_5005_UNABLE_TO_EXCAVATE_LAND);
 	} else {
 		ret = DoCommand(end_tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 			MakeRailTunnel(start_tile, _current_player, direction,                 (RailType)GB(p1, 0, 4));
 			MakeRailTunnel(end_tile,   _current_player, ReverseDiagDir(direction), (RailType)GB(p1, 0, 4));
 			UpdateSignalsOnSegment(start_tile, direction);
 			YapfNotifyTrackLayoutChange(start_tile, AxisToTrack(DiagDirToAxis(direction)));
 		} else {
-			MakeRoadTunnel(start_tile, _current_player, direction);
+			MakeRoadTunnel(start_tile, _current_player, direction,                 (RoadTypes)GB(p1, 0, 3));
-			MakeRoadTunnel(end_tile,   _current_player, ReverseDiagDir(direction));
+			MakeRoadTunnel(end_tile,   _current_player, ReverseDiagDir(direction), (RoadTypes)GB(p1, 0, 3));
 		}
 	}
 	return cost;
 }
 			return_cmd_error(STR_2009_LOCAL_AUTHORITY_REFUSES);
 		}
 	}
 	if (flags & DC_EXEC) {
-		// We first need to request the direction before calling DoClearSquare
+		/* We first need to request the direction before calling DoClearSquare
-		//  else the direction is always 0.. dah!! ;)
+		 *  else the direction is always 0.. dah!! ;) */
 		DiagDirection dir = GetTunnelDirection(tile);
 		Track track;
-		// Adjust the town's player rating. Do this before removing the tile owner info.
+		/* Adjust the town's player rating. Do this before removing the tile owner info. */
 		if (IsTileOwner(tile, OWNER_TOWN) && _game_mode != GM_EDITOR)
 			ChangeTownRating(t, RATING_TUNNEL_BRIDGE_DOWN_STEP, RATING_TUNNEL_BRIDGE_MINIMUM);
 		DoClearSquare(tile);
 		DoClearSquare(endtile);
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	if (!CheckAllowRemoveTunnelBridge(tile)) return CMD_ERROR;
 	endtile = GetOtherBridgeEnd(tile);
+	byte bridge_height = GetBridgeHeight(tile);
-	if (!EnsureNoVehicle(tile) ||
-			!EnsureNoVehicle(endtile) ||
+	if (FindVehicleOnTileZ(tile, bridge_height) != NULL ||
-			IsVehicleOnBridge(tile, endtile, GetBridgeHeight(tile))) {
+			FindVehicleOnTileZ(endtile, bridge_height) != NULL ||
+			IsVehicleOnBridge(tile, endtile, bridge_height)) {
 		return CMD_ERROR;
 	}
 	direction = GetBridgeRampDirection(tile);
 	delta = TileOffsByDiagDir(direction);
 	if (flags & DC_EXEC) {
 		TileIndex c;
 		Track track;
-		//checks if the owner is town then decrease town rating by RATING_TUNNEL_BRIDGE_DOWN_STEP until
+		/* checks if the owner is town then decrease town rating by RATING_TUNNEL_BRIDGE_DOWN_STEP until
-		// you have a "Poor" (0) town rating
+		 * you have a "Poor" (0) town rating */
 		if (IsTileOwner(tile, OWNER_TOWN) && _game_mode != GM_EDITOR)
 			ChangeTownRating(t, RATING_TUNNEL_BRIDGE_DOWN_STEP, RATING_TUNNEL_BRIDGE_MINIMUM);
 		DoClearSquare(tile);
 		DoClearSquare(endtile);
 		if (!CheckTileOwnership(tile)) return CMD_ERROR;
 		if (GetRailType(tile) == totype) 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;
 		endtile = CheckTunnelBusy(tile, &length);
 		if (endtile == INVALID_TILE) return CMD_ERROR;
 	} else if (IsBridge(tile) && GetBridgeTransportType(tile) == TRANSPORT_RAIL) {
 		if (!CheckTileOwnership(tile)) return CMD_ERROR;
 		endtile = GetOtherBridgeEnd(tile);
+		byte bridge_height = GetBridgeHeight(tile);
-		if (!EnsureNoVehicle(tile) ||
-				!EnsureNoVehicle(endtile) ||
+		if (FindVehicleOnTileZ(tile, bridge_height) != NULL ||
-				IsVehicleOnBridge(tile, endtile, GetBridgeHeight(tile))) {
+				FindVehicleOnTileZ(endtile, bridge_height) != NULL ||
+				IsVehicleOnBridge(tile, endtile, bridge_height)) {
 			return CMD_ERROR;
 		}
 		if (GetRailType(tile) == totype) return CMD_ERROR;
 			{ 1, 8, 4, 2,   2, 16, 9, 0 },
 			{ 4, 8, 1, 2,  16,  2, 0, 9 },
 			{ 2, 4, 8, 1,   2, 16, 9, 0 }
 		};
-		if (_display_opt & DO_TRANS_BUILDINGS) {
+		if (HASBIT(_transparent_opt, TO_BRIDGES)) {
 			SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);
 			pal = PALETTE_TO_TRANSPARENT;
 		} else {
 			pal = psid->pal;
 		}
 {
 	uint i;
 	if (HASBIT(BRIDGE_FULL_LEVELED_FOUNDATION, tileh)) return tileh;
-	// inclined sloped building
+	/* inclined sloped building */
 	switch (tileh) {
 		case SLOPE_W:
 		case SLOPE_STEEP_W: i = 0; break;
 		case SLOPE_S:
 		case SLOPE_STEEP_S: i = 2; break;
 	if (axis != AXIS_X) ++i;
 	return i + 15;
 }
 /**
+* Draws the trambits over an already drawn (lower end) of a bridge.
+* @param x       the x of the bridge
+* @param y       the y of the bridge
+* @param z       the z of the bridge
+* @param offset  number representing whether to level or sloped and the direction
+* @param overlay do we want to still see the road?
+*/
+static void DrawBridgeTramBits(int x, int y, byte z, int offset, bool overlay)
+{
+	static const SpriteID tram_offsets[2][6] = { { 107, 108, 109, 110, 111, 112 }, { 4, 5, 15, 16, 17, 18 } };
+	static const SpriteID back_offsets[6]    =   {  95,  95,  99, 102, 100, 101 };
+	static const SpriteID front_offsets[6]   =   {  97,  98, 103, 106, 104, 105 };
+	static const uint size_x[6] = { 11, 16, 16, 16, 16, 16 };
+	static const uint size_y[6] = { 16, 11, 16, 16, 16, 16 };
+	AddSortableSpriteToDraw(SPR_TRAMWAY_BASE + tram_offsets[overlay][offset], PAL_NONE, x, y, size_x[offset], size_y[offset], offset >= 2 ? 1 : 0, z);
+	SpriteID front = SPR_TRAMWAY_BASE + front_offsets[offset];
+	SpriteID back  = SPR_TRAMWAY_BASE + back_offsets[offset];
+	SpriteID pal   = PAL_NONE;
+	if (HASBIT(_transparent_opt, TO_BUILDINGS)) {
+		SETBIT(front, PALETTE_MODIFIER_TRANSPARENT);
+		SETBIT(back,  PALETTE_MODIFIER_TRANSPARENT);
+		pal = PALETTE_TO_TRANSPARENT;
+	}
+	AddSortableSpriteToDraw(back,  pal, x, y, size_x[offset], size_y[offset], 0, z);
+	/* For sloped sprites the bounding box needs to be higher, as the pylons stop on a higher point */
+	AddSortableSpriteToDraw(front, pal, x, y, size_x[offset], size_y[offset], offset >= 2 ? 0x30 : 0x10, z);
+}
+/**
 * Draws a tunnel of bridge tile.
 * For tunnels, this is rather simple, as you only needa draw the entrance.
 * Bridges are a bit more complex. base_offset is where the sprite selection comes into play
 * and it works a bit like a bitmask.<p> For bridge heads:
+* @param ti TileInfo of the structure to draw
 * <ul><li>Bit 0: direction</li>
 * <li>Bit 1: northern or southern heads</li>
 * <li>Bit 2: Set if the bridge head is sloped</li>
 * <li>Bit 3 and more: Railtype Specific subset</li>
 * </ul>
 		if (HasTunnelSnowOrDesert(ti->tile)) image += 32;
 		image += GetTunnelDirection(ti->tile) * 2;
 		DrawGroundSprite(image, PAL_NONE);
-		if (GetRailType(ti->tile) == RAILTYPE_ELECTRIC) DrawCatenary(ti);
+		if (GetTunnelTransportType(ti->tile) == TRANSPORT_ROAD) {
+			DiagDirection dir = GetTunnelDirection(ti->tile);
-		AddSortableSpriteToDraw(image+1, PAL_NONE, ti->x + TILE_SIZE - 1, ti->y + TILE_SIZE - 1, 1, 1, 8, (byte)ti->z);
+			RoadTypes rts = GetRoadTypes(ti->tile);
+			if (HASBIT(rts, ROADTYPE_TRAM)) {
+				static const SpriteID tunnel_sprites[2][4] = { { 28, 78, 79, 27 }, {  5, 76, 77,  4 } };
+				DrawGroundSprite(SPR_TRAMWAY_BASE + tunnel_sprites[rts - ROADTYPES_TRAM][dir], PAL_NONE);
+				AddSortableSpriteToDraw(SPR_TRAMWAY_TUNNEL_WIRES + dir, PAL_NONE, ti->x, ti->y, 16, 16, 16, (byte)ti->z);
+			}
+		} else if (GetRailType(ti->tile) == RAILTYPE_ELECTRIC) {
+			DrawCatenary(ti);
+		}
+		AddSortableSpriteToDraw(image + 1, PAL_NONE, ti->x + TILE_SIZE - 1, ti->y + TILE_SIZE - 1, 1, 1, 8, (byte)ti->z);
 		DrawBridgeMiddle(ti);
 	} else if (IsBridge(ti->tile)) { // XXX is this necessary?
 		const PalSpriteID *psid;
 		int base_offset;
 		bool ice = HasBridgeSnowOrDesert(ti->tile);
 		if (GetBridgeTransportType(ti->tile) == TRANSPORT_RAIL) {
 			base_offset = GetRailTypeInfo(GetRailType(ti->tile))->bridge_offset;
-			assert(base_offset != 8); /* This one is used for roads */
+			assert(base_offset != 8); // This one is used for roads
 		} else {
 			base_offset = 8;
 		}
 		/* as the lower 3 bits are used for other stuff, make sure they are clear */
 		if (!HASBIT(BRIDGE_NO_FOUNDATION, ti->tileh)) {
 			int f = GetBridgeFoundation(ti->tileh, DiagDirToAxis(GetBridgeRampDirection(ti->tile)));
 			if (f != 0) DrawFoundation(ti, f);
 		}
-		// HACK Wizardry to convert the bridge ramp direction into a sprite offset
+		/* HACK Wizardry to convert the bridge ramp direction into a sprite offset */
 		base_offset += (6 - GetBridgeRampDirection(ti->tile)) % 4;
 		if (ti->tileh == SLOPE_FLAT) base_offset += 4; // sloped bridge head
 		/* Table number 6 always refers to the bridge heads for any bridge type */
 			DrawClearLandTile(ti, 3);
 		} else {
 			DrawGroundSprite(SPR_FLAT_SNOWY_TILE + _tileh_to_sprite[ti->tileh], PAL_NONE);
 		}
-		if (GetRailType(ti->tile) == RAILTYPE_ELECTRIC) DrawCatenary(ti);
 		image = psid->sprite;
-		// draw ramp
+		/* draw ramp */
-		if (_display_opt & DO_TRANS_BUILDINGS) {
+		if (HASBIT(_transparent_opt, TO_BRIDGES)) {
 			SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);
 			pal = PALETTE_TO_TRANSPARENT;
 		} else {
 			pal = psid->pal;
 		}
 		/* HACK set the height of the BB of a sloped ramp to 1 so a vehicle on
 		 * it doesn't disappear behind it
 		 */
 		AddSortableSpriteToDraw(
-			image, pal, ti->x, ti->y, 16, 16, ti->tileh == SLOPE_FLAT ? 1 : 8, ti->z
+			image, pal, ti->x, ti->y, 16, 16, ti->tileh == SLOPE_FLAT ? 0 : 8, ti->z
 		);
+		if (GetBridgeTransportType(ti->tile) == TRANSPORT_ROAD) {
+			RoadTypes rts = GetRoadTypes(ti->tile);
+			if (HASBIT(rts, ROADTYPE_TRAM)) {
+				uint offset = GetBridgeRampDirection(ti->tile);
+				uint z = ti->z;
+				if (ti->tileh != SLOPE_FLAT) {
+					offset = (offset + 1) & 1;
+					z += TILE_HEIGHT;
+				} else {
+					offset += 2;
+				}
+				DrawBridgeTramBits(ti->x, ti->y, z, offset, HASBIT(rts, ROADTYPE_ROAD));
+			}
+		} else if (GetRailType(ti->tile) == RAILTYPE_ELECTRIC) {
+			DrawCatenary(ti);
+		}
 		DrawBridgeMiddle(ti);
 	}
 }
 	psid = base_offset + GetBridgeSpriteTable(type, piece);
 	if (axis != AXIS_X) psid += 4;
 	x = ti->x;
 	y = ti->y;
-	z = GetBridgeHeight(rampsouth) - 3;
+	uint bridge_z = GetBridgeHeight(rampsouth);
+	z = bridge_z - 3;
 	image = psid->sprite;
-	if (_display_opt & DO_TRANS_BUILDINGS) {
+	if (HASBIT(_transparent_opt, TO_BRIDGES)) {
 		SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);
 		pal = PALETTE_TO_TRANSPARENT;
 	} else {
 		pal = psid->pal;
 	}
 		AddSortableSpriteToDraw(image, pal, x, y, 11, 16, 1, z);
 	}
 	psid++;
 	image = psid->sprite;
-	if (_display_opt & DO_TRANS_BUILDINGS) {
+	if (HASBIT(_transparent_opt, TO_BRIDGES)) {
 		SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);
 		pal = PALETTE_TO_TRANSPARENT;
 	} else {
 		pal = psid->pal;
 	}
-	// draw roof, the component of the bridge which is logically between the vehicle and the camera
+	if (GetBridgeTransportType(rampsouth) == TRANSPORT_ROAD) {
+		RoadTypes rts = GetRoadTypes(rampsouth);
+		if (HASBIT(rts, ROADTYPE_TRAM)) {
+			DrawBridgeTramBits(x, y, bridge_z, axis ^ 1, HASBIT(rts, ROADTYPE_ROAD));
+		}
+	} else if (GetRailType(rampsouth) == RAILTYPE_ELECTRIC) {
+		DrawCatenary(ti);
+	}
+	/* draw roof, the component of the bridge which is logically between the vehicle and the camera */
 	if (axis == AXIS_X) {
 		y += 12;
 		if (image & SPRITE_MASK) AddSortableSpriteToDraw(image, pal, x, y, 16, 1, 0x28, z);
 	} else {
 		x += 12;
 		if (image & SPRITE_MASK) AddSortableSpriteToDraw(image, pal, x, y, 1, 16, 0x28, z);
 	}
-	if (GetRailType(rampsouth) == RAILTYPE_ELECTRIC) DrawCatenary(ti);
 	psid++;
 	if (ti->z + 5 == z) {
-		// draw poles below for small bridges
+		/* draw poles below for small bridges */
 		if (psid->sprite != 0) {
 			image = psid->sprite;
-			if (_display_opt & DO_TRANS_BUILDINGS) {
+			if (HASBIT(_transparent_opt, TO_BRIDGES)) {
 				SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);
 				pal = PALETTE_TO_TRANSPARENT;
 			} else {
 				pal = psid->pal;
 			}
 			DrawGroundSpriteAt(image, pal, x, y, z);
 		}
 	} else if (_patches.bridge_pillars) {
-		// draw pillars below for high bridges
+		/* draw pillars below for high bridges */
 		DrawBridgePillars(psid, ti, axis, type, x, y, z);
 	}
 }
 	y &= 0xF;
 	if (IsTunnel(tile)) {
 		uint pos = (DiagDirToAxis(GetTunnelDirection(tile)) == AXIS_X ? y : x);
-		// In the tunnel entrance?
+		/* In the tunnel entrance? */
 		if (5 <= pos && pos <= 10) return z;
 	} else {
 		DiagDirection dir = GetBridgeRampDirection(tile);
 		uint pos = (DiagDirToAxis(dir) == AXIS_X ? y : x);
-		// On the bridge ramp?
+		/* On the bridge ramp? */
 		if (5 <= pos && pos <= 10) {
 			uint delta;
 			if (IsSteepSlope(tileh)) return z + TILE_HEIGHT * 2;
 			if (HASBIT(BRIDGE_HORZ_RAMP, tileh)) return z + TILE_HEIGHT;
 {
 	/* not used */
 }
-static uint32 GetTileTrackStatus_TunnelBridge(TileIndex tile, TransportType mode)
+static uint32 GetTileTrackStatus_TunnelBridge(TileIndex tile, TransportType mode, uint sub_mode)
 {
 	if (IsTunnel(tile)) {
 		if (GetTunnelTransportType(tile) != mode) return 0;
+		if (GetTunnelTransportType(tile) == TRANSPORT_ROAD && (GetRoadTypes(tile) & sub_mode) == 0) return 0;
 		return AxisToTrackBits(DiagDirToAxis(GetTunnelDirection(tile))) * 0x101;
 	} else {
 		if (GetBridgeTransportType(tile) != mode) return 0;
+		if (GetBridgeTransportType(tile) == TRANSPORT_ROAD && (GetRoadTypes(tile) & sub_mode) == 0) return 0;
 		return AxisToTrackBits(DiagDirToAxis(GetBridgeRampDirection(tile))) * 0x101;
 	}
 }
 static void ChangeTileOwner_TunnelBridge(TileIndex tile, PlayerID old_player, PlayerID new_player)
 	if (!IsTileOwner(tile, old_player)) return;
 	if (new_player != PLAYER_SPECTATOR) {
 		SetTileOwner(tile, new_player);
 	} else {
-		DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
+		if (CmdFailed(DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR))) {
+			/* When clearing the bridge/tunnel failed there are still vehicles on/in
+			 * the bridge/tunnel. As all *our* vehicles are already removed, they
+			 * must be of another owner. Therefor this must be a road bridge/tunnel.
+			 * In that case we can safely reassign the ownership to OWNER_NONE. */
+			assert((IsTunnel(tile) ? GetTunnelTransportType(tile) : GetBridgeTransportType(tile)) == TRANSPORT_ROAD);
+			SetTileOwner(tile, OWNER_NONE);
+		}
 	}
 }
 static const byte _tunnel_fractcoord_1[4]    = {0x8E, 0x18, 0x81, 0xE8};
 		} else if (v->type == VEH_ROAD) {
 			fc = (x & 0xF) + (y << 4);
 			dir = GetTunnelDirection(tile);
 			vdir = DirToDiagDir(v->direction);
-			// Enter tunnel?
+			/* Enter tunnel? */
 			if (v->u.road.state != RVSB_WORMHOLE && dir == vdir) {
 				if (fc == _tunnel_fractcoord_4[dir] ||
 						fc == _tunnel_fractcoord_5[dir]) {
 					v->tile = tile;
 					v->u.road.state = RVSB_WORMHOLE;

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