Reagent interactivity (pt. 1) (#15130)

* Puddle slippy

* spillable melee

* splash spilling!

* splat melee sound

* p

Content.Server/Destructible/Thresholds/Behaviors/SpillBehavior.cs

@@ -31,12 +31,12 @@ namespace Content.Server.Destructible.Thresholds.Behaviors
                 solutionContainerSystem.TryGetSolution(owner, spillableComponent.SolutionName,
                     out var compSolution))
             {
-                spillableSystem.SpillAt(compSolution, coordinates, "PuddleSmear", false);
+                spillableSystem.SplashSpillAt(owner, compSolution, coordinates, "PuddleSmear", false, user: cause);
             }
             else if (Solution != null &&
                      solutionContainerSystem.TryGetSolution(owner, Solution, out var behaviorSolution))
             {
-                spillableSystem.SpillAt(behaviorSolution, coordinates, "PuddleSmear");
+                spillableSystem.SplashSpillAt(owner, behaviorSolution, coordinates, "PuddleSmear", user: cause);
             }
         }
     }

Content.Server/Fluids/Components/SpillableComponent.cs

@@ -1,3 +1,5 @@
+using Content.Shared.FixedPoint;
+
 namespace Content.Server.Fluids.Components;
 
 [RegisterComponent]
@@ -15,4 +17,10 @@ public sealed class SpillableComponent : Component
 
     [DataField("spillDelay")]
     public float? SpillDelay;
+
+    /// <summary>
+    ///     At most how much reagent can be splashed on someone at once?
+    /// </summary>
+    [DataField("maxMeleeSpillAmount")]
+    public FixedPoint2 MaxMeleeSpillAmount = FixedPoint2.New(20);
 }

Content.Server/Fluids/EntitySystems/PuddleSystem.cs

@@ -1,8 +1,13 @@
 using Content.Server.Chemistry.EntitySystems;
 using Content.Server.Fluids.Components;
+using Content.Shared.Chemistry;
+using Content.Shared.Chemistry.Reaction;
+using Content.Shared.Chemistry.Reagent;
 using Content.Shared.Examine;
 using Content.Shared.FixedPoint;
 using Content.Shared.Fluids;
+using Content.Shared.Popups;
+using Content.Shared.Slippery;
 using Content.Shared.StepTrigger.Components;
 using Content.Shared.StepTrigger.Systems;
 using JetBrains.Annotations;
@@ -11,6 +16,7 @@ using Robust.Shared.Map;
 using Robust.Shared.Player;
 using Solution = Content.Shared.Chemistry.Components.Solution;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
 
 namespace Content.Server.Fluids.EntitySystems
 {
@@ -21,7 +27,10 @@ namespace Content.Server.Fluids.EntitySystems
         [Dependency] private readonly FluidSpreaderSystem _fluidSpreaderSystem = default!;
         [Dependency] private readonly StepTriggerSystem _stepTrigger = default!;
         [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+        [Dependency] private readonly ReactiveSystem _reactive = default!;
+        [Dependency] private readonly SharedPopupSystem _popup = default!;
         [Dependency] private readonly IPrototypeManager _protoMan = default!;
+        [Dependency] private readonly IRobustRandom _random = default!;
 
         public static float PuddleVolume = 1000;
 
@@ -38,6 +47,7 @@ namespace Content.Server.Fluids.EntitySystems
             SubscribeLocalEvent<PuddleComponent, ExaminedEvent>(HandlePuddleExamined);
             SubscribeLocalEvent<PuddleComponent, SolutionChangedEvent>(OnSolutionUpdate);
             SubscribeLocalEvent<PuddleComponent, ComponentInit>(OnPuddleInit);
+            SubscribeLocalEvent<PuddleComponent, SlipEvent>(OnPuddleSlip);
         }
 
         public override void Update(float frameTime)
@@ -55,6 +65,29 @@ namespace Content.Server.Fluids.EntitySystems
             _solutionContainerSystem.EnsureSolution(uid, component.SolutionName, FixedPoint2.New(PuddleVolume), out _);
         }
 
+        private void OnPuddleSlip(EntityUid uid, PuddleComponent component, ref SlipEvent args)
+        {
+            // Reactive entities have a chance to get a touch reaction from slipping on a puddle
+            // (i.e. it is implied they fell face first onto it or something)
+            if (!HasComp<ReactiveComponent>(args.Slipped))
+                return;
+
+            // Eventually probably have some system of 'body coverage' to tweak the probability but for now just 0.5
+            // (implying that spacemen have a 50% chance to either land on their ass or their face)
+            if (!_random.Prob(0.5f))
+                return;
+
+            if (!_solutionContainerSystem.TryGetSolution(uid, component.SolutionName, out var solution))
+                return;
+
+            _popup.PopupEntity(Loc.GetString("puddle-component-slipped-touch-reaction", ("puddle", uid)),
+                args.Slipped, args.Slipped, PopupType.SmallCaution);
+
+            // Take 15% of the puddle solution
+            var splitSol = _solutionContainerSystem.SplitSolution(uid, solution, solution.Volume * 0.15f);
+            _reactive.DoEntityReaction(args.Slipped, splitSol, ReactionMethod.Touch);
+        }
+
         private void OnSolutionUpdate(EntityUid uid, PuddleComponent component, SolutionChangedEvent args)
         {
             if (args.Solution.Name != component.SolutionName)

Content.Server/Fluids/EntitySystems/SpillableSystem.cs

@@ -15,8 +15,17 @@ using Robust.Shared.Map;
 using Robust.Shared.Prototypes;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using Content.Shared.Chemistry;
+using Content.Shared.Chemistry.Reaction;
 using Content.Shared.DoAfter;
+using Content.Shared.Examine;
+using Content.Shared.IdentityManagement;
+using Content.Shared.Popups;
 using Content.Shared.Spillable;
+using Content.Shared.Weapons.Melee;
+using Content.Shared.Weapons.Melee.Events;
+using Robust.Shared.Player;
+using Robust.Shared.Random;
 
 namespace Content.Server.Fluids.EntitySystems;
 
@@ -28,19 +37,32 @@ public sealed class SpillableSystem : EntitySystem
     [Dependency] private readonly IMapManager _mapManager = default!;
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
     [Dependency] private readonly EntityLookupSystem _entityLookup = default!;
-    [Dependency] private readonly IAdminLogManager _adminLogger= default!;
+    [Dependency] private readonly IAdminLogManager _adminLogger = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
     [Dependency] private readonly SharedDoAfterSystem _doAfterSystem = default!;
+    [Dependency] private readonly ReactiveSystem _reactive = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
 
     public override void Initialize()
     {
         base.Initialize();
+        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)
@@ -104,11 +126,61 @@ public sealed class SpillableSystem : EntitySystem
         if (args.User != null)
         {
             _adminLogger.Add(LogType.Landed,
-                $"{ToPrettyString(uid):entity} spilled a solution {SolutionContainerSystem.ToPrettyString(solution):solution} on landing");
+                $"{ToPrettyString(args.User.Value):user} threw {ToPrettyString(uid):entity} which spilled a solution {SolutionContainerSystem.ToPrettyString(solution):solution} on landing");
         }
 
         var drainedSolution = _solutionContainerSystem.Drain(uid, solution, solution.Volume);
-        SpillAt(drainedSolution, EntityManager.GetComponent<TransformComponent>(uid).Coordinates, "PuddleSmear");
+        SplashSpillAt(uid, drainedSolution, Transform(uid).Coordinates, "PuddleSmear");
+    }
+
+    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);
+
+            _popup.PopupEntity(
+                Loc.GetString("spill-melee-hit-attacker", ("amount", totalSplit / hitCount), ("spillable", uid),
+                    ("target", Identity.Entity(hit, EntityManager))),
+                hit, args.User);
+
+            _popup.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 AddSpillVerb(EntityUid uid, SpillableComponent component, GetVerbsEvent<Verb> args)
@@ -144,6 +216,39 @@ public sealed class SpillableSystem : EntitySystem
         args.Verbs.Add(verb);
     }
 
+    /// <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>
+    public PuddleComponent? SplashSpillAt(EntityUid uid, Solution solution, EntityCoordinates coordinates, string prototype,
+        bool overflow = true, bool sound = true, bool combine = true, EntityUid? user=null)
+    {
+        if (solution.Volume == 0)
+            return null;
+
+        // Get reactive entities nearby--if there are some, it'll spill a bit on them instead.
+        foreach (var ent in _entityLookup.GetComponentsInRange<ReactiveComponent>(coordinates, 1.0f))
+        {
+            // sorry! no overload for returning uid, so .owner must be used
+            var owner = ent.Owner;
+
+            // between 5 and 30%
+            var splitAmount = solution.Volume * _random.NextFloat(0.05f, 0.30f);
+            var splitSolution = solution.SplitSolution(splitAmount);
+
+            if (user != null)
+            {
+                _adminLogger.Add(LogType.Landed,
+                    $"{ToPrettyString(user.Value):user} threw {ToPrettyString(uid):entity} which splashed a solution {SolutionContainerSystem.ToPrettyString(solution):solution} onto {ToPrettyString(owner):target}");
+            }
+
+            _reactive.DoEntityReaction(owner, splitSolution, ReactionMethod.Touch);
+            _popup.PopupEntity(Loc.GetString("spill-land-spilled-on-other", ("spillable", uid), ("target", owner)), owner, PopupType.SmallCaution);
+        }
+
+        return SpillAt(solution, coordinates, prototype, overflow, sound, combine: combine);
+    }
+
     /// <summary>
     ///     Spills solution at the specified grid coordinates.
     /// </summary>
@@ -159,7 +264,6 @@ public sealed class SpillableSystem : EntitySystem
     {
         if (solution.Volume == 0) return null;
 
-
         if (!_mapManager.TryGetGrid(coordinates.GetGridUid(EntityManager), out var mapGrid))
             return null; // Let's not spill to space.
 

Content.Server/Nutrition/EntitySystems/SmokingSystem.cs

@@ -136,7 +136,7 @@ namespace Content.Server.Nutrition.EntitySystems
                     continue;
                 }
 
-                _reactiveSystem.ReactionEntity(containerManager.Owner, ReactionMethod.Ingestion, inhaledSolution);
+                _reactiveSystem.DoEntityReaction(containerManager.Owner, inhaledSolution, ReactionMethod.Ingestion);
                 _bloodstreamSystem.TryAddToChemicals(containerManager.Owner, inhaledSolution, bloodstream);
             }
 

Content.Shared/Chemistry/ReactiveSystem.cs

@@ -17,14 +17,6 @@ namespace Content.Shared.Chemistry
         [Dependency] private readonly IRobustRandom _robustRandom = default!;
         [Dependency] private readonly ISharedAdminLogManager _adminLogger = default!;
 
-        public void ReactionEntity(EntityUid uid, ReactionMethod method, Solution solution)
-        {
-            foreach (var (id, quantity) in solution)
-            {
-                ReactionEntity(uid, method, id, quantity, solution);
-            }
-        }
-
         public void DoEntityReaction(EntityUid uid, Solution solution, ReactionMethod method)
         {
             foreach (var (reagentId, quantity) in solution.Contents.ToArray())

Resources/Locale/en-US/fluids/components/puddle-component.ftl

@@ -1 +1,2 @@
 puddle-component-examine-is-slipper-text = It looks slippery.
+puddle-component-slipped-touch-reaction = The chemicals in {THE($puddle)} get on your skin!

Resources/Locale/en-US/fluids/components/spillable-component.ftl

@@ -3,3 +3,11 @@
 spill-target-verb-get-data-text = Spill liquid
 spill-target-verb-activate-cannot-drain-message = You can't pour anything from {$owner}!
 spill-target-verb-activate-is-empty-message = {$owner} is empty!
+
+spill-melee-hit-attacker = You spill {$amount}u of {THE($spillable)} onto {THE($target)}!
+spill-melee-hit-others = {CAPITALIZE(THE($attacker))} spills some of {THE($spillable)} onto {THE($target)}!
+
+spill-land-spilled-on-other = {CAPITALIZE(THE($spillable))} spills some of its solution onto {THE($target)}!
+
+spill-examine-is-spillable = This container looks spillable.
+spill-examine-spillable-weapon = You could splash this onto someone with a melee attack.

Resources/Prototypes/Entities/Objects/Consumable/Drinks/drinks.yml

@@ -14,6 +14,12 @@
   - type: Drink
   - type: Sprite
     state: icon
+  - type: MeleeWeapon
+    soundNoDamage:
+      path: "/Audio/Effects/Fluids/splat.ogg"
+    damage:
+      types:
+        Blunt: 0
   - type: Spillable
     solution: drink
   - type: FitsInDispenser

Resources/Prototypes/Entities/Objects/Consumable/Drinks/drinks_cans.yml

@@ -44,6 +44,12 @@
           False: {state: "icon"}
   - type: Spillable
     solution: drink
+  - type: MeleeWeapon
+    soundNoDamage:
+      path: "/Audio/Effects/Fluids/splat.ogg"
+    damage:
+      types:
+        Blunt: 0
   - type: ItemCooldown
   - type: Recyclable
   - type: SpaceGarbage

Resources/Prototypes/Entities/Objects/Consumable/Drinks/drinks_cups.yml

@@ -31,6 +31,12 @@
     state: icon
   - type: Spillable
     solution: drink
+  - type: MeleeWeapon
+    soundNoDamage:
+      path: "/Audio/Effects/Fluids/splat.ogg"
+    damage:
+      types:
+        Blunt: 0
   - type: ItemCooldown
 
 - type: entity

Resources/Prototypes/Entities/Objects/Consumable/Drinks/trash_drinks.yml

@@ -17,6 +17,12 @@
     maxTransferAmount: 5
   - type: Drink
     isOpen: true
+  - type: MeleeWeapon
+    soundNoDamage:
+      path: "/Audio/Effects/Fluids/splat.ogg"
+    damage:
+      types:
+        Blunt: 0
   - type: Spillable
     solution: drink
   - type: FitsInDispenser

Resources/Prototypes/Entities/Objects/Consumable/Food/ingredients.yml

@@ -53,6 +53,12 @@
       path: /Audio/Items/eating_1.ogg
   - type: Spillable
     solution: food
+  - type: MeleeWeapon
+    soundNoDamage:
+      path: "/Audio/Effects/Fluids/splat.ogg"
+    damage:
+      types:
+        Blunt: 0
   - type: TrashOnEmpty
     solution: food
 

Resources/Prototypes/Entities/Objects/Consumable/Food/soup.yml

@@ -26,6 +26,13 @@
         Blunt: 5
   - type: Spillable
     solution: food
+  # soup weapon!
+  - type: MeleeWeapon
+    soundNoDamage:
+      path: "/Audio/Effects/Fluids/splat.ogg"
+    damage:
+      types:
+        Blunt: 0
   - type: Damageable
     damageContainer: Inorganic
   - type: Destructible

Resources/Prototypes/Entities/Objects/Specific/chemistry-bottles.yml

@@ -42,6 +42,12 @@
     sprite: Objects/Specific/Chemistry/beaker.rsi
   - type: Spillable
     solution: drink
+  - type: MeleeWeapon
+    soundNoDamage:
+      path: "/Audio/Effects/Fluids/splat.ogg"
+    damage:
+      types:
+        Blunt: 0
   - type: TrashOnEmpty
     solution: drink
   - type: StaticPrice

Resources/Prototypes/Entities/Objects/Specific/chemistry.yml

@@ -16,6 +16,12 @@
         visible: false
   - type: Item
     sprite: Objects/Specific/Chemistry/beaker.rsi
+  - type: MeleeWeapon
+    soundNoDamage:
+      path: "/Audio/Effects/Fluids/splat.ogg"
+    damage:
+      types:
+        Blunt: 0
   - type: SolutionContainerManager
     solutions:
       beaker:

Resources/Prototypes/Entities/Objects/Tools/bucket.yml

@@ -35,6 +35,12 @@
     interfaces:
     - key: enum.TransferAmountUiKey.Key
       type: TransferAmountBoundUserInterface
+  - type: MeleeWeapon
+    soundNoDamage:
+      path: "/Audio/Effects/Fluids/splat.ogg"
+    damage:
+      types:
+        Blunt: 0
   - type: Spillable
     solution: bucket
   - type: DrawableSolution