diff --git a/src/newgrf_railtype.cpp b/src/newgrf_railtype.cpp
index bb1d8cf3d2..8218625fd6 100644
--- a/src/newgrf_railtype.cpp
+++ b/src/newgrf_railtype.cpp
@@ -133,7 +133,7 @@ SpriteID GetCustomSignalSprite(const RailTypeInfo *rti, TileIndex tile, SignalTy
 	if (rti->group[RailSpriteType::Signals] == nullptr) return 0;
 
 	uint32_t param1 = gui ? 0x10 : 0x00;
-	uint32_t param2 = (to_underlying(type) << 16) | (to_underlying(var) << 8) | state;
+	uint32_t param2 = (to_underlying(type) << 16) | (to_underlying(var) << 8) | to_underlying(state);
 	RailTypeResolverObject object(rti, tile, TCX_NORMAL, RailSpriteType::Signals, param1, param2);
 
 	const auto *group = object.Resolve<ResultSpriteGroup>();
diff --git a/src/pathfinder/yapf/yapf_costrail.hpp b/src/pathfinder/yapf/yapf_costrail.hpp
index c198496d92..b08a90e765 100644
--- a/src/pathfinder/yapf/yapf_costrail.hpp
+++ b/src/pathfinder/yapf/yapf_costrail.hpp
@@ -214,7 +214,7 @@ public:
 
 					/* cache the look-ahead polynomial constant only if we didn't pass more signals than the look-ahead limit is */
 					int look_ahead_cost = (n.num_signals_passed < this->sig_look_ahead_costs.size()) ? this->sig_look_ahead_costs[n.num_signals_passed] : 0;
-					if (sig_state != SIGNAL_STATE_RED) {
+					if (sig_state != SignalState::Red) {
 						/* green signal */
 						n.flags_u.flags_s.last_signal_was_red = false;
 						/* negative look-ahead red-signal penalties would cause problems later, so use them as positive penalties for green signal */
@@ -376,7 +376,7 @@ public:
 					if (segment.last_signal_tile != INVALID_TILE) {
 						assert(HasSignalOnTrackdir(segment.last_signal_tile, segment.last_signal_td));
 						SignalState sig_state = GetSignalStateByTrackdir(segment.last_signal_tile, segment.last_signal_td);
-						bool is_red = (sig_state == SIGNAL_STATE_RED);
+						bool is_red = (sig_state == SignalState::Red);
 						n.flags_u.flags_s.last_signal_was_red = is_red;
 						if (is_red) {
 							n.last_red_signal_type = GetSignalType(segment.last_signal_tile, TrackdirToTrack(segment.last_signal_td));
diff --git a/src/pathfinder/yapf/yapf_rail.cpp b/src/pathfinder/yapf/yapf_rail.cpp
index d454f9aed8..6d4e8b66c9 100644
--- a/src/pathfinder/yapf/yapf_rail.cpp
+++ b/src/pathfinder/yapf/yapf_rail.cpp
@@ -115,9 +115,9 @@ private:
 			}
 
 			/* Green path signal opposing the path? Turn to red. */
-			if (HasPbsSignalOnTrackdir(tile, rev_td) && GetSignalStateByTrackdir(tile, rev_td) == SIGNAL_STATE_GREEN) {
+			if (HasPbsSignalOnTrackdir(tile, rev_td) && GetSignalStateByTrackdir(tile, rev_td) == SignalState::Green) {
 				this->signals_set_to_red.emplace_back(tile, rev_td);
-				SetSignalStateByTrackdir(tile, rev_td, SIGNAL_STATE_RED);
+				SetSignalStateByTrackdir(tile, rev_td, SignalState::Red);
 				MarkTileDirtyByTile(tile);
 			}
 
@@ -217,7 +217,7 @@ public:
 
 				/* Re-instate green path signals we turned to red. */
 				for (auto [sig_tile, td] : this->signals_set_to_red) {
-					SetSignalStateByTrackdir(sig_tile, td, SIGNAL_STATE_GREEN);
+					SetSignalStateByTrackdir(sig_tile, td, SignalState::Green);
 				}
 
 				return false;
diff --git a/src/rail.h b/src/rail.h
index 6215aa6fc5..a997b06bc5 100644
--- a/src/rail.h
+++ b/src/rail.h
@@ -147,7 +147,7 @@ public:
 		SpriteID build_depot;        ///< button for building depots
 		SpriteID build_tunnel;       ///< button for building a tunnel
 		SpriteID convert_rail;       ///< button for converting rail
-		EnumIndexArray<EnumIndexArray<EnumIndexArray<SpriteID, SignalState, SIGNAL_STATE_END>, SignalVariant, SignalVariant::End>, SignalType, SignalType::End> signals; ///< signal GUI sprites (type, variant, state)
+		EnumIndexArray<EnumIndexArray<EnumIndexArray<SpriteID, SignalState, SignalState::End>, SignalVariant, SignalVariant::End>, SignalType, SignalType::End> signals; ///< signal GUI sprites (type, variant, state)
 	} gui_sprites;
 
 	struct {
diff --git a/src/rail_cmd.cpp b/src/rail_cmd.cpp
index fb045a49ab..edb5259189 100644
--- a/src/rail_cmd.cpp
+++ b/src/rail_cmd.cpp
@@ -105,10 +105,10 @@ void ResolveRailTypeGUISprites(RailTypeInfo *rti)
 
 	for (SignalType type = SignalType::Block; type < SignalType::End; type = static_cast<SignalType>(to_underlying(type) + 1)) {
 		for (SignalVariant var : {SignalVariant::Electric, SignalVariant::Semaphore}) {
-			SpriteID red = GetCustomSignalSprite(rti, INVALID_TILE, type, var, SIGNAL_STATE_RED, true);
-			SpriteID green = GetCustomSignalSprite(rti, INVALID_TILE, type, var, SIGNAL_STATE_GREEN, true);
-			rti->gui_sprites.signals[type][var][SIGNAL_STATE_RED] = (red != 0) ? red + SIGNAL_TO_SOUTH : _signal_lookup[var][type];
-			rti->gui_sprites.signals[type][var][SIGNAL_STATE_GREEN] = (green != 0) ? green + SIGNAL_TO_SOUTH : _signal_lookup[var][type] + 1;
+			SpriteID red = GetCustomSignalSprite(rti, INVALID_TILE, type, var, SignalState::Red, true);
+			SpriteID green = GetCustomSignalSprite(rti, INVALID_TILE, type, var, SignalState::Green, true);
+			rti->gui_sprites.signals[type][var][SignalState::Red] = (red != 0) ? red + SIGNAL_TO_SOUTH : _signal_lookup[var][type];
+			rti->gui_sprites.signals[type][var][SignalState::Green] = (green != 0) ? green + SIGNAL_TO_SOUTH : _signal_lookup[var][type] + 1;
 		}
 	}
 }
@@ -1905,7 +1905,7 @@ static void DrawSingleSignal(TileIndex tile, const RailTypeInfo *rti, Track trac
 	} else {
 		/* Normal electric signals are stored in a different sprite block than all other signals. */
 		sprite = (type == SignalType::Block && variant == SignalVariant::Electric) ? SPR_ORIGINAL_SIGNALS_BASE : SPR_SIGNALS_BASE - 16;
-		sprite += to_underlying(type) * 16 + to_underlying(variant) * 64 + image * 2 + condition + (type >= SignalType::Path ? 64 : 0);
+		sprite += to_underlying(type) * 16 + to_underlying(variant) * 64 + image * 2 + to_underlying(condition) + (type >= SignalType::Path ? 64 : 0);
 	}
 
 	AddSortableSpriteToDraw(sprite, PAL_NONE, x, y, GetSafeSlopeZ(x, y, track), {{}, {1, 1, BB_HEIGHT_UNDER_BRIDGE}, {}});
diff --git a/src/rail_gui.cpp b/src/rail_gui.cpp
index dd5d10affd..55103bf789 100644
--- a/src/rail_gui.cpp
+++ b/src/rail_gui.cpp
@@ -1556,7 +1556,7 @@ public:
 		const RailTypeInfo *rti = GetRailTypeInfo(_cur_railtype);
 		for (SignalType type = SignalType::Block; type < SignalType::End; type = static_cast<SignalType>(to_underlying(type) + 1)) {
 			for (SignalVariant variant : {SignalVariant::Electric, SignalVariant::Semaphore}) {
-				for (SignalState state : {SIGNAL_STATE_RED, SIGNAL_STATE_GREEN}) {
+				for (SignalState state : {SignalState::Red, SignalState::Green}) {
 					Point offset;
 					Dimension sprite_size = GetSpriteSize(rti->gui_sprites.signals[type][variant][state], &offset);
 					this->sig_sprite_bottom_offset = std::max<int>(this->sig_sprite_bottom_offset, sprite_size.height);
diff --git a/src/rail_map.h b/src/rail_map.h
index 83f028b63d..31ef57a0e9 100644
--- a/src/rail_map.h
+++ b/src/rail_map.h
@@ -431,7 +431,7 @@ inline uint GetSignalStates(Tile tile)
  */
 inline SignalState GetSingleSignalState(Tile t, uint8_t signalbit)
 {
-	return (SignalState)HasBit(GetSignalStates(t), signalbit);
+	return static_cast<SignalState>(HasBit(GetSignalStates(t), signalbit));
 }
 
 /**
@@ -508,7 +508,7 @@ inline SignalState GetSignalStateByTrackdir(Tile tile, Trackdir trackdir)
 	assert(IsValidTrackdir(trackdir));
 	assert(HasSignalOnTrack(tile, TrackdirToTrack(trackdir)));
 	return GetSignalStates(tile) & SignalAlongTrackdir(trackdir) ?
-		SIGNAL_STATE_GREEN : SIGNAL_STATE_RED;
+		SignalState::Green : SignalState::Red;
 }
 
 /**
@@ -519,7 +519,7 @@ inline SignalState GetSignalStateByTrackdir(Tile tile, Trackdir trackdir)
  */
 inline void SetSignalStateByTrackdir(Tile tile, Trackdir trackdir, SignalState state)
 {
-	if (state == SIGNAL_STATE_GREEN) { // set 1
+	if (state == SignalState::Green) { // set 1
 		SetSignalStates(tile, GetSignalStates(tile) | SignalAlongTrackdir(trackdir));
 	} else {
 		SetSignalStates(tile, GetSignalStates(tile) & ~SignalAlongTrackdir(trackdir));
diff --git a/src/signal.cpp b/src/signal.cpp
index 771ba21676..0c432d409e 100644
--- a/src/signal.cpp
+++ b/src/signal.cpp
@@ -338,7 +338,7 @@ static SigFlags ExploreSegment(Owner owner)
 						if (!flags.Test(SigFlag::MultiGreen) && IsPresignalExit(tile, track) && HasSignalOnTrackdir(tile, trackdir)) { // found presignal exit
 							if (flags.Test(SigFlag::Exit)) flags.Set(SigFlag::MultiExit); // found two (or more) exits
 							flags.Set(SigFlag::Exit); // found at least one exit - allow for compiler optimizations
-							if (GetSignalStateByTrackdir(tile, trackdir) == SIGNAL_STATE_GREEN) { // found green presignal exit
+							if (GetSignalStateByTrackdir(tile, trackdir) == SignalState::Green) { // found green presignal exit
 								if (flags.Test(SigFlag::Green)) flags.Set(SigFlag::MultiGreen);
 								flags.Set(SigFlag::Green);
 							}
@@ -424,7 +424,7 @@ static void UpdateSignalsAroundSegment(SigFlags flags)
 
 		Track track = TrackdirToTrack(trackdir);
 		SignalType sig = GetSignalType(tile, track);
-		SignalState newstate = SIGNAL_STATE_GREEN;
+		SignalState newstate = SignalState::Green;
 
 		/* Signal state of reserved path signals is handled by the reserve/unreserve process. */
 		if (IsPbsSignal(sig) && (GetRailReservationTrackBits(tile) & TrackToTrackBits(track)) != TRACK_BIT_NONE) continue;
@@ -432,10 +432,10 @@ static void UpdateSignalsAroundSegment(SigFlags flags)
 		/* determine whether the new state is red */
 		if (flags.Test(SigFlag::Train)) {
 			/* train in the segment */
-			newstate = SIGNAL_STATE_RED;
+			newstate = SignalState::Red;
 		} else if (IsPbsSignal(sig) && flags.Any({SigFlag::Split, SigFlag::MultiEnter})) {
 			/* Turn path signals red if the segment has a junction or more than one way in. */
-			newstate = SIGNAL_STATE_RED;
+			newstate = SignalState::Red;
 		} else {
 			/* is it a bidir combo? - then do not count its other signal direction as exit */
 			if (sig == SignalType::Combo && HasSignalOnTrackdir(tile, ReverseTrackdir(trackdir))) {
@@ -444,11 +444,11 @@ static void UpdateSignalsAroundSegment(SigFlags flags)
 						/* no green exit */
 						(!flags.Test(SigFlag::Green) ||
 						/* only one green exit, and it is this one - so all other exits are red */
-						(!flags.Test(SigFlag::MultiGreen) && GetSignalStateByTrackdir(tile, ReverseTrackdir(trackdir)) == SIGNAL_STATE_GREEN))) {
-					newstate = SIGNAL_STATE_RED;
+						(!flags.Test(SigFlag::MultiGreen) && GetSignalStateByTrackdir(tile, ReverseTrackdir(trackdir)) == SignalState::Green))) {
+					newstate = SignalState::Red;
 				}
 			} else { // entry, at least one exit, no green exit
-				if (IsPresignalEntry(tile, TrackdirToTrack(trackdir)) && flags.Test(SigFlag::Exit) && !flags.Test(SigFlag::Green)) newstate = SIGNAL_STATE_RED;
+				if (IsPresignalEntry(tile, TrackdirToTrack(trackdir)) && flags.Test(SigFlag::Exit) && !flags.Test(SigFlag::Green)) newstate = SignalState::Red;
 			}
 		}
 
diff --git a/src/signal_type.h b/src/signal_type.h
index eb73c6e286..970a0ae05f 100644
--- a/src/signal_type.h
+++ b/src/signal_type.h
@@ -30,17 +30,17 @@ enum class SignalType : uint8_t {
 	PathOneWay = 5, ///< no-entry path signal.
 	End, ///< End marker.
 };
-DECLARE_ENUM_AS_ADDABLE(SignalType)
+
 
 /**
  * These are states in which a signal can be. Currently these are only two, so
  * simple boolean logic will do. But do try to compare to this enum instead of
  * normal boolean evaluation, since that will make future additions easier.
  */
-enum SignalState : uint8_t {
-	SIGNAL_STATE_RED   = 0, ///< The signal is red
-	SIGNAL_STATE_GREEN = 1, ///< The signal is green
-	SIGNAL_STATE_END, ///< End marker.
+enum class SignalState : uint8_t {
+	Red = 0, ///< The signal is red
+	Green = 1, ///< The signal is green
+	End, ///< End marker.
 };
 
 #endif /* SIGNAL_TYPE_H */
diff --git a/src/train_cmd.cpp b/src/train_cmd.cpp
index 15c745522b..1dd75c3a7b 100644
--- a/src/train_cmd.cpp
+++ b/src/train_cmd.cpp
@@ -2318,7 +2318,7 @@ static void CheckNextTrainTile(Train *consist)
 	Trackdir td = moving_front->GetVehicleTrackdir();
 
 	/* On a tile with a red non-pbs signal, don't look ahead. */
-	if (HasBlockSignalOnTrackdir(moving_front->tile, td) && GetSignalStateByTrackdir(moving_front->tile, td) == SIGNAL_STATE_RED) return;
+	if (HasBlockSignalOnTrackdir(moving_front->tile, td) && GetSignalStateByTrackdir(moving_front->tile, td) == SignalState::Red) return;
 
 	CFollowTrackRail ft(consist);
 	if (!ft.Follow(moving_front->tile, td)) return;
@@ -2502,12 +2502,12 @@ void FreeTrainTrackReservation(const Train *consist)
 				break;
 			}
 			if (HasPbsSignalOnTrackdir(tile, td)) {
-				if (GetSignalStateByTrackdir(tile, td) == SIGNAL_STATE_RED) {
+				if (GetSignalStateByTrackdir(tile, td) == SignalState::Red) {
 					/* Red PBS signal? Can't be our reservation, would be green then. */
 					break;
 				} else {
 					/* Turn the signal back to red. */
-					SetSignalStateByTrackdir(tile, td, SIGNAL_STATE_RED);
+					SetSignalStateByTrackdir(tile, td, SignalState::Red);
 					MarkTileDirtyByTile(tile);
 				}
 			} else if (HasPbsSignalOnTrackdir(tile, ReverseTrackdir(td))) {
@@ -2604,9 +2604,9 @@ static PBSTileInfo ExtendTrainReservation(const Train *v, TrackBits *new_tracks,
 			bool wp_free = IsWaitingPositionFree(v, tile, cur_td, _settings_game.pf.forbid_90_deg);
 			if (!(wp_free && TryReserveRailTrack(tile, TrackdirToTrack(cur_td)))) break;
 			/* Green path signal opposing the path? Turn to red. */
-			if (HasPbsSignalOnTrackdir(tile, rev_td) && GetSignalStateByTrackdir(tile, rev_td) == SIGNAL_STATE_GREEN) {
+			if (HasPbsSignalOnTrackdir(tile, rev_td) && GetSignalStateByTrackdir(tile, rev_td) == SignalState::Green) {
 				signals_set_to_red.emplace_back(tile, rev_td);
-				SetSignalStateByTrackdir(tile, rev_td, SIGNAL_STATE_RED);
+				SetSignalStateByTrackdir(tile, rev_td, SignalState::Red);
 				MarkTileDirtyByTile(tile);
 			}
 			/* Safe position is all good, path valid and okay. */
@@ -2616,9 +2616,9 @@ static PBSTileInfo ExtendTrainReservation(const Train *v, TrackBits *new_tracks,
 		if (!TryReserveRailTrack(tile, TrackdirToTrack(cur_td))) break;
 
 		/* Green path signal opposing the path? Turn to red. */
-		if (HasPbsSignalOnTrackdir(tile, rev_td) && GetSignalStateByTrackdir(tile, rev_td) == SIGNAL_STATE_GREEN) {
+		if (HasPbsSignalOnTrackdir(tile, rev_td) && GetSignalStateByTrackdir(tile, rev_td) == SignalState::Green) {
 			signals_set_to_red.emplace_back(tile, rev_td);
-			SetSignalStateByTrackdir(tile, rev_td, SIGNAL_STATE_RED);
+			SetSignalStateByTrackdir(tile, rev_td, SignalState::Red);
 			MarkTileDirtyByTile(tile);
 		}
 	}
@@ -2650,7 +2650,7 @@ static PBSTileInfo ExtendTrainReservation(const Train *v, TrackBits *new_tracks,
 
 	/* Re-instate green signals we turned to red. */
 	for (auto [sig_tile, td] : signals_set_to_red) {
-		SetSignalStateByTrackdir(sig_tile, td, SIGNAL_STATE_GREEN);
+		SetSignalStateByTrackdir(sig_tile, td, SignalState::Green);
 	}
 
 	/* Path invalid. */
@@ -2791,7 +2791,7 @@ static Track ChooseTrainTrack(Train *consist, TileIndex tile, DiagDirection ente
 		if (IsValidTrack(track) && HasPbsSignalOnTrackdir(tile, TrackEnterdirToTrackdir(track, enterdir))) {
 			do_track_reservation = true;
 			changed_signal = true;
-			SetSignalStateByTrackdir(tile, TrackEnterdirToTrackdir(track, enterdir), SIGNAL_STATE_GREEN);
+			SetSignalStateByTrackdir(tile, TrackEnterdirToTrackdir(track, enterdir), SignalState::Green);
 		} else if (!do_track_reservation) {
 			return track;
 		}
@@ -2807,7 +2807,7 @@ static Track ChooseTrainTrack(Train *consist, TileIndex tile, DiagDirection ente
 		if (res_dest.tile == INVALID_TILE) {
 			/* Reservation failed? */
 			if (mark_stuck) MarkTrainAsStuck(consist);
-			if (changed_signal) SetSignalStateByTrackdir(tile, TrackEnterdirToTrackdir(best_track, enterdir), SIGNAL_STATE_RED);
+			if (changed_signal) SetSignalStateByTrackdir(tile, TrackEnterdirToTrackdir(best_track, enterdir), SignalState::Red);
 			return FindFirstTrack(tracks);
 		}
 		if (res_dest.okay) {
@@ -3531,7 +3531,7 @@ bool TrainController(Train *v, Vehicle *nomove, bool reverse)
 					Track track = FindFirstTrack(chosen_track);
 					Trackdir tdir = TrackDirectionToTrackdir(track, chosen_dir);
 					if (v->IsMovingFront() && HasPbsSignalOnTrackdir(gp.new_tile, tdir)) {
-						SetSignalStateByTrackdir(gp.new_tile, tdir, SIGNAL_STATE_RED);
+						SetSignalStateByTrackdir(gp.new_tile, tdir, SignalState::Red);
 						MarkTileDirtyByTile(gp.new_tile);
 					}