Make vending machine restocks predicted (and its sound not spammable) (#38609)

* feat: make vending machine restocks predicted

* refactor: VendingMachineRestockComponent cleanup

* refactor: minor simplification

* revert: refactor: minor simplification; load bearing IsFirstTimePredicted

lol second guessed myself

* chore: unneeded VendingMachineSystem dep

* Update Content.Shared/VendingMachines/VendingMachineComponent.cs

---------

Co-authored-by: slarticodefast <161409025+slarticodefast@users.noreply.github.com>

Content.Shared/VendingMachines/SharedVendingMachineSystem.Restock.cs

@@ -3,7 +3,6 @@ using Content.Shared.IdentityManagement;
 using Content.Shared.Interaction;
 using Content.Shared.Popups;
 using Content.Shared.Wires;
-using Robust.Shared.Audio;
 
 namespace Content.Shared.VendingMachines;
 
@@ -46,6 +45,17 @@ public abstract partial class SharedVendingMachineSystem
         return true;
     }
 
+    public void TryRestockInventory(EntityUid uid, VendingMachineComponent? vendComponent = null)
+    {
+        if (!Resolve(uid, ref vendComponent))
+            return;
+
+        RestockInventoryFromPrototype(uid, vendComponent);
+
+        Dirty(uid, vendComponent);
+        TryUpdateVisualState((uid, vendComponent));
+    }
+
     private void OnAfterInteract(EntityUid uid, VendingMachineRestockComponent component, AfterInteractEvent args)
     {
         if (args.Target is not { } target || !args.CanReach || args.Handled)
@@ -62,8 +72,13 @@ public abstract partial class SharedVendingMachineSystem
 
         args.Handled = true;
 
-        var doAfterArgs = new DoAfterArgs(EntityManager, args.User, (float)component.RestockDelay.TotalSeconds, new RestockDoAfterEvent(), target,
-            target: target, used: uid)
+        var doAfterArgs = new DoAfterArgs(EntityManager,
+            args.User,
+            component.RestockDelay,
+            new RestockDoAfterEvent(),
+            target,
+            target: target,
+            used: uid)
         {
             BreakOnMove = true,
             BreakOnDamage = true,
@@ -74,13 +89,48 @@ public abstract partial class SharedVendingMachineSystem
             return;
 
         var selfMessage = Loc.GetString("vending-machine-restock-start-self", ("target", target));
-        var othersMessage = Loc.GetString("vending-machine-restock-start-others", ("user", Identity.Entity(args.User, EntityManager)), ("target", target));
-        Popup.PopupPredicted(selfMessage,
-            othersMessage,
-            uid,
-            args.User,
-            PopupType.Medium);
+        var othersMessage = Loc.GetString("vending-machine-restock-start-others",
+            ("user", Identity.Entity(args.User, EntityManager)),
+            ("target", target));
+        Popup.PopupPredicted(selfMessage, othersMessage, target, args.User, PopupType.Medium);
 
-        Audio.PlayPredicted(component.SoundRestockStart, uid, args.User);
+
+        if (!Timing.IsFirstTimePredicted)
+            return;
+
+        Audio.Stop(machineComponent.RestockStream);
+        machineComponent.RestockStream = Audio.PlayPredicted(component.SoundRestockStart, target, args.User)?.Entity;
+    }
+
+    private void OnRestockDoAfter(Entity<VendingMachineComponent> ent, ref RestockDoAfterEvent args)
+    {
+        if (args.Cancelled)
+        {
+            // Future predicted ticks can clobber the RestockStream with null while not stopping anything
+            if (Timing.IsFirstTimePredicted)
+                ent.Comp.RestockStream = Audio.Stop(ent.Comp.RestockStream);
+            return;
+        }
+
+        if (args.Handled || args.Used == null)
+            return;
+
+        if (!TryComp<VendingMachineRestockComponent>(args.Used, out var restockComponent))
+        {
+            Log.Error($"{ToPrettyString(args.User)} tried to restock {ToPrettyString(ent)} with {ToPrettyString(args.Used.Value)} which did not have a VendingMachineRestockComponent.");
+            return;
+        }
+
+        TryRestockInventory(ent, ent.Comp);
+
+        var userMessage = Loc.GetString("vending-machine-restock-done-self", ("target", ent));
+        var othersMessage = Loc.GetString("vending-machine-restock-done-others",
+            ("user", Identity.Entity(args.User, EntityManager)),
+            ("target", ent));
+        Popup.PopupPredicted(userMessage, othersMessage, ent, args.User, PopupType.Medium);
+
+        Audio.PlayPredicted(restockComponent.SoundRestockDone, ent, args.User);
+
+        PredictedQueueDel(args.Used.Value);
     }
 }

Content.Shared/VendingMachines/SharedVendingMachineSystem.cs

@@ -41,6 +41,7 @@ public abstract partial class SharedVendingMachineSystem : EntitySystem
         SubscribeLocalEvent<VendingMachineComponent, ComponentGetState>(OnVendingGetState);
         SubscribeLocalEvent<VendingMachineComponent, MapInitEvent>(OnMapInit);
         SubscribeLocalEvent<VendingMachineComponent, GotEmaggedEvent>(OnEmagged);
+        SubscribeLocalEvent<VendingMachineComponent, RestockDoAfterEvent>(OnRestockDoAfter);
 
         SubscribeLocalEvent<VendingMachineRestockComponent, AfterInteractEvent>(OnAfterInteract);
 

Content.Shared/VendingMachines/VendingMachineComponent.cs

@@ -139,6 +139,12 @@ namespace Content.Shared.VendingMachines
         [DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
         public TimeSpan NextEmpEject = TimeSpan.Zero;
 
+        /// <summary>
+        /// Audio entity used during restock in case the doafter gets canceled.
+        /// </summary>
+        [DataField]
+        public EntityUid? RestockStream;
+
         #region Client Visuals
         /// <summary>
         /// RSI state for when the vending machine is unpowered.

Content.Shared/VendingMachines/VendingMachineRestockComponent.cs

@@ -12,23 +12,20 @@ public sealed partial class VendingMachineRestockComponent : Component
     /// <summary>
     /// The time (in seconds) that it takes to restock a machine.
     /// </summary>
-    [ViewVariables(VVAccess.ReadWrite)]
-    [DataField("restockDelay")]
+    [DataField]
     public TimeSpan RestockDelay = TimeSpan.FromSeconds(5.0f);
 
     /// <summary>
     /// What sort of machine inventory does this restock?
     /// This is checked against the VendingMachineComponent's pack value.
     /// </summary>
-    [ViewVariables(VVAccess.ReadWrite)]
-    [DataField("canRestock", customTypeSerializer: typeof(PrototypeIdHashSetSerializer<VendingMachineInventoryPrototype>))]
-    public HashSet<string> CanRestock = new();
+    [DataField(customTypeSerializer: typeof(PrototypeIdHashSetSerializer<VendingMachineInventoryPrototype>))]
+    public HashSet<string> CanRestock = [];
 
     /// <summary>
     ///     Sound that plays when starting to restock a machine.
     /// </summary>
-    [ViewVariables(VVAccess.ReadWrite)]
-    [DataField("soundRestockStart")]
+    [DataField]
     public SoundSpecifier SoundRestockStart = new SoundPathSpecifier("/Audio/Machines/vending_restock_start.ogg")
     {
         Params = new AudioParams
@@ -41,12 +38,10 @@ public sealed partial class VendingMachineRestockComponent : Component
     /// <summary>
     ///     Sound that plays when finished restocking a machine.
     /// </summary>
-    [ViewVariables(VVAccess.ReadWrite)]
-    [DataField("soundRestockDone")]
-    public SoundSpecifier SoundRestockDone = new SoundPathSpecifier("/Audio/Machines/vending_restock_done.ogg");
+    [DataField]
+    public SoundSpecifier SoundRestockDone = new SoundPathSpecifier("/Audio/Machines/vending_restock_done.ogg",
+        AudioParams.Default.WithVolume(-2f).WithVariation(0.2f));
 }
 
 [Serializable, NetSerializable]
-public sealed partial class RestockDoAfterEvent : SimpleDoAfterEvent
-{
-}
+public sealed partial class RestockDoAfterEvent : SimpleDoAfterEvent;