Created Proximity Detection and Beeper Systems (#23177)

Content.Shared/Beeper/BeeperEvents.cs

@@ -0,0 +1,4 @@
+namespace Content.Shared.Beeper;
+[ByRefEvent]
+public record struct BeepPlayedEvent(bool Muted);
+

Content.Shared/Beeper/Components/BeeperComponent.cs

@@ -0,0 +1,66 @@
+using Content.Shared.Beeper.Systems;
+using Content.Shared.FixedPoint;
+using Content.Shared.ProximityDetection.Systems;
+using Robust.Shared.Audio;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Beeper.Components;
+
+/// <summary>
+/// This is used for an item that beeps based on
+/// proximity to a specified component.
+/// </summary>
+[RegisterComponent, NetworkedComponent, Access(typeof(BeeperSystem)), AutoGenerateComponentState]
+public sealed partial class BeeperComponent : Component
+{
+    /// <summary>
+    /// Whether or not it's on.
+    /// </summary>
+    [DataField("enabled")]
+    public bool Enabled = true;
+
+    /// <summary>
+    /// How much to scale the interval by (< 0 = min, > 1 = max)
+    /// </summary>
+    [DataField("intervalScaling"), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+    public FixedPoint2 IntervalScaling = 0;
+
+    /// <summary>
+    /// The maximum interval between beeps.
+    /// </summary>
+    [DataField("maxBeepInterval"), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+    public TimeSpan MaxBeepInterval = TimeSpan.FromSeconds(1.5f);
+
+    /// <summary>
+    /// The minimum interval between beeps.
+    /// </summary>
+    [DataField("minBeepInterval"), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+    public TimeSpan MinBeepInterval = TimeSpan.FromSeconds(0.25f);
+
+    /// <summary>
+    /// Interval for the next beep
+    /// </summary>
+    [ViewVariables(VVAccess.ReadWrite)]
+    public TimeSpan Interval;
+
+    /// <summary>
+    /// Time when we beeped last
+    /// </summary>
+    [ViewVariables(VVAccess.ReadWrite)]
+    public TimeSpan LastBeepTime;
+
+    [ViewVariables(VVAccess.ReadOnly)]
+    public TimeSpan NextBeep => LastBeepTime == TimeSpan.MaxValue ? TimeSpan.MaxValue : LastBeepTime + Interval;
+
+    /// <summary>
+    /// Is the beep muted
+    /// </summary>
+    [DataField("muted"), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+    public bool IsMuted = false;
+
+    /// <summary>
+    /// The sound played when the locator beeps.
+    /// </summary>
+    [DataField("beepSound"), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+    public SoundSpecifier? BeepSound;
+}

Content.Shared/Beeper/Components/ProximityBeeperComponent.cs

@@ -0,0 +1,8 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Beeper.Components;
+
+[RegisterComponent] //component tag for events. If we add support for component pairs on events then this won't be needed anymore!
+public sealed partial class ProximityBeeperComponent : Component
+{
+}

Content.Shared/Beeper/Systems/BeeperSystem.cs

@@ -0,0 +1,109 @@
+using Content.Shared.Beeper.Components;
+using Content.Shared.FixedPoint;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Network;
+using Robust.Shared.Timing;
+
+namespace Content.Shared.Beeper.Systems;
+
+
+//This handles generic proximity beeper logic
+public sealed class BeeperSystem : EntitySystem
+{
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly INetManager _net = default!;
+
+    public override void Initialize()
+    {
+    }
+
+    public override void Update(float frameTime)
+    {
+        var query = EntityQueryEnumerator<BeeperComponent>();
+        while (query.MoveNext(out var uid, out var beeper))
+        {
+            if (!beeper.Enabled)
+                continue;
+            RunUpdate_Internal(uid, beeper);
+        }
+    }
+
+    public void SetEnable(EntityUid owner, bool isEnabled, BeeperComponent? beeper = null)
+    {
+        if (!Resolve(owner, ref beeper) || beeper.Enabled == isEnabled)
+            return;
+        beeper.Enabled = isEnabled;
+
+        RunUpdate_Internal(owner, beeper);
+        Dirty(owner, beeper);
+    }
+
+    public void SetIntervalScaling(EntityUid owner, BeeperComponent beeper, FixedPoint2 newScaling)
+    {
+        newScaling = FixedPoint2.Clamp(newScaling, 0, 1);
+        beeper.IntervalScaling = newScaling;
+        RunUpdate_Internal(owner, beeper);
+        Dirty(owner, beeper);
+    }
+
+    public void SetInterval(EntityUid owner, BeeperComponent beeper, TimeSpan newInterval)
+    {
+        if (newInterval < beeper.MinBeepInterval)
+            newInterval = beeper.MinBeepInterval;
+        if (newInterval > beeper.MaxBeepInterval)
+            newInterval = beeper.MaxBeepInterval;
+        beeper.Interval = newInterval;
+        RunUpdate_Internal(owner, beeper);
+        Dirty(owner, beeper);
+    }
+
+    public void SetIntervalScaling(EntityUid owner, FixedPoint2 newScaling, BeeperComponent? beeper = null)
+    {
+        if (!Resolve(owner, ref beeper))
+            return;
+        SetIntervalScaling(owner, beeper, newScaling);
+    }
+
+    public void SetMute(EntityUid owner, bool isMuted, BeeperComponent? comp = null)
+    {
+        if (!Resolve(owner, ref comp))
+            return;
+        comp.IsMuted = isMuted;
+    }
+
+    private void UpdateBeepInterval(EntityUid owner, BeeperComponent beeper)
+    {
+        var scalingFactor = beeper.IntervalScaling.Float();
+        var interval = (beeper.MaxBeepInterval - beeper.MinBeepInterval) * scalingFactor + beeper.MinBeepInterval;
+        if (beeper.Interval == interval)
+            return;
+        beeper.Interval = interval;
+        Dirty(owner, beeper);
+    }
+
+    public void ForceUpdate(EntityUid owner, BeeperComponent? beeper = null)
+    {
+        if (!Resolve(owner, ref beeper))
+            return;
+        RunUpdate_Internal(owner, beeper);
+    }
+
+    private void RunUpdate_Internal(EntityUid owner, BeeperComponent beeper)
+    {
+        if (!beeper.Enabled)
+        {
+            return;
+        }
+        UpdateBeepInterval(owner, beeper);
+        if (beeper.NextBeep >= _timing.CurTime)
+            return;
+        var beepEvent = new BeepPlayedEvent(beeper.IsMuted);
+        RaiseLocalEvent(owner, ref beepEvent);
+        if (!beeper.IsMuted && _net.IsServer)
+        {
+            _audio.PlayPvs(beeper.BeepSound, owner);
+        }
+        beeper.LastBeepTime = _timing.CurTime;
+    }
+}

Content.Shared/Beeper/Systems/ProximityBeeperSystem.cs

@@ -0,0 +1,114 @@
+using Content.Shared.Beeper.Components;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Pinpointer;
+using Content.Shared.PowerCell;
+using Content.Shared.ProximityDetection;
+using Content.Shared.ProximityDetection.Components;
+using Content.Shared.ProximityDetection.Systems;
+
+namespace Content.Shared.Beeper.Systems;
+
+/// <summary>
+/// This handles logic for implementing proximity beeper as a handheld tool />
+/// </summary>
+public sealed class ProximityBeeperSystem : EntitySystem
+{
+    [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+    [Dependency] private readonly SharedPowerCellSystem _powerCell = default!;
+    [Dependency] private readonly ProximityDetectionSystem _proximity = default!;
+    [Dependency] private readonly BeeperSystem _beeper = default!;
+
+    /// <inheritdoc/>
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<ProximityBeeperComponent, UseInHandEvent>(OnUseInHand);
+        SubscribeLocalEvent<ProximityBeeperComponent, PowerCellSlotEmptyEvent>(OnPowerCellSlotEmpty);
+        SubscribeLocalEvent<ProximityBeeperComponent, NewProximityTargetEvent>(OnNewProximityTarget);
+        SubscribeLocalEvent<ProximityBeeperComponent, ProximityTargetUpdatedEvent>(OnProximityTargetUpdate);
+    }
+
+    private void OnProximityTargetUpdate(EntityUid owner, ProximityBeeperComponent proxBeeper, ref ProximityTargetUpdatedEvent args)
+    {
+        if (!TryComp<BeeperComponent>(owner, out var beeper))
+            return;
+        if (args.Target == null)
+        {
+            _beeper.SetEnable(owner, false, beeper);
+            return;
+        }
+        _beeper.SetIntervalScaling(owner,args.Distance/args.Detector.Range, beeper);
+        _beeper.SetEnable(owner, true, beeper);
+    }
+
+    private void OnNewProximityTarget(EntityUid owner, ProximityBeeperComponent proxBeeper, ref NewProximityTargetEvent args)
+    {
+        _beeper.SetEnable(owner, args.Target != null);
+    }
+
+    private void OnUseInHand(EntityUid uid, ProximityBeeperComponent proxBeeper, UseInHandEvent args)
+    {
+        if (args.Handled)
+            return;
+        args.Handled = TryToggle(uid, proxBeeper, user: args.User);
+    }
+
+    private void OnPowerCellSlotEmpty(EntityUid uid, ProximityBeeperComponent beeper, ref PowerCellSlotEmptyEvent args)
+    {
+        if (_proximity.GetEnable(uid))
+            TryDisable(uid);
+    }
+    public bool TryEnable(EntityUid owner, BeeperComponent? beeper = null, ProximityDetectorComponent? detector = null,
+        PowerCellDrawComponent? draw = null,EntityUid? user = null)
+    {
+        if (!Resolve(owner, ref beeper, ref detector))
+            return false;
+        if (Resolve(owner, ref draw, false) && !_powerCell.HasActivatableCharge(owner, battery: draw, user: user))
+                return false;
+        Enable(owner, beeper, detector, draw);
+        return true;
+    }
+    private void Enable(EntityUid owner, BeeperComponent beeper,
+        ProximityDetectorComponent detector, PowerCellDrawComponent? draw)
+    {
+        _proximity.SetEnable(owner, true, detector);
+        _appearance.SetData(owner, ProximityBeeperVisuals.Enabled, true);
+        _powerCell.SetPowerCellDrawEnabled(owner, true, draw);
+    }
+
+
+    /// <summary>
+    /// Disables the proximity beeper
+    /// </summary>
+    public bool TryDisable(EntityUid owner,BeeperComponent? beeper = null, ProximityDetectorComponent? detector = null, PowerCellDrawComponent? draw = null)
+    {
+        if (!Resolve(owner, ref beeper, ref detector))
+            return false;
+
+        if (!detector.Enabled)
+            return false;
+        Disable(owner, beeper, detector, draw);
+        return true;
+    }
+    private void Disable(EntityUid owner, BeeperComponent beeper,
+        ProximityDetectorComponent detector, PowerCellDrawComponent? draw)
+    {
+        _proximity.SetEnable(owner, false, detector);
+        _appearance.SetData(owner, ProximityBeeperVisuals.Enabled, false);
+        _beeper.SetEnable(owner, false, beeper);
+        _powerCell.SetPowerCellDrawEnabled(owner, false, draw);
+    }
+
+    /// <summary>
+    /// toggles the proximity beeper
+    /// </summary>
+    public bool TryToggle(EntityUid owner, ProximityBeeperComponent? proxBeeper = null, BeeperComponent? beeper = null, ProximityDetectorComponent? detector = null,
+        PowerCellDrawComponent? draw = null, EntityUid? user = null)
+    {
+        if (!Resolve(owner,  ref proxBeeper, ref beeper, ref detector))
+            return false;
+
+        return detector.Enabled
+            ? TryDisable(owner, beeper, detector, draw)
+            : TryEnable(owner, beeper, detector, draw,user);
+    }
+}