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

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 Content.Client.Graphics.Overlays;
+using System;
+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;
-            SetOverlay(state.ScreenEffect);
-        }
-
-        private void SetOverlay(ScreenEffects effect)
-        {
-            RemoveOverlay();
-
-            _currentEffect = effect;
-
-            ApplyOverlay();
-        }
-
-        private void RemoveOverlay()
-        {
-            if (CurrentlyControlled && _currentEffect != ScreenEffects.None)
+            if (!(curState is OverlayEffectComponentState state) || ActiveOverlays.Equals(state.Overlays))
             {
-                var appliedEffect = _effectsDictionary[_currentEffect];
-                _overlayManager.RemoveOverlay(appliedEffect.ID);
+                return;
             }
 
-            _currentEffect = ScreenEffects.None;
+            ActiveOverlays = state.Overlays;
         }
 
-        private void ApplyOverlay()
+        private void SetEffects(List<OverlayContainer> newOverlays)
         {
-            if (CurrentlyControlled && _currentEffect != ScreenEffects.None)
+            foreach (var container in ActiveOverlays.ShallowClone())
             {
-                var overlay = _effectsDictionary[_currentEffect];
-                if (_overlayManager.HasOverlay(overlay.ID))
+                if (!newOverlays.Contains(container))
                 {
-                    return;
+                    RemoveOverlay(container);
                 }
-                _overlayManager.AddOverlay(overlay);
-                Logger.InfoS("overlay", $"Changed overlay to {overlay}");
             }
+
+            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>();
         }
     }
 }