Merge branch 'space-wizards:master' into sec-jetpack

.editorconfig

@@ -344,6 +344,9 @@ resharper_keep_existing_attribute_arrangement = true
 resharper_wrap_chained_binary_patterns = chop_if_long
 resharper_wrap_chained_method_calls = chop_if_long
 resharper_csharp_trailing_comma_in_multiline_lists = true
+resharper_csharp_qualified_using_at_nested_scope = false
+resharper_csharp_prefer_qualified_reference = false
+resharper_csharp_allow_alias = false
 
 [*.{csproj,xml,yml,yaml,dll.config,msbuildproj,targets,props}]
 indent_size = 2

Content.Client/Medical/CrewMonitoring/CrewMonitoringWindow.xaml.cs

@@ -25,6 +25,7 @@ public sealed partial class CrewMonitoringWindow : FancyWindow
 {
     [Dependency] private readonly IEntityManager _entManager = default!;
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    private readonly SharedTransformSystem _transformSystem;
     private readonly SpriteSystem _spriteSystem;
 
     private NetEntity? _trackedEntity;
@@ -36,10 +37,10 @@ public CrewMonitoringWindow()
         RobustXamlLoader.Load(this);
         IoCManager.InjectDependencies(this);
 
+        _transformSystem = _entManager.System<SharedTransformSystem>();
         _spriteSystem = _entManager.System<SpriteSystem>();
 
         NavMap.TrackedEntitySelectedAction += SetTrackedEntityFromNavMap;
-
     }
 
     public void Set(string stationName, EntityUid? mapUid)
@@ -290,7 +291,7 @@ private void PopulateDepartmentList(IEnumerable<SuitSensorStatus> departmentSens
             {
                 NavMap.TrackedEntities.TryAdd(sensor.SuitSensorUid,
                     new NavMapBlip
-                    (coordinates.Value,
+                    (CoordinatesToLocal(coordinates.Value),
                     _blipTexture,
                     (_trackedEntity == null || sensor.SuitSensorUid == _trackedEntity) ? Color.LimeGreen : Color.LimeGreen * Color.DimGray,
                     sensor.SuitSensorUid == _trackedEntity));
@@ -356,7 +357,7 @@ private void UpdateSensorsTable(NetEntity? currTrackedEntity, NetEntity? prevTra
             if (NavMap.TrackedEntities.TryGetValue(castSensor.SuitSensorUid, out var data))
             {
                 data = new NavMapBlip
-                    (data.Coordinates,
+                    (CoordinatesToLocal(data.Coordinates),
                     data.Texture,
                     (currTrackedEntity == null || castSensor.SuitSensorUid == currTrackedEntity) ? Color.LimeGreen : Color.LimeGreen * Color.DimGray,
                     castSensor.SuitSensorUid == currTrackedEntity);
@@ -421,6 +422,26 @@ private bool TryGetNextScrollPosition([NotNullWhen(true)] out float? nextScrollP
         return false;
     }
 
+    /// <summary>
+    /// Converts the input coordinates to an EntityCoordinates which are in
+    /// reference to the grid that the map is displaying. This is a stylistic
+    /// choice; this window deliberately limits the rate that blips update,
+    /// but if the blip is attached to another grid which is moving, that
+    /// blip will move smoothly, unlike the others. By converting the
+    /// coordinates, we are back in control of the blip movement.
+    /// </summary>
+    private EntityCoordinates CoordinatesToLocal(EntityCoordinates refCoords)
+    {
+        if (NavMap.MapUid != null)
+        {
+            return _transformSystem.WithEntityId(refCoords, (EntityUid)NavMap.MapUid);
+        }
+        else
+        {
+            return refCoords;
+        }
+    }
+
     private void ClearOutDatedData()
     {
         SensorsTable.RemoveAllChildren();

Content.Client/Movement/Components/EyeCursorOffsetComponent.cs

@@ -0,0 +1,19 @@
+using System.Numerics;
+using Content.Client.Movement.Systems;
+using Content.Shared.Movement.Components;
+
+namespace Content.Client.Movement.Components;
+
+[RegisterComponent]
+public sealed partial class EyeCursorOffsetComponent : SharedEyeCursorOffsetComponent
+{
+    /// <summary>
+    /// The location the offset will attempt to pan towards; based on the cursor's position in the game window.
+    /// </summary>
+    public Vector2 TargetPosition = Vector2.Zero;
+
+    /// <summary>
+    /// The current positional offset being applied. Used to enable gradual panning.
+    /// </summary>
+    public Vector2 CurrentPosition = Vector2.Zero;
+}

Content.Client/Movement/Systems/ContentEyeSystem.cs

@@ -1,6 +1,7 @@
 using System.Numerics;
 using Content.Shared.Movement.Components;
 using Content.Shared.Movement.Systems;
+using Robust.Client.GameObjects;
 using Robust.Client.Player;
 
 namespace Content.Client.Movement.Systems;
@@ -52,4 +53,14 @@ public void RequestEye(bool drawFov, bool drawLight)
     {
         RaisePredictiveEvent(new RequestEyeEvent(drawFov, drawLight));
     }
+
+    public override void FrameUpdate(float frameTime)
+    {
+        base.FrameUpdate(frameTime);
+        var eyeEntities = AllEntityQuery<ContentEyeComponent, EyeComponent>();
+        while (eyeEntities.MoveNext(out var entity, out ContentEyeComponent? contentComponent, out EyeComponent? eyeComponent))
+        {
+            UpdateEyeOffset((entity, eyeComponent));
+        }
+    }
 }

Content.Client/Movement/Systems/EyeCursorOffsetSystem.cs

@@ -0,0 +1,91 @@
+using System.Numerics;
+using Content.Client.Movement.Components;
+using Content.Shared.Camera;
+using Content.Shared.Inventory;
+using Content.Shared.Movement.Systems;
+using Robust.Client.Graphics;
+using Robust.Client.Input;
+using Robust.Shared.Map;
+using Robust.Client.Player;
+
+namespace Content.Client.Movement.Systems;
+
+public partial class EyeCursorOffsetSystem : EntitySystem
+{
+    [Dependency] private readonly IEyeManager _eyeManager = default!;
+    [Dependency] private readonly IInputManager _inputManager = default!;
+    [Dependency] private readonly IPlayerManager _player = default!;
+    [Dependency] private readonly SharedTransformSystem _transform = default!;
+    [Dependency] private readonly SharedContentEyeSystem _contentEye = default!;
+    [Dependency] private readonly IMapManager _mapManager = default!;
+    [Dependency] private readonly IClyde _clyde = default!;
+
+    // This value is here to make sure the user doesn't have to move their mouse
+    // all the way out to the edge of the screen to get the full offset.
+    static private float _edgeOffset = 0.9f;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<EyeCursorOffsetComponent, GetEyeOffsetEvent>(OnGetEyeOffsetEvent);
+    }
+
+    private void OnGetEyeOffsetEvent(EntityUid uid, EyeCursorOffsetComponent component, ref GetEyeOffsetEvent args)
+    {
+        var offset = OffsetAfterMouse(uid, component);
+        if (offset == null)
+            return;
+
+        args.Offset += offset.Value;
+    }
+
+    public Vector2? OffsetAfterMouse(EntityUid uid, EyeCursorOffsetComponent? component)
+    {
+        var localPlayer = _player.LocalPlayer?.ControlledEntity;
+        var mousePos = _inputManager.MouseScreenPosition;
+        var screenSize = _clyde.MainWindow.Size;
+        var minValue = MathF.Min(screenSize.X / 2, screenSize.Y / 2) * _edgeOffset;
+
+        var mouseNormalizedPos = new Vector2(-(mousePos.X - screenSize.X / 2) / minValue, (mousePos.Y - screenSize.Y / 2) / minValue); // X needs to be inverted here for some reason, otherwise it ends up flipped.
+
+        if (localPlayer == null)
+            return null;
+
+        var playerPos = _transform.GetWorldPosition(localPlayer.Value);
+
+        if (component == null)
+        {
+            component = EnsureComp<EyeCursorOffsetComponent>(uid);
+        }
+
+        // Doesn't move the offset if the mouse has left the game window!
+        if (mousePos.Window != WindowId.Invalid)
+        {
+            // The offset must account for the in-world rotation.
+            var eyeRotation = _eyeManager.CurrentEye.Rotation;
+            var mouseActualRelativePos = Vector2.Transform(mouseNormalizedPos, System.Numerics.Quaternion.CreateFromAxisAngle(-System.Numerics.Vector3.UnitZ, (float)(eyeRotation.Opposite().Theta))); // I don't know, it just works.
+
+            // Caps the offset into a circle around the player.
+            mouseActualRelativePos *= component.MaxOffset;
+            if (mouseActualRelativePos.Length() > component.MaxOffset)
+            {
+                mouseActualRelativePos = mouseActualRelativePos.Normalized() * component.MaxOffset;
+            }
+
+            component.TargetPosition = mouseActualRelativePos;
+
+            //Makes the view not jump immediately when moving the cursor fast.
+            if (component.CurrentPosition != component.TargetPosition)
+            {
+                Vector2 vectorOffset = component.TargetPosition - component.CurrentPosition;
+                if (vectorOffset.Length() > component.OffsetSpeed)
+                {
+                    vectorOffset = vectorOffset.Normalized() * component.OffsetSpeed;
+                }
+                component.CurrentPosition += vectorOffset;
+            }
+        }
+        return component.CurrentPosition;
+    }
+}

Content.Client/Overlays/ShowMindShieldIconsSystem.cs

@@ -15,6 +15,16 @@ public override void Initialize()
         base.Initialize();
 
         SubscribeLocalEvent<MindShieldComponent, GetStatusIconsEvent>(OnGetStatusIconsEvent);
+        SubscribeLocalEvent<FakeMindShieldComponent, GetStatusIconsEvent>(OnGetStatusIconsEventFake);
+    }
+    // TODO: Probably need to get this OFF of client since this can be read by bad actors rather easily
+    //  ...imagine cheating in a game about silly paper dolls
+    private void OnGetStatusIconsEventFake(EntityUid uid, FakeMindShieldComponent component, ref GetStatusIconsEvent ev)
+    {
+        if(!IsActive)
+            return;
+        if (component.IsEnabled && _prototype.TryIndex(component.MindShieldStatusIcon, out var fakeStatusIconPrototype))
+            ev.StatusIcons.Add(fakeStatusIconPrototype);
     }
 
     private void OnGetStatusIconsEvent(EntityUid uid, MindShieldComponent component, ref GetStatusIconsEvent ev)

Content.Client/Storage/StorageBoundUserInterface.cs

@@ -1,39 +1,80 @@
-using Content.Client.Storage.Systems;
+using Content.Client.UserInterface.Systems.Storage;
+using Content.Client.UserInterface.Systems.Storage.Controls;
 using Content.Shared.Storage;
 using JetBrains.Annotations;
+using Robust.Client.UserInterface;
 
 namespace Content.Client.Storage;
 
 [UsedImplicitly]
 public sealed class StorageBoundUserInterface : BoundUserInterface
 {
-    [Dependency] private readonly IEntityManager _entManager = default!;
-
-    private readonly StorageSystem _storage;
-
-    [Obsolete] public override bool DeferredClose => false;
+    private StorageWindow? _window;
 
     public StorageBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
     {
-        IoCManager.InjectDependencies(this);
-        _storage = _entManager.System<StorageSystem>();
     }
 
     protected override void Open()
     {
         base.Open();
 
-        if (_entManager.TryGetComponent<StorageComponent>(Owner, out var comp))
-            _storage.OpenStorageWindow((Owner, comp));
+        _window = IoCManager.Resolve<IUserInterfaceManager>()
+            .GetUIController<StorageUIController>()
+            .CreateStorageWindow(Owner);
+
+        if (EntMan.TryGetComponent(Owner, out StorageComponent? storage))
+        {
+            _window.UpdateContainer((Owner, storage));
+        }
+
+        _window.OnClose += Close;
+        _window.FlagDirty();
+    }
+
+    public void Refresh()
+    {
+        _window?.FlagDirty();
+    }
+
+    public void Reclaim()
+    {
+        if (_window == null)
+            return;
+
+        _window.OnClose -= Close;
+        _window.Orphan();
+        _window = null;
     }
 
     protected override void Dispose(bool disposing)
     {
         base.Dispose(disposing);
-        if (!disposing)
+
+        Reclaim();
+    }
+
+    public void Hide()
+    {
+        if (_window == null)
+            return;
+
+        _window.Visible = false;
+    }
+
+    public void Show()
+    {
+        if (_window == null)
             return;
 
-        _storage.CloseStorageWindow(Owner);
+        _window.Visible = true;
+    }
+
+    public void ReOpen()
+    {
+        _window?.Orphan();
+        _window = null;
+        Open();
     }
 }