diff --git a/src/bridge_map.cpp b/src/bridge_map.cpp
index eb28673867..3c2e40552d 100644
--- a/src/bridge_map.cpp
+++ b/src/bridge_map.cpp
@@ -69,8 +69,7 @@ TileIndex GetOtherBridgeEnd(TileIndex tile)
  */
 int GetBridgeHeight(TileIndex t)
 {
-	int h;
-	Slope tileh = GetTileSlope(t, &h);
+	auto [tileh, h] = GetTileSlopeZ(t);
 	Foundation f = GetBridgeFoundation(tileh, DiagDirToAxis(GetTunnelBridgeDirection(t)));
 
 	/* one height level extra for the ramp */
diff --git a/src/clear_cmd.cpp b/src/clear_cmd.cpp
index 9831764b31..4df61805e3 100644
--- a/src/clear_cmd.cpp
+++ b/src/clear_cmd.cpp
@@ -129,8 +129,7 @@ static void DrawTile_Clear(TileInfo *ti)
 
 static int GetSlopePixelZ_Clear(TileIndex tile, uint x, uint y, bool)
 {
-	int z;
-	Slope tileh = GetTilePixelSlope(tile, &z);
+	auto [tileh, z] = GetTilePixelSlope(tile);
 
 	return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
 }
diff --git a/src/dock_gui.cpp b/src/dock_gui.cpp
index 76a778622a..f43c1ae7ba 100644
--- a/src/dock_gui.cpp
+++ b/src/dock_gui.cpp
@@ -67,8 +67,8 @@ void CcPlaySound_CONSTRUCTION_WATER(Commands, const CommandCost &result, TileInd
  */
 static TileIndex GetOtherAqueductEnd(TileIndex tile_from, TileIndex *tile_to = nullptr)
 {
-	int z;
-	DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile_from, &z));
+	auto [slope, z] = GetTileSlopeZ(tile_from);
+	DiagDirection dir = GetInclinedSlopeDirection(slope);
 
 	/* If the direction isn't right, just return the next tile so the command
 	 * complains about the wrong slope instead of the ends not matching up.
diff --git a/src/landscape.cpp b/src/landscape.cpp
index 43dacf8a35..f5383884fb 100644
--- a/src/landscape.cpp
+++ b/src/landscape.cpp
@@ -373,28 +373,24 @@ void GetSlopePixelZOnEdge(Slope tileh, DiagDirection edge, int *z1, int *z2)
  * If a tile does not have a foundation, the function returns the same as GetTileSlope.
  *
  * @param tile The tile of interest.
- * @param z returns the z of the foundation slope. (Can be nullptr, if not needed)
- * @return The slope on top of the foundation.
+ * @return The slope on top of the foundation and the z of the foundation slope.
  */
-Slope GetFoundationSlope(TileIndex tile, int *z)
+std::tuple<Slope, int> GetFoundationSlope(TileIndex tile)
 {
-	Slope tileh = GetTileSlope(tile, z);
+	auto [tileh, z] = GetTileSlopeZ(tile);
 	Foundation f = _tile_type_procs[GetTileType(tile)]->get_foundation_proc(tile, tileh);
-	uint z_inc = ApplyFoundationToSlope(f, &tileh);
-	if (z != nullptr) *z += z_inc;
-	return tileh;
+	z += ApplyFoundationToSlope(f, &tileh);
+	return {tileh, z};
 }
 
 
 bool HasFoundationNW(TileIndex tile, Slope slope_here, uint z_here)
 {
-	int z;
-
 	int z_W_here = z_here;
 	int z_N_here = z_here;
 	GetSlopePixelZOnEdge(slope_here, DIAGDIR_NW, &z_W_here, &z_N_here);
 
-	Slope slope = GetFoundationPixelSlope(TILE_ADDXY(tile, 0, -1), &z);
+	auto [slope, z] = GetFoundationPixelSlope(TILE_ADDXY(tile, 0, -1));
 	int z_W = z;
 	int z_N = z;
 	GetSlopePixelZOnEdge(slope, DIAGDIR_SE, &z_W, &z_N);
@@ -405,13 +401,11 @@ bool HasFoundationNW(TileIndex tile, Slope slope_here, uint z_here)
 
 bool HasFoundationNE(TileIndex tile, Slope slope_here, uint z_here)
 {
-	int z;
-
 	int z_E_here = z_here;
 	int z_N_here = z_here;
 	GetSlopePixelZOnEdge(slope_here, DIAGDIR_NE, &z_E_here, &z_N_here);
 
-	Slope slope = GetFoundationPixelSlope(TILE_ADDXY(tile, -1, 0), &z);
+	auto [slope, z] = GetFoundationPixelSlope(TILE_ADDXY(tile, -1, 0));
 	int z_E = z;
 	int z_N = z;
 	GetSlopePixelZOnEdge(slope, DIAGDIR_SW, &z_E, &z_N);
@@ -432,8 +426,7 @@ void DrawFoundation(TileInfo *ti, Foundation f)
 	assert(f != FOUNDATION_STEEP_BOTH);
 
 	uint sprite_block = 0;
-	int z;
-	Slope slope = GetFoundationPixelSlope(ti->tile, &z);
+	auto [slope, z] = GetFoundationPixelSlope(ti->tile);
 
 	/* Select the needed block of foundations sprites
 	 * Block 0: Walls at NW and NE edge
@@ -1194,10 +1187,8 @@ static bool FlowsDown(TileIndex begin, TileIndex end)
 {
 	assert(DistanceManhattan(begin, end) == 1);
 
-	int heightBegin;
-	int heightEnd;
-	Slope slopeBegin = GetTileSlope(begin, &heightBegin);
-	Slope slopeEnd   = GetTileSlope(end, &heightEnd);
+	auto [slopeBegin, heightBegin] = GetTileSlopeZ(begin);
+	auto [slopeEnd, heightEnd] = GetTileSlopeZ(end);
 
 	return heightEnd <= heightBegin &&
 			/* Slope either is inclined or flat; rivers don't support other slopes. */
diff --git a/src/landscape.h b/src/landscape.h
index 249dcc9efa..96a5c6a331 100644
--- a/src/landscape.h
+++ b/src/landscape.h
@@ -34,7 +34,7 @@ byte LowestSnowLine();
 void ClearSnowLine();
 
 int GetSlopeZInCorner(Slope tileh, Corner corner);
-Slope GetFoundationSlope(TileIndex tile, int *z = nullptr);
+std::tuple<Slope, int> GetFoundationSlope(TileIndex tile);
 
 uint GetPartialPixelZ(int x, int y, Slope corners);
 int GetSlopePixelZ(int x, int y, bool ground_vehicle = false);
@@ -60,15 +60,12 @@ inline int GetSlopePixelZInCorner(Slope tileh, Corner corner)
  * If a tile does not have a foundation, the function returns the same as GetTilePixelSlope.
  *
  * @param tile The tile of interest.
- * @param z returns the z of the foundation slope. (Can be nullptr, if not needed)
- * @return The slope on top of the foundation.
+ * @return The slope on top of the foundation and the z of the foundation.
  */
-inline Slope GetFoundationPixelSlope(TileIndex tile, int *z)
+inline std::tuple<Slope, int> GetFoundationPixelSlope(TileIndex tile)
 {
-	assert(z != nullptr);
-	Slope s = GetFoundationSlope(tile, z);
-	*z *= TILE_HEIGHT;
-	return s;
+	auto [s, z] = GetFoundationSlope(tile);
+	return {s, z * TILE_HEIGHT};
 }
 
 /**
diff --git a/src/newgrf_commons.cpp b/src/newgrf_commons.cpp
index cf83224830..7804c08e30 100644
--- a/src/newgrf_commons.cpp
+++ b/src/newgrf_commons.cpp
@@ -433,8 +433,7 @@ uint32_t GetNearbyTileInformation(TileIndex tile, bool grf_version8)
 	/* Fake tile type for trees on shore */
 	if (IsTileType(tile, MP_TREES) && GetTreeGround(tile) == TREE_GROUND_SHORE) tile_type = MP_WATER;
 
-	int z;
-	Slope tileh = GetTilePixelSlope(tile, &z);
+	auto [tileh, z] = GetTilePixelSlope(tile);
 	/* Return 0 if the tile is a land tile */
 	byte terrain_type = (HasTileWaterClass(tile) ? (GetWaterClass(tile) + 1) & 3 : 0) << 5 | GetTerrainType(tile) << 2 | (tile_type == MP_WATER ? 1 : 0) << 1;
 	if (grf_version8) z /= TILE_HEIGHT;
diff --git a/src/object_cmd.cpp b/src/object_cmd.cpp
index 3e2654a853..5ead59bd8a 100644
--- a/src/object_cmd.cpp
+++ b/src/object_cmd.cpp
@@ -267,8 +267,8 @@ CommandCost CmdBuildObject(DoCommandFlag flags, TileIndex tile, ObjectType type,
 		}
 
 		/* So, now the surface is checked... check the slope of said surface. */
-		int allowed_z;
-		if (GetTileSlope(tile, &allowed_z) != SLOPE_FLAT) allowed_z++;
+		auto [slope, allowed_z] = GetTileSlopeZ(tile);
+		if (slope != SLOPE_FLAT) allowed_z++;
 
 		for (TileIndex t : ta) {
 			uint16_t callback = CALLBACK_FAILED;
@@ -492,8 +492,7 @@ static void DrawTile_Object(TileInfo *ti)
 static int GetSlopePixelZ_Object(TileIndex tile, uint x, uint y, bool)
 {
 	if (IsObjectType(tile, OBJECT_OWNED_LAND)) {
-		int z;
-		Slope tileh = GetTilePixelSlope(tile, &z);
+		auto [tileh, z] = GetTilePixelSlope(tile);
 
 		return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
 	} else {
diff --git a/src/rail_cmd.cpp b/src/rail_cmd.cpp
index 89329ea6d0..ac6130dadb 100644
--- a/src/rail_cmd.cpp
+++ b/src/rail_cmd.cpp
@@ -2580,8 +2580,7 @@ void DrawTrainDepotSprite(int x, int y, int dir, RailType railtype)
 static int GetSlopePixelZ_Track(TileIndex tile, uint x, uint y, bool)
 {
 	if (IsPlainRail(tile)) {
-		int z;
-		Slope tileh = GetTilePixelSlope(tile, &z);
+		auto [tileh, z] = GetTilePixelSlope(tile);
 		if (tileh == SLOPE_FLAT) return z;
 
 		z += ApplyPixelFoundationToSlope(GetRailFoundation(tileh, GetTrackBits(tile)), &tileh);
@@ -2608,8 +2607,7 @@ static void TileLoop_Track(TileIndex tile)
 
 	switch (_settings_game.game_creation.landscape) {
 		case LT_ARCTIC: {
-			int z;
-			Slope slope = GetTileSlope(tile, &z);
+			auto [slope, z] = GetTileSlopeZ(tile);
 			bool half = false;
 
 			/* for non-flat track, use lower part of track
@@ -3052,8 +3050,7 @@ static Vehicle *EnsureNoShipProc(Vehicle *v, void *)
 
 static CommandCost TerraformTile_Track(TileIndex tile, DoCommandFlag flags, int z_new, Slope tileh_new)
 {
-	int z_old;
-	Slope tileh_old = GetTileSlope(tile, &z_old);
+	auto [tileh_old, z_old] = GetTileSlopeZ(tile);
 	if (IsPlainRail(tile)) {
 		TrackBits rail_bits = GetTrackBits(tile);
 		/* Is there flat water on the lower halftile that must be cleared expensively? */
diff --git a/src/road.cpp b/src/road.cpp
index d3de25d44f..248533c4fd 100644
--- a/src/road.cpp
+++ b/src/road.cpp
@@ -35,7 +35,7 @@ static bool IsPossibleCrossing(const TileIndex tile, Axis ax)
 	return (IsTileType(tile, MP_RAILWAY) &&
 		GetRailTileType(tile) == RAIL_TILE_NORMAL &&
 		GetTrackBits(tile) == (ax == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X) &&
-		GetFoundationSlope(tile) == SLOPE_FLAT);
+		std::get<0>(GetFoundationSlope(tile)) == SLOPE_FLAT);
 }
 
 /**
diff --git a/src/road_cmd.cpp b/src/road_cmd.cpp
index c2501a1d12..608010ea91 100644
--- a/src/road_cmd.cpp
+++ b/src/road_cmd.cpp
@@ -1926,8 +1926,7 @@ static int GetSlopePixelZ_Road(TileIndex tile, uint x, uint y, bool)
 {
 
 	if (IsNormalRoad(tile)) {
-		int z;
-		Slope tileh = GetTilePixelSlope(tile, &z);
+		auto [tileh, z] = GetTilePixelSlope(tile);
 		if (tileh == SLOPE_FLAT) return z;
 
 		Foundation f = GetRoadFoundation(tileh, GetAllRoadBits(tile));
@@ -1999,7 +1998,7 @@ static void TileLoop_Road(TileIndex tile)
 			if (t->road_build_months != 0 &&
 					(DistanceManhattan(t->xy, tile) < 8 || grp != HZB_TOWN_EDGE) &&
 					IsNormalRoad(tile) && !HasAtMostOneBit(GetAllRoadBits(tile))) {
-				if (GetFoundationSlope(tile) == SLOPE_FLAT && EnsureNoVehicleOnGround(tile).Succeeded() && Chance16(1, 40)) {
+				if (std::get<0>(GetFoundationSlope(tile)) == SLOPE_FLAT && EnsureNoVehicleOnGround(tile).Succeeded() && Chance16(1, 40)) {
 					StartRoadWorks(tile);
 
 					if (_settings_client.sound.ambient) SndPlayTileFx(SND_21_ROAD_WORKS, tile);
@@ -2343,8 +2342,7 @@ static CommandCost TerraformTile_Road(TileIndex tile, DoCommandFlag flags, int z
 				if (CheckRoadSlope(tileh_new, &bits_copy, ROAD_NONE, ROAD_NONE).Succeeded()) {
 					/* CheckRoadSlope() sometimes changes the road_bits, if it does not agree with them. */
 					if (bits == bits_copy) {
-						int z_old;
-						Slope tileh_old = GetTileSlope(tile, &z_old);
+						auto [tileh_old, z_old] = GetTileSlopeZ(tile);
 
 						/* Get the slope on top of the foundation */
 						z_old += ApplyFoundationToSlope(GetRoadFoundation(tileh_old, bits), &tileh_old);
diff --git a/src/script/api/script_tile.cpp b/src/script/api/script_tile.cpp
index f292bfd647..508ca201a7 100644
--- a/src/script/api/script_tile.cpp
+++ b/src/script/api/script_tile.cpp
@@ -199,8 +199,7 @@
 {
 	if (!::IsValidTile(tile) || !::IsValidCorner((::Corner)corner)) return -1;
 
-	int z;
-	::Slope slope = ::GetTileSlope(tile, &z);
+	auto [slope, z] = ::GetTileSlopeZ(tile);
 	return (z + ::GetSlopeZInCorner(slope, (::Corner)corner));
 }
 
diff --git a/src/script/api/script_tunnel.cpp b/src/script/api/script_tunnel.cpp
index 1ae9f2d78f..ed7680593c 100644
--- a/src/script/api/script_tunnel.cpp
+++ b/src/script/api/script_tunnel.cpp
@@ -31,8 +31,7 @@
 	/* If it's a tunnel already, take the easy way out! */
 	if (IsTunnelTile(tile)) return ::GetOtherTunnelEnd(tile);
 
-	int start_z;
-	Slope start_tileh = ::GetTileSlope(tile, &start_z);
+	auto [start_tileh, start_z] = ::GetTileSlopeZ(tile);
 	DiagDirection direction = ::GetInclinedSlopeDirection(start_tileh);
 	if (direction == INVALID_DIAGDIR) return INVALID_TILE;
 
@@ -42,7 +41,7 @@
 		tile += delta;
 		if (!::IsValidTile(tile)) return INVALID_TILE;
 
-		::GetTileSlope(tile, &end_z);
+		std::tie(std::ignore, end_z) = ::GetTileSlopeZ(tile);
 	} while (start_z != end_z);
 
 	return tile;
diff --git a/src/station_cmd.cpp b/src/station_cmd.cpp
index c63b0531e2..9ffb2630a8 100644
--- a/src/station_cmd.cpp
+++ b/src/station_cmd.cpp
@@ -805,8 +805,7 @@ CommandCost CheckBuildableTile(TileIndex tile, uint invalid_dirs, int &allowed_z
 	CommandCost ret = EnsureNoVehicleOnGround(tile);
 	if (ret.Failed()) return ret;
 
-	int z;
-	Slope tileh = GetTileSlope(tile, &z);
+	auto [tileh, z] = GetTileSlopeZ(tile);
 
 	/* Prohibit building if
 	 *   1) The tile is "steep" (i.e. stretches two height levels).
@@ -3031,8 +3030,7 @@ static void DrawTile_Station(TileInfo *ti)
 			/* Station has custom foundations.
 			 * Check whether the foundation continues beyond the tile's upper sides. */
 			uint edge_info = 0;
-			int z;
-			Slope slope = GetFoundationPixelSlope(ti->tile, &z);
+			auto [slope, z] = GetFoundationPixelSlope(ti->tile);
 			if (!HasFoundationNW(ti->tile, slope, z)) SetBit(edge_info, 0);
 			if (!HasFoundationNE(ti->tile, slope, z)) SetBit(edge_info, 1);
 			SpriteID image = GetCustomStationFoundationRelocation(statspec, st, ti->tile, tile_layout, edge_info);
diff --git a/src/tile_map.cpp b/src/tile_map.cpp
index 09a95385b4..54cfc8ebd2 100644
--- a/src/tile_map.cpp
+++ b/src/tile_map.cpp
@@ -18,10 +18,9 @@
  * @param hwest  The height at the western corner in the same unit as TileHeight.
  * @param heast  The height at the eastern corner in the same unit as TileHeight.
  * @param hsouth The height at the southern corner in the same unit as TileHeight.
- * @param[out] h The lowest height of the four corners.
- * @return The slope.
+ * @return The slope and the lowest height of the four corners.
  */
-static Slope GetTileSlopeGivenHeight(int hnorth, int hwest, int heast, int hsouth, int *h)
+static std::tuple<Slope, int> GetTileSlopeGivenHeight(int hnorth, int hwest, int heast, int hsouth)
 {
 	/* Due to the fact that tiles must connect with each other without leaving gaps, the
 	 * biggest difference in height between any corner and 'min' is between 0, 1, or 2.
@@ -32,8 +31,6 @@ static Slope GetTileSlopeGivenHeight(int hnorth, int hwest, int heast, int hsout
 	int hmines = std::min(heast, hsouth);
 	int hmin = std::min(hminnw, hmines);
 
-	if (h != nullptr) *h = hmin;
-
 	int hmaxnw = std::max(hnorth, hwest);
 	int hmaxes = std::max(heast, hsouth);
 	int hmax = std::max(hmaxnw, hmaxes);
@@ -47,16 +44,15 @@ static Slope GetTileSlopeGivenHeight(int hnorth, int hwest, int heast, int hsout
 
 	if (hmax - hmin == 2) r |= SLOPE_STEEP;
 
-	return r;
+	return {r, hmin};
 }
 
 /**
  * Return the slope of a given tile inside the map.
  * @param tile Tile to compute slope of
- * @param h    If not \c nullptr, pointer to storage of z height
- * @return Slope of the tile, except for the HALFTILE part
+ * @return Slope of the tile, except for the HALFTILE part, and the z height
  */
-Slope GetTileSlope(TileIndex tile, int *h)
+std::tuple<Slope, int> GetTileSlopeZ(TileIndex tile)
 {
 	uint x1 = TileX(tile);
 	uint y1 = TileY(tile);
@@ -68,7 +64,7 @@ Slope GetTileSlope(TileIndex tile, int *h)
 	int heast  = TileHeight(TileXY(x1, y2)); // Height of the East corner.
 	int hsouth = TileHeight(TileXY(x2, y2)); // Height of the South corner.
 
-	return GetTileSlopeGivenHeight(hnorth, hwest, heast, hsouth, h);
+	return GetTileSlopeGivenHeight(hnorth, hwest, heast, hsouth);
 }
 
 /**
@@ -77,18 +73,17 @@ Slope GetTileSlope(TileIndex tile, int *h)
  * @param x X coordinate of the tile to compute slope of, may be outside the map.
  * @param y Y coordinate of the tile to compute slope of, may be outside the map.
  * @param h If not \c nullptr, pointer to storage of z height.
- * @return Slope of the tile, except for the HALFTILE part.
+ * @return Slope of the tile, except for the HALFTILE part, and the z height of the tile.
  */
-Slope GetTilePixelSlopeOutsideMap(int x, int y, int *h)
+std::tuple<Slope, int> GetTilePixelSlopeOutsideMap(int x, int y)
 {
 	int hnorth = TileHeightOutsideMap(x,     y);     // N corner.
 	int hwest  = TileHeightOutsideMap(x + 1, y);     // W corner.
 	int heast  = TileHeightOutsideMap(x,     y + 1); // E corner.
 	int hsouth = TileHeightOutsideMap(x + 1, y + 1); // S corner.
 
-	Slope s = GetTileSlopeGivenHeight(hnorth, hwest, heast, hsouth, h);
-	if (h != nullptr) *h *= TILE_HEIGHT;
-	return s;
+	auto [slope, h] = GetTileSlopeGivenHeight(hnorth, hwest, heast, hsouth);
+	return {slope, h * TILE_HEIGHT};
 }
 
 /**
diff --git a/src/tile_map.h b/src/tile_map.h
index 6ec6609e6b..a4bd524b2f 100644
--- a/src/tile_map.h
+++ b/src/tile_map.h
@@ -265,26 +265,34 @@ inline void SetAnimationFrame(Tile t, byte frame)
 	t.m7() = frame;
 }
 
-Slope GetTileSlope(TileIndex tile, int *h = nullptr);
+std::tuple<Slope, int> GetTileSlopeZ(TileIndex tile);
 int GetTileZ(TileIndex tile);
 int GetTileMaxZ(TileIndex tile);
 
 bool IsTileFlat(TileIndex tile, int *h = nullptr);
 
 /**
- * Return the slope of a given tile
+ * Return the slope of a given tile inside the map.
  * @param tile Tile to compute slope of
- * @param h    If not \c nullptr, pointer to storage of z height
  * @return Slope of the tile, except for the HALFTILE part
  */
-inline Slope GetTilePixelSlope(TileIndex tile, int *h)
+inline Slope GetTileSlope(TileIndex tile)
 {
-	Slope s = GetTileSlope(tile, h);
-	if (h != nullptr) *h *= TILE_HEIGHT;
-	return s;
+	return std::get<0>(GetTileSlopeZ(tile));
 }
 
-Slope GetTilePixelSlopeOutsideMap(int x, int y, int *h);
+/**
+ * Return the slope of a given tile
+ * @param tile Tile to compute slope of
+ * @return Slope of the tile, except for the HALFTILE part, and the z height.
+ */
+inline std::tuple<Slope, int> GetTilePixelSlope(TileIndex tile)
+{
+	auto [s, h] = GetTileSlopeZ(tile);
+	return {s, h * TILE_HEIGHT};
+}
+
+std::tuple<Slope, int> GetTilePixelSlopeOutsideMap(int x, int y);
 
 /**
  * Get bottom height of the tile
diff --git a/src/town_cmd.cpp b/src/town_cmd.cpp
index ffa3d746b3..d8d4009fd2 100644
--- a/src/town_cmd.cpp
+++ b/src/town_cmd.cpp
@@ -1003,7 +1003,7 @@ static bool IsRoadAllowedHere(Town *t, TileIndex tile, DiagDirection dir)
 		}
 	}
 
-	Slope cur_slope = _settings_game.construction.build_on_slopes ? GetFoundationSlope(tile) : GetTileSlope(tile);
+	Slope cur_slope = _settings_game.construction.build_on_slopes ? std::get<0>(GetFoundationSlope(tile)) : GetTileSlope(tile);
 	bool ret = !IsNeighborRoadTile(tile, dir, t->layout == TL_ORIGINAL ? 1 : 2);
 	if (cur_slope == SLOPE_FLAT) return ret;
 
diff --git a/src/tree_cmd.cpp b/src/tree_cmd.cpp
index 0263f819fb..0c888c831b 100644
--- a/src/tree_cmd.cpp
+++ b/src/tree_cmd.cpp
@@ -588,8 +588,7 @@ static void DrawTile_Trees(TileInfo *ti)
 
 static int GetSlopePixelZ_Trees(TileIndex tile, uint x, uint y, bool)
 {
-	int z;
-	Slope tileh = GetTilePixelSlope(tile, &z);
+	auto [tileh, z] = GetTilePixelSlope(tile);
 
 	return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
 }
diff --git a/src/tunnelbridge_cmd.cpp b/src/tunnelbridge_cmd.cpp
index a2e9d67f1c..d395396d6f 100644
--- a/src/tunnelbridge_cmd.cpp
+++ b/src/tunnelbridge_cmd.cpp
@@ -324,10 +324,8 @@ CommandCost CmdBuildBridge(DoCommandFlag flags, TileIndex tile_end, TileIndex ti
 	}
 	bridge_len += 2; // begin and end tiles/ramps
 
-	int z_start;
-	int z_end;
-	Slope tileh_start = GetTileSlope(tile_start, &z_start);
-	Slope tileh_end = GetTileSlope(tile_end, &z_end);
+	auto [tileh_start, z_start] = GetTileSlopeZ(tile_start);
+	auto [tileh_end, z_end] = GetTileSlopeZ(tile_end);
 	bool pbs_reservation = false;
 
 	CommandCost terraform_cost_north = CheckBridgeSlope(BRIDGE_PIECE_NORTH, direction, &tileh_start, &z_start);
@@ -655,9 +653,7 @@ CommandCost CmdBuildTunnel(DoCommandFlag flags, TileIndex start_tile, TransportT
 		}
 	}
 
-	int start_z;
-	int end_z;
-	Slope start_tileh = GetTileSlope(start_tile, &start_z);
+	auto [start_tileh, start_z] = GetTileSlopeZ(start_tile);
 	DiagDirection direction = GetInclinedSlopeDirection(start_tileh);
 	if (direction == INVALID_DIAGDIR) return_cmd_error(STR_ERROR_SITE_UNSUITABLE_FOR_TUNNEL);
 
@@ -690,10 +686,11 @@ CommandCost CmdBuildTunnel(DoCommandFlag flags, TileIndex start_tile, TransportT
 
 	CommandCost cost(EXPENSES_CONSTRUCTION);
 	Slope end_tileh;
+	int end_z;
 	for (;;) {
 		end_tile += delta;
 		if (!IsValidTile(end_tile)) return_cmd_error(STR_ERROR_TUNNEL_THROUGH_MAP_BORDER);
-		end_tileh = GetTileSlope(end_tile, &end_z);
+		std::tie(end_tileh, end_z) = GetTileSlopeZ(end_tile);
 
 		if (start_z == end_z) break;
 
@@ -1666,8 +1663,7 @@ void DrawBridgeMiddle(const TileInfo *ti)
 
 static int GetSlopePixelZ_TunnelBridge(TileIndex tile, uint x, uint y, bool ground_vehicle)
 {
-	int z;
-	Slope tileh = GetTilePixelSlope(tile, &z);
+	auto [tileh, z] = GetTilePixelSlope(tile);
 
 	x &= 0xF;
 	y &= 0xF;
@@ -2042,8 +2038,7 @@ static CommandCost TerraformTile_TunnelBridge(TileIndex tile, DoCommandFlag flag
 		DiagDirection direction = GetTunnelBridgeDirection(tile);
 		Axis axis = DiagDirToAxis(direction);
 		CommandCost res;
-		int z_old;
-		Slope tileh_old = GetTileSlope(tile, &z_old);
+		auto [tileh_old, z_old] = GetTileSlopeZ(tile);
 
 		/* Check if new slope is valid for bridges in general (so we can safely call GetBridgeFoundation()) */
 		if ((direction == DIAGDIR_NW) || (direction == DIAGDIR_NE)) {
diff --git a/src/viewport.cpp b/src/viewport.cpp
index cd5987e6c6..c035cc2a45 100644
--- a/src/viewport.cpp
+++ b/src/viewport.cpp
@@ -1242,10 +1242,10 @@ static void ViewportAddLandscape()
 
 			if (tile_type != MP_VOID) {
 				/* We are inside the map => paint landscape. */
-				_cur_ti.tileh = GetTilePixelSlope(_cur_ti.tile, &_cur_ti.z);
+				std::tie(_cur_ti.tileh, _cur_ti.z) = GetTilePixelSlope(_cur_ti.tile);
 			} else {
 				/* We are outside the map => paint black. */
-				_cur_ti.tileh = GetTilePixelSlopeOutsideMap(tilecoord.x, tilecoord.y, &_cur_ti.z);
+				std::tie(_cur_ti.tileh, _cur_ti.z) = GetTilePixelSlopeOutsideMap(tilecoord.x, tilecoord.y);
 			}
 
 			int viewport_y = GetViewportY(tilecoord);
diff --git a/src/void_cmd.cpp b/src/void_cmd.cpp
index 81dc9ed6c2..5e35a1f883 100644
--- a/src/void_cmd.cpp
+++ b/src/void_cmd.cpp
@@ -29,8 +29,7 @@ static int GetSlopePixelZ_Void(TileIndex, uint x, uint y, bool)
 {
 	/* This function may be called on tiles outside the map, don't assume
 	 * that 'tile' is a valid tile index. See GetSlopePixelZOutsideMap. */
-	int z;
-	Slope tileh = GetTilePixelSlopeOutsideMap(x >> 4, y >> 4, &z);
+	auto [tileh, z] = GetTilePixelSlopeOutsideMap(x >> 4, y >> 4);
 
 	return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
 }
diff --git a/src/water_cmd.cpp b/src/water_cmd.cpp
index d503bfcda4..7b3703ed77 100644
--- a/src/water_cmd.cpp
+++ b/src/water_cmd.cpp
@@ -210,8 +210,7 @@ void MakeWaterKeepingClass(TileIndex tile, Owner o)
 	WaterClass wc = GetWaterClass(tile);
 
 	/* Autoslope might turn an originally canal or river tile into land */
-	int z;
-	Slope slope = GetTileSlope(tile, &z);
+	auto [slope, z] = GetTileSlopeZ(tile);
 
 	if (slope != SLOPE_FLAT) {
 		if (wc == WATER_CLASS_CANAL) {
@@ -951,8 +950,7 @@ void DrawShipDepotSprite(int x, int y, Axis axis, DepotPart part)
 
 static int GetSlopePixelZ_Water(TileIndex tile, uint x, uint y, bool)
 {
-	int z;
-	Slope tileh = GetTilePixelSlope(tile, &z);
+	auto [tileh, z] = GetTilePixelSlope(tile);
 
 	return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
 }
@@ -1245,18 +1243,17 @@ void TileLoop_Water(TileIndex tile)
 				/* TREE_GROUND_SHORE is the sign of a previous flood. */
 				if (IsTileType(dest, MP_TREES) && GetTreeGround(dest) == TREE_GROUND_SHORE) continue;
 
-				int z_dest;
-				Slope slope_dest = GetFoundationSlope(dest, &z_dest) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP;
+				auto [slope_dest, z_dest] = GetFoundationSlope(dest);
 				if (z_dest > 0) continue;
 
-				if (!HasBit(_flood_from_dirs[slope_dest], ReverseDir(dir))) continue;
+				if (!HasBit(_flood_from_dirs[slope_dest & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP], ReverseDir(dir))) continue;
 
 				DoFloodTile(dest);
 			}
 			break;
 
 		case FLOOD_DRYUP: {
-			Slope slope_here = GetFoundationSlope(tile) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP;
+			Slope slope_here = std::get<0>(GetFoundationSlope(tile)) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP;
 			for (uint dir : SetBitIterator(_flood_from_dirs[slope_here])) {
 				TileIndex dest = tile + TileOffsByDir((Direction)dir);
 				if (dest >= Map::Size()) continue;
@@ -1274,10 +1271,8 @@ void TileLoop_Water(TileIndex tile)
 
 void ConvertGroundTilesIntoWaterTiles()
 {
-	int z;
-
 	for (TileIndex tile = 0; tile < Map::Size(); ++tile) {
-		Slope slope = GetTileSlope(tile, &z);
+		auto [slope, z] = GetTileSlopeZ(tile);
 		if (IsTileType(tile, MP_CLEAR) && z == 0) {
 			/* Make both water for tiles at level 0
 			 * and make shore, as that looks much better