Vulpkanin Update

Content.Client/Forensics/ScentTrackerSystem.cs

@@ -0,0 +1,31 @@
+using Content.Shared.Forensics;
+using Robust.Shared.Random;
+using Robust.Shared.Timing;
+using Robust.Client.Player;
+
+namespace Content.Client.Forensics
+{
+    public sealed class ScentTrackerSystem : EntitySystem
+    {
+        [Dependency] private readonly IGameTiming _timing = default!;
+        [Dependency] private readonly IRobustRandom _random = default!;
+        [Dependency] private readonly SharedTransformSystem _transform = default!;
+        [Dependency] private readonly IPlayerManager _playerManager = default!;
+
+        public override void Update(float frameTime)
+        {
+            base.Update(frameTime);
+
+            var query = AllEntityQuery<ForensicsComponent>();
+            while (query.MoveNext(out var uid, out var comp))
+                if (TryComp<ScentTrackerComponent>(_playerManager.LocalEntity, out var scentcomp)
+                    && scentcomp.Scent != string.Empty
+                    && scentcomp.Scent == comp.Scent
+                    && _timing.CurTime > comp.TargetTime)
+                {
+                    comp.TargetTime = _timing.CurTime + TimeSpan.FromSeconds(1.0f);
+                    Spawn("ScentTrackEffect", _transform.GetMapCoordinates(uid).Offset(_random.NextVector2(0.25f)));
+                }
+        }
+    }
+}

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

@@ -1,11 +1,12 @@
 using System.Numerics;
-using Content.Server.Forensics;
+using Content.Shared.Forensics;
 using Content.Server.Stack;
 using Content.Shared.Prototypes;
 using Content.Shared.Stacks;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
 using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.Dictionary;
+using Content.Server.Administration.Commands;
 
 namespace Content.Server.Destructible.Thresholds.Behaviors
 {
@@ -85,6 +86,7 @@ public void TransferForensics(EntityUid spawned, DestructibleSystem system, Enti
 
             if (!system.Random.Prob(0.4f))
                 return;
+
             comp.Fingerprints = forensicsComponent.Fingerprints;
             comp.Fibers = forensicsComponent.Fibers;
         }

Content.Server/Flash/FlashSystem.cs

@@ -21,6 +21,8 @@
 using Robust.Shared.Timing;
 using InventoryComponent = Content.Shared.Inventory.InventoryComponent;
 using Content.Shared.Traits.Assorted.Components;
+using Robust.Shared.Random;
+using Content.Shared.Eye.Blinding.Systems;
 
 namespace Content.Server.Flash
 {
@@ -37,6 +39,8 @@ internal sealed class FlashSystem : SharedFlashSystem
         [Dependency] private readonly PopupSystem _popup = default!;
         [Dependency] private readonly StunSystem _stun = default!;
         [Dependency] private readonly TagSystem _tag = default!;
+        [Dependency] private readonly IRobustRandom _random = default!;
+        [Dependency] private readonly BlindableSystem _blindingSystem = default!;
 
         public override void Initialize()
         {
@@ -139,6 +143,11 @@ public void Flash(EntityUid target,
             flashable.Duration = flashDuration / 1000f; // TODO: Make this sane...
             Dirty(target, flashable);
 
+            if (TryComp<BlindableComponent>(target, out var blindable)
+                && !blindable.IsBlind
+                && _random.Prob(flashable.EyeDamageChance))
+                _blindingSystem.AdjustEyeDamage((target, blindable), flashable.EyeDamage);
+
             _stun.TrySlowdown(target, TimeSpan.FromSeconds(flashDuration/1000f), true,
                 slowTo, slowTo);
 

Content.Server/Forensics/Components/ScentComponent.cs

@@ -0,0 +1,11 @@
+namespace Content.Server.Forensics;
+
+/// <summary>
+/// This component is for mobs that have a Scent.
+/// </summary>
+[RegisterComponent]
+public sealed partial class ScentComponent : Component
+{
+    [DataField]
+    public string Scent = String.Empty;
+}

Content.Server/Forensics/Systems/ForensicsSystem.cs

@@ -11,6 +11,7 @@
 using Content.Shared.Inventory;
 using Content.Shared.Weapons.Melee.Events;
 using Robust.Shared.Random;
+using Content.Shared.Inventory.Events;
 
 namespace Content.Server.Forensics
 {
@@ -23,9 +24,11 @@ public sealed class ForensicsSystem : EntitySystem
         public override void Initialize()
         {
             SubscribeLocalEvent<FingerprintComponent, ContactInteractionEvent>(OnInteract);
+            SubscribeLocalEvent<ScentComponent, DidEquipEvent>(OnEquip);
             SubscribeLocalEvent<FiberComponent, MapInitEvent>(OnFiberInit);
             SubscribeLocalEvent<FingerprintComponent, MapInitEvent>(OnFingerprintInit);
             SubscribeLocalEvent<DnaComponent, MapInitEvent>(OnDNAInit);
+            SubscribeLocalEvent<ScentComponent, MapInitEvent>(OnScentInit);
 
             SubscribeLocalEvent<DnaComponent, BeingGibbedEvent>(OnBeingGibbed);
             SubscribeLocalEvent<ForensicsComponent, MeleeHitEvent>(OnMeleeHit);
@@ -40,6 +43,11 @@ private void OnInteract(EntityUid uid, FingerprintComponent component, ContactIn
             ApplyEvidence(uid, args.Other);
         }
 
+        private void OnEquip(EntityUid uid, ScentComponent component, DidEquipEvent args)
+        {
+            ApplyScent(uid, args.Equipment);
+        }
+
         private void OnFiberInit(EntityUid uid, FiberComponent component, MapInitEvent args)
         {
             component.Fiberprint = GenerateFingerprint(length: 7);
@@ -53,35 +61,49 @@ private void OnFingerprintInit(EntityUid uid, FingerprintComponent component, Ma
         private void OnDNAInit(EntityUid uid, DnaComponent component, MapInitEvent args)
         {
             component.DNA = GenerateDNA();
+
+        }
+
+        private void OnScentInit(EntityUid uid, ScentComponent component, MapInitEvent args)
+        {
+            component.Scent = GenerateFingerprint(length: 5);
+
+            var updatecomp = EnsureComp<ForensicsComponent>(uid);
+            updatecomp.Scent = component.Scent;
+
+            Dirty(uid, updatecomp);
         }
 
         private void OnBeingGibbed(EntityUid uid, DnaComponent component, BeingGibbedEvent args)
         {
-            foreach(EntityUid part in args.GibbedParts)
+            foreach (EntityUid part in args.GibbedParts)
             {
                 var partComp = EnsureComp<ForensicsComponent>(part);
                 partComp.DNAs.Add(component.DNA);
                 partComp.CanDnaBeCleaned = false;
+                Dirty(part, partComp);
             }
         }
 
         private void OnMeleeHit(EntityUid uid, ForensicsComponent component, MeleeHitEvent args)
         {
-            if((args.BaseDamage.DamageDict.TryGetValue("Blunt", out var bluntDamage) && bluntDamage.Value > 0) ||
+            if ((args.BaseDamage.DamageDict.TryGetValue("Blunt", out var bluntDamage) && bluntDamage.Value > 0) ||
                 (args.BaseDamage.DamageDict.TryGetValue("Slash", out var slashDamage) && slashDamage.Value > 0) ||
                 (args.BaseDamage.DamageDict.TryGetValue("Piercing", out var pierceDamage) && pierceDamage.Value > 0))
             {
-                foreach(EntityUid hitEntity in args.HitEntities)
+                foreach (EntityUid hitEntity in args.HitEntities)
                 {
-                    if(TryComp<DnaComponent>(hitEntity, out var hitEntityComp))
+                    if (TryComp<DnaComponent>(hitEntity, out var hitEntityComp))
                         component.DNAs.Add(hitEntityComp.DNA);
                 }
             }
+            Dirty(uid, component);
         }
 
         private void OnRehydrated(Entity<ForensicsComponent> ent, ref GotRehydratedEvent args)
         {
             CopyForensicsFrom(ent.Comp, args.Target);
+            Dirty(args.Target, ent.Comp);
         }
 
         /// <summary>
@@ -112,19 +134,43 @@ private void OnAfterInteract(EntityUid uid, CleansForensicsComponent component,
             if (args.Handled)
                 return;
 
-            if (!TryComp<ForensicsComponent>(args.Target, out var forensicsComp))
+            if (TryComp<ForensicsComponent>(args.Target, out var forensicsComp)
+                && forensicsComp.DNAs.Count > 0 && forensicsComp.CanDnaBeCleaned
+                && forensicsComp.Fingerprints.Count + forensicsComp.Fibers.Count > 0
+                && forensicsComp.Scent != string.Empty)
+            {
+                var cleanDelay = component.CleanDelay;
+                if (HasComp<ScentComponent>(args.Target))
+                    cleanDelay += 30;
+
+                var doAfterArgs = new DoAfterArgs(EntityManager, args.User, cleanDelay, new CleanForensicsDoAfterEvent(), uid, target: args.Target, used: args.Used)
+                {
+                    BreakOnHandChange = true,
+                    NeedHand = true,
+                    BreakOnDamage = true,
+                    BreakOnTargetMove = true,
+                    MovementThreshold = 0.01f,
+                    DistanceThreshold = forensicsComp.CleanDistance,
+                };
+
+                _doAfterSystem.TryStartDoAfter(doAfterArgs);
+                _popupSystem.PopupEntity(Loc.GetString("forensics-cleaning", ("target", args.Target)), args.User, args.User);
+
+                args.Handled = true;
                 return;
+            }
 
-            if((forensicsComp.DNAs.Count > 0 && forensicsComp.CanDnaBeCleaned) || (forensicsComp.Fingerprints.Count + forensicsComp.Fibers.Count > 0))
+            if (TryComp<ScentComponent>(args.Target, out var scentComp))
             {
-                var doAfterArgs = new DoAfterArgs(EntityManager, args.User, component.CleanDelay, new CleanForensicsDoAfterEvent(), uid, target: args.Target, used: args.Used)
+                var cleanDelay = component.CleanDelay + 30;
+                var doAfterArgs = new DoAfterArgs(EntityManager, args.User, cleanDelay, new CleanForensicsDoAfterEvent(), uid, target: args.Target, used: args.Used)
                 {
                     BreakOnHandChange = true,
                     NeedHand = true,
                     BreakOnDamage = true,
                     BreakOnTargetMove = true,
                     MovementThreshold = 0.01f,
-                    DistanceThreshold = forensicsComp.CleanDistance,
+                    DistanceThreshold = 1.5f,
                 };
 
                 _doAfterSystem.TryStartDoAfter(doAfterArgs);
@@ -144,6 +190,7 @@ private void OnCleanForensicsDoAfter(EntityUid uid, ForensicsComponent component
 
             targetComp.Fibers = new();
             targetComp.Fingerprints = new();
+            targetComp.Scent = String.Empty;
 
             if (targetComp.CanDnaBeCleaned)
                 targetComp.DNAs = new();
@@ -154,6 +201,30 @@ private void OnCleanForensicsDoAfter(EntityUid uid, ForensicsComponent component
 
             if (TryComp<ResidueComponent>(args.Used, out var residue))
                 targetComp.Residues.Add(string.IsNullOrEmpty(residue.ResidueColor) ? Loc.GetString("forensic-residue", ("adjective", residue.ResidueAdjective)) : Loc.GetString("forensic-residue-colored", ("color", residue.ResidueColor), ("adjective", residue.ResidueAdjective)));
+
+            // If the ent has a Scent Component, we compleatly generate a new one and apply the new scent to all currently weared items.
+            if (TryComp<ScentComponent>(args.Target, out var scentComp))
+            {
+                var generatedscent = GenerateFingerprint(length: 5);
+                scentComp.Scent = generatedscent;
+                targetComp.Scent = generatedscent;
+
+                if (args.Target is { Valid: true } target
+                    && _inventory.TryGetSlots(target, out var slotDefinitions))
+                    foreach (var slot in slotDefinitions)
+                    {
+                        if (!_inventory.TryGetSlotEntity(target, slot.Name, out var slotEnt))
+                            continue;
+
+                        EnsureComp<ForensicsComponent>(slotEnt.Value, out var recipientComp);
+                        recipientComp.Scent = generatedscent;
+
+                        Dirty(slotEnt.Value, recipientComp);
+                    }
+            }
+
+            if (args.Target is { Valid: true } targetuid)
+                Dirty(targetuid, targetComp);
         }
 
         public string GenerateFingerprint(int length = 16)
@@ -193,17 +264,37 @@ private void ApplyEvidence(EntityUid user, EntityUid target)
                 }
 
                 if (HasComp<FingerprintMaskComponent>(gloves))
+                {
+                    Dirty(target, component);
                     return;
+                }
             }
             if (TryComp<FingerprintComponent>(user, out var fingerprint))
+            {
                 component.Fingerprints.Add(fingerprint.Fingerprint ?? "");
+                Dirty(target, component);
+            }
+        }
+
+        private void ApplyScent(EntityUid user, EntityUid target)
+        {
+            if (HasComp<ScentComponent>(target))
+                return;
+
+            var component = EnsureComp<ForensicsComponent>(target);
+            if (TryComp<ScentComponent>(user, out var scent))
+                component.Scent = scent.Scent;
+
+            Dirty(target, component);
         }
 
         private void OnTransferDnaEvent(EntityUid uid, DnaComponent component, ref TransferDnaEvent args)
         {
             var recipientComp = EnsureComp<ForensicsComponent>(args.Recipient);
             recipientComp.DNAs.Add(component.DNA);
             recipientComp.CanDnaBeCleaned = args.CanDnaBeCleaned;
+
+            Dirty(args.Recipient, recipientComp);
         }
 
         #region Public API
@@ -221,6 +312,8 @@ public void TransferDna(EntityUid recipient, EntityUid donor, bool canDnaBeClean
                 EnsureComp<ForensicsComponent>(recipient, out var recipientComp);
                 recipientComp.DNAs.Add(donorComp.DNA);
                 recipientComp.CanDnaBeCleaned = canDnaBeCleaned;
+
+                Dirty(recipient, recipientComp);
             }
         }