Fix pinpointer flicker (#15452)

Content.Client/Pinpointer/PinpointerSystem.cs

@@ -1,78 +1,41 @@
 using Content.Shared.Pinpointer;
 using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
-using Robust.Shared.GameStates;
 
-namespace Content.Client.Pinpointer
+namespace Content.Client.Pinpointer;
-{
+
 public sealed class PinpointerSystem : SharedPinpointerSystem
 {
     [Dependency] private readonly IEyeManager _eyeManager = default!;
-        [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
 
-        public override void Initialize()
+    public override void Update(float frameTime)
     {
-            base.Initialize();
+        base.Update(frameTime);
-            SubscribeLocalEvent<PinpointerComponent, ComponentHandleState>(HandleCompState);
-        }
-
-        public override void FrameUpdate(float frameTime)
-        {
-            base.FrameUpdate(frameTime);
 
         // we want to show pinpointers arrow direction relative
         // to players eye rotation (like it was in SS13)
 
         // because eye can change it rotation anytime
         // we need to update this arrow in a update loop
-            foreach (var pinpointer in EntityQuery<PinpointerComponent>())
+        var query = EntityQueryEnumerator<PinpointerComponent, SpriteComponent>();
+        while (query.MoveNext(out var _, out var pinpointer, out var sprite))
         {
-                UpdateAppearance(pinpointer.Owner, pinpointer);
+            if (!pinpointer.HasTarget)
-                UpdateEyeDir(pinpointer.Owner, pinpointer);
+                continue;
-            }
-        }
-
-        private void HandleCompState(EntityUid uid, PinpointerComponent pinpointer, ref ComponentHandleState args)
-        {
-            if (args.Current is not PinpointerComponentState state)
-                return;
-
-            pinpointer.IsActive = state.IsActive;
-            pinpointer.ArrowAngle = state.ArrowAngle;
-            pinpointer.DistanceToTarget = state.DistanceToTarget;
-        }
-
-        private void UpdateAppearance(EntityUid uid, PinpointerComponent? pinpointer = null,
-            AppearanceComponent? appearance = null)
-        {
-            if (!Resolve(uid, ref pinpointer, ref appearance))
-                return;
-
-            _appearance.SetData(uid, PinpointerVisuals.IsActive, pinpointer.IsActive, appearance);
-            _appearance.SetData(uid, PinpointerVisuals.TargetDistance, pinpointer.DistanceToTarget, appearance);
-        }
-
-        private void UpdateArrowAngle(EntityUid uid, Angle angle, PinpointerComponent? pinpointer = null,
-            AppearanceComponent? appearance = null)
-        {
-            if (!Resolve(uid, ref pinpointer, ref appearance))
-                return;
-
-            _appearance.SetData(uid, PinpointerVisuals.ArrowAngle, angle, appearance);
-        }
-
-        /// <summary>
-        ///     Transform pinpointer arrow from world space to eye space
-        ///     And send it to the appearance component
-        /// </summary>
-        private void UpdateEyeDir(EntityUid uid, PinpointerComponent? pinpointer = null)
-        {
-            if (!Resolve(uid, ref pinpointer) || !pinpointer.HasTarget)
-                return;
-
             var eye = _eyeManager.CurrentEye;
             var angle = pinpointer.ArrowAngle + eye.Rotation;
-            UpdateArrowAngle(uid, angle, pinpointer);
+
+            switch (pinpointer.DistanceToTarget)
+            {
+                case Distance.Close:
+                case Distance.Medium:
+                case Distance.Far:
+                    sprite.LayerSetRotation(PinpointerLayers.Screen, angle);
+                    break;
+                default:
+                    sprite.LayerSetRotation(PinpointerLayers.Screen, Angle.Zero);
+                    break;
+            }
         }
     }
 }

Content.Client/Pinpointer/PinpointerVisualizerSystem.cs

@@ -1,60 +0,0 @@
-using Content.Shared.Pinpointer;
-using JetBrains.Annotations;
-using Robust.Client.GameObjects;
-
-namespace Content.Client.Pinpointer
-{
-    [UsedImplicitly]
-    public sealed class PinpointerVisualizerSystem : VisualizerSystem<PinpointerComponent>
-    {
-        protected override void OnAppearanceChange(EntityUid uid, PinpointerComponent component, ref AppearanceChangeEvent args)
-        {
-            base.OnAppearanceChange(uid, component, ref args);
-
-            if (!TryComp(component.Owner, out SpriteComponent? sprite))
-                return;
-
-            // check if pinpointer screen is active
-            if (!AppearanceSystem.TryGetData<bool>(uid, PinpointerVisuals.IsActive, out var isActive, args.Component) || !isActive)
-            {
-                sprite.LayerSetVisible(PinpointerLayers.Screen, false);
-                return;
-            }
-
-            sprite.LayerSetVisible(PinpointerLayers.Screen, true);
-
-            // check distance and direction to target
-            if (!AppearanceSystem.TryGetData<Distance>(uid, PinpointerVisuals.TargetDistance, out var dis, args.Component) ||
-                !AppearanceSystem.TryGetData<Angle>(uid, PinpointerVisuals.ArrowAngle, out var angle, args.Component))
-            {
-                sprite.LayerSetState(PinpointerLayers.Screen, "pinonnull");
-                sprite.LayerSetRotation(PinpointerLayers.Screen, Angle.Zero);
-                return;
-            }
-
-            switch (dis)
-            {
-                case Distance.Reached:
-                    sprite.LayerSetState(PinpointerLayers.Screen, "pinondirect");
-                    sprite.LayerSetRotation(PinpointerLayers.Screen, Angle.Zero);
-                    break;
-                case Distance.Close:
-                    sprite.LayerSetState(PinpointerLayers.Screen, "pinonclose");
-                    sprite.LayerSetRotation(PinpointerLayers.Screen, angle);
-                    break;
-                case Distance.Medium:
-                    sprite.LayerSetState(PinpointerLayers.Screen, "pinonmedium");
-                    sprite.LayerSetRotation(PinpointerLayers.Screen, angle);
-                    break;
-                case Distance.Far:
-                    sprite.LayerSetState(PinpointerLayers.Screen, "pinonfar");
-                    sprite.LayerSetRotation(PinpointerLayers.Screen, angle);
-                    break;
-                case Distance.Unknown:
-                    sprite.LayerSetState(PinpointerLayers.Screen, "pinonnull");
-                    sprite.LayerSetRotation(PinpointerLayers.Screen, Angle.Zero);
-                    break;
-            }
-        }
-    }
-}

Content.Server/Pinpointer/PinpointerSystem.cs

@@ -4,11 +4,12 @@ using System.Linq;
 using Robust.Shared.Utility;
 using Content.Server.Shuttles.Events;
 
-namespace Content.Server.Pinpointer
+namespace Content.Server.Pinpointer;
-{
+
 public sealed class PinpointerSystem : SharedPinpointerSystem
 {
     [Dependency] private readonly SharedTransformSystem _transform = default!;
+    [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
 
     public override void Initialize()
     {
@@ -23,15 +24,35 @@ namespace Content.Server.Pinpointer
         LocateTarget(uid, component);
     }
 
+    public bool TogglePinpointer(EntityUid uid, PinpointerComponent? pinpointer = null)
+    {
+        if (!Resolve(uid, ref pinpointer))
+            return false;
+
+        var isActive = !pinpointer.IsActive;
+        SetActive(uid, isActive, pinpointer);
+        UpdateAppearance(uid, pinpointer);
+        return isActive;
+    }
+
+    private void UpdateAppearance(EntityUid uid, PinpointerComponent pinpointer, AppearanceComponent? appearance = null)
+    {
+        if (!Resolve(uid, ref appearance))
+            return;
+        _appearance.SetData(uid, PinpointerVisuals.IsActive, pinpointer.IsActive, appearance);
+        _appearance.SetData(uid, PinpointerVisuals.TargetDistance, pinpointer.DistanceToTarget, appearance);
+    }
+
     private void OnLocateTarget(ref FTLCompletedEvent ev)
     {
         // This feels kind of expensive, but it only happens once per hyperspace jump
 
         // todo: ideally, you would need to raise this event only on jumped entities
         // this code update ALL pinpointers in game
-            foreach (var pinpointer in EntityQuery<PinpointerComponent>())
+        var query = EntityQueryEnumerator<PinpointerComponent>();
+        while (query.MoveNext(out var uid, out var pinpointer))
         {
-                LocateTarget(pinpointer.Owner, pinpointer);
+            LocateTarget(uid, pinpointer);
         }
     }
 
@@ -58,9 +79,10 @@ namespace Content.Server.Pinpointer
 
         // because target or pinpointer can move
         // we need to update pinpointers arrow each frame
-            foreach (var pinpointer in EntityQuery<PinpointerComponent>())
+        var query = EntityQueryEnumerator<PinpointerComponent>();
+        while (query.MoveNext(out var uid, out var pinpointer))
         {
-                UpdateDirectionToTarget(pinpointer.Owner, pinpointer);
+            UpdateDirectionToTarget(uid, pinpointer);
         }
     }
 
@@ -115,11 +137,8 @@ namespace Content.Server.Pinpointer
     /// <summary>
     ///     Update direction from pinpointer to selected target (if it was set)
     /// </summary>
-        private void UpdateDirectionToTarget(EntityUid uid, PinpointerComponent? pinpointer = null)
+    private void UpdateDirectionToTarget(EntityUid uid, PinpointerComponent pinpointer)
     {
-            if (!Resolve(uid, ref pinpointer))
-                return;
-
         if (!pinpointer.IsActive)
             return;
 
@@ -131,17 +150,20 @@ namespace Content.Server.Pinpointer
         }
 
         var dirVec = CalculateDirection(uid, target.Value);
+        var oldDist = pinpointer.DistanceToTarget;
         if (dirVec != null)
         {
             var angle = dirVec.Value.ToWorldAngle();
             TrySetArrowAngle(uid, angle, pinpointer);
-                var dist = CalculateDistance(uid, dirVec.Value, pinpointer);
+            var dist = CalculateDistance(dirVec.Value, pinpointer);
             SetDistance(uid, dist, pinpointer);
         }
         else
         {
             SetDistance(uid, Distance.Unknown, pinpointer);
         }
+        if (oldDist != pinpointer.DistanceToTarget)
+            UpdateAppearance(uid, pinpointer);
     }
 
     /// <summary>
@@ -163,15 +185,12 @@ namespace Content.Server.Pinpointer
             return null;
 
         // get world direction vector
-            var dir = (_transform.GetWorldPosition(trg, xformQuery) - _transform.GetWorldPosition(pin, xformQuery));
+        var dir = _transform.GetWorldPosition(trg, xformQuery) - _transform.GetWorldPosition(pin, xformQuery);
         return dir;
     }
 
-        private Distance CalculateDistance(EntityUid uid, Vector2 vec, PinpointerComponent? pinpointer = null)
+    private static Distance CalculateDistance(Vector2 vec, PinpointerComponent pinpointer)
     {
-            if (!Resolve(uid, ref pinpointer))
-                return Distance.Unknown;
-
         var dist = vec.Length;
         if (dist <= pinpointer.ReachedDistance)
             return Distance.Reached;
@@ -183,4 +202,3 @@ namespace Content.Server.Pinpointer
             return Distance.Far;
     }
 }
-}

Content.Shared/Pinpointer/PinpointerComponent.cs

@@ -1,48 +1,52 @@
 using Robust.Shared.GameStates;
 using Robust.Shared.Serialization;
 
-namespace Content.Shared.Pinpointer
+namespace Content.Shared.Pinpointer;
-{
+
 /// <summary>
 /// Displays a sprite on the item that points towards the target component.
 /// </summary>
-    [RegisterComponent]
+[RegisterComponent, NetworkedComponent]
-    [NetworkedComponent]
+[AutoGenerateComponentState]
 [Access(typeof(SharedPinpointerSystem))]
-    public sealed class PinpointerComponent : Component
+public sealed partial class PinpointerComponent : Component
 {
     // TODO: Type serializer oh god
     [DataField("component")]
     public string? Component;
 
-        [DataField("mediumDistance")]
+    [DataField("mediumDistance"), ViewVariables(VVAccess.ReadWrite)]
     public float MediumDistance = 16f;
 
-        [DataField("closeDistance")]
+    [DataField("closeDistance"), ViewVariables(VVAccess.ReadWrite)]
     public float CloseDistance = 8f;
 
-        [DataField("reachedDistance")]
+    [DataField("reachedDistance"), ViewVariables(VVAccess.ReadWrite)]
     public float ReachedDistance = 1f;
 
     /// <summary>
     ///     Pinpointer arrow precision in radians.
     /// </summary>
-        [DataField("precision")]
+    [DataField("precision"), ViewVariables(VVAccess.ReadWrite)]
     public double Precision = 0.09;
 
+    [ViewVariables]
     public EntityUid? Target = null;
-        public bool IsActive = false;
-        public Angle ArrowAngle;
-        public Distance DistanceToTarget = Distance.Unknown;
-        public bool HasTarget => DistanceToTarget != Distance.Unknown;
-    }
 
-    [Serializable, NetSerializable]
+    [ViewVariables]
-    public sealed class PinpointerComponentState : ComponentState
+    [AutoNetworkedField]
-    {
+    public bool IsActive = false;
-        public bool IsActive;
+
+    [ViewVariables]
+    [AutoNetworkedField]
     public Angle ArrowAngle;
-        public Distance DistanceToTarget;
+
+    [ViewVariables]
+    [AutoNetworkedField]
+    public Distance DistanceToTarget = Distance.Unknown;
+
+    [ViewVariables]
+    public bool HasTarget => DistanceToTarget != Distance.Unknown;
 }
 
 [Serializable, NetSerializable]
@@ -54,4 +58,3 @@ namespace Content.Shared.Pinpointer
     Medium,
     Far
 }
-}

Content.Shared/Pinpointer/SharedPinpointerSystem.cs

@@ -1,25 +1,7 @@
-using Robust.Shared.GameStates;
+namespace Content.Shared.Pinpointer;
 
-namespace Content.Shared.Pinpointer
-{
 public abstract class SharedPinpointerSystem : EntitySystem
 {
-        public override void Initialize()
-        {
-            base.Initialize();
-            SubscribeLocalEvent<PinpointerComponent, ComponentGetState>(GetCompState);
-        }
-
-        private void GetCompState(EntityUid uid, PinpointerComponent pinpointer, ref ComponentGetState args)
-        {
-            args.State = new PinpointerComponentState
-            {
-                IsActive = pinpointer.IsActive,
-                ArrowAngle = pinpointer.ArrowAngle,
-                DistanceToTarget = pinpointer.DistanceToTarget
-            };
-        }
-
     /// <summary>
     ///     Manually set distance from pinpointer to target
     /// </summary>
@@ -67,20 +49,4 @@ namespace Content.Shared.Pinpointer
         pinpointer.IsActive = isActive;
         Dirty(pinpointer);
     }
-
-
-        /// <summary>
-        ///     Toggle Pinpointer screen. If it has target it will start tracking it.
-        /// </summary>
-        /// <returns>True if pinpointer was activated, false otherwise</returns>
-        public bool TogglePinpointer(EntityUid uid, PinpointerComponent? pinpointer = null)
-        {
-            if (!Resolve(uid, ref pinpointer))
-                return false;
-
-            var isActive = !pinpointer.IsActive;
-            SetActive(uid, isActive, pinpointer);
-            return isActive;
-        }
-    }
 }

Resources/Prototypes/Entities/Objects/Devices/pinpointer.yml

@@ -8,7 +8,6 @@
   - type: Transform
     noRot: True
   - type: Sprite
-    netsync: false
     noRot: True
     sprite: Objects/Devices/pinpointer.rsi
     layers:
@@ -16,10 +15,26 @@
       map: ["enum.PinpointerLayers.Base"]
     - state: pinonnull
       map: ["enum.PinpointerLayers.Screen"]
+      shader: unshaded
+      visible: false
   - type: Item
     sprite: Objects/Devices/pinpointer.rsi
   - type: Pinpointer
   - type: Appearance
+  - type: GenericVisualizer
+    visuals:
+      enum.PinpointerVisuals.IsActive:
+        enum.PinpointerLayers.Screen:
+          True: { visible: True }
+          False: { visible: False }
+      enum.PinpointerVisuals.TargetDistance:
+        enum.PinpointerLayers.Screen:
+          Unknown: { state: pinonnull }
+          Reached: { state: pinondirect }
+          Close: { state: pinonclose }
+          Medium: { state: pinonmedium }
+          Far: { state: pinonfar }
+  - type: AnimationPlayer
 
 - type: entity
   name: pinpointer