tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor: ProximityDetectionSystem (#35133)

Browse Source 
* Refactor: ProximityDetectionSystem

* Update

* Update

* Update

* Yikes

* Update

* Dirty

* Update

* Update

* Lil cleanup

* Update

* Update
This commit is contained in:
Winkarst
2025-05-11 17:33:35 +03:00
committed by GitHub
parent cd1ebecab0
commit 078814ce41
6 changed files with 144 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Content.Shared/Beeper/Systems/ProximityBeeperSystem.cs
View File

@@ -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.SetMute(owner, false, beeper);
_beeper.SetIntervalScaling(owner, args.Distance / args.Detector.Comp.Range, beeper);
}
private void OnNewProximityTarget(EntityUid owner, ProximityBeeperComponent proxBeeper, ref NewProximityTargetEvent args)

52
Content.Shared/ProximityDetection/Components/ProximityDetectorComponent.cs
View File

@@ -1,43 +1,51 @@
using Content.Shared.FixedPoint;
using Content.Shared.ProximityDetection.Systems;
using Content.Shared.Whitelist;
using Content.Shared.ProximityDetection.Systems;
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
/// Note: RequireAll is only supported for tags, all components are required to count as a match!
/// Entities that detector will search for.
/// </summary>
[DataField( required: true), AutoNetworkedField, ViewVariables(VVAccess.ReadWrite)]
public EntityWhitelist Criteria = new();
[DataField(required: true)]
public ComponentRegistry Components;
/// <summary>
/// Found Entity
/// The entity that was found.
/// </summary>
[ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
public EntityUid? TargetEnt;
[ViewVariables, AutoNetworkedField]
public EntityUid? Target;
/// <summary>
/// Distance to Found Entity
/// The distance to <see cref="Target"/>.
/// </summary>
[ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
public FixedPoint2 Distance = -1;
[ViewVariables, AutoNetworkedField]
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]
public FixedPoint2 Range = 10f;
[DataField, AutoNetworkedField]
public float Range = 10f;
// TODO: use timespans not this
public float AccumulatedFrameTime;
/// <summary>
/// How often detector updates.
/// </summary>
[DataField, AutoNetworkedField]
public TimeSpan UpdateCooldown = TimeSpan.FromSeconds(1);
[DataField, ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
public float UpdateRate = 0.3f;
/// <summary>
/// Next time detector updates.
/// </summary>
[DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoNetworkedField, AutoPausedField]
public TimeSpan NextUpdate = TimeSpan.Zero;
}

28
Content.Shared/ProximityDetection/ProximityDetectionEvents.cs
View File

@@ -1,17 +1,27 @@
using Content.Shared.FixedPoint;
using Content.Shared.ProximityDetection.Components;
using Robust.Shared.Serialization;
using Content.Shared.ProximityDetection.Components;
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);

248
Content.Shared/ProximityDetection/Systems/ProximityDetectionSystem.cs
View File

@@ -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.Network;
using Robust.Shared.Timing;
namespace Content.Shared.ProximityDetection.Systems;
//This handles generic proximity detector logic
/// <summary>
/// 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)
return;
Log.Debug("DetectorComponent only supports requireAll = false for tags. All components are required for a match!");
}
var component = ent.Comp;
public override void Update(float frameTime)
{
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);
}
component.NextUpdate = _timing.CurTime + component.UpdateCooldown;
DirtyField(ent, component, nameof(ProximityDetectorComponent.NextUpdate));
}
private void OnToggled(Entity<ProximityDetectorComponent> ent, ref ItemToggledEvent args)
{
if (args.Activated)
{
RunUpdate_Internal(ent, ent.Comp);
return;
UpdateTarget(ent);
else
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))
return;
RunUpdate_Internal(owner, detector);
var query = EntityQueryEnumerator<ProximityDetectorComponent>();
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;
if (comp.TargetEnt == null)
var component = ent.Comp;
// Don't do anything if we have no target.
if (component.Target == null)
return;
comp.Distance = -1;
comp.TargetEnt = null;
var noDetectEvent = new ProximityTargetUpdatedEvent(comp, null, -1);
RaiseLocalEvent(uid, ref noDetectEvent);
var newTargetEvent = new NewProximityTargetEvent(comp, null);
RaiseLocalEvent(uid, ref newTargetEvent);
Dirty(uid, comp);
component.Distance = float.PositiveInfinity;
DirtyField(ent, component, nameof(ProximityDetectorComponent.Distance));
component.Target = null;
DirtyField(ent, component, nameof(ProximityDetectorComponent.Target));
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));
}
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!)))
if (!_xformQuery.TryGetComponent(uid, out var xForm))
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)
{
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))
if (!transform.Coordinates.TryDistance(EntityManager, xForm.Coordinates, out var distance) ||
distance > component.Range || distance >= closestDistance)
continue;
validEnts.Add(ent);
}
(foundEnts, validEnts) = (validEnts, foundEnts);
}
validEnts.Clear();
if (tagSearchEnabled)
{
foreach (var ent in foundEnts)
{
if (!HasComp<TagComponent>(ent))
var detectAttempt = new ProximityDetectionAttemptEvent(distance, detector, uid);
RaiseLocalEvent(detector, ref detectAttempt);
if (detectAttempt.Cancelled)
continue;
validEnts.Add(ent);
}
(foundEnts, validEnts) = (validEnts, foundEnts);
validEnts.Clear();
}
closestDistance = distance;
closestUid = uid;
}
var newDistance = component.Distance != closestDistance;
var newTarget = component.Target != closestUid;
private bool CheckDetectConditions(EntityUid targetEntity, float dist, EntityUid owner, ProximityDetectorComponent detector)
if (newDistance)
{
var detectAttempt = new ProximityDetectionAttemptEvent(false, dist, (owner, detector));
RaiseLocalEvent(targetEntity, ref detectAttempt);
return !detectAttempt.Cancel;
var updatedEv = new ProximityTargetUpdatedEvent(closestDistance, detector, closestUid);
RaiseLocalEvent(detector, ref updatedEv);
component.Distance = closestDistance;
DirtyField(detector, component, nameof(ProximityDetectorComponent.Distance));
}
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 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);
RaiseLocalEvent(owner, ref newTargetEvent);
}
var newTargetEv = new NewProximityTargetEvent(closestDistance, detector, closestUid);
RaiseLocalEvent(detector, ref newTargetEv);
if (!newData)
return;
var targetUpdatedEvent = new ProximityTargetUpdatedEvent(detector, closestEnt, closestDistance);
RaiseLocalEvent(owner, ref targetUpdatedEvent);
Dirty(owner, detector);
component.Target = closestUid;
DirtyField(detector, component, nameof(ProximityDetectorComponent.Target));
}
public void SetRange(EntityUid owner, float newRange, ProximityDetectorComponent? detector = null)
{
if (!Resolve(owner, ref detector))
return;
detector.Range = newRange;
Dirty(owner, detector);
}
}

3
Resources/Prototypes/Entities/Objects/Fun/spectral_locator.yml
View File

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

3
Resources/Prototypes/Entities/Objects/Specific/Research/anomaly.yml
View File

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