Merge remote-tracking branch 'upstream/master' into up180824

Content.Client/_NC/Radio/UI/HandheldRadioBoundUserInterface.cs

@@ -0,0 +1,62 @@
+using Content.Shared._NC.Radio;
+using JetBrains.Annotations;
+using Robust.Client.GameObjects;
+
+namespace Content.Client._NC.Radio.UI;
+
+
+[UsedImplicitly]
+public sealed class HandheldRadioBoundUserInterface : BoundUserInterface
+{
+    [ViewVariables]
+    private HandheldRadioMenu? _menu;
+
+    public HandheldRadioBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _menu = new();
+
+        _menu.OnMicPressed += enabled =>
+        {
+            SendMessage(new ToggleHandheldRadioMicMessage(enabled));
+        };
+        _menu.OnSpeakerPressed += enabled =>
+        {
+            SendMessage(new ToggleHandheldRadioSpeakerMessage(enabled));
+        };
+        _menu.OnFrequencyChanged += frequency =>
+        {
+            if (int.TryParse(frequency.Trim(), out var intFreq) && intFreq > 0)
+                SendMessage(new SelectHandheldRadioFrequencyMessage(intFreq));
+            else
+                SendMessage(new SelectHandheldRadioFrequencyMessage(-1)); // Query the current frequency
+        };
+
+        _menu.OnClose += Close;
+        _menu.OpenCentered();
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+        if (!disposing)
+            return;
+        _menu?.Close();
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        if (state is not HandheldRadioBoundUIState msg)
+            return;
+
+        _menu?.Update(msg);
+    }
+}

Content.Client/_NC/Radio/UI/HandheldRadioMenu.xaml

@@ -0,0 +1,29 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+                      xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+                      Title="{Loc 'handheld-radio-menu-title'}"
+                      MinSize="200 150"
+                      SetSize="200 150">
+    <BoxContainer Orientation="Vertical"
+                  HorizontalExpand="True"
+                  VerticalExpand="True"
+                  Margin="5 0 5 0">
+        <Control MinHeight="10"/>
+        <BoxContainer Orientation="Vertical" SeparationOverride="4" MinWidth="150">
+            <Label Name="CurrentTextFrequency" Text="{Loc 'handheld-radio-current-text-frequency'}" />
+            <LineEdit Name="FrequencyLineEdit" />
+        </BoxContainer>
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True" HorizontalAlignment="Right" Margin="5 0 5 5">
+            <Button Name="MicButton" ToggleMode="True" Text="{Loc 'handheld-radio-button-text-mic'}" StyleClasses="OpenRight" MinWidth="70"/>
+            <Button Name="SpeakerButton" ToggleMode="True" Text="{Loc 'handheld-radio-button-text-speaker'}" StyleClasses="OpenLeft" MinWidth="70"/>
+        </BoxContainer>
+        <BoxContainer Orientation="Vertical">
+            <PanelContainer StyleClasses="LowDivider" />
+            <BoxContainer Orientation="Horizontal" Margin="10 2 5 0" VerticalAlignment="Bottom">
+                <Label Text="{Loc 'handheld-radio-flavor-text-left'}" StyleClasses="WindowFooterText"
+                       HorizontalAlignment="Left" HorizontalExpand="True"  Margin="0 0 5 0" />
+                <TextureRect StyleClasses="NTLogoDark" Stretch="KeepAspectCentered"
+                             VerticalAlignment="Center" HorizontalAlignment="Right" SetSize="19 19"/>
+            </BoxContainer>
+        </BoxContainer>
+    </BoxContainer>
+</controls:FancyWindow>

Content.Client/_NC/Radio/UI/HandheldRadioMenu.xaml.cs

@@ -0,0 +1,35 @@
+using Content.Client.UserInterface.Controls;
+using Content.Shared._NC.Radio;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client._NC.Radio.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class HandheldRadioMenu : FancyWindow
+{
+
+    public event Action<bool>? OnMicPressed;
+    public event Action<bool>? OnSpeakerPressed;
+    public event Action<string>? OnFrequencyChanged;
+
+    public HandheldRadioMenu()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+
+        MicButton.OnPressed += args => OnMicPressed?.Invoke(args.Button.Pressed);
+        SpeakerButton.OnPressed += args => OnSpeakerPressed?.Invoke(args.Button.Pressed);
+
+        FrequencyLineEdit.OnTextEntered += e => OnFrequencyChanged?.Invoke(e.Text);
+        FrequencyLineEdit.OnFocusExit += e => OnFrequencyChanged?.Invoke(e.Text);
+    }
+
+    public void Update(HandheldRadioBoundUIState state)
+    {
+        MicButton.Pressed = state.MicEnabled;
+        SpeakerButton.Pressed = state.SpeakerEnabled;
+        FrequencyLineEdit.Text = state.Frequency.ToString();
+    }
+}

Content.Server/Radio/Components/RadioMicrophoneComponent.cs

@@ -40,4 +40,11 @@ public sealed partial class RadioMicrophoneComponent : Component
     /// </summary>
     [DataField("unobstructedRequired")]
     public bool UnobstructedRequired = false;
+
+    // Nuclear-14
+    /// <summary>
+    // The radio frequency on which the message will be transmitted
+    /// </summary>
+    [DataField]
+    public int Frequency = 1459; // Common channel frequency
 }

Content.Server/Radio/EntitySystems/RadioDeviceSystem.cs

@@ -11,6 +11,9 @@
 using Content.Shared.Interaction;
 using Content.Shared.Radio;
 using Content.Shared.Radio.Components;
+using Content.Shared.UserInterface; // Nuclear-14
+using Content.Shared._NC.Radio; // Nuclear-14
+using Robust.Server.GameObjects; // Nuclear-14
 using Robust.Shared.Prototypes;
 
 namespace Content.Server.Radio.EntitySystems;
@@ -26,10 +29,15 @@ public sealed class RadioDeviceSystem : EntitySystem
     [Dependency] private readonly RadioSystem _radio = default!;
     [Dependency] private readonly InteractionSystem _interaction = default!;
     [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+    [Dependency] private readonly UserInterfaceSystem _ui = default!;
 
     // Used to prevent a shitter from using a bunch of radios to spam chat.
     private HashSet<(string, EntityUid)> _recentlySent = new();
 
+    // Frontier: minimum, maximum radio frequencies
+    private const int MinRadioFrequency = 1000;
+    private const int MaxRadioFrequency = 3000;
+
     public override void Initialize()
     {
         base.Initialize();
@@ -49,6 +57,13 @@ public override void Initialize()
         SubscribeLocalEvent<IntercomComponent, ToggleIntercomSpeakerMessage>(OnToggleIntercomSpeaker);
         SubscribeLocalEvent<IntercomComponent, SelectIntercomChannelMessage>(OnSelectIntercomChannel);
 
+        // Nuclear-14-Start
+        SubscribeLocalEvent<RadioMicrophoneComponent, BeforeActivatableUIOpenEvent>(OnBeforeHandheldRadioUiOpen);
+        SubscribeLocalEvent<RadioMicrophoneComponent, ToggleHandheldRadioMicMessage>(OnToggleHandheldRadioMic);
+        SubscribeLocalEvent<RadioMicrophoneComponent, ToggleHandheldRadioSpeakerMessage>(OnToggleHandheldRadioSpeaker);
+        SubscribeLocalEvent<RadioMicrophoneComponent, SelectHandheldRadioFrequencyMessage>(OnChangeHandheldRadioFrequency);
+        // Nuclear-14-End
+
         SubscribeLocalEvent<IntercomComponent, MapInitEvent>(OnMapInit); // Frontier
     }
 
@@ -180,7 +195,7 @@ private void OnExamine(EntityUid uid, RadioMicrophoneComponent component, Examin
 
         using (args.PushGroup(nameof(RadioMicrophoneComponent)))
         {
-            args.PushMarkup(Loc.GetString("handheld-radio-component-on-examine", ("frequency", proto.Frequency)));
+            args.PushMarkup(Loc.GetString("handheld-radio-component-on-examine", ("frequency", /*Nuclear-14-start*/ component.Frequency /*Nuclear-14-end*/)));
             args.PushMarkup(Loc.GetString("handheld-radio-component-chennel-examine",
                 ("channel", proto.LocalizedName)));
         }
@@ -192,7 +207,7 @@ private void OnListen(EntityUid uid, RadioMicrophoneComponent component, ListenE
             return; // no feedback loops please.
 
         if (_recentlySent.Add((args.Message, args.Source)))
-            _radio.SendRadioMessage(args.Source, args.Message, _protoMan.Index<RadioChannelPrototype>(component.BroadcastChannel), uid);
+            _radio.SendRadioMessage(args.Source, args.Message, _protoMan.Index<RadioChannelPrototype>(component.BroadcastChannel), uid, /*Nuclear-14-start*/ frequency: component.Frequency /*Nuclear-14-end*/);
     }
 
     private void OnAttemptListen(EntityUid uid, RadioMicrophoneComponent component, ListenAttemptEvent args)
@@ -256,7 +271,7 @@ private void OnSelectIntercomChannel(Entity<IntercomComponent> ent, ref SelectIn
         if (ent.Comp.RequiresPower && !this.IsPowered(ent, EntityManager))
             return;
 
-        if (!_protoMan.HasIndex<RadioChannelPrototype>(args.Channel) || !ent.Comp.SupportedChannels.Contains(args.Channel))
+        if (!_protoMan.TryIndex<RadioChannelPrototype>(args.Channel, out var channel) || !ent.Comp.SupportedChannels.Contains(args.Channel)) // Nuclear-14: add channel
             return;
 
         SetIntercomChannel(ent, args.Channel);
@@ -277,14 +292,79 @@ private void SetIntercomChannel(Entity<IntercomComponent> ent, ProtoId<RadioChan
         }
 
         if (TryComp<RadioMicrophoneComponent>(ent, out var mic))
+        {
             mic.BroadcastChannel = channel;
+            if(_protoMan.TryIndex<RadioChannelPrototype>(channel, out var channelProto)) // Frontier
+                mic.Frequency = _radio.GetFrequency(ent, channelProto); // Frontier
+        }
         if (TryComp<RadioSpeakerComponent>(ent, out var speaker))
             speaker.Channels = new(){ channel };
         Dirty(ent);
     }
 
-    private void OnMapInit(EntityUid uid, IntercomComponent ent, MapInitEvent args) // Frontier - Init on map
+    // Nuclear-14-Start
+    #region Handheld Radio
+
+    private void OnBeforeHandheldRadioUiOpen(Entity<RadioMicrophoneComponent> microphone, ref BeforeActivatableUIOpenEvent args)
+    {
+        UpdateHandheldRadioUi(microphone);
+    }
+
+    private void OnToggleHandheldRadioMic(Entity<RadioMicrophoneComponent> microphone, ref ToggleHandheldRadioMicMessage args)
+    {
+        if (!args.Actor.Valid)
+            return;
+
+        SetMicrophoneEnabled(microphone, args.Actor, args.Enabled, true);
+        UpdateHandheldRadioUi(microphone);
+    }
+
+    private void OnToggleHandheldRadioSpeaker(Entity<RadioMicrophoneComponent> microphone, ref ToggleHandheldRadioSpeakerMessage args)
+    {
+        if (!args.Actor.Valid)
+            return;
+
+        SetSpeakerEnabled(microphone, args.Actor, args.Enabled, true);
+        UpdateHandheldRadioUi(microphone);
+    }
+
+    private void OnChangeHandheldRadioFrequency(Entity<RadioMicrophoneComponent> microphone, ref SelectHandheldRadioFrequencyMessage args)
+    {
+        if (!args.Actor.Valid)
+            return;
+
+        // Update frequency if valid and within range.
+        if (args.Frequency >= MinRadioFrequency && args.Frequency <= MaxRadioFrequency)
+            microphone.Comp.Frequency = args.Frequency;
+        // Update UI with current frequency.
+        UpdateHandheldRadioUi(microphone);
+    }
+
+    private void UpdateHandheldRadioUi(Entity<RadioMicrophoneComponent> radio)
     {
+        var speakerComp = CompOrNull<RadioSpeakerComponent>(radio);
+        var frequency = radio.Comp.Frequency;
+
+        var micEnabled = radio.Comp.Enabled;
+        var speakerEnabled = speakerComp?.Enabled ?? false;
+        var state = new HandheldRadioBoundUIState(micEnabled, speakerEnabled, frequency);
+        if (TryComp<UserInterfaceComponent>(radio, out var uiComp))
+            _ui.SetUiState((radio.Owner, uiComp), HandheldRadioUiKey.Key, state); // Frontier: TrySetUiState<SetUiState
+    }
+
+    #endregion
+    // Nuclear-14-End
+
+    // Frontier: init intercom with map
+    private void OnMapInit(EntityUid uid, IntercomComponent ent, MapInitEvent args)
+    {
+        // Set initial frequency (must be done regardless of power/enabled)
+        if (ent.CurrentChannel != null &&
+                _protoMan.TryIndex(ent.CurrentChannel, out var channel) &&
+                TryComp(uid, out RadioMicrophoneComponent? mic))
+        {
+            mic.Frequency = channel.Frequency;
+        }
         if (ent.StartSpeakerOnMapInit)
         {
             SetSpeakerEnabled(uid, null, true);
@@ -298,4 +378,5 @@ private void OnMapInit(EntityUid uid, IntercomComponent ent, MapInitEvent args)
             _appearance.SetData(uid, RadioDeviceVisuals.Broadcasting, true);
         }
     }
+    // End Frontier
 }

Content.Server/Radio/EntitySystems/RadioSystem.cs

@@ -10,6 +10,7 @@
 using Content.Shared.Radio.Components;
 using Robust.Server.GameObjects;
 using Content.Shared.Speech;
+using Content.Shared.Ghost; // Nuclear-14
 using Robust.Shared.Map;
 using Robust.Shared.Network;
 using Robust.Shared.Player;
@@ -56,6 +57,18 @@ private void OnIntrinsicSpeak(EntityUid uid, IntrinsicRadioTransmitterComponent
         }
     }
 
+    //Nuclear-14
+    /// <summary>
+    /// Gets the message frequency, if there is no such frequency, returns the standard channel frequency.
+    /// </summary>
+    public int GetFrequency(EntityUid source, RadioChannelPrototype channel)
+    {
+        if (TryComp<RadioMicrophoneComponent>(source, out var radioMicrophone))
+            return radioMicrophone.Frequency;
+
+        return channel.Frequency;
+    }
+
     private void OnIntrinsicReceive(EntityUid uid, IntrinsicRadioReceiverComponent component, ref RadioReceiveEvent args)
     {
         if (TryComp(uid, out ActorComponent? actor))
@@ -65,17 +78,17 @@ private void OnIntrinsicReceive(EntityUid uid, IntrinsicRadioReceiverComponent c
     /// <summary>
     /// Send radio message to all active radio listeners
     /// </summary>
-    public void SendRadioMessage(EntityUid messageSource, string message, ProtoId<RadioChannelPrototype> channel, EntityUid radioSource, bool escapeMarkup = true)
+    public void SendRadioMessage(EntityUid messageSource, string message, ProtoId<RadioChannelPrototype> channel, EntityUid radioSource, int? frequency = null, bool escapeMarkup = true) // Frontier: added frequency
     {
-        SendRadioMessage(messageSource, message, _prototype.Index(channel), radioSource, escapeMarkup: escapeMarkup);
+        SendRadioMessage(messageSource, message, _prototype.Index(channel), radioSource, frequency: frequency, escapeMarkup: escapeMarkup); // Frontier: added frequency
     }
 
     /// <summary>
     /// Send radio message to all active radio listeners
     /// </summary>
     /// <param name="messageSource">Entity that spoke the message</param>
     /// <param name="radioSource">Entity that picked up the message and will send it, e.g. headset</param>
-    public void SendRadioMessage(EntityUid messageSource, string message, RadioChannelPrototype channel, EntityUid radioSource, bool escapeMarkup = true)
+    public void SendRadioMessage(EntityUid messageSource, string message, RadioChannelPrototype channel, EntityUid radioSource, int? frequency = null, bool escapeMarkup = true) // Nuclear-14: add frequency
     {
         // TODO if radios ever garble / modify messages, feedback-prevention needs to be handled better than this.
         if (!_messages.Add(message))
@@ -127,12 +140,20 @@ public void SendRadioMessage(EntityUid messageSource, string message, RadioChann
             ? FormattedMessage.EscapeText(message)
             : message;
 
+        // Frontier: append frequency if the channel requests it
+        string channelText;
+        if (channel.ShowFrequency)
+            channelText = $"\\[{channel.LocalizedName} ({frequency})\\]";
+        else
+            channelText = $"\\[{channel.LocalizedName}\\]";
+        // End Frontier
+
         var wrappedMessage = Loc.GetString(speech.Bold ? "chat-radio-message-wrap-bold" : "chat-radio-message-wrap",
             ("color", channel.Color),
             ("fontType", speech.FontId),
             ("fontSize", speech.FontSize),
             ("verb", Loc.GetString(_random.Pick(speech.SpeechVerbStrings))),
-            ("channel", $"\\[{channel.LocalizedName}\\]"),
+            ("channel", channelText), // Frontier: $"\\[{channel.LocalizedName}\\]"<channelText
             ("name", name),
             ("message", content));
 
@@ -156,6 +177,10 @@ public void SendRadioMessage(EntityUid messageSource, string message, RadioChann
         var sourceServerExempt = _exemptQuery.HasComp(radioSource);
 
         var radioQuery = EntityQueryEnumerator<ActiveRadioComponent, TransformComponent>();
+
+        if (frequency == null) // Nuclear-14
+            frequency = GetFrequency(messageSource, channel); // Nuclear-14
+
         while (canSend && radioQuery.MoveNext(out var receiver, out var radio, out var transform))
         {
             if (!radio.ReceiveAllChannels)
@@ -165,6 +190,9 @@ public void SendRadioMessage(EntityUid messageSource, string message, RadioChann
                     continue;
             }
 
+            if (!HasComp<GhostComponent>(receiver) && GetFrequency(receiver, channel) != frequency) // Nuclear-14
+                continue; // Nuclear-14
+
             if (!channel.LongRange && transform.MapID != sourceMapId && !radio.GlobalReceive)
                 continue;
 

Content.Shared/Radio/RadioChannelPrototype.cs

@@ -35,4 +35,12 @@ public sealed partial class RadioChannelPrototype : IPrototype
     /// </summary>
     [DataField("longRange"), ViewVariables]
     public bool LongRange = false;
+
+    // Frontier: radio channel frequencies
+    /// <summary>
+    /// If true, the frequency of the message being sent will be appended to the chat message
+    /// </summary>
+    [DataField, ViewVariables]
+    public bool ShowFrequency = false;
+    // End Frontier
 }