Radio Host Job and Equipment (#5288)

## Short description
<!-- What do you propose to change with your PR? -->
Mirror of my [Moffstation
PR](moff-station/moff-station-14#1471) porting
Goobstation's Radio Host job and equipment. Since the code originates
from Goobstation which is an AGPL licensed work, it is required to be
relicensed to MIT. You can see screenshots of messages from JohnJohn,
Rouden, loltart and H20we (jvne) giving MIT approval in the above link.
Each have contributed majorly or in part to the ported code and thus
each were reached out for approval which was received.

This adds Station Radio equipment consisting of...
 - Station Radio Server
 - Station Radio Rig
 - Vinyl Player
 - Tape Deck
 - Station Radio Receivers

These machines will need to eventually be incorporated into mapping
along with Job spawn markers for the Radio Host. Station Radio Server,
Rig, Vinyl Player and the Tape deck should ideally be mapped in a closed
secure room to avoid access from random persons.

A new access was added called "Journalism" which is intended for the
Radio Host and Reporter. Locking other service workers from accessing
the equipment.

Appropriate Journalist Access Doors have been added for mapping.

Station Radio Receivers will need to be placed around stations and on
some shuttles like the Cargo Shuttle.

A new research is added for creating circuit boards for the Server, Rig,
Vinyl player and Tape Deck. The Station Radio Receiver board can be
created straight from the autolathe with no research required.

A large selection of songs and ads have been added. These can be
inserted into Vinyl Players to play said audio tracks.

Vinyls and CDs have a chance to spawn in Maintenance. You can also
purchase a crate of Vinyls or ADs through cargo.

Syndicate Agents can purchase a new Disruptive CD called Numbers. Which
when inserted into a Vinyl player and broadcasted across station, it
will summon a random threat upon completion. The Vinyl player must be
connected to a Station Rig which must also be connected to a server in
order for the CD to work.

Nukies can find a collection of joke CDs from their uplinks.

## Current Issues
~~I am having issues with getting Journalist access to appear in ID
computers.~~
No way to test to see how TTS will work with this. If they broadcast
over the radio or not.
~~Unsure if there are enough mapping assets included (doors, etc). I
don't know mapping so I don't know what else might be required.~~
~~Whatever the rabbit thinks of the code.~~


## Why we need to add this
<!-- What is the reason for adding these changes? Please post links to
Discussions as well as Bug Reports here. Please describe how this will
change the game balance. -->
The Radio Host is a person whose whole purpose is to maintain and run
the Station's radio. Playing songs, advertisements as well as hosting
interviews live on air.
A fun service role which adds variety to the game. Plus more things to
do on high pop.

## Test plan
<!--
Describe how you tested the pull request, and how someone reviewing this
PR can test it themselves.
-->
Load Branch
Add Testing YAML from below.

### Testing Radio Host Equipment

1. Spawn in CrateRadioHostFIlled.
2. Activate all 4 flat packs.
3. Link the Vinyl Player to the Station Radio Rig, and the Station Radio
Rig to the Station Radio Server.
4. Spawn in CrateRadioHostVinyls and CrateRadioHostADs.
5. Open and observe random selection of Vinyls and CDs.
6. Spawn StationRadioReceiver away from the Vinyl Player.
7. Insert a Vinyl or CD into the Vinyl player.
8. Listen to Music/AD.
9. Walk to the StationRadioReceiver and here same Music/AD playing.
10. Press E on StationRadioReceiver to turn on and off.
11. Alt Click StationRadioReceiver to turn volume down/up.
12. Right Click StationRadioReceiver and select to Lower or Increase
Volume.
13. Unanchor/Mess with power to StationRadioReceiver.
14. Load a second game client.
15. Position the second client in another room with a
StationRadioReceiver.
16. On the first client, spawn a tape recorder and record you saying
some things.
17. Rewind tape and insert it into your Tape Deck.
18. Turn on the station Radio Server by pressing E on it.
19. Say words, and observe them be transmitted through the radio on the
second client.
20. Turn the radio receiver volume down, and observe the sounds coming
through as whispers.
21. Play the tape on the Tape Deck, and observe it playing through the
station.

### Testing Acquiring Radio Host Gear

1. Traverse through the R&D portal on Dev Map.
2. Check the Autolathe and see Station Radio Machine Board available for
printing.
3. Insert the Debug Research Disk into the Research Server
4. Research the Civilian Tree until Radio Music Communications appears.
5. Spawn a Circuit Imprinter and observer no Radio Host Equipment
Available.
6. Unlock Radio Music Communications.
7. Observe Radio Host Gear now an option.
8. Print and build all pieces of Radio Equipment. Radio Receiver, Tape
Deck, Vinyl Player, Radio Rig and Radio Server.
9. Observe construction graphs working.
10. Spawn in Cargo Request Computer.
11. Observe Vinyls Crate and ADs Crate as purchase options.
12. Spawn a Cargo Telepad and link to the Cargo Request Computer.
13. Spawn in some spesos and add to Cargo Request Computer.
14. Purchase a vinyls and ads crate.
20. Open crates and observe random selection of Vinyls.

### Testing Numbers CD calling in Threat.
1. Spawn in a Vinyl Player.
2. Spawn in CDNumbers.
3. Attempt to insert CD and see it fail to play.
4. Spawn in a Radio Rig and Radio Server.
5. Link three machines together.
6. Insert Numbers CD and observe it playing.
7. Eject the Numbers CD, and spawn in CDNumbersQuickAdmin (CD: Nmbrz)
8. Insert and wait 15 seconds for CD to finish playing.
9. Observe a threat is called via Central Command Announcement and the
CD is destroyed after completion.

### Threat Table Chances for Numbers CD
```
Threat Chances
20% Major Threat
  - 8% Lone Op
  - 6% Dragon
  - 4% Colossus
  - 2% Wizard
60% Moderate Threat
  - 18% Ninja
  - 16% Eeplet
  - 12% Rod (8% fast Rod, 4% slow Rod)
  - 10% Revenant
  - 4% Pirate
20% Minor Threat
  - 8% Clown Trio
  - 12% Dead Drop
```

## Media (Video/Screenshots)
<!-- Attach media if the PR makes in-game changes (clothing, items,
features, etc). -->
**FULL DEMONSTATION HERE**
https://youtu.be/4D5zqJWV-IY

<img width="1024" height="514" alt="image"
src="https://github.com/user-attachments/assets/c04ed5a3-dee1-4723-adfd-79dd307150f4"
/>


<img width="775" height="618" alt="image"
src="https://github.com/user-attachments/assets/a106cb94-afe8-4898-b924-3908b410986f"
/>
<img width="488" height="224" alt="image"
src="https://github.com/user-attachments/assets/a1c1f6e9-0a35-42a9-8945-68528a563b6c"
/>

## Checks
<!-- check boxes for faster reviewing of your PR -->

- [X] I do not require assistance to complete the PR.
- [X] Before posting/requesting review of a PR, I have verified that the
changes work.
- [X] I have added screenshots/videos of the changes, or this PR does
not change in-game mechanics.
- [X] I affirm that my changes are licensed under the [MIT
License](https://github.com/ss14Starlight/space-station-14/blob/Starlight/LICENSE.TXT)
and grant permission for use in this repository under its conditions.

**Changelog**
:cl: JohnJJohn, Rouden, H20we, loltart

- add: Radio Host equipment has found it's way into the sector.
- add: Syndicate agents can find illegal CDs in their uplinks.

Author: Huaqas

Content.Server/Radio/EntitySystems/RadioDeviceSystem.cs

@@ -13,6 +13,7 @@
 using Content.Shared.Speech;
 using Content.Shared.Speech.Components;
 using Robust.Shared.Prototypes;
+using Content.Shared.Power.EntitySystems; // Goobstation - Radio Host
 
 #region Starlight
 using Content.Server._Starlight.Language;
@@ -32,6 +33,8 @@ public sealed partial class RadioDeviceSystem : SharedRadioDeviceSystem
     [Dependency] private InteractionSystem _interaction = default!;
     [Dependency] private SharedAppearanceSystem _appearance = default!;
 
+    [Dependency] private SharedPowerReceiverSystem _power = default!; // Goobstation - Radio Host
+
     // Used to prevent a shitter from using a bunch of radios to spam chat.
     private HashSet<(string, EntityUid, string)> _recentlySent = new(); // Starlight edit
 
@@ -192,7 +195,7 @@ private void OnAttemptListen(EntityUid uid, RadioMicrophoneComponent component,
 
     private void OnReceiveRadio(EntityUid uid, RadioSpeakerComponent component, ref RadioReceiveEvent args)
     {
-        if (uid == args.RadioSource)
+        if (uid == args.RadioSource || component.PowerRequired && !_power.IsPowered(uid)) // Goobstation - Radio Host - Powered required
             return;
 
         var nameEv = new TransformSpeakerNameEvent(args.MessageSource, Name(args.MessageSource));
@@ -204,8 +207,9 @@ private void OnReceiveRadio(EntityUid uid, RadioSpeakerComponent component, ref
 
         // log to chat so people can identity the speaker/source, but avoid clogging ghost chat if there are many radios
         var message = args.OriginalChatMsg.Message; // Starlight-edit: The chat system will handle the rest and re-obfuscate if needed.
-        _chat.TrySendInGameICMessage(uid, message, InGameICChatType.Whisper, ChatTransmitRange.GhostRangeLimit,
-            nameOverride: name, checkRadioPrefix: false, languageOverride: args.Language); // Starlight
+        _chat.TrySendInGameICMessage(uid, message, InGameICChatType.Whisper, ChatTransmitRange.GhostRangeLimit, nameOverride: name,
+            checkRadioPrefix: component.ParseRadioPrefix, // Starlight - Radio Host, change LouderSpeech to ParseRadioPrefix
+            languageOverride: args.Language); // Starlight
     }
 
     private void OnIntercomEncryptionChannelsChanged(Entity<IntercomComponent> ent, ref EncryptionChannelsChangedEvent args)

Content.Server/_Goobstation/StationRadio/VinylSummonRuleSystem.cs

@@ -0,0 +1,230 @@
+using Content.Shared._Goobstation.StationRadio.Components; // Starlight - _Goob -> _Goobstation
+using Content.Shared._Goobstation.StationRadio.Events; // Starlight - _Goob -> _Goobstation
+using Content.Server.GameTicking;
+using Content.Server.Station.Systems;
+using Content.Shared.Communications;
+using Content.Shared.Containers.ItemSlots;
+using Content.Shared.Popups;
+using Content.Shared.Power.EntitySystems;
+using Content.Shared.Random;
+using Content.Shared.Random.Helpers;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Containers;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using Robust.Shared.Timing;
+using System.Linq;
+using Content.Shared.Radio.Components;
+using Content.Server.Chat.Systems;
+using Content.Shared._Goobstation.StationRadio.Systems; // Starlight - Station Radio Check oved to StationRadioReceiverSystem
+
+namespace Content.Server._Goobstation.StationRadio; // Starlight - _Goob -> _Goobstation
+
+/// <summary>
+/// System that handles spawning game rules when vinyl disks finish playing.
+/// </summary>
+public sealed partial class VinylSummonRuleSystem : EntitySystem
+{
+    [Dependency] private IGameTiming _timing = default!;
+    [Dependency] private SharedAudioSystem _audio = default!;
+    [Dependency] private GameTicker _gameTicker = default!;
+    [Dependency] private SharedContainerSystem _containers = default!;
+    [Dependency] private IPrototypeManager _prototypeManager = default!;
+    [Dependency] private IRobustRandom _random = default!;
+    [Dependency] private StationSystem _stationSystem = default!;
+    [Dependency] private SharedPowerReceiverSystem _power = default!;
+    [Dependency] private ItemSlotsSystem _itemSlots = default!;
+    [Dependency] private SharedPopupSystem _popups = default!;
+    [Dependency] private ChatSystem _chat = default!;
+    [Dependency] private readonly StationRadioReceiverSystem _stationRadio = default!; // Starlight - Station Radio Check oved to StationRadioReceiverSystem
+
+    private record struct TrackingData(EntityUid VinylPlayerUid, TimeSpan EndTime);
+    private readonly Dictionary<EntityUid, TrackingData> _trackingVinyls = new();
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<VinylPlayerComponent, VinylInsertedEvent>(OnVinylInserted);
+        SubscribeLocalEvent<VinylPlayerComponent, VinylRemovedEvent>(OnVinylRemoved);
+    }
+
+    private void OnVinylInserted(EntityUid uid, VinylPlayerComponent player, ref VinylInsertedEvent args)
+    {
+        var playerUid = uid;
+        var vinylUid = args.Vinyl;
+
+        // Check if the inserted entity has the summon rule component / A song
+        if (!TryComp<VinylSummonRuleComponent>(vinylUid, out _)
+            || !TryComp<VinylComponent>(vinylUid, out var vinylComp)
+            || vinylComp.Song == null)
+            return;
+
+        void QueueSafeEject()
+        {
+            Timer.Spawn(0, () => EjectVinyl(playerUid, vinylUid));
+        }
+
+        // Check if vinyl player is on a station
+        if (_stationSystem.GetOwningStation(playerUid) == null)
+        {
+            _popups.PopupPredicted(Loc.GetString("vinyl-popout-no-station"), playerUid, null, PopupType.Medium);
+            QueueSafeEject();
+            return;
+        }
+
+        // Check if vinyl player is powered
+        if (!_power.IsPowered(playerUid))
+        {
+            _popups.PopupPredicted(Loc.GetString("vinyl-popout-no-power"), playerUid, null, PopupType.Medium);
+            QueueSafeEject();
+            return;
+        }
+
+        // Check if vinyl player is connected to the radio system
+        if (!_stationRadio.TryGetLinkedPoweredServer(playerUid, out _)) // Starlight - Station Radio Check oved to StationRadioReceiverSystem
+        {
+            _popups.PopupPredicted(Loc.GetString("vinyl-popout-no-radio-connection"), playerUid, null, PopupType.Medium);
+            QueueSafeEject();
+            return;
+        }
+
+        // Get the audio length
+        var resolved = _audio.ResolveSound(vinylComp.Song);
+        var audioLength = _audio.GetAudioLength(resolved);
+        var endTime = _timing.CurTime + audioLength;
+
+        // Track this vinyl with its player
+        _trackingVinyls[vinylUid] = new TrackingData(playerUid, endTime);
+    }
+
+    private void OnVinylRemoved(EntityUid uid, VinylPlayerComponent player, ref VinylRemovedEvent args)
+    {
+        // Stop tracking if the vinyl is removed
+        _trackingVinyls.Remove(args.Vinyl);
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var currentTime = _timing.CurTime;
+
+        foreach (var (vinylUid, data) in _trackingVinyls.ToList())
+        {
+            // Check if the vinyl still exists
+            if (!Exists(vinylUid)
+                || !Exists(data.VinylPlayerUid))
+            {
+                _trackingVinyls.Remove(vinylUid);
+                continue;
+            }
+
+            // Check if vinyl player is still on a station
+            if (_stationSystem.GetOwningStation(data.VinylPlayerUid) == null)
+            {
+                _trackingVinyls.Remove(vinylUid);
+                _popups.PopupPredicted(Loc.GetString("vinyl-popout-no-station"), data.VinylPlayerUid, null, PopupType.Medium);
+                EjectVinyl(data.VinylPlayerUid, vinylUid);
+                continue;
+            }
+
+            // Check if vinyl player is still powered
+            if (!_power.IsPowered(data.VinylPlayerUid))
+            {
+                _trackingVinyls.Remove(vinylUid);
+                _popups.PopupPredicted(Loc.GetString("vinyl-popout-no-power"), data.VinylPlayerUid, null, PopupType.Medium);
+                EjectVinyl(data.VinylPlayerUid, vinylUid);
+                continue;
+            }
+
+            // Check if vinyl player is still connected to the radio system
+            if (!_stationRadio.TryGetLinkedPoweredServer(data.VinylPlayerUid, out _)) // Starlight - Station Radio Check oved to StationRadioReceiverSystem
+            {
+                _trackingVinyls.Remove(vinylUid);
+                _popups.PopupPredicted(Loc.GetString("vinyl-popout-no-radio-connection"), data.VinylPlayerUid, null, PopupType.Medium);
+                EjectVinyl(data.VinylPlayerUid, vinylUid);
+                continue;
+            }
+
+            // Check if playback has finished
+            if (currentTime >= data.EndTime)
+            {
+                HandleVinylFinished(vinylUid);
+                _trackingVinyls.Remove(vinylUid);
+            }
+        }
+    }
+
+    private void EjectVinyl(EntityUid playerUid, EntityUid vinylUid)
+    {
+        if (!Exists(vinylUid)
+            || !Exists(playerUid)
+            || !TryComp<ItemSlotsComponent>(playerUid, out var itemSlots))
+            return;
+
+        // Find the slot containing the vinyl
+        foreach (var (_, slot) in itemSlots.Slots)
+            if (slot.Item == vinylUid)
+            {
+                _itemSlots.TryEject(playerUid, slot, null, out _);
+                return;
+            }
+    }
+
+    private void HandleVinylFinished(EntityUid vinylUid)
+    {
+        if (!TryComp<VinylSummonRuleComponent>(vinylUid, out var summonComp))
+            return;
+
+        // Resolve the game rule ID and get the threat prototype if available
+        var ruleId = ResolveGameRule(summonComp.GameRule, out var threat);
+
+        if (ruleId != null)
+        {
+            _gameTicker.StartGameRule(ruleId, out _);
+
+            // If we have a threat prototype with an announcement, send it
+            if (threat != null)
+                _chat.DispatchGlobalAnnouncement(Loc.GetString(threat.Announcement), playSound: true, colorOverride: Color.Red);
+        }
+
+        var vinylXform = Transform(vinylUid);
+        var vinylCoords = vinylXform.Coordinates;
+
+        // Remove from container
+        if (_containers.TryGetContainingContainer((vinylUid, vinylXform, null), out var container))
+            _containers.Remove(vinylUid, container);
+
+        // Play sound effect
+        _audio.PlayPvs(summonComp.BurnSound, vinylCoords, summonComp.BurnSoundParams);  // Starlight - Dehardcode BurnSoundParams
+
+        // Spawn ash at the vinyl's location
+        Spawn(summonComp.AshPrototype, vinylCoords); // Starlight - Dehardcode ash prototype
+
+        // Delete the vinyl
+        QueueDel(vinylUid);
+    }
+
+    private string? ResolveGameRule(string gameRuleIdentifier, out NinjaHackingThreatPrototype? threat)
+    {
+        threat = null;
+
+        // Check if it's a weighted random pool
+        if (_prototypeManager.TryIndex<WeightedRandomPrototype>(gameRuleIdentifier, out var weightedPool))
+        {
+            // Pick a random threat ID from the weighted pool
+            var threatId = weightedPool.Pick(_random);
+
+            // Look up the threat prototype to get the actual game rule ID
+            if (_prototypeManager.TryIndex<NinjaHackingThreatPrototype>(threatId, out threat))
+                return threat.Rule;
+
+            return null;
+        }
+
+        // Assume it's a direct game rule entity ID
+        return gameRuleIdentifier;
+    }
+}

Content.Shared/Radio/Components/RadioSpeakerComponent.cs

@@ -2,14 +2,15 @@
 using Content.Shared.Chat;
 using Robust.Shared.GameStates;
 using Robust.Shared.Prototypes;
+using Content.Shared._Goobstation.StationRadio.Systems; // Starlight - Radio Host _Goob -> _Goobstation
 
 namespace Content.Shared.Radio.Components;
 
 /// <summary>
 ///     Listens for radio messages and relays them to local chat.
 /// </summary>
 [RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
-[Access(typeof(SharedRadioDeviceSystem))]
+[Access(typeof(SharedRadioDeviceSystem), typeof(StationRadioReceiverSystem))] // Goobstation - Add StationRadioReceiverSystem access.
 public sealed partial class RadioSpeakerComponent : Component
 {
     /// <summary>
@@ -24,4 +25,20 @@ public sealed partial class RadioSpeakerComponent : Component
 
     [DataField, AutoNetworkedField]
     public bool Enabled;
+
+    // Starlight - Radio Host LouderSpeech -> ParseRadioPrefix.
+    /// <summary>
+    /// Whether or not a message is parsed through the radio when when sent in local chat.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public bool ParseRadioPrefix;
+    // Starlight - End
+
+    // Goobstation - Radio Host
+    /// <summary>
+    /// Does the radio need to be on a power grid to work?
+    /// </summary>
+    [DataField]
+    public bool PowerRequired;
+    // Goobstation - End
 }

Content.Shared/_Goobstation/StationRadio/Components/RadioRigComponent.cs

@@ -0,0 +1,6 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._Goobstation.StationRadio.Components; // Starlight - _Goob -> _Goobstation
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class RadioRigComponent : Component;

Content.Shared/_Goobstation/StationRadio/Components/StationRadioReceiverComponent.cs

@@ -0,0 +1,42 @@
+using Robust.Shared.Audio;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._Goobstation.StationRadio.Components; // Starlight - _Goob -> _Goobstation
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class StationRadioReceiverComponent : Component
+{
+    /// <summary>
+    /// The sound entity being played
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public EntityUid? SoundEntity;
+
+    /// <summary>
+    /// Is the radio turned on
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public bool Active = true;
+
+    /// <summary>
+    /// Default audio params for the played audio.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public AudioParams DefaultParams = AudioParams.Default.WithVolume(3.5f).WithMaxDistance(8f); // 8 is just the edge of the screen usually
+
+    // Moffstation - Add Low Volume mode
+    /// <summary>
+    /// Is Radio is playing at full or low volume.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public bool LowVolume;
+    // Moffstation - End
+
+    // Starlight - Dehardcode LowVolume mode's gain.
+    /// <summary>
+    /// How quiet the low volume setting on a Station Radio is. Default is 10%.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public float LowVolumeGain = 0.1f;
+    // Starlight - End
+}

Content.Shared/_Goobstation/StationRadio/Components/StationRadioServerComponent.cs

@@ -0,0 +1,23 @@
+using Robust.Shared.GameStates;
+using Robust.Shared.Audio; // Starlight - Add Station Radio Resume Play
+
+namespace Content.Shared._Goobstation.StationRadio.Components; // Starlight - _Goob -> _Goobstation
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class StationRadioServerComponent : Component
+    // Starlight - Add the ability for Station Radios to resume play.
+{
+    /// <summary>
+    /// The song currently being broadcasted.
+    /// Null if nothing is playing.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public SoundPathSpecifier? CurrentSong;
+
+    /// <summary>
+    /// For determining where the sound should resume.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public TimeSpan? PlaybackStartTime;
+}
+    // Starlight - End

Content.Shared/_Goobstation/StationRadio/Components/VinylComponent.cs

@@ -0,0 +1,13 @@
+using Robust.Shared.Audio;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._Goobstation.StationRadio.Components; // Starlight - _Goob -> _Goobstation
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class VinylComponent : Component
+{
+    /// <summary>
+    /// What song should be played when the vinyl is played
+    /// </summary>
+    [DataField] public SoundPathSpecifier? Song;
+}