--- /dev/null
+using Content.Shared.Radio;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.Set;
+
+namespace Content.Server.GameTicking.Rules.Configurations;
+
+/// <summary>
+/// Solar Flare event specific configuration
+/// </summary>
+public sealed class SolarFlareEventRuleConfiguration : StationEventRuleConfiguration
+{
+ /// <summary>
+ /// In seconds, most early moment event can end
+ /// </summary>
+ [DataField("minEndAfter")]
+ public int MinEndAfter;
+
+ /// <summary>
+ /// In seconds, most late moment event can end
+ /// </summary>
+ [DataField("maxEndAfter")]
+ public int MaxEndAfter;
+
+ /// <summary>
+ /// If true, only headsets affected, but e.g. handheld radio will still work
+ /// </summary>
+ [DataField("onlyJamHeadsets")]
+ public bool OnlyJamHeadsets;
+
+ /// <summary>
+ /// Channels that will be disabled for a duration of event
+ /// </summary>
+ [DataField("affectedChannels", customTypeSerializer: typeof(PrototypeIdHashSetSerializer<RadioChannelPrototype>))]
+ public readonly HashSet<string> AffectedChannels = new();
+
+ /// <summary>
+ /// Chance any given light bulb breaks due to event
+ /// </summary>
+ [DataField("lightBreakChance")]
+ public float LightBreakChance;
+}
\ No newline at end of file
/// game rules.
/// </summary>
[UsedImplicitly]
-public sealed class StationEventRuleConfiguration : GameRuleConfiguration
+public class StationEventRuleConfiguration : GameRuleConfiguration
{
[DataField("id", required: true)]
private string _id = default!;
&& TryComp(component.Headset, out HeadsetComponent? headset)
&& headset.Channels.Contains(args.Channel.ID))
{
- _radio.SendRadioMessage(uid, args.Message, args.Channel);
+ _radio.SendRadioMessage(uid, args.Message, args.Channel, component.Headset);
args.Channel = null; // prevent duplicate messages from other listeners.
}
}
return; // no feedback loops please.
if (_recentlySent.Add((args.Message, args.Source)))
- _radio.SendRadioMessage(args.Source, args.Message, _protoMan.Index<RadioChannelPrototype>(component.BroadcastChannel));
+ _radio.SendRadioMessage(args.Source, args.Message, _protoMan.Index<RadioChannelPrototype>(component.BroadcastChannel), uid);
}
private void OnAttemptListen(EntityUid uid, RadioMicrophoneComponent component, ListenAttemptEvent args)
using Content.Server.Chat.Systems;
using Content.Server.Radio.Components;
using Content.Server.VoiceMask;
+using Content.Server.Popups;
using Content.Shared.Chat;
using Content.Shared.Database;
using Content.Shared.Radio;
using Robust.Shared.Network;
using Robust.Shared.Replays;
using Robust.Shared.Utility;
+using Content.Shared.Popups;
namespace Content.Server.Radio.EntitySystems;
[Dependency] private readonly INetManager _netMan = default!;
[Dependency] private readonly IReplayRecordingManager _replay = default!;
[Dependency] private readonly IAdminLogManager _adminLogger = default!;
+ [Dependency] private readonly PopupSystem _popupSystem = default!;
// set used to prevent radio feedback loops.
private readonly HashSet<string> _messages = new();
_netMan.ServerSendMessage(args.ChatMsg, actor.PlayerSession.ConnectedClient);
}
- public void SendRadioMessage(EntityUid source, string message, RadioChannelPrototype channel)
+ public void SendRadioMessage(EntityUid source, string message, RadioChannelPrototype channel, EntityUid? radioSource = null)
{
// TODO if radios ever garble / modify messages, feedback-prevention needs to be handled better than this.
if (!_messages.Add(message))
EntityUid.Invalid);
var chatMsg = new MsgChatMessage { Message = chat };
- var ev = new RadioReceiveEvent(message, source, channel, chatMsg);
- var attemptEv = new RadioReceiveAttemptEvent(message, source, channel);
+ var ev = new RadioReceiveEvent(message, source, channel, chatMsg, radioSource);
+ var attemptEv = new RadioReceiveAttemptEvent(message, source, channel, radioSource);
+ bool sentAtLeastOnce = false;
foreach (var radio in EntityQuery<ActiveRadioComponent>())
{
attemptEv.Uncancel();
continue;
}
-
+ sentAtLeastOnce = true;
RaiseLocalEvent(radio.Owner, ev);
}
+ if (!sentAtLeastOnce)
+ _popupSystem.PopupEntity(Loc.GetString("failed-to-send-message"), source, PopupType.MediumCaution);
if (name != Name(source))
_adminLogger.Add(LogType.Chat, LogImpact.Low, $"Radio message from {ToPrettyString(source):user} as {name} on {channel.LocalizedName}: {message}");
public readonly EntityUid Source;
public readonly RadioChannelPrototype Channel;
public readonly MsgChatMessage ChatMsg;
+ public readonly EntityUid? RadioSource;
- public RadioReceiveEvent(string message, EntityUid source, RadioChannelPrototype channel, MsgChatMessage chatMsg)
+ public RadioReceiveEvent(string message, EntityUid source, RadioChannelPrototype channel, MsgChatMessage chatMsg, EntityUid? radioSource)
{
Message = message;
Source = source;
Channel = channel;
ChatMsg = chatMsg;
+ RadioSource = radioSource;
}
}
public readonly string Message;
public readonly EntityUid Source;
public readonly RadioChannelPrototype Channel;
+ public readonly EntityUid? RadioSource;
- public RadioReceiveAttemptEvent(string message, EntityUid source, RadioChannelPrototype channel)
+ public RadioReceiveAttemptEvent(string message, EntityUid source, RadioChannelPrototype channel, EntityUid? radioSource)
{
Message = message;
Source = source;
Channel = channel;
+ RadioSource = radioSource;
}
}
--- /dev/null
+using Content.Server.GameTicking.Rules.Configurations;
+using Content.Server.Radio.Components;
+using Content.Server.Radio;
+using Robust.Shared.Random;
+using Content.Server.Light.EntitySystems;
+using Content.Server.Light.Components;
+
+namespace Content.Server.StationEvents.Events;
+
+public sealed class SolarFlare : StationEventSystem
+{
+ [Dependency] private readonly PoweredLightSystem _poweredLight = default!;
+
+ public override string Prototype => "SolarFlare";
+
+ private SolarFlareEventRuleConfiguration _event = default!;
+
+ public override void Initialize()
+ {
+ base.Initialize();
+ SubscribeLocalEvent<ActiveRadioComponent, RadioReceiveAttemptEvent>(OnRadioSendAttempt);
+ }
+
+ public override void Added()
+ {
+ base.Added();
+
+ if (Configuration is not SolarFlareEventRuleConfiguration ev)
+ return;
+
+ _event = ev;
+ _event.EndAfter = RobustRandom.Next(ev.MinEndAfter, ev.MaxEndAfter);
+ }
+
+ public override void Started()
+ {
+ base.Started();
+ MessLights();
+ }
+
+ private void MessLights()
+ {
+ foreach (var comp in EntityQuery<PoweredLightComponent>())
+ {
+ if (RobustRandom.Prob(_event.LightBreakChance))
+ {
+ var uid = comp.Owner;
+ _poweredLight.TryDestroyBulb(uid, comp);
+ }
+ }
+ }
+
+ public override void Update(float frameTime)
+ {
+ base.Update(frameTime);
+
+ if (!RuleStarted)
+ return;
+
+ if (Elapsed > _event.EndAfter)
+ {
+ ForceEndSelf();
+ return;
+ }
+ }
+
+ private void OnRadioSendAttempt(EntityUid uid, ActiveRadioComponent component, RadioReceiveAttemptEvent args)
+ {
+ if (RuleStarted && _event.AffectedChannels.Contains(args.Channel.ID))
+ if (!_event.OnlyJamHeadsets || (HasComp<HeadsetComponent>(uid) || HasComp<HeadsetComponent>(args.RadioSource)))
+ args.Cancel();
+ }
+}
--- /dev/null
+failed-to-send-message = Failed to send message!
--- /dev/null
+station-event-solar-flare-start-announcement = A solar flare has been detected near the station. Some communication channels may not function.
+station-event-solar-flare-end-announcement = The solar flare ended. Communication channels no longer affected.
startAudio:
path: /Audio/Announcements/attention.ogg
+- type: gameRule
+ id: SolarFlare
+ config: !type:SolarFlareEventRuleConfiguration
+ id: SolarFlare
+ weight: 10
+ startAnnouncement: station-event-solar-flare-start-announcement
+ endAnnouncement: station-event-solar-flare-end-announcement
+ startAudio:
+ path: /Audio/Announcements/attention.ogg
+ minEndAfter: 120
+ maxEndAfter: 240
+ onlyJamHeadsets: true
+ affectedChannels:
+ - Common
+ - Service
+ lightBreakChance: 0.05
+
- type: gameRule
id: VentClog
config:
earliestStart: 20
minimumPlayers: 15
weight: 5
- endAfter: 60
+ endAfter: 60
- type: gameRule
id: ZombieOutbreak
projects / space-station-14.git / commitdiff