WiP movement prediction.

Content.Shared/GameObjects/Components/Movement/IMoverComponent.cs

@@ -0,0 +1,59 @@
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
+
+namespace Content.Shared.GameObjects.Components.Movement
+{
+    // Does nothing except ensure uniqueness between mover components.
+    // There can only be one.
+    public interface IMoverComponent : IComponent
+    {
+        /// <summary>
+        ///     Movement speed (m/s) that the entity walks.
+        /// </summary>
+        float CurrentWalkSpeed { get; }
+
+        /// <summary>
+        ///     Movement speed (m/s) that the entity sprints.
+        /// </summary>
+        float CurrentSprintSpeed { get; }
+
+
+        /// <summary>
+        ///     The movement speed (m/s) of the entity when it pushes off of a solid object in zero gravity.
+        /// </summary>
+        float CurrentPushSpeed { get; }
+
+        /// <summary>
+        ///     How far an entity can reach (in meters) to grab hold of a solid object in zero gravity.
+        /// </summary>
+        float GrabRange { get; }
+
+        /// <summary>
+        ///     Is the entity Sprinting (running)?
+        /// </summary>
+        bool Sprinting { get; }
+
+        /// <summary>
+        ///     Calculated linear velocity direction of the entity.
+        /// </summary>
+        (Vector2 walking, Vector2 sprinting) VelocityDir { get; }
+
+        GridCoordinates LastPosition { get; set; }
+
+        float StepSoundDistance { get; set; }
+
+        /// <summary>
+        ///     Toggles one of the four cardinal directions. Each of the four directions are
+        ///     composed into a single direction vector, <see cref="PlayerInputMoverComponent.VelocityDir"/>. Enabling
+        ///     opposite directions will cancel each other out, resulting in no direction.
+        /// </summary>
+        /// <param name="direction">Direction to toggle.</param>
+        /// <param name="subTick"></param>
+        /// <param name="enabled">If the direction is active.</param>
+        void SetVelocityDirection(Direction direction, ushort subTick, bool enabled);
+
+        void SetSprinting(ushort subTick, bool enabled);
+
+    }
+}

Content.Shared/GameObjects/Components/Movement/IRelayMoveInput.cs

@@ -0,0 +1,9 @@
+using Robust.Shared.Players;
+
+namespace Content.Shared.GameObjects.Components.Movement
+{
+    public interface IRelayMoveInput
+    {
+        void MoveInputPressed(ICommonSession session);
+    }
+}

Content.Shared/GameObjects/Components/Movement/MovementSpeedModifierComponent.cs

@@ -0,0 +1,92 @@
+using Robust.Shared.GameObjects;
+using Robust.Shared.Serialization;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Shared.GameObjects.Components.Movement
+{
+    [RegisterComponent]
+    public class MovementSpeedModifierComponent : Component
+    {
+        public const float DefaultBaseWalkSpeed = 4.0f;
+        public const float DefaultBaseSprintSpeed = 7.0f;
+
+        public override string Name => "MovementSpeedModifier";
+
+        private float _cachedWalkSpeedModifier = 1.0f;
+        [ViewVariables]
+        public float WalkSpeedModifier
+        {
+            get
+            {
+                RecalculateMovementSpeedModifiers();
+                return _cachedWalkSpeedModifier;
+            }
+        }
+        private float _cachedSprintSpeedModifier;
+        [ViewVariables]
+        public float SprintSpeedModifier
+        {
+            get
+            {
+                RecalculateMovementSpeedModifiers();
+                return _cachedSprintSpeedModifier;
+            }
+        }
+
+        [ViewVariables(VVAccess.ReadWrite)]
+        public float BaseWalkSpeed { get; set; }
+        [ViewVariables(VVAccess.ReadWrite)]
+        public float BaseSprintSpeed { get; set; }
+
+        [ViewVariables]
+        public float CurrentWalkSpeed => WalkSpeedModifier * BaseWalkSpeed;
+        [ViewVariables]
+        public float CurrentSprintSpeed => SprintSpeedModifier * BaseSprintSpeed;
+
+        /// <summary>
+        ///     set to warn us that a component's movespeed modifier has changed
+        /// </summary>
+        private bool _movespeedModifiersNeedRefresh = true;
+
+        public void RefreshMovementSpeedModifiers()
+        {
+            _movespeedModifiersNeedRefresh = true;
+        }
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            base.ExposeData(serializer);
+
+            serializer.DataField(this, p => p.BaseWalkSpeed, "baseWalkSpeed", 4);
+            serializer.DataField(this, p => p.BaseSprintSpeed, "baseSprintSpeed", 7);
+        }
+
+        /// <summary>
+        ///     Recalculate movement speed with current modifiers, or return early if no change
+        /// </summary>
+        private void RecalculateMovementSpeedModifiers()
+        {
+            {
+                if (!_movespeedModifiersNeedRefresh)
+                    return;
+                var movespeedModifiers = Owner.GetAllComponents<IMoveSpeedModifier>();
+                float walkSpeedModifier = 1.0f;
+                float sprintSpeedModifier = 1.0f;
+                foreach (var component in movespeedModifiers)
+                {
+                    walkSpeedModifier *= component.WalkSpeedModifier;
+                    sprintSpeedModifier *= component.SprintSpeedModifier;
+                }
+                _cachedWalkSpeedModifier = walkSpeedModifier;
+                _cachedSprintSpeedModifier = sprintSpeedModifier;
+            }
+            _movespeedModifiersNeedRefresh = false;
+        }
+    }
+
+    public interface IMoveSpeedModifier
+    {
+        float WalkSpeedModifier { get; }
+        float SprintSpeedModifier { get; }
+    }
+}

Content.Shared/GameObjects/Components/Movement/SharedPlayerInputMoverComponent.cs

@@ -0,0 +1,287 @@
+using System;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Interfaces.Configuration;
+using Robust.Shared.Interfaces.Timing;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
+using Robust.Shared.Physics;
+using Robust.Shared.Serialization;
+using Robust.Shared.Timing;
+using Robust.Shared.ViewVariables;
+
+#nullable enable
+
+namespace Content.Shared.GameObjects.Components.Movement
+{
+    public abstract class SharedPlayerInputMoverComponent : Component, IMoverComponent
+    {
+        // This class has to be able to handle server TPS being lower than client FPS.
+        // While still having perfectly responsive movement client side.
+        // We do this by keeping track of the exact sub-tick values that inputs are pressed on the client,
+        // and then building a total movement vector based on those sub-tick steps.
+        //
+        // We keep track of the last sub-tick a movement input came in,
+        // Then when a new input comes in, we calculate the fraction of the tick the LAST input was active for
+        //   (new sub-tick - last sub-tick)
+        // and then add to the total-this-tick movement vector
+        // by multiplying that fraction by the movement direction for the last input.
+        // This allows us to incrementally build the movement vector for the current tick,
+        // without having to keep track of some kind of list of inputs and calculating it later.
+        //
+        // We have to keep track of a separate movement vector for walking and sprinting,
+        // since we don't actually know our current movement speed while processing inputs.
+        // We change which vector we write into based on whether we were sprinting after the previous input.
+        //   (well maybe we do but the code is designed such that MoverSystem applies movement speed)
+        //   (and I'm not changing that)
+
+        [Dependency] private readonly IConfigurationManager _configurationManager = default!;
+        [Dependency] private readonly IGameTiming _gameTiming = default!;
+
+        public sealed override string Name => "PlayerInputMover";
+        public sealed override uint? NetID => ContentNetIDs.PLAYER_INPUT_MOVER;
+
+        private GameTick _lastInputTick;
+        private ushort _lastInputSubTick;
+        private Vector2 _curTickWalkMovement;
+        private Vector2 _curTickSprintMovement;
+
+        private MoveButtons _heldMoveButtons = MoveButtons.None;
+
+        public float CurrentWalkSpeed
+        {
+            get
+            {
+                if (Owner.TryGetComponent(out MovementSpeedModifierComponent component))
+                {
+                    return component.CurrentWalkSpeed;
+                }
+
+                return MovementSpeedModifierComponent.DefaultBaseWalkSpeed;
+            }
+        }
+
+        public float CurrentSprintSpeed
+        {
+            get
+            {
+                if (Owner.TryGetComponent(out MovementSpeedModifierComponent component))
+                {
+                    return component.CurrentSprintSpeed;
+                }
+
+                return MovementSpeedModifierComponent.DefaultBaseSprintSpeed;
+            }
+        }
+
+        public float CurrentPushSpeed => 5;
+        public float GrabRange => 0.2f;
+        public bool Sprinting => !_heldMoveButtons.HasFlag(MoveButtons.Sprint);
+
+        /// <summary>
+        ///     Calculated linear velocity direction of the entity.
+        /// </summary>
+        [ViewVariables]
+        public (Vector2 walking, Vector2 sprinting) VelocityDir
+        {
+            get
+            {
+                if (!_gameTiming.InSimulation)
+                {
+                    // Outside of simulation we'll be running client predicted movement per-frame.
+                    // So return a full-length vector as if it's a full tick.
+                    // Physics system will have the correct time step anyways.
+                    var immediateDir = DirVecForButtons(_heldMoveButtons);
+                    return Sprinting ? (Vector2.Zero, immediateDir) : (immediateDir, Vector2.Zero);
+                }
+
+                Vector2 walk;
+                Vector2 sprint;
+                float remainingFraction;
+
+                if (_gameTiming.CurTick > _lastInputTick)
+                {
+                    walk = Vector2.Zero;
+                    sprint = Vector2.Zero;
+                    remainingFraction = 1;
+                }
+                else
+                {
+                    walk = _curTickWalkMovement;
+                    sprint = _curTickSprintMovement;
+                    remainingFraction = (ushort.MaxValue - _lastInputSubTick) / (float) ushort.MaxValue;
+                }
+
+                var curDir = DirVecForButtons(_heldMoveButtons) * remainingFraction;
+
+                if (Sprinting)
+                {
+                    sprint += curDir;
+                }
+                else
+                {
+                    walk += curDir;
+                }
+
+                // Logger.Info($"{curDir}{walk}{sprint}");
+                return (walk, sprint);
+            }
+        }
+
+        public abstract GridCoordinates LastPosition { get; set; }
+        public abstract float StepSoundDistance { get; set; }
+
+        /// <summary>
+        ///     Whether or not the player can move diagonally.
+        /// </summary>
+        [ViewVariables]
+        public bool DiagonalMovementEnabled => _configurationManager.GetCVar<bool>("game.diagonalmovement");
+
+        /// <inheritdoc />
+        public override void OnAdd()
+        {
+            // This component requires that the entity has a PhysicsComponent.
+            if (!Owner.HasComponent<SharedPhysicsComponent>())
+                Logger.Error(
+                    $"[ECS] {Owner.Prototype?.Name} - {nameof(SharedPlayerInputMoverComponent)} requires" +
+                    $" {nameof(SharedPhysicsComponent)}. ");
+
+            base.OnAdd();
+        }
+
+
+        /// <summary>
+        ///     Toggles one of the four cardinal directions. Each of the four directions are
+        ///     composed into a single direction vector, <see cref="VelocityDir"/>. Enabling
+        ///     opposite directions will cancel each other out, resulting in no direction.
+        /// </summary>
+        /// <param name="direction">Direction to toggle.</param>
+        /// <param name="subTick"></param>
+        /// <param name="enabled">If the direction is active.</param>
+        public void SetVelocityDirection(Direction direction, ushort subTick, bool enabled)
+        {
+            // Logger.Info($"[{_gameTiming.CurTick}/{subTick}] {direction}: {enabled}");
+
+            var bit = direction switch
+            {
+                Direction.East => MoveButtons.Right,
+                Direction.North => MoveButtons.Up,
+                Direction.West => MoveButtons.Left,
+                Direction.South => MoveButtons.Down,
+                _ => throw new ArgumentException(nameof(direction))
+            };
+
+            SetMoveInput(subTick, enabled, bit);
+        }
+
+        private void SetMoveInput(ushort subTick, bool enabled, MoveButtons bit)
+        {
+            // Modifies held state of a movement button at a certain sub tick and updates current tick movement vectors.
+
+            if (_gameTiming.CurTick > _lastInputTick)
+            {
+                _curTickWalkMovement = Vector2.Zero;
+                _curTickSprintMovement = Vector2.Zero;
+                _lastInputTick = _gameTiming.CurTick;
+                _lastInputSubTick = 0;
+            }
+
+            var fraction = (subTick - _lastInputSubTick) / (float) ushort.MaxValue;
+
+            ref var lastMoveAmount = ref Sprinting ? ref _curTickSprintMovement : ref _curTickWalkMovement;
+
+            lastMoveAmount += DirVecForButtons(_heldMoveButtons) * fraction;
+
+            if (enabled)
+            {
+                _heldMoveButtons |= bit;
+            }
+            else
+            {
+                _heldMoveButtons &= ~bit;
+            }
+
+            _lastInputSubTick = subTick;
+
+            Dirty();
+        }
+
+        public void SetSprinting(ushort subTick, bool enabled)
+        {
+            // Logger.Info($"[{_gameTiming.CurTick}/{subTick}] Sprint: {enabled}");
+
+            SetMoveInput(subTick, enabled, MoveButtons.Sprint);
+        }
+
+        public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)
+        {
+            if (curState is MoverComponentState state)
+            {
+                _heldMoveButtons = state.Buttons;
+                _lastInputTick = GameTick.Zero;
+                _lastInputSubTick = 0;
+            }
+        }
+
+        public override ComponentState GetComponentState()
+        {
+            return new MoverComponentState(_heldMoveButtons);
+        }
+
+        /// <summary>
+        ///     Retrieves the normalized direction vector for a specified combination of movement keys.
+        /// </summary>
+        private Vector2 DirVecForButtons(MoveButtons buttons)
+        {
+            // key directions are in screen coordinates
+            // _moveDir is in world coordinates
+            // if the camera is moved, this needs to be changed
+
+            var x = 0;
+            x -= buttons.HasFlag(MoveButtons.Left) ? 1 : 0;
+            x += buttons.HasFlag(MoveButtons.Right) ? 1 : 0;
+
+            var y = 0;
+            if (DiagonalMovementEnabled || x == 0)
+            {
+                y -= buttons.HasFlag(MoveButtons.Down) ? 1 : 0;
+                y += buttons.HasFlag(MoveButtons.Up) ? 1 : 0;
+            }
+
+            var vec = new Vector2(x, y);
+
+            // can't normalize zero length vector
+            if (vec.LengthSquared > 1.0e-6)
+            {
+                // Normalize so that diagonals aren't faster or something.
+                vec = vec.Normalized;
+            }
+
+            return vec;
+        }
+
+        [Serializable, NetSerializable]
+        private sealed class MoverComponentState : ComponentState
+        {
+            public MoveButtons Buttons { get; }
+
+            public MoverComponentState(MoveButtons buttons) : base(ContentNetIDs
+                .PLAYER_INPUT_MOVER)
+            {
+                Buttons = buttons;
+            }
+        }
+
+        [Flags]
+        private enum MoveButtons : byte
+        {
+            None = 0,
+            Up = 1,
+            Down = 2,
+            Left = 4,
+            Right = 8,
+            Sprint = 16,
+        }
+    }
+}