Merge branch 'master' into buckle-locker-fix-1262

Content.Client/ClientPreferencesManager.cs

@@ -26,6 +26,7 @@ namespace Content.Client
         {
             _netManager.RegisterNetMessage<MsgPreferencesAndSettings>(nameof(MsgPreferencesAndSettings),
                 HandlePreferencesAndSettings);
+            _netManager.RegisterNetMessage<MsgUpdateCharacter>(nameof(MsgUpdateCharacter));
         }
 
         public void SelectCharacter(ICharacterProfile profile)

Content.Client/EntryPoint.cs

@@ -124,9 +124,12 @@ namespace Content.Client
         /// Remove the character interface master from this entity now that we have detached ourselves from it
         /// </summary>
         public static void DetachPlayerFromEntity(EntityDetachedEventArgs eventArgs)
+        {
+            if (!eventArgs.OldEntity.Deleted)
             {
                 eventArgs.OldEntity.RemoveComponent<CharacterInterface>();
             }
+        }
 
         public override void PostInit()
         {

Content.Client/EscapeMenuOwner.cs

@@ -6,6 +6,7 @@ using Robust.Client.Interfaces.Placement;
 using Robust.Client.Interfaces.ResourceManagement;
 using Robust.Client.Interfaces.State;
 using Robust.Shared.Input;
+using Robust.Shared.Input.Binding;
 using Robust.Shared.Interfaces.Configuration;
 using Robust.Shared.Interfaces.Map;
 using Robust.Shared.IoC;

Content.Client/GameObjects/Components/Items/ItemComponent.cs

@@ -1,4 +1,6 @@
-using Content.Shared.GameObjects;
+using Content.Client.GameObjects.Components.Storage;
+using Content.Client.Interfaces.GameObjects.Components.Interaction;
+using Content.Shared.GameObjects;
 using Content.Shared.GameObjects.Components.Items;
 using Robust.Client.Graphics;
 using Robust.Client.Interfaces.ResourceManagement;

Content.Client/GameObjects/Components/Mobs/BuckleComponent.cs

@@ -1,16 +1,19 @@
-using Content.Shared.GameObjects.Components.Mobs;
+using Content.Client.GameObjects.Components.Strap;
+using Content.Client.Interfaces.GameObjects.Components.Interaction;
+using Content.Shared.GameObjects.Components.Mobs;
 using Robust.Client.GameObjects;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Maths;
 
 namespace Content.Client.GameObjects.Components.Mobs
 {
     [RegisterComponent]
-    public class BuckleComponent : SharedBuckleComponent
+    public class BuckleComponent : SharedBuckleComponent, IClientDraggable
     {
         private bool _buckled;
         private int? _originalDrawDepth;
 
+        protected override bool Buckled => _buckled;
+
         public override void HandleComponentState(ComponentState curState, ComponentState nextState)
         {
             if (!(curState is BuckleComponentState buckle))
@@ -39,6 +42,14 @@ namespace Content.Client.GameObjects.Components.Mobs
             }
         }
 
-        protected override bool Buckled => _buckled;
+        bool IClientDraggable.ClientCanDropOn(CanDropEventArgs eventArgs)
+        {
+            return eventArgs.Target.HasComponent<StrapComponent>();
+        }
+
+        bool IClientDraggable.ClientCanDrag(CanDragEventArgs eventArgs)
+        {
+            return true;
+        }
     }
 }

Content.Client/GameObjects/Components/Mobs/BuckleVisualizer2D.cs

@@ -17,7 +17,7 @@ namespace Content.Client.GameObjects.Components.Mobs
                 return;
             }
 
-            if (!component.TryGetData<int>(SharedStrapComponent.StrapVisuals.RotationAngle, out var angle))
+            if (!component.TryGetData<int>(StrapVisuals.RotationAngle, out var angle))
             {
                 return;
             }

Content.Client/GameObjects/Components/Mobs/ClientOverlayEffectsComponent.cs

@@ -1,18 +1,21 @@
-using System.Collections.Generic;
+using System;
-using Content.Client.Graphics.Overlays;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
 using Content.Shared.GameObjects.Components.Mobs;
+using Content.Shared.Interfaces;
 using Robust.Client.GameObjects;
 using Robust.Client.Graphics.Overlays;
 using Robust.Client.Interfaces.Graphics.Overlays;
-using Robust.Client.Player;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Network;
+using Robust.Shared.Interfaces.Reflection;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
-using Robust.Shared.Players;
+using Robust.Shared.Utility;
+using Robust.Shared.ViewVariables;
 
-namespace Content.Client.GameObjects
+namespace Content.Client.GameObjects.Components.Mobs
 {
     /// <summary>
     /// A character UI component which shows the current damage state of the mob (living/dead)
@@ -21,48 +24,33 @@ namespace Content.Client.GameObjects
     [ComponentReference(typeof(SharedOverlayEffectsComponent))]
     public sealed class ClientOverlayEffectsComponent : SharedOverlayEffectsComponent//, ICharacterUI
     {
-
         /// <summary>
         /// An enum representing the current state being applied to the user
         /// </summary>
-        private ScreenEffects _currentEffect = ScreenEffects.None;
+        private readonly List<OverlayContainer> _currentEffects = new List<OverlayContainer>();
+
+        [ViewVariables(VVAccess.ReadOnly)]
+        public List<OverlayContainer> ActiveOverlays
+        {
+            get => _currentEffects;
+            set => SetEffects(value);
+        }
 
 #pragma warning disable 649
         // Required dependencies
         [Dependency] private readonly IOverlayManager _overlayManager;
-        [Dependency] private readonly IPlayerManager _playerManager;
+        [Dependency] private readonly IReflectionManager _reflectionManager;
 #pragma warning restore 649
 
-        /// <summary>
-        /// Holds the screen effects that can be applied mapped ot their relevant overlay
-        /// </summary>
-        private Dictionary<ScreenEffects, Overlay> _effectsDictionary;
-
-        /// <summary>
-        /// Allows calculating if we need to act due to this component being controlled by the current mob
-        /// </summary>
-        private bool CurrentlyControlled => _playerManager.LocalPlayer.ControlledEntity == Owner;
-
-        public override void OnAdd()
-        {
-            base.OnAdd();
-
-            _effectsDictionary = new Dictionary<ScreenEffects, Overlay>()
-            {
-                { ScreenEffects.CircleMask, new CircleMaskOverlay() },
-                { ScreenEffects.GradientCircleMask, new GradientCircleMask() }
-            };
-        }
-
         public override void HandleMessage(ComponentMessage message, IComponent component)
         {
             switch (message)
             {
                 case PlayerAttachedMsg _:
-                    SetOverlay(_currentEffect);
+                    SetEffects(ActiveOverlays);
                     break;
                 case PlayerDetachedMsg _:
-                    RemoveOverlay();
+                    ActiveOverlays = new List<OverlayContainer>();
                     break;
             }
         }
@@ -70,42 +58,77 @@ namespace Content.Client.GameObjects
         public override void HandleComponentState(ComponentState curState, ComponentState nextState)
         {
             base.HandleComponentState(curState, nextState);
-            if (!(curState is OverlayEffectComponentState state) || _currentEffect == state.ScreenEffect) return;
+            if (!(curState is OverlayEffectComponentState state) || ActiveOverlays.Equals(state.Overlays))
-            SetOverlay(state.ScreenEffect);
-        }
-
-        private void SetOverlay(ScreenEffects effect)
-        {
-            RemoveOverlay();
-
-            _currentEffect = effect;
-
-            ApplyOverlay();
-        }
-
-        private void RemoveOverlay()
-        {
-            if (CurrentlyControlled && _currentEffect != ScreenEffects.None)
-            {
-                var appliedEffect = _effectsDictionary[_currentEffect];
-                _overlayManager.RemoveOverlay(appliedEffect.ID);
-            }
-
-            _currentEffect = ScreenEffects.None;
-        }
-
-        private void ApplyOverlay()
-        {
-            if (CurrentlyControlled && _currentEffect != ScreenEffects.None)
-            {
-                var overlay = _effectsDictionary[_currentEffect];
-                if (_overlayManager.HasOverlay(overlay.ID))
             {
                 return;
             }
-                _overlayManager.AddOverlay(overlay);
+
-                Logger.InfoS("overlay", $"Changed overlay to {overlay}");
+            ActiveOverlays = state.Overlays;
         }
+
+        private void SetEffects(List<OverlayContainer> newOverlays)
+        {
+            foreach (var container in ActiveOverlays.ShallowClone())
+            {
+                if (!newOverlays.Contains(container))
+                {
+                    RemoveOverlay(container);
+                }
+            }
+
+            foreach (var container in newOverlays)
+            {
+                if (!ActiveOverlays.Contains(container))
+                {
+                    AddOverlay(container);
+                }
+            }
+        }
+
+        private void RemoveOverlay(OverlayContainer container)
+        {
+            ActiveOverlays.Remove(container);
+            _overlayManager.RemoveOverlay(container.ID);
+        }
+
+        private void AddOverlay(OverlayContainer container)
+        {
+            ActiveOverlays.Add(container);
+            if (TryCreateOverlay(container, out var overlay))
+            {
+                _overlayManager.AddOverlay(overlay);
+            }
+            else
+            {
+                Logger.ErrorS("overlay", $"Could not add overlay {container.ID}");
+            }
+        }
+
+        private bool TryCreateOverlay(OverlayContainer container, out Overlay overlay)
+        {
+            var overlayTypes = _reflectionManager.GetAllChildren<Overlay>();
+            var foundType = overlayTypes.FirstOrDefault(t => t.Name == container.ID);
+
+            if (foundType != null)
+            {
+                overlay = Activator.CreateInstance(foundType) as Overlay;
+                var configurable = foundType
+                    .GetInterfaces()
+                    .FirstOrDefault(type =>
+                        type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IConfigurable<>)
+                                           && type.GenericTypeArguments.First() == container.GetType());
+
+                if (configurable != null)
+                {
+                    var method = overlay?.GetType().GetMethod("Configure");
+                    method?.Invoke(overlay, new []{ container });
+                }
+
+                return true;
+            }
+
+            overlay = default;
+            return false;
         }
     }
 }

Content.Client/GameObjects/Components/PlaceableSurfaceComponent.cs

@@ -0,0 +1,11 @@
+using Content.Shared.GameObjects.Components;
+using Robust.Shared.GameObjects;
+
+namespace Content.Client.GameObjects.Components
+{
+    [RegisterComponent]
+    public class PlaceableSurfaceComponent : SharedPlaceableSurfaceComponent
+    {
+
+    }
+}

Content.Client/GameObjects/Components/Storage/ClientStorageComponent.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using Content.Shared.GameObjects.Components.Storage;
 using Content.Client.Interfaces.GameObjects;
+using Content.Client.Interfaces.GameObjects.Components.Interaction;
 using Robust.Client.Graphics.Drawing;
 using Robust.Client.Interfaces.GameObjects.Components;
 using Robust.Client.UserInterface;
@@ -21,7 +22,7 @@ namespace Content.Client.GameObjects.Components.Storage
     /// Client version of item storage containers, contains a UI which displays stored entities and their size
     /// </summary>
     [RegisterComponent]
-    public class ClientStorageComponent : SharedStorageComponent
+    public class ClientStorageComponent : SharedStorageComponent, IClientDraggable
     {
         private Dictionary<EntityUid, int> StoredEntities { get; set; } = new Dictionary<EntityUid, int>();
         private int StorageSizeUsed;
@@ -316,5 +317,17 @@ namespace Content.Client.GameObjects.Components.Storage
                 AddChild(hBoxContainer);
             }
         }
+
+        public bool ClientCanDropOn(CanDropEventArgs eventArgs)
+        {
+            //can only drop on placeable surfaces to empty out contents
+            return eventArgs.Target.HasComponent<PlaceableSurfaceComponent>();
+        }
+
+        public bool ClientCanDrag(CanDragEventArgs eventArgs)
+        {
+            //always draggable, at least for now
+            return true;
+        }
     }
 }

Content.Client/GameObjects/Components/Strap/StrapComponent.cs

@@ -0,0 +1,22 @@
+#nullable enable
+using Content.Shared.GameObjects.Components.Strap;
+using Robust.Shared.GameObjects;
+
+namespace Content.Client.GameObjects.Components.Strap
+{
+    [RegisterComponent]
+    public class StrapComponent : SharedStrapComponent
+    {
+        public override StrapPosition Position { get; protected set; }
+
+        public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)
+        {
+            if (!(curState is StrapComponentState strap))
+            {
+                return;
+            }
+
+            Position = strap.Position;
+        }
+    }
+}

Content.Client/GameObjects/EntitySystems/DragDropSystem.cs

@@ -0,0 +1,397 @@
+using System.Collections.Generic;
+using Content.Client.Interfaces.GameObjects.Components.Interaction;
+using Content.Client.State;
+using Content.Shared.GameObjects;
+using Content.Shared.GameObjects.EntitySystemMessages;
+using Content.Shared.GameObjects.EntitySystems;
+using JetBrains.Annotations;
+using Robust.Client.GameObjects;
+using Robust.Client.GameObjects.EntitySystems;
+using Robust.Client.Graphics.Shaders;
+using Robust.Client.Interfaces.Graphics.ClientEye;
+using Robust.Client.Interfaces.Input;
+using Robust.Client.Interfaces.State;
+using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.Input;
+using Robust.Shared.Input.Binding;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.Interfaces.Map;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Robust.Shared.Maths;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client.GameObjects.EntitySystems
+{
+    /// <summary>
+    /// Handles clientside drag and drop logic
+    /// </summary>
+    [UsedImplicitly]
+    public class DragDropSystem : EntitySystem
+    {
+        // drag will be triggered when mouse leaves this deadzone around the click position.
+        private const float DragDeadzone = 2f;
+        // how often to recheck possible targets (prevents calling expensive
+        // check logic each update)
+        private const float TargetRecheckInterval = 0.25f;
+
+        // if a drag ends up being cancelled and it has been under this
+        // amount of time since the mousedown, we will "replay" the original
+        // mousedown event so it can be treated like a regular click
+        private const float MaxMouseDownTimeForReplayingClick = 0.85f;
+
+        private const string ShaderDropTargetInRange = "SelectionOutlineInrange";
+        private const string ShaderDropTargetOutOfRange = "SelectionOutline";
+
+#pragma warning disable 649
+        [Dependency] private readonly IStateManager _stateManager;
+        [Dependency] private readonly IEntityManager _entityManager;
+        [Dependency] private readonly IInputManager _inputManager;
+        [Dependency] private readonly IEyeManager _eyeManager;
+        [Dependency] private readonly IPrototypeManager _prototypeManager;
+        [Dependency] private readonly IMapManager _mapManager;
+#pragma warning restore 649
+
+        // entity performing the drag action
+        private IEntity _dragger;
+        private IEntity _draggedEntity;
+        private IClientDraggable _draggable;
+        private IEntity _dragShadow;
+        private DragState _state;
+        // time since mouse down over the dragged entity
+        private float _mouseDownTime;
+        // screen pos where the mouse down began
+        private Vector2 _mouseDownScreenPos;
+        // how much time since last recheck of all possible targets
+        private float _targetRecheckTime;
+        // reserved initial mousedown event so we can replay it if no drag ends up being performed
+        private PointerInputCmdHandler.PointerInputCmdArgs? _savedMouseDown;
+        // whether we are currently replaying the original mouse down, so we
+        // can ignore any events sent to this system
+        private bool _isReplaying;
+
+        private ShaderInstance _dropTargetInRangeShader;
+        private ShaderInstance _dropTargetOutOfRangeShader;
+        private SharedInteractionSystem _interactionSystem;
+        private InputSystem _inputSystem;
+
+        private List<SpriteComponent> highlightedSprites = new List<SpriteComponent>();
+
+        private enum DragState
+        {
+            NotDragging,
+            // not dragging yet, waiting to see
+            // if they hold for long enough
+            MouseDown,
+            // currently dragging something
+            Dragging,
+        }
+
+
+        public override void Initialize()
+        {
+            _state = DragState.NotDragging;
+
+            _dropTargetInRangeShader = _prototypeManager.Index<ShaderPrototype>(ShaderDropTargetInRange).Instance();
+            _dropTargetOutOfRangeShader = _prototypeManager.Index<ShaderPrototype>(ShaderDropTargetOutOfRange).Instance();
+            _interactionSystem = EntitySystem.Get<SharedInteractionSystem>();
+            _inputSystem = EntitySystem.Get<InputSystem>();
+            // needs to fire on mouseup and mousedown so we can detect a drag / drop
+            CommandBinds.Builder
+                .Bind(EngineKeyFunctions.Use, new PointerInputCmdHandler(OnUse, false))
+                .Register<DragDropSystem>();
+
+        }
+
+        public override void Shutdown()
+        {
+            CancelDrag(false, null);
+            CommandBinds.Unregister<DragDropSystem>();
+            base.Shutdown();
+        }
+
+        private bool OnUse(in PointerInputCmdHandler.PointerInputCmdArgs args)
+        {
+            // not currently predicted
+            if (_inputSystem.Predicted) return false;
+
+            // currently replaying a saved click, don't handle this because
+            // we already decided this click doesn't represent an actual drag attempt
+            if (_isReplaying) return false;
+
+            if (args.State == BoundKeyState.Down)
+            {
+                return OnUseMouseDown(args);
+            }
+            else if (args.State == BoundKeyState.Up)
+            {
+                return OnUseMouseUp(args);
+            }
+
+            return false;
+        }
+
+        private bool OnUseMouseDown(in PointerInputCmdHandler.PointerInputCmdArgs args)
+        {
+            var dragger = args.Session.AttachedEntity;
+            // cancel any current dragging if there is one (shouldn't be because they would've had to have lifted
+            // the mouse, canceling the drag, but just being cautious)
+            CancelDrag(false, null);
+
+            // possibly initiating a drag
+            // check if the clicked entity is draggable
+            if (_entityManager.TryGetEntity(args.EntityUid, out var entity))
+            {
+                // check if the entity is reachable
+                if (_interactionSystem.InRangeUnobstructed(dragger.Transform.MapPosition,
+                    entity.Transform.MapPosition, ignoredEnt: dragger) == false)
+                {
+                    {
+                        return false;
+                    }
+                }
+                foreach (var draggable in entity.GetAllComponents<IClientDraggable>())
+                {
+                    var dragEventArgs = new CanDragEventArgs(args.Session.AttachedEntity, entity);
+                    if (draggable.ClientCanDrag(dragEventArgs))
+                    {
+                        // wait to initiate a drag
+                        _dragger = dragger;
+                        _draggedEntity = entity;
+                        _draggable = draggable;
+                        _mouseDownTime = 0;
+                        _state = DragState.MouseDown;
+                        _mouseDownScreenPos = _inputManager.MouseScreenPosition;
+                        // don't want anything else to process the click,
+                        // but we will save the event so we can "re-play" it if this drag does
+                        // not turn into an actual drag so the click can be handled normally
+                        _savedMouseDown = args;
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private bool OnUseMouseUp(in PointerInputCmdHandler.PointerInputCmdArgs args)
+        {
+            if (_state == DragState.MouseDown)
+            {
+                // quick mouseup, definitely treat it as a normal click by
+                // replaying the original
+                CancelDrag(true, args.OriginalMessage);
+                return false;
+            }
+            if (_state != DragState.Dragging) return false;
+
+            // remaining CancelDrag calls will not replay the click because
+            // by this time we've determined the input was actually a drag attempt
+
+
+            // tell the server we are dropping if we are over a valid drop target in range.
+            // We don't use args.EntityUid here because drag interactions generally should
+            // work even if there's something "on top" of the drop target
+            if (_interactionSystem.InRangeUnobstructed(_dragger.Transform.MapPosition,
+                    args.Coordinates.ToMap(_mapManager), ignoredEnt: _dragger) == false)
+            {
+                {
+                    CancelDrag(false, null);
+                    return false;
+                }
+            }
+
+            var entities = GameScreenBase.GetEntitiesUnderPosition(_stateManager, args.Coordinates);
+            foreach (var entity in entities)
+            {
+                // check if it's able to be dropped on by current dragged entity
+                if (_draggable.ClientCanDropOn(new CanDropEventArgs(_dragger, _draggedEntity, entity)))
+                {
+                    // tell the server about the drop attempt
+                    RaiseNetworkEvent(new DragDropMessage(args.Coordinates, _draggedEntity.Uid,
+                        entity.Uid));
+
+                    CancelDrag(false, null);
+                    return true;
+                }
+            }
+            CancelDrag(false, null);
+            return false;
+        }
+
+        private void StartDragging()
+        {
+            // this is checked elsewhere but adding this as a failsafe
+            if (_draggedEntity == null || _draggedEntity.Deleted)
+            {
+                Logger.Error("Programming error. Cannot initiate drag, no dragged entity or entity" +
+                               " was deleted.");
+                return;
+            }
+
+            if (_draggedEntity.TryGetComponent<SpriteComponent>(out var draggedSprite))
+            {
+                _state = DragState.Dragging;
+                // pop up drag shadow under mouse
+                var mousePos = _eyeManager.ScreenToMap(_inputManager.MouseScreenPosition);
+                _dragShadow = _entityManager.SpawnEntity("dragshadow", mousePos);
+                var dragSprite = _dragShadow.GetComponent<SpriteComponent>();
+                dragSprite.CopyFrom(draggedSprite);
+                dragSprite.RenderOrder = EntityManager.CurrentTick.Value;
+                dragSprite.Color = dragSprite.Color.WithAlpha(0.7f);
+                // keep it on top of everything
+                dragSprite.DrawDepth = (int) DrawDepth.Overlays;
+
+                HighlightTargets();
+            }
+            else
+            {
+                Logger.Warning("Unable to display drag shadow for {0} because it" +
+                               " has no sprite component.", _draggedEntity.Name);
+            }
+        }
+
+        private void HighlightTargets()
+        {
+            if (_state != DragState.Dragging || _draggedEntity == null ||
+                _draggedEntity.Deleted || _dragShadow == null || _dragShadow.Deleted)
+            {
+                Logger.Warning("Programming error. Can't highlight drag and drop targets, not currently " +
+                               "dragging anything or dragged entity / shadow was deleted.");
+                return;
+            }
+
+            // highlights the possible targets which are visible
+            // and able to be dropped on by the current dragged entity
+
+            // remove current highlights
+            RemoveHighlights();
+
+            // find possible targets on screen even if not reachable
+            // TODO: Duplicated in SpriteSystem
+            var pvsBounds = _eyeManager.GetWorldViewport().Enlarged(5);
+            var pvsEntities = EntityManager.GetEntitiesIntersecting(_eyeManager.CurrentMap, pvsBounds, true);
+            foreach (var pvsEntity in pvsEntities)
+            {
+                if (pvsEntity.TryGetComponent<SpriteComponent>(out var inRangeSprite))
+                {
+                    // can't highlight if there's no sprite or it's not visible
+                    if (inRangeSprite.Visible == false) continue;
+
+                    // check if it's able to be dropped on by current dragged entity
+                    if (_draggable.ClientCanDropOn(new CanDropEventArgs(_dragger, _draggedEntity, pvsEntity)))
+                    {
+                        // highlight depending on whether its in or out of range
+                        var inRange = _interactionSystem.InRangeUnobstructed(_dragger.Transform.MapPosition,
+                            pvsEntity.Transform.MapPosition, ignoredEnt: _dragger);
+                        inRangeSprite.PostShader = inRange ? _dropTargetInRangeShader : _dropTargetOutOfRangeShader;
+                        inRangeSprite.RenderOrder = EntityManager.CurrentTick.Value;
+                        highlightedSprites.Add(inRangeSprite);
+                    }
+                }
+            }
+        }
+
+        private void RemoveHighlights()
+        {
+            foreach (var highlightedSprite in highlightedSprites)
+            {
+                highlightedSprite.PostShader = null;
+                highlightedSprite.RenderOrder = 0;
+            }
+            highlightedSprites.Clear();
+        }
+
+        /// <summary>
+        /// Cancels the drag, firing our saved drag event if instructed to do so and
+        /// we are within the threshold for replaying the click
+        /// (essentially reverting the drag attempt and allowing the original click
+        /// to proceed as if no drag was performed)
+        /// </summary>
+        /// <param name="cause">if fireSavedCmd is true, this should be passed with the value of
+        ///  the pointer cmd that caused the drag to be cancelled</param>
+        private void CancelDrag(bool fireSavedCmd, FullInputCmdMessage cause)
+        {
+            RemoveHighlights();
+            if (_dragShadow != null)
+            {
+                _entityManager.DeleteEntity(_dragShadow);
+            }
+
+            _dragShadow = null;
+            _draggedEntity = null;
+            _draggable = null;
+            _dragger = null;
+            _state = DragState.NotDragging;
+
+            _mouseDownTime = 0;
+
+            if (fireSavedCmd && _savedMouseDown.HasValue && _mouseDownTime < MaxMouseDownTimeForReplayingClick)
+            {
+                var savedValue = _savedMouseDown.Value;
+                _isReplaying = true;
+                // adjust the timing info based on the current tick so it appears as if it happened now
+                var replayMsg = savedValue.OriginalMessage;
+                var adjustedInputMsg = new FullInputCmdMessage(cause.Tick, cause.SubTick, replayMsg.InputFunctionId, replayMsg.State, replayMsg.Coordinates, replayMsg.ScreenCoordinates, replayMsg.Uid);
+
+                _inputSystem.HandleInputCommand(savedValue.Session, EngineKeyFunctions.Use,
+                    adjustedInputMsg, true);
+                _isReplaying = false;
+            }
+
+            _savedMouseDown = null;
+
+        }
+
+        public override void Update(float frameTime)
+        {
+            base.Update(frameTime);
+            if (_state == DragState.MouseDown)
+            {
+                var screenPos = _inputManager.MouseScreenPosition;
+                if (_draggedEntity == null || _draggedEntity.Deleted)
+                {
+                    // something happened to the clicked entity or we moved the mouse off the target so
+                    // we shouldn't replay the original click
+                    CancelDrag(false, null);
+                    return;
+                }
+                else if ((_mouseDownScreenPos - screenPos).Length > DragDeadzone)
+                {
+                    // initiate actual drag
+                    StartDragging();
+                    _mouseDownTime = 0;
+                }
+            }
+            else if (_state == DragState.Dragging)
+            {
+                if (_draggedEntity == null || _draggedEntity.Deleted)
+                {
+                    CancelDrag(false, null);
+                    return;
+                }
+                // still in range of the thing we are dragging?
+                if (_interactionSystem.InRangeUnobstructed(_dragger.Transform.MapPosition,
+                        _draggedEntity.Transform.MapPosition, ignoredEnt: _dragger) == false)
+                {
+                    CancelDrag(false, null);
+                    return;
+                }
+
+                // keep dragged entity under mouse
+                var mousePos = _eyeManager.ScreenToMap(_inputManager.MouseScreenPosition);
+                // TODO: would use MapPosition instead if it had a setter, but it has no setter.
+                // is that intentional, or should we add a setter for Transform.MapPosition?
+                _dragShadow.Transform.WorldPosition = mousePos.Position;
+
+                _targetRecheckTime += frameTime;
+                if (_targetRecheckTime > TargetRecheckInterval)
+                {
+                    HighlightTargets();
+                    _targetRecheckTime = 0;
+                }
+
+            }
+        }
+    }
+}

Content.Client/GameObjects/EntitySystems/MoverSystem.cs

@@ -46,7 +46,7 @@ namespace Content.Client.GameObjects.EntitySystems
 
         protected override void SetController(PhysicsComponent physics)
         {
-            ((PhysicsComponent)physics).SetController<MoverController>();
+            physics.SetController<MoverController>();
         }
     }
 }

Content.Client/Graphics/Overlays/CircleMaskOverlay.cs

@@ -1,4 +1,5 @@
-using Robust.Client.Graphics.Drawing;
+using Content.Shared.GameObjects.Components.Mobs;
+using Robust.Client.Graphics.Drawing;
 using Robust.Client.Graphics.Overlays;
 using Robust.Client.Graphics.Shaders;
 using Robust.Client.Interfaces.Graphics.ClientEye;
@@ -17,7 +18,7 @@ namespace Content.Client.Graphics.Overlays
 
         public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-        public CircleMaskOverlay() : base(nameof(CircleMaskOverlay))
+        public CircleMaskOverlay() : base(nameof(OverlayType.CircleMaskOverlay))
         {
             IoCManager.InjectDependencies(this);
             Shader = _prototypeManager.Index<ShaderPrototype>("CircleMask").Instance();

Content.Client/Graphics/Overlays/FlashOverlay.cs

@@ -0,0 +1,73 @@
+using System.Net.Mime;
+using Content.Shared.GameObjects.Components.Mobs;
+using Content.Shared.Interfaces;
+using Robust.Client.Graphics;
+using Robust.Client.Graphics.Drawing;
+using Robust.Client.Graphics.Overlays;
+using Robust.Client.Graphics.Shaders;
+using Robust.Client.Interfaces.Graphics;
+using Robust.Client.Interfaces.Graphics.ClientEye;
+using Robust.Shared.Interfaces.Timing;
+using Robust.Shared.IoC;
+using Robust.Shared.Maths;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
+using Color = Robust.Shared.Maths.Color;
+
+namespace Content.Client.Graphics.Overlays
+{
+    public class FlashOverlay : Overlay, IConfigurable<TimedOverlayContainer>
+    {
+#pragma warning disable 649
+        [Dependency] private readonly IPrototypeManager _prototypeManager;
+        [Dependency] private readonly IClyde _displayManager;
+        [Dependency] private readonly IGameTiming _gameTiming;
+#pragma warning restore 649
+
+        public override OverlaySpace Space => OverlaySpace.ScreenSpace;
+        private double _startTime;
+        private int lastsFor = 5000;
+        private Texture _screenshotTexture;
+
+        public FlashOverlay() : base(nameof(OverlayType.FlashOverlay))
+        {
+            IoCManager.InjectDependencies(this);
+            Shader = _prototypeManager.Index<ShaderPrototype>("FlashedEffect").Instance().Duplicate();
+
+            _startTime = _gameTiming.CurTime.TotalMilliseconds;
+            _displayManager.Screenshot(ScreenshotType.BeforeUI, image =>
+            {
+                var rgba32Image = image.CloneAs<Rgba32>(Configuration.Default);
+                _screenshotTexture = _displayManager.LoadTextureFromImage(rgba32Image);
+            });
+        }
+
+        protected override void Draw(DrawingHandleBase handle)
+        {
+            var percentComplete = (float) ((_gameTiming.CurTime.TotalMilliseconds - _startTime) / lastsFor);
+            Shader?.SetParameter("percentComplete", percentComplete);
+
+            var screenSpaceHandle = handle as DrawingHandleScreen;
+            var screenSize = UIBox2.FromDimensions((0, 0), _displayManager.ScreenSize);
+
+            if (_screenshotTexture != null)
+            {
+                screenSpaceHandle?.DrawTextureRect(_screenshotTexture, screenSize);
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            base.Dispose(disposing);
+
+            _screenshotTexture = null;
+        }
+
+        public void Configure(TimedOverlayContainer parameters)
+        {
+            lastsFor = parameters.Length;
+        }
+    }
+}

Content.Client/Graphics/Overlays/GradientCircleMask.cs

@@ -1,4 +1,5 @@
-using Robust.Client.Graphics.Drawing;
+using Content.Shared.GameObjects.Components.Mobs;
+using Robust.Client.Graphics.Drawing;
 using Robust.Client.Graphics.Overlays;
 using Robust.Client.Graphics.Shaders;
 using Robust.Client.Interfaces.Graphics.ClientEye;
@@ -8,7 +9,7 @@ using Robust.Shared.Prototypes;
 
 namespace Content.Client.Graphics.Overlays
 {
-    public class GradientCircleMask : Overlay
+    public class GradientCircleMaskOverlay : Overlay
     {
 #pragma warning disable 649
         [Dependency] private readonly IPrototypeManager _prototypeManager;
@@ -16,7 +17,7 @@ namespace Content.Client.Graphics.Overlays
 #pragma warning restore 649
         public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-        public GradientCircleMask() : base(nameof(GradientCircleMask))
+        public GradientCircleMaskOverlay() : base(nameof(OverlayType.GradientCircleMaskOverlay))
         {
             IoCManager.InjectDependencies(this);
             Shader = _prototypeManager.Index<ShaderPrototype>("GradientCircleMask").Instance();

Content.Client/IgnoredComponents.cs

@@ -25,7 +25,6 @@
             "ItemTeleporter",
             "Portal",
             "EntityStorage",
-            "PlaceableSurface",
             "Wirecutter",
             "Screwdriver",
             "Multitool",
@@ -116,7 +115,6 @@
             "Utensil",
             "UnarmedCombat",
             "TimedSpawner",
-            "Strap",
             "NodeContainer",
             "PowerSupplier",
             "PowerConsumer",

Content.Client/Input/ContentContexts.cs

@@ -13,6 +13,7 @@ namespace Content.Client.Input
         {
             var common = contexts.GetContext("common");
             common.AddFunction(ContentKeyFunctions.FocusChat);
+            common.AddFunction(ContentKeyFunctions.FocusOOC);
             common.AddFunction(ContentKeyFunctions.ExamineEntity);
             common.AddFunction(ContentKeyFunctions.OpenTutorial);
             common.AddFunction(ContentKeyFunctions.TakeScreenshot);

Content.Client/Interfaces/GameObjects/Components/Interaction/IClientDraggable.cs

@@ -0,0 +1,59 @@
+using System;
+using Robust.Shared.Interfaces.GameObjects;
+
+namespace Content.Client.Interfaces.GameObjects.Components.Interaction
+{
+    /// <summary>
+    /// This interface allows a local client to initiate dragging of the component's entity by mouse, for drag and
+    /// drop interactions. The actual logic of what happens on drop
+    /// is handled by IDragDrop
+    /// </summary>
+    public interface IClientDraggable
+    {
+
+        /// <summary>
+        /// Invoked on entities visible to the user to check if this component's entity
+        /// can be dropped on the indicated target entity. No need to check range / reachability in here.
+        /// </summary>
+        /// <returns>true iff target is a valid target to be dropped on by this
+        /// component's entity. Returning true will cause the target entity to be highlighted as a potential
+        /// target and allow dropping when in range.</returns>
+        bool ClientCanDropOn(CanDropEventArgs eventArgs);
+
+        /// <summary>
+        /// Invoked clientside when user is attempting to initiate a drag with this component's entity
+        /// in range. Return true if the drag should be initiated. It's fine to
+        /// return true even if there wouldn't be any valid targets - just return true
+        /// if this entity is in a "draggable" state.
+        /// </summary>
+        /// <param name="eventArgs"></param>
+        /// <returns>true iff drag should be initiated</returns>
+        bool ClientCanDrag(CanDragEventArgs eventArgs);
+    }
+
+    public class CanDropEventArgs : EventArgs
+    {
+        public CanDropEventArgs(IEntity user, IEntity dragged, IEntity target)
+        {
+            User = user;
+            Dragged = dragged;
+            Target = target;
+        }
+
+        public IEntity User { get; }
+        public IEntity Dragged { get; }
+        public IEntity Target { get; }
+    }
+
+    public class CanDragEventArgs : EventArgs
+    {
+        public CanDragEventArgs(IEntity user, IEntity dragged)
+        {
+            User = user;
+            Dragged = dragged;
+        }
+
+        public IEntity User { get; }
+        public IEntity Dragged { get; }
+    }
+}

Content.Client/Sandbox/SandboxManager.cs

@@ -8,6 +8,7 @@ using Robust.Client.Interfaces.ResourceManagement;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Shared.Input;
+using Robust.Shared.Input.Binding;
 using Robust.Shared.Interfaces.Map;
 using Robust.Shared.Interfaces.Network;
 using Robust.Shared.IoC;
@@ -36,7 +37,7 @@ namespace Content.Client.Sandbox
         private SandboxWindow _window;
         private EntitySpawnWindow _spawnWindow;
         private TileSpawnWindow _tilesSpawnWindow;
-        private bool _sandboxWindowToggled = false;
+        private bool _sandboxWindowToggled;
 
         public void Initialize()
         {
@@ -114,6 +115,7 @@ namespace Content.Client.Sandbox
         {
             _window = null;
             _gameHud.SandboxButtonDown = false;
+            _sandboxWindowToggled = false;
         }
 
         private void OnRespawnButtonOnOnPressed(BaseButton.ButtonEventArgs args)

Content.Client/ScreenshotHook.cs

@@ -5,6 +5,7 @@ using Content.Shared.Input;
 using Robust.Client.Interfaces.Graphics;
 using Robust.Client.Interfaces.Input;
 using Robust.Shared.Input;
+using Robust.Shared.Input.Binding;
 using Robust.Shared.Interfaces.Resources;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;

Content.Client/State/GameScreen.cs

@@ -1,13 +1,19 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
 using Content.Client.Chat;
 using Content.Client.Interfaces.Chat;
 using Content.Client.UserInterface;
 using Content.Shared.Input;
 using Robust.Client.Interfaces.Input;
+using Robust.Client.Interfaces.State;
 using Robust.Client.Interfaces.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Shared.Input;
+using Robust.Shared.Input.Binding;
+using Robust.Shared.Interfaces.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Localization;
+using Robust.Shared.Map;
 using Robust.Shared.ViewVariables;
 
 namespace Content.Client.State
@@ -41,6 +47,9 @@ namespace Content.Client.State
 
             _inputManager.SetInputCommand(ContentKeyFunctions.FocusChat,
                 InputCmdHandler.FromDelegate(s => FocusChat(_gameChat)));
+
+            _inputManager.SetInputCommand(ContentKeyFunctions.FocusOOC,
+                InputCmdHandler.FromDelegate(s => FocusOOC(_gameChat)));
         }
 
         public override void Shutdown()
@@ -61,5 +70,16 @@ namespace Content.Client.State
             chat.Input.IgnoreNext = true;
             chat.Input.GrabKeyboardFocus();
         }
+        internal static void FocusOOC(ChatBox chat)
+        {
+            if (chat == null || chat.UserInterfaceManager.KeyboardFocused != null)
+            {
+                return;
+            }
+
+            chat.Input.IgnoreNext = true;
+            chat.Input.GrabKeyboardFocus();
+            chat.Input.InsertAtCursor("[");
+        }
     }
 }

Content.Client/State/GameScreenBase.cs

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using Content.Client.GameObjects.Components;
-using Content.Shared.GameObjects;
 using Content.Shared.GameObjects.EntitySystems;
 using Robust.Client.GameObjects.EntitySystems;
 using Robust.Client.Interfaces.GameObjects;
@@ -9,6 +9,7 @@ using Robust.Client.Interfaces.GameObjects.Components;
 using Robust.Client.Interfaces.Graphics.ClientEye;
 using Robust.Client.Interfaces.Input;
 using Robust.Client.Interfaces.UserInterface;
+using Robust.Client.Interfaces.State;
 using Robust.Client.Player;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Input;
@@ -71,7 +72,7 @@ namespace Content.Client.State
                     .InRangeUnobstructed(playerPos, entityPos,
                         predicate: entity =>
                             entity == _playerManager.LocalPlayer.ControlledEntity || entity == entityToClick,
-                        insideBlockerValid: true);
+                        ignoreInsideBlocker: true);
             }
 
             InteractionOutlineComponent outline;
@@ -146,6 +147,25 @@ namespace Content.Client.State
             return foundEntities.Select(a => a.clicked).ToList();
         }
 
+        /// <summary>
+        /// Gets all entities intersecting the given position.
+        ///
+        /// Static alternative to GetEntitiesUnderPosition to cut out
+        /// some of the boilerplate needed to get state manager and check the current state.
+        /// </summary>
+        /// <param name="stateManager">state manager to use to get the current game screen</param>
+        /// <param name="coordinates">coordinates to check</param>
+        /// <returns>the entities under the position, empty list if none found</returns>
+        public static IList<IEntity> GetEntitiesUnderPosition(IStateManager stateManager, GridCoordinates coordinates)
+        {
+            if (stateManager.CurrentState is GameScreenBase gameScreenBase)
+            {
+                return gameScreenBase.GetEntitiesUnderPosition(coordinates);
+            }
+
+            return ImmutableList<IEntity>.Empty;
+        }
+
         internal class ClickableEntityComparer : IComparer<(IEntity clicked, int depth, uint renderOrder)>
         {
             public int Compare((IEntity clicked, int depth, uint renderOrder) x,

Content.Client/State/LobbyState.cs

@@ -12,6 +12,7 @@ using Robust.Client.Interfaces.UserInterface;
 using Robust.Client.Player;
 using Robust.Client.UserInterface.Controls;
 using Robust.Shared.Input;
+using Robust.Shared.Input.Binding;
 using Robust.Shared.Interfaces.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Localization;

Content.Client/UserInterface/GameHud.cs

@@ -9,6 +9,7 @@ using Robust.Client.Interfaces.ResourceManagement;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Shared.Input;
+using Robust.Shared.Input.Binding;
 using Robust.Shared.IoC;
 using Robust.Shared.Localization;
 using Robust.Shared.Maths;

Content.Client/UserInterface/HumanoidProfileEditor.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Content.Client.GameObjects.Components;
@@ -6,6 +6,7 @@ using Content.Client.Interfaces;
 using Content.Client.Utility;
 using Content.Shared;
 using Content.Shared.Jobs;
+using Content.Shared.Antags;
 using Content.Shared.Preferences;
 using Robust.Client.Graphics.Drawing;
 using Robust.Client.UserInterface;
@@ -42,6 +43,7 @@ namespace Content.Client.UserInterface
         private readonly FacialHairStylePicker _facialHairPicker;
         private readonly List<JobPrioritySelector> _jobPriorities;
         private readonly OptionButton _preferenceUnavailableButton;
+        private readonly List<AntagPreferenceSelector> _antagPreferences;
 
         private bool _isDirty;
         public int CharacterSlot;
@@ -320,6 +322,52 @@ namespace Content.Client.UserInterface
 
             #endregion
 
+            #region Antags
+
+            {
+                var antagList = new VBoxContainer();
+
+                var antagVBox = new VBoxContainer
+                {
+                    Children =
+                    {
+                        new ScrollContainer
+                        {
+                            SizeFlagsVertical = SizeFlags.FillExpand,
+                            Children =
+                            {
+                                antagList
+                            }
+                        }
+                    }
+                };
+
+                tabContainer.AddChild(antagVBox);
+
+                tabContainer.SetTabTitle(2, Loc.GetString("Antags"));
+
+                _antagPreferences = new List<AntagPreferenceSelector>();
+
+                foreach (var antag in prototypeManager.EnumeratePrototypes<AntagPrototype>().OrderBy(a => a.Name))
+                {
+                    if(!antag.SetPreference)
+                    {
+                        continue;
+                    }
+                    var selector = new AntagPreferenceSelector(antag);
+                    antagList.AddChild(selector);
+                    _antagPreferences.Add(selector);
+
+                    selector.PreferenceChanged += preference =>
+                    {
+                        Profile = Profile.WithAntagPreference(antag.ID, preference);
+                        IsDirty = true;
+                    };
+                }
+            }
+
+            #endregion
+
             var rightColumn = new VBoxContainer();
             middleContainer.AddChild(rightColumn);
 
@@ -466,6 +514,7 @@ namespace Content.Client.UserInterface
             UpdateHairPickers();
             UpdateSaveButton();
             UpdateJobPriorities();
+            UpdateAntagPreferences();
 
             _preferenceUnavailableButton.SelectId((int) Profile.PreferenceUnavailable);
         }
@@ -533,5 +582,51 @@ namespace Content.Client.UserInterface
                 });
             }
         }
+
+        private void UpdateAntagPreferences()
+        {
+            foreach (var preferenceSelector in _antagPreferences)
+            {
+                var antagId = preferenceSelector.Antag.ID;
+
+                var preference = Profile.AntagPreferences.Contains(antagId);
+
+                preferenceSelector.Preference = preference;
+            }
+        }
+
+        private class AntagPreferenceSelector : Control
+        {
+            public AntagPrototype Antag { get; }
+            private readonly CheckBox _checkBox;
+
+            public bool Preference
+            {
+                get => _checkBox.Pressed;
+                set => _checkBox.Pressed = value;
+            }
+
+            public event Action<bool> PreferenceChanged;
+
+            public AntagPreferenceSelector(AntagPrototype antag)
+            {
+                Antag = antag;
+
+                _checkBox = new CheckBox {Text = $"{antag.Name}"};
+                _checkBox.OnToggled += OnCheckBoxToggled;
+
+                AddChild(new HBoxContainer
+                {
+                    Children =
+                    {
+                        _checkBox
+                    }
+                });
+            }
+            private void OnCheckBoxToggled(BaseButton.ButtonToggledEventArgs args)
+            {
+                PreferenceChanged?.Invoke(Preference);
+            }
+        }
     }
 }

Content.Client/UserInterface/TutorialWindow.cs

@@ -75,6 +75,7 @@ Open inventory: [color=#a4885c]{7}[/color]
 Open character window: [color=#a4885c]{8}[/color]
 Open crafting window: [color=#a4885c]{9}[/color]
 Focus chat: [color=#a4885c]{10}[/color]
+Focus OOC: [color=#a4885c]{26}[/color]
 Use hand/object in hand: [color=#a4885c]{22}[/color]
 Do wide attack: [color=#a4885c]{23}[/color]
 Use targeted entity: [color=#a4885c]{11}[/color]
@@ -110,7 +111,8 @@ Toggle sandbox window: [color=#a4885c]{21}[/color]",
                 Key(Use),
                 Key(WideAttack),
                 Key(SmartEquipBackpack),
-                Key(SmartEquipBelt)));
+                Key(SmartEquipBelt),
+                Key(FocusOOC)));
 
             //Gameplay
             VBox.AddChild(new Label { FontOverride = headerFont, Text = "\nGameplay" });

Content.Server.Database/Migrations/Postgres/20200706172726_Antags.Designer.cs

@@ -0,0 +1,185 @@
+// <auto-generated />
+using Content.Server.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace Content.Server.Database.Migrations.Postgres
+{
+    [DbContext(typeof(PostgresPreferencesDbContext))]
+    [Migration("20200706172726_Antags")]
+    partial class Antags
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn)
+                .HasAnnotation("ProductVersion", "3.1.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.Property<int>("AntagId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("AntagName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("HumanoidProfileId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("AntagId");
+
+                    b.HasIndex("HumanoidProfileId", "AntagName")
+                        .IsUnique();
+
+                    b.ToTable("Antag");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.HumanoidProfile", b =>
+                {
+                    b.Property<int>("HumanoidProfileId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("CharacterName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EyeColor")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FacialHairColor")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FacialHairName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("HairColor")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("HairName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("PreferenceUnavailable")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PrefsId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Sex")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SkinColor")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Slot")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SlotName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("HumanoidProfileId");
+
+                    b.HasIndex("PrefsId");
+
+                    b.HasIndex("Slot", "PrefsId")
+                        .IsUnique();
+
+                    b.ToTable("HumanoidProfile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.Property<int>("JobId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProfileHumanoidProfileId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("ProfileHumanoidProfileId");
+
+                    b.ToTable("Job");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Prefs", b =>
+                {
+                    b.Property<int>("PrefsId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int>("SelectedCharacterSlot")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("PrefsId");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Preferences");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.HasOne("Content.Server.Database.HumanoidProfile", "Profile")
+                        .WithMany("Antags")
+                        .HasForeignKey("HumanoidProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Content.Server.Database.HumanoidProfile", b =>
+                {
+                    b.HasOne("Content.Server.Database.Prefs", "Prefs")
+                        .WithMany("HumanoidProfiles")
+                        .HasForeignKey("PrefsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.HasOne("Content.Server.Database.HumanoidProfile", "Profile")
+                        .WithMany("Jobs")
+                        .HasForeignKey("ProfileHumanoidProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Content.Server.Database/Migrations/Postgres/20200706172726_Antags.cs

@@ -0,0 +1,43 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace Content.Server.Database.Migrations.Postgres
+{
+    public partial class Antags : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Antag",
+                columns: table => new
+                {
+                    AntagId = table.Column<int>(nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    HumanoidProfileId = table.Column<int>(nullable: false),
+                    AntagName = table.Column<string>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Antag", x => x.AntagId);
+                    table.ForeignKey(
+                        name: "FK_Antag_HumanoidProfile_HumanoidProfileId",
+                        column: x => x.HumanoidProfileId,
+                        principalTable: "HumanoidProfile",
+                        principalColumn: "HumanoidProfileId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Antag_HumanoidProfileId_AntagName",
+                table: "Antag",
+                columns: new[] { "HumanoidProfileId", "AntagName" },
+                unique: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Antag");
+        }
+    }
+}

Content.Server.Database/Migrations/Postgres/PostgresPreferencesDbContextModelSnapshot.cs

@@ -18,6 +18,28 @@ namespace Content.Server.Database.Migrations.Postgres
                 .HasAnnotation("ProductVersion", "3.1.4")
                 .HasAnnotation("Relational:MaxIdentifierLength", 63);
 
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.Property<int>("AntagId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("AntagName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("HumanoidProfileId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("AntagId");
+
+                    b.HasIndex("HumanoidProfileId", "AntagName")
+                        .IsUnique();
+
+                    b.ToTable("Antag");
+                });
+
             modelBuilder.Entity("Content.Server.Database.HumanoidProfile", b =>
                 {
                     b.Property<int>("HumanoidProfileId")
@@ -129,6 +151,15 @@ namespace Content.Server.Database.Migrations.Postgres
                     b.ToTable("Preferences");
                 });
 
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.HasOne("Content.Server.Database.HumanoidProfile", "Profile")
+                        .WithMany("Antags")
+                        .HasForeignKey("HumanoidProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Content.Server.Database.HumanoidProfile", b =>
                 {
                     b.HasOne("Content.Server.Database.Prefs", "Prefs")

Content.Server.Database/Migrations/Sqlite/20200706172741_Antags.Designer.cs

@@ -0,0 +1,178 @@
+// <auto-generated />
+using Content.Server.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace Content.Server.Database.Migrations.Sqlite
+{
+    [DbContext(typeof(SqlitePreferencesDbContext))]
+    [Migration("20200706172741_Antags")]
+    partial class Antags
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "3.1.4");
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.Property<int>("AntagId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AntagName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("HumanoidProfileId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("AntagId");
+
+                    b.HasIndex("HumanoidProfileId", "AntagName")
+                        .IsUnique();
+
+                    b.ToTable("Antag");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.HumanoidProfile", b =>
+                {
+                    b.Property<int>("HumanoidProfileId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Age")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("CharacterName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EyeColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("FacialHairColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("FacialHairName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HairColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HairName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PreferenceUnavailable")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PrefsId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Sex")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SkinColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Slot")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SlotName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("HumanoidProfileId");
+
+                    b.HasIndex("PrefsId");
+
+                    b.HasIndex("Slot", "PrefsId")
+                        .IsUnique();
+
+                    b.ToTable("HumanoidProfile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.Property<int>("JobId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProfileHumanoidProfileId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("JobId");
+
+                    b.HasIndex("ProfileHumanoidProfileId");
+
+                    b.ToTable("Job");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Prefs", b =>
+                {
+                    b.Property<int>("PrefsId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SelectedCharacterSlot")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("PrefsId");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Preferences");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.HasOne("Content.Server.Database.HumanoidProfile", "Profile")
+                        .WithMany("Antags")
+                        .HasForeignKey("HumanoidProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Content.Server.Database.HumanoidProfile", b =>
+                {
+                    b.HasOne("Content.Server.Database.Prefs", "Prefs")
+                        .WithMany("HumanoidProfiles")
+                        .HasForeignKey("PrefsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.HasOne("Content.Server.Database.HumanoidProfile", "Profile")
+                        .WithMany("Jobs")
+                        .HasForeignKey("ProfileHumanoidProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Content.Server.Database/Migrations/Sqlite/20200706172741_Antags.cs

@@ -0,0 +1,42 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Content.Server.Database.Migrations.Sqlite
+{
+    public partial class Antags : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Antag",
+                columns: table => new
+                {
+                    AntagId = table.Column<int>(nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    HumanoidProfileId = table.Column<int>(nullable: false),
+                    AntagName = table.Column<string>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Antag", x => x.AntagId);
+                    table.ForeignKey(
+                        name: "FK_Antag_HumanoidProfile_HumanoidProfileId",
+                        column: x => x.HumanoidProfileId,
+                        principalTable: "HumanoidProfile",
+                        principalColumn: "HumanoidProfileId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Antag_HumanoidProfileId_AntagName",
+                table: "Antag",
+                columns: new[] { "HumanoidProfileId", "AntagName" },
+                unique: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Antag");
+        }
+    }
+}

Content.Server.Database/Migrations/Sqlite/SqlitePreferencesDbContextModelSnapshot.cs

@@ -15,6 +15,27 @@ namespace Content.Server.Database.Migrations
             modelBuilder
                 .HasAnnotation("ProductVersion", "3.1.4");
 
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.Property<int>("AntagId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AntagName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("HumanoidProfileId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("AntagId");
+
+                    b.HasIndex("HumanoidProfileId", "AntagName")
+                        .IsUnique();
+
+                    b.ToTable("Antag");
+                });
+
             modelBuilder.Entity("Content.Server.Database.HumanoidProfile", b =>
                 {
                     b.Property<int>("HumanoidProfileId")
@@ -123,6 +144,15 @@ namespace Content.Server.Database.Migrations
                     b.ToTable("Preferences");
                 });
 
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.HasOne("Content.Server.Database.HumanoidProfile", "Profile")
+                        .WithMany("Antags")
+                        .HasForeignKey("HumanoidProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Content.Server.Database.HumanoidProfile", b =>
                 {
                     b.HasOne("Content.Server.Database.Prefs", "Prefs")

Content.Server.Database/Model.cs

@@ -64,6 +64,10 @@ namespace Content.Server.Database
             modelBuilder.Entity<HumanoidProfile>()
                 .HasIndex(p => new {p.Slot, p.PrefsId})
                 .IsUnique();
+
+            modelBuilder.Entity<Antag>()
+                .HasIndex(p => new {p.HumanoidProfileId , p.AntagName})
+                .IsUnique();
         }
     }
 
@@ -90,6 +94,7 @@ namespace Content.Server.Database
         public string EyeColor { get; set; } = null!;
         public string SkinColor { get; set; } = null!;
         public List<Job> Jobs { get; } = new List<Job>();
+        public List<Antag> Antags { get; } = new List<Antag>();
         public DbPreferenceUnavailableMode PreferenceUnavailable { get; set; }
 
         public int PrefsId { get; set; }
@@ -114,6 +119,15 @@ namespace Content.Server.Database
         High = 3
     }
 
+    public class Antag
+    {
+        public int AntagId { get; set; }
+        public HumanoidProfile Profile { get; set; } = null!;
+        public int HumanoidProfileId { get; set; }
+
+        public string AntagName { get; set; } = null!;
+    }
+
     public enum DbPreferenceUnavailableMode
     {
         // These enum values HAVE to match the ones in PreferenceUnavailableMode in Shared.

Content.Server.Database/PrefsDb.cs

@@ -26,8 +26,8 @@ namespace Content.Server.Database
         {
             return await _prefsCtx
                 .Preferences
-                .Include(p => p.HumanoidProfiles)
+                .Include(p => p.HumanoidProfiles).ThenInclude(h => h.Jobs)
-                .ThenInclude(h => h.Jobs)
+                .Include(p => p.HumanoidProfiles).ThenInclude(h => h.Antags)
                 .SingleOrDefaultAsync(p => p.Username == username);
         }
 
@@ -72,6 +72,7 @@ namespace Content.Server.Database
         {
             return await _prefsCtx.HumanoidProfile
                 .Include(p => p.Jobs)
+                .Include(a => a.Antags)
                 .Join(_prefsCtx.Preferences,
                     profile => new {profile.Slot, profile.PrefsId},
                     prefs => new {Slot = prefs.SelectedCharacterSlot, prefs.PrefsId},

Content.Server/AI/Operators/Combat/Melee/SwingMeleeWeaponOperator.cs

@@ -2,6 +2,7 @@ using Content.Server.GameObjects;
 using Content.Server.GameObjects.Components.Mobs;
 using Content.Server.GameObjects.Components.Weapon.Melee;
 using Content.Server.GameObjects.EntitySystems;
+using Content.Server.GameObjects.EntitySystems.Click;
 using Robust.Shared.Interfaces.GameObjects;
 using Robust.Shared.IoC;
 

Content.Server/AI/Operators/Combat/Melee/UnarmedCombatOperator.cs

@@ -2,6 +2,7 @@ using Content.Server.GameObjects;
 using Content.Server.GameObjects.Components.Mobs;
 using Content.Server.GameObjects.Components.Weapon.Melee;
 using Content.Server.GameObjects.EntitySystems;
+using Content.Server.GameObjects.EntitySystems.Click;
 using Robust.Shared.Interfaces.GameObjects;
 using Robust.Shared.IoC;
 

Content.Server/AI/Operators/Inventory/CloseStorageOperator.cs

@@ -1,8 +1,7 @@
 using Content.Server.AI.Utility;
 using Content.Server.AI.WorldState.States.Inventory;
 using Content.Server.GameObjects.Components;
-using Content.Server.GameObjects.Components.Items.Storage;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
-using Content.Server.GameObjects.EntitySystems;
 using Content.Server.Utility;
 using Robust.Shared.Interfaces.GameObjects;
 

Content.Server/AI/Operators/Inventory/InteractWithEntityOperator.cs

@@ -1,5 +1,5 @@
 using Content.Server.GameObjects.Components.Mobs;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.GameObjects.EntitySystems.Click;
 using Content.Server.Utility;
 using Robust.Shared.Interfaces.GameObjects;
 using Robust.Shared.IoC;

Content.Server/AI/Operators/Inventory/OpenStorageOperator.cs

@@ -1,8 +1,7 @@
 using Content.Server.AI.Utility;
 using Content.Server.AI.WorldState.States.Inventory;
 using Content.Server.GameObjects.Components;
-using Content.Server.GameObjects.Components.Items.Storage;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
-using Content.Server.GameObjects.EntitySystems;
 using Content.Server.Utility;
 using Content.Shared.GameObjects.EntitySystems;
 using Robust.Shared.Containers;

Content.Server/AI/Operators/Inventory/PickupEntityOperator.cs

@@ -1,6 +1,5 @@
 using Content.Server.GameObjects;
-using Content.Server.GameObjects.Components.Items.Storage;
+using Content.Server.GameObjects.EntitySystems.Click;
-using Content.Server.GameObjects.EntitySystems;
 using Content.Server.Utility;
 using Robust.Shared.Containers;
 using Robust.Shared.Interfaces.GameObjects;

Content.Server/AI/Operators/Inventory/UseItemInHandsOperator.cs

@@ -31,7 +31,7 @@ namespace Content.Server.AI.Operators.Inventory
                 return Outcome.Failed;
             }
 
-            if (_target.TryGetComponent(out ItemComponent itemComponent))
+            if (!_target.TryGetComponent(out ItemComponent itemComponent))
             {
                 return Outcome.Failed;
             }

Content.Server/AI/Utility/Considerations/ActionBlocker/CanMoveCon.cs

@@ -1,6 +1,8 @@
 using Content.Server.AI.Utility.Curves;
 using Content.Server.AI.WorldState;
 using Content.Server.AI.WorldState.States;
+using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Shared.GameObjects.EntitySystems;
 
 namespace Content.Server.AI.Utility.Considerations.ActionBlocker

Content.Server/Chat/ChatManager.cs

@@ -1,6 +1,6 @@
 using System.Linq;
 using Content.Server.GameObjects.Components.Observer;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces;
 using Content.Server.Interfaces.Chat;
 using Content.Server.Observer;

Content.Server/EntryPoint.cs

@@ -61,6 +61,7 @@ namespace Content.Server
             IoCManager.Resolve<IServerPreferencesManager>().StartInit();
             IoCManager.Resolve<INodeGroupFactory>().Initialize();
             IoCManager.Resolve<INodeFactory>().Initialize();
+            IoCManager.Resolve<ISandboxManager>().Initialize();
         }
 
         public override void PostInit()
@@ -69,7 +70,6 @@ namespace Content.Server
 
             IoCManager.Resolve<IServerPreferencesManager>().FinishInit();
             _gameTicker.Initialize();
-            IoCManager.Resolve<ISandboxManager>().Initialize();
             IoCManager.Resolve<RecipeManager>().Initialize();
             IoCManager.Resolve<BlackboardManager>().Initialize();
             IoCManager.Resolve<IPDAUplinkManager>().Initialize();

Content.Server/Explosions/ExplosionHelper.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Content.Server.GameObjects.Components.Mobs;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Shared.Maps;
 using Robust.Server.GameObjects;
 using Robust.Server.GameObjects.EntitySystems;

Content.Server/GameObjects/Components/Access/IdCardConsoleComponent.cs

@@ -2,6 +2,7 @@ using System.Collections.Generic;
 using System.Linq;
 using Content.Server.GameObjects.Components.Items.Storage;
 using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces;
 using Content.Server.Interfaces.GameObjects;
 using Content.Server.Utility;

Content.Server/GameObjects/Components/AnchorableComponent.cs

@@ -1,5 +1,5 @@
-using Content.Server.GameObjects.Components.Interactable;
+using Content.Server.GameObjects.Components.Interactable;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Shared.GameObjects.Components.Interactable;
 using Robust.Shared.GameObjects;
 using Robust.Shared.GameObjects.Components;

Content.Server/GameObjects/Components/Cargo/CargoConsoleComponent.cs

@@ -1,6 +1,7 @@
 using Content.Server.Cargo;
 using Content.Server.GameObjects.Components.Power.ApcNetComponents;
 using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Shared.GameObjects.Components.Cargo;
 using Content.Shared.Prototypes.Cargo;
 using JetBrains.Annotations;

Content.Server/GameObjects/Components/Chemistry/InjectorComponent.cs

@@ -1,6 +1,6 @@
 using System;
 using Content.Server.GameObjects.Components.Metabolism;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces;
 using Content.Server.Utility;
 using Content.Shared.Chemistry;

Content.Server/GameObjects/Components/Chemistry/PourableComponent.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Text;
 using Content.Server.GameObjects.Components.Nutrition;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces;
 using Content.Server.Utility;
 using Content.Shared.Chemistry;

Content.Server/GameObjects/Components/Chemistry/ReagentDispenserComponent.cs

@@ -2,7 +2,7 @@
 using System.Linq;
 using Content.Server.GameObjects.Components.Items.Storage;
 using Content.Server.GameObjects.Components.Sound;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.GameObjects.Components.Power;
 using Content.Server.Interfaces;
 using Content.Server.Interfaces.GameObjects;

Content.Server/GameObjects/Components/Chemistry/SolutionComponent.cs

@@ -1,5 +1,5 @@
 using Content.Server.Chemistry;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Shared.Chemistry;
 using Content.Shared.GameObjects;
 using Content.Shared.GameObjects.Components.Chemistry;
@@ -19,6 +19,7 @@ using System.Collections.Generic;
 using System.Linq;
 using Content.Shared.GameObjects.EntitySystems;
 using Robust.Shared.GameObjects.Systems;
+using Content.Server.GameObjects.EntitySystems.Click;
 
 namespace Content.Server.GameObjects.Components.Chemistry
 {

Content.Server/GameObjects/Components/Chemistry/TransformableContainerComponent.cs

@@ -1,4 +1,4 @@
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Shared.Chemistry;
 using Robust.Server.GameObjects;
 using Robust.Shared.GameObjects;

Content.Server/GameObjects/Components/Command/CommunicationsConsoleComponent.cs

@@ -1,6 +1,6 @@
 using Content.Server.GameObjects.Components.Power.ApcNetComponents;
 using Content.Server.GameObjects.Components.Power;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces.GameTicking;
 using Content.Server.Utility;
 using Content.Shared.GameObjects.Components.Command;

Content.Server/GameObjects/Components/Construction/ConstructionComponent.cs

@@ -1,4 +1,11 @@
-using Content.Shared.Construction;
+using System;
+using System.Collections.Generic;
+using Content.Server.GameObjects.Components.Interactable;
+using Content.Server.GameObjects.Components.Stack;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
+using Content.Server.Interfaces;
+using Content.Server.Utility;
+using Content.Shared.Construction;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Serialization;
 using Robust.Shared.ViewVariables;

Content.Server/GameObjects/Components/Damage/BreakableComponent.cs

@@ -1,5 +1,5 @@
 using System.Collections.Generic;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces;
 using Content.Shared.GameObjects;
 using Robust.Shared.GameObjects;

Content.Server/GameObjects/Components/Damage/DamageOnToolInteractComponent.cs

@@ -0,0 +1,68 @@
+using Content.Server.GameObjects.Components.Interactable;
+using Content.Server.GameObjects.EntitySystems;
+using Content.Shared.GameObjects.Components.Interactable;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Serialization;
+using System.Collections.Generic;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
+
+namespace Content.Server.GameObjects.Components.Damage
+{
+    [RegisterComponent]
+    class DamageOnToolInteractComponent : Component, IInteractUsing
+    {
+        public override string Name => "DamageOnToolInteract";
+
+        /* Set in YAML */
+        protected int Damage;
+        private List<ToolQuality> _tools = new List<ToolQuality>();
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            base.ExposeData(serializer);
+
+            serializer.DataField(ref Damage, "damage", 0);
+
+            serializer.DataField(ref _tools, "tools", new List<ToolQuality>());
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            Owner.EnsureComponent<DamageableComponent>();
+        }
+
+        public bool InteractUsing(InteractUsingEventArgs eventArgs)
+        {
+            if (eventArgs.Using.TryGetComponent<ToolComponent>(out var tool))
+            {
+                foreach (var toolQuality in _tools)
+                {
+                    if (tool.HasQuality(ToolQuality.Welding) && toolQuality == ToolQuality.Welding)
+                    {
+                    if (eventArgs.Using.TryGetComponent<WelderComponent>(out WelderComponent welder))
+                    {
+                            if (welder.WelderLit) return CallDamage(eventArgs, tool);
+                    }
+                        break; //If the tool quality is welding and its not lit or its not actually a welder that can be lit then its pointless to continue.
+                }
+
+                    if (tool.HasQuality(toolQuality)) return CallDamage(eventArgs, tool);
+                }
+            }
+            return false;
+        }
+
+        protected bool CallDamage(InteractUsingEventArgs eventArgs, ToolComponent tool)
+        {
+            if (eventArgs.Target.TryGetComponent<DamageableComponent>(out var damageable))
+            {
+                if(tool.HasQuality(ToolQuality.Welding)) damageable.TakeDamage(Shared.GameObjects.DamageType.Heat, Damage, eventArgs.Using, eventArgs.User);
+                else
+                damageable.TakeDamage(Shared.GameObjects.DamageType.Brute, Damage, eventArgs.Using, eventArgs.User);
+                return true;
+            }
+                return false;
+        }
+    }
+}

Content.Server/GameObjects/Components/Damage/DestructibleComponent.cs

@@ -1,5 +1,5 @@
 using System.Collections.Generic;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces;
 using Content.Shared.GameObjects;
 using Robust.Server.GameObjects.EntitySystems;

Content.Server/GameObjects/Components/Doors/AirlockComponent.cs

@@ -3,7 +3,7 @@ using System.Threading;
 using Content.Server.GameObjects.Components.Interactable;
 using Content.Server.GameObjects.Components.Power.ApcNetComponents;
 using Content.Server.GameObjects.Components.VendingMachines;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces;
 using Content.Shared.GameObjects.Components.Doors;
 using Content.Shared.GameObjects.Components.Interactable;

Content.Server/GameObjects/Components/Doors/ServerDoorComponent.cs

@@ -1,6 +1,8 @@
 using System;
 using Content.Server.GameObjects.Components.Access;
 using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
+using Content.Server.Utility;
 using Content.Shared.GameObjects.Components.Doors;
 using Content.Shared.GameObjects.Components.Movement;
 using Robust.Server.GameObjects;
@@ -154,7 +156,7 @@ namespace Content.Server.GameObjects
 
             Timer.Spawn(OpenTimeOne, async () =>
             {
-                collidableComponent.CanCollide = false;
+                collidableComponent.Hard = false;
 
                 await Timer.Delay(OpenTimeTwo, _cancellationTokenSource.Token);
 
@@ -192,14 +194,14 @@ namespace Content.Server.GameObjects
 
         public bool Close()
         {
-            if (collidableComponent.IsColliding(Vector2.Zero))
+            if (collidableComponent.IsColliding(Vector2.Zero, false))
             {
                 // Do nothing, somebody's in the door.
                 return false;
             }
 
             State = DoorState.Closing;
-            collidableComponent.CanCollide = true;
+            collidableComponent.Hard = true;
             OpenTimeCounter = 0;
             SetAppearance(DoorVisualState.Closing);
 

Content.Server/GameObjects/Components/Explosion/ExplosiveComponent.cs

@@ -1,5 +1,5 @@
 using Content.Server.Explosions;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Serialization;
 

Content.Server/GameObjects/Components/Explosion/FlashExplosiveComponent.cs

@@ -1,6 +1,7 @@
 using Content.Server.GameObjects.Components.Items.Storage;
 using Content.Server.GameObjects.Components.Weapon;
 using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Robust.Server.GameObjects.EntitySystems;
 using Robust.Shared.Containers;
 using Robust.Shared.GameObjects;

Content.Server/GameObjects/Components/Fluids/BucketComponent.cs

@@ -1,7 +1,7 @@
 using System;
 using Content.Server.GameObjects.Components.Chemistry;
 using Content.Server.GameObjects.Components.Sound;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Utility;
 using Content.Shared.Chemistry;
 using Content.Shared.Interfaces;

Content.Server/GameObjects/Components/Fluids/MopComponent.cs

@@ -1,7 +1,7 @@
 using System;
 using Content.Server.GameObjects.Components.Chemistry;
 using Content.Server.GameObjects.Components.Sound;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Utility;
 using Content.Shared.Chemistry;
 using Content.Shared.Interfaces;

Content.Server/GameObjects/Components/GUI/InventoryComponent.cs

@@ -2,9 +2,8 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks.Dataflow;
-using Content.Server.GameObjects.Components.Items.Clothing;
+using Content.Server.GameObjects.EntitySystems.Click;
-using Content.Server.GameObjects.Components.Items.Storage;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
-using Content.Server.GameObjects.EntitySystems;
 using Content.Server.Interfaces;
 using Content.Shared.GameObjects;
 using Content.Shared.GameObjects.EntitySystems;

Content.Server/GameObjects/Components/GUI/ServerHandsComponent.cs

@@ -6,6 +6,8 @@ using System.Collections.Generic;
 using System.Linq;
 using Content.Server.GameObjects.Components.Items.Storage;
 using Content.Server.GameObjects.EntitySystems;
+using Content.Server.GameObjects.EntitySystems.Click;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces.GameObjects;
 using Content.Shared.GameObjects;
 using Robust.Server.GameObjects;

Content.Server/GameObjects/Components/Gravity/GravityGeneratorComponent.cs

@@ -2,7 +2,7 @@
 using Content.Server.GameObjects.Components.Interactable;
 using Content.Server.GameObjects.Components.Power.ApcNetComponents;
 using Content.Server.GameObjects.Components.Power;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces;
 using Content.Server.Utility;
 using Content.Shared.GameObjects.Components.Gravity;

Content.Server/GameObjects/Components/Healing/HealingComponent.cs

@@ -1,5 +1,5 @@
 using Content.Server.GameObjects.Components.Stack;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Utility;
 using Content.Shared.GameObjects;
 using Robust.Shared.GameObjects;

Content.Server/GameObjects/Components/Instruments/InstrumentComponent.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Linq;
 using Content.Server.GameObjects.Components.Mobs;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces;
 using Content.Server.Mobs;
 using Content.Shared.GameObjects.Components.Instruments;

Content.Server/GameObjects/Components/Interactable/HandheldLightComponent.cs

@@ -1,4 +1,7 @@
 using Content.Server.GameObjects.Components.Power;
+using Content.Server.GameObjects.Components.Sound;
+using Content.Server.GameObjects.EntitySystems.Click;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.GameObjects.EntitySystems;
 using Content.Server.Interfaces.GameObjects;
 using Content.Shared.GameObjects;

Content.Server/GameObjects/Components/Interactable/MultitoolComponent.cs

@@ -1,5 +1,5 @@
 using System.Collections.Generic;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Shared.GameObjects;
 using Content.Shared.GameObjects.Components.Interactable;
 using Robust.Server.GameObjects;

Content.Server/GameObjects/Components/Interactable/TilePryingComponent.cs

@@ -1,4 +1,5 @@
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.GameObjects.EntitySystems.Click;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Shared.GameObjects.Components.Interactable;
 using Content.Shared.Maps;
 using Robust.Shared.GameObjects;

Content.Server/GameObjects/Components/Interactable/ToolComponent.cs

@@ -3,6 +3,11 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Reflection.Metadata.Ecma335;
+using Content.Server.GameObjects.Components.Chemistry;
+using Content.Server.GameObjects.EntitySystems.Click;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Shared.Audio;
 using Content.Shared.GameObjects.Components.Interactable;
 using Content.Shared.GameObjects.EntitySystems;

Content.Server/GameObjects/Components/Interactable/WelderComponent.cs

@@ -1,8 +1,8 @@
 using System;
 using System.Runtime.Remoting;
 using Content.Server.GameObjects.Components.Chemistry;
-using Content.Server.GameObjects.Components.Items.Storage;
+using Content.Server.GameObjects.EntitySystems.Click;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces;
 using Content.Server.Interfaces.Chat;
 using Content.Server.Interfaces.GameObjects;

Content.Server/GameObjects/Components/Items/Clothing/ClothingComponent.cs

@@ -3,18 +3,17 @@
 using Robust.Shared.Utility;
 using System;
 using System.Collections.Generic;
-using Content.Server.GameObjects.Components.Items.Storage;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
-using Content.Server.GameObjects.EntitySystems;
 using Content.Server.Interfaces;
 using Content.Shared.GameObjects;
 using Content.Shared.GameObjects.Components.Items;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Interfaces.GameObjects;
 using Robust.Shared.IoC;
+using Robust.Shared.GameObjects;
 using Robust.Shared.Serialization;
 using static Content.Shared.GameObjects.Components.Inventory.EquipmentSlotDefines;
+using Robust.Shared.Interfaces.GameObjects;
 
-namespace Content.Server.GameObjects.Components.Items.Clothing
+namespace Content.Server.GameObjects
 {
     [RegisterComponent]
     [ComponentReference(typeof(ItemComponent))]

Content.Server/GameObjects/Components/Items/DiceComponent.cs

@@ -1,5 +1,6 @@
-using Content.Server.GameObjects.Components.Sound;
+using Content.Server.GameObjects.Components.Sound;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.GameObjects.EntitySystems.Click;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Utility;
 using Content.Shared.Audio;
 using Robust.Server.GameObjects;

Content.Server/GameObjects/Components/Items/FloorTileItemComponent.cs

@@ -1,5 +1,5 @@
 using Content.Server.GameObjects.Components.Stack;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Utility;
 using Content.Shared.Maps;
 using Robust.Server.GameObjects.EntitySystems;

Content.Server/GameObjects/Components/Items/Storage/ItemComponent.cs

@@ -1,4 +1,8 @@
-using Content.Server.GameObjects.EntitySystems;
+using System;
+using Content.Server.GameObjects.Components;
+using Content.Server.GameObjects.Components.Destructible;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
+using Content.Server.GameObjects.EntitySystems;
 using Content.Server.Interfaces.GameObjects;
 using Content.Server.Throw;
 using Content.Server.Utility;
@@ -89,7 +93,7 @@ namespace Content.Server.GameObjects.Components.Items.Storage
             var userPos = user.Transform.MapPosition;
             var itemPos = Owner.Transform.MapPosition;
 
-            return InteractionChecks.InRangeUnobstructed(user, itemPos, ignoredEnt: Owner, insideBlockerValid:true);
+            return InteractionChecks.InRangeUnobstructed(user, itemPos, ignoredEnt: Owner, ignoreInsideBlocker:true);
         }
 
         public bool InteractHand(InteractHandEventArgs eventArgs)

Content.Server/GameObjects/Components/Items/Storage/SecureEntityStorageComponent.cs

@@ -1,5 +1,5 @@
 using Content.Server.GameObjects.Components.Access;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces;
 using Content.Shared.GameObjects;
 using Content.Shared.GameObjects.Components.Storage;

Content.Server/GameObjects/Components/Items/Storage/ServerStorageComponent.cs

@@ -1,8 +1,12 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.GameObjects.Components;
+using Content.Server.GameObjects.Components.Items.Storage;
+using Content.Server.GameObjects.EntitySystems.Click;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces.GameObjects;
+using Content.Server.Utility;
 using Content.Shared.GameObjects.Components.Storage;
 using Content.Shared.Interfaces;
 using Robust.Server.GameObjects;
@@ -18,10 +22,11 @@ using Robust.Shared.Interfaces.Map;
 using Robust.Shared.Interfaces.Network;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
+using Robust.Shared.Maths;
 using Robust.Shared.Players;
 using Robust.Shared.Serialization;
 
-namespace Content.Server.GameObjects.Components.Items.Storage
+namespace Content.Server.GameObjects
 {
     /// <summary>
     /// Storage component for containing entities within this one, matches a UI on the client which shows stored entities
@@ -29,7 +34,8 @@ namespace Content.Server.GameObjects.Components.Items.Storage
     [RegisterComponent]
     [ComponentReference(typeof(IActivate))]
     [ComponentReference(typeof(IStorageComponent))]
-    public class ServerStorageComponent : SharedStorageComponent, IInteractUsing, IUse, IActivate, IStorageComponent, IDestroyAct, IExAct
+    public class ServerStorageComponent : SharedStorageComponent, IInteractUsing, IUse, IActivate, IStorageComponent, IDestroyAct, IExAct,
+        IDragDrop
     {
 #pragma warning disable 649
         [Dependency] private readonly IMapManager _mapManager;
@@ -406,5 +412,26 @@ namespace Content.Server.GameObjects.Components.Items.Storage
             Owner.PopupMessage(player, "Can't insert.");
             return false;
         }
+
+        public bool DragDrop(DragDropEventArgs eventArgs)
+        {
+            if (eventArgs.Target.TryGetComponent<PlaceableSurfaceComponent>(out var placeableSurface))
+            {
+                if (!placeableSurface.IsPlaceable) return false;
+
+                // empty everything out
+                foreach (var storedEntity in StoredEntities.ToList())
+                {
+                    if (Remove(storedEntity))
+                    {
+                        storedEntity.Transform.WorldPosition = eventArgs.DropLocation.Position;
+                    }
+                }
+
+                return true;
+            }
+
+            return false;
+        }
     }
 }

Content.Server/GameObjects/Components/Items/ToysComponent.cs

@@ -1,5 +1,6 @@
 using Content.Server.GameObjects.Components.Sound;
 using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Utility;
 using Content.Shared.Audio;
 using Robust.Server.GameObjects;

Content.Server/GameObjects/Components/Kitchen/MicrowaveComponent.cs

@@ -1,6 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.ViewVariables;

Content.Server/GameObjects/Components/MagicMirrorComponent.cs

@@ -1,5 +1,5 @@
 using Content.Server.GameObjects.Components.Mobs;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Utility;
 using Content.Shared.GameObjects.Components;
 using Content.Shared.Interfaces;

Content.Server/GameObjects/Components/Markers/WarpPointComponent.cs

@@ -1,4 +1,5 @@
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.GameObjects.EntitySystems.Click;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Localization;
 using Robust.Shared.Serialization;

Content.Server/GameObjects/Components/Medical/MedicalScannerComponent.cs

@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Shared.GameObjects;
 using Content.Shared.GameObjects.Components.Medical;
 using Content.Server.GameObjects.Components.Power;

Content.Server/GameObjects/Components/Metabolism/BloodstreamComponent.cs

@@ -1,6 +1,6 @@
 using System.Linq;
 using Content.Server.GameObjects.Components.Chemistry;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Shared.Chemistry;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;

Content.Server/GameObjects/Components/Mining/AsteroidRockComponent.cs

@@ -1,6 +1,6 @@
 using Content.Server.GameObjects.Components.Sound;
 using Content.Server.GameObjects.Components.Weapon.Melee;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Utility;
 using Content.Shared.GameObjects;
 using Robust.Server.GameObjects;

Content.Server/GameObjects/Components/Mobs/BuckleComponent.cs

@@ -2,6 +2,7 @@
 using Content.Server.GameObjects.Components.Strap;
 using Content.Server.GameObjects.EntitySystems;
 using Content.Server.Interfaces;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Mobs;
 using Content.Server.Utility;
 using Content.Shared.GameObjects;
@@ -22,7 +23,7 @@ using Robust.Shared.ViewVariables;
 namespace Content.Server.GameObjects.Components.Mobs
 {
     [RegisterComponent]
-    public class BuckleComponent : SharedBuckleComponent, IInteractHand
+    public class BuckleComponent : SharedBuckleComponent, IInteractHand, IDragDrop
     {
 #pragma warning disable 649
         [Dependency] private readonly IEntitySystemManager _entitySystem = default!;
@@ -305,6 +306,11 @@ namespace Content.Server.GameObjects.Components.Mobs
             return TryUnbuckle(eventArgs.User);
         }
 
+        bool IDragDrop.DragDrop(DragDropEventArgs eventArgs)
+        {
+            return TryBuckle(eventArgs.User, eventArgs.Target);
+        }
+
         [Verb]
         private sealed class BuckleVerb : Verb<BuckleComponent>
         {

Content.Server/GameObjects/Components/Mobs/DamageStates.cs

@@ -1,5 +1,5 @@
 using Content.Server.GameObjects.Components.Mobs;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Mobs;
 using Content.Shared.Audio;
 using Content.Shared.GameObjects.Components.Mobs;

Content.Server/GameObjects/Components/Mobs/DamageThresholdTemplates/HumanTemplate.cs

@@ -69,21 +69,24 @@ namespace Content.Server.GameObjects
                     statusEffectsComponent?.ChangeStatusEffectIcon(StatusEffect.Health,
                             "/Textures/Mob/UI/Human/human" + modifier + ".png");
 
-                    overlayComponent?.ChangeOverlay(ScreenEffects.None);
+                    overlayComponent?.RemoveOverlay(OverlayType.GradientCircleMaskOverlay);
+                    overlayComponent?.RemoveOverlay(OverlayType.CircleMaskOverlay);
 
                     return;
                 case ThresholdType.Critical:
                     statusEffectsComponent?.ChangeStatusEffectIcon(
                         StatusEffect.Health,
                         "/Textures/Mob/UI/Human/humancrit-0.png");
-                    overlayComponent?.ChangeOverlay(ScreenEffects.GradientCircleMask);
+                    overlayComponent?.ClearOverlays();
+                    overlayComponent?.AddOverlay(OverlayType.GradientCircleMaskOverlay);
 
                     return;
                 case ThresholdType.Death:
                     statusEffectsComponent?.ChangeStatusEffectIcon(
                         StatusEffect.Health,
                         "/Textures/Mob/UI/Human/humandead.png");
-                    overlayComponent?.ChangeOverlay(ScreenEffects.CircleMask);
+                    overlayComponent?.ClearOverlays();
+                    overlayComponent?.AddOverlay(OverlayType.CircleMaskOverlay);
 
                     return;
                 default:

Content.Server/GameObjects/Components/Mobs/MindComponent.cs

@@ -1,5 +1,6 @@
 using Content.Server.GameObjects.Components.Observer;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.GameObjects.EntitySystems.Click;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces.GameTicking;
 using Content.Server.Mobs;
 using Robust.Shared.GameObjects;

Content.Server/GameObjects/Components/Mobs/ServerOverlayEffectsComponent.cs

@@ -1,5 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using Content.Shared.GameObjects.Components.Mobs;
 using Robust.Shared.GameObjects;
+using Robust.Shared.Timers;
+using Robust.Shared.ViewVariables;
 
 namespace Content.Server.GameObjects.Components.Mobs
 {
@@ -7,20 +12,49 @@ namespace Content.Server.GameObjects.Components.Mobs
     [ComponentReference(typeof(SharedOverlayEffectsComponent))]
     public sealed class ServerOverlayEffectsComponent : SharedOverlayEffectsComponent
     {
-        private ScreenEffects _currentOverlay = ScreenEffects.None;
+        private readonly List<OverlayContainer> _currentOverlays = new List<OverlayContainer>();
+
+        [ViewVariables(VVAccess.ReadWrite)]
+        private List<OverlayContainer> ActiveOverlays => _currentOverlays;
 
         public override ComponentState GetComponentState()
         {
-            return new OverlayEffectComponentState(_currentOverlay);
+            return new OverlayEffectComponentState(_currentOverlays);
         }
 
-        public void ChangeOverlay(ScreenEffects effect)
+        public void AddOverlay(OverlayContainer container)
         {
-            if (effect == _currentOverlay)
+            if (!ActiveOverlays.Contains(container))
             {
-                return;
+                ActiveOverlays.Add(container);
+                Dirty();
             }
-            _currentOverlay = effect;
+        }
+
+        public void AddOverlay(string id) => AddOverlay(new OverlayContainer(id));
+        public void AddOverlay(OverlayType type) => AddOverlay(new OverlayContainer(type));
+
+        public void RemoveOverlay(OverlayContainer container)
+        {
+            if (ActiveOverlays.RemoveAll(c => c.Equals(container)) > 0)
+            {
+                Dirty();
+            }
+        }
+
+        public void RemoveOverlay(string id)
+        {
+            if (ActiveOverlays.RemoveAll(container => container.ID == id) > 0)
+            {
+                Dirty();
+            }
+        }
+
+        public void RemoveOverlay(OverlayType type) => RemoveOverlay(type.ToString());
+
+        public void ClearOverlays()
+        {
+            ActiveOverlays.Clear();
             Dirty();
         }
     }

Content.Server/GameObjects/Components/Mobs/SpeciesComponent.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 using Content.Server.GameObjects.Components.Mobs;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Server.Interfaces;
 using Content.Server.Observer;
 using Content.Shared.GameObjects;
@@ -79,7 +79,7 @@ namespace Content.Server.GameObjects
             statusEffectsComponent?.RemoveStatusEffect(StatusEffect.Health);
 
             Owner.TryGetComponent(out ServerOverlayEffectsComponent overlayEffectsComponent);
-            overlayEffectsComponent?.ChangeOverlay(ScreenEffects.None);
+            overlayEffectsComponent?.ClearOverlays();
         }
 
         bool IActionBlocker.CanMove()

Content.Server/GameObjects/Components/Mobs/StunnableComponent.cs

@@ -1,5 +1,8 @@
 using System;
 using System.Threading;
+using Content.Server.GameObjects.Components.Movement;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
+using Content.Server.Interfaces.GameObjects;
 using Content.Server.GameObjects.EntitySystems;
 using Content.Server.Mobs;
 using Content.Shared.Audio;

Content.Server/GameObjects/Components/Movement/ServerTeleporterComponent.cs

@@ -1,6 +1,6 @@
 using System;
 using System.Linq;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Shared.GameObjects.Components.Movement;
 using Robust.Server.GameObjects;
 using Robust.Server.GameObjects.EntitySystems;

Content.Server/GameObjects/Components/NodeContainer/NodeGroups/INodeGroup.cs

@@ -1,4 +1,5 @@
 using Content.Server.GameObjects.Components.NodeContainer.Nodes;
+using Robust.Shared.IoC;
 using Robust.Shared.ViewVariables;
 using System.Collections.Generic;
 
@@ -10,7 +11,7 @@ namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
     /// </summary>
     public interface INodeGroup
     {
-        public IReadOnlyList<Node> Nodes { get; }
+        IReadOnlyList<Node> Nodes { get; }
 
         void AddNode(Node node);
 
@@ -25,6 +26,8 @@ namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
         void BeforeRemakeSpread();
 
         void AfterRemakeSpread();
+
+        void RemakeGroup();
     }
 
     [NodeGroup(NodeGroupID.Default)]
@@ -49,7 +52,7 @@ namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
         {
             _nodes.Remove(node);
             OnRemoveNode(node);
-            RemakeGroup();
+            IoCManager.Resolve<INodeGroupManager>().AddDirtyNodeGroup(this);
         }
 
         public void CombineGroup(INodeGroup newGroup)
@@ -73,7 +76,7 @@ namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
         ///     Causes all <see cref="Node"/>s to remake their groups. Called when a <see cref="Node"/> is removed
         ///     and may have split a group in two, so multiple new groups may need to be formed.
         /// </summary>
-        private void RemakeGroup()
+        public void RemakeGroup()
         {
             BeforeRemake();
             foreach (var node in Nodes)
@@ -116,6 +119,7 @@ namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
             public void AfterCombine() { }
             public void BeforeRemakeSpread() { }
             public void AfterRemakeSpread() { }
+            public void RemakeGroup() { }
         }
     }
 }

Content.Server/GameObjects/Components/NodeContainer/NodeGroups/INodeGroupManager.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+
+namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
+{
+    /// <summary>
+    ///     Maintains a set of <see cref="INodeGroup"/>s that need to be remade with <see cref="INodeGroup.RemakeGroup"/>.
+    ///     Defers remaking to reduce recalculations when a group is altered multiple times in a frame.
+    /// </summary>
+    public interface INodeGroupManager
+    {
+        /// <summary>
+        ///     Queue up an <see cref="INodeGroup"/> to be remade.
+        /// </summary>
+        void AddDirtyNodeGroup(INodeGroup nodeGroup);
+
+        void Update(float frameTime);
+    }
+
+    public class NodeGroupManager : INodeGroupManager
+    {
+        private readonly HashSet<INodeGroup> _dirtyNodeGroups = new HashSet<INodeGroup>();
+
+        public void AddDirtyNodeGroup(INodeGroup nodeGroup)
+        {
+            _dirtyNodeGroups.Add(nodeGroup);
+        }
+
+        public void Update(float frameTime)
+        {
+            foreach (var group in _dirtyNodeGroups)
+            {
+                group.RemakeGroup();
+            }
+            _dirtyNodeGroups.Clear();
+        }
+    }
+}

Content.Server/GameObjects/Components/NodeContainer/Nodes/Node.cs

@@ -72,7 +72,6 @@ namespace Content.Server.GameObjects.Components.NodeContainer.Nodes
             _deleting = true;
             if (Owner.TryGetComponent<PhysicsComponent>(out var physics))
             {
-                AnchorUpdate();
                 physics.AnchoredChanged -= AnchorUpdate;
             }
             NodeGroup.RemoveNode(this);

Content.Server/GameObjects/Components/Nutrition/DrinkComponent.cs

@@ -1,6 +1,7 @@
 using System;
 using Content.Server.GameObjects.Components.Chemistry;
-using Content.Server.GameObjects.EntitySystems;
+using Content.Server.GameObjects.EntitySystems.Click;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Shared.Audio;
 using Content.Shared.Chemistry;
 using Content.Shared.GameObjects.Components.Nutrition;
@@ -128,6 +129,7 @@ namespace Content.Server.GameObjects.Components.Nutrition
             if (!_opened)
             {
                 target.PopupMessage(target, Loc.GetString("Open it first!"));
+                return false;
             }
 
             if (_contents.CurrentVolume.Float() <= 0)

Content.Server/GameObjects/Components/Nutrition/FoodComponent.cs

@@ -5,6 +5,8 @@ using Content.Server.GameObjects.Components.Items.Storage;
 using Content.Server.GameObjects.Components.Utensil;
 using Content.Server.GameObjects.EntitySystems;
 using Content.Server.Utility;
+using Content.Server.GameObjects.Components.Sound;
+using Content.Server.Interfaces.GameObjects.Components.Interaction;
 using Content.Shared.Chemistry;
 using Content.Shared.GameObjects.Components.Utensil;
 using Content.Shared.Interfaces;