Add prediction to Spill Container verb, add dummy TrySpill methods to shared (#25813)

* Moved abstract spill methods to shared; added prediction to spill container verb.

* Rerun tests

* Requested changes

* Note Client behavior in Spill method docs

Content.Shared/Fluids/Components/PreventSpillerComponent.cs

@@ -0,0 +1,12 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Fluids.Components;
+
+/// <summary>
+/// Blocks this entity's ability to spill solution containing entities via the verb menu.
+/// </summary>
+[RegisterComponent, NetworkedComponent]
+public sealed partial class PreventSpillerComponent : Component
+{
+
+}

Content.Shared/Fluids/Components/SpillableComponent.cs

@@ -2,6 +2,12 @@ using Content.Shared.FixedPoint;
 
 namespace Content.Shared.Fluids.Components;
 
+/// <summary>
+/// Makes a solution contained in this entity spillable.
+/// Spills can occur when a container with this component overflows,
+/// is used to melee attack something, is equipped (see <see cref="SpillWorn"/>),
+/// lands after being thrown, or has the Spill verb used.
+/// </summary>
 [RegisterComponent]
 public sealed partial class SpillableComponent : Component
 {

Content.Shared/Fluids/SharedPuddleSystem.Spillable.cs

@@ -1,14 +1,23 @@
+using Content.Shared.Database;
+using Content.Shared.DoAfter;
 using Content.Shared.Examine;
+using Content.Shared.FixedPoint;
 using Content.Shared.Fluids.Components;
+using Content.Shared.Nutrition.EntitySystems;
+using Content.Shared.Spillable;
+using Content.Shared.Verbs;
 using Content.Shared.Weapons.Melee;
 
 namespace Content.Shared.Fluids;
 
 public abstract partial class SharedPuddleSystem
 {
+    [Dependency] protected readonly SharedOpenableSystem Openable = default!;
+
     protected virtual void InitializeSpillable()
     {
         SubscribeLocalEvent<SpillableComponent, ExaminedEvent>(OnExamined);
+        SubscribeLocalEvent<SpillableComponent, GetVerbsEvent<Verb>>(AddSpillVerb);
     }
 
     private void OnExamined(Entity<SpillableComponent> entity, ref ExaminedEvent args)
@@ -21,4 +30,55 @@ public abstract partial class SharedPuddleSystem
                 args.PushMarkup(Loc.GetString("spill-examine-spillable-weapon"));
         }
     }
+
+    private void AddSpillVerb(Entity<SpillableComponent> entity, ref GetVerbsEvent<Verb> args)
+    {
+        if (!args.CanAccess || !args.CanInteract)
+            return;
+
+        if (!_solutionContainerSystem.TryGetSolution(args.Target, entity.Comp.SolutionName, out var soln, out var solution))
+            return;
+
+        if (Openable.IsClosed(args.Target))
+            return;
+
+        if (solution.Volume == FixedPoint2.Zero)
+            return;
+
+        if (HasComp<PreventSpillerComponent>(args.User))
+            return;
+
+
+        Verb verb = new()
+        {
+            Text = Loc.GetString("spill-target-verb-get-data-text")
+        };
+
+        // TODO VERB ICONS spill icon? pouring out a glass/beaker?
+        if (entity.Comp.SpillDelay == null)
+        {
+            var target = args.Target;
+            verb.Act = () =>
+            {
+                var puddleSolution = _solutionContainerSystem.SplitSolution(soln.Value, solution.Volume);
+                TrySpillAt(Transform(target).Coordinates, puddleSolution, out _);
+            };
+        }
+        else
+        {
+            var user = args.User;
+            verb.Act = () =>
+            {
+                _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, user, entity.Comp.SpillDelay ?? 0, new SpillDoAfterEvent(), entity.Owner, target: entity.Owner)
+                {
+                    BreakOnDamage = true,
+                    BreakOnMove = true,
+                    NeedHand = true,
+                });
+            };
+        }
+        verb.Impact = LogImpact.Medium; // dangerous reagent reaction are logged separately.
+        verb.DoContactInteraction = true;
+        args.Verbs.Add(verb);
+    }
 }

Content.Shared/Fluids/SharedPuddleSystem.cs

@@ -1,12 +1,14 @@
 using Content.Shared.Chemistry.Components;
 using Content.Shared.Chemistry.EntitySystems;
 using Content.Shared.Chemistry.Reagent;
+using Content.Shared.DoAfter;
 using Content.Shared.DragDrop;
 using Content.Shared.Examine;
 using Content.Shared.FixedPoint;
 using Content.Shared.Fluids.Components;
 using Content.Shared.Movement.Events;
 using Content.Shared.StepTrigger.Components;
+using Robust.Shared.Map;
 using Robust.Shared.Prototypes;
 
 namespace Content.Shared.Fluids;
@@ -15,6 +17,7 @@ public abstract partial class SharedPuddleSystem : EntitySystem
 {
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
     [Dependency] private readonly SharedSolutionContainerSystem _solutionContainerSystem = default!;
+    [Dependency] private readonly SharedDoAfterSystem _doAfterSystem = default!;
 
     /// <summary>
     /// The lowest threshold to be considered for puddle sprite states as well as slipperiness of a puddle.
@@ -106,4 +109,54 @@ public abstract partial class SharedPuddleSystem : EntitySystem
                 args.PushMarkup(Loc.GetString("puddle-component-examine-evaporating-no"));
         }
     }
+
+    #region Spill
+    // These methods are in Shared to make it easier to interact with PuddleSystem in Shared code.
+    // Note that they always fail when run on the client, not creating a puddle and returning false.
+    // Adding proper prediction to this system would require spawning temporary puddle entities on the
+    // client and replacing or merging them with the ones spawned by the server when the client goes to
+    // replicate those, and I am not enough of a wizard to attempt implementing that.
+
+    /// <summary>
+    ///     First splashes reagent on reactive entities near the spilling entity, then spills the rest regularly to a
+    ///     puddle. This is intended for 'destructive' spills, like when entities are destroyed or thrown.
+    /// </summary>
+    /// <remarks>
+    /// On the client, this will always set <paramref name="puddleUid"/> to <see cref="EntityUid.Invalid"> and return false.
+    /// </remarks>
+    public abstract bool TrySplashSpillAt(EntityUid uid,
+        EntityCoordinates coordinates,
+        Solution solution,
+        out EntityUid puddleUid,
+        bool sound = true,
+        EntityUid? user = null);
+
+    /// <summary>
+    ///     Spills solution at the specified coordinates.
+    /// Will add to an existing puddle if present or create a new one if not.
+    /// </summary>
+    /// <remarks>
+    /// On the client, this will always set <paramref name="puddleUid"/> to <see cref="EntityUid.Invalid"> and return false.
+    /// </remarks>
+    public abstract bool TrySpillAt(EntityCoordinates coordinates, Solution solution, out EntityUid puddleUid, bool sound = true);
+
+    /// <summary>
+    /// <see cref="TrySpillAt(EntityCoordinates, Solution, out EntityUid, bool)"/>
+    /// </summary>
+    /// <remarks>
+    /// On the client, this will always set <paramref name="puddleUid"/> to <see cref="EntityUid.Invalid"> and return false.
+    /// </remarks>
+    public abstract bool TrySpillAt(EntityUid uid, Solution solution, out EntityUid puddleUid, bool sound = true,
+        TransformComponent? transformComponent = null);
+
+    /// <summary>
+    /// <see cref="TrySpillAt(EntityCoordinates, Solution, out EntityUid, bool)"/>
+    /// </summary>
+    /// <remarks>
+    /// On the client, this will always set <paramref name="puddleUid"/> to <see cref="EntityUid.Invalid"> and return false.
+    /// </remarks>
+    public abstract bool TrySpillAt(TileRef tileRef, Solution solution, out EntityUid puddleUid, bool sound = true,
+        bool tileReact = true);
+
+    #endregion Spill
 }