From 231d9466244db89e9309627991eb072bb3703f8a Mon Sep 17 00:00:00 2001 From: Peter Nelson Date: Sat, 6 Jun 2026 16:30:36 +0100 Subject: [PATCH] Codechange: make SignalType a scoped enum --- src/newgrf_railtype.cpp | 2 +- src/pathfinder/yapf/yapf_costrail.hpp | 12 +++++------ src/pathfinder/yapf/yapf_node_rail.hpp | 4 ++-- src/pbs.cpp | 2 +- src/rail.h | 2 +- src/rail_cmd.cpp | 24 +++++++++++----------- src/rail_gui.cpp | 28 +++++++++++++------------- src/rail_map.h | 14 ++++++------- src/saveload/afterload.cpp | 4 ++-- src/script/api/script_rail.cpp | 2 +- src/script/api/script_rail.hpp | 12 +++++------ src/signal.cpp | 2 +- src/signal_type.h | 19 ++++++++--------- src/train_cmd.cpp | 2 +- 14 files changed, 63 insertions(+), 66 deletions(-) diff --git a/src/newgrf_railtype.cpp b/src/newgrf_railtype.cpp index 207b96e597..bb1d8cf3d2 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 = (type << 16) | (to_underlying(var) << 8) | state; + uint32_t param2 = (to_underlying(type) << 16) | (to_underlying(var) << 8) | state; RailTypeResolverObject object(rti, tile, TCX_NORMAL, RailSpriteType::Signals, param1, param2); const auto *group = object.Resolve(); diff --git a/src/pathfinder/yapf/yapf_costrail.hpp b/src/pathfinder/yapf/yapf_costrail.hpp index 23ae26384b..c198496d92 100644 --- a/src/pathfinder/yapf/yapf_costrail.hpp +++ b/src/pathfinder/yapf/yapf_costrail.hpp @@ -244,10 +244,10 @@ public: /* special signal penalties */ if (n.num_signals_passed == 0) { switch (sig_type) { - case SIGTYPE_COMBO: - case SIGTYPE_EXIT: cost += Yapf().PfGetSettings().rail_firstred_exit_penalty; break; // first signal is red pre-signal-exit - case SIGTYPE_BLOCK: - case SIGTYPE_ENTRY: cost += Yapf().PfGetSettings().rail_firstred_penalty; break; + case SignalType::Combo: + case SignalType::Exit: cost += Yapf().PfGetSettings().rail_firstred_exit_penalty; break; // first signal is red pre-signal-exit + case SignalType::Block: + case SignalType::Entry: cost += Yapf().PfGetSettings().rail_firstred_penalty; break; default: break; } } @@ -534,7 +534,7 @@ no_entry_cost: // jump here at the beginning if the node has no parent (it is th if (HasSignalOnTrackdir(next.tile, next.td) && IsPbsSignal(GetSignalType(next.tile, TrackdirToTrack(next.td)))) { /* Possible safe tile. */ end_segment_reason.Set(EndSegmentReason::SafeTile); - } else if (HasSignalOnTrackdir(next.tile, ReverseTrackdir(next.td)) && GetSignalType(next.tile, TrackdirToTrack(next.td)) == SIGTYPE_PBS_ONEWAY) { + } else if (HasSignalOnTrackdir(next.tile, ReverseTrackdir(next.td)) && GetSignalType(next.tile, TrackdirToTrack(next.td)) == SignalType::PathOneWay) { /* Possible safe tile, but not so good as it's the back of a signal... */ end_segment_reason.Set({EndSegmentReason::SafeTile, EndSegmentReason::DeadEnd}); extra_cost += Yapf().PfGetSettings().rail_lastred_exit_penalty; @@ -606,7 +606,7 @@ no_entry_cost: // jump here at the beginning if the node has no parent (it is th n.flags_u.flags_s.target_seen = true; /* Last-red and last-red-exit penalties. */ if (n.flags_u.flags_s.last_signal_was_red) { - if (n.last_red_signal_type == SIGTYPE_EXIT) { + if (n.last_red_signal_type == SignalType::Exit) { /* last signal was red pre-signal-exit */ extra_cost += Yapf().PfGetSettings().rail_lastred_exit_penalty; } else if (!IsPbsSignal(n.last_red_signal_type)) { diff --git a/src/pathfinder/yapf/yapf_node_rail.hpp b/src/pathfinder/yapf/yapf_node_rail.hpp index 30c6f18c7a..8e3790618f 100644 --- a/src/pathfinder/yapf/yapf_node_rail.hpp +++ b/src/pathfinder/yapf/yapf_node_rail.hpp @@ -134,7 +134,7 @@ struct CYapfRailNode : CYapfNodeT { if (parent == nullptr) { this->num_signals_passed = 0; this->flags_u.inherited_flags = 0; - this->last_red_signal_type = SIGTYPE_BLOCK; + this->last_red_signal_type = SignalType::Block; /* We use PBS as initial signal type because if we are in * a PBS section and need to route, i.e. we're at a safe * waiting point of a station, we need to account for the @@ -145,7 +145,7 @@ struct CYapfRailNode : CYapfNodeT { * then avoiding that train with help of the reservation * costs is not a bad thing, actually it would probably * be a good thing to do. */ - this->last_signal_type = SIGTYPE_PBS; + this->last_signal_type = SignalType::Path; } else { this->num_signals_passed = parent->num_signals_passed; this->flags_u.inherited_flags = parent->flags_u.inherited_flags; diff --git a/src/pbs.cpp b/src/pbs.cpp index 91f30cc2d7..1f6cbf2c93 100644 --- a/src/pbs.cpp +++ b/src/pbs.cpp @@ -419,7 +419,7 @@ bool IsSafeWaitingPosition(const Train *v, TileIndex tile, Trackdir trackdir, bo if (HasPbsSignalOnTrackdir(ft.new_tile, td)) return true; /* One-way PBS signal against us? Safe if end-of-line is allowed. */ if (IsTileType(ft.new_tile, TileType::Railway) && HasSignalOnTrackdir(ft.new_tile, ReverseTrackdir(td)) && - GetSignalType(ft.new_tile, TrackdirToTrack(td)) == SIGTYPE_PBS_ONEWAY) { + GetSignalType(ft.new_tile, TrackdirToTrack(td)) == SignalType::PathOneWay) { return include_line_end; } } diff --git a/src/rail.h b/src/rail.h index 5267c3a992..6215aa6fc5 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, SignalVariant, SignalVariant::End>, SignalType, SIGTYPE_END> signals; ///< signal GUI sprites (type, variant, state) + EnumIndexArray, 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 1d678188b6..fb045a49ab 100644 --- a/src/rail_cmd.cpp +++ b/src/rail_cmd.cpp @@ -95,7 +95,7 @@ void ResolveRailTypeGUISprites(RailTypeInfo *rti) } /* Array of default GUI signal sprite numbers. */ - const EnumIndexArray, SignalVariant, SignalVariant::End> _signal_lookup{{{ + const EnumIndexArray, SignalVariant, SignalVariant::End> _signal_lookup{{{ {SPR_IMG_SIGNAL_ELECTRIC_NORM, SPR_IMG_SIGNAL_ELECTRIC_ENTRY, SPR_IMG_SIGNAL_ELECTRIC_EXIT, SPR_IMG_SIGNAL_ELECTRIC_COMBO, SPR_IMG_SIGNAL_ELECTRIC_PBS, SPR_IMG_SIGNAL_ELECTRIC_PBS_OWAY}, @@ -103,7 +103,7 @@ void ResolveRailTypeGUISprites(RailTypeInfo *rti) SPR_IMG_SIGNAL_SEMAPHORE_COMBO, SPR_IMG_SIGNAL_SEMAPHORE_PBS, SPR_IMG_SIGNAL_SEMAPHORE_PBS_OWAY}, }}}; - for (SignalType type = SIGTYPE_BLOCK; type < SIGTYPE_END; type = static_cast(to_underlying(type) + 1)) { + for (SignalType type = SignalType::Block; type < SignalType::End; type = static_cast(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); @@ -1056,8 +1056,8 @@ CommandCost CmdBuildTrainDepot(DoCommandFlags flags, TileIndex tile, RailType ra */ CommandCost CmdBuildSingleSignal(DoCommandFlags flags, TileIndex tile, Track track, SignalType sigtype, SignalVariant sigvar, bool convert_signal, bool skip_existing_signals, bool ctrl_pressed, SignalType cycle_start, SignalType cycle_stop, uint8_t num_dir_cycle, uint8_t signals_copy) { - if (sigtype > SIGTYPE_LAST || sigvar > SignalVariant::Semaphore) return CMD_ERROR; - if (cycle_start > cycle_stop || cycle_stop > SIGTYPE_LAST) return CMD_ERROR; + if (sigtype >= SignalType::End || sigvar >= SignalVariant::End) return CMD_ERROR; + if (cycle_start > cycle_stop || cycle_stop >= SignalType::End) return CMD_ERROR; if (ctrl_pressed) sigvar = (sigvar == SignalVariant::Electric ? SignalVariant::Semaphore : SignalVariant::Electric); @@ -1154,7 +1154,7 @@ CommandCost CmdBuildSingleSignal(DoCommandFlags flags, TileIndex tile, Track tra } else if (ctrl_pressed) { /* cycle between cycle_start and cycle_end */ - sigtype = (SignalType)(GetSignalType(tile, track) + 1); + sigtype = static_cast(to_underlying(GetSignalType(tile, track)) + 1); if (sigtype < cycle_start || sigtype > cycle_stop) sigtype = cycle_start; @@ -1267,7 +1267,7 @@ static CommandCost CmdSignalTrackHelper(DoCommandFlags flags, TileIndex tile, Ti if (end_tile >= Map::Size() || !ValParamTrackOrientation(track)) return CMD_ERROR; if (signal_density == 0 || signal_density > 20) return CMD_ERROR; - if (!remove && (sigtype > SIGTYPE_LAST || sigvar > SignalVariant::Semaphore)) return CMD_ERROR; + if (!remove && (sigtype >= SignalType::End || sigvar >= SignalVariant::End)) return CMD_ERROR; if (!IsPlainRailTile(tile)) return CommandCost(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK); TileIndex start_tile = tile; @@ -1296,7 +1296,7 @@ static CommandCost CmdSignalTrackHelper(DoCommandFlags flags, TileIndex tile, Ti sigtype = GetSignalType(tile, track); /* Don't but copy entry or exit-signal type */ - if (sigtype == SIGTYPE_ENTRY || sigtype == SIGTYPE_EXIT) sigtype = SIGTYPE_BLOCK; + if (sigtype == SignalType::Entry || sigtype == SignalType::Exit) sigtype = SignalType::Block; } else { // no signals exist, drag a two-way signal stretch signals = IsPbsSignal(sigtype) ? SignalAlongTrackdir(trackdir) : SignalOnTrack(track); } @@ -1331,7 +1331,7 @@ static CommandCost CmdSignalTrackHelper(DoCommandFlags flags, TileIndex tile, Ti if (HasBit(signal_dir, 1)) signals |= SignalAgainstTrackdir(trackdir); DoCommandFlags do_flags = test_only ? DoCommandFlags{flags}.Reset(DoCommandFlag::Execute) : flags; - CommandCost ret = remove ? Command::Do(do_flags, tile, TrackdirToTrack(trackdir)) : Command::Do(do_flags, tile, TrackdirToTrack(trackdir), sigtype, sigvar, false, signal_ctr == 0, mode, SIGTYPE_BLOCK, SIGTYPE_BLOCK, 0, signals); + CommandCost ret = remove ? Command::Do(do_flags, tile, TrackdirToTrack(trackdir)) : Command::Do(do_flags, tile, TrackdirToTrack(trackdir), sigtype, sigvar, false, signal_ctr == 0, mode, SignalType::Block, SignalType::Block, 0, signals); if (test_only) return ret.Succeeded(); @@ -1532,7 +1532,7 @@ CommandCost CmdRemoveSingleSignal(DoCommandFlags flags, TileIndex tile, Track tr */ CommandCost CmdRemoveSignalTrack(DoCommandFlags flags, TileIndex tile, TileIndex end_tile, Track track, bool autofill) { - return CmdSignalTrackHelper(flags, tile, end_tile, track, SIGTYPE_BLOCK, SignalVariant::Electric, false, true, autofill, false, 1); // bit 5 is remove bit + return CmdSignalTrackHelper(flags, tile, end_tile, track, SignalType::Block, SignalVariant::Electric, false, true, autofill, false, 1); // bit 5 is remove bit } /** @@ -1904,8 +1904,8 @@ static void DrawSingleSignal(TileIndex tile, const RailTypeInfo *rti, Track trac sprite += image; } else { /* Normal electric signals are stored in a different sprite block than all other signals. */ - sprite = (type == SIGTYPE_BLOCK && variant == SignalVariant::Electric) ? SPR_ORIGINAL_SIGNALS_BASE : SPR_SIGNALS_BASE - 16; - sprite += type * 16 + to_underlying(variant) * 64 + image * 2 + condition + (type > SIGTYPE_LAST_NOPBS ? 64 : 0); + 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); } AddSortableSpriteToDraw(sprite, PAL_NONE, x, y, GetSafeSlopeZ(x, y, track), {{}, {1, 1, BB_HEIGHT_UNDER_BRIDGE}, {}}); @@ -2838,7 +2838,7 @@ static void GetTileDesc_Rail(TileIndex tile, TileDesc &td) break; case RailTileType::Signals: { - static constexpr EnumIndexArray, SignalType, SIGTYPE_END> signal_type{{{ + static constexpr EnumIndexArray, SignalType, SignalType::End> signal_type{{{ { STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_SIGNALS, STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_PRESIGNALS, diff --git a/src/rail_gui.cpp b/src/rail_gui.cpp index d4105a9ba9..dd5d10affd 100644 --- a/src/rail_gui.cpp +++ b/src/rail_gui.cpp @@ -260,18 +260,18 @@ static void GenericPlaceSignals(TileIndex tile) /* Start with the least restrictive case: the player wants to cycle through all signals they can see. */ if (_settings_client.gui.cycle_signal_types == SIGNAL_CYCLE_ALL) { - cycle_start = _settings_client.gui.signal_gui_mode == SIGNAL_GUI_ALL ? SIGTYPE_BLOCK : SIGTYPE_PBS; - cycle_end = SIGTYPE_LAST; + cycle_start = _settings_client.gui.signal_gui_mode == SIGNAL_GUI_ALL ? SignalType::Block : SignalType::Path; + cycle_end = SignalType::PathOneWay; } else { /* Only cycle through signals of the same group (block or path) as the current signal on the tile. */ - if (cur_signal_on_tile <= SIGTYPE_LAST_NOPBS) { + if (cur_signal_on_tile <= SignalType::Combo) { /* Block signals only. */ - cycle_start = SIGTYPE_BLOCK; - cycle_end = SIGTYPE_LAST_NOPBS; + cycle_start = SignalType::Block; + cycle_end = SignalType::Combo; } else { /* Path signals only. */ - cycle_start = SIGTYPE_PBS; - cycle_end = SIGTYPE_LAST; + cycle_start = SignalType::Path; + cycle_end = SignalType::PathOneWay; } } @@ -1554,7 +1554,7 @@ public: this->sig_sprite_size.height = 0; this->sig_sprite_bottom_offset = 0; const RailTypeInfo *rti = GetRailTypeInfo(_cur_railtype); - for (SignalType type = SIGTYPE_BLOCK; type < SIGTYPE_END; type = static_cast(to_underlying(type) + 1)) { + for (SignalType type = SignalType::Block; type < SignalType::End; type = static_cast(to_underlying(type) + 1)) { for (SignalVariant variant : {SignalVariant::Electric, SignalVariant::Semaphore}) { for (SignalState state : {SIGNAL_STATE_RED, SIGNAL_STATE_GREEN}) { Point offset; @@ -1593,8 +1593,8 @@ public: { if (IsInsideMM(widget, WID_BS_SEMAPHORE_NORM, WID_BS_ELECTRIC_PBS_OWAY + 1)) { /* Extract signal from widget number. */ - SignalType type = static_cast((widget - WID_BS_SEMAPHORE_NORM) % SIGTYPE_END); - SignalVariant var = static_cast(to_underlying(SignalVariant::Semaphore) - (widget - WID_BS_SEMAPHORE_NORM) / SIGTYPE_END); // SignalVariant order is reversed compared to the widgets. + SignalType type = static_cast((widget - WID_BS_SEMAPHORE_NORM) % to_underlying(SignalType::End)); + SignalVariant var = static_cast(to_underlying(SignalVariant::Semaphore) - (widget - WID_BS_SEMAPHORE_NORM) / to_underlying(SignalType::End)); // SignalVariant order is reversed compared to the widgets. SpriteID sprite = GetRailTypeInfo(_cur_railtype)->gui_sprites.signals[type][var][static_cast(this->IsWidgetLowered(widget))]; this->DrawSignalSprite(r, sprite); @@ -1616,9 +1616,9 @@ public: case WID_BS_ELECTRIC_COMBO: case WID_BS_ELECTRIC_PBS: case WID_BS_ELECTRIC_PBS_OWAY: - this->RaiseWidget((_cur_signal_variant == SignalVariant::Electric ? WID_BS_ELECTRIC_NORM : WID_BS_SEMAPHORE_NORM) + _cur_signal_type); + this->RaiseWidget((_cur_signal_variant == SignalVariant::Electric ? WID_BS_ELECTRIC_NORM : WID_BS_SEMAPHORE_NORM) + to_underlying(_cur_signal_type)); - _cur_signal_type = (SignalType)((uint)((widget - WID_BS_SEMAPHORE_NORM) % (SIGTYPE_LAST + 1))); + _cur_signal_type = static_cast((uint)((widget - WID_BS_SEMAPHORE_NORM) % to_underlying(SignalType::End))); _cur_signal_variant = widget >= WID_BS_ELECTRIC_NORM ? SignalVariant::Electric : SignalVariant::Semaphore; /* Update default (last-used) signal type in config file. */ @@ -1664,7 +1664,7 @@ public: void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override { if (!gui_scope) return; - this->LowerWidget((_cur_signal_variant == SignalVariant::Electric ? WID_BS_ELECTRIC_NORM : WID_BS_SEMAPHORE_NORM) + _cur_signal_type); + this->LowerWidget((_cur_signal_variant == SignalVariant::Electric ? WID_BS_ELECTRIC_NORM : WID_BS_SEMAPHORE_NORM) + to_underlying(_cur_signal_type)); this->SetWidgetLoweredState(WID_BS_CONVERT, _convert_signal_button); @@ -2039,7 +2039,7 @@ void ResetSignalVariant(int32_t) Window *w = FindWindowById(WindowClass::BuildSignal, 0); if (w != nullptr) { w->SetDirty(); - w->RaiseWidget((_cur_signal_variant == SignalVariant::Electric ? WID_BS_ELECTRIC_NORM : WID_BS_SEMAPHORE_NORM) + _cur_signal_type); + w->RaiseWidget((_cur_signal_variant == SignalVariant::Electric ? WID_BS_ELECTRIC_NORM : WID_BS_SEMAPHORE_NORM) + to_underlying(_cur_signal_type)); } _cur_signal_variant = new_variant; } diff --git a/src/rail_map.h b/src/rail_map.h index b242b880be..83f028b63d 100644 --- a/src/rail_map.h +++ b/src/rail_map.h @@ -291,7 +291,7 @@ inline TrackBits GetDepotReservationTrackBits(Tile t) */ inline bool IsPbsSignal(SignalType s) { - return s == SIGTYPE_PBS || s == SIGTYPE_PBS_ONEWAY; + return s == SignalType::Path || s == SignalType::PathOneWay; } /** @@ -305,7 +305,7 @@ inline SignalType GetSignalType(Tile t, Track track) { assert(GetRailTileType(t) == RailTileType::Signals); uint8_t pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 0; - return (SignalType)GB(t.m2(), pos, 3); + return static_cast(GB(t.m2(), pos, 3)); } /** @@ -319,8 +319,8 @@ inline void SetSignalType(Tile t, Track track, SignalType s) { assert(GetRailTileType(t) == RailTileType::Signals); uint8_t pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 0; - SB(t.m2(), pos, 3, s); - if (!IsValidTrack(track)) SB(t.m2(), 4, 3, s); + SB(t.m2(), pos, 3, to_underlying(s)); + if (!IsValidTrack(track)) SB(t.m2(), 4, 3, to_underlying(s)); } /** @@ -332,7 +332,7 @@ inline void SetSignalType(Tile t, Track track, SignalType s) */ inline bool IsPresignalEntry(Tile t, Track track) { - return GetSignalType(t, track) == SIGTYPE_ENTRY || GetSignalType(t, track) == SIGTYPE_COMBO; + return GetSignalType(t, track) == SignalType::Entry || GetSignalType(t, track) == SignalType::Combo; } /** @@ -344,7 +344,7 @@ inline bool IsPresignalEntry(Tile t, Track track) */ inline bool IsPresignalExit(Tile t, Track track) { - return GetSignalType(t, track) == SIGTYPE_EXIT || GetSignalType(t, track) == SIGTYPE_COMBO; + return GetSignalType(t, track) == SignalType::Exit || GetSignalType(t, track) == SignalType::Combo; } /** @@ -357,7 +357,7 @@ inline bool IsPresignalExit(Tile t, Track track) */ inline bool IsOnewaySignal(Tile t, Track track) { - return GetSignalType(t, track) != SIGTYPE_PBS; + return GetSignalType(t, track) != SignalType::Path; } /** diff --git a/src/saveload/afterload.cpp b/src/saveload/afterload.cpp index 7e610c157c..1bbd2dd888 100644 --- a/src/saveload/afterload.cpp +++ b/src/saveload/afterload.cpp @@ -1400,8 +1400,8 @@ bool AfterLoadGame() * version 48 they are in m2. The bits has been already moved to m2 * (see the code somewhere above) so don't use m4, use m2 instead. */ - /* convert PBS signals to combo-signals */ - if (HasBit(t.m2(), 2)) SB(t.m2(), 0, 2, SIGTYPE_COMBO); + /* convert old PBS signals to combo-signals */ + if (HasBit(t.m2(), 2)) SB(t.m2(), 0, 2, to_underlying(SignalType::Combo)); /* move the signal variant back */ SB(t.m2(), 2, 1, to_underlying(HasBit(t.m2(), 3) ? SignalVariant::Semaphore : SignalVariant::Electric)); diff --git a/src/script/api/script_rail.cpp b/src/script/api/script_rail.cpp index e23a921e53..c249dc85c7 100644 --- a/src/script/api/script_rail.cpp +++ b/src/script/api/script_rail.cpp @@ -466,7 +466,7 @@ static bool IsValidSignalType(int signal_type) } ::SignalType sig_type = (::SignalType)(signal >= SIGNALTYPE_TWOWAY ? signal ^ SIGNALTYPE_TWOWAY : signal); - return ScriptObject::Command::Do(tile, track, sig_type, ::SignalVariant::Electric, false, false, false, ::SIGTYPE_BLOCK, ::SIGTYPE_BLOCK, signal_cycles, 0); + return ScriptObject::Command::Do(tile, track, sig_type, ::SignalVariant::Electric, false, false, false, ::SignalType::Block, ::SignalType::Block, signal_cycles, 0); } /* static */ bool ScriptRail::RemoveSignal(TileIndex tile, TileIndex front) diff --git a/src/script/api/script_rail.hpp b/src/script/api/script_rail.hpp index ebe8a9de7b..09794028aa 100644 --- a/src/script/api/script_rail.hpp +++ b/src/script/api/script_rail.hpp @@ -67,12 +67,12 @@ public: */ enum SignalType { /* Note: these values represent part of the in-game SignalType enum */ - SIGNALTYPE_NORMAL = ::SIGTYPE_BLOCK, ///< Block signal. - SIGNALTYPE_ENTRY = ::SIGTYPE_ENTRY, ///< Entry presignal. - SIGNALTYPE_EXIT = ::SIGTYPE_EXIT, ///< Exit signal. - SIGNALTYPE_COMBO = ::SIGTYPE_COMBO, ///< Combo signal. - SIGNALTYPE_PBS = ::SIGTYPE_PBS, ///< Normal PBS signal. - SIGNALTYPE_PBS_ONEWAY = ::SIGTYPE_PBS_ONEWAY, ///< No-entry PBS signal. + SIGNALTYPE_NORMAL = to_underlying(::SignalType::Block), ///< Block signal. + SIGNALTYPE_ENTRY = to_underlying(::SignalType::Entry), ///< Entry presignal. + SIGNALTYPE_EXIT = to_underlying(::SignalType::Exit), ///< Exit signal. + SIGNALTYPE_COMBO = to_underlying(::SignalType::Combo), ///< Combo signal. + SIGNALTYPE_PBS = to_underlying(::SignalType::Path), ///< Normal path signal. + SIGNALTYPE_PBS_ONEWAY = to_underlying(::SignalType::PathOneWay), ///< No-entry path signal. SIGNALTYPE_TWOWAY = 8, ///< Bit mask for twoway signal. SIGNALTYPE_NORMAL_TWOWAY = SIGNALTYPE_NORMAL | SIGNALTYPE_TWOWAY, ///< Normal twoway signal. diff --git a/src/signal.cpp b/src/signal.cpp index 3153b9e4ff..771ba21676 100644 --- a/src/signal.cpp +++ b/src/signal.cpp @@ -438,7 +438,7 @@ static void UpdateSignalsAroundSegment(SigFlags flags) newstate = SIGNAL_STATE_RED; } else { /* is it a bidir combo? - then do not count its other signal direction as exit */ - if (sig == SIGTYPE_COMBO && HasSignalOnTrackdir(tile, ReverseTrackdir(trackdir))) { + if (sig == SignalType::Combo && HasSignalOnTrackdir(tile, ReverseTrackdir(trackdir))) { /* at least one more exit */ if (flags.Test(SigFlag::MultiExit) && /* no green exit */ diff --git a/src/signal_type.h b/src/signal_type.h index 6a9b781750..eb73c6e286 100644 --- a/src/signal_type.h +++ b/src/signal_type.h @@ -21,17 +21,14 @@ enum class SignalVariant : uint8_t { /** Type of signal, i.e. how does the signal behave? */ -enum SignalType : uint8_t { - SIGTYPE_BLOCK = 0, ///< block signal - SIGTYPE_ENTRY = 1, ///< presignal block entry - SIGTYPE_EXIT = 2, ///< presignal block exit - SIGTYPE_COMBO = 3, ///< presignal inter-block - SIGTYPE_PBS = 4, ///< normal pbs signal - SIGTYPE_PBS_ONEWAY = 5, ///< no-entry signal - - SIGTYPE_END, /// End marker. - SIGTYPE_LAST = SIGTYPE_PBS_ONEWAY, - SIGTYPE_LAST_NOPBS = SIGTYPE_COMBO, +enum class SignalType : uint8_t { + Block = 0, ///< block signal. + Entry = 1, ///< presignal block entry. + Exit = 2, ///< presignal block exit. + Combo = 3, ///< presignal inter-block. + Path = 4, ///< normal path signal. + PathOneWay = 5, ///< no-entry path signal. + End, ///< End marker. }; DECLARE_ENUM_AS_ADDABLE(SignalType) diff --git a/src/train_cmd.cpp b/src/train_cmd.cpp index 0ac7a0d96a..15c745522b 100644 --- a/src/train_cmd.cpp +++ b/src/train_cmd.cpp @@ -3426,7 +3426,7 @@ bool TrainController(Train *v, Vehicle *nomove, bool reverse) Trackdir dir = FindFirstTrackdir(trackdirbits); if (HasSignalOnTrackdir(gp.new_tile, dir) || (HasSignalOnTrackdir(gp.new_tile, ReverseTrackdir(dir)) && - GetSignalType(gp.new_tile, TrackdirToTrack(dir)) != SIGTYPE_PBS)) { + GetSignalType(gp.new_tile, TrackdirToTrack(dir)) != SignalType::Path)) { /* However, we do not want to be stopped by PBS signals * entered via the back. */ first->force_proceed = (first->force_proceed == TFP_SIGNAL) ? TFP_STUCK : TFP_NONE;