Merge remote-tracking branch 'upstream/master'

Content.Client/_White/SecurityHud/SecurityHudBUI.cs

@@ -0,0 +1,122 @@
+using System.Linq;
+using Content.Client._White.UserInterface.Radial;
+using Content.Shared._White.SecurityHud;
+using Content.Shared.Security;
+using Content.Shared.StatusIcon;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client._White.SecurityHud;
+
+public sealed class SecurityHudBUI : BoundUserInterface
+{
+    private RadialContainer? _radialContainer;
+
+    private bool _updated;
+
+    private readonly Dictionary<string, string> _names = new()
+    {
+        { "SecurityIconDischarged", Loc.GetString("criminal-records-status-discharged")},
+        { "SecurityIconParoled", Loc.GetString("criminal-records-status-paroled")},
+        { "SecurityIconSuspected", Loc.GetString("criminal-records-status-suspected")},
+        { "SecurityIconWanted", Loc.GetString("criminal-records-status-wanted")},
+        { "SecurityIconIncarcerated", Loc.GetString("criminal-records-status-detained")},
+        { "CriminalRecordIconRemove", Loc.GetString("security-hud-remove-status") }
+    };
+
+    private readonly Dictionary<string, string> _icons = new()
+    {
+        { "SecurityIconDischarged", "/Textures/White/Interface/securityhud.rsi/discharged.png" },
+        { "SecurityIconParoled", "/Textures/White/Interface/securityhud.rsi/paroled.png" },
+        { "SecurityIconSuspected", "/Textures/White/Interface/securityhud.rsi/suspected.png" },
+        { "SecurityIconWanted", "/Textures/White/Interface/securityhud.rsi/wanted.png" },
+        { "SecurityIconIncarcerated", "/Textures/White/Interface/securityhud.rsi/incarcerated.png" },
+        { "CriminalRecordIconRemove", "/Textures/White/Interface/securityhud.rsi/remove.png" }
+    };
+
+    private readonly Dictionary<string, SecurityStatus> _status = new()
+    {
+        { "SecurityIconDischarged", SecurityStatus.Discharged },
+        { "SecurityIconParoled", SecurityStatus.Paroled },
+        { "SecurityIconSuspected", SecurityStatus.Suspected },
+        { "SecurityIconWanted", SecurityStatus.Wanted },
+        { "SecurityIconIncarcerated", SecurityStatus.Detained },
+        { "CriminalRecordIconRemove", SecurityStatus.None }
+    };
+
+
+    public SecurityHudBUI(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        if (_radialContainer != null)
+            UIReset();
+
+        _radialContainer = new RadialContainer();
+
+        _radialContainer.Closed += Close;
+
+        if (State != null)
+            UpdateState(State);
+    }
+
+    private void UIReset()
+    {
+        _radialContainer?.Close();
+        _radialContainer = null;
+        _updated = false;
+    }
+
+    private void PopulateRadial(IReadOnlyCollection<string> ids, NetEntity user, NetEntity target)
+    {
+        foreach (var id in ids)
+        {
+            if (_radialContainer == null)
+                continue;
+
+            if(!_names.TryGetValue(id, out var name) || !_icons.TryGetValue(id, out var icon) || !_status.TryGetValue(id, out var status))
+                return;
+
+            var button = _radialContainer.AddButton(name, icon);
+            button.Controller.OnPressed += _ =>
+            {
+                Select(status, user, target);
+            };
+        }
+    }
+
+    private void Select(SecurityStatus status, NetEntity user, NetEntity target)
+    {
+        SendMessage(new SecurityHudStatusSelectedMessage(status, user, target));
+        UIReset();
+        Close();
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+        UIReset();
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        if (_updated)
+            return;
+
+        if (state is SecurityHudBUIState newState)
+        {
+            PopulateRadial(newState.Ids, newState.User, newState.Target);
+        }
+
+        if (_radialContainer == null)
+            return;
+
+        _radialContainer?.OpenAttachedLocalPlayer();
+        _updated = true;
+    }
+}

Content.Client/_White/Telescope/TelescopeSystem.cs

@@ -1,10 +1,12 @@
 using System.Numerics;
+using Content.Client.Viewport;
 using Content.Shared._White.Telescope;
 using Content.Shared.Hands.Components;
 using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
 using Robust.Client.Input;
 using Robust.Client.Player;
+using Robust.Client.UserInterface;
 using Robust.Shared.Input;
 using Robust.Shared.Timing;
 
@@ -17,7 +19,9 @@ public sealed class TelescopeSystem : SharedTelescopeSystem
     [Dependency] private readonly IPlayerManager _player = default!;
     [Dependency] private readonly IInputManager _input = default!;
     [Dependency] private readonly IEyeManager _eyeManager = default!;
-    [Dependency] private readonly IClyde _displayManager = default!;
+    [Dependency] private readonly IUserInterfaceManager _uiManager = default!;
+
+    private ScalingViewport? _viewport;
 
     public override void Update(float frameTime)
     {
@@ -44,14 +48,23 @@ public sealed class TelescopeSystem : SharedTelescopeSystem
             return;
         }
 
-        var mousePos = _input.MouseScreenPosition.Position;
+        var mousePos = _input.MouseScreenPosition;
+
+        if (_uiManager.MouseGetControl(mousePos) as ScalingViewport is { } viewport)
+            _viewport = viewport;
+
+        if (_viewport == null)
+            return;
+
         var centerPos = _eyeManager.WorldToScreen(eye.Eye.Position.Position + eye.Offset);
 
-        var diff = mousePos - centerPos;
+        var diff = mousePos.Position - centerPos;
         var len = diff.Length();
 
-        var maxLength = _displayManager.ScreenSize.Y / 2.5f;
-        var minLength = maxLength / 5f;
+        var size = _viewport.PixelSize;
+
+        var maxLength = Math.Min(size.X, size.Y) * 0.4f;
+        var minLength = maxLength * 0.2f;
 
         if (len > maxLength)
         {
@@ -59,7 +72,7 @@ public sealed class TelescopeSystem : SharedTelescopeSystem
             len = maxLength;
         }
 
-        var divisor = maxLength / 10f * telescope.Divisor;
+        var divisor = maxLength * telescope.Divisor;
 
         if (len > minLength)
         {