Refactor: ProximityDetectionSystem (#35133)

* Refactor: ProximityDetectionSystem

* Update

* Update

* Update

* Yikes

* Update

* Dirty

* Update

* Update

* Lil cleanup

* Update

* Update

Content.Shared/Beeper/Systems/ProximityBeeperSystem.cs

@@ -25,14 +25,8 @@ public sealed class ProximityBeeperSystem : EntitySystem
     {
         if (!TryComp<BeeperComponent>(owner, out var beeper))
             return;
-        if (args.Target == null)
-        {
-            _beeper.SetMute(owner, true, beeper);
-            return;
-        }
 
-        _beeper.SetIntervalScaling(owner, args.Distance / args.Detector.Range, beeper);
+        _beeper.SetIntervalScaling(owner, args.Distance / args.Detector.Comp.Range, beeper);
-        _beeper.SetMute(owner, false, beeper);
     }
 
     private void OnNewProximityTarget(EntityUid owner, ProximityBeeperComponent proxBeeper, ref NewProximityTargetEvent args)

Content.Shared/ProximityDetection/Components/ProximityDetectorComponent.cs

@@ -1,43 +1,51 @@
-using Content.Shared.FixedPoint;
+using Content.Shared.ProximityDetection.Systems;
-using Content.Shared.ProximityDetection.Systems;
-using Content.Shared.Whitelist;
 using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
 
 namespace Content.Shared.ProximityDetection.Components;
+
 /// <summary>
-/// This is used to search for the closest entity with a range that matches specified requirements (tags and/or components)
+/// Used to search for the closest entity with a range that matches specified requirements (tags and/or components).
 /// </summary>
-[RegisterComponent, NetworkedComponent, AutoGenerateComponentState ,Access(typeof(ProximityDetectionSystem))]
+[RegisterComponent, NetworkedComponent]
+[AutoGenerateComponentState(fieldDeltas: true), AutoGenerateComponentPause]
+[Access(typeof(ProximityDetectionSystem))]
 public sealed partial class ProximityDetectorComponent : Component
 {
     /// <summary>
-    /// The criteria used to filter entities
+    /// Entities that detector will search for.
-    /// Note: RequireAll is only supported for tags, all components are required to count as a match!
     /// </summary>
-    [DataField( required: true), AutoNetworkedField, ViewVariables(VVAccess.ReadWrite)]
+    [DataField(required: true)]
-    public EntityWhitelist Criteria = new();
+    public ComponentRegistry Components;
 
     /// <summary>
-    /// Found Entity
+    /// The entity that was found.
     /// </summary>
-    [ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+    [ViewVariables, AutoNetworkedField]
-    public EntityUid? TargetEnt;
+    public EntityUid? Target;
 
     /// <summary>
-    /// Distance to Found Entity
+    /// The distance to <see cref="Target"/>.
     /// </summary>
-    [ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+    [ViewVariables, AutoNetworkedField]
-    public FixedPoint2 Distance = -1;
+    public float Distance = float.PositiveInfinity;
 
     /// <summary>
-    /// The farthest distance to search for targets
+    /// The farthest distance to search for targets.
     /// </summary>
-    [DataField, ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+    [DataField, AutoNetworkedField]
-    public FixedPoint2 Range = 10f;
+    public float Range = 10f;
 
-    // TODO: use timespans not this
+    /// <summary>
-    public float AccumulatedFrameTime;
+    /// How often detector updates.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public TimeSpan UpdateCooldown = TimeSpan.FromSeconds(1);
 
-    [DataField, ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+    /// <summary>
-    public float UpdateRate = 0.3f;
+    /// Next time detector updates.
+    /// </summary>
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoNetworkedField, AutoPausedField]
+    public TimeSpan NextUpdate = TimeSpan.Zero;
 }

Content.Shared/ProximityDetection/ProximityDetectionEvents.cs

@@ -1,17 +1,27 @@
-using Content.Shared.FixedPoint;
+using Content.Shared.ProximityDetection.Components;
-using Content.Shared.ProximityDetection.Components;
-using Robust.Shared.Serialization;
 
 namespace Content.Shared.ProximityDetection;
 
+/// <summary>
+/// Raised to determine if proximity sensor can detect an entity.
+/// </summary>
 [ByRefEvent]
-public record struct ProximityDetectionAttemptEvent(bool Cancel, FixedPoint2 Distance, Entity<ProximityDetectorComponent> Detector);
+public struct ProximityDetectionAttemptEvent(float distance, Entity<ProximityDetectorComponent> detector, EntityUid target)
+{
+    public bool Cancelled;
+    public readonly float Distance = distance;
+    public readonly Entity<ProximityDetectorComponent> Detector = detector;
+    public readonly EntityUid Target = target;
+}
 
+/// <summary>
+/// Raised when distance from proximity sensor to the target was updated.
+/// </summary>
 [ByRefEvent]
-public record struct ProximityTargetUpdatedEvent(ProximityDetectorComponent Detector, EntityUid? Target, FixedPoint2 Distance);
+public readonly record struct ProximityTargetUpdatedEvent(float Distance, Entity<ProximityDetectorComponent> Detector, EntityUid? Target = null);
 
+/// <summary>
+/// Raised when proximity sensor got new target.
+/// </summary>
 [ByRefEvent]
-public record struct NewProximityTargetEvent(ProximityDetectorComponent Detector, EntityUid? Target);
+public readonly record struct NewProximityTargetEvent(float Distance, Entity<ProximityDetectorComponent> Detector, EntityUid? Target = null);
-
-
-

Content.Shared/ProximityDetection/Systems/ProximityDetectionSystem.cs

@@ -1,219 +1,139 @@
 using Content.Shared.Item.ItemToggle;
-using Content.Shared.Item.ItemToggle.Components;
+using Content.Shared.Item.ItemToggle.Components;
 using Content.Shared.ProximityDetection.Components;
-using Content.Shared.Tag;
+using Robust.Shared.Timing;
-using Robust.Shared.Network;
 
 namespace Content.Shared.ProximityDetection.Systems;
 
-
+/// <summary>
-//This handles generic proximity detector logic
+/// Handles generic proximity detector logic.
+/// </summary>
 public sealed class ProximityDetectionSystem : EntitySystem
 {
-    [Dependency] private readonly EntityLookupSystem _entityLookup = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
     [Dependency] private readonly ItemToggleSystem _toggle = default!;
-    [Dependency] private readonly SharedTransformSystem _transform = default!;
-    [Dependency] private readonly TagSystem _tagSystem = default!;
-    [Dependency] private readonly INetManager _net = default!;
 
-    //update is only run on the server
+    private EntityQuery<TransformComponent> _xformQuery;
 
     public override void Initialize()
     {
         base.Initialize();
 
-        SubscribeLocalEvent<ProximityDetectorComponent, ComponentInit>(OnCompInit);
+        SubscribeLocalEvent<ProximityDetectorComponent, MapInitEvent>(OnMapInit);
         SubscribeLocalEvent<ProximityDetectorComponent, ItemToggledEvent>(OnToggled);
+
+        _xformQuery = GetEntityQuery<TransformComponent>();
     }
 
-    private void OnCompInit(EntityUid uid, ProximityDetectorComponent component, ComponentInit args)
+    private void OnMapInit(Entity<ProximityDetectorComponent> ent, ref MapInitEvent args)
     {
-        if (component.Criteria.RequireAll)
+        var component = ent.Comp;
-            return;
-        Log.Debug("DetectorComponent only supports requireAll = false for tags. All components are required for a match!");
-    }
 
-    public override void Update(float frameTime)
+        component.NextUpdate = _timing.CurTime + component.UpdateCooldown;
-    {
+        DirtyField(ent, component, nameof(ProximityDetectorComponent.NextUpdate));
-        if (_net.IsClient)
-            return;
-
-        var query = EntityQueryEnumerator<ProximityDetectorComponent>();
-        while (query.MoveNext(out var owner, out var detector))
-        {
-            if (!_toggle.IsActivated(owner))
-                continue;
-
-            detector.AccumulatedFrameTime += frameTime;
-            if (detector.AccumulatedFrameTime < detector.UpdateRate)
-                continue;
-
-            detector.AccumulatedFrameTime -= detector.UpdateRate;
-            RunUpdate_Internal(owner, detector);
-        }
     }
 
     private void OnToggled(Entity<ProximityDetectorComponent> ent, ref ItemToggledEvent args)
     {
         if (args.Activated)
-        {
+            UpdateTarget(ent);
-            RunUpdate_Internal(ent, ent.Comp);
+        else
-            return;
+            ClearTarget(ent);
-        }
-
-        var noDetectEvent = new ProximityTargetUpdatedEvent(ent.Comp, Target: null, ent.Comp.Distance);
-        RaiseLocalEvent(ent, ref noDetectEvent);
-
-        ent.Comp.AccumulatedFrameTime = 0;
-        Dirty(ent, ent.Comp);
     }
 
-    public void ForceUpdate(EntityUid owner, ProximityDetectorComponent? detector = null)
+    public override void Update(float frameTime)
     {
-        if (!Resolve(owner, ref detector))
+        var query = EntityQueryEnumerator<ProximityDetectorComponent>();
-            return;
+
-        RunUpdate_Internal(owner, detector);
+        while (query.MoveNext(out var uid, out var component))
+        {
+            if (component.NextUpdate > _timing.CurTime)
+                continue;
+
+            component.NextUpdate += component.UpdateCooldown;
+            DirtyField(uid, component, nameof(ProximityDetectorComponent.NextUpdate));
+
+            if (!_toggle.IsActivated(uid))
+                continue;
+
+            UpdateTarget((uid, component));
+        }
     }
 
     private void ClearTarget(Entity<ProximityDetectorComponent> ent)
     {
-        var (uid, comp) = ent;
+        var component = ent.Comp;
-        if (comp.TargetEnt == null)
+
+        // Don't do anything if we have no target.
+        if (component.Target == null)
             return;
 
-        comp.Distance = -1;
+        component.Distance = float.PositiveInfinity;
-        comp.TargetEnt = null;
+        DirtyField(ent, component, nameof(ProximityDetectorComponent.Distance));
-        var noDetectEvent = new ProximityTargetUpdatedEvent(comp, null, -1);
+
-        RaiseLocalEvent(uid, ref noDetectEvent);
+        component.Target = null;
-        var newTargetEvent = new NewProximityTargetEvent(comp, null);
+        DirtyField(ent, component, nameof(ProximityDetectorComponent.Target));
-        RaiseLocalEvent(uid, ref newTargetEvent);
+
-        Dirty(uid, comp);
+        var updatedEv = new ProximityTargetUpdatedEvent(component.Distance, ent);
+        RaiseLocalEvent(ent, ref updatedEv);
+
+        var newTargetEv = new NewProximityTargetEvent(component.Distance, ent);
+        RaiseLocalEvent(ent, ref newTargetEv);
     }
 
-    private void RunUpdate_Internal(EntityUid owner,ProximityDetectorComponent detector)
+    private void UpdateTarget(Entity<ProximityDetectorComponent> detector)
     {
-        if (!_net.IsServer) //only run detection checks on the server!
+        var component = detector.Comp;
+
+        if (!_xformQuery.TryGetComponent(detector, out var transform))
             return;
 
-        if (Deleted(detector.TargetEnt))
+        if (Deleted(component.Target))
+            ClearTarget(detector);
+
+        var closestDistance = float.PositiveInfinity;
+        EntityUid? closestUid = null;
+
+        var query = EntityManager.CompRegistryQueryEnumerator(component.Components);
+
+        while (query.MoveNext(out var uid))
         {
-            ClearTarget((owner, detector));
+            if (!_xformQuery.TryGetComponent(uid, out var xForm))
-        }
-
-        var xformQuery = GetEntityQuery<TransformComponent>();
-        var xform = xformQuery.GetComponent(owner);
-        List<(EntityUid TargetEnt, float Distance)> detections = new();
-
-        if (detector.Criteria.Components == null)
-        {
-            Log.Error($"ProximityDetectorComponent on {ToPrettyString(owner)} must use at least 1 component as a filter in criteria!");
-            throw new ArgumentException($"ProximityDetectorComponent on {ToPrettyString(owner)} must use at least 1 component as a filter in criteria!");
-        }
-        var firstCompType = EntityManager.ComponentFactory.GetRegistration(detector.Criteria.Components[0]).Type;
-        var foundEnts = _entityLookup.GetEntitiesInRange(firstCompType,_transform.GetMapCoordinates(owner, xform), detector.Range.Float());
-
-        var tagSearchEnabled = detector.Criteria.Tags is {Count: > 0};
-
-        CheckForAllComponentsPresent(detector, ref foundEnts, tagSearchEnabled);
-
-        if (foundEnts.Count == 0)
-        {
-            UpdateTargetFromClosest(owner, detector, detections);
-            return;
-        }
-
-        foreach (var ent in foundEnts)
-        {
-            if (tagSearchEnabled && ent.Comp is TagComponent tags && (detector.Criteria.RequireAll
-                    ? _tagSystem.HasAllTags(tags, detector.Criteria.Tags!)
-                    : _tagSystem.HasAnyTag(tags, detector.Criteria.Tags!)))
                 continue;
-            var distance = (_transform.GetWorldPosition(xform, xformQuery) - _transform.GetWorldPosition(ent, xformQuery)).Length();
-            if (CheckDetectConditions(ent, distance, owner, detector))
-            {
-                detections.Add((ent, distance));
-            }
-        }
-        UpdateTargetFromClosest(owner, detector, detections);
-    }
 
-    private void CheckForAllComponentsPresent(ProximityDetectorComponent detector, ref HashSet<Entity<IComponent>> foundEnts, bool tagSearchEnabled)
+            if (!transform.Coordinates.TryDistance(EntityManager, xForm.Coordinates, out var distance) ||
-    {
+                distance > component.Range || distance >= closestDistance)
-        var validEnts = new HashSet<Entity<IComponent>>(foundEnts.Count);
-        for (var i = 1; i < detector.Criteria.Components!.Length; i++)
-        {
-            validEnts.Clear();
-            var compType = EntityManager.ComponentFactory.GetRegistration(detector.Criteria.Components[i]).Type;
-            foreach (var ent in foundEnts)
-            {
-                if (!HasComp(ent, compType))
-                    continue;
-                validEnts.Add(ent);
-            }
-            (foundEnts, validEnts) = (validEnts, foundEnts);
-        }
-        validEnts.Clear();
-        if (tagSearchEnabled)
-        {
-            foreach (var ent in foundEnts)
-            {
-                if (!HasComp<TagComponent>(ent))
-                    continue;
-                validEnts.Add(ent);
-            }
-            (foundEnts, validEnts) = (validEnts, foundEnts);
-            validEnts.Clear();
-        }
-    }
-
-
-    private bool CheckDetectConditions(EntityUid targetEntity, float dist, EntityUid owner, ProximityDetectorComponent detector)
-    {
-        var detectAttempt = new ProximityDetectionAttemptEvent(false, dist, (owner, detector));
-        RaiseLocalEvent(targetEntity, ref detectAttempt);
-        return !detectAttempt.Cancel;
-    }
-
-    private void UpdateTargetFromClosest(EntityUid owner, ProximityDetectorComponent detector, List<(EntityUid TargetEnt, float Distance)> detections)
-    {
-        if (detections.Count == 0)
-        {
-            ClearTarget((owner, detector));
-            return;
-        }
-        var closestDistance = detections[0].Distance;
-        EntityUid closestEnt = default!;
-        foreach (var (ent,dist) in detections)
-        {
-            if (dist >= closestDistance)
                 continue;
-            closestEnt = ent;
+
-            closestDistance = dist;
+            var detectAttempt = new ProximityDetectionAttemptEvent(distance, detector, uid);
+            RaiseLocalEvent(detector, ref detectAttempt);
+
+            if (detectAttempt.Cancelled)
+                continue;
+
+            closestDistance = distance;
+            closestUid = uid;
+        }
+
+        var newDistance = component.Distance != closestDistance;
+        var newTarget = component.Target != closestUid;
+
+        if (newDistance)
+        {
+            var updatedEv = new ProximityTargetUpdatedEvent(closestDistance, detector, closestUid);
+            RaiseLocalEvent(detector, ref updatedEv);
+
+            component.Distance = closestDistance;
+            DirtyField(detector, component, nameof(ProximityDetectorComponent.Distance));
         }
 
-        var newTarget = detector.TargetEnt != closestEnt;
-        var newData = newTarget || detector.Distance != closestDistance;
-        detector.TargetEnt = closestEnt;
-        detector.Distance = closestDistance;
-        Dirty(owner, detector);
         if (newTarget)
         {
-            var newTargetEvent = new NewProximityTargetEvent(detector, closestEnt);
+            var newTargetEv = new NewProximityTargetEvent(closestDistance, detector, closestUid);
-            RaiseLocalEvent(owner, ref newTargetEvent);
+            RaiseLocalEvent(detector, ref newTargetEv);
+
+            component.Target = closestUid;
+            DirtyField(detector, component, nameof(ProximityDetectorComponent.Target));
         }
-
-        if (!newData)
-            return;
-        var targetUpdatedEvent = new ProximityTargetUpdatedEvent(detector, closestEnt, closestDistance);
-        RaiseLocalEvent(owner, ref targetUpdatedEvent);
-        Dirty(owner, detector);
-    }
-
-    public void SetRange(EntityUid owner, float newRange, ProximityDetectorComponent? detector = null)
-    {
-        if (!Resolve(owner, ref detector))
-            return;
-        detector.Range = newRange;
-        Dirty(owner, detector);
     }
 }

Resources/Prototypes/Entities/Objects/Fun/spectral_locator.yml

@@ -24,9 +24,8 @@
   - type: ProximityBeeper
   - type: ProximityDetector
     range: 12
-    criteria:
+    components:
-      components:
+    - type: Spectral # reacts to AI eye, intentional
-      - Spectral # reacts to AI eye, intentional
   - type: Beeper
     isMuted: true
     minBeepInterval: 0.25

Resources/Prototypes/Entities/Objects/Specific/Research/anomaly.yml

@@ -48,9 +48,8 @@
   - type: ProximityBeeper
   - type: ProximityDetector
     range: 20
-    criteria:
+    components:
-      components:
+    - type: Anomaly
-      - Anomaly
   - type: Beeper
     isMuted: true
     minBeepInterval: 0.15