Fix minor puddle regressions (#15295)

diff --git a/Content.Server/Fluids/EntitySystems/PuddleSystem.Spillable.cs b/Content.Server/Fluids/EntitySystems/PuddleSystem.Spillable.cs
index 31deaf82bbd9e47770e1a0ff17ee3134db54fa22..ecdb899f9f7c5e2823c03ea27acad613e9d9eb14 100644 (file)
--- a/Content.Server/Fluids/EntitySystems/PuddleSystem.Spillable.cs
+++ b/Content.Server/Fluids/EntitySystems/PuddleSystem.Spillable.cs
@@ -1,14 +1,23 @@
 using Content.Server.Chemistry.EntitySystems;
 using Content.Server.Fluids.Components;
 using Content.Server.Nutrition.Components;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.Reaction;
+using Content.Shared.Chemistry.Reagent;
 using Content.Shared.Clothing.Components;
 using Content.Shared.Database;
 using Content.Shared.DoAfter;
+using Content.Shared.Examine;
 using Content.Shared.FixedPoint;
+using Content.Shared.IdentityManagement;
 using Content.Shared.Inventory.Events;
+using Content.Shared.Popups;
 using Content.Shared.Spillable;
 using Content.Shared.Throwing;
 using Content.Shared.Verbs;
+using Content.Shared.Weapons.Melee;
+using Content.Shared.Weapons.Melee.Events;
+using Robust.Shared.Player;
 
 namespace Content.Server.Fluids.EntitySystems;
 
@@ -16,13 +25,23 @@ public sealed partial class PuddleSystem
 {
     private void InitializeSpillable()
     {
+        SubscribeLocalEvent<SpillableComponent, ExaminedEvent>(OnExamined);
         SubscribeLocalEvent<SpillableComponent, LandEvent>(SpillOnLand);
+        SubscribeLocalEvent<SpillableComponent, MeleeHitEvent>(SplashOnMeleeHit);
         SubscribeLocalEvent<SpillableComponent, GetVerbsEvent<Verb>>(AddSpillVerb);
         SubscribeLocalEvent<SpillableComponent, GotEquippedEvent>(OnGotEquipped);
         SubscribeLocalEvent<SpillableComponent, SolutionSpikeOverflowEvent>(OnSpikeOverflow);
         SubscribeLocalEvent<SpillableComponent, SpillDoAfterEvent>(OnDoAfter);
     }
 
+    private void OnExamined(EntityUid uid, SpillableComponent component, ExaminedEvent args)
+    {
+        args.PushMarkup(Loc.GetString("spill-examine-is-spillable"));
+
+        if (HasComp<MeleeWeaponComponent>(uid))
+            args.PushMarkup(Loc.GetString("spill-examine-spillable-weapon"));
+    }
+
     private void OnSpikeOverflow(EntityUid uid, SpillableComponent component, SolutionSpikeOverflowEvent args)
     {
         if (!args.Handled)
@@ -33,6 +52,56 @@ public sealed partial class PuddleSystem
         args.Handled = true;
     }
 
+    private void SplashOnMeleeHit(EntityUid uid, SpillableComponent component, MeleeHitEvent args)
+    {
+        // When attacking someone reactive with a spillable entity,
+        // splash a little on them (touch react)
+        // If this also has solution transfer, then assume the transfer amount is how much we want to spill.
+        // Otherwise let's say they want to spill a quarter of its max volume.
+
+        if (!_solutionContainerSystem.TryGetDrainableSolution(uid, out var solution))
+            return;
+
+        if (TryComp<DrinkComponent>(uid, out var drink) && !drink.Opened)
+            return;
+
+        var hitCount = args.HitEntities.Count;
+
+        var totalSplit = FixedPoint2.Min(solution.MaxVolume * 0.25, solution.Volume);
+        if (TryComp<SolutionTransferComponent>(uid, out var transfer))
+        {
+            totalSplit = FixedPoint2.Min(transfer.TransferAmount, solution.Volume);
+        }
+
+        // a little lame, but reagent quantity is not very balanced and we don't want people
+        // spilling like 100u of reagent on someone at once!
+        totalSplit = FixedPoint2.Min(totalSplit, component.MaxMeleeSpillAmount);
+
+        foreach (var hit in args.HitEntities)
+        {
+            if (!HasComp<ReactiveComponent>(hit))
+            {
+                hitCount -= 1; // so we don't undershoot solution calculation for actual reactive entities
+                continue;
+            }
+
+            var splitSolution = _solutionContainerSystem.SplitSolution(uid, solution, totalSplit / hitCount);
+
+            _adminLogger.Add(LogType.MeleeHit, $"{ToPrettyString(args.User)} splashed {SolutionContainerSystem.ToPrettyString(splitSolution):solution} from {ToPrettyString(uid):entity} onto {ToPrettyString(hit):target}");
+            _reactive.DoEntityReaction(hit, splitSolution, ReactionMethod.Touch);
+
+            _popups.PopupEntity(
+                Loc.GetString("spill-melee-hit-attacker", ("amount", totalSplit / hitCount), ("spillable", uid),
+                    ("target", Identity.Entity(hit, EntityManager))),
+                hit, args.User);
+
+            _popups.PopupEntity(
+                Loc.GetString("spill-melee-hit-others", ("attacker", args.User), ("spillable", uid),
+                    ("target", Identity.Entity(hit, EntityManager))),
+                hit, Filter.PvsExcept(args.User), true, PopupType.SmallCaution);
+        }
+    }
+
     private void OnGotEquipped(EntityUid uid, SpillableComponent component, GotEquippedEvent args)
     {
         if (!component.SpillWorn)
@@ -55,7 +124,7 @@ public sealed partial class PuddleSystem
 
         // spill all solution on the player
         var drainedSolution = _solutionContainerSystem.Drain(uid, solution, solution.Volume);
-        TrySpillAt(args.Equipee, drainedSolution, out _);
+        TrySplashSpillAt(uid, Transform(args.Equipee).Coordinates, drainedSolution, out _);
     }
 
     private void SpillOnLand(EntityUid uid, SpillableComponent component, ref LandEvent args)