Make mopping predicted (and some other stuff) (#38749)

* refactor: move puddle evaporation + absorbents to shared

* refactor: move SolutionRegeneration to shared

* refactor: make AbsorbentSystem visuals clientside

* style: general formatting/cleanup on touched files

- Few logical simplifications
- Add field for hard-coded sparkle effect ent
- Switch stuff to Entity<T>

No actual prediction fixes in this commit (though in
retrospect I should've done this commit last).

* fix: use predicted variants for predicted code

* fix: average out evaporation rates in mixtures

* refactor: move SolutionPurge to shared

* style: Basic SolutionPurgeComponent field cleanup

* fix: general prediction + timing + networking fixes

- Moves client side visuals back to shared because other
  players exist
- Don't accumulate CurTime in Purge/RegenerationSystem
- Network the next update field in Purge/RegenerationSystem to
  deal with UI mispredictions???

* fix: add udder bug workaround

Not needed for SolutionPurgeSystem which doesn't resolve
solutions (probably fine that SolutionPurgeSystem doesn't
cache since it's much rarer, though it probably should), and
likely not needed for AbsorbentSystem since it only resolves
against puddles which, I don't think can be in containers.

* fix: don't divide by zero for evaporation speed = 0.

* refactor: revert evaporation changes

Will cherry-pick these out in another PR.

Also reverting the evaporation speed bugfix since it's easier
to revert all at once. :)

* fix: component cleanup; autopause fields, use ProtoID

* fix: remove unused AbsorbentComponentState

* fix: ProtoId is not string

* refactor: move PuddleSystem.UpdateAppearance to shared

* style: general PuddleSystem.UpdateAppearance tweaks

- Switch to Entity<T>
- Use ProtoIds
- Minor simplifications

* fix: add udderly silly PVS workaround

* cleanup

* fix

---------

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

Content.Shared/Fluids/AbsorbentComponent.cs

@@ -2,16 +2,22 @@ using Content.Shared.Audio;
 using Content.Shared.FixedPoint;
 using Robust.Shared.Audio;
 using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
 
 namespace Content.Shared.Fluids;
 
 /// <summary>
 /// For entities that can clean up puddles
 /// </summary>
-[RegisterComponent, NetworkedComponent]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
 public sealed partial class AbsorbentComponent : Component
 {
-    public Dictionary<Color, float> Progress = new();
+    /// <summary>
+    /// Used by the client to display a bar showing the reagents contained when held.
+    /// Has to still be networked in case the item is given to someone who didn't see a mop in PVS.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public Dictionary<Color, float> Progress = [];
 
     /// <summary>
     /// Name for solution container, that should be used for absorbed solution storage and as source of absorber solution.
@@ -26,23 +32,23 @@ public sealed partial class AbsorbentComponent : Component
     [DataField]
     public FixedPoint2 PickupAmount = FixedPoint2.New(100);
 
+    /// <summary>
+    /// The effect spawned when the puddle fully evaporates.
+    /// </summary>
     [DataField]
-    public SoundSpecifier PickupSound = new SoundPathSpecifier("/Audio/Effects/Fluids/watersplash.ogg")
-    {
-        Params = AudioParams.Default.WithVariation(SharedContentAudioSystem.DefaultVariation),
-    };
+    public EntProtoId MoppedEffect = "PuddleSparkle";
 
-    [DataField] public SoundSpecifier TransferSound =
-        new SoundPathSpecifier("/Audio/Effects/Fluids/slosh.ogg")
-        {
-            Params = AudioParams.Default.WithVariation(SharedContentAudioSystem.DefaultVariation).WithVolume(-3f),
-        };
+    [DataField]
+    public SoundSpecifier PickupSound = new SoundPathSpecifier("/Audio/Effects/Fluids/watersplash.ogg",
+        AudioParams.Default.WithVariation(SharedContentAudioSystem.DefaultVariation));
+
+    [DataField]
+    public SoundSpecifier TransferSound = new SoundPathSpecifier("/Audio/Effects/Fluids/slosh.ogg",
+        AudioParams.Default.WithVariation(SharedContentAudioSystem.DefaultVariation).WithVolume(-3f));
 
     public static readonly SoundSpecifier DefaultTransferSound =
-        new SoundPathSpecifier("/Audio/Effects/Fluids/slosh.ogg")
-        {
-            Params = AudioParams.Default.WithVariation(SharedContentAudioSystem.DefaultVariation).WithVolume(-3f),
-        };
+        new SoundPathSpecifier("/Audio/Effects/Fluids/slosh.ogg",
+            AudioParams.Default.WithVariation(SharedContentAudioSystem.DefaultVariation).WithVolume(-3f));
 
     /// <summary>
     /// Marker that absorbent component owner should try to use 'absorber solution' to replace solution to be absorbed.

Content.Shared/Fluids/Components/EvaporationComponent.cs

@@ -1,5 +1,6 @@
 using Content.Shared.FixedPoint;
 using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
 
 namespace Content.Shared.Fluids.Components;
@@ -7,19 +8,25 @@ namespace Content.Shared.Fluids.Components;
 /// <summary>
 /// Added to puddles that contain water so it may evaporate over time.
 /// </summary>
-[NetworkedComponent]
+[NetworkedComponent, AutoGenerateComponentPause]
 [RegisterComponent, Access(typeof(SharedPuddleSystem))]
 public sealed partial class EvaporationComponent : Component
 {
     /// <summary>
     /// The next time we remove the EvaporationSystem reagent amount from this entity.
     /// </summary>
-    [ViewVariables(VVAccess.ReadWrite), DataField("nextTick", customTypeSerializer: typeof(TimeOffsetSerializer))]
-    public TimeSpan NextTick = TimeSpan.Zero;
+    [AutoPausedField, DataField(customTypeSerializer: typeof(TimeOffsetSerializer))]
+    public TimeSpan NextTick;
 
     /// <summary>
     /// Evaporation factor. Multiplied by the evaporating speed of the reagent.
     /// </summary>
-    [DataField("evaporationAmount")]
+    [DataField]
     public FixedPoint2 EvaporationAmount = FixedPoint2.New(1);
+
+    /// <summary>
+    /// The effect spawned when the puddle fully evaporates.
+    /// </summary>
+    [DataField]
+    public EntProtoId EvaporationEffect = "PuddleSparkle";
 }

Content.Shared/Fluids/SharedAbsorbentSystem.cs

@@ -1,6 +1,16 @@
-using System.Linq;
-using Robust.Shared.GameStates;
-using Robust.Shared.Serialization;
+using System.Numerics;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.FixedPoint;
+using Content.Shared.Fluids.Components;
+using Content.Shared.Interaction;
+using Content.Shared.Item;
+using Content.Shared.Popups;
+using Content.Shared.Timing;
+using Content.Shared.Weapons.Melee;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Prototypes;
 
 namespace Content.Shared.Fluids;
 
@@ -9,41 +19,338 @@ namespace Content.Shared.Fluids;
 /// </summary>
 public abstract class SharedAbsorbentSystem : EntitySystem
 {
+    [Dependency] private readonly IPrototypeManager _proto = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly SharedPopupSystem _popups = default!;
+    [Dependency] protected readonly SharedPuddleSystem Puddle = default!;
+    [Dependency] private readonly SharedMeleeWeaponSystem _melee = default!;
+    [Dependency] private readonly SharedTransformSystem _transform = default!;
+    [Dependency] protected readonly SharedSolutionContainerSystem SolutionContainer = default!;
+    [Dependency] private readonly UseDelaySystem _useDelay = default!;
+    [Dependency] private readonly SharedMapSystem _mapSystem = default!;
+    [Dependency] private readonly SharedItemSystem _item = default!;
+
     public override void Initialize()
     {
         base.Initialize();
-        SubscribeLocalEvent<AbsorbentComponent, ComponentGetState>(OnAbsorbentGetState);
-        SubscribeLocalEvent<AbsorbentComponent, ComponentHandleState>(OnAbsorbentHandleState);
+
+        SubscribeLocalEvent<AbsorbentComponent, AfterInteractEvent>(OnAfterInteract);
+        SubscribeLocalEvent<AbsorbentComponent, UserActivateInWorldEvent>(OnActivateInWorld);
+        SubscribeLocalEvent<AbsorbentComponent, SolutionContainerChangedEvent>(OnAbsorbentSolutionChange);
     }
 
-    private void OnAbsorbentHandleState(EntityUid uid, AbsorbentComponent component, ref ComponentHandleState args)
+    private void OnActivateInWorld(Entity<AbsorbentComponent> ent, ref UserActivateInWorldEvent args)
     {
-        if (args.Current is not AbsorbentComponentState state)
+        if (args.Handled)
             return;
 
-        if (component.Progress.OrderBy(x => x.Key.ToArgb()).SequenceEqual(state.Progress))
+        Mop(ent, args.User, args.Target);
+        args.Handled = true;
+    }
+
+    private void OnAfterInteract(Entity<AbsorbentComponent> ent, ref AfterInteractEvent args)
+    {
+        if (!args.CanReach || args.Handled || args.Target is not { } target)
             return;
 
-        component.Progress.Clear();
-        foreach (var item in state.Progress)
-        {
-            component.Progress.Add(item.Key, item.Value);
-        }
+        Mop(ent, args.User, target);
+        args.Handled = true;
     }
 
-    private void OnAbsorbentGetState(EntityUid uid, AbsorbentComponent component, ref ComponentGetState args)
+    private void OnAbsorbentSolutionChange(Entity<AbsorbentComponent> ent, ref SolutionContainerChangedEvent args)
     {
-        args.State = new AbsorbentComponentState(component.Progress);
+        if (!SolutionContainer.TryGetSolution(ent.Owner, ent.Comp.SolutionName, out _, out var solution))
+            return;
+
+        ent.Comp.Progress.Clear();
+
+        var absorbentReagents = Puddle.GetAbsorbentReagents(solution);
+        var mopReagent = solution.GetTotalPrototypeQuantity(absorbentReagents);
+        if (mopReagent > FixedPoint2.Zero)
+            ent.Comp.Progress[solution.GetColorWithOnly(_proto, absorbentReagents)] = mopReagent.Float();
+
+        var otherColor = solution.GetColorWithout(_proto, absorbentReagents);
+        var other = solution.Volume - mopReagent;
+        if (other > FixedPoint2.Zero)
+            ent.Comp.Progress[otherColor] = other.Float();
+
+        if (solution.AvailableVolume > FixedPoint2.Zero)
+            ent.Comp.Progress[Color.DarkGray] = solution.AvailableVolume.Float();
+
+        Dirty(ent);
+        _item.VisualsChanged(ent);
     }
 
-    [Serializable, NetSerializable]
-    protected sealed class AbsorbentComponentState : ComponentState
+    [Obsolete("Use Entity<T> variant")]
+    public void Mop(EntityUid user, EntityUid target, EntityUid used, AbsorbentComponent component)
     {
-        public Dictionary<Color, float> Progress;
+        Mop((used, component), user, target);
+    }
 
-        public AbsorbentComponentState(Dictionary<Color, float> progress)
+    public void Mop(Entity<AbsorbentComponent> absorbEnt, EntityUid user, EntityUid target)
+    {
+        if (!SolutionContainer.TryGetSolution(absorbEnt.Owner, absorbEnt.Comp.SolutionName, out var absorberSoln))
+            return;
+
+        // Use the non-optional form of IsDelayed to safe the TryComp in Mop
+        if (TryComp<UseDelayComponent>(absorbEnt, out var useDelay)
+            && _useDelay.IsDelayed((absorbEnt.Owner, useDelay)))
+            return;
+
+        // Try to slurp up the puddle.
+        // We're then done if our mop doesn't use absorber solutions, since those don't need refilling.
+        if (TryPuddleInteract((absorbEnt.Owner, absorbEnt.Comp, useDelay), absorberSoln.Value, user, target)
+            || !absorbEnt.Comp.UseAbsorberSolution)
+            return;
+
+        // If it's refillable try to transfer
+        TryRefillableInteract((absorbEnt.Owner, absorbEnt.Comp, useDelay), absorberSoln.Value, user, target);
+    }
+
+    /// <summary>
+    ///     Logic for an absorbing entity interacting with a refillable.
+    /// </summary>
+    private bool TryRefillableInteract(Entity<AbsorbentComponent, UseDelayComponent?> absorbEnt,
+        Entity<SolutionComponent> absorbentSoln,
+        EntityUid user,
+        EntityUid target)
+    {
+        if (!TryComp<RefillableSolutionComponent>(target, out var refillable))
+            return false;
+
+        if (!SolutionContainer.TryGetRefillableSolution((target, refillable, null),
+                out var refillableSoln,
+                out var refillableSolution))
+            return false;
+
+        if (refillableSolution.Volume <= 0)
         {
-            Progress = progress;
+            // Target empty - only transfer absorbent contents into refillable
+            if (!TryTransferFromAbsorbentToRefillable(absorbEnt, absorbentSoln, refillableSoln.Value, user, target))
+                return false;
         }
+        else
+        {
+            // Target non-empty - do a two-way transfer
+            if (!TryTwoWayAbsorbentRefillableTransfer(absorbEnt, absorbentSoln, refillableSoln.Value, user, target))
+                return false;
+        }
+
+        var (used, absorber, useDelay) = absorbEnt;
+        _audio.PlayPredicted(absorber.TransferSound, target, user);
+
+        if (useDelay != null)
+            _useDelay.TryResetDelay((used, useDelay));
+
+        return true;
+    }
+
+    /// <summary>
+    ///     Logic for an transferring solution from absorber to an empty refillable.
+    /// </summary>
+    private bool TryTransferFromAbsorbentToRefillable(Entity<AbsorbentComponent> absorbEnt,
+        Entity<SolutionComponent> absorbentSoln,
+        Entity<SolutionComponent> refillableSoln,
+        EntityUid user,
+        EntityUid target)
+    {
+        var absorbentSolution = absorbentSoln.Comp.Solution;
+        if (absorbentSolution.Volume <= 0)
+        {
+            _popups.PopupClient(Loc.GetString("mopping-system-target-container-empty", ("target", target)), user, user);
+            return false;
+        }
+
+        var refillableSolution = refillableSoln.Comp.Solution;
+        var transferAmount = absorbEnt.Comp.PickupAmount < refillableSolution.AvailableVolume
+            ? absorbEnt.Comp.PickupAmount
+            : refillableSolution.AvailableVolume;
+
+        if (transferAmount <= 0)
+        {
+            _popups.PopupClient(Loc.GetString("mopping-system-full", ("used", absorbEnt)), absorbEnt, user);
+            return false;
+        }
+
+        // Prioritize transferring non-evaporatives if absorbent has any
+        var contaminants = SolutionContainer.SplitSolutionWithout(absorbentSoln,
+            transferAmount,
+            Puddle.GetAbsorbentReagents(absorbentSoln.Comp.Solution));
+
+        SolutionContainer.TryAddSolution(refillableSoln,
+            contaminants.Volume > 0
+                ? contaminants
+                : SolutionContainer.SplitSolution(absorbentSoln, transferAmount));
+
+        return true;
+    }
+
+    /// <summary>
+    ///     Logic for an transferring contaminants to a non-empty refillable & reabsorbing water if any available.
+    /// </summary>
+    private bool TryTwoWayAbsorbentRefillableTransfer(Entity<AbsorbentComponent> absorbEnt,
+        Entity<SolutionComponent> absorbentSoln,
+        Entity<SolutionComponent> refillableSoln,
+        EntityUid user,
+        EntityUid target)
+    {
+        var contaminantsFromAbsorbent = SolutionContainer.SplitSolutionWithout(absorbentSoln,
+            absorbEnt.Comp.PickupAmount,
+            Puddle.GetAbsorbentReagents(absorbentSoln.Comp.Solution));
+
+        var absorbentSolution = absorbentSoln.Comp.Solution;
+        if (contaminantsFromAbsorbent.Volume == FixedPoint2.Zero
+            && absorbentSolution.AvailableVolume == FixedPoint2.Zero)
+        {
+            // Nothing to transfer to refillable and no room to absorb anything extra
+            _popups.PopupClient(Loc.GetString("mopping-system-puddle-space", ("used", absorbEnt)), user, user);
+
+            // We can return cleanly because nothing was split from absorbent solution
+            return false;
+        }
+
+        var waterPulled = absorbEnt.Comp.PickupAmount < absorbentSolution.AvailableVolume
+            ? absorbEnt.Comp.PickupAmount
+            : absorbentSolution.AvailableVolume;
+
+        var refillableSolution = refillableSoln.Comp.Solution;
+        var waterFromRefillable =
+            refillableSolution.SplitSolutionWithOnly(waterPulled,
+                Puddle.GetAbsorbentReagents(refillableSoln.Comp.Solution));
+        SolutionContainer.UpdateChemicals(refillableSoln);
+
+        if (waterFromRefillable.Volume == FixedPoint2.Zero && contaminantsFromAbsorbent.Volume == FixedPoint2.Zero)
+        {
+            // Nothing to transfer in either direction
+            _popups.PopupClient(Loc.GetString("mopping-system-target-container-empty-water", ("target", target)),
+                user,
+                user);
+
+            // We can return cleanly because nothing was split from refillable solution
+            return false;
+        }
+
+        var anyTransferOccurred = false;
+
+        if (waterFromRefillable.Volume > FixedPoint2.Zero)
+        {
+            // transfer water to absorbent
+            SolutionContainer.TryAddSolution(absorbentSoln, waterFromRefillable);
+            anyTransferOccurred = true;
+        }
+
+        if (contaminantsFromAbsorbent.Volume <= 0)
+            return anyTransferOccurred;
+
+        if (refillableSolution.AvailableVolume <= 0)
+        {
+            _popups.PopupClient(Loc.GetString("mopping-system-full", ("used", target)), user, user);
+        }
+        else
+        {
+            // transfer as much contaminants to refillable as will fit
+            var contaminantsForRefillable = contaminantsFromAbsorbent.SplitSolution(refillableSolution.AvailableVolume);
+            SolutionContainer.TryAddSolution(refillableSoln, contaminantsForRefillable);
+            anyTransferOccurred = true;
+        }
+
+        // absorb everything that did not fit in the refillable back by the absorbent
+        SolutionContainer.TryAddSolution(absorbentSoln, contaminantsFromAbsorbent);
+
+        return anyTransferOccurred;
+    }
+
+    /// <summary>
+    ///     Logic for an absorbing entity interacting with a puddle.
+    /// </summary>
+    private bool TryPuddleInteract(Entity<AbsorbentComponent, UseDelayComponent?> absorbEnt,
+        Entity<SolutionComponent> absorberSoln,
+        EntityUid user,
+        EntityUid target)
+    {
+        if (!TryComp<PuddleComponent>(target, out var puddle))
+            return false;
+
+        if (!SolutionContainer.ResolveSolution(target, puddle.SolutionName, ref puddle.Solution, out var puddleSolution)
+            || puddleSolution.Volume <= 0)
+            return false;
+
+        var (_, absorber, useDelay) = absorbEnt;
+
+        Solution puddleSplit;
+        var isRemoved = false;
+        if (absorber.UseAbsorberSolution)
+        {
+            // No reason to mop something that 1) can evaporate, 2) is an absorber, and 3) is being mopped with
+            // something that uses absorbers.
+            var puddleAbsorberVolume =
+                puddleSolution.GetTotalPrototypeQuantity(Puddle.GetAbsorbentReagents(puddleSolution));
+            if (puddleAbsorberVolume == puddleSolution.Volume)
+            {
+                _popups.PopupClient(Loc.GetString("mopping-system-puddle-already-mopped", ("target", target)),
+                    target,
+                    user);
+                return true;
+            }
+
+            // Check if we have any evaporative reagents on our absorber to transfer
+            var absorberSolution = absorberSoln.Comp.Solution;
+            var available = absorberSolution.GetTotalPrototypeQuantity(Puddle.GetAbsorbentReagents(absorberSolution));
+
+            // No material
+            if (available == FixedPoint2.Zero)
+            {
+                _popups.PopupClient(Loc.GetString("mopping-system-no-water", ("used", absorbEnt)), absorbEnt, user);
+                return true;
+            }
+
+            var transferMax = absorber.PickupAmount;
+            var transferAmount = available > transferMax ? transferMax : available;
+
+            puddleSplit =
+                puddleSolution.SplitSolutionWithout(transferAmount, Puddle.GetAbsorbentReagents(puddleSolution));
+            var absorberSplit =
+                absorberSolution.SplitSolutionWithOnly(puddleSplit.Volume,
+                    Puddle.GetAbsorbentReagents(absorberSolution));
+
+            // Do tile reactions first
+            var targetXform = Transform(target);
+            var gridUid = targetXform.GridUid;
+            if (TryComp<MapGridComponent>(gridUid, out var mapGrid))
+            {
+                var tileRef = _mapSystem.GetTileRef(gridUid.Value, mapGrid, targetXform.Coordinates);
+                Puddle.DoTileReactions(tileRef, absorberSplit);
+            }
+            SolutionContainer.AddSolution(puddle.Solution.Value, absorberSplit);
+        }
+        else
+        {
+            // Note: arguably shouldn't this get all solutions?
+            puddleSplit = puddleSolution.SplitSolutionWithout(absorber.PickupAmount, Puddle.GetAbsorbentReagents(puddleSolution));
+            // Despawn if we're done
+            if (puddleSolution.Volume == FixedPoint2.Zero)
+            {
+                // Spawn a *sparkle*
+                PredictedSpawnAttachedTo(absorber.MoppedEffect, Transform(target).Coordinates);
+                PredictedQueueDel(target);
+                isRemoved = true;
+            }
+        }
+
+        SolutionContainer.AddSolution(absorberSoln, puddleSplit);
+
+        _audio.PlayPredicted(absorber.PickupSound, isRemoved ? absorbEnt : target, user);
+
+        if (useDelay != null)
+            _useDelay.TryResetDelay((absorbEnt, useDelay));
+
+        var userXform = Transform(user);
+        var targetPos = _transform.GetWorldPosition(target);
+        var localPos = Vector2.Transform(targetPos, _transform.GetInvWorldMatrix(userXform));
+        localPos = userXform.LocalRotation.RotateVec(localPos);
+
+        _melee.DoLunge(user, absorbEnt, Angle.Zero, localPos, null);
+
+        return true;
     }
 }

Content.Shared/Fluids/SharedPuddleSystem.cs

@@ -1,3 +1,4 @@
+using System.Linq;
 using Content.Shared.Chemistry.Components;
 using Content.Shared.Chemistry.EntitySystems;
 using Content.Shared.Chemistry.Reagent;
@@ -8,6 +9,7 @@ using Content.Shared.FixedPoint;
 using Content.Shared.Fluids.Components;
 using Content.Shared.Movement.Events;
 using Content.Shared.StepTrigger.Components;
+using Robust.Shared.Containers;
 using Robust.Shared.Map;
 using Robust.Shared.Prototypes;
 
@@ -16,9 +18,16 @@ namespace Content.Shared.Fluids;
 public abstract partial class SharedPuddleSystem : EntitySystem
 {
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
     [Dependency] private readonly SharedSolutionContainerSystem _solutionContainerSystem = default!;
     [Dependency] private readonly SharedDoAfterSystem _doAfterSystem = default!;
 
+    private static readonly ProtoId<ReagentPrototype> Blood = "Blood";
+    private static readonly ProtoId<ReagentPrototype> Slime = "Slime";
+    private static readonly ProtoId<ReagentPrototype> CopperBlood = "CopperBlood";
+
+    private static readonly string[] StandoutReagents = [Blood, Slime, CopperBlood];
+
     /// <summary>
     /// The lowest threshold to be considered for puddle sprite states as well as slipperiness of a puddle.
     /// </summary>
@@ -33,12 +42,23 @@ public abstract partial class SharedPuddleSystem : EntitySystem
         SubscribeLocalEvent<DumpableSolutionComponent, CanDropTargetEvent>(OnDumpCanDropTarget);
         SubscribeLocalEvent<DrainableSolutionComponent, CanDropTargetEvent>(OnDrainCanDropTarget);
         SubscribeLocalEvent<RefillableSolutionComponent, CanDropDraggedEvent>(OnRefillableCanDropDragged);
+
+        SubscribeLocalEvent<PuddleComponent, SolutionContainerChangedEvent>(OnSolutionUpdate);
         SubscribeLocalEvent<PuddleComponent, GetFootstepSoundEvent>(OnGetFootstepSound);
         SubscribeLocalEvent<PuddleComponent, ExaminedEvent>(HandlePuddleExamined);
+        SubscribeLocalEvent<PuddleComponent, EntRemovedFromContainerMessage>(OnEntRemoved);
 
         InitializeSpillable();
     }
 
+    protected virtual void OnSolutionUpdate(Entity<PuddleComponent> entity, ref SolutionContainerChangedEvent args)
+    {
+        if (args.SolutionId != entity.Comp.SolutionName)
+            return;
+
+        UpdateAppearance((entity, entity.Comp));
+    }
+
     private void OnRefillableCanDrag(Entity<RefillableSolutionComponent> entity, ref CanDragEvent args)
     {
         args.Handled = true;
@@ -110,6 +130,68 @@ public abstract partial class SharedPuddleSystem : EntitySystem
         }
     }
 
+    // Workaround for https://github.com/space-wizards/space-station-14/pull/35314
+    private void OnEntRemoved(Entity<PuddleComponent> ent, ref EntRemovedFromContainerMessage args)
+    {
+        // Make sure the removed entity was our contained solution and clear our cached reference
+        if (args.Entity == ent.Comp.Solution?.Owner)
+            ent.Comp.Solution = null;
+    }
+
+    private void UpdateAppearance(Entity<PuddleComponent?, AppearanceComponent?> ent)
+    {
+        var (uid, puddle, appearance) = ent;
+        if (!Resolve(ent, ref puddle, ref appearance))
+            return;
+
+        var volume = FixedPoint2.Zero;
+        var color = Color.White;
+
+        if (_solutionContainerSystem.ResolveSolution(uid,
+                puddle.SolutionName,
+                ref puddle.Solution,
+                out var solution))
+        {
+            volume = solution.Volume / puddle.OverflowVolume;
+
+            // Make blood stand out more
+            // Kinda EH
+            // Could potentially do alpha per-solution but future problem.
+
+            color = solution.GetColorWithout(_prototypeManager, StandoutReagents);
+            color = color.WithAlpha(0.7f);
+
+            foreach (var standout in StandoutReagents)
+            {
+                var quantity = solution.GetTotalPrototypeQuantity(standout);
+                if (quantity <= FixedPoint2.Zero)
+                    continue;
+
+                var interpolateValue = quantity.Float() / solution.Volume.Float();
+                color = Color.InterpolateBetween(color,
+                    _prototypeManager.Index<ReagentPrototype>(standout).SubstanceColor,
+                    interpolateValue);
+            }
+        }
+
+        _appearance.SetData(ent, PuddleVisuals.CurrentVolume, volume.Float(), appearance);
+        _appearance.SetData(ent, PuddleVisuals.SolutionColor, color, appearance);
+    }
+
+    public void DoTileReactions(TileRef tileRef, Solution solution)
+    {
+        for (var i = solution.Contents.Count - 1; i >= 0; i--)
+        {
+            var (reagent, quantity) = solution.Contents[i];
+            var proto = _prototypeManager.Index<ReagentPrototype>(reagent.Prototype);
+            var removed = proto.ReactionTile(tileRef, quantity, EntityManager, reagent.Data);
+            if (removed <= FixedPoint2.Zero)
+                continue;
+
+            solution.RemoveReagent(reagent, removed);
+        }
+    }
+
     #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.