diff --git a/src/aircraft_cmd.cpp b/src/aircraft_cmd.cpp
index 1ec5ea3ed0..1064658bf6 100644
--- a/src/aircraft_cmd.cpp
+++ b/src/aircraft_cmd.cpp
@@ -841,13 +841,13 @@ static uint8_t AircraftGetEntryPoint(const Aircraft *v, const AirportFTAClass *a
 	DiagDirection dir;
 	if (abs(delta_y) < abs(delta_x)) {
 		/* We are northeast or southwest of the airport */
-		dir = delta_x < 0 ? DIAGDIR_NE : DIAGDIR_SW;
+		dir = delta_x < 0 ? DiagDirection::NE : DiagDirection::SW;
 	} else {
 		/* We are northwest or southeast of the airport */
-		dir = delta_y < 0 ? DIAGDIR_NW : DIAGDIR_SE;
+		dir = delta_y < 0 ? DiagDirection::NW : DiagDirection::SE;
 	}
-	dir = ChangeDiagDir(dir, DiagDirDifference(DIAGDIR_NE, DirToDiagDir(rotation)));
-	return apc->entry_points[dir];
+	dir = ChangeDiagDir(dir, DiagDirDifference(DiagDirection::NE, DirToDiagDir(rotation)));
+	return apc->entry_points[to_underlying(dir)];
 }
 
 
diff --git a/src/cachecheck.cpp b/src/cachecheck.cpp
index eb65e5c7cf..ad5805920a 100644
--- a/src/cachecheck.cpp
+++ b/src/cachecheck.cpp
@@ -74,8 +74,8 @@ void CheckCaches()
 	for (const RoadStop *rs : RoadStop::Iterate()) {
 		if (IsBayRoadStopTile(rs->xy)) continue;
 
-		rs->GetEntry(DIAGDIR_NE).CheckIntegrity(rs);
-		rs->GetEntry(DIAGDIR_NW).CheckIntegrity(rs);
+		rs->GetEntry(DiagDirection::NE).CheckIntegrity(rs);
+		rs->GetEntry(DiagDirection::NW).CheckIntegrity(rs);
 	}
 
 	std::vector<NewGRFCache> grf_cache;
diff --git a/src/clear_cmd.cpp b/src/clear_cmd.cpp
index 5fc79d7eff..3d1b67fca9 100644
--- a/src/clear_cmd.cpp
+++ b/src/clear_cmd.cpp
@@ -76,7 +76,7 @@ static void DrawClearLandFence(const TileInfo *ti)
 
 	bounds.extent.z += GetSlopeMaxPixelZ(ti->tileh);
 
-	uint fence_nw = GetFence(ti->tile, DIAGDIR_NW);
+	uint fence_nw = GetFence(ti->tile, DiagDirection::NW);
 	if (fence_nw != 0) {
 		bounds.offset.x = 0;
 		bounds.offset.y = -static_cast<int>(TILE_SIZE);
@@ -85,7 +85,7 @@ static void DrawClearLandFence(const TileInfo *ti)
 		AddSortableSpriteToDraw(sprite, PAL_NONE, *ti, bounds, false);
 	}
 
-	uint fence_ne = GetFence(ti->tile, DIAGDIR_NE);
+	uint fence_ne = GetFence(ti->tile, DiagDirection::NE);
 	if (fence_ne != 0) {
 		bounds.offset.x = -static_cast<int>(TILE_SIZE);
 		bounds.offset.y = 0;
@@ -94,8 +94,8 @@ static void DrawClearLandFence(const TileInfo *ti)
 		AddSortableSpriteToDraw(sprite, PAL_NONE, *ti, bounds, false);
 	}
 
-	uint fence_sw = GetFence(ti->tile, DIAGDIR_SW);
-	uint fence_se = GetFence(ti->tile, DIAGDIR_SE);
+	uint fence_sw = GetFence(ti->tile, DiagDirection::SW);
+	uint fence_se = GetFence(ti->tile, DiagDirection::SE);
 
 	if (fence_sw != 0 || fence_se != 0) {
 		bounds.offset.x = 0;
@@ -179,7 +179,7 @@ static void UpdateFences(TileIndex tile)
 	assert(IsTileType(tile, TileType::Clear) && IsClearGround(tile, ClearGround::Fields));
 	bool dirty = false;
 
-	for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
+	for (DiagDirection dir = DiagDirection::Begin; dir < DiagDirection::End; dir++) {
 		if (GetFence(tile, dir) != 0) continue;
 		TileIndex neighbour = tile + TileOffsByDiagDir(dir);
 		if (IsTileType(neighbour, TileType::Clear) && IsClearGround(neighbour, ClearGround::Fields)) continue;
@@ -232,7 +232,7 @@ static void TileLoopClearAlps(TileIndex tile)
  */
 static inline bool NeighbourIsNormal(TileIndex tile)
 {
-	for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
+	for (DiagDirection dir = DiagDirection::Begin; dir < DiagDirection::End; dir++) {
 		TileIndex t = tile + TileOffsByDiagDir(dir);
 		if (!IsValidTile(t)) continue;
 		if (GetTropicZone(t) != TropicZone::Desert) return true;
diff --git a/src/clear_map.h b/src/clear_map.h
index c181420c74..fb65880f6f 100644
--- a/src/clear_map.h
+++ b/src/clear_map.h
@@ -217,10 +217,10 @@ inline uint GetFence(Tile t, DiagDirection side)
 	assert(IsClearGround(t, ClearGround::Fields));
 	switch (side) {
 		default: NOT_REACHED();
-		case DIAGDIR_SE: return GB(t.m4(), 2, 3);
-		case DIAGDIR_SW: return GB(t.m4(), 5, 3);
-		case DIAGDIR_NE: return GB(t.m3(), 5, 3);
-		case DIAGDIR_NW: return GB(t.m6(), 2, 3);
+		case DiagDirection::SE: return GB(t.m4(), 2, 3);
+		case DiagDirection::SW: return GB(t.m4(), 5, 3);
+		case DiagDirection::NE: return GB(t.m3(), 5, 3);
+		case DiagDirection::NW: return GB(t.m6(), 2, 3);
 	}
 }
 
@@ -236,10 +236,10 @@ inline void SetFence(Tile t, DiagDirection side, uint h)
 	assert(IsClearGround(t, ClearGround::Fields));
 	switch (side) {
 		default: NOT_REACHED();
-		case DIAGDIR_SE: SB(t.m4(), 2, 3, h); break;
-		case DIAGDIR_SW: SB(t.m4(), 5, 3, h); break;
-		case DIAGDIR_NE: SB(t.m3(), 5, 3, h); break;
-		case DIAGDIR_NW: SB(t.m6(), 2, 3, h); break;
+		case DiagDirection::SE: SB(t.m4(), 2, 3, h); break;
+		case DiagDirection::SW: SB(t.m4(), 5, 3, h); break;
+		case DiagDirection::NE: SB(t.m3(), 5, 3, h); break;
+		case DiagDirection::NW: SB(t.m6(), 2, 3, h); break;
 	}
 }
 
diff --git a/src/direction_func.h b/src/direction_func.h
index ae6ca8e653..74c27948d2 100644
--- a/src/direction_func.h
+++ b/src/direction_func.h
@@ -20,7 +20,7 @@
  */
 inline bool IsValidDiagDirection(DiagDirection d)
 {
-	return d < DIAGDIR_END;
+	return d < DiagDirection::End;
 }
 
 /**
@@ -168,7 +168,7 @@ inline DiagDirection ChangeDiagDir(DiagDirection d, DiagDirDiff delta)
  *
  * This function can be used to convert the 8-way Direction to
  * the 4-way DiagDirection. If the direction cannot be mapped its
- * "rounded clockwise". So DIR_N becomes DIAGDIR_NE.
+ * "rounded clockwise". So DIR_N becomes DiagDirection::NE.
  *
  * @param dir The direction to convert
  * @return The resulting DiagDirection, maybe "rounded clockwise".
@@ -258,8 +258,8 @@ inline DiagDirections AxisToDiagDirs(Axis a)
 {
 	assert(IsValidAxis(a));
 	return a == Axis::X
-		? DiagDirections{DIAGDIR_NE, DIAGDIR_SW}
-		: DiagDirections{DIAGDIR_SE, DIAGDIR_NW};
+		? DiagDirections{DiagDirection::NE, DiagDirection::SW}
+		: DiagDirections{DiagDirection::SE, DiagDirection::NW};
 }
 
 /**
diff --git a/src/direction_type.h b/src/direction_type.h
index 3c07caa3ce..23543cead6 100644
--- a/src/direction_type.h
+++ b/src/direction_type.h
@@ -82,29 +82,30 @@ enum class DirDiff : uint8_t {
  *
  * This enumeration is used for the 4 direction of the tile-edges.
  */
-enum DiagDirection : uint8_t {
-	DIAGDIR_BEGIN = 0,      ///< Used for iterations
-	DIAGDIR_NE  = 0,        ///< Northeast, upper right on your monitor
-	DIAGDIR_SE  = 1,        ///< Southeast
-	DIAGDIR_SW  = 2,        ///< Southwest
-	DIAGDIR_NW  = 3,        ///< Northwest
-	DIAGDIR_END,            ///< Used for iterations
-	INVALID_DIAGDIR = 0xFF, ///< Flag for an invalid DiagDirection
+enum class DiagDirection : uint8_t {
+	Begin = 0, ///< Used for iterations
+	NE = 0, ///< Northeast, upper right on your monitor
+	SE = 1, ///< Southeast
+	SW = 2, ///< Southwest
+	NW = 3, ///< Northwest
+	End, ///< Used for iterations
+	Invalid = 0xFF, ///< Flag for an invalid DiagDirection
 };
 DECLARE_INCREMENT_DECREMENT_OPERATORS(DiagDirection)
 DECLARE_ENUM_AS_ADDABLE(DiagDirection)
 
+/** Bitset of \c DiagDirection elements. */
 using DiagDirections = EnumBitSet<DiagDirection, uint8_t>;
 
 /** All possible diagonal directions. */
-static constexpr DiagDirections DIAGDIRECTIONS_ALL{DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_NW};
+static constexpr DiagDirections DIAGDIRECTIONS_ALL{DiagDirection::NE, DiagDirection::SE, DiagDirection::SW, DiagDirection::NW};
 
 /**
  * Array with \c DiagDirection as index.
  * @tparam T the type contained within the array.
  */
 template <typename T>
-using DiagDirectionIndexArray = EnumIndexArray<T, DiagDirection, DIAGDIR_END>;
+using DiagDirectionIndexArray = EnumIndexArray<T, DiagDirection, DiagDirection::End>;
 
 /**
  * Enumeration for the difference between to DiagDirection.
@@ -112,7 +113,7 @@ using DiagDirectionIndexArray = EnumIndexArray<T, DiagDirection, DIAGDIR_END>;
  * As the DiagDirection only contains 4 possible directions the
  * difference between two of these directions can only be in 4 ways.
  * As the DirDiff enumeration the values can be added together and
- * you will get the resulting difference (use modulo DIAGDIR_END).
+ * you will get the resulting difference (use modulo DiagDirection::End).
  *
  * @see DirDiff
  */
diff --git a/src/dock_gui.cpp b/src/dock_gui.cpp
index 4344b76948..6786377466 100644
--- a/src/dock_gui.cpp
+++ b/src/dock_gui.cpp
@@ -214,7 +214,7 @@ struct BuildDocksToolbarWindow : Window {
 			case WID_DT_STATION: { // Build station button
 				/* Determine the watery part of the dock. */
 				DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile));
-				TileIndex tile_to = (dir != INVALID_DIAGDIR ? TileAddByDiagDir(tile, ReverseDiagDir(dir)) : tile);
+				TileIndex tile_to = (dir != DiagDirection::Invalid ? TileAddByDiagDir(tile, ReverseDiagDir(dir)) : tile);
 
 				bool adjacent = _ctrl_pressed;
 				auto proc = [=](bool test, StationID to_join) -> bool {
diff --git a/src/elrail.cpp b/src/elrail.cpp
index 9f1f51569b..eb9f25e514 100644
--- a/src/elrail.cpp
+++ b/src/elrail.cpp
@@ -133,7 +133,7 @@ static TrackBits MaskWireBits(TileIndex t, TrackBits tracks)
 	if (!IsPlainRailTile(t)) return tracks;
 
 	TrackdirBits neighbour_tdb = TRACKDIR_BIT_NONE;
-	for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
+	for (DiagDirection d = DiagDirection::Begin; d < DiagDirection::End; d++) {
 		/* If the neighbour tile is either not electrified or has no tracks that can be reached
 		 * from this tile, mark all trackdirs that can be reached from the neighbour tile
 		 * as needing no catenary. We make an exception for blocked station tiles with a matching
@@ -309,7 +309,7 @@ static void DrawRailCatenaryRailway(const TileInfo *ti)
 	SpriteID pylon_normal = GetPylonBase(ti->tile);
 	SpriteID pylon_halftile = (halftile_corner != CORNER_INVALID) ? GetPylonBase(ti->tile, TCX_UPPER_HALFTILE) : pylon_normal;
 
-	for (DiagDirection i = DIAGDIR_BEGIN; i < DIAGDIR_END; i++) {
+	for (DiagDirection i = DiagDirection::Begin; i < DiagDirection::End; i++) {
 		SpriteID pylon_base = (halftile_corner != CORNER_INVALID && HasBit(InclinedSlope(i), halftile_corner)) ? pylon_halftile : pylon_normal;
 		TileIndex neighbour = ti->tile + TileOffsByDiagDir(i);
 		int elevation = GetPCPElevation(ti->tile, i);
@@ -525,7 +525,7 @@ void DrawRailCatenaryOnBridge(const TileInfo *ti)
 	/* Finished with wires, draw pylons
 	 * every other tile needs a pylon on the northern end */
 	if (num % 2) {
-		DiagDirection pcp_pos = (axis == Axis::X ? DIAGDIR_NE : DIAGDIR_NW);
+		DiagDirection pcp_pos = (axis == Axis::X ? DiagDirection::NE : DiagDirection::NW);
 		Direction ppp_pos = (axis == Axis::X ? DIR_NW : DIR_NE);
 		if (HasBit(tlg, (axis == Axis::X ? 0 : 1))) ppp_pos = ReverseDir(ppp_pos);
 		uint x = ti->x + _x_pcp_offsets[pcp_pos] + _x_ppp_offsets[ppp_pos];
@@ -535,7 +535,7 @@ void DrawRailCatenaryOnBridge(const TileInfo *ti)
 
 	/* need a pylon on the southern end of the bridge */
 	if (GetTunnelBridgeLength(ti->tile, start) + 1 == length) {
-		DiagDirection pcp_pos = (axis == Axis::X ? DIAGDIR_SW : DIAGDIR_SE);
+		DiagDirection pcp_pos = (axis == Axis::X ? DiagDirection::SW : DiagDirection::SE);
 		Direction ppp_pos = (axis == Axis::X ? DIR_NW : DIR_NE);
 		if (HasBit(tlg, (axis == Axis::X ? 0 : 1))) ppp_pos = ReverseDir(ppp_pos);
 		uint x = ti->x + _x_pcp_offsets[pcp_pos] + _x_ppp_offsets[ppp_pos];
diff --git a/src/ground_vehicle.hpp b/src/ground_vehicle.hpp
index 97684117aa..55300514c0 100644
--- a/src/ground_vehicle.hpp
+++ b/src/ground_vehicle.hpp
@@ -216,7 +216,7 @@ struct GroundVehicle : public SpecializedVehicle<T, Type> {
 			int8_t d = DiagDirToAxis(dir) == Axis::X ? x_pos : y_pos;
 			/* We need only the least significant bit */
 			d &= 1;
-			d ^= (int8_t)(dir == DIAGDIR_NW || dir == DIAGDIR_NE);
+			d ^= (int8_t)(dir == DiagDirection::NW || dir == DiagDirection::NE);
 			/* Subtraction instead of addition because we are testing for GVF_GOINGUP_BIT.
 			 * GVF_GOINGUP_BIT is used because it's bit 0, so simple AND can be used,
 			 * without any shift */
diff --git a/src/industry_cmd.cpp b/src/industry_cmd.cpp
index 6c8eed54ad..1de15e9767 100644
--- a/src/industry_cmd.cpp
+++ b/src/industry_cmd.cpp
@@ -1090,10 +1090,10 @@ static void PlantFarmField(TileIndex tile, IndustryID industry)
 		type = _plantfarmfield_type[Random() & 0xF];
 	}
 
-	SetupFarmFieldFence(ta.tile, ta.h, type, DIAGDIR_NE);
-	SetupFarmFieldFence(ta.tile, ta.w, type, DIAGDIR_NW);
-	SetupFarmFieldFence(ta.tile + TileDiffXY(ta.w - 1, 0), ta.h, type, DIAGDIR_SW);
-	SetupFarmFieldFence(ta.tile + TileDiffXY(0, ta.h - 1), ta.w, type, DIAGDIR_SE);
+	SetupFarmFieldFence(ta.tile, ta.h, type, DiagDirection::NE);
+	SetupFarmFieldFence(ta.tile, ta.w, type, DiagDirection::NW);
+	SetupFarmFieldFence(ta.tile + TileDiffXY(ta.w - 1, 0), ta.h, type, DiagDirection::SW);
+	SetupFarmFieldFence(ta.tile + TileDiffXY(0, ta.h - 1), ta.w, type, DiagDirection::SE);
 }
 
 void PlantRandomFarmField(const Industry *i)
@@ -1293,10 +1293,10 @@ static bool CheckScaledDistanceFromEdge(TileIndex tile, uint maxdist)
 	if (Map::SizeX() > 256) maxdist_x *= Map::SizeX() / 256;
 	if (Map::SizeY() > 256) maxdist_y *= Map::SizeY() / 256;
 
-	if (DistanceFromEdgeDir(tile, DIAGDIR_NE) < maxdist_x) return true;
-	if (DistanceFromEdgeDir(tile, DIAGDIR_NW) < maxdist_y) return true;
-	if (DistanceFromEdgeDir(tile, DIAGDIR_SW) < maxdist_x) return true;
-	if (DistanceFromEdgeDir(tile, DIAGDIR_SE) < maxdist_y) return true;
+	if (DistanceFromEdgeDir(tile, DiagDirection::NE) < maxdist_x) return true;
+	if (DistanceFromEdgeDir(tile, DiagDirection::NW) < maxdist_y) return true;
+	if (DistanceFromEdgeDir(tile, DiagDirection::SW) < maxdist_x) return true;
+	if (DistanceFromEdgeDir(tile, DiagDirection::SE) < maxdist_y) return true;
 
 	return false;
 }
diff --git a/src/landscape.cpp b/src/landscape.cpp
index 10eec7ba76..ee3393f75b 100644
--- a/src/landscape.cpp
+++ b/src/landscape.cpp
@@ -366,10 +366,10 @@ void GetSlopePixelZOnEdge(Slope tileh, DiagDirection edge, int &z1, int &z2)
 	static const DiagDirectionIndexArray<std::array<Slope, 4>> corners{{{
 		/*    corner     |          steep slope
 		 *  z1      z2   |       z1             z2        */
-		{SLOPE_E, SLOPE_N, SLOPE_STEEP_E, SLOPE_STEEP_N}, // DIAGDIR_NE, z1 = E, z2 = N
-		{SLOPE_S, SLOPE_E, SLOPE_STEEP_S, SLOPE_STEEP_E}, // DIAGDIR_SE, z1 = S, z2 = E
-		{SLOPE_S, SLOPE_W, SLOPE_STEEP_S, SLOPE_STEEP_W}, // DIAGDIR_SW, z1 = S, z2 = W
-		{SLOPE_W, SLOPE_N, SLOPE_STEEP_W, SLOPE_STEEP_N}, // DIAGDIR_NW, z1 = W, z2 = N
+		{SLOPE_E, SLOPE_N, SLOPE_STEEP_E, SLOPE_STEEP_N}, // DiagDirection::NE, z1 = E, z2 = N
+		{SLOPE_S, SLOPE_E, SLOPE_STEEP_S, SLOPE_STEEP_E}, // DiagDirection::SE, z1 = S, z2 = E
+		{SLOPE_S, SLOPE_W, SLOPE_STEEP_S, SLOPE_STEEP_W}, // DiagDirection::SW, z1 = S, z2 = W
+		{SLOPE_W, SLOPE_N, SLOPE_STEEP_W, SLOPE_STEEP_N}, // DiagDirection::NW, z1 = W, z2 = N
 	}}};
 
 	Slope halftile_test = IsHalftileSlope(tileh) ? SlopeWithOneCornerRaised(GetHalftileSlopeCorner(tileh)) : SLOPE_FLAT;
@@ -402,12 +402,12 @@ bool HasFoundationNW(TileIndex tile, Slope slope_here, uint z_here)
 {
 	int z_W_here = z_here;
 	int z_N_here = z_here;
-	GetSlopePixelZOnEdge(slope_here, DIAGDIR_NW, z_W_here, z_N_here);
+	GetSlopePixelZOnEdge(slope_here, DiagDirection::NW, z_W_here, z_N_here);
 
 	auto [slope, z] = GetFoundationPixelSlope(TileAddXY(tile, 0, -1));
 	int z_W = z;
 	int z_N = z;
-	GetSlopePixelZOnEdge(slope, DIAGDIR_SE, z_W, z_N);
+	GetSlopePixelZOnEdge(slope, DiagDirection::SE, z_W, z_N);
 
 	return (z_N_here > z_N) || (z_W_here > z_W);
 }
@@ -417,12 +417,12 @@ bool HasFoundationNE(TileIndex tile, Slope slope_here, uint z_here)
 {
 	int z_E_here = z_here;
 	int z_N_here = z_here;
-	GetSlopePixelZOnEdge(slope_here, DIAGDIR_NE, z_E_here, z_N_here);
+	GetSlopePixelZOnEdge(slope_here, DiagDirection::NE, z_E_here, z_N_here);
 
 	auto [slope, z] = GetFoundationPixelSlope(TileAddXY(tile, -1, 0));
 	int z_E = z;
 	int z_N = z;
-	GetSlopePixelZOnEdge(slope, DIAGDIR_SW, z_E, z_N);
+	GetSlopePixelZOnEdge(slope, DiagDirection::SW, z_E, z_N);
 
 	return (z_N_here > z_N) || (z_E_here > z_E);
 }
@@ -560,7 +560,7 @@ void DoClearSquare(TileIndex tile)
  * @param tile tile to get info about
  * @param mode transport type
  * @param sub_mode for TRANSPORT_ROAD, roadtypes to check
- * @param side side we are entering from, INVALID_DIAGDIR to return all trackbits
+ * @param side side we are entering from, DiagDirection::Invalid to return all trackbits
  * @return trackdirbits and other info depending on 'mode'
  */
 TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, RoadTramType sub_mode, DiagDirection side)
@@ -922,7 +922,7 @@ static void GenerateTerrain(int type, uint flag)
 	 * is higher than the height of the map. In other words, this only raises the tile heights. */
 	switch (direction) {
 		default: NOT_REACHED();
-		case DIAGDIR_NE:
+		case DiagDirection::NE:
 			do {
 				TileIndex tile_cur = tile;
 
@@ -935,7 +935,7 @@ static void GenerateTerrain(int type, uint flag)
 			} while (--h != 0);
 			break;
 
-		case DIAGDIR_SE:
+		case DiagDirection::SE:
 			do {
 				TileIndex tile_cur = tile;
 
@@ -948,7 +948,7 @@ static void GenerateTerrain(int type, uint flag)
 			} while (--w != 0);
 			break;
 
-		case DIAGDIR_SW:
+		case DiagDirection::SW:
 			tile += TileDiffXY(w - 1, 0);
 			do {
 				TileIndex tile_cur = tile;
@@ -962,7 +962,7 @@ static void GenerateTerrain(int type, uint flag)
 			} while (--h != 0);
 			break;
 
-		case DIAGDIR_NW:
+		case DiagDirection::NW:
 			tile += TileDiffXY(0, h - 1);
 			do {
 				TileIndex tile_cur = tile;
@@ -1046,7 +1046,7 @@ static bool FindSpring(TileIndex tile)
 	};
 
 	uint num_hills = 0;
-	for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
+	for (DiagDirection d = DiagDirection::Begin; d < DiagDirection::End; d++) {
 		TileIndex check_tile = tile;
 		for (uint i = 0; i < max_hill_distance; i++) {
 			check_tile = TileAddByDiagDir(check_tile, d);
@@ -1089,7 +1089,7 @@ static void MakeLake(TileIndex lake_centre, uint height_lake)
 	for (uint loops = 0; loops < 2; ++loops) {
 		for (TileIndex tile : SpiralTileSequence(lake_centre, diameter)) {
 			if (!IsValidRiverTerminusTile(tile, height_lake)) continue;
-			for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
+			for (DiagDirection d = DiagDirection::Begin; d < DiagDirection::End; d++) {
 				TileIndex t = tile + TileOffsByDiagDir(d);
 				if (IsWaterTile(t)) {
 					MakeRiverAndModifyDesertZoneAround(tile);
@@ -1209,7 +1209,7 @@ void RiverMakeWider(TileIndex tile, TileIndex origin_tile)
 		 */
 
 		/* First, determine the desired slope based on adjacent river tiles. This doesn't necessarily match the origin tile for the SpiralTileSequence. */
-		for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
+		for (DiagDirection d = DiagDirection::Begin; d < DiagDirection::End; d++) {
 			TileIndex other_tile = TileAddByDiagDir(tile, d);
 			Slope other_slope = GetTileSlope(other_tile);
 
@@ -1240,7 +1240,7 @@ void RiverMakeWider(TileIndex tile, TileIndex origin_tile)
 		/* If the river is flat and the adjacent tile has one corner lowered, we want to raise it. */
 		if (desired_slope == SLOPE_FLAT && IsSlopeWithThreeCornersRaised(cur_slope)) {
 			/* Make sure we're not affecting an existing river slope tile. */
-			for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
+			for (DiagDirection d = DiagDirection::Begin; d < DiagDirection::End; d++) {
 				TileIndex other_tile = TileAddByDiagDir(tile, d);
 				if (IsInclinedSlope(GetTileSlope(other_tile)) && IsWaterTile(other_tile)) return;
 			}
@@ -1363,7 +1363,7 @@ static bool CountConnectedSeaTiles(TileIndex tile, std::unordered_set<TileIndex>
 	if (sea.size() > limit) return false;
 
 	/* Count adjacent tiles using recursion. */
-	for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
+	for (DiagDirection d = DiagDirection::Begin; d < DiagDirection::End; d++) {
 		TileIndex t = tile + TileOffsByDiagDir(d);
 		if (IsValidTile(t) && !sea.contains(t)) {
 			if (CountConnectedSeaTiles(t, sea, limit)) return true;
@@ -1430,7 +1430,7 @@ static std::tuple<bool, bool> FlowRiver(TileIndex spring, TileIndex begin, uint
 			}
 		}
 
-		for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
+		for (DiagDirection d = DiagDirection::Begin; d < DiagDirection::End; d++) {
 			TileIndex t = end + TileOffsByDiagDir(d);
 			if (IsValidTile(t) && !marks.contains(t) && RiverFlowsDown(end, t)) {
 				marks.insert(t);
@@ -1542,7 +1542,7 @@ static uint CalculateCoverageLine(uint coverage, uint edge_multiplier)
 
 		if (edge_multiplier != 0) {
 			/* Check if any of our neighbours is below us. */
-			for (DiagDirection dir = DIAGDIR_BEGIN; dir != DIAGDIR_END; dir++) {
+			for (DiagDirection dir = DiagDirection::Begin; dir != DiagDirection::End; dir++) {
 				TileIndex neighbour_tile = AddTileIndexDiffCWrap(tile, TileIndexDiffCByDiagDir(dir));
 				if (IsValidTile(neighbour_tile) && TileHeight(neighbour_tile) < h) {
 					edge_histogram[h]++;
diff --git a/src/map.cpp b/src/map.cpp
index 4443faa2b3..02a4628444 100644
--- a/src/map.cpp
+++ b/src/map.cpp
@@ -139,10 +139,10 @@ extern const AxisIndexArray<TileIndexDiffC> _tileoffs_by_axis{{{
 
 /** 'Lookup table' for tile offsets given a DiagDirection */
 extern const DiagDirectionIndexArray<TileIndexDiffC> _tileoffs_by_diagdir{{{
-	{-1,  0}, // DIAGDIR_NE
-	{ 0,  1}, // DIAGDIR_SE
-	{ 1,  0}, // DIAGDIR_SW
-	{ 0, -1}, // DIAGDIR_NW
+	{-1,  0}, // DiagDirection::NE
+	{ 0,  1}, // DiagDirection::SE
+	{ 1,  0}, // DiagDirection::SW
+	{ 0, -1}, // DiagDirection::NW
 }}};
 
 /** 'Lookup table' for tile offsets given a Direction */
@@ -246,10 +246,10 @@ uint DistanceFromEdge(TileIndex tile)
 uint DistanceFromEdgeDir(TileIndex tile, DiagDirection dir)
 {
 	switch (dir) {
-		case DIAGDIR_NE: return             TileX(tile) - (_settings_game.construction.freeform_edges ? 1 : 0);
-		case DIAGDIR_NW: return             TileY(tile) - (_settings_game.construction.freeform_edges ? 1 : 0);
-		case DIAGDIR_SW: return Map::MaxX() - TileX(tile) - 1;
-		case DIAGDIR_SE: return Map::MaxY() - TileY(tile) - 1;
+		case DiagDirection::NE: return             TileX(tile) - (_settings_game.construction.freeform_edges ? 1 : 0);
+		case DiagDirection::NW: return             TileY(tile) - (_settings_game.construction.freeform_edges ? 1 : 0);
+		case DiagDirection::SW: return Map::MaxX() - TileX(tile) - 1;
+		case DiagDirection::SE: return Map::MaxY() - TileY(tile) - 1;
 		default: NOT_REACHED();
 	}
 }
@@ -279,7 +279,7 @@ uint GetClosestWaterDistance(TileIndex tile, bool water)
 		y--;
 
 		/* going counter-clockwise around this square */
-		for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
+		for (DiagDirection dir = DiagDirection::Begin; dir < DiagDirection::End; dir++) {
 			static constexpr DiagDirectionIndexArray<int8_t> ddx{-1,  1,  1, -1};
 			static constexpr DiagDirectionIndexArray<int8_t> ddy{ 1,  1, -1, -1};
 
diff --git a/src/map_func.h b/src/map_func.h
index 119f9878d8..4dbb57f1d5 100644
--- a/src/map_func.h
+++ b/src/map_func.h
@@ -622,18 +622,18 @@ inline TileIndex TileAddByDiagDir(TileIndex tile, DiagDirection dir)
  * The tiles do not necessarily have to be adjacent.
  * @param tile_from Origin tile
  * @param tile_to Destination tile
- * @return DiagDirection from tile_from towards tile_to, or INVALID_DIAGDIR if the tiles are not on an axis
+ * @return DiagDirection from tile_from towards tile_to, or DiagDirection::Invalid if the tiles are not on an axis
  */
 inline DiagDirection DiagdirBetweenTiles(TileIndex tile_from, TileIndex tile_to)
 {
 	int dx = (int)TileX(tile_to) - (int)TileX(tile_from);
 	int dy = (int)TileY(tile_to) - (int)TileY(tile_from);
 	if (dx == 0) {
-		if (dy == 0) return INVALID_DIAGDIR;
-		return (dy < 0 ? DIAGDIR_NW : DIAGDIR_SE);
+		if (dy == 0) return DiagDirection::Invalid;
+		return (dy < 0 ? DiagDirection::NW : DiagDirection::SE);
 	} else {
-		if (dy != 0) return INVALID_DIAGDIR;
-		return (dx < 0 ? DIAGDIR_NE : DIAGDIR_SW);
+		if (dy != 0) return DiagDirection::Invalid;
+		return (dx < 0 ? DiagDirection::NE : DiagDirection::SW);
 	}
 }
 
diff --git a/src/misc/dbg_helpers.cpp b/src/misc/dbg_helpers.cpp
index e11b6120b4..6c4e922810 100644
--- a/src/misc/dbg_helpers.cpp
+++ b/src/misc/dbg_helpers.cpp
@@ -53,7 +53,7 @@ static const std::string_view diagdir_names[] = {
  */
 std::string ValueStr(DiagDirection dd)
 {
-	return fmt::format("{} ({})", to_underlying(dd), ItemAt(dd, diagdir_names, "UNK", INVALID_DIAGDIR, "INV"));
+	return fmt::format("{} ({})", to_underlying(dd), ItemAt(dd, diagdir_names, "UNK", DiagDirection::Invalid, "INV"));
 }
 
 
diff --git a/src/misc/dbg_helpers.h b/src/misc/dbg_helpers.h
index 9f7ff3b2d1..68159b00c8 100644
--- a/src/misc/dbg_helpers.h
+++ b/src/misc/dbg_helpers.h
@@ -32,7 +32,7 @@ inline std::string_view ItemAt(E idx, std::span<const std::string_view> names, s
 	if (static_cast<size_t>(idx) >= std::size(names)) {
 		return unknown_name;
 	}
-	return names[idx];
+	return names[to_underlying(idx)];
 }
 
 /**
@@ -80,7 +80,7 @@ inline std::string ComposeName(E value, std::span<const std::string_view> names,
 			if ((value & (1 << i)) == 0) continue;
 			out += (!out.empty() ? "+" : "");
 			out += names[i];
-			value &= ~(E)(1 << i);
+			value &= ~static_cast<E>(1 << i);
 		}
 		if (value != 0) {
 			out += (!out.empty() ? "+" : "");
diff --git a/src/newgrf_station.cpp b/src/newgrf_station.cpp
index 748b9a7ace..044517118c 100644
--- a/src/newgrf_station.cpp
+++ b/src/newgrf_station.cpp
@@ -205,11 +205,11 @@ static uint32_t GetRailContinuationInfo(TileIndex tile)
 {
 	/* Tile offsets and exit dirs for X axis */
 	static const Direction x_dir[8] = { DIR_SW, DIR_NE, DIR_SE, DIR_NW, DIR_S, DIR_E, DIR_W, DIR_N };
-	static const DiagDirection x_exits[8] = { DIAGDIR_SW, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NE, DIAGDIR_SW, DIAGDIR_NE };
+	static const DiagDirection x_exits[8] = { DiagDirection::SW, DiagDirection::NE, DiagDirection::SE, DiagDirection::NW, DiagDirection::SW, DiagDirection::NE, DiagDirection::SW, DiagDirection::NE };
 
 	/* Tile offsets and exit dirs for Y axis */
 	static const Direction y_dir[8] = { DIR_SE, DIR_NW, DIR_SW, DIR_NE, DIR_S, DIR_W, DIR_E, DIR_N };
-	static const DiagDirection y_exits[8] = { DIAGDIR_SE, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NW, DIAGDIR_SE, DIAGDIR_NW };
+	static const DiagDirection y_exits[8] = { DiagDirection::SE, DiagDirection::NW, DiagDirection::SW, DiagDirection::NE, DiagDirection::SE, DiagDirection::NW, DiagDirection::SE, DiagDirection::NW };
 
 	Axis axis = GetRailStationAxis(tile);
 
diff --git a/src/object_cmd.cpp b/src/object_cmd.cpp
index 7af12c59d6..7a97e428fe 100644
--- a/src/object_cmd.cpp
+++ b/src/object_cmd.cpp
@@ -818,17 +818,17 @@ static bool TryBuildCoastLighthouse()
 	/* Pick a random perimeter tile to start from. */
 	int perimeter = (GB(r, 16, 16) % (2 * (maxx + maxy))) - maxy;
 	DiagDirection dir;
-	for (dir = DIAGDIR_NE; perimeter > 0; dir++) {
+	for (dir = DiagDirection::NE; perimeter > 0; dir++) {
 		perimeter -= (DiagDirToAxis(dir) == Axis::X) ? maxx : maxy;
 	}
 
 	TileIndex tile;
 	switch (dir) {
 		default:
-		case DIAGDIR_NE: tile = TileXY(maxx - 1, r % maxy); break;
-		case DIAGDIR_SE: tile = TileXY(r % maxx, 1); break;
-		case DIAGDIR_SW: tile = TileXY(1, r % maxy); break;
-		case DIAGDIR_NW: tile = TileXY(r % maxx, maxy - 1); break;
+		case DiagDirection::NE: tile = TileXY(maxx - 1, r % maxy); break;
+		case DiagDirection::SE: tile = TileXY(r % maxx, 1); break;
+		case DiagDirection::SW: tile = TileXY(1, r % maxy); break;
+		case DiagDirection::NW: tile = TileXY(r % maxx, maxy - 1); break;
 	}
 
 	/* Now walk inwards until we find a valid tile, or hit the other edge of the map. */
diff --git a/src/pathfinder/follow_track.hpp b/src/pathfinder/follow_track.hpp
index 6365aaa1dd..e5f30723b2 100644
--- a/src/pathfinder/follow_track.hpp
+++ b/src/pathfinder/follow_track.hpp
@@ -78,7 +78,7 @@ struct CFollowTrackT {
 		this->old_td = INVALID_TRACKDIR;
 		this->new_tile = INVALID_TILE;
 		this->new_td_bits = TRACKDIR_BIT_NONE;
-		this->exitdir = INVALID_DIAGDIR;
+		this->exitdir = DiagDirection::Invalid;
 		this->is_station = false;
 		this->is_bridge = false;
 		this->is_tunnel = false;
@@ -98,7 +98,7 @@ struct CFollowTrackT {
 	/**
 	 * Tests if a tile is a road tile with a single tramtrack (tram can reverse).
 	 * @param tile The tile to get this for.
-	 * @return The direction of the tram bit, or \c INVALID_DIAGDIR when there are no or multiple tram bits.
+	 * @return The direction of the tram bit, or \c DiagDirection::Invalid when there are no or multiple tram bits.
 	 */
 	inline DiagDirection GetSingleTramBit(TileIndex tile)
 	{
@@ -107,14 +107,14 @@ struct CFollowTrackT {
 		if (IsNormalRoadTile(tile)) {
 			RoadBits rb = GetRoadBits(tile, RoadTramType::Tram);
 			switch (rb.base()) {
-				case RoadBits{RoadBit::NW}.base(): return DIAGDIR_NW;
-				case RoadBits{RoadBit::SW}.base(): return DIAGDIR_SW;
-				case RoadBits{RoadBit::SE}.base(): return DIAGDIR_SE;
-				case RoadBits{RoadBit::NE}.base(): return DIAGDIR_NE;
+				case RoadBits{RoadBit::NW}.base(): return DiagDirection::NW;
+				case RoadBits{RoadBit::SW}.base(): return DiagDirection::SW;
+				case RoadBits{RoadBit::SE}.base(): return DiagDirection::SE;
+				case RoadBits{RoadBit::NE}.base(): return DiagDirection::NE;
 				default: break;
 			}
 		}
-		return INVALID_DIAGDIR;
+		return DiagDirection::Invalid;
 	}
 
 	/**
@@ -131,7 +131,7 @@ struct CFollowTrackT {
 		this->err = EC_NONE;
 
 		assert([&]() {
-			if (this->IsTram() && this->GetSingleTramBit(this->old_tile) != INVALID_DIAGDIR) return true; // Skip the check for single tram bits
+			if (this->IsTram() && this->GetSingleTramBit(this->old_tile) != DiagDirection::Invalid) return true; // Skip the check for single tram bits
 			const RoadTramType sub_mode = (IsRoadTT() && this->veh != nullptr) ? (this->IsTram() ? RoadTramType::Tram : RoadTramType::Road) : RoadTramType::Invalid;
 			const TrackdirBits old_tile_valid_dirs = TrackStatusToTrackdirBits(GetTileTrackStatus(this->old_tile, TT(), sub_mode));
 			return (old_tile_valid_dirs & TrackdirToTrackdirBits(this->old_td)) != TRACKDIR_BIT_NONE;
@@ -276,7 +276,7 @@ protected:
 		/* single tram bits can only be left in one direction */
 		if (this->IsTram()) {
 			DiagDirection single_tram = GetSingleTramBit(this->old_tile);
-			if (single_tram != INVALID_DIAGDIR && single_tram != this->exitdir) {
+			if (single_tram != DiagDirection::Invalid && single_tram != this->exitdir) {
 				this->err = EC_NO_WAY;
 				return false;
 			}
@@ -311,7 +311,7 @@ protected:
 		/* single tram bits can only be entered from one direction */
 		if (this->IsTram()) {
 			DiagDirection single_tram = this->GetSingleTramBit(this->new_tile);
-			if (single_tram != INVALID_DIAGDIR && single_tram != ReverseDiagDir(this->exitdir)) {
+			if (single_tram != DiagDirection::Invalid && single_tram != ReverseDiagDir(this->exitdir)) {
 				this->err = EC_NO_WAY;
 				return false;
 			}
diff --git a/src/pathfinder/water_regions.cpp b/src/pathfinder/water_regions.cpp
index 9658cfab8d..c39d999098 100644
--- a/src/pathfinder/water_regions.cpp
+++ b/src/pathfinder/water_regions.cpp
@@ -198,7 +198,7 @@ public:
 
 		const size_t max_element_width = fmt::format("{}", this->NumberOfPatches()).size();
 
-		std::string traversability = fmt::format("{:0{}b}", this->GetEdgeTraversabilityBits(DIAGDIR_NW), WATER_REGION_EDGE_LENGTH);
+		std::string traversability = fmt::format("{:0{}b}", this->GetEdgeTraversabilityBits(DiagDirection::NW), WATER_REGION_EDGE_LENGTH);
 		Debug(map, 9, "    {:{}}", fmt::join(traversability, " "), max_element_width);
 		Debug(map, 9, "  +{:->{}}+", "", WATER_REGION_EDGE_LENGTH * (max_element_width + 1) + 1);
 
@@ -212,11 +212,11 @@ public:
 					line = fmt::format("{:{}} {}", label, max_element_width, line);
 				}
 			}
-			Debug(map, 9, "{} | {}| {}", GB(this->GetEdgeTraversabilityBits(DIAGDIR_SW), y, 1), line, GB(this->GetEdgeTraversabilityBits(DIAGDIR_NE), y, 1));
+			Debug(map, 9, "{} | {}| {}", GB(this->GetEdgeTraversabilityBits(DiagDirection::SW), y, 1), line, GB(this->GetEdgeTraversabilityBits(DiagDirection::NE), y, 1));
 		}
 
 		Debug(map, 9, "  +{:->{}}+", "", WATER_REGION_EDGE_LENGTH * (max_element_width + 1) + 1);
-		traversability = fmt::format("{:0{}b}", this->GetEdgeTraversabilityBits(DIAGDIR_SE), WATER_REGION_EDGE_LENGTH);
+		traversability = fmt::format("{:0{}b}", this->GetEdgeTraversabilityBits(DiagDirection::SE), WATER_REGION_EDGE_LENGTH);
 		Debug(map, 9, "    {:{}}", fmt::join(traversability, " "), max_element_width);
 	}
 };
@@ -235,10 +235,10 @@ static TileIndex GetEdgeTileCoordinate(int region_x, int region_y, DiagDirection
 {
 	assert(x_or_y >= 0 && x_or_y < WATER_REGION_EDGE_LENGTH);
 	switch (side) {
-		case DIAGDIR_NE: return GetTileIndexFromLocalCoordinate(region_x, region_y, 0, x_or_y);
-		case DIAGDIR_SW: return GetTileIndexFromLocalCoordinate(region_x, region_y, WATER_REGION_EDGE_LENGTH - 1, x_or_y);
-		case DIAGDIR_NW: return GetTileIndexFromLocalCoordinate(region_x, region_y, x_or_y, 0);
-		case DIAGDIR_SE: return GetTileIndexFromLocalCoordinate(region_x, region_y, x_or_y, WATER_REGION_EDGE_LENGTH - 1);
+		case DiagDirection::NE: return GetTileIndexFromLocalCoordinate(region_x, region_y, 0, x_or_y);
+		case DiagDirection::SW: return GetTileIndexFromLocalCoordinate(region_x, region_y, WATER_REGION_EDGE_LENGTH - 1, x_or_y);
+		case DiagDirection::NW: return GetTileIndexFromLocalCoordinate(region_x, region_y, x_or_y, 0);
+		case DiagDirection::SE: return GetTileIndexFromLocalCoordinate(region_x, region_y, x_or_y, WATER_REGION_EDGE_LENGTH - 1);
 		default: NOT_REACHED();
 	}
 }
diff --git a/src/pathfinder/yapf/yapf_node.hpp b/src/pathfinder/yapf/yapf_node.hpp
index b3712a3da0..703c215d08 100644
--- a/src/pathfinder/yapf/yapf_node.hpp
+++ b/src/pathfinder/yapf/yapf_node.hpp
@@ -23,7 +23,7 @@ struct CYapfNodeKeyExitDir {
 	{
 		this->tile = tile;
 		this->td = td;
-		this->exitdir = (this->td == INVALID_TRACKDIR) ? INVALID_DIAGDIR : TrackdirToExitdir(this->td);
+		this->exitdir = (this->td == INVALID_TRACKDIR) ? DiagDirection::Invalid : TrackdirToExitdir(this->td);
 	}
 
 	inline int CalcHash() const
diff --git a/src/pathfinder/yapf/yapf_river_builder.cpp b/src/pathfinder/yapf/yapf_river_builder.cpp
index fe8367cfbe..8f98d5707e 100644
--- a/src/pathfinder/yapf/yapf_river_builder.cpp
+++ b/src/pathfinder/yapf/yapf_river_builder.cpp
@@ -88,7 +88,7 @@ public:
 	/** @copydoc CYapfBaseT::PfFollowNodeFunc */
 	inline void PfFollowNode(Node &old_node)
 	{
-		for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; ++d) {
+		for (DiagDirection d = DiagDirection::Begin; d < DiagDirection::End; ++d) {
 			const TileIndex t = old_node.GetTile() + TileOffsByDiagDir(d);
 			if (IsValidTile(t) && RiverFlowsDown(old_node.GetTile(), t)) {
 				Node &node = Yapf().CreateNewNode();
diff --git a/src/pathfinder/yapf/yapf_ship_regions.cpp b/src/pathfinder/yapf/yapf_ship_regions.cpp
index 70baf065a4..a25ac65902 100644
--- a/src/pathfinder/yapf/yapf_ship_regions.cpp
+++ b/src/pathfinder/yapf/yapf_ship_regions.cpp
@@ -62,14 +62,14 @@ struct WaterRegionNode : CYapfNodeT<WaterRegionPatchKey, WaterRegionNode> {
 
 	DiagDirection GetDiagDirFromParent() const
 	{
-		if (this->parent == nullptr) return INVALID_DIAGDIR;
+		if (this->parent == nullptr) return DiagDirection::Invalid;
 		const int dx = this->key.water_region_patch.x - this->parent->key.water_region_patch.x;
 		const int dy = this->key.water_region_patch.y - this->parent->key.water_region_patch.y;
-		if (dx > 0 && dy == 0) return DIAGDIR_SW;
-		if (dx < 0 && dy == 0) return DIAGDIR_NE;
-		if (dx == 0 && dy > 0) return DIAGDIR_SE;
-		if (dx == 0 && dy < 0) return DIAGDIR_NW;
-		return INVALID_DIAGDIR;
+		if (dx > 0 && dy == 0) return DiagDirection::SW;
+		if (dx < 0 && dy == 0) return DiagDirection::NE;
+		if (dx == 0 && dy > 0) return DiagDirection::SE;
+		if (dx == 0 && dy < 0) return DiagDirection::NW;
+		return DiagDirection::Invalid;
 	}
 };
 
diff --git a/src/rail_cmd.cpp b/src/rail_cmd.cpp
index f039f3b5df..57f576a753 100644
--- a/src/rail_cmd.cpp
+++ b/src/rail_cmd.cpp
@@ -1016,7 +1016,7 @@ CommandCost CmdBuildTrainDepot(DoCommandFlags flags, TileIndex tile, RailType ra
 		}
 
 		MarkTileDirtyByTile(tile);
-		AddSideToSignalBuffer(tile, INVALID_DIAGDIR, _current_company);
+		AddSideToSignalBuffer(tile, DiagDirection::Invalid, _current_company);
 		YapfNotifyTrackLayoutChange(tile, DiagDirToDiagTrack(dir));
 	}
 
@@ -2498,16 +2498,16 @@ static void DrawTile_Rail(TileInfo *ti)
 			SpriteID ground = GetCustomRailSprite(rti, ti->tile, RailSpriteType::Ground);
 
 			switch (GetRailDepotDirection(ti->tile)) {
-				case DIAGDIR_NE:
+				case DiagDirection::NE:
 					if (!IsInvisibilitySet(TO_BUILDINGS)) break;
 					[[fallthrough]];
-				case DIAGDIR_SW:
+				case DiagDirection::SW:
 					DrawGroundSprite(ground + RTO_X, PAL_NONE);
 					break;
-				case DIAGDIR_NW:
+				case DiagDirection::NW:
 					if (!IsInvisibilitySet(TO_BUILDINGS)) break;
 					[[fallthrough]];
-				case DIAGDIR_SE:
+				case DiagDirection::SE:
 					DrawGroundSprite(ground + RTO_Y, PAL_NONE);
 					break;
 				default:
@@ -2518,16 +2518,16 @@ static void DrawTile_Rail(TileInfo *ti)
 				SpriteID overlay = GetCustomRailSprite(rti, ti->tile, RailSpriteType::Overlay);
 
 				switch (GetRailDepotDirection(ti->tile)) {
-					case DIAGDIR_NE:
+					case DiagDirection::NE:
 						if (!IsInvisibilitySet(TO_BUILDINGS)) break;
 						[[fallthrough]];
-					case DIAGDIR_SW:
+					case DiagDirection::SW:
 						DrawGroundSprite(overlay + RTO_X, PALETTE_CRASH);
 						break;
-					case DIAGDIR_NW:
+					case DiagDirection::NW:
 						if (!IsInvisibilitySet(TO_BUILDINGS)) break;
 						[[fallthrough]];
-					case DIAGDIR_SE:
+					case DiagDirection::SE:
 						DrawGroundSprite(overlay + RTO_Y, PALETTE_CRASH);
 						break;
 					default:
@@ -2538,16 +2538,16 @@ static void DrawTile_Rail(TileInfo *ti)
 			/* PBS debugging, draw reserved tracks darker */
 			if (_game_mode != GameMode::Menu && _settings_client.gui.show_track_reservation && HasDepotReservation(ti->tile)) {
 				switch (GetRailDepotDirection(ti->tile)) {
-					case DIAGDIR_NE:
+					case DiagDirection::NE:
 						if (!IsInvisibilitySet(TO_BUILDINGS)) break;
 						[[fallthrough]];
-					case DIAGDIR_SW:
+					case DiagDirection::SW:
 						DrawGroundSprite(rti->base_sprites.single_x, PALETTE_CRASH);
 						break;
-					case DIAGDIR_NW:
+					case DiagDirection::NW:
 						if (!IsInvisibilitySet(TO_BUILDINGS)) break;
 						[[fallthrough]];
-					case DIAGDIR_SE:
+					case DiagDirection::SE:
 						DrawGroundSprite(rti->base_sprites.single_y, PALETTE_CRASH);
 						break;
 					default:
@@ -2589,8 +2589,8 @@ void DrawTrainDepotSprite(int x, int y, DiagDirection dir, RailType railtype)
 		SpriteID ground = GetCustomRailSprite(rti, INVALID_TILE, RailSpriteType::Ground);
 
 		switch (dir) {
-			case DIAGDIR_SW: DrawSprite(ground + RTO_X, PAL_NONE, x, y); break;
-			case DIAGDIR_SE: DrawSprite(ground + RTO_Y, PAL_NONE, x, y); break;
+			case DiagDirection::SW: DrawSprite(ground + RTO_X, PAL_NONE, x, y); break;
+			case DiagDirection::SE: DrawSprite(ground + RTO_Y, PAL_NONE, x, y); break;
 			default: break;
 		}
 	}
@@ -2708,7 +2708,7 @@ static void TileLoop_Rail(TileIndex tile)
 		Owner owner = GetTileOwner(tile);
 		DiagDirections fences{};
 
-		for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
+		for (DiagDirection d = DiagDirection::Begin; d < DiagDirection::End; d++) {
 			static constexpr DiagDirectionIndexArray<TrackBits> dir_to_trackbits{TRACK_BIT_3WAY_NE, TRACK_BIT_3WAY_SE, TRACK_BIT_3WAY_SW, TRACK_BIT_3WAY_NW};
 
 			/* Track bit on this edge => no fence. */
@@ -2725,16 +2725,16 @@ static void TileLoop_Rail(TileIndex tile)
 
 		switch (fences.base()) {
 			case DiagDirections{}.base(): break;
-			case DiagDirections{DIAGDIR_NE}.base(): new_ground = RailGroundType::FenceNE; break;
-			case DiagDirections{DIAGDIR_SE}.base(): new_ground = RailGroundType::FenceSE; break;
-			case DiagDirections{DIAGDIR_SW}.base(): new_ground = RailGroundType::FenceSW; break;
-			case DiagDirections{DIAGDIR_NW}.base(): new_ground = RailGroundType::FenceNW; break;
-			case DiagDirections{DIAGDIR_NE, DIAGDIR_SW}.base(): new_ground = RailGroundType::FenceNESW; break;
-			case DiagDirections{DIAGDIR_SE, DIAGDIR_NW}.base(): new_ground = RailGroundType::FenceSENW; break;
-			case DiagDirections{DIAGDIR_NE, DIAGDIR_SE}.base(): new_ground = RailGroundType::FenceVert1; break;
-			case DiagDirections{DIAGDIR_NE, DIAGDIR_NW}.base(): new_ground = RailGroundType::FenceHoriz2; break;
-			case DiagDirections{DIAGDIR_SE, DIAGDIR_SW}.base(): new_ground = RailGroundType::FenceHoriz1; break;
-			case DiagDirections{DIAGDIR_SW, DIAGDIR_NW}.base(): new_ground = RailGroundType::FenceVert2; break;
+			case DiagDirections{DiagDirection::NE}.base(): new_ground = RailGroundType::FenceNE; break;
+			case DiagDirections{DiagDirection::SE}.base(): new_ground = RailGroundType::FenceSE; break;
+			case DiagDirections{DiagDirection::SW}.base(): new_ground = RailGroundType::FenceSW; break;
+			case DiagDirections{DiagDirection::NW}.base(): new_ground = RailGroundType::FenceNW; break;
+			case DiagDirections{DiagDirection::NE, DiagDirection::SW}.base(): new_ground = RailGroundType::FenceNESW; break;
+			case DiagDirections{DiagDirection::SE, DiagDirection::NW}.base(): new_ground = RailGroundType::FenceSENW; break;
+			case DiagDirections{DiagDirection::NE, DiagDirection::SE}.base(): new_ground = RailGroundType::FenceVert1; break;
+			case DiagDirections{DiagDirection::NE, DiagDirection::NW}.base(): new_ground = RailGroundType::FenceHoriz2; break;
+			case DiagDirections{DiagDirection::SE, DiagDirection::SW}.base(): new_ground = RailGroundType::FenceHoriz1; break;
+			case DiagDirections{DiagDirection::SW, DiagDirection::NW}.base(): new_ground = RailGroundType::FenceVert2; break;
 			default: NOT_REACHED();
 		}
 	}
@@ -2800,7 +2800,7 @@ static TrackStatus GetTileTrackStatus_Rail(TileIndex tile, TransportType mode, [
 		case RailTileType::Depot: {
 			DiagDirection dir = GetRailDepotDirection(tile);
 
-			if (side != INVALID_DIAGDIR && side != dir) break;
+			if (side != DiagDirection::Invalid && side != dir) break;
 
 			trackbits = DiagDirToDiagTrackBits(dir);
 			break;
@@ -2981,10 +2981,10 @@ int TicksToLeaveDepot(const Train *v)
 	int length = v->CalcNextVehicleOffset() + 1;
 
 	switch (dir) {
-		case DIAGDIR_NE: return  (static_cast<int>(v->x_pos & TILE_UNIT_MASK) - (_fractcoords_enter[dir].x - length));
-		case DIAGDIR_SE: return -(static_cast<int>(v->y_pos & TILE_UNIT_MASK) - (_fractcoords_enter[dir].y + length));
-		case DIAGDIR_SW: return -(static_cast<int>(v->x_pos & TILE_UNIT_MASK) - (_fractcoords_enter[dir].x + length));
-		case DIAGDIR_NW: return  (static_cast<int>(v->y_pos & TILE_UNIT_MASK) - (_fractcoords_enter[dir].y - length));
+		case DiagDirection::NE: return  (static_cast<int>(v->x_pos & TILE_UNIT_MASK) - (_fractcoords_enter[dir].x - length));
+		case DiagDirection::SE: return -(static_cast<int>(v->y_pos & TILE_UNIT_MASK) - (_fractcoords_enter[dir].y + length));
+		case DiagDirection::SW: return -(static_cast<int>(v->x_pos & TILE_UNIT_MASK) - (_fractcoords_enter[dir].x + length));
+		case DiagDirection::NW: return  (static_cast<int>(v->y_pos & TILE_UNIT_MASK) - (_fractcoords_enter[dir].y - length));
 		default: NOT_REACHED();
 	}
 }
diff --git a/src/rail_gui.cpp b/src/rail_gui.cpp
index 20636a14bf..f0b7f803b3 100644
--- a/src/rail_gui.cpp
+++ b/src/rail_gui.cpp
@@ -137,9 +137,9 @@ static constexpr std::array<DiagDirectionIndexArray<Track>, 3> _place_depot_extr
 
 /** Direction to check for existing track pieces. */
 static constexpr std::array<DiagDirectionIndexArray<DiagDirection>, 3> _place_depot_extra_dir{{
-	{DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE, DIAGDIR_SW}, // First additional track for directions 0..3
-	{DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE, DIAGDIR_SE}, // Second additional track
-	{DIAGDIR_NW, DIAGDIR_NE, DIAGDIR_NW, DIAGDIR_NE}, // Third additional track
+	{DiagDirection::SE, DiagDirection::SW, DiagDirection::SE, DiagDirection::SW}, // First additional track for directions 0..3
+	{DiagDirection::SW, DiagDirection::NW, DiagDirection::NE, DiagDirection::SE}, // Second additional track
+	{DiagDirection::NW, DiagDirection::NE, DiagDirection::NW, DiagDirection::NE}, // Third additional track
 }};
 
 void CcRailDepot(Commands, const CommandCost &result, TileIndex tile, RailType, DiagDirection dir)
@@ -1780,7 +1780,7 @@ struct BuildRailDepotWindow : public PickerWindowBase {
 			AutoRestoreBackup dpi_backup(_cur_dpi, &tmp_dpi);
 			int x = (ir.Width()  - ScaleSpriteTrad(64)) / 2 + ScaleSpriteTrad(31);
 			int y = (ir.Height() + ScaleSpriteTrad(48)) / 2 - ScaleSpriteTrad(31);
-			DrawTrainDepotSprite(x, y, static_cast<DiagDirection>(widget - WID_BRAD_DEPOT_NE + to_underlying(DIAGDIR_NE)), _cur_railtype);
+			DrawTrainDepotSprite(x, y, static_cast<DiagDirection>(widget - WID_BRAD_DEPOT_NE + to_underlying(DiagDirection::NE)), _cur_railtype);
 		}
 	}
 
@@ -1962,7 +1962,7 @@ static void ShowBuildWaypointPicker(Window *parent)
  */
 void InitializeRailGui()
 {
-	_build_depot_direction = DIAGDIR_NW;
+	_build_depot_direction = DiagDirection::NW;
 	_station_gui.sel_class = STAT_CLASS_DFLT;
 	_station_gui.sel_type = 0;
 	_waypoint_gui.sel_class = STAT_CLASS_WAYP;
diff --git a/src/road.cpp b/src/road.cpp
index e4310e6ce0..0632076ea0 100644
--- a/src/road.cpp
+++ b/src/road.cpp
@@ -59,7 +59,7 @@ static bool IsPossibleCrossing(const TileIndex tile, Axis ax)
 RoadBits CleanUpRoadBits(const TileIndex tile, RoadBits org_rb)
 {
 	if (!IsValidTile(tile)) return {};
-	for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
+	for (DiagDirection dir = DiagDirection::Begin; dir < DiagDirection::End; dir++) {
 		const TileIndex neighbour_tile = TileAddByDiagDir(tile, dir);
 
 		/* Get the Roadbit pointing to the neighbour_tile */
diff --git a/src/road_cmd.cpp b/src/road_cmd.cpp
index 4bbaa60ce9..e8e1e55687 100644
--- a/src/road_cmd.cpp
+++ b/src/road_cmd.cpp
@@ -1377,7 +1377,7 @@ void DrawRoadTypeCatenary(const TileInfo *ti, RoadType rt, RoadBits rb)
 		/* On junctions we check whether neighbouring tiles also have catenary, and possibly
 		 * do not draw catenary towards those neighbours, which do not have catenary. */
 		RoadBits rb_new{};
-		for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
+		for (DiagDirection dir = DiagDirection::Begin; dir < DiagDirection::End; dir++) {
 			if (rb.Any(DiagDirToRoadBits(dir))) {
 				TileIndex neighbour = TileAddByDiagDir(ti->tile, dir);
 				if (MayHaveRoad(neighbour)) {
@@ -1807,19 +1807,19 @@ static void DrawTile_Road(TileInfo *ti)
 						DrawRailTileSeq(ti, &_crossing_layout, TO_CATENARY, rail, 0, PAL_NONE);
 						break;
 
-					case DiagDirections{DIAGDIR_NE}.base():
+					case DiagDirections{DiagDirection::NE}.base():
 						DrawRailTileSeq(ti, &_crossing_layout_SW, TO_CATENARY, rail, 0, PAL_NONE);
 						break;
 
-					case DiagDirections{DIAGDIR_SE}.base():
+					case DiagDirections{DiagDirection::SE}.base():
 						DrawRailTileSeq(ti, &_crossing_layout_NW, TO_CATENARY, rail, 0, PAL_NONE);
 						break;
 
-					case DiagDirections{DIAGDIR_SW}.base():
+					case DiagDirections{DiagDirection::SW}.base():
 						DrawRailTileSeq(ti, &_crossing_layout_NE, TO_CATENARY, rail, 0, PAL_NONE);
 						break;
 
-					case DiagDirections{DIAGDIR_NW}.base():
+					case DiagDirections{DiagDirection::NW}.base():
 						DrawRailTileSeq(ti, &_crossing_layout_SE, TO_CATENARY, rail, 0, PAL_NONE);
 						break;
 
@@ -2158,7 +2158,7 @@ static TrackStatus GetTileTrackStatus_Road(TileIndex tile, TransportType mode, R
 					RoadBits bits = GetRoadBits(tile, rtt);
 
 					/* no roadbit at this side of tile, return 0 */
-					if (side != INVALID_DIAGDIR && !DiagDirToRoadBits(side).Any(bits)) break;
+					if (side != DiagDirection::Invalid && !DiagDirToRoadBits(side).Any(bits)) break;
 
 					uint multiplier = drd_to_multiplier[(rtt == RoadTramType::Tram) ? 0 : GetDisallowedRoadDirections(tile).base()];
 					if (!HasRoadWorks(tile)) trackdirbits = static_cast<TrackdirBits>(_road_trackbits[bits.base()] * multiplier);
@@ -2168,7 +2168,7 @@ static TrackStatus GetTileTrackStatus_Road(TileIndex tile, TransportType mode, R
 				case RoadTileType::Crossing: {
 					Axis axis = GetCrossingRoadAxis(tile);
 
-					if (side != INVALID_DIAGDIR && axis != DiagDirToAxis(side)) break;
+					if (side != DiagDirection::Invalid && axis != DiagDirToAxis(side)) break;
 
 					trackdirbits = TrackBitsToTrackdirBits(AxisToTrackBits(axis));
 					if (IsCrossingBarred(tile)) {
@@ -2190,7 +2190,7 @@ static TrackStatus GetTileTrackStatus_Road(TileIndex tile, TransportType mode, R
 				case RoadTileType::Depot: {
 					DiagDirection dir = GetRoadDepotDirection(tile);
 
-					if (side != INVALID_DIAGDIR && side != dir) break;
+					if (side != DiagDirection::Invalid && side != dir) break;
 
 					trackdirbits = TrackBitsToTrackdirBits(DiagDirToDiagTrackBits(dir));
 					break;
diff --git a/src/road_gui.cpp b/src/road_gui.cpp
index 9d8256e151..3dff866f84 100644
--- a/src/road_gui.cpp
+++ b/src/road_gui.cpp
@@ -234,8 +234,8 @@ static void PlaceRoadStop(TileIndex start_tile, TileIndex end_tile, RoadStopType
 {
 	TileArea ta(start_tile, end_tile);
 	DiagDirection ddir = _roadstop_gui.orientation;
-	bool drive_through = ddir >= DIAGDIR_END;
-	if (drive_through) ddir = ddir - DIAGDIR_END; // Adjust picker result to actual direction.
+	bool drive_through = ddir >= DiagDirection::End;
+	if (drive_through) ddir = ddir - DiagDirection::End; // Adjust picker result to actual direction.
 	RoadStopClassID spec_class = _roadstop_gui.sel_class;
 	uint16_t spec_index = _roadstop_gui.sel_type;
 
@@ -284,7 +284,7 @@ static void PlaceRoad_BusStation(TileIndex tile)
 	if (_remove_button_clicked) {
 		VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_REMOVE_BUSSTOP);
 	} else {
-		if (_roadstop_gui.orientation < DIAGDIR_END) { // Not a drive-through stop.
+		if (_roadstop_gui.orientation < DiagDirection::End) { // Not a drive-through stop.
 			VpStartPlaceSizing(tile, (DiagDirToAxis(_roadstop_gui.orientation) == Axis::X) ? VPM_X_LIMITED : VPM_Y_LIMITED, DDSP_BUILD_BUSSTOP);
 		} else {
 			VpStartPlaceSizing(tile, VPM_X_AND_Y_LIMITED, DDSP_BUILD_BUSSTOP);
@@ -302,7 +302,7 @@ static void PlaceRoad_TruckStation(TileIndex tile)
 	if (_remove_button_clicked) {
 		VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_REMOVE_TRUCKSTOP);
 	} else {
-		if (_roadstop_gui.orientation < DIAGDIR_END) { // Not a drive-through stop.
+		if (_roadstop_gui.orientation < DiagDirection::End) { // Not a drive-through stop.
 			VpStartPlaceSizing(tile, (DiagDirToAxis(_roadstop_gui.orientation) == Axis::X) ? VPM_X_LIMITED : VPM_Y_LIMITED, DDSP_BUILD_TRUCKSTOP);
 		} else {
 			VpStartPlaceSizing(tile, VPM_X_AND_Y_LIMITED, DDSP_BUILD_TRUCKSTOP);
@@ -1193,7 +1193,7 @@ struct BuildRoadDepotWindow : public PickerWindowBase {
 			AutoRestoreBackup dpi_backup(_cur_dpi, &tmp_dpi);
 			int x = (ir.Width()  - ScaleSpriteTrad(64)) / 2 + ScaleSpriteTrad(31);
 			int y = (ir.Height() + ScaleSpriteTrad(48)) / 2 - ScaleSpriteTrad(31);
-			DrawRoadDepotSprite(x, y, static_cast<DiagDirection>(widget - WID_BROD_DEPOT_NE + to_underlying(DIAGDIR_NE)), _cur_roadtype);
+			DrawRoadDepotSprite(x, y, static_cast<DiagDirection>(widget - WID_BROD_DEPOT_NE + to_underlying(DiagDirection::NE)), _cur_roadtype);
 		}
 	}
 
@@ -1325,7 +1325,7 @@ public:
 			StationPickerDrawSprite(x, y, roadstoptype == RoadStopType::Bus ? StationType::Bus : StationType::Truck, INVALID_RAILTYPE, _cur_roadtype, to_underlying(_roadstop_gui.orientation));
 		} else {
 			DiagDirection orientation = _roadstop_gui.orientation;
-			if (orientation < DIAGDIR_END && spec->flags.Test(RoadStopSpecFlag::DriveThroughOnly)) orientation = DIAGDIR_END;
+			if (orientation < DiagDirection::End && spec->flags.Test(RoadStopSpecFlag::DriveThroughOnly)) orientation = DiagDirection::End;
 			DrawRoadStopTile(x, y, _cur_roadtype, spec, roadstoptype == RoadStopType::Bus ? StationType::Bus : StationType::Truck, to_underlying(orientation));
 		}
 	}
@@ -1378,11 +1378,11 @@ private:
 			this->LowerWidget(WID_BROS_STATION_NE + _roadstop_gui.orientation);
 		}
 
-		if (_roadstop_gui.orientation >= DIAGDIR_END) return;
+		if (_roadstop_gui.orientation >= DiagDirection::End) return;
 
 		if (spec != nullptr && spec->flags.Test(RoadStopSpecFlag::DriveThroughOnly)) {
 			this->RaiseWidget(WID_BROS_STATION_NE + _roadstop_gui.orientation);
-			_roadstop_gui.orientation = DIAGDIR_END;
+			_roadstop_gui.orientation = DiagDirection::End;
 			this->LowerWidget(WID_BROS_STATION_NE + _roadstop_gui.orientation);
 			this->SetDirty();
 			CloseWindowById(WindowClass::JoinStation, 0);
@@ -1395,8 +1395,8 @@ public:
 		this->coverage_height = 2 * GetCharacterHeight(FontSize::Normal) + WidgetDimensions::scaled.vsep_normal;
 
 		/* Trams don't have non-drivethrough stations */
-		if (RoadTypeIsTram(_cur_roadtype) && _roadstop_gui.orientation < DIAGDIR_END) {
-			_roadstop_gui.orientation = DIAGDIR_END;
+		if (RoadTypeIsTram(_cur_roadtype) && _roadstop_gui.orientation < DiagDirection::End) {
+			_roadstop_gui.orientation = DiagDirection::End;
 		}
 		this->ConstructWindow();
 
@@ -1815,8 +1815,8 @@ static void ShowBuildRoadWaypointPicker(Window *parent)
 
 void InitializeRoadGui()
 {
-	_road_depot_orientation = DIAGDIR_NW;
-	_roadstop_gui.orientation = DIAGDIR_NW;
+	_road_depot_orientation = DiagDirection::NW;
+	_roadstop_gui.orientation = DiagDirection::NW;
 	_waypoint_gui.sel_class = ROADSTOP_CLASS_WAYP;
 	_waypoint_gui.sel_type = 0;
 }
diff --git a/src/roadstop.cpp b/src/roadstop.cpp
index 190d99f702..45b0ed17c5 100644
--- a/src/roadstop.cpp
+++ b/src/roadstop.cpp
@@ -307,8 +307,8 @@ void RoadStop::Entry::Enter(const RoadVehicle *rv)
 static DiagDirection GetEntryDirection(bool east, Axis axis)
 {
 	switch (axis) {
-		case Axis::X: return east ? DIAGDIR_NE : DIAGDIR_SW;
-		case Axis::Y: return east ? DIAGDIR_SE : DIAGDIR_NW;
+		case Axis::X: return east ? DiagDirection::NE : DiagDirection::SW;
+		case Axis::Y: return east ? DiagDirection::SE : DiagDirection::NW;
 		default: NOT_REACHED();
 	}
 }
diff --git a/src/roadstop_base.h b/src/roadstop_base.h
index 96f64a417e..85d7028117 100644
--- a/src/roadstop_base.h
+++ b/src/roadstop_base.h
@@ -128,7 +128,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
 	 */
 	inline const Entry &GetEntry(DiagDirection dir) const
 	{
-		return dir >= DIAGDIR_SW ? this->entries->west : this->entries->east;
+		return dir >= DiagDirection::SW ? this->entries->west : this->entries->east;
 	}
 
 	/**
@@ -138,7 +138,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
 	 */
 	inline Entry &GetEntry(DiagDirection dir)
 	{
-		return dir >= DIAGDIR_SW ? this->entries->west : this->entries->east;
+		return dir >= DiagDirection::SW ? this->entries->west : this->entries->east;
 	}
 
 	void MakeDriveThrough();
diff --git a/src/roadveh_cmd.cpp b/src/roadveh_cmd.cpp
index fb4b6fde87..2e8a54a80c 100644
--- a/src/roadveh_cmd.cpp
+++ b/src/roadveh_cmd.cpp
@@ -1066,7 +1066,7 @@ static Trackdir FollowPreviousRoadVehicle(const RoadVehicle *v, const RoadVehicl
 	Trackdir dir;
 
 	if (prev_state == RVSB_WORMHOLE || prev_state == RVSB_IN_DEPOT) {
-		DiagDirection diag_dir = INVALID_DIAGDIR;
+		DiagDirection diag_dir = DiagDirection::Invalid;
 
 		if (IsTileType(tile, TileType::TunnelBridge)) {
 			diag_dir = GetTunnelBridgeDirection(tile);
@@ -1074,7 +1074,7 @@ static Trackdir FollowPreviousRoadVehicle(const RoadVehicle *v, const RoadVehicl
 			diag_dir = ReverseDiagDir(GetRoadDepotDirection(tile));
 		}
 
-		if (diag_dir == INVALID_DIAGDIR) return INVALID_TRACKDIR;
+		if (diag_dir == DiagDirection::Invalid) return INVALID_TRACKDIR;
 		dir = DiagDirToDiagTrackdir(diag_dir);
 	} else {
 		if (already_reversed && (prev->tile != tile || (prev_state < TRACKDIR_END && IsReversingRoadTrackdir(static_cast<Trackdir>(prev_state))))) {
@@ -1381,10 +1381,10 @@ again:
 			turn_around_start_frame = RVC_START_FRAME_AFTER_LONG_TRAM;
 			switch (static_cast<DiagDirection>(rd.x & 0x3)) {
 				default: NOT_REACHED();
-				case DIAGDIR_NW: dir = TRACKDIR_RVREV_SE; break;
-				case DIAGDIR_NE: dir = TRACKDIR_RVREV_SW; break;
-				case DIAGDIR_SE: dir = TRACKDIR_RVREV_NW; break;
-				case DIAGDIR_SW: dir = TRACKDIR_RVREV_NE; break;
+				case DiagDirection::NW: dir = TRACKDIR_RVREV_SE; break;
+				case DiagDirection::NE: dir = TRACKDIR_RVREV_SW; break;
+				case DiagDirection::SE: dir = TRACKDIR_RVREV_NW; break;
+				case DiagDirection::SW: dir = TRACKDIR_RVREV_NE; break;
 			}
 		} else {
 			if (v->IsFrontEngine()) {
diff --git a/src/saveload/afterload.cpp b/src/saveload/afterload.cpp
index 7159e3c65c..27ca45e9b8 100644
--- a/src/saveload/afterload.cpp
+++ b/src/saveload/afterload.cpp
@@ -114,7 +114,7 @@ void SetWaterClassDependingOnSurroundings(Tile t, bool include_invalid_water_cla
 	bool has_canal = false;
 	bool has_river = false;
 
-	for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
+	for (DiagDirection dir = DiagDirection::Begin; dir < DiagDirection::End; dir++) {
 		Tile neighbour = TileAddByDiagDir(t, dir);
 		switch (GetTileType(neighbour)) {
 			case TileType::Water:
@@ -436,7 +436,7 @@ static void FixOwnerOfRailTrack(Tile t)
 	}
 
 	/* try to find any connected rail */
-	for (DiagDirection dd = DIAGDIR_BEGIN; dd < DIAGDIR_END; dd++) {
+	for (DiagDirection dd = DiagDirection::Begin; dd < DiagDirection::End; dd++) {
 		TileIndex tt{t + TileOffsByDiagDir(dd)};
 		if (GetTileTrackStatus(t, TRANSPORT_RAIL, RoadTramType::Invalid, dd) != 0 &&
 				GetTileTrackStatus(tt, TRANSPORT_RAIL, RoadTramType::Invalid, ReverseDiagDir(dd)) != 0 &&
@@ -1285,10 +1285,10 @@ bool AfterLoadGame()
 				if (dir != DirToDiagDir(v->direction)) continue;
 				switch (dir) {
 					default: SlErrorCorrupt("Invalid vehicle direction");
-					case DIAGDIR_NE: if ((v->x_pos & 0xF) !=  0)            continue; break;
-					case DIAGDIR_SE: if ((v->y_pos & 0xF) != TILE_SIZE - 1) continue; break;
-					case DIAGDIR_SW: if ((v->x_pos & 0xF) != TILE_SIZE - 1) continue; break;
-					case DIAGDIR_NW: if ((v->y_pos & 0xF) !=  0)            continue; break;
+					case DiagDirection::NE: if ((v->x_pos & 0xF) !=  0)            continue; break;
+					case DiagDirection::SE: if ((v->y_pos & 0xF) != TILE_SIZE - 1) continue; break;
+					case DiagDirection::SW: if ((v->x_pos & 0xF) != TILE_SIZE - 1) continue; break;
+					case DiagDirection::NW: if ((v->y_pos & 0xF) !=  0)            continue; break;
 				}
 			} else if (v->z_pos > GetTileMaxPixelZ(TileVirtXY(v->x_pos, v->y_pos))) {
 				v->tile = GetNorthernBridgeEnd(v->tile);
@@ -2647,7 +2647,7 @@ bool AfterLoadGame()
 
 			/* Have we passed the visibility "switch" state already? */
 			uint8_t pos = (DiagDirToAxis(vdir) == Axis::X ? v->x_pos : v->y_pos) & TILE_UNIT_MASK;
-			uint8_t frame = (vdir == DIAGDIR_NE || vdir == DIAGDIR_NW) ? TILE_SIZE - 1 - pos : pos;
+			uint8_t frame = (vdir == DiagDirection::NE || vdir == DiagDirection::NW) ? TILE_SIZE - 1 - pos : pos;
 			extern const DiagDirectionIndexArray<uint8_t> _tunnel_visibility_frame;
 
 			/* Should the vehicle be hidden or not? */
@@ -2916,11 +2916,11 @@ bool AfterLoadGame()
 			if (IsTileType(t, TileType::Clear) && IsClearGround(t, ClearGround::Fields)) continue;
 			uint fence = GB(t.m4(), 5, 3);
 			if (fence != 0 && IsTileType(TileAddXY(t, 1, 0), TileType::Clear) && IsClearGround(TileAddXY(t, 1, 0), ClearGround::Fields)) {
-				SetFence(TileAddXY(t, 1, 0), DIAGDIR_NE, fence);
+				SetFence(TileAddXY(t, 1, 0), DiagDirection::NE, fence);
 			}
 			fence = GB(t.m4(), 2, 3);
 			if (fence != 0 && IsTileType(TileAddXY(t, 0, 1), TileType::Clear) && IsClearGround(TileAddXY(t, 0, 1), ClearGround::Fields)) {
-				SetFence(TileAddXY(t, 0, 1), DIAGDIR_NW, fence);
+				SetFence(TileAddXY(t, 0, 1), DiagDirection::NW, fence);
 			}
 			SB(t.m4(), 2, 3, 0);
 			SB(t.m4(), 5, 3, 0);
@@ -3190,10 +3190,10 @@ bool AfterLoadGame()
 			DiagDirection shipdiagdir = DirToDiagDir(s->direction);
 			switch (shipdiagdir) {
 				default: NOT_REACHED();
-				case DIAGDIR_NE: second_half = x < 8; break;
-				case DIAGDIR_NW: second_half = y < 8; break;
-				case DIAGDIR_SW: second_half = x > 8; break;
-				case DIAGDIR_SE: second_half = y > 8; break;
+				case DiagDirection::NE: second_half = x < 8; break;
+				case DiagDirection::NW: second_half = y < 8; break;
+				case DiagDirection::SW: second_half = x > 8; break;
+				case DiagDirection::SE: second_half = y > 8; break;
 			}
 
 			DiagDirection slopediagdir = GetInclinedSlopeDirection(GetTileSlope(s->tile));
diff --git a/src/saveload/station_sl.cpp b/src/saveload/station_sl.cpp
index 07664c275d..68dfa445db 100644
--- a/src/saveload/station_sl.cpp
+++ b/src/saveload/station_sl.cpp
@@ -151,8 +151,8 @@ void AfterLoadRoadStops()
 	for (RoadStop *rs : RoadStop::Iterate()) {
 		if (!rs->status.Test(RoadStop::RoadStopStatusFlag::BaseEntry)) continue;
 
-		rs->GetEntry(DIAGDIR_NE).Rebuild(rs);
-		rs->GetEntry(DIAGDIR_NW).Rebuild(rs);
+		rs->GetEntry(DiagDirection::NE).Rebuild(rs);
+		rs->GetEntry(DiagDirection::NW).Rebuild(rs);
 	}
 }
 
diff --git a/src/script/api/script_rail.cpp b/src/script/api/script_rail.cpp
index 24a9cff31b..952288a598 100644
--- a/src/script/api/script_rail.cpp
+++ b/src/script/api/script_rail.cpp
@@ -143,7 +143,7 @@
 	EnforcePrecondition(false, ::TileX(tile) == ::TileX(front) || ::TileY(tile) == ::TileY(front));
 	EnforcePrecondition(false, IsRailTypeAvailable(GetCurrentRailType()));
 
-	DiagDirection entrance_dir = (::TileX(tile) == ::TileX(front)) ? (::TileY(tile) < ::TileY(front) ? DIAGDIR_SE : DIAGDIR_NW) : (::TileX(tile) < ::TileX(front) ? DIAGDIR_SW : DIAGDIR_NE);
+	DiagDirection entrance_dir = (::TileX(tile) == ::TileX(front)) ? (::TileY(tile) < ::TileY(front) ? DiagDirection::SE : DiagDirection::NW) : (::TileX(tile) < ::TileX(front) ? DiagDirection::SW : DiagDirection::NE);
 
 	return ScriptObject::Command<Commands::BuildRailDepot>::Do(tile, (::RailType)ScriptObject::GetRailType(), entrance_dir);
 }
diff --git a/src/script/api/script_road.cpp b/src/script/api/script_road.cpp
index 3b01c6a704..b07c63965b 100644
--- a/src/script/api/script_road.cpp
+++ b/src/script/api/script_road.cpp
@@ -489,10 +489,10 @@ static bool NeighbourHasReachableRoad(::RoadType rt, TileIndex start_tile, DiagD
 	::RoadType rt = (::RoadType)GetCurrentRoadType();
 	int32_t neighbour = 0;
 
-	if (TileX(tile) > 0 && NeighbourHasReachableRoad(rt, tile, DIAGDIR_NE)) neighbour++;
-	if (NeighbourHasReachableRoad(rt, tile, DIAGDIR_SE)) neighbour++;
-	if (NeighbourHasReachableRoad(rt, tile, DIAGDIR_SW)) neighbour++;
-	if (TileY(tile) > 0 && NeighbourHasReachableRoad(rt, tile, DIAGDIR_NW)) neighbour++;
+	if (TileX(tile) > 0 && NeighbourHasReachableRoad(rt, tile, DiagDirection::NE)) neighbour++;
+	if (NeighbourHasReachableRoad(rt, tile, DiagDirection::SE)) neighbour++;
+	if (NeighbourHasReachableRoad(rt, tile, DiagDirection::SW)) neighbour++;
+	if (TileY(tile) > 0 && NeighbourHasReachableRoad(rt, tile, DiagDirection::NW)) neighbour++;
 
 	return neighbour;
 }
@@ -565,7 +565,7 @@ static bool NeighbourHasReachableRoad(::RoadType rt, TileIndex start_tile, DiagD
 	EnforcePrecondition(false, ::TileX(tile) == ::TileX(front) || ::TileY(tile) == ::TileY(front));
 	EnforcePrecondition(false, IsRoadTypeAvailable(GetCurrentRoadType()));
 
-	DiagDirection entrance_dir = (::TileX(tile) == ::TileX(front)) ? (::TileY(tile) < ::TileY(front) ? DIAGDIR_SE : DIAGDIR_NW) : (::TileX(tile) < ::TileX(front) ? DIAGDIR_SW : DIAGDIR_NE);
+	DiagDirection entrance_dir = (::TileX(tile) == ::TileX(front)) ? (::TileY(tile) < ::TileY(front) ? DiagDirection::SE : DiagDirection::NW) : (::TileX(tile) < ::TileX(front) ? DiagDirection::SW : DiagDirection::NE);
 
 	return ScriptObject::Command<Commands::BuildRoadDepot>::Do(tile, ScriptObject::GetRoadType(), entrance_dir);
 }
diff --git a/src/script/api/script_tunnel.cpp b/src/script/api/script_tunnel.cpp
index 8cb71f1480..40a49ad830 100644
--- a/src/script/api/script_tunnel.cpp
+++ b/src/script/api/script_tunnel.cpp
@@ -33,7 +33,7 @@
 
 	auto [start_tileh, start_z] = ::GetTileSlopeZ(tile);
 	DiagDirection direction = ::GetInclinedSlopeDirection(start_tileh);
-	if (direction == INVALID_DIAGDIR) return INVALID_TILE;
+	if (direction == DiagDirection::Invalid) return INVALID_TILE;
 
 	TileIndexDiff delta = ::TileOffsByDiagDir(direction);
 	int end_z;
diff --git a/src/ship_cmd.cpp b/src/ship_cmd.cpp
index f2a8ad4c4e..6ed0f15645 100644
--- a/src/ship_cmd.cpp
+++ b/src/ship_cmd.cpp
@@ -569,7 +569,7 @@ bool IsShipDestinationTile(TileIndex tile, StationID station)
 {
 	assert(IsDockingTile(tile));
 	/* Check each tile adjacent to docking tile. */
-	for (DiagDirection d = DIAGDIR_BEGIN; d != DIAGDIR_END; d++) {
+	for (DiagDirection d = DiagDirection::Begin; d != DiagDirection::End; d++) {
 		TileIndex t = tile + TileOffsByDiagDir(d);
 		if (!IsValidTile(t)) continue;
 		if (IsDockTile(t) && GetStationIndex(t) == station && IsDockWaterPart(t)) return true;
@@ -713,7 +713,7 @@ static void ShipController(Ship *v)
 				if (!IsValidTile(gp.new_tile)) return ReverseShip(v);
 
 				const DiagDirection diagdir = DiagdirBetweenTiles(gp.old_tile, gp.new_tile);
-				assert(diagdir != INVALID_DIAGDIR);
+				assert(diagdir != DiagDirection::Invalid);
 				const TrackBits tracks = GetAvailShipTracks(gp.new_tile, diagdir);
 				if (tracks == TRACK_BIT_NONE) {
 					Trackdir trackdir = INVALID_TRACKDIR;
diff --git a/src/signal.cpp b/src/signal.cpp
index bd462a43e3..ba9e3b9998 100644
--- a/src/signal.cpp
+++ b/src/signal.cpp
@@ -275,18 +275,18 @@ static SigFlags ExploreSegment(Owner owner)
 	SigFlags flags{};
 
 	TileIndex tile = INVALID_TILE; // Stop GCC from complaining about a possibly uninitialized variable (issue #8280).
-	DiagDirection enterdir = INVALID_DIAGDIR;
+	DiagDirection enterdir = DiagDirection::Invalid;
 
 	while (_tbdset.Get(&tile, &enterdir)) { // tile and enterdir are initialized here, unless I'm mistaken.
 		TileIndex oldtile = tile; // tile we are leaving
-		DiagDirection exitdir = enterdir == INVALID_DIAGDIR ? INVALID_DIAGDIR : ReverseDiagDir(enterdir); // expected new exit direction (for straight line)
+		DiagDirection exitdir = enterdir == DiagDirection::Invalid ? DiagDirection::Invalid : ReverseDiagDir(enterdir); // expected new exit direction (for straight line)
 
 		switch (GetTileType(tile)) {
 			case TileType::Railway: {
 				if (GetTileOwner(tile) != owner) continue; // do not propagate signals on others' tiles (remove for tracksharing)
 
 				if (IsRailDepot(tile)) {
-					if (enterdir == INVALID_DIAGDIR) { // from 'inside' - train just entered or left the depot
+					if (enterdir == DiagDirection::Invalid) { // from 'inside' - train just entered or left the depot
 						if (!flags.Test(SigFlag::Train) && HasVehicleOnTile(tile, IsTrainAndNotInDepot)) flags.Set(SigFlag::Train);
 						exitdir = GetRailDepotDirection(tile);
 						tile += TileOffsByDiagDir(exitdir);
@@ -348,7 +348,7 @@ static SigFlags ExploreSegment(Owner owner)
 					}
 				}
 
-				for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) { // test all possible exit directions
+				for (DiagDirection dir = DiagDirection::Begin; dir < DiagDirection::End; dir++) { // test all possible exit directions
 					if (dir != enterdir && (tracks & _enterdir_to_trackbits[dir])) { // any accessible track?
 						TileIndex newtile = tile + TileOffsByDiagDir(dir);  // new tile to check
 						DiagDirection newdir = ReverseDiagDir(dir); // direction we are entering from
@@ -383,7 +383,7 @@ static SigFlags ExploreSegment(Owner owner)
 				if (GetTunnelBridgeTransportType(tile) != TRANSPORT_RAIL) continue;
 				DiagDirection dir = GetTunnelBridgeDirection(tile);
 
-				if (enterdir == INVALID_DIAGDIR) { // incoming from the wormhole
+				if (enterdir == DiagDirection::Invalid) { // incoming from the wormhole
 					if (!flags.Test(SigFlag::Train) && HasVehicleOnTile(tile, IsTrainAndNotInDepot)) flags.Set(SigFlag::Train);
 					enterdir = dir;
 					exitdir = ReverseDiagDir(dir);
@@ -392,8 +392,8 @@ static SigFlags ExploreSegment(Owner owner)
 					if (ReverseDiagDir(enterdir) != dir) continue;
 					if (!flags.Test(SigFlag::Train) && HasVehicleOnTile(tile, IsTrainAndNotInDepot)) flags.Set(SigFlag::Train);
 					tile = GetOtherTunnelBridgeEnd(tile); // just skip to exit tile
-					enterdir = INVALID_DIAGDIR;
-					exitdir = INVALID_DIAGDIR;
+					enterdir = DiagDirection::Invalid;
+					exitdir = DiagDirection::Invalid;
 				}
 				}
 				break;
@@ -491,7 +491,7 @@ static SigSegState UpdateSignalsInBuffer(Owner owner)
 	SigSegState state = SIGSEG_FREE; // value to return
 
 	TileIndex tile = INVALID_TILE; // Stop GCC from complaining about a possibly uninitialized variable (issue #8280).
-	DiagDirection dir = INVALID_DIAGDIR;
+	DiagDirection dir = DiagDirection::Invalid;
 
 	while (_globset.Get(&tile, &dir)) {
 		assert(_tbuset.IsEmpty());
@@ -506,16 +506,16 @@ static SigSegState UpdateSignalsInBuffer(Owner owner)
 			case TileType::TunnelBridge:
 				/* 'optimization assert' - do not try to update signals when it is not needed */
 				assert(GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL);
-				assert(dir == INVALID_DIAGDIR || dir == ReverseDiagDir(GetTunnelBridgeDirection(tile)));
-				_tbdset.Add(tile, INVALID_DIAGDIR);  // we can safely start from wormhole centre
-				_tbdset.Add(GetOtherTunnelBridgeEnd(tile), INVALID_DIAGDIR);
+				assert(dir == DiagDirection::Invalid || dir == ReverseDiagDir(GetTunnelBridgeDirection(tile)));
+				_tbdset.Add(tile, DiagDirection::Invalid);  // we can safely start from wormhole centre
+				_tbdset.Add(GetOtherTunnelBridgeEnd(tile), DiagDirection::Invalid);
 				break;
 
 			case TileType::Railway:
 				if (IsRailDepot(tile)) {
 					/* 'optimization assert' do not try to update signals in other cases */
-					assert(dir == INVALID_DIAGDIR || dir == GetRailDepotDirection(tile));
-					_tbdset.Add(tile, INVALID_DIAGDIR); // start from depot inside
+					assert(dir == DiagDirection::Invalid || dir == GetRailDepotDirection(tile));
+					_tbdset.Add(tile, DiagDirection::Invalid); // start from depot inside
 					break;
 				}
 				[[fallthrough]];
@@ -596,10 +596,10 @@ void UpdateSignalsInBuffer()
 void AddTrackToSignalBuffer(TileIndex tile, Track track, Owner owner)
 {
 	static const DiagDirection _search_dir_1[] = {
-		DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE
+		DiagDirection::NE, DiagDirection::SE, DiagDirection::NE, DiagDirection::SE, DiagDirection::SW, DiagDirection::SE
 	};
 	static const DiagDirection _search_dir_2[] = {
-		DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE
+		DiagDirection::SW, DiagDirection::NW, DiagDirection::NW, DiagDirection::SW, DiagDirection::NW, DiagDirection::NE
 	};
 
 	/* do not allow signal updates for two companies in one run */
diff --git a/src/slope_func.h b/src/slope_func.h
index 3e306d4439..f478559720 100644
--- a/src/slope_func.h
+++ b/src/slope_func.h
@@ -234,16 +234,16 @@ inline bool IsInclinedSlope(Slope s)
  * Returns the direction of an inclined slope.
  *
  * @param s A #Slope
- * @return The direction the slope goes up in. Or INVALID_DIAGDIR if the slope is not an inclined slope.
+ * @return The direction the slope goes up in. Or DiagDirection::Invalid if the slope is not an inclined slope.
  */
 inline DiagDirection GetInclinedSlopeDirection(Slope s)
 {
 	switch (s) {
-		case SLOPE_NE: return DIAGDIR_NE;
-		case SLOPE_SE: return DIAGDIR_SE;
-		case SLOPE_SW: return DIAGDIR_SW;
-		case SLOPE_NW: return DIAGDIR_NW;
-		default: return INVALID_DIAGDIR;
+		case SLOPE_NE: return DiagDirection::NE;
+		case SLOPE_SE: return DiagDirection::SE;
+		case SLOPE_SW: return DiagDirection::SW;
+		case SLOPE_NW: return DiagDirection::NW;
+		default: return DiagDirection::Invalid;
 	}
 }
 
@@ -256,10 +256,10 @@ inline DiagDirection GetInclinedSlopeDirection(Slope s)
 inline Slope InclinedSlope(DiagDirection dir)
 {
 	switch (dir) {
-		case DIAGDIR_NE: return SLOPE_NE;
-		case DIAGDIR_SE: return SLOPE_SE;
-		case DIAGDIR_SW: return SLOPE_SW;
-		case DIAGDIR_NW: return SLOPE_NW;
+		case DiagDirection::NE: return SLOPE_NE;
+		case DiagDirection::SE: return SLOPE_SE;
+		case DiagDirection::SW: return SLOPE_SW;
+		case DiagDirection::NW: return SLOPE_NW;
 		default: NOT_REACHED();
 	}
 }
diff --git a/src/station.cpp b/src/station.cpp
index 960390cd04..fbb91d8bf8 100644
--- a/src/station.cpp
+++ b/src/station.cpp
@@ -294,7 +294,7 @@ void Station::MarkTilesDirty(bool cargo_change) const
 	TileIndex start_tile = tile;
 	uint length = 0;
 	assert(IsRailStationTile(tile));
-	assert(dir < DIAGDIR_END);
+	assert(dir < DiagDirection::End);
 
 	do {
 		length++;
diff --git a/src/station_cmd.cpp b/src/station_cmd.cpp
index 50c95390e4..69ead8a361 100644
--- a/src/station_cmd.cpp
+++ b/src/station_cmd.cpp
@@ -828,7 +828,7 @@ CommandCost CheckBuildableTile(TileIndex tile, DiagDirections invalid_dirs, int
 	int flat_z = z + GetSlopeMaxZ(tileh);
 	if (tileh != SLOPE_FLAT) {
 		/* Forbid building if the tile faces a slope in a invalid direction. */
-		for (DiagDirection dir = DIAGDIR_BEGIN; dir != DIAGDIR_END; dir++) {
+		for (DiagDirection dir = DiagDirection::Begin; dir != DiagDirection::End; dir++) {
 			if (invalid_dirs.Test(dir) && !CanBuildDepotByTileh(dir, tileh)) {
 				return CommandCost(STR_ERROR_FLAT_LAND_REQUIRED);
 			}
@@ -1050,7 +1050,7 @@ static CommandCost CheckFlatLandRailStation(TileIndex tile_cur, TileIndex north_
 			if (HasPowerOnRail(GetRailType(tile_cur), rt)) {
 				TrackBits tracks = GetTrackBits(tile_cur);
 				Track track = RemoveFirstTrack(&tracks);
-				Track expected_track = invalid_dirs.Test(DIAGDIR_NE) ? TRACK_X : TRACK_Y;
+				Track expected_track = invalid_dirs.Test(DiagDirection::NE) ? TRACK_X : TRACK_Y;
 
 				/* The existing track must align with the desired station axis. */
 				if (tracks == TRACK_BIT_NONE && track == expected_track) {
@@ -2911,7 +2911,7 @@ CommandCost CmdBuildDock(DoCommandFlags flags, TileIndex tile, StationID station
 	if (distant_join && (!_settings_game.station.distant_join_stations || !Station::IsValidID(station_to_join))) return CMD_ERROR;
 
 	DiagDirection direction = GetInclinedSlopeDirection(GetTileSlope(tile));
-	if (direction == INVALID_DIAGDIR) return CommandCost(STR_ERROR_SITE_UNSUITABLE);
+	if (direction == DiagDirection::Invalid) return CommandCost(STR_ERROR_SITE_UNSUITABLE);
 	direction = ReverseDiagDir(direction);
 
 	/* Docks cannot be placed on rapids */
@@ -2992,7 +2992,7 @@ CommandCost CmdBuildDock(DoCommandFlags flags, TileIndex tile, StationID station
 
 void RemoveDockingTile(TileIndex t)
 {
-	for (DiagDirection d = DIAGDIR_BEGIN; d != DIAGDIR_END; d++) {
+	for (DiagDirection d = DiagDirection::Begin; d != DiagDirection::End; d++) {
 		TileIndex tile = t + TileOffsByDiagDir(d);
 		if (!IsValidTile(tile)) continue;
 
@@ -3016,7 +3016,7 @@ void ClearDockingTilesCheckingNeighbours(TileIndex tile)
 	assert(IsValidTile(tile));
 
 	/* Clear and maybe re-set docking tile */
-	for (DiagDirection d = DIAGDIR_BEGIN; d != DIAGDIR_END; d++) {
+	for (DiagDirection d = DiagDirection::Begin; d != DiagDirection::End; d++) {
 		TileIndex docking_tile = tile + TileOffsByDiagDir(d);
 		if (!IsValidTile(docking_tile)) continue;
 
@@ -3039,7 +3039,7 @@ static TileIndex FindDockLandPart(TileIndex t)
 	StationGfx gfx = GetStationGfx(t);
 	if (gfx < GFX_DOCK_BASE_WATER_PART) return t;
 
-	for (DiagDirection d = DIAGDIR_BEGIN; d != DIAGDIR_END; d++) {
+	for (DiagDirection d = DiagDirection::Begin; d != DiagDirection::End; d++) {
 		TileIndex tile = t + TileOffsByDiagDir(d);
 		if (!IsValidTile(tile)) continue;
 		if (!IsDockTile(tile)) continue;
@@ -3721,11 +3721,11 @@ static TrackStatus GetTileTrackStatus_Station(TileIndex tile, TransportType mode
 
 				if (IsBayRoadStopTile(tile)) {
 					DiagDirection dir = GetBayRoadStopDir(tile);
-					if (side != INVALID_DIAGDIR && dir != side) break;
+					if (side != DiagDirection::Invalid && dir != side) break;
 					trackbits = DiagDirToDiagTrackBits(dir);
 				} else {
 					Axis axis = GetDriveThroughStopAxis(tile);
-					if (side != INVALID_DIAGDIR && axis != DiagDirToAxis(side)) break;
+					if (side != DiagDirection::Invalid && axis != DiagDirToAxis(side)) break;
 					trackbits = AxisToTrackBits(axis);
 				}
 			}
@@ -3872,7 +3872,7 @@ static VehicleEnterTileStates VehicleEnterTile_Station(Vehicle *v, TileIndex til
 
 		if (DiagDirToAxis(dir) != Axis::X) std::swap(x, y);
 		if (y == TILE_SIZE / 2) {
-			if (dir != DIAGDIR_SE && dir != DIAGDIR_SW) x = TILE_SIZE - 1 - x;
+			if (dir != DiagDirection::SE && dir != DiagDirection::SW) x = TILE_SIZE - 1 - x;
 			stop &= TILE_SIZE - 1;
 
 			if (x == stop) {
diff --git a/src/table/elrail_data.h b/src/table/elrail_data.h
index 5b47410bd7..9e286de296 100644
--- a/src/table/elrail_data.h
+++ b/src/table/elrail_data.h
@@ -60,12 +60,12 @@ static const DiagDirectionIndexArray<Directions> _owned_ppp_on_pcp{{{
 
 /** Maps a track bit onto two PCP positions */
 static const TrackIndexArray<std::array<DiagDirection, 2>> _pcp_positions{{{
-	{DIAGDIR_NE, DIAGDIR_SW}, // X
-	{DIAGDIR_SE, DIAGDIR_NW}, // Y
-	{DIAGDIR_NW, DIAGDIR_NE}, // UPPER
-	{DIAGDIR_SE, DIAGDIR_SW}, // LOWER
-	{DIAGDIR_SW, DIAGDIR_NW}, // LEFT
-	{DIAGDIR_NE, DIAGDIR_SE}, // RIGHT
+	{DiagDirection::NE, DiagDirection::SW}, // X
+	{DiagDirection::SE, DiagDirection::NW}, // Y
+	{DiagDirection::NW, DiagDirection::NE}, // UPPER
+	{DiagDirection::SE, DiagDirection::SW}, // LOWER
+	{DiagDirection::SW, DiagDirection::NW}, // LEFT
+	{DiagDirection::NE, DiagDirection::SE}, // RIGHT
 }}};
 
 /**
diff --git a/src/table/roadveh_movement.h b/src/table/roadveh_movement.h
index 71901e5142..3ad718362b 100644
--- a/src/table/roadveh_movement.h
+++ b/src/table/roadveh_movement.h
@@ -24,7 +24,7 @@ static const RoadDriveEntry _roadveh_drive_data_0[] = {
 	{ 2, 5},
 	{ 1, 5},
 	{ 0, 5},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NE), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_1[] = {
 	{5,  0},
@@ -43,7 +43,7 @@ static const RoadDriveEntry _roadveh_drive_data_1[] = {
 	{5, 13},
 	{5, 14},
 	{5, 15},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SE), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_2[] = {
 	{5, 0},
@@ -54,7 +54,7 @@ static const RoadDriveEntry _roadveh_drive_data_2[] = {
 	{2, 5},
 	{1, 5},
 	{0, 5},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NE), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_3[] = {
 	{15,  5},
@@ -73,7 +73,7 @@ static const RoadDriveEntry _roadveh_drive_data_3[] = {
 	{ 5, 13},
 	{ 5, 14},
 	{ 5, 15},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SE), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_4[] = {
 	{ 5, 0},
@@ -92,7 +92,7 @@ static const RoadDriveEntry _roadveh_drive_data_4[] = {
 	{13, 9},
 	{14, 9},
 	{15, 9},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_5[] = {
 	{0,  9},
@@ -104,21 +104,21 @@ static const RoadDriveEntry _roadveh_drive_data_5[] = {
 	{5, 13},
 	{5, 14},
 	{5, 15},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SE), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_6[] = {
 	{0, 6},
 	{0, 7},
 	{0, 8},
 	{0, 9},
-	{RDE_TURNED | to_underlying(DIAGDIR_SW), 0}
+	{RDE_TURNED | to_underlying(DiagDirection::SW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_7[] = {
 	{6, 15},
 	{7, 15},
 	{8, 15},
 	{9, 15},
-	{RDE_TURNED | to_underlying(DIAGDIR_NW), 0}
+	{RDE_TURNED | to_underlying(DiagDirection::NW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_8[] = {
 	{ 0, 9},
@@ -137,7 +137,7 @@ static const RoadDriveEntry _roadveh_drive_data_8[] = {
 	{13, 9},
 	{14, 9},
 	{15, 9},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_9[] = {
 	{9, 15},
@@ -156,7 +156,7 @@ static const RoadDriveEntry _roadveh_drive_data_9[] = {
 	{9,  2},
 	{9,  1},
 	{9,  0},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_10[] = {
 	{0, 9},
@@ -174,7 +174,7 @@ static const RoadDriveEntry _roadveh_drive_data_10[] = {
 	{9, 2},
 	{9, 1},
 	{9, 0},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_11[] = {
 	{ 9, 15},
@@ -186,7 +186,7 @@ static const RoadDriveEntry _roadveh_drive_data_11[] = {
 	{13,  9},
 	{14,  9},
 	{15,  9},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_12[] = {
 	{15, 5},
@@ -197,7 +197,7 @@ static const RoadDriveEntry _roadveh_drive_data_12[] = {
 	{10, 2},
 	{ 9, 1},
 	{ 9, 0},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_13[] = {
 	{9, 15},
@@ -215,21 +215,21 @@ static const RoadDriveEntry _roadveh_drive_data_13[] = {
 	{2,  5},
 	{1,  5},
 	{0,  5},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NE), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_14[] = {
 	{15, 8},
 	{15, 7},
 	{15, 6},
 	{15, 5},
-	{RDE_TURNED | to_underlying(DIAGDIR_NE), 0}
+	{RDE_TURNED | to_underlying(DiagDirection::NE), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_15[] = {
 	{8, 0},
 	{7, 0},
 	{6, 0},
 	{5, 0},
-	{RDE_TURNED | to_underlying(DIAGDIR_SE), 0}
+	{RDE_TURNED | to_underlying(DiagDirection::SE), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_16[] = {
 	{15, 9},
@@ -248,7 +248,7 @@ static const RoadDriveEntry _roadveh_drive_data_16[] = {
 	{ 2, 9},
 	{ 1, 9},
 	{ 0, 9},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NE), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_17[] = {
 	{9,  0},
@@ -267,7 +267,7 @@ static const RoadDriveEntry _roadveh_drive_data_17[] = {
 	{9, 13},
 	{9, 14},
 	{9, 15},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SE), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_18[] = {
 	{9, 0},
@@ -285,7 +285,7 @@ static const RoadDriveEntry _roadveh_drive_data_18[] = {
 	{2, 9},
 	{1, 9},
 	{0, 9},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NE), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_19[] = {
 	{15,  9},
@@ -297,7 +297,7 @@ static const RoadDriveEntry _roadveh_drive_data_19[] = {
 	{ 9, 13},
 	{ 9, 14},
 	{ 9, 15},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SE), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_20[] = {
 	{ 9, 0},
@@ -308,7 +308,7 @@ static const RoadDriveEntry _roadveh_drive_data_20[] = {
 	{13, 5},
 	{14, 5},
 	{15, 5},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_21[] = {
 	{0,  5},
@@ -326,21 +326,21 @@ static const RoadDriveEntry _roadveh_drive_data_21[] = {
 	{9, 13},
 	{9, 14},
 	{9, 15},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SE), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_22[] = {
 	{0, 8},
 	{0, 7},
 	{0, 6},
 	{0, 5},
-	{RDE_TURNED | to_underlying(DIAGDIR_SW), 0}
+	{RDE_TURNED | to_underlying(DiagDirection::SW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_23[] = {
 	{8, 15},
 	{7, 15},
 	{6, 15},
 	{5, 15},
-	{RDE_TURNED | to_underlying(DIAGDIR_NW), 0}
+	{RDE_TURNED | to_underlying(DiagDirection::NW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_24[] = {
 	{ 0, 5},
@@ -359,7 +359,7 @@ static const RoadDriveEntry _roadveh_drive_data_24[] = {
 	{13, 5},
 	{14, 5},
 	{15, 5},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_25[] = {
 	{5, 15},
@@ -378,7 +378,7 @@ static const RoadDriveEntry _roadveh_drive_data_25[] = {
 	{5,  2},
 	{5,  1},
 	{5,  0},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_26[] = {
 	{0, 5},
@@ -389,7 +389,7 @@ static const RoadDriveEntry _roadveh_drive_data_26[] = {
 	{5, 2},
 	{5, 1},
 	{5, 0},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_27[] = {
 	{ 5, 15},
@@ -408,7 +408,7 @@ static const RoadDriveEntry _roadveh_drive_data_27[] = {
 	{13,  5},
 	{14,  5},
 	{15,  5},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_28[] = {
 	{15, 9},
@@ -427,7 +427,7 @@ static const RoadDriveEntry _roadveh_drive_data_28[] = {
 	{ 5, 2},
 	{ 5, 1},
 	{ 5, 0},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NW), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_29[] = {
 	{5, 15},
@@ -439,21 +439,21 @@ static const RoadDriveEntry _roadveh_drive_data_29[] = {
 	{2,  9},
 	{1,  9},
 	{0,  9},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NE), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_30[] = {
 	{15, 6},
 	{15, 7},
 	{15, 8},
 	{15, 9},
-	{RDE_TURNED | to_underlying(DIAGDIR_NE), 0}
+	{RDE_TURNED | to_underlying(DiagDirection::NE), 0}
 };
 static const RoadDriveEntry _roadveh_drive_data_31[] = {
 	{6, 0},
 	{7, 0},
 	{8, 0},
 	{9, 0},
-	{RDE_TURNED | to_underlying(DIAGDIR_SE), 0}
+	{RDE_TURNED | to_underlying(DiagDirection::SE), 0}
 };
 static const RoadDriveEntry _rv_station_left_sw_far[] = {
 	{15,  5},
@@ -493,7 +493,7 @@ static const RoadDriveEntry _rv_station_left_sw_far[] = {
 	{13, 10},
 	{14,  9},
 	{15,  9},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SW), 0}
 };
 static const RoadDriveEntry _rv_station_left_nw_far[] = {
 	{ 5,  0},
@@ -533,7 +533,7 @@ static const RoadDriveEntry _rv_station_left_nw_far[] = {
 	{10,  2},
 	{ 9,  1},
 	{ 9,  0},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NW), 0}
 };
 static const RoadDriveEntry _rv_station_left_sw_near[] = {
 	{15,  5},
@@ -565,7 +565,7 @@ static const RoadDriveEntry _rv_station_left_sw_near[] = {
 	{13, 10},
 	{14,  9},
 	{15,  9},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SW), 0}
 };
 static const RoadDriveEntry _rv_station_left_nw_near[] = {
 	{ 5, 0},
@@ -597,7 +597,7 @@ static const RoadDriveEntry _rv_station_left_nw_near[] = {
 	{10, 2},
 	{ 9, 1},
 	{ 9, 0},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NW), 0}
 };
 static const RoadDriveEntry _rv_station_left_ne_far[] = {
 	{ 0, 9},
@@ -635,7 +635,7 @@ static const RoadDriveEntry _rv_station_left_ne_far[] = {
 	{ 2, 4},
 	{ 1, 5},
 	{ 0, 5},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NE), 0}
 };
 static const RoadDriveEntry _rv_station_left_se_far[] = {
 	{9, 15},
@@ -673,7 +673,7 @@ static const RoadDriveEntry _rv_station_left_se_far[] = {
 	{4, 13},
 	{5, 14},
 	{5, 15},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SE), 0}
 };
 static const RoadDriveEntry _rv_station_left_ne_near[] = {
 	{0, 9},
@@ -703,7 +703,7 @@ static const RoadDriveEntry _rv_station_left_ne_near[] = {
 	{2, 4},
 	{1, 5},
 	{0, 5},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NE), 0}
 };
 static const RoadDriveEntry _rv_station_left_se_near[] = {
 	{9, 15},
@@ -733,7 +733,7 @@ static const RoadDriveEntry _rv_station_left_se_near[] = {
 	{4, 13},
 	{5, 14},
 	{5, 15},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SE), 0}
 };
 static const RoadDriveEntry _rv_station_right_sw_far[] = {
 	{15,  9},
@@ -773,7 +773,7 @@ static const RoadDriveEntry _rv_station_right_sw_far[] = {
 	{13,  6},
 	{14,  5},
 	{15,  5},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SW), 0}
 };
 static const RoadDriveEntry _rv_station_right_nw_far[] = {
 	{ 9,  0},
@@ -813,7 +813,7 @@ static const RoadDriveEntry _rv_station_right_nw_far[] = {
 	{ 6,  2},
 	{ 5,  1},
 	{ 5,  0},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NW), 0}
 };
 static const RoadDriveEntry _rv_station_right_sw_near[] = {
 	{15,  9},
@@ -845,7 +845,7 @@ static const RoadDriveEntry _rv_station_right_sw_near[] = {
 	{13,  6},
 	{14,  5},
 	{15,  5},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SW), 0}
 };
 static const RoadDriveEntry _rv_station_right_nw_near[] = {
 	{ 9, 0},
@@ -877,7 +877,7 @@ static const RoadDriveEntry _rv_station_right_nw_near[] = {
 	{ 6, 2},
 	{ 5, 1},
 	{ 5, 0},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NW), 0}
 };
 static const RoadDriveEntry _rv_station_right_ne_far[] = {
 	{ 0, 5},
@@ -915,7 +915,7 @@ static const RoadDriveEntry _rv_station_right_ne_far[] = {
 	{ 2, 8},
 	{ 1, 9},
 	{ 0, 9},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NE), 0}
 };
 static const RoadDriveEntry _rv_station_right_se_far[] = {
 	{5, 15},
@@ -953,7 +953,7 @@ static const RoadDriveEntry _rv_station_right_se_far[] = {
 	{8, 13},
 	{9, 14},
 	{9, 15},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SE), 0}
 };
 static const RoadDriveEntry _rv_station_right_ne_near[] = {
 	{0, 5},
@@ -983,7 +983,7 @@ static const RoadDriveEntry _rv_station_right_ne_near[] = {
 	{2, 8},
 	{1, 9},
 	{0, 9},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NE), 0}
 };
 static const RoadDriveEntry _rv_station_right_se_near[] = {
 	{5, 15},
@@ -1013,7 +1013,7 @@ static const RoadDriveEntry _rv_station_right_se_near[] = {
 	{8, 13},
 	{9, 14},
 	{9, 15},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SE), 0}
 };
 
 static const RoadDriveEntry * const _road_road_drive_data[] = {
@@ -1113,7 +1113,7 @@ static const RoadDriveEntry _roadveh_tram_turn_ne_0[] = {
 	{ 0, 7},
 	{ 0, 8},
 	{ 0, 9},
-	{RDE_TURNED | to_underlying(DIAGDIR_SW), 0},
+	{RDE_TURNED | to_underlying(DiagDirection::SW), 0},
 	{ 1, 9},
 	{ 2, 9},
 	{ 3, 9},
@@ -1129,7 +1129,7 @@ static const RoadDriveEntry _roadveh_tram_turn_ne_0[] = {
 	{13, 9},
 	{14, 9},
 	{15, 9},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SW), 0}
 };
 
 static const RoadDriveEntry _roadveh_tram_turn_ne_1[] = {
@@ -1153,7 +1153,7 @@ static const RoadDriveEntry _roadveh_tram_turn_ne_1[] = {
 	{ 0, 7},
 	{ 0, 6},
 	{ 0, 5},
-	{RDE_TURNED | to_underlying(DIAGDIR_SW), 0},
+	{RDE_TURNED | to_underlying(DiagDirection::SW), 0},
 	{ 1, 5},
 	{ 2, 5},
 	{ 3, 5},
@@ -1169,7 +1169,7 @@ static const RoadDriveEntry _roadveh_tram_turn_ne_1[] = {
 	{13, 5},
 	{14, 5},
 	{15, 5},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SW), 0}
 };
 
 static const RoadDriveEntry _roadveh_tram_turn_se_0[] = {
@@ -1193,7 +1193,7 @@ static const RoadDriveEntry _roadveh_tram_turn_se_0[] = {
 	{7, 15},
 	{8, 15},
 	{9, 15},
-	{RDE_TURNED | to_underlying(DIAGDIR_NW), 0},
+	{RDE_TURNED | to_underlying(DiagDirection::NW), 0},
 	{9, 14},
 	{9, 13},
 	{9, 12},
@@ -1209,7 +1209,7 @@ static const RoadDriveEntry _roadveh_tram_turn_se_0[] = {
 	{9,  2},
 	{9,  1},
 	{9,  0},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NW), 0}
 };
 
 static const RoadDriveEntry _roadveh_tram_turn_se_1[] = {
@@ -1233,7 +1233,7 @@ static const RoadDriveEntry _roadveh_tram_turn_se_1[] = {
 	{7, 15},
 	{6, 15},
 	{5, 15},
-	{RDE_TURNED | to_underlying(DIAGDIR_NW), 0},
+	{RDE_TURNED | to_underlying(DiagDirection::NW), 0},
 	{5, 14},
 	{5, 13},
 	{5, 12},
@@ -1249,7 +1249,7 @@ static const RoadDriveEntry _roadveh_tram_turn_se_1[] = {
 	{5,  2},
 	{5,  1},
 	{5,  0},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NW), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NW), 0}
 };
 
 static const RoadDriveEntry _roadveh_tram_turn_sw_0[] = {
@@ -1273,7 +1273,7 @@ static const RoadDriveEntry _roadveh_tram_turn_sw_0[] = {
 	{15, 7},
 	{15, 6},
 	{15, 5},
-	{RDE_TURNED | to_underlying(DIAGDIR_NE), 0},
+	{RDE_TURNED | to_underlying(DiagDirection::NE), 0},
 	{14, 5},
 	{13, 5},
 	{12, 5},
@@ -1289,7 +1289,7 @@ static const RoadDriveEntry _roadveh_tram_turn_sw_0[] = {
 	{ 2, 5},
 	{ 1, 5},
 	{ 0, 5},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NE), 0}
 };
 static const RoadDriveEntry _roadveh_tram_turn_sw_1[] = {
 	{ 0, 5},
@@ -1312,7 +1312,7 @@ static const RoadDriveEntry _roadveh_tram_turn_sw_1[] = {
 	{15, 7},
 	{15, 8},
 	{15, 9},
-	{RDE_TURNED | to_underlying(DIAGDIR_NE), 0},
+	{RDE_TURNED | to_underlying(DiagDirection::NE), 0},
 	{14, 9},
 	{13, 9},
 	{12, 9},
@@ -1328,7 +1328,7 @@ static const RoadDriveEntry _roadveh_tram_turn_sw_1[] = {
 	{ 2, 9},
 	{ 1, 9},
 	{ 0, 9},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_NE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::NE), 0}
 };
 
 static const RoadDriveEntry _roadveh_tram_turn_nw_0[] = {
@@ -1352,7 +1352,7 @@ static const RoadDriveEntry _roadveh_tram_turn_nw_0[] = {
 	{7,  0},
 	{6,  0},
 	{5,  0},
-	{RDE_TURNED | to_underlying(DIAGDIR_SE), 0},
+	{RDE_TURNED | to_underlying(DiagDirection::SE), 0},
 	{5,  1},
 	{5,  2},
 	{5,  3},
@@ -1368,7 +1368,7 @@ static const RoadDriveEntry _roadveh_tram_turn_nw_0[] = {
 	{5, 13},
 	{5, 14},
 	{5, 15},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SE), 0}
 };
 static const RoadDriveEntry _roadveh_tram_turn_nw_1[] = {
 	{5, 15},
@@ -1391,7 +1391,7 @@ static const RoadDriveEntry _roadveh_tram_turn_nw_1[] = {
 	{7,  0},
 	{8,  0},
 	{9,  0},
-	{RDE_TURNED | to_underlying(DIAGDIR_SE), 0},
+	{RDE_TURNED | to_underlying(DiagDirection::SE), 0},
 	{9,  1},
 	{9,  2},
 	{9,  3},
@@ -1407,7 +1407,7 @@ static const RoadDriveEntry _roadveh_tram_turn_nw_1[] = {
 	{9, 13},
 	{9, 14},
 	{9, 15},
-	{RDE_NEXT_TILE | to_underlying(DIAGDIR_SE), 0}
+	{RDE_NEXT_TILE | to_underlying(DiagDirection::SE), 0}
 };
 
 static const RoadDriveEntry * const _road_tram_drive_data[] = {
diff --git a/src/table/track_data.h b/src/table/track_data.h
index 4bbd0944f5..924f9c5594 100644
--- a/src/table/track_data.h
+++ b/src/table/track_data.h
@@ -12,10 +12,10 @@
  * track entering in this direction (including those making 90 degree turns).
  */
 extern const DiagDirectionIndexArray<TrackdirBits> _exitdir_reaches_trackdirs{
-	TRACKDIR_BIT_X_NE | TRACKDIR_BIT_LOWER_E | TRACKDIR_BIT_LEFT_N,  // DIAGDIR_NE
-	TRACKDIR_BIT_Y_SE | TRACKDIR_BIT_LEFT_S  | TRACKDIR_BIT_UPPER_E, // DIAGDIR_SE
-	TRACKDIR_BIT_X_SW | TRACKDIR_BIT_UPPER_W | TRACKDIR_BIT_RIGHT_S, // DIAGDIR_SW
-	TRACKDIR_BIT_Y_NW | TRACKDIR_BIT_RIGHT_N | TRACKDIR_BIT_LOWER_W  // DIAGDIR_NW
+	TRACKDIR_BIT_X_NE | TRACKDIR_BIT_LOWER_E | TRACKDIR_BIT_LEFT_N,  // DiagDirection::NE
+	TRACKDIR_BIT_Y_SE | TRACKDIR_BIT_LEFT_S  | TRACKDIR_BIT_UPPER_E, // DiagDirection::SE
+	TRACKDIR_BIT_X_SW | TRACKDIR_BIT_UPPER_W | TRACKDIR_BIT_RIGHT_S, // DiagDirection::SW
+	TRACKDIR_BIT_Y_NW | TRACKDIR_BIT_RIGHT_N | TRACKDIR_BIT_LOWER_W  // DiagDirection::NW
 };
 
 /** Next trackdir to use when moving to a new tile for each current trackdir. */
@@ -46,8 +46,8 @@ extern const TrackIndexArray<TrackBits> _track_crosses_tracks{
 
 /** Maps a trackdir to the (4-way) direction the tile is exited when following that trackdir. */
 extern const TrackdirIndexArray<DiagDirection> _trackdir_to_exitdir{
-	DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_NE,
-	DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE,
+	DiagDirection::NE, DiagDirection::SE, DiagDirection::NE, DiagDirection::SE, DiagDirection::SW, DiagDirection::SE, DiagDirection::NE, DiagDirection::NE,
+	DiagDirection::SW, DiagDirection::NW, DiagDirection::NW, DiagDirection::SW, DiagDirection::NW, DiagDirection::NE,
 };
 
 /** Maps a track and an (4-way) dir to the trackdir that represents the track with the exit in the given direction. */
diff --git a/src/table/track_land.h b/src/table/track_land.h
index bd74ddcc55..9e52c4cdf1 100644
--- a/src/table/track_land.h
+++ b/src/table/track_land.h
@@ -10,21 +10,21 @@
 #define TILE_SEQ_LINE(img, dx, dy, sx, sy) { dx, dy, 0, sx, sy, 23, {img, PAL_NONE} },
 
 
-static const DrawTileSeqStruct _depot_gfx_NE[] = {
+static constexpr DrawTileSeqStruct _depot_gfx_NE[] = {
 	TILE_SEQ_LINE(SPR_RAIL_DEPOT_NE | (1 << PALETTE_MODIFIER_COLOUR), 2, 13, 13, 1)
 };
 
-static const DrawTileSeqStruct _depot_gfx_SE[] = {
+static constexpr DrawTileSeqStruct _depot_gfx_SE[] = {
 	TILE_SEQ_LINE(SPR_RAIL_DEPOT_SE_1 | (1 << PALETTE_MODIFIER_COLOUR),  2, 2, 1, 13)
 	TILE_SEQ_LINE(SPR_RAIL_DEPOT_SE_2 | (1 << PALETTE_MODIFIER_COLOUR), 13, 2, 1, 13)
 };
 
-static const DrawTileSeqStruct _depot_gfx_SW[] = {
+static constexpr DrawTileSeqStruct _depot_gfx_SW[] = {
 	TILE_SEQ_LINE(SPR_RAIL_DEPOT_SW_1 | (1 << PALETTE_MODIFIER_COLOUR), 2,  2, 13, 1)
 	TILE_SEQ_LINE(SPR_RAIL_DEPOT_SW_2 | (1 << PALETTE_MODIFIER_COLOUR), 2, 13, 13, 1)
 };
 
-static const DrawTileSeqStruct _depot_gfx_NW[] = {
+static constexpr DrawTileSeqStruct _depot_gfx_NW[] = {
 	TILE_SEQ_LINE(SPR_RAIL_DEPOT_NW | (1 << PALETTE_MODIFIER_COLOUR), 13, 2, 1, 13)
 };
 
diff --git a/src/terraform_cmd.cpp b/src/terraform_cmd.cpp
index 954375f0e2..524691f439 100644
--- a/src/terraform_cmd.cpp
+++ b/src/terraform_cmd.cpp
@@ -135,7 +135,7 @@ static std::tuple<CommandCost, TileIndex> TerraformTileHeight(TerraformerState *
 	total_cost.AddCost(_price[Price::Terraform]);
 
 	/* Recurse to neighboured corners if height difference is larger than 1 */
-	for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
+	for (DiagDirection dir = DiagDirection::Begin; dir < DiagDirection::End; dir++) {
 		TileIndex neighbour_tile = AddTileIndexDiffCWrap(tile, TileIndexDiffCByDiagDir(dir));
 
 		/* Not using IsValidTile as we want to also change TileType::Void tiles, which IsValidTile excludes. */
diff --git a/src/tile_cmd.h b/src/tile_cmd.h
index ab58213cb1..51955cde57 100644
--- a/src/tile_cmd.h
+++ b/src/tile_cmd.h
@@ -230,7 +230,7 @@ struct TileTypeProcs {
 
 extern const EnumIndexArray<const TileTypeProcs *, TileType, TileType::MaxSize> _tile_type_procs;
 
-TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, RoadTramType sub_mode, DiagDirection side = INVALID_DIAGDIR);
+TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, RoadTramType sub_mode, DiagDirection side = DiagDirection::Invalid);
 VehicleEnterTileStates VehicleEnterTile(Vehicle *v, TileIndex tile, int x, int y);
 void ChangeTileOwner(TileIndex tile, Owner old_owner, Owner new_owner);
 void GetTileDesc(TileIndex tile, TileDesc &td);
diff --git a/src/tilearea.cpp b/src/tilearea.cpp
index 62a17312a8..73c1566229 100644
--- a/src/tilearea.cpp
+++ b/src/tilearea.cpp
@@ -301,20 +301,20 @@ TileIterator &DiagonalTileIterator::operator++()
 SpiralTileIterator::SpiralTileIterator(TileIndex center, uint diameter) :
 	max_radius(diameter / 2),
 	cur_radius(0),
-	dir(DIAGDIR_BEGIN)
+	dir(DiagDirection::Begin)
 {
 	assert(diameter > 0);
 
 	if (diameter % 2 == 1) {
 		this->extent.fill(1);
-		this->dir = INVALID_DIAGDIR; // special case for odd diameters, see Increment()
+		this->dir = DiagDirection::Invalid; // special case for odd diameters, see Increment()
 		this->position = 0;
 
 		this->x = TileX(center);
 		this->y = TileY(center);
 	} else {
 		this->extent.fill(0);
-		this->dir = DIAGDIR_BEGIN;
+		this->dir = DiagDirection::Begin;
 		this->InitPosition();
 
 		/* Start with the west corner of the center 2x2 rect */
@@ -329,7 +329,7 @@ SpiralTileIterator::SpiralTileIterator(TileIndex start_north, uint radius, uint
 	max_radius(radius),
 	extent{w, h, w, h},
 	cur_radius(0),
-	dir(DIAGDIR_BEGIN),
+	dir(DiagDirection::Begin),
 	/* first tile is the west corner */
 	x(TileX(start_north) + w + 1),
 	y(TileY(start_north))
@@ -364,11 +364,11 @@ void SpiralTileIterator::Increment()
 	assert(!this->IsEnd());
 
 	/* Special value for first tile in areas with odd diameter */
-	if (this->dir == INVALID_DIAGDIR) {
+	if (this->dir == DiagDirection::Invalid) {
 		const auto west = TileIndexDiffCByDir(DIR_W);
 		this->x += west.x;
 		this->y += west.y;
-		this->dir = DIAGDIR_BEGIN;
+		this->dir = DiagDirection::Begin;
 		this->InitPosition();
 		return;
 	}
@@ -383,13 +383,13 @@ void SpiralTileIterator::Increment()
 	/* Corner reached, switch direction */
 	++this->dir;
 
-	if (this->dir == DIAGDIR_END) {
+	if (this->dir == DiagDirection::End) {
 		/* Jump to next circle */
 		const auto west = TileIndexDiffCByDir(DIR_W);
 		this->x += west.x;
 		this->y += west.y;
 		++this->cur_radius;
-		this->dir = DIAGDIR_BEGIN;
+		this->dir = DiagDirection::Begin;
 	}
 
 	this->InitPosition();
diff --git a/src/tilearea_type.h b/src/tilearea_type.h
index 6b14673888..6a5e973fd4 100644
--- a/src/tilearea_type.h
+++ b/src/tilearea_type.h
@@ -315,7 +315,7 @@ private:
 	 */
 	bool IsEnd() const
 	{
-		return this->cur_radius == this->max_radius && this->dir != INVALID_DIAGDIR;
+		return this->cur_radius == this->max_radius && this->dir != DiagDirection::Invalid;
 	}
 };
 
diff --git a/src/town_cmd.cpp b/src/town_cmd.cpp
index 5a1c7d5fb9..5d68c247f3 100644
--- a/src/town_cmd.cpp
+++ b/src/town_cmd.cpp
@@ -255,7 +255,7 @@ static TownDrawTileProc * const _town_draw_tile_procs[1] = {
  */
 static inline DiagDirection RandomDiagDir()
 {
-	return static_cast<DiagDirection>(RandomRange(to_underlying(DIAGDIR_END)));
+	return static_cast<DiagDirection>(RandomRange(to_underlying(DiagDirection::End)));
 }
 
 /** @copydoc DrawTileProc */
@@ -1057,7 +1057,7 @@ static bool IsRoadAllowedHere(Town *t, TileIndex tile, DiagDirection dir)
 		 * If that fails clear the land, and if that fails exit.
 		 * This is to make sure that we can build a road here later. */
 		RoadType rt = GetTownRoadType();
-		if (Command<Commands::BuildRoad>::Do({DoCommandFlag::Auto, DoCommandFlag::NoWater}, tile, (dir == DIAGDIR_NW || dir == DIAGDIR_SE) ? ROAD_Y : ROAD_X, rt, {}, t->index).Failed() &&
+		if (Command<Commands::BuildRoad>::Do({DoCommandFlag::Auto, DoCommandFlag::NoWater}, tile, (dir == DiagDirection::NW || dir == DiagDirection::SE) ? ROAD_Y : ROAD_X, rt, {}, t->index).Failed() &&
 				Command<Commands::LandscapeClear>::Do({DoCommandFlag::Auto, DoCommandFlag::NoWater}, tile).Failed()) {
 			return false;
 		}
@@ -1069,7 +1069,7 @@ static bool IsRoadAllowedHere(Town *t, TileIndex tile, DiagDirection dir)
 
 	/* If the tile is not a slope in the right direction, then
 	 * maybe terraform some. */
-	Slope desired_slope = (dir == DIAGDIR_NW || dir == DIAGDIR_SE) ? SLOPE_NW : SLOPE_NE;
+	Slope desired_slope = (dir == DiagDirection::NW || dir == DiagDirection::SE) ? SLOPE_NW : SLOPE_NE;
 	if (desired_slope != cur_slope && ComplementSlope(desired_slope) != cur_slope) {
 		if (Chance16(1, 8)) {
 			CommandCost res = CMD_ERROR;
@@ -1189,7 +1189,7 @@ static bool GrowTownWithExtraHouse(Town *t, TileIndex tile, TownExpandModes mode
 	uint counter = 0; // counts the house neighbour tiles
 
 	/* Check the tiles E,N,W and S of the current tile for houses */
-	for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
+	for (DiagDirection dir = DiagDirection::Begin; dir < DiagDirection::End; dir++) {
 		/* Count both void and house tiles for checking whether there
 		 * are enough houses in the area. This to make it likely that
 		 * houses get build up to the edge of the map. */
@@ -1282,7 +1282,7 @@ static bool CanRoadContinueIntoNextTile(const Town *t, const TileIndex tile, con
  */
 static bool GrowTownWithBridge(const Town *t, const TileIndex tile, const DiagDirection bridge_dir)
 {
-	assert(bridge_dir < DIAGDIR_END);
+	assert(bridge_dir < DiagDirection::End);
 
 	const Slope slope = GetTileSlope(tile);
 
@@ -1371,7 +1371,7 @@ static bool GrowTownWithBridge(const Town *t, const TileIndex tile, const DiagDi
  */
 static bool GrowTownWithTunnel(const Town *t, const TileIndex tile, const DiagDirection tunnel_dir)
 {
-	assert(tunnel_dir < DIAGDIR_END);
+	assert(tunnel_dir < DiagDirection::End);
 
 	Slope slope = GetTileSlope(tile);
 
@@ -1562,7 +1562,7 @@ static TownGrowthResult GrowTownInTile(TileIndex *tile_ptr, RoadBits cur_rb, Dia
 				break;
 		}
 
-	} else if (target_dir < DIAGDIR_END && !cur_rb.Any(DiagDirToRoadBits(ReverseDiagDir(target_dir)))) {
+	} else if (target_dir < DiagDirection::End && !cur_rb.Any(DiagDirToRoadBits(ReverseDiagDir(target_dir)))) {
 		if (!TownCanGrowRoad(tile)) return TownGrowthResult::Continue;
 
 		if (!TownAllowedToBuildRoads(modes)) return TownGrowthResult::SearchStopped;
@@ -1589,7 +1589,7 @@ static TownGrowthResult GrowTownInTile(TileIndex *tile_ptr, RoadBits cur_rb, Dia
 		/* Reached a tunnel/bridge? Then continue at the other side of it, unless
 		 * it is the starting tile. Half the time, we stay on this side then.*/
 		if (IsTileType(tile, TileType::TunnelBridge)) {
-			if (GetTunnelBridgeTransportType(tile) == TRANSPORT_ROAD && (target_dir != DIAGDIR_END || Chance16(1, 2))) {
+			if (GetTunnelBridgeTransportType(tile) == TRANSPORT_ROAD && (target_dir != DiagDirection::End || Chance16(1, 2))) {
 				*tile_ptr = GetOtherTunnelBridgeEnd(tile);
 			}
 			return TownGrowthResult::Continue;
@@ -1629,7 +1629,7 @@ static TownGrowthResult GrowTownInTile(TileIndex *tile_ptr, RoadBits cur_rb, Dia
 				default:
 					return TownGrowthResult::Continue; // not a turn
 			}
-			target_dir = DIAGDIR_END;
+			target_dir = DiagDirection::End;
 		} else {
 			house_tile = TileAddByDiagDir(tile, target_dir);
 		}
@@ -1641,7 +1641,7 @@ static TownGrowthResult GrowTownInTile(TileIndex *tile_ptr, RoadBits cur_rb, Dia
 
 		TownGrowthResult result = TownGrowthResult::Continue;
 
-		if (target_dir != DIAGDIR_END && TownAllowedToBuildRoads(modes)) {
+		if (target_dir != DiagDirection::End && TownAllowedToBuildRoads(modes)) {
 			switch (t1->layout) {
 				default: NOT_REACHED();
 
@@ -1770,7 +1770,7 @@ static bool GrowTownAtRoad(Town *t, TileIndex tile, TownExpandModes modes)
 	/* Special case.
 	 * @see GrowTownInTile Check the else if
 	 */
-	DiagDirection target_dir = DIAGDIR_END; // The direction in which we want to extend the town
+	DiagDirection target_dir = DiagDirection::End; // The direction in which we want to extend the town
 
 	assert(tile < Map::Size());
 
@@ -2605,7 +2605,7 @@ static bool CheckFree2x2Area(TileIndex tile, int z, bool noslope)
 	/* we need to check this tile too because we can be at different tile now */
 	if (!CheckBuildHouseSameZ(tile, z, noslope)) return false;
 
-	for (DiagDirection d = DIAGDIR_SE; d < DIAGDIR_END; d++) {
+	for (DiagDirection d = DiagDirection::SE; d < DiagDirection::End; d++) {
 		tile += TileOffsByDiagDir(d);
 		if (!CheckBuildHouseSameZ(tile, z, noslope)) return false;
 	}
@@ -2728,12 +2728,12 @@ static bool CheckTownBuild2x2House(TileIndex *tile, Town *t, int maxz, bool nosl
 {
 	TileIndex tile2 = *tile;
 
-	for (DiagDirection d = DIAGDIR_SE;; d++) { // 'd' goes through DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_END
+	for (DiagDirection d = DiagDirection::SE;; d++) { // 'd' goes through DiagDirection::SE, DiagDirection::SW, DiagDirection::NW, DiagDirection::End
 		if (TownLayoutAllows2x2HouseHere(t, tile2, modes) && CheckFree2x2Area(tile2, maxz, noslope)) {
 			*tile = tile2;
 			return true;
 		}
-		if (d == DIAGDIR_END) break;
+		if (d == DiagDirection::End) break;
 		tile2 += TileOffsByDiagDir(ReverseDiagDir(d)); // go clockwise
 	}
 
@@ -2889,9 +2889,9 @@ static bool TryBuildTownHouse(Town *t, TileIndex tile, TownExpandModes modes)
 		if (hs->building_flags.Test(BuildingFlag::Size2x2)) {
 			if (!CheckTownBuild2x2House(&tile, t, maxz, noslope, modes)) continue;
 		} else if (hs->building_flags.Test(BuildingFlag::Size2x1)) {
-			if (!CheckTownBuild2House(&tile, t, maxz, noslope, DIAGDIR_SW, modes)) continue;
+			if (!CheckTownBuild2House(&tile, t, maxz, noslope, DiagDirection::SW, modes)) continue;
 		} else if (hs->building_flags.Test(BuildingFlag::Size1x2)) {
-			if (!CheckTownBuild2House(&tile, t, maxz, noslope, DIAGDIR_SE, modes)) continue;
+			if (!CheckTownBuild2House(&tile, t, maxz, noslope, DiagDirection::SE, modes)) continue;
 		} else {
 			/* 1x1 house checks are already done */
 		}
@@ -2938,8 +2938,8 @@ CommandCost CmdPlaceHouse(DoCommandFlags flags, TileIndex tile, HouseID house, b
 	/* Check each tile of a multi-tile house. */
 	TileArea ta(tile, 1, 1);
 	if (hs->building_flags.Test(BuildingFlag::Size2x2)) ta.Add(TileAddXY(tile, 1, 1));
-	if (hs->building_flags.Test(BuildingFlag::Size2x1)) ta.Add(TileAddByDiagDir(tile, DIAGDIR_SW));
-	if (hs->building_flags.Test(BuildingFlag::Size1x2)) ta.Add(TileAddByDiagDir(tile, DIAGDIR_SE));
+	if (hs->building_flags.Test(BuildingFlag::Size2x1)) ta.Add(TileAddByDiagDir(tile, DiagDirection::SW));
+	if (hs->building_flags.Test(BuildingFlag::Size1x2)) ta.Add(TileAddByDiagDir(tile, DiagDirection::SE));
 
 	for (const TileIndex subtile : ta) {
 		/* Houses cannot be built on steep slopes. */
diff --git a/src/track_func.h b/src/track_func.h
index 18325dce96..d0ccdf5594 100644
--- a/src/track_func.h
+++ b/src/track_func.h
@@ -478,7 +478,7 @@ inline Trackdir TrackExitdirToTrackdir(Track track, DiagDirection diagdir)
  * you follow the DiagDirection and then turn by 45 deg left or right on the
  * next tile. The new direction on the new track will be the returning Trackdir
  * value. If the parameters makes no sense like the track TRACK_UPPER and the
- * direction DIAGDIR_NE (target track cannot be reached) this function returns
+ * direction DiagDirection::NE (target track cannot be reached) this function returns
  * INVALID_TRACKDIR.
  *
  * @param track The target track
diff --git a/src/train_cmd.cpp b/src/train_cmd.cpp
index d5ca320160..30eac619fb 100644
--- a/src/train_cmd.cpp
+++ b/src/train_cmd.cpp
@@ -1542,10 +1542,10 @@ void Train::UpdateDeltaXY()
 	if (!IsDiagonalDirection(dir)) {
 		static constexpr DiagDirectionIndexArray<Point> _sign_table{{{
 			/* x, y */
-			{-1, -1}, // DIAGDIR_N
-			{-1,  1}, // DIAGDIR_E
-			{ 1,  1}, // DIAGDIR_S
-			{ 1, -1}, // DIAGDIR_W
+			{-1, -1}, // DiagDirection::N
+			{-1,  1}, // DiagDirection::E
+			{ 1,  1}, // DiagDirection::S
+			{ 1, -1}, // DiagDirection::W
 		}}};
 
 		int half_shorten = (VEHICLE_LENGTH - this->gcache.cached_veh_length + flipped) / 2;
@@ -2089,7 +2089,7 @@ static void ReverseTrainDirection(Train *consist)
 	/* VehicleExitDir does not always produce the desired dir for depots and
 	 * tunnels/bridges that is needed for UpdateSignalsOnSegment. */
 	DiagDirection dir = VehicleExitDir(moving_front->GetMovingDirection(), moving_front->track);
-	if (IsRailDepotTile(moving_front->tile) || IsTileType(moving_front->tile, TileType::TunnelBridge)) dir = INVALID_DIAGDIR;
+	if (IsRailDepotTile(moving_front->tile) || IsTileType(moving_front->tile, TileType::TunnelBridge)) dir = DiagDirection::Invalid;
 
 	if (UpdateSignalsOnSegment(moving_front->tile, dir, consist->owner) == SIGSEG_PBS || _settings_game.pf.reserve_paths) {
 		/* If we are currently on a tile with conventional signals, we can't treat the
@@ -2368,14 +2368,14 @@ static bool CheckTrainStayInDepot(Train *v)
 
 		v->wait_counter = 0;
 
-		seg_state = _settings_game.pf.reserve_paths ? SIGSEG_PBS : UpdateSignalsOnSegment(v->tile, INVALID_DIAGDIR, v->owner);
+		seg_state = _settings_game.pf.reserve_paths ? SIGSEG_PBS : UpdateSignalsOnSegment(v->tile, DiagDirection::Invalid, v->owner);
 		if (seg_state == SIGSEG_FULL || HasDepotReservation(v->tile)) {
 			/* Full and no PBS signal in block or depot reserved, can't exit. */
 			SetWindowClassesDirty(WindowClass::TrainList);
 			return true;
 		}
 	} else {
-		seg_state = _settings_game.pf.reserve_paths ? SIGSEG_PBS : UpdateSignalsOnSegment(v->tile, INVALID_DIAGDIR, v->owner);
+		seg_state = _settings_game.pf.reserve_paths ? SIGSEG_PBS : UpdateSignalsOnSegment(v->tile, DiagDirection::Invalid, v->owner);
 	}
 
 	/* We are leaving a depot, but have to go to the exact same one; re-enter. */
@@ -2408,7 +2408,7 @@ static bool CheckTrainStayInDepot(Train *v)
 
 	v->UpdateViewport(true, true);
 	v->UpdatePosition();
-	UpdateSignalsOnSegment(v->tile, INVALID_DIAGDIR, v->owner);
+	UpdateSignalsOnSegment(v->tile, DiagDirection::Invalid, v->owner);
 	v->UpdateAcceleration();
 	InvalidateWindowData(WindowClass::VehicleDepot, v->tile);
 
@@ -3353,7 +3353,7 @@ bool TrainController(Train *v, Vehicle *nomove, bool reverse)
 
 	/* For every vehicle after and including the given vehicle */
 	for (prev = v->GetMovingPrev(); v != nomove; prev = v, v = v->GetMovingNext()) {
-		DiagDirection enterdir = DIAGDIR_BEGIN;
+		DiagDirection enterdir = DiagDirection::Begin;
 		bool update_signals_crossing = false; // will we update signals or crossing state?
 
 		GetNewVehiclePosResult gp = GetNewVehiclePos(v);
@@ -3748,7 +3748,7 @@ static void DeleteLastWagon(Train *v)
 
 	/* Update signals */
 	if (IsTileType(tile, TileType::TunnelBridge) || IsRailDepotTile(tile)) {
-		UpdateSignalsOnSegment(tile, INVALID_DIAGDIR, owner);
+		UpdateSignalsOnSegment(tile, DiagDirection::Invalid, owner);
 	} else {
 		SetSignalsOnBothDir(tile, track, owner);
 	}
@@ -4038,7 +4038,7 @@ static bool TrainLocoHandler(Train *consist, bool mode)
 		 * when an overlength train gets turned around in a station. */
 		const Train *moving_front = consist->GetMovingFront();
 		DiagDirection dir = VehicleExitDir(moving_front->GetMovingDirection(), moving_front->track);
-		if (IsRailDepotTile(moving_front->tile) || IsTileType(moving_front->tile, TileType::TunnelBridge)) dir = INVALID_DIAGDIR;
+		if (IsRailDepotTile(moving_front->tile) || IsTileType(moving_front->tile, TileType::TunnelBridge)) dir = DiagDirection::Invalid;
 
 		if (UpdateSignalsOnSegment(moving_front->tile, dir, consist->owner) == SIGSEG_PBS || _settings_game.pf.reserve_paths) {
 			TryPathReserve(consist, true, true);
diff --git a/src/tunnel_map.cpp b/src/tunnel_map.cpp
index 05354093b3..2b8d8ed50f 100644
--- a/src/tunnel_map.cpp
+++ b/src/tunnel_map.cpp
@@ -67,6 +67,6 @@ bool IsTunnelInWayDir(TileIndex tile, int z, DiagDirection dir)
  */
 bool IsTunnelInWay(TileIndex tile, int z)
 {
-	return IsTunnelInWayDir(tile, z, (TileX(tile) > (Map::MaxX() / 2)) ? DIAGDIR_NE : DIAGDIR_SW) ||
-			IsTunnelInWayDir(tile, z, (TileY(tile) > (Map::MaxY() / 2)) ? DIAGDIR_NW : DIAGDIR_SE);
+	return IsTunnelInWayDir(tile, z, (TileX(tile) > (Map::MaxX() / 2)) ? DiagDirection::NE : DiagDirection::SW) ||
+			IsTunnelInWayDir(tile, z, (TileY(tile) > (Map::MaxY() / 2)) ? DiagDirection::NW : DiagDirection::SE);
 }
diff --git a/src/tunnelbridge_cmd.cpp b/src/tunnelbridge_cmd.cpp
index acc40683e9..27b004c4da 100644
--- a/src/tunnelbridge_cmd.cpp
+++ b/src/tunnelbridge_cmd.cpp
@@ -593,7 +593,7 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t
 
 	if (flags.Test(DoCommandFlag::Execute) && transport_type == TRANSPORT_RAIL) {
 		Track track = AxisToTrack(direction);
-		AddSideToSignalBuffer(tile_start, INVALID_DIAGDIR, company);
+		AddSideToSignalBuffer(tile_start, DiagDirection::Invalid, company);
 		YapfNotifyTrackLayoutChange(tile_start, track);
 	}
 
@@ -672,7 +672,7 @@ CommandCost CmdBuildTunnel(DoCommandFlags flags, TileIndex start_tile, Transport
 
 	auto [start_tileh, start_z] = GetTileSlopeZ(start_tile);
 	DiagDirection direction = GetInclinedSlopeDirection(start_tileh);
-	if (direction == INVALID_DIAGDIR) return CommandCost(STR_ERROR_SITE_UNSUITABLE_FOR_TUNNEL);
+	if (direction == DiagDirection::Invalid) return CommandCost(STR_ERROR_SITE_UNSUITABLE_FOR_TUNNEL);
 
 	if (HasTileWaterGround(start_tile)) return CommandCost(STR_ERROR_CAN_T_BUILD_ON_WATER);
 
@@ -687,9 +687,9 @@ CommandCost CmdBuildTunnel(DoCommandFlags flags, TileIndex start_tile, Transport
 	TileIndexDiff delta = TileOffsByDiagDir(direction);
 	DiagDirection tunnel_in_way_dir;
 	if (DiagDirToAxis(direction) == Axis::Y) {
-		tunnel_in_way_dir = (TileX(start_tile) < (Map::MaxX() / 2)) ? DIAGDIR_SW : DIAGDIR_NE;
+		tunnel_in_way_dir = (TileX(start_tile) < (Map::MaxX() / 2)) ? DiagDirection::SW : DiagDirection::NE;
 	} else {
-		tunnel_in_way_dir = (TileY(start_tile) < (Map::MaxX() / 2)) ? DIAGDIR_SE : DIAGDIR_NW;
+		tunnel_in_way_dir = (TileY(start_tile) < (Map::MaxX() / 2)) ? DiagDirection::SE : DiagDirection::NW;
 	}
 
 	TileIndex end_tile = start_tile;
@@ -790,7 +790,7 @@ CommandCost CmdBuildTunnel(DoCommandFlags flags, TileIndex start_tile, Transport
 			if (c != nullptr) c->infrastructure.rail[railtype] += num_pieces;
 			MakeRailTunnel(start_tile, company, direction,                 railtype);
 			MakeRailTunnel(end_tile,   company, ReverseDiagDir(direction), railtype);
-			AddSideToSignalBuffer(start_tile, INVALID_DIAGDIR, company);
+			AddSideToSignalBuffer(start_tile, DiagDirection::Invalid, company);
 			YapfNotifyTrackLayoutChange(start_tile, DiagDirToDiagTrack(direction));
 		} else {
 			if (c != nullptr) c->infrastructure.road[roadtype] += num_pieces * 2; // A full diagonal road has two road bits.
@@ -911,7 +911,7 @@ static CommandCost DoClearTunnel(TileIndex tile, DoCommandFlags flags)
 			DoClearSquare(tile);
 			DoClearSquare(endtile);
 
-			/* cannot use INVALID_DIAGDIR for signal update because the tunnel doesn't exist anymore */
+			/* cannot use DiagDirection::Invalid for signal update because the tunnel doesn't exist anymore */
 			AddSideToSignalBuffer(tile,    ReverseDiagDir(dir), owner);
 			AddSideToSignalBuffer(endtile, dir,                 owner);
 
@@ -1009,7 +1009,7 @@ static CommandCost DoClearBridge(TileIndex tile, DoCommandFlags flags)
 		}
 
 		if (rail) {
-			/* cannot use INVALID_DIAGDIR for signal update because the bridge doesn't exist anymore */
+			/* cannot use DiagDirection::Invalid for signal update because the bridge doesn't exist anymore */
 			AddSideToSignalBuffer(tile,    ReverseDiagDir(direction), owner);
 			AddSideToSignalBuffer(endtile, direction,                 owner);
 
@@ -1736,10 +1736,10 @@ static int GetSlopePixelZ_TunnelBridge(TileIndex tile, uint x, uint y, bool grou
 
 			switch (dir) {
 				default: NOT_REACHED();
-				case DIAGDIR_NE: tileh = SLOPE_NE; break;
-				case DIAGDIR_SE: tileh = SLOPE_SE; break;
-				case DIAGDIR_SW: tileh = SLOPE_SW; break;
-				case DIAGDIR_NW: tileh = SLOPE_NW; break;
+				case DiagDirection::NE: tileh = SLOPE_NE; break;
+				case DiagDirection::SE: tileh = SLOPE_SE; break;
+				case DiagDirection::SW: tileh = SLOPE_SW; break;
+				case DiagDirection::NW: tileh = SLOPE_NW; break;
 			}
 		}
 	}
@@ -1856,7 +1856,7 @@ static TrackStatus GetTileTrackStatus_TunnelBridge(TileIndex tile, TransportType
 	if (transport_type != mode || (transport_type == TRANSPORT_ROAD && !HasTileRoadType(tile, (RoadTramType)sub_mode))) return 0;
 
 	DiagDirection dir = GetTunnelBridgeDirection(tile);
-	if (side != INVALID_DIAGDIR && side != ReverseDiagDir(dir)) return 0;
+	if (side != DiagDirection::Invalid && side != ReverseDiagDir(dir)) return 0;
 	return CombineTrackStatus(TrackBitsToTrackdirBits(DiagDirToDiagTrackBits(dir)), TRACKDIR_BIT_NONE);
 }
 
@@ -1968,7 +1968,7 @@ static VehicleEnterTileStates VehicleEnterTile_TunnelBridge(Vehicle *v, TileInde
 	/* New position of the vehicle on the tile */
 	uint8_t pos = (DiagDirToAxis(vdir) == Axis::X ? x : y) & TILE_UNIT_MASK;
 	/* Number of units moved by the vehicle since entering the tile */
-	uint8_t frame = (vdir == DIAGDIR_NE || vdir == DIAGDIR_NW) ? TILE_SIZE - 1 - pos : pos;
+	uint8_t frame = (vdir == DiagDirection::NE || vdir == DiagDirection::NW) ? TILE_SIZE - 1 - pos : pos;
 
 	if (IsTunnel(tile)) {
 		if (v->type == VehicleType::Train) {
@@ -2106,7 +2106,7 @@ static CommandCost TerraformTile_TunnelBridge(TileIndex tile, DoCommandFlags fla
 		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)) {
+		if ((direction == DiagDirection::NW) || (direction == DiagDirection::NE)) {
 			CheckBridgeSlope(BRIDGE_PIECE_SOUTH, axis, tileh_old, z_old);
 			res = CheckBridgeSlope(BRIDGE_PIECE_SOUTH, axis, tileh_new, z_new);
 		} else {
diff --git a/src/vehicle.cpp b/src/vehicle.cpp
index e9e3c08c25..c2c76d923e 100644
--- a/src/vehicle.cpp
+++ b/src/vehicle.cpp
@@ -1572,7 +1572,7 @@ void VehicleEnterDepot(Vehicle *v)
 			SetDepotReservation(t->tile, false);
 			if (_settings_client.gui.show_track_reservation) MarkTileDirtyByTile(t->tile);
 
-			UpdateSignalsOnSegment(t->tile, INVALID_DIAGDIR, t->owner);
+			UpdateSignalsOnSegment(t->tile, DiagDirection::Invalid, t->owner);
 			t->wait_counter = 0;
 			t->force_proceed = TFP_NONE;
 			t->flags.Reset(VehicleRailFlag::Reversed);
diff --git a/src/viewport.cpp b/src/viewport.cpp
index 7898967c12..6040cffbf7 100644
--- a/src/viewport.cpp
+++ b/src/viewport.cpp
@@ -2891,7 +2891,7 @@ static void VpStartPreSizing()
  * @param direction The rough direction the drag has been made in.
  * @return The highlight style of the first tile.
  * @note Depending on where on the start tile the click was, and some hysterasis, the
- *       direction for dragging to the east could be either DIAGDIR_NE or DIAGDIR_SE.
+ *       direction for dragging to the east could be either DiagDirection::NE or DiagDirection::SE.
  */
 static HighLightStyle Check2x1AutoRail(DiagDirection direction)
 {
@@ -2902,22 +2902,22 @@ static HighLightStyle Check2x1AutoRail(DiagDirection direction)
 
 	switch (direction) {
 		default: NOT_REACHED();
-		case DIAGDIR_SE: // end piece is lower right
+		case DiagDirection::SE: // end piece is lower right
 			if (fxpy >= 20 && sxpy <= 12) return HT_DIR_HL;
 			if (fxmy < -3 && sxmy > 3) return HT_DIR_VR;
 			return HT_DIR_Y;
 
-		case DIAGDIR_NW:
+		case DiagDirection::NW:
 			if (fxmy > 3 && sxmy < -3) return HT_DIR_VL;
 			if (fxpy <= 12 && sxpy >= 20) return HT_DIR_HU;
 			return HT_DIR_Y;
 
-		case DIAGDIR_SW:
+		case DiagDirection::SW:
 			if (fxmy > 3 && sxmy < -3) return HT_DIR_VL;
 			if (fxpy >= 20 && sxpy <= 12) return HT_DIR_HL;
 			return HT_DIR_X;
 
-		case DIAGDIR_NE:
+		case DiagDirection::NE:
 			if (fxmy < -3 && sxmy > 3) return HT_DIR_VR;
 			if (fxpy <= 12 && sxpy >= 20) return HT_DIR_HU;
 			return HT_DIR_X;
@@ -3193,18 +3193,18 @@ static void CalcRaildirsDrawstyle(int x, int y, int method)
 		}
 	} else if (h == TILE_SIZE) { // Is this in X direction?
 		if (dx == (int)TILE_SIZE) { // 2x1 special handling
-			b = Check2x1AutoRail(DIAGDIR_NE) | HT_LINE;
+			b = Check2x1AutoRail(DiagDirection::NE) | HT_LINE;
 		} else if (dx == -(int)TILE_SIZE) {
-			b = Check2x1AutoRail(DIAGDIR_SW) | HT_LINE;
+			b = Check2x1AutoRail(DiagDirection::SW) | HT_LINE;
 		} else {
 			b = HT_LINE | HT_DIR_X;
 		}
 		y = _thd.selstart.y;
 	} else if (w == TILE_SIZE) { // Or Y direction?
 		if (dy == (int)TILE_SIZE) { // 2x1 special handling
-			b = Check2x1AutoRail(DIAGDIR_NW) | HT_LINE;
+			b = Check2x1AutoRail(DiagDirection::NW) | HT_LINE;
 		} else if (dy == -(int)TILE_SIZE) { // 2x1 other direction
-			b = Check2x1AutoRail(DIAGDIR_SE) | HT_LINE;
+			b = Check2x1AutoRail(DiagDirection::SE) | HT_LINE;
 		} else {
 			b = HT_LINE | HT_DIR_Y;
 		}
diff --git a/src/water_cmd.cpp b/src/water_cmd.cpp
index 5c9be60348..9b1f7401b5 100644
--- a/src/water_cmd.cpp
+++ b/src/water_cmd.cpp
@@ -200,7 +200,7 @@ bool IsPossibleDockingTile(Tile t)
  */
 void CheckForDockingTile(TileIndex t)
 {
-	for (DiagDirection d = DIAGDIR_BEGIN; d != DIAGDIR_END; d++) {
+	for (DiagDirection d = DiagDirection::Begin; d != DiagDirection::End; d++) {
 		TileIndex tile = t + TileOffsByDiagDir(d);
 		if (!IsValidTile(tile)) continue;
 
@@ -242,7 +242,7 @@ void MakeWaterKeepingClass(TileIndex tile, Owner o)
 		}
 
 		/* Only river water should be restored on appropriate slopes. Other water would be invalid on slopes */
-		if (wc != WaterClass::River || GetInclinedSlopeDirection(slope) == INVALID_DIAGDIR) {
+		if (wc != WaterClass::River || GetInclinedSlopeDirection(slope) == DiagDirection::Invalid) {
 			wc = WaterClass::Invalid;
 		}
 	}
@@ -460,7 +460,7 @@ static CommandCost RemoveLock(TileIndex tile, DoCommandFlags flags)
 CommandCost CmdBuildLock(DoCommandFlags flags, TileIndex tile)
 {
 	DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile));
-	if (dir == INVALID_DIAGDIR) return CommandCost(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
+	if (dir == DiagDirection::Invalid) return CommandCost(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
 
 	TileIndex lower_tile = TileAddByDiagDir(tile, ReverseDiagDir(dir));