After all this time, finally, stains

Content.Client/_Funkystation/Stains/StainSystem.cs

@@ -0,0 +1,76 @@
+using Content.Client.Clothing;
+using Content.Client.Items.Systems;
+using Content.Shared._Funkystation.Stains.Components;
+using Content.Shared._Funkystation.Stains.Systems;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.Clothing;
+using Content.Shared.FixedPoint;
+using Content.Shared.Hands;
+using Robust.Client.GameObjects;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client._Funkystation.Stains;
+
+public sealed partial class StainSystem : SharedStainSystem
+{
+    [Dependency] private IPrototypeManager _prototypeManager = null!;
+    [Dependency] private SharedSolutionContainerSystem _solution = null!;
+    [Dependency] private SpriteSystem _sprite = null!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<StainableComponent, AppearanceChangeEvent>(OnAppearanceChanged);
+        SubscribeLocalEvent<StainableComponent, GetEquipmentVisualsEvent>(OnEquipmentVisuals, after: [typeof(ClientClothingSystem)]);
+        SubscribeLocalEvent<StainableComponent, GetInhandVisualsEvent>(OnInhandVisuals, after: [typeof(ItemSystem)]);
+    }
+
+    private void OnAppearanceChanged(Entity<StainableComponent> ent, ref AppearanceChangeEvent args)
+    {
+        if (args.Sprite == null)
+            return;
+
+        var spriteEnt = new Entity<SpriteComponent?>(ent.Owner, args.Sprite);
+
+        var layers = new List<int>(ent.Comp.RevealedLayers);
+        layers.Sort((a, b) => b.CompareTo(a));
+
+        foreach (var layer in layers)
+        {
+            _sprite.RemoveLayer(spriteEnt, layer);
+        }
+
+        ent.Comp.RevealedLayers.Clear();
+
+        foreach (var (_, layerData) in BuildVisuals(ent, ent.Comp.IconVisuals, "icon"))
+        {
+            ent.Comp.RevealedLayers.Add(_sprite.AddLayer(spriteEnt, layerData, null));
+        }
+    }
+
+    private void OnEquipmentVisuals(Entity<StainableComponent> ent, ref GetEquipmentVisualsEvent args)
+    {
+        if (ent.Comp.ClothingVisuals.TryGetValue(args.Slot, out var layers))
+            args.Layers.AddRange(BuildVisuals(ent, layers, args.Slot));
+    }
+
+    private void OnInhandVisuals(Entity<StainableComponent> ent, ref GetInhandVisualsEvent args)
+    {
+        if (ent.Comp.ItemVisuals.TryGetValue(args.Location.ToString(), out var layers))
+            args.Layers.AddRange(BuildVisuals(ent, layers, args.Location.ToString()));
+    }
+
+    private IEnumerable<(string, PrototypeLayerData)> BuildVisuals(Entity<StainableComponent> ent, List<PrototypeLayerData> templates, string prefix)
+    {
+        if (!_solution.TryGetSolution(ent.Owner, ent.Comp.SolutionName, out _, out var sol) || sol.Volume <= FixedPoint2.Zero)
+            yield break;
+
+        var color = sol.GetColor(_prototypeManager);
+        for (var i = 0; i < templates.Count; i++)
+        {
+            var layer = templates[i];
+            layer.Color = color;
+            yield return ($"stain-{prefix}-{i}", layer);
+        }
+    }
+}

Content.Client/_Funkystation/WashingMachine/WashingMachineSystem.cs

@@ -0,0 +1,5 @@
+using Content.Shared._Funkystation.WashingMachine;
+
+namespace Content.Client._Funkystation.WashingMachine;
+
+public sealed class WashingMachineSystem : SharedWashingMachineSystem;

Content.Server/Fluids/EntitySystems/PuddleSystem.cs

@@ -14,9 +14,16 @@
 using Content.Shared.Maps;
 using Content.Shared.Popups;
 using Content.Shared.Slippery;
+using Content.Shared.Inventory;
+using Content.Shared._Funkystation.Fluids;
+using Content.Shared.Gravity;
+using Content.Shared.Standing;
+using Content.Shared.StepTrigger.Systems;
 using Robust.Shared.Collections;
 using Robust.Shared.Map;
 using Robust.Shared.Map.Components;
+using Robust.Shared.Physics.Components;
+using Robust.Shared.Physics.Events;
 using Robust.Shared.Player;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
@@ -36,7 +43,6 @@ public sealed partial class PuddleSystem : SharedPuddleSystem
     [Dependency] private SharedSolutionContainerSystem _solutionContainerSystem = default!;
     [Dependency] private SharedTransformSystem _transform = default!;
     [Dependency] private TurfSystem _turf = default!;
-
     private EntityQuery<PuddleComponent> _puddleQuery;
 
     /*
@@ -265,6 +271,14 @@ private void OnPuddleSlip(Entity<PuddleComponent> entity, ref SlipEvent args)
         // Take 15% of the puddle solution
         var splitSol = _solutionContainerSystem.SplitSolution(entity.Comp.Solution.Value, solution.Volume * 0.15f);
         Reactive.DoEntityReaction(args.Slipped, splitSol, ReactionMethod.Touch);
+
+        // Funky - Start - Clothing stains
+        if (splitSol.Volume > 0)
+        {
+            var stainEv = new SpilledOnEvent(entity.Owner, splitSol.Clone());
+            RaiseLocalEvent(args.Slipped, stainEv);
+        }
+        // Funky - End
     }
 
     /// <summary>
@@ -430,6 +444,12 @@ public override bool TrySplashSpillAt(EntityUid entity,
 
             targets.Add(owner);
             Reactive.DoEntityReaction(owner, splitSolution, ReactionMethod.Touch);
+
+            // Funky - Start - Clothing stains
+            if (splitSolution.Volume > 0)
+                RaiseLocalEvent(owner, new SpilledOnEvent(entity, splitSolution.Clone()));
+            // Funky - End
+
             Popups.PopupEntity(Loc.GetString("spill-land-spilled-on-other",
                     ("spillable", entity),
                     ("target", Identity.Entity(owner, EntityManager))),

Content.Server/_Funkystation/Stains/StainSystem.cs

@@ -0,0 +1,21 @@
+using Content.Shared._Funkystation.Stains.Components;
+using Content.Shared._Funkystation.Stains.Systems;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Tag;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server._Funkystation.Stains;
+
+public sealed partial class StainSystem : SharedStainSystem
+{
+    [Dependency] private TagSystem _tag = null!;
+
+    private static readonly ProtoId<TagPrototype> Tag = "DNASolutionScannable";
+
+    protected override void OnStained(Entity<StainableComponent> ent, Entity<SolutionComponent> solution)
+    {
+        base.OnStained(ent, solution);
+
+        _tag.AddTag(ent.Owner, Tag);
+    }
+}

Content.Server/_Funkystation/WashingMachine/WashingMachineSystem.cs

@@ -0,0 +1,52 @@
+using Content.Shared._Funkystation.WashingMachine;
+using Content.Shared._Funkystation.Stains.Components;
+using Content.Shared._Funkystation.Stains.Systems;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Prototypes;
+using Content.Shared.Destructible;
+using Content.Shared.Storage.Components;
+using Content.Server.Forensics;
+using Content.Shared.Clothing.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using System.Linq;
+using Content.Shared.Chemistry;
+using Content.Shared.Damage.Systems;
+
+namespace Content.Server._Funkystation.WashingMachine;
+
+public sealed partial class WashingMachineSystem : SharedWashingMachineSystem
+{
+    [Dependency] private SharedSolutionContainerSystem _solution = null!;
+    [Dependency] private ForensicsSystem _forensics = null!;
+
+    protected override void UpdateForensics(Entity<WashingMachineComponent> ent, HashSet<EntityUid> items)
+    {
+        if (!TryComp<ForensicsComponent>(ent.Owner, out var forensics))
+            return;
+
+        foreach (var item in items)
+        {
+            // Pull DNA out of the item's stain solution before the shared FinishWash washes it out.
+            if (TryComp<StainableComponent>(item, out var stain)
+                && _solution.TryGetSolution(item, stain.SolutionName, out var sol))
+            {
+                forensics.DNAs.UnionWith(_forensics.GetSolutionsDNA(sol.Value.Comp.Solution));
+            }
+
+            if (!TryComp<FiberComponent>(item, out var fiber))
+                continue;
+
+            var fiberText = fiber.FiberColor == null
+                ? Loc.GetString("forensic-fibers", ("material", fiber.FiberMaterial))
+                : Loc.GetString("forensic-fibers-colored",
+                    ("color", fiber.FiberColor),
+                    ("material", fiber.FiberMaterial));
+
+            forensics.Fibers.Add(fiberText);
+        }
+    }
+}

Content.Shared/Fluids/SharedPuddleSystem.Spillable.cs

@@ -16,6 +16,7 @@
 using Content.Shared.Verbs;
 using Content.Shared.Weapons.Melee;
 using Content.Shared.Weapons.Melee.Events;
+using Content.Shared._Funkystation.Fluids;
 using Robust.Shared.Player;
 
 namespace Content.Shared.Fluids;
@@ -163,6 +164,14 @@ private void SplashOnMeleeHit(Entity<SpillableComponent> entity, ref MeleeHitEve
 
             var splitSolution = _solutionContainerSystem.SplitSolution(soln.Value, totalSplit / hitCount);
 
+            // Forky - Start - Stains
+            if (splitSolution.Volume > 0)
+            {
+                var stainEv = new SpilledOnEvent(entity.Owner, splitSolution.Clone());
+                RaiseLocalEvent(hit, stainEv);
+            }
+            // Forky - End
+
             AdminLogger.Add(LogType.MeleeHit,
                 $"{ToPrettyString(args.User):actor} "
                 + $"splashed {SharedSolutionContainerSystem.ToPrettyString(splitSolution):solution} "

Content.Shared/Fluids/SharedPuddleSystem.cs

@@ -1,4 +1,5 @@
 using System.Linq;
+using Content.Shared._Funkystation.Fluids;
 using Content.Shared.Administration.Logs;
 using Content.Shared.Chemistry;
 using Content.Shared.Chemistry.Components;
@@ -10,17 +11,22 @@
 using Content.Shared.FixedPoint;
 using Content.Shared.Fluids.Components;
 using Content.Shared.Friction;
+using Content.Shared.Gravity;
+using Content.Shared.Inventory;
 using Content.Shared.Movement.Components;
 using Content.Shared.Movement.Events;
 using Content.Shared.Movement.Systems;
 using Content.Shared.Nutrition.EntitySystems;
 using Content.Shared.Popups;
 using Content.Shared.Slippery;
+using Content.Shared.Standing;
 using Content.Shared.StepTrigger.Components;
 using Content.Shared.StepTrigger.Systems;
 using Robust.Shared.Audio.Systems;
 using Robust.Shared.Containers;
 using Robust.Shared.Map;
+using Robust.Shared.Physics.Components;
+using Robust.Shared.Physics.Events;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Timing;
 
@@ -41,6 +47,13 @@ public abstract partial class SharedPuddleSystem : EntitySystem
     [Dependency] private SpeedModifierContactsSystem _speedModContacts = default!;
     [Dependency] private StepTriggerSystem _stepTrigger = default!;
     [Dependency] private TileFrictionController _tile = default!;
+    [Dependency] private InventorySystem _inventory = default!; // Funky - Clothing stains
+    [Dependency] private StandingStateSystem _standing = default!; // Moff - Clothing stains
+    [Dependency] private SharedGravitySystem _gravity = default!; // Moff - Clothing Stains
+
+    [Dependency] private EntityQuery<StepTriggerComponent> _stepTriggerQuery = default!;
+    [Dependency] private EntityQuery<ReactiveComponent> _reactiveQuery = default!;
+    [Dependency] private EntityQuery<EvaporationComponent> _evaporationQuery = default!;
 
     private ProtoId<ReagentPrototype>[] _standoutReagents = [];
 
@@ -55,10 +68,6 @@ public abstract partial class SharedPuddleSystem : EntitySystem
     // loses & then gains reagents in a single tick.
     private HashSet<EntityUid> _deletionQueue = [];
 
-    private EntityQuery<StepTriggerComponent> _stepTriggerQuery;
-    private EntityQuery<ReactiveComponent> _reactiveQuery;
-    private EntityQuery<EvaporationComponent> _evaporationQuery;
-
     public override void Initialize()
     {
         base.Initialize();
@@ -98,6 +107,40 @@ public override void Update(float frameTime)
         TickEvaporation();
     }
 
+    // Moff start - we basically rewrote this function compared to what funky has
+    // Using startcollide rather than onstep, since the onstep is messed with by slippable... its bleak
+    [SubscribeLocalEvent]
+    private void OnStepInPuddle(Entity<PuddleComponent> ent, ref StartCollideEvent args)
+    {
+        // The thing stepping in the puddle. Because I keep forgetting which is which
+        var stepper = args.OtherEntity;
+
+        if (!_solutionContainerSystem.ResolveSolution(ent.Owner, ent.Comp.SolutionName, ref ent.Comp.Solution, out var solution))
+            return;
+
+        if (solution.Volume <= FixedPoint2.Zero)
+            return;
+
+        // Check if its in air... because... if you're not on the ground you don't get spilled on
+        if (TryComp<PhysicsComponent>(stepper, out var physicsComp)
+            && (physicsComp.BodyStatus == BodyStatus.InAir || _gravity.IsWeightless(stepper)))
+            return;
+
+        // Choose le target...
+        // if standing and have shoes, just get it on their shoes
+        EntityUid target;
+        if (_standing.IsDown(stepper)) // on the ground, spill it on them in general
+            target = stepper;
+        else if (_inventory.TryGetSlotEntity(stepper, "shoes", out var shoes) && shoes is { } shoeUid)
+            target = shoeUid;
+        else
+            return;
+
+        var spilledEvent = new SpilledOnEvent(ent.Owner, solution);
+        RaiseLocalEvent(target, spilledEvent);
+    }
+    // Moff end
+
     private void OnPrototypesReloaded(PrototypesReloadedEventArgs ev)
     {
         if (ev.WasModified<ReagentPrototype>())

Content.Shared/Inventory/InventorySystem.Relay.cs

@@ -1,3 +1,4 @@
+using Content.Shared._Funkystation.Fluids;
 using Content.Shared.Armor;
 using Content.Shared.Atmos;
 using Content.Shared.Chat;
@@ -112,6 +113,7 @@ public void InitializeRelay()
         SubscribeLocalEvent<InventoryComponent, GetVerbsEvent<EquipmentVerb>>(OnGetEquipmentVerbs);
         SubscribeLocalEvent<InventoryComponent, GetVerbsEvent<InnateVerb>>(OnGetInnateVerbs);
 
+        SubscribeLocalEvent<InventoryComponent, SpilledOnEvent>(RelayInventoryEvent); // Funky - Stains
     }
 
     protected void RefRelayInventoryEvent<T>(EntityUid uid, InventoryComponent component, ref T args) where T : IInventoryRelayEvent

Content.Shared/Medical/VomitSystem.cs

@@ -12,6 +12,7 @@
 using Content.Shared.Nutrition.Components;
 using Content.Shared.Nutrition.EntitySystems;
 using Content.Shared.Popups;
+using Content.Shared._Funkystation.Fluids;
 using Robust.Shared.Audio;
 using Robust.Shared.Audio.Systems;
 using Robust.Shared.Network;
@@ -135,6 +136,11 @@ public void Vomit(EntityUid uid, float thirstAdded = -40f, float hungerAdded = -
             solution.AddReagent(new ReagentId(VomitPrototype, _bloodstream.GetEntityBloodData((uid, bloodStream))), vomitAmount);
         }
 
+        // Forky - Start - Stains
+        var stainEv = new SpilledOnEvent(uid, solution.Clone());
+        RaiseLocalEvent(uid, stainEv);
+        // Forky - End
+
         if (_puddle.TrySpillAt(uid, solution, out var puddle, false))
         {
             _forensics.TransferDna(puddle, uid, false);

Content.Shared/_Funkystation/Fluids/SpilledOnEvent.cs

@@ -0,0 +1,15 @@
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Inventory;
+
+namespace Content.Shared._Funkystation.Fluids;
+
+/// <summary>
+/// Raised when a fluid is spilled on an entity
+/// </summary>
+public sealed class SpilledOnEvent(EntityUid source, Solution solution) : EntityEventArgs, IInventoryRelayEvent
+{
+    public SlotFlags TargetSlots { get; } = SlotFlags.WITHOUT_POCKET;
+
+    public EntityUid Source = source;
+    public Solution Solution = solution;
+}

Content.Shared/_Funkystation/Stains/Components/StainBlockerComponent.cs

@@ -0,0 +1,14 @@
+using Content.Shared.Inventory;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._Funkystation.Stains.Components;
+
+/// <summary>
+/// Prevents entities equipped in specific slots underneath this item from getting stained
+/// </summary>
+[RegisterComponent, NetworkedComponent]
+public sealed partial class StainBlockerComponent : Component
+{
+    [DataField("slots", required: true)]
+    public SlotFlags BlockedSlots;
+}