diff --git a/Content.Server/Pinpointer/PinpointerSystem.cs b/Content.Server/Pinpointer/PinpointerSystem.cs index fd85f1e56e2..076489a2e20 100644 --- a/Content.Server/Pinpointer/PinpointerSystem.cs +++ b/Content.Server/Pinpointer/PinpointerSystem.cs @@ -4,7 +4,7 @@ using System.Linq; using System.Numerics; using Robust.Shared.Utility; using Content.Server.Shuttles.Events; -using Content.Shared.IdentityManagement; + namespace Content.Server.Pinpointer; public sealed class PinpointerSystem : SharedPinpointerSystem @@ -23,34 +23,35 @@ public sealed class PinpointerSystem : SharedPinpointerSystem SubscribeLocalEvent(OnLocateTarget); } - public override bool TogglePinpointer(EntityUid uid, PinpointerComponent? pinpointer = null) + public override bool TogglePinpointer(Entity ent) { - if (!Resolve(uid, ref pinpointer)) + if (!Resolve(ent, ref ent.Comp)) return false; - var isActive = !pinpointer.IsActive; - SetActive(uid, isActive, pinpointer); - UpdateAppearance(uid, pinpointer); + var isActive = !ent.Comp.IsActive; + SetActive(ent, isActive); + UpdateAppearance(ent); return isActive; } - private void UpdateAppearance(EntityUid uid, PinpointerComponent pinpointer, AppearanceComponent? appearance = null) + private void UpdateAppearance(Entity ent) { - if (!Resolve(uid, ref appearance)) + if (!Resolve(ent, ref ent.Comp1) || !Resolve(ent, ref ent.Comp2)) return; - _appearance.SetData(uid, PinpointerVisuals.IsActive, pinpointer.IsActive, appearance); - _appearance.SetData(uid, PinpointerVisuals.TargetDistance, pinpointer.DistanceToTarget, appearance); + + _appearance.SetData(ent, PinpointerVisuals.IsActive, ent.Comp1.IsActive, ent.Comp2); + _appearance.SetData(ent, PinpointerVisuals.TargetDistance, ent.Comp1.DistanceToTarget, ent.Comp2); } - private void OnActivate(EntityUid uid, PinpointerComponent component, ActivateInWorldEvent args) + private void OnActivate(Entity ent, ref ActivateInWorldEvent args) { if (args.Handled || !args.Complex) return; - TogglePinpointer(uid, component); + TogglePinpointer(ent.AsNullable()); - if (!component.CanRetarget) - LocateTarget(uid, component, args); //#IMP args + if (!ent.Comp.CanRetarget) + LocateTarget(ent, args); // #IMP args args.Handled = true; } @@ -68,13 +69,15 @@ public sealed class PinpointerSystem : SharedPinpointerSystem if (pinpointer.CanRetarget) continue; - LocateTarget(uid, pinpointer); + LocateTarget((uid, pinpointer)); } } //#IMP ActivateInWorldEvent args: added this - private void LocateTarget(EntityUid uid, PinpointerComponent component, ActivateInWorldEvent? args = null) + private void LocateTarget(Entity ent, ActivateInWorldEvent? args = null) { + var component = ent.Comp; + // try to find target from whitelist if (component.IsActive && component.Component != null) { @@ -85,8 +88,8 @@ public sealed class PinpointerSystem : SharedPinpointerSystem return; } - var target = FindTargetFromComponent(uid, reg.Type); - SetTarget(uid, target, component); + var target = FindTargetFromComponent(ent.Owner, reg.Type); + SetTarget(ent.AsNullable(), target); } } @@ -99,7 +102,7 @@ public sealed class PinpointerSystem : SharedPinpointerSystem var query = EntityQueryEnumerator(); while (query.MoveNext(out var uid, out var pinpointer)) { - UpdateDirectionToTarget(uid, pinpointer); + UpdateDirectionToTarget((uid, pinpointer)); } } @@ -107,17 +110,15 @@ public sealed class PinpointerSystem : SharedPinpointerSystem /// Try to find the closest entity from whitelist on a current map /// Will return null if can't find anything /// - private EntityUid? FindTargetFromComponent(EntityUid uid, Type whitelist, TransformComponent? transform = null) + private EntityUid? FindTargetFromComponent(Entity ent, Type whitelist) { - _xformQuery.Resolve(uid, ref transform, false); - - if (transform == null) + if (!Resolve(ent, ref ent.Comp)) return null; // sort all entities in distance increasing order - var mapId = transform.MapID; + var mapId = ent.Comp.MapID; var l = new SortedList(); - var worldPos = _transform.GetWorldPosition(transform); + var worldPos = _transform.GetWorldPosition(ent.Comp); foreach (var (otherUid, _) in EntityManager.GetAllComponents(whitelist)) { @@ -135,36 +136,38 @@ public sealed class PinpointerSystem : SharedPinpointerSystem /// /// Update direction from pinpointer to selected target (if it was set) /// - protected override void UpdateDirectionToTarget(EntityUid uid, PinpointerComponent? pinpointer = null) + protected override void UpdateDirectionToTarget(Entity ent) { - if (!Resolve(uid, ref pinpointer)) + if (!Resolve(ent, ref ent.Comp)) return; + var pinpointer = ent.Comp; + if (!pinpointer.IsActive) return; var target = pinpointer.Target; if (target == null || !Exists(target.Value)) { - SetDistance(uid, Distance.Unknown, pinpointer); + SetDistance(ent, Distance.Unknown); return; } - var dirVec = CalculateDirection(uid, target.Value); + var dirVec = CalculateDirection(ent, target.Value); var oldDist = pinpointer.DistanceToTarget; if (dirVec != null) { var angle = dirVec.Value.ToWorldAngle(); - TrySetArrowAngle(uid, angle, pinpointer); + TrySetArrowAngle(ent, angle); var dist = CalculateDistance(dirVec.Value, pinpointer); - SetDistance(uid, dist, pinpointer); + SetDistance(ent, dist); } else { - SetDistance(uid, Distance.Unknown, pinpointer); + SetDistance(ent, Distance.Unknown); } if (oldDist != pinpointer.DistanceToTarget) - UpdateAppearance(uid, pinpointer); + UpdateAppearance(ent); } /// diff --git a/Content.Shared/Pinpointer/PinpointerComponent.cs b/Content.Shared/Pinpointer/PinpointerComponent.cs index ff7321d50c9..f1a3a692f00 100644 --- a/Content.Shared/Pinpointer/PinpointerComponent.cs +++ b/Content.Shared/Pinpointer/PinpointerComponent.cs @@ -12,40 +12,40 @@ namespace Content.Shared.Pinpointer; public sealed partial class PinpointerComponent : Component { // TODO: Type serializer oh god - [DataField("component"), ViewVariables(VVAccess.ReadWrite)] + [DataField] public string? Component; - [DataField("mediumDistance"), ViewVariables(VVAccess.ReadWrite)] + [DataField] public float MediumDistance = 16f; - [DataField("closeDistance"), ViewVariables(VVAccess.ReadWrite)] + [DataField] public float CloseDistance = 8f; - [DataField("reachedDistance"), ViewVariables(VVAccess.ReadWrite)] + [DataField] public float ReachedDistance = 1f; /// /// Pinpointer arrow precision in radians. /// - [DataField("precision"), ViewVariables(VVAccess.ReadWrite)] + [DataField] public double Precision = 0.09; /// /// Name to display of the target being tracked. /// - [DataField("targetName"), ViewVariables(VVAccess.ReadWrite)] + [DataField] public string? TargetName; /// /// Whether or not the target name should be updated when the target is updated. /// - [DataField("updateTargetName"), ViewVariables(VVAccess.ReadWrite)] + [DataField] public bool UpdateTargetName; /// /// Whether or not the target can be reassigned. /// - [DataField("canRetarget"), ViewVariables(VVAccess.ReadWrite)] + [DataField] public bool CanRetarget; [ViewVariables] diff --git a/Content.Shared/Pinpointer/SharedPinpointerSystem.cs b/Content.Shared/Pinpointer/SharedPinpointerSystem.cs index 47109601835..79fc820baf8 100644 --- a/Content.Shared/Pinpointer/SharedPinpointerSystem.cs +++ b/Content.Shared/Pinpointer/SharedPinpointerSystem.cs @@ -23,30 +23,32 @@ public abstract class SharedPinpointerSystem : EntitySystem /// /// Set the target if capable /// - private void OnAfterInteract(EntityUid uid, PinpointerComponent component, AfterInteractEvent args) + private void OnAfterInteract(Entity ent, ref AfterInteractEvent args) { if (!args.CanReach || args.Target is not { } target) return; - if (!component.CanRetarget || component.IsActive) + if (!ent.Comp.CanRetarget || ent.Comp.IsActive) return; // TODO add doafter once the freeze is lifted args.Handled = true; - component.Target = args.Target; - _adminLogger.Add(LogType.Action, LogImpact.Low, $"{ToPrettyString(args.User):player} set target of {ToPrettyString(uid):pinpointer} to {ToPrettyString(component.Target.Value):target}"); - if (component.UpdateTargetName) - component.TargetName = component.Target == null ? null : Identity.Name(component.Target.Value, EntityManager); + ent.Comp.Target = args.Target; + _adminLogger.Add(LogType.Action, LogImpact.Low, $"{ToPrettyString(args.User):player} set target of {ToPrettyString(ent):pinpointer} to {ToPrettyString(ent.Comp.Target.Value):target}"); + if (ent.Comp.UpdateTargetName) + ent.Comp.TargetName = ent.Comp.Target == null ? null : Identity.Name(ent.Comp.Target.Value, EntityManager); } /// /// Set pinpointers target to track /// - public virtual void SetTarget(EntityUid uid, EntityUid? target, PinpointerComponent? pinpointer = null) + public virtual void SetTarget(Entity ent, EntityUid? target) { - if (!Resolve(uid, ref pinpointer)) + if (!Resolve(ent, ref ent.Comp)) return; + var pinpointer = ent.Comp; + if (pinpointer.Target == target) return; @@ -54,38 +56,38 @@ public abstract class SharedPinpointerSystem : EntitySystem if (pinpointer.UpdateTargetName) pinpointer.TargetName = target == null ? null : Identity.Name(target.Value, EntityManager); if (pinpointer.IsActive) - UpdateDirectionToTarget(uid, pinpointer); + UpdateDirectionToTarget(ent); } /// /// Update direction from pinpointer to selected target (if it was set) /// - protected virtual void UpdateDirectionToTarget(EntityUid uid, PinpointerComponent? pinpointer = null) + protected virtual void UpdateDirectionToTarget(Entity ent) { } - private void OnExamined(EntityUid uid, PinpointerComponent component, ExaminedEvent args) + private void OnExamined(Entity ent, ref ExaminedEvent args) { - if (!args.IsInDetailsRange || component.TargetName == null) + if (!args.IsInDetailsRange || ent.Comp.TargetName == null) return; - args.PushMarkup(Loc.GetString("examine-pinpointer-linked", ("target", component.TargetName))); + args.PushMarkup(Loc.GetString("examine-pinpointer-linked", ("target", ent.Comp.TargetName))); } /// /// Manually set distance from pinpointer to target /// - public void SetDistance(EntityUid uid, Distance distance, PinpointerComponent? pinpointer = null) + public void SetDistance(Entity ent, Distance distance) { - if (!Resolve(uid, ref pinpointer)) + if (!Resolve(ent, ref ent.Comp)) return; - if (distance == pinpointer.DistanceToTarget) + if (distance == ent.Comp.DistanceToTarget) return; - pinpointer.DistanceToTarget = distance; - Dirty(uid, pinpointer); + ent.Comp.DistanceToTarget = distance; + Dirty(ent); } /// @@ -93,16 +95,16 @@ public abstract class SharedPinpointerSystem : EntitySystem /// If difference between current angle and new angle is smaller than /// pinpointer precision, new value will be ignored and it will return false. /// - public bool TrySetArrowAngle(EntityUid uid, Angle arrowAngle, PinpointerComponent? pinpointer = null) + public bool TrySetArrowAngle(Entity ent, Angle arrowAngle) { - if (!Resolve(uid, ref pinpointer)) + if (!Resolve(ent, ref ent.Comp)) return false; - if (pinpointer.ArrowAngle.EqualsApprox(arrowAngle, pinpointer.Precision)) + if (ent.Comp.ArrowAngle.EqualsApprox(arrowAngle, ent.Comp.Precision)) return false; - pinpointer.ArrowAngle = arrowAngle; - Dirty(uid, pinpointer); + ent.Comp.ArrowAngle = arrowAngle; + Dirty(ent); return true; } @@ -110,15 +112,16 @@ public abstract class SharedPinpointerSystem : EntitySystem /// /// Activate/deactivate pinpointer screen. If it has target it will start tracking it. /// - public void SetActive(EntityUid uid, bool isActive, PinpointerComponent? pinpointer = null) + public void SetActive(Entity ent, bool isActive) { - if (!Resolve(uid, ref pinpointer)) - return; - if (isActive == pinpointer.IsActive) + if (!Resolve(ent, ref ent.Comp)) return; - pinpointer.IsActive = isActive; - Dirty(uid, pinpointer); + if (isActive == ent.Comp.IsActive) + return; + + ent.Comp.IsActive = isActive; + Dirty(ent); } @@ -126,28 +129,28 @@ public abstract class SharedPinpointerSystem : EntitySystem /// Toggle Pinpointer screen. If it has target it will start tracking it. /// /// True if pinpointer was activated, false otherwise - public virtual bool TogglePinpointer(EntityUid uid, PinpointerComponent? pinpointer = null) + public virtual bool TogglePinpointer(Entity ent) { - if (!Resolve(uid, ref pinpointer)) + if (!Resolve(ent, ref ent.Comp)) return false; - var isActive = !pinpointer.IsActive; - SetActive(uid, isActive, pinpointer); + var isActive = !ent.Comp.IsActive; + SetActive(ent, isActive); return isActive; } - private void OnEmagged(EntityUid uid, PinpointerComponent component, ref GotEmaggedEvent args) + private void OnEmagged(Entity ent, ref GotEmaggedEvent args) { if (!_emag.CompareFlag(args.Type, EmagType.Interaction)) return; - if (_emag.CheckFlag(uid, EmagType.Interaction)) + if (_emag.CheckFlag(ent, EmagType.Interaction)) return; - if (component.CanRetarget) + if (ent.Comp.CanRetarget) return; args.Handled = true; - component.CanRetarget = true; + ent.Comp.CanRetarget = true; } }