Fix duplicate mech footstep sounds (#12972)

* Fix duplicate mech footstep sounds

We just add a new component for relay targets so we can use that for audio prediction.

* Fix cwash

* woop

Content.Client/Physics/Controllers/MoverController.cs

@@ -140,7 +140,7 @@ namespace Content.Client.Physics.Controllers
 
         protected override bool CanSound()
         {
-            return _timing.IsFirstTimePredicted && _timing.InSimulation;
+            return _timing is { IsFirstTimePredicted: true, InSimulation: true };
         }
     }
 }

Content.Server/Physics/Controllers/MoverController.cs

@@ -84,7 +84,7 @@ namespace Content.Server.Physics.Controllers
                 }
 
                 PhysicsComponent? body = null;
-                TransformComponent? xformMover = xform;
+                var xformMover = xform;
 
                 if (mover.ToParent && relayQuery.HasComponent(xform.ParentUid))
                 {

Content.Shared/Movement/Components/MovementRelayTargetComponent.cs

@@ -0,0 +1,12 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Movement.Components;
+
+[RegisterComponent, NetworkedComponent]
+public sealed class MovementRelayTargetComponent : Component
+{
+    /// <summary>
+    /// Entities that are relaying to us.
+    /// </summary>
+    [ViewVariables] public readonly List<EntityUid> Entities = new();
+}

Content.Shared/Movement/Systems/SharedMoverController.Relay.cs

@@ -12,6 +12,10 @@ public abstract partial class SharedMoverController
         SubscribeLocalEvent<RelayInputMoverComponent, ComponentGetState>(OnRelayGetState);
         SubscribeLocalEvent<RelayInputMoverComponent, ComponentHandleState>(OnRelayHandleState);
         SubscribeLocalEvent<RelayInputMoverComponent, ComponentShutdown>(OnRelayShutdown);
+
+        SubscribeLocalEvent<MovementRelayTargetComponent, ComponentGetState>(OnTargetRelayGetState);
+        SubscribeLocalEvent<MovementRelayTargetComponent, ComponentHandleState>(OnTargetRelayHandleState);
+        SubscribeLocalEvent<MovementRelayTargetComponent, ComponentShutdown>(OnTargetRelayShutdown);
     }
 
     /// <summary>
@@ -20,7 +24,7 @@ public abstract partial class SharedMoverController
     /// </summary>
     public void SetRelay(EntityUid uid, EntityUid relayEntity, RelayInputMoverComponent? component = null)
     {
-        if (!Resolve(uid, ref component))
+        if (!Resolve(uid, ref component) || component.RelayEntity == relayEntity)
             return;
 
         if (uid == relayEntity)
@@ -29,14 +33,38 @@ public abstract partial class SharedMoverController
             return;
         }
 
+        if (TryComp<MovementRelayTargetComponent>(relayEntity, out var targetComp))
+        {
+            targetComp.Entities.Remove(uid);
+
+            if (targetComp.Entities.Count == 0)
+                RemComp<MovementRelayTargetComponent>(relayEntity);
+        }
+
         component.RelayEntity = relayEntity;
+        targetComp = EnsureComp<MovementRelayTargetComponent>(relayEntity);
+        targetComp.Entities.Add(uid);
         Dirty(component);
+        Dirty(targetComp);
     }
 
     private void OnRelayShutdown(EntityUid uid, RelayInputMoverComponent component, ComponentShutdown args)
     {
         // If relay is removed then cancel all inputs.
-        if (!TryComp<InputMoverComponent>(component.RelayEntity, out var inputMover)) return;
+        if (!TryComp<InputMoverComponent>(component.RelayEntity, out var inputMover))
+            return;
+
+        if (TryComp<MovementRelayTargetComponent>(component.RelayEntity, out var targetComp) &&
+            targetComp.LifeStage < ComponentLifeStage.Stopping)
+        {
+            targetComp.Entities.Remove(uid);
+
+            if (targetComp.Entities.Count == 0)
+                RemCompDeferred<MovementRelayTargetComponent>(component.RelayEntity.Value);
+            else
+                Dirty(targetComp);
+        }
+
         SetMoveInput(inputMover, MoveButtons.None);
     }
 
@@ -56,9 +84,59 @@ public abstract partial class SharedMoverController
         };
     }
 
+    #region Target Relay
+
+    private void OnTargetRelayShutdown(EntityUid uid, MovementRelayTargetComponent component, ComponentShutdown args)
+    {
+        if (component.Entities.Count == 0)
+            return;
+
+        var relayQuery = GetEntityQuery<RelayInputMoverComponent>();
+
+        foreach (var ent in component.Entities)
+        {
+            if (!relayQuery.TryGetComponent(ent, out var relay))
+                continue;
+
+            DebugTools.Assert(relay.RelayEntity == uid);
+
+            if (relay.RelayEntity != uid)
+                continue;
+
+            RemCompDeferred<RelayInputMoverComponent>(ent);
+        }
+    }
+
+    private void OnTargetRelayHandleState(EntityUid uid, MovementRelayTargetComponent component, ref ComponentHandleState args)
+    {
+        if (args.Current is not MovementRelayTargetComponentState state)
+            return;
+
+        component.Entities.Clear();
+        component.Entities.AddRange(state.Entities);
+    }
+
+    private void OnTargetRelayGetState(EntityUid uid, MovementRelayTargetComponent component, ref ComponentGetState args)
+    {
+        args.State = new MovementRelayTargetComponentState(component.Entities);
+    }
+
+    #endregion
+
     [Serializable, NetSerializable]
     private sealed class RelayInputMoverComponentState : ComponentState
     {
         public EntityUid? Entity;
     }
+
+    [Serializable, NetSerializable]
+    private sealed class MovementRelayTargetComponentState : ComponentState
+    {
+        public List<EntityUid> Entities;
+
+        public MovementRelayTargetComponentState(List<EntityUid> entities)
+        {
+            Entities = entities;
+        }
+    }
 }

Content.Shared/Movement/Systems/SharedMoverController.cs

@@ -287,7 +287,18 @@ namespace Content.Shared.Movement.Systems
                         .WithVolume(FootstepVolume * soundModifier)
                         .WithVariation(sound.Params.Variation ?? FootstepVariation);
 
-                    _audio.PlayPredicted(sound, mover.Owner, mover.Owner, audioParams);
+                    // If we're a relay target then predict the sound for all relays.
+                    if (TryComp<MovementRelayTargetComponent>(mover.Owner, out var targetComp))
+                    {
+                        foreach (var ent in targetComp.Entities)
+                        {
+                            _audio.PlayPredicted(sound, mover.Owner, ent, audioParams);
+                        }
+                    }
+                    else
+                    {
+                        _audio.PlayPredicted(sound, mover.Owner, mover.Owner, audioParams);
+                    }
                 }
             }