The real movement refactor (#9645)

* The real movement refactor

* ref events

* Jetpack cleanup

* a

* Vehicles partially working

* Balance tweaks

* Restore some shitcode

* AAAAAAAA

* Even more prediction

* ECS compstate trying to fix this

* yml

* vehicles kill me

* Don't lock keys

* a

* Fix problem

* Fix sounds

* shuttle inputs

* Shuttle controls

* space brakes

* Keybinds

* Fix merge

* Handle shutdown

* Fix keys

* Bump friction

* fix buckle offset

* Fix relay and friction

* Fix jetpack turning

* contexts amirite

Content.Shared/Buckle/Components/SharedBuckleComponent.cs

@@ -1,5 +1,6 @@
 using Content.Shared.DragDrop;
 using Content.Shared.Interaction;
+using Content.Shared.Standing;
 using Robust.Shared.GameStates;
 using Robust.Shared.Serialization;
 
@@ -8,6 +9,8 @@ namespace Content.Shared.Buckle.Components
     [NetworkedComponent()]
     public abstract class SharedBuckleComponent : Component, IDraggable
     {
+        [Dependency] protected readonly IEntityManager EntMan = default!;
+
         /// <summary>
         ///     The range from which this entity can buckle to a <see cref="SharedStrapComponent"/>.
         /// </summary>
@@ -35,6 +38,33 @@ namespace Content.Shared.Buckle.Components
         {
             return TryBuckle(args.User, args.Target);
         }
+
+        /// <summary>
+        ///     Reattaches this entity to the strap, modifying its position and rotation.
+        /// </summary>
+        /// <param name="strap">The strap to reattach to.</param>
+        public void ReAttach(SharedStrapComponent strap)
+        {
+            var ownTransform = EntMan.GetComponent<TransformComponent>(Owner);
+            var strapTransform = EntMan.GetComponent<TransformComponent>(strap.Owner);
+
+            ownTransform.AttachParent(strapTransform);
+            ownTransform.LocalRotation = Angle.Zero;
+
+            switch (strap.Position)
+            {
+                case StrapPosition.None:
+                    break;
+                case StrapPosition.Stand:
+                    EntitySystem.Get<StandingStateSystem>().Stand(Owner);
+                    break;
+                case StrapPosition.Down:
+                    EntitySystem.Get<StandingStateSystem>().Down(Owner, false, false);
+                    break;
+            }
+
+            ownTransform.LocalPosition = strap.BuckleOffset;
+        }
     }
 
     [Serializable, NetSerializable]

Content.Shared/Buckle/Components/SharedStrapComponent.cs

@@ -26,6 +26,40 @@ namespace Content.Shared.Buckle.Components
     [NetworkedComponent()]
     public abstract class SharedStrapComponent : Component, IDragDropOn
     {
+        /// <summary>
+        /// The change in position to the strapped mob
+        /// </summary>
+        [DataField("position")]
+        public StrapPosition Position { get; set; } = StrapPosition.None;
+
+
+        /// <summary>
+        /// The entity that is currently buckled here, synced from <see cref="BuckleComponent.BuckledTo"/>
+        /// </summary>
+        public readonly HashSet<EntityUid> BuckledEntities = new();
+
+        /// <summary>
+        /// The distance above which a buckled entity will be automatically unbuckled.
+        /// Don't change it unless you really have to
+        /// </summary>
+        [DataField("maxBuckleDistance", required: false)]
+        public float MaxBuckleDistance = 0.1f;
+
+        /// <summary>
+        /// Gets and clamps the buckle offset to MaxBuckleDistance
+        /// </summary>
+        public Vector2 BuckleOffset => Vector2.Clamp(
+            BuckleOffsetUnclamped,
+            Vector2.One * -MaxBuckleDistance,
+            Vector2.One * MaxBuckleDistance);
+
+        /// <summary>
+        /// The buckled entity will be offset by this amount from the center of the strap object.
+        /// If this offset it too big, it will be clamped to <see cref="MaxBuckleDistance"/>
+        /// </summary>
+        [DataField("buckleOffset", required: false)]
+        public Vector2 BuckleOffsetUnclamped = Vector2.Zero;
+
         bool IDragDropOn.CanDragDropOn(DragDropEvent eventArgs)
         {
             if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(eventArgs.Dragged, out SharedBuckleComponent? buckleComponent)) return false;
@@ -40,15 +74,22 @@ namespace Content.Shared.Buckle.Components
     [Serializable, NetSerializable]
     public sealed class StrapComponentState : ComponentState
     {
-        public StrapComponentState(StrapPosition position)
-        {
-            Position = position;
-        }
-
         /// <summary>
         /// The change in position that this strap makes to the strapped mob
         /// </summary>
-        public StrapPosition Position { get; }
+        public StrapPosition Position;
+
+        public float MaxBuckleDistance;
+        public Vector2 BuckleOffsetClamped;
+        public HashSet<EntityUid> BuckledEntities;
+
+        public StrapComponentState(StrapPosition position, Vector2 offset, HashSet<EntityUid> buckled, float maxBuckleDistance)
+        {
+            Position = position;
+            BuckleOffsetClamped = offset;
+            BuckledEntities = buckled;
+            MaxBuckleDistance = maxBuckleDistance;
+        }
     }
 
     [Serializable, NetSerializable]

Content.Shared/Buckle/SharedBuckleSystem.cs

@@ -13,6 +13,8 @@ namespace Content.Shared.Buckle
         public override void Initialize()
         {
             base.Initialize();
+            SubscribeLocalEvent<SharedStrapComponent, RotateEvent>(OnStrapRotate);
+
             SubscribeLocalEvent<SharedBuckleComponent, PreventCollideEvent>(PreventCollision);
             SubscribeLocalEvent<SharedBuckleComponent, DownAttemptEvent>(HandleDown);
             SubscribeLocalEvent<SharedBuckleComponent, StandAttemptEvent>(HandleStand);
@@ -21,6 +23,23 @@ namespace Content.Shared.Buckle
             SubscribeLocalEvent<SharedBuckleComponent, ChangeDirectionAttemptEvent>(OnBuckleChangeDirectionAttempt);
         }
 
+        private void OnStrapRotate(EntityUid uid, SharedStrapComponent component, ref RotateEvent args)
+        {
+            // TODO: This looks dirty af.
+            // On rotation of a strap, reattach all buckled entities.
+            // This fixes buckle offsets and draw depths.
+            foreach (var buckledEntity in component.BuckledEntities)
+            {
+                if (!EntityManager.TryGetComponent(buckledEntity, out SharedBuckleComponent? buckled))
+                {
+                    continue;
+                }
+
+                buckled.ReAttach(component);
+                Dirty(buckled);
+            }
+        }
+
         private void OnBuckleChangeDirectionAttempt(EntityUid uid, SharedBuckleComponent component, ChangeDirectionAttemptEvent args)
         {
             if (component.Buckled)