{
text.AppendLine(dna);
}
+ text.AppendLine();
+ text.AppendLine(Loc.GetString("forensic-scanner-interface-residues"));
+ foreach (var residue in msg.Residues)
+ {
+ text.AppendLine(residue);
+ }
Diagnostics.Text = text.ToString();
}
}
using Content.Server.Body.Components;
using Content.Server.Chemistry.ReactionEffects;
using Content.Server.Fluids.EntitySystems;
-using Content.Server.Forensics;
using Content.Server.HealthExaminable;
using Content.Server.Popups;
using Content.Shared.Alert;
using Robust.Shared.Random;
using Content.Shared.Speech.EntitySystems;
using Robust.Server.Audio;
+using Robust.Shared.GameObjects;
+using Content.Server.Forensics;
namespace Content.Server.Body.Systems;
[Dependency] private readonly SolutionContainerSystem _solutionContainerSystem = default!;
[Dependency] private readonly SharedStutteringSystem _stutteringSystem = default!;
[Dependency] private readonly AlertsSystem _alertsSystem = default!;
+ [Dependency] private readonly ForensicsSystem _forensicsSystem = default!;
public override void Initialize()
{
component.BloodTemporarySolution.AddSolution(temp, _prototypeManager);
if (_puddleSystem.TrySpillAt(uid, component.BloodTemporarySolution, out var puddleUid, false))
{
- if (TryComp<DnaComponent>(uid, out var dna))
- {
- var comp = EnsureComp<ForensicsComponent>(puddleUid);
- comp.DNAs.Add(dna.DNA);
- }
+ _forensicsSystem.TransferDna(puddleUid, uid, false);
}
component.BloodTemporarySolution.RemoveAllSolution();
if (_puddleSystem.TrySpillAt(uid, tempSol, out var puddleUid))
{
- if (TryComp<DnaComponent>(uid, out var dna))
- {
- var comp = EnsureComp<ForensicsComponent>(puddleUid);
- comp.DNAs.Add(dna.DNA);
- }
+ _forensicsSystem.TransferDna(puddleUid, uid, false);
}
}
using Content.Shared.Verbs;
using Content.Shared.Stacks;
using Robust.Shared.Player;
+using Content.Shared.Forensics;
namespace Content.Server.Chemistry.EntitySystems;
("target", Identity.Entity(target, EntityManager))), injector, user);
Dirty(component);
- AfterInject(component, injector);
+ AfterInject(component, injector, target);
}
private void TryInject(InjectorComponent component, EntityUid injector, EntityUid targetEntity, Solution targetSolution, EntityUid user, bool asRefill)
("target", Identity.Entity(targetEntity, EntityManager))), injector, user);
Dirty(component);
- AfterInject(component, injector);
+ AfterInject(component, injector, targetEntity);
}
- private void AfterInject(InjectorComponent component, EntityUid injector)
+ private void AfterInject(InjectorComponent component, EntityUid injector, EntityUid target)
{
// Automatically set syringe to draw after completely draining it.
if (_solutions.TryGetSolution(injector, InjectorComponent.SolutionName, out var solution)
{
component.ToggleState = SharedInjectorComponent.InjectorToggleMode.Draw;
}
+
+ // Leave some DNA from the injectee on it
+ var ev = new TransferDnaEvent { Donor = target, Recipient = injector };
+ RaiseLocalEvent(target, ref ev);
}
- private void AfterDraw(InjectorComponent component, EntityUid injector)
+ private void AfterDraw(InjectorComponent component, EntityUid injector, EntityUid target)
{
// Automatically set syringe to inject after completely filling it.
if (_solutions.TryGetSolution(injector, InjectorComponent.SolutionName, out var solution)
{
component.ToggleState = SharedInjectorComponent.InjectorToggleMode.Inject;
}
+
+ // Leave some DNA from the drawee on it
+ var ev = new TransferDnaEvent { Donor = target, Recipient = injector };
+ RaiseLocalEvent(target, ref ev);
}
private void TryDraw(InjectorComponent component, EntityUid injector, EntityUid targetEntity, Solution targetSolution, EntityUid user, BloodstreamComponent? stream = null)
("target", Identity.Entity(targetEntity, EntityManager))), injector, user);
Dirty(component);
- AfterDraw(component, injector);
+ AfterDraw(component, injector, targetEntity);
}
private void DrawFromBlood(EntityUid user, EntityUid injector, EntityUid target, InjectorComponent component, Solution injectorSolution, BloodstreamComponent stream, FixedPoint2 transferAmount)
("target", Identity.Entity(target, EntityManager))), injector, user);
Dirty(component);
- AfterDraw(component, injector);
+ AfterDraw(component, injector, target);
}
}
using Content.Shared.Weapons.Melee.Events;
using Content.Shared.Timing;
using Robust.Shared.GameStates;
+using Content.Shared.Forensics;
namespace Content.Server.Chemistry.EntitySystems
{
_reactiveSystem.DoEntityReaction(target.Value, removedSolution, ReactionMethod.Injection);
_solutions.TryAddSolution(target.Value, targetSolution, removedSolution);
+ var ev = new TransferDnaEvent { Donor = target.Value, Recipient = uid };
+ RaiseLocalEvent(target.Value, ref ev);
+
// same LogType as syringes...
_adminLogger.Add(LogType.ForceFeed, $"{_entMan.ToPrettyString(user):user} injected {_entMan.ToPrettyString(target.Value):target} with a solution {SolutionContainerSystem.ToPrettyString(removedSolution):removedSolution} using a {_entMan.ToPrettyString(uid):using}");
/// <summary>
/// A list of fingerprint GUIDs that the forensic scanner found from the <see cref="ForensicsComponent"/> on an entity.
/// </summary>
- [ViewVariables(VVAccess.ReadOnly)]
+ [ViewVariables(VVAccess.ReadOnly), DataField("fingerprints")]
public List<string> Fingerprints = new();
/// <summary>
/// A list of glove fibers that the forensic scanner found from the <see cref="ForensicsComponent"/> on an entity.
/// </summary>
- [ViewVariables(VVAccess.ReadOnly)]
+ [ViewVariables(VVAccess.ReadOnly), DataField("fibers")]
public List<string> Fibers = new();
/// <summary>
/// DNA that the forensic scanner found from the <see cref="DNAComponent"/> on an entity.
/// </summary>
- [ViewVariables(VVAccess.ReadOnly)]
+ [ViewVariables(VVAccess.ReadOnly), DataField("dnas")]
public List<string> DNAs = new();
+ /// <summary>
+ /// Residue that the forensic scanner found from the <see cref="ForensicsComponent"/> on an entity.
+ /// </summary>
+ [ViewVariables(VVAccess.ReadOnly), DataField("residues")]
+ public List<string> Residues = new();
+
/// <summary>
/// What is the name of the entity that was scanned last?
/// </summary>
[DataField("dnas")]
public HashSet<string> DNAs = new();
+
+ [DataField("residues")]
+ public HashSet<string> Residues = new();
+
+ /// <summary>
+ /// How long it takes to wipe the prints/blood/etc. off of this entity
+ /// </summary>
+ [DataField("cleanDelay")]
+ public float CleanDelay = 12.0f;
+
+ /// <summary>
+ /// How close you must be to wipe the prints/blood/etc. off of this entity
+ /// </summary>
+ [DataField("cleanDistance")]
+ public float CleanDistance = 1.5f;
+
+ /// <summary>
+ /// Can the DNA be cleaned off of this entity?
+ /// e.g. you can clean the DNA off of a knife, but not a puddle
+ /// </summary>
+ [DataField("canDnaBeCleaned")]
+ public bool CanDnaBeCleaned = true;
}
}
--- /dev/null
+namespace Content.Server.Forensics;
+
+/// <summary>
+/// This controls residues left on items
+/// which the forensics system uses.
+/// </summary>
+[RegisterComponent]
+public sealed partial class ResidueComponent : Component
+{
+ [DataField]
+ public LocId ResidueAdjective = "residue-unknown";
+
+ [DataField]
+ public string? ResidueColor;
+}
component.Fingerprints,
component.Fibers,
component.DNAs,
+ component.Residues,
component.LastScannedName,
component.PrintCooldown,
component.PrintReadyAt);
scanner.Fingerprints = new();
scanner.Fibers = new();
scanner.DNAs = new();
+ scanner.Residues = new();
}
else
scanner.Fingerprints = forensics.Fingerprints.ToList();
scanner.Fibers = forensics.Fibers.ToList();
scanner.DNAs = forensics.DNAs.ToList();
+ scanner.Residues = forensics.Residues.ToList();
}
scanner.LastScannedName = MetaData(args.Args.Target.Value).EntityName;
{
text.AppendLine(dna);
}
+ text.AppendLine();
+ text.AppendLine(Loc.GetString("forensic-scanner-interface-residues"));
+ foreach (var residue in component.Residues)
+ {
+ text.AppendLine(residue);
+ }
_paperSystem.SetContent(printed, text.ToString());
_audioSystem.PlayPvs(component.SoundPrint, uid,
+using Content.Server.Body.Components;
+using Content.Server.Chemistry.EntitySystems;
+using Content.Server.DoAfter;
+using Content.Shared.DoAfter;
+using Content.Shared.Forensics;
+using Content.Shared.Interaction;
using Content.Shared.Interaction.Events;
using Content.Shared.Inventory;
+using Content.Shared.Tag;
+using Content.Shared.Weapons.Melee.Events;
using Robust.Shared.Random;
namespace Content.Server.Forensics
{
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly InventorySystem _inventory = default!;
+ [Dependency] private readonly TagSystem _tagSystem = default!;
+ [Dependency] private readonly DoAfterSystem _doAfterSystem = default!;
public override void Initialize()
{
SubscribeLocalEvent<FingerprintComponent, ContactInteractionEvent>(OnInteract);
SubscribeLocalEvent<FingerprintComponent, MapInitEvent>(OnFingerprintInit);
SubscribeLocalEvent<DnaComponent, MapInitEvent>(OnDNAInit);
+
+ SubscribeLocalEvent<DnaComponent, BeingGibbedEvent>(OnBeingGibbed);
+ SubscribeLocalEvent<ForensicsComponent, MeleeHitEvent>(OnMeleeHit);
+ SubscribeLocalEvent<ForensicsComponent, AfterInteractEvent>(OnAfterInteract);
+ SubscribeLocalEvent<ForensicsComponent, CleanForensicsDoAfterEvent>(OnCleanForensicsDoAfter);
+ SubscribeLocalEvent<DnaComponent, TransferDnaEvent>(OnTransferDnaEvent);
}
private void OnInteract(EntityUid uid, FingerprintComponent component, ContactInteractionEvent args)
component.DNA = GenerateDNA();
}
+ private void OnBeingGibbed(EntityUid uid, DnaComponent component, BeingGibbedEvent args)
+ {
+ foreach(EntityUid part in args.GibbedParts)
+ {
+ var partComp = EnsureComp<ForensicsComponent>(part);
+ partComp.DNAs.Add(component.DNA);
+ partComp.CanDnaBeCleaned = false;
+ }
+ }
+
+ private void OnMeleeHit(EntityUid uid, ForensicsComponent component, MeleeHitEvent args)
+ {
+ 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)
+ {
+ if(TryComp<DnaComponent>(hitEntity, out var hitEntityComp))
+ component.DNAs.Add(hitEntityComp.DNA);
+ }
+ }
+ }
+
+ private void OnAfterInteract(EntityUid uid, ForensicsComponent component, AfterInteractEvent args)
+ {
+ if (args.Handled)
+ return;
+
+ if (!_tagSystem.HasTag(args.Used, "CleansForensics"))
+ return;
+
+ if((component.DNAs.Count > 0 && component.CanDnaBeCleaned) || (component.Fingerprints.Count + component.Fibers.Count > 0))
+ {
+ var doAfterArgs = new DoAfterArgs(EntityManager, args.User, component.CleanDelay, new CleanForensicsDoAfterEvent(), uid, target: args.Target, used: args.Used)
+ {
+ BreakOnHandChange = true,
+ NeedHand = true,
+ BreakOnDamage = true,
+ BreakOnTargetMove = true,
+ MovementThreshold = 0.01f,
+ DistanceThreshold = component.CleanDistance,
+ };
+
+
+ _doAfterSystem.TryStartDoAfter(doAfterArgs);
+
+ args.Handled = true;
+ }
+ }
+
+ private void OnCleanForensicsDoAfter(EntityUid uid, ForensicsComponent component, CleanForensicsDoAfterEvent args)
+ {
+ if (args.Handled || args.Cancelled || args.Args.Target == null)
+ return;
+
+ if (!TryComp<ForensicsComponent>(args.Target, out var targetComp))
+ return;
+
+ targetComp.Fibers = new();
+ targetComp.Fingerprints = new();
+
+ if (targetComp.CanDnaBeCleaned)
+ targetComp.DNAs = new();
+
+ // leave behind evidence it was cleaned
+ if (TryComp<FiberComponent>(args.Used, out var fiber))
+ targetComp.Fibers.Add(string.IsNullOrEmpty(fiber.FiberColor) ? Loc.GetString("forensic-fibers", ("material", fiber.FiberMaterial)) : Loc.GetString("forensic-fibers-colored", ("color", fiber.FiberColor), ("material", fiber.FiberMaterial)));
+
+ 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)));
+ }
+
public string GenerateFingerprint()
{
var fingerprint = new byte[16];
if (TryComp<FingerprintComponent>(user, out var fingerprint))
component.Fingerprints.Add(fingerprint.Fingerprint ?? "");
}
+
+ 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;
+ }
+
+ #region Public API
+
+ /// <summary>
+ /// Transfer DNA from one entity onto the forensics of another
+ /// </summary>
+ /// <param name="recipient">The entity receiving the DNA</param>
+ /// <param name="donor">The entity applying its DNA</param>
+ /// <param name="canDnaBeCleaned">If this DNA be cleaned off of the recipient. e.g. cleaning a knife vs cleaning a puddle of blood</param>
+ public void TransferDna(EntityUid recipient, EntityUid donor, bool canDnaBeCleaned = true)
+ {
+ if (TryComp<DnaComponent>(donor, out var donorComp))
+ {
+ EnsureComp<ForensicsComponent>(recipient, out var recipientComp);
+ recipientComp.DNAs.Add(donorComp.DNA);
+ }
+ }
+
+ #endregion
}
}
[Dependency] private readonly SolutionContainerSystem _solutionContainer = default!;
[Dependency] private readonly StunSystem _stun = default!;
[Dependency] private readonly ThirstSystem _thirst = default!;
+ [Dependency] private readonly ForensicsSystem _forensics = default!;
/// <summary>
/// Make an entity vomit, if they have a stomach.
if (_puddle.TrySpillAt(uid, solution, out var puddle, false))
{
- var forensics = EnsureComp<ForensicsComponent>(puddle);
- if (TryComp<DnaComponent>(uid, out var dna))
- forensics.DNAs.Add(dna.DNA);
+ _forensics.TransferDna(puddle, uid, false);
}
// Force sound to play as spill doesn't work if solution is empty.
[Dependency] private readonly SharedInteractionSystem _interaction = default!;
[Dependency] private readonly SolutionContainerSystem _solutionContainer = default!;
[Dependency] private readonly StomachSystem _stomach = default!;
+ [Dependency] private readonly ForensicsSystem _forensics = default!;
public override void Initialize()
{
//TODO: Grab the stomach UIDs somehow without using Owner
_stomach.TryTransferSolution(firstStomach.Value.Comp.Owner, drained, firstStomach.Value.Comp);
- var comp = EnsureComp<ForensicsComponent>(uid);
- if (TryComp<DnaComponent>(args.Target, out var dna))
- comp.DNAs.Add(dna.DNA);
+ _forensics.TransferDna(uid, args.Target.Value);
if (!forceDrink && solution.Volume > 0)
args.Repeat = true;
using Robust.Server.GameObjects;
using Robust.Shared.Containers;
using System.Linq;
+using Content.Shared.Inventory.Events;
+using Content.Server.Forensics;
namespace Content.Server.Nutrition.EntitySystems
{
[Dependency] private readonly SharedItemSystem _items = default!;
[Dependency] private readonly SharedContainerSystem _container = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+ [Dependency] private readonly ForensicsSystem _forensics = default!;
private const float UpdateTimer = 3f;
{
SubscribeLocalEvent<SmokableComponent, IsHotEvent>(OnSmokableIsHotEvent);
SubscribeLocalEvent<SmokableComponent, ComponentShutdown>(OnSmokableShutdownEvent);
+ SubscribeLocalEvent<SmokableComponent, GotEquippedEvent>(OnSmokeableEquipEvent);
InitializeCigars();
InitializePipes();
_active.Remove(uid);
}
+ private void OnSmokeableEquipEvent(EntityUid uid, SmokableComponent component, GotEquippedEvent args)
+ {
+ if (args.Slot == "mask")
+ {
+ _forensics.TransferDna(uid, args.Equipee, false);
+ }
+ }
+
public override void Update(float frameTime)
{
_timer += frameTime;
public override DoAfterEvent Clone() => this;
}
+
+[Serializable, NetSerializable]
+public sealed partial class CleanForensicsDoAfterEvent : SimpleDoAfterEvent
+{
+}
+
+/// <summary>
+/// An event to apply DNA evidence from a donor onto some recipient.
+/// </summary>
+[ByRefEvent]
+public record struct TransferDnaEvent()
+{
+ /// <summary>
+ /// The entity donating the DNA.
+ /// </summary>
+ public EntityUid Donor;
+
+ /// <summary>
+ /// The entity receiving the DNA.
+ /// </summary>
+ public EntityUid Recipient;
+
+ /// <summary>
+ /// Can the DNA be cleaned off?
+ /// </summary>
+ public bool CanDnaBeCleaned = true;
+}
public readonly List<string> Fingerprints = new();
public readonly List<string> Fibers = new();
public readonly List<string> DNAs = new();
+ public readonly List<string> Residues = new();
public readonly string LastScannedName = string.Empty;
public readonly TimeSpan PrintCooldown = TimeSpan.Zero;
public readonly TimeSpan PrintReadyAt = TimeSpan.Zero;
List<string> fingerprints,
List<string> fibers,
List<string> dnas,
+ List<string> residues,
string lastScannedName,
TimeSpan printCooldown,
TimeSpan printReadyAt)
Fingerprints = fingerprints;
Fibers = fibers;
DNAs = dnas;
+ Residues = residues;
LastScannedName = lastScannedName;
PrintCooldown = printCooldown;
PrintReadyAt = printReadyAt;
using Content.Shared.Containers.ItemSlots;
using Content.Shared.DoAfter;
using Content.Shared.Examine;
+using Content.Shared.Forensics;
using Content.Shared.IdentityManagement;
using Content.Shared.Implants.Components;
using Content.Shared.Popups;
else
ImplantMode(implanter, component);
+ var ev = new TransferDnaEvent { Donor = target, Recipient = implanter };
+ RaiseLocalEvent(target, ref ev);
+
Dirty(component);
}
implantComp.ImplantedEntity = null;
implanterContainer.Insert(implant);
permanentFound = implantComp.Permanent;
+
+ var ev = new TransferDnaEvent { Donor = target, Recipient = implanter };
+ RaiseLocalEvent(target, ref ev);
+
//Break so only one implant is drawn
break;
}
forensic-scanner-interface-fingerprints = Fingerprints
forensic-scanner-interface-fibers = Fibers
forensic-scanner-interface-dnas = DNAs
+forensic-scanner-interface-residues = Residues
forensic-scanner-interface-no-data = No scan data available
forensic-scanner-interface-print = Print
forensic-scanner-interface-clear = Clear
--- /dev/null
+forensic-residue = {LOC($adjective)} residue
+forensic-residue-colored = {LOC($adjective)} {LOC($color)} residue
+
+residue-unknown = unknown
+residue-slippery = slippery
+
+residue-green = green
+residue-blue = blue
+residue-red = red
+residue-grey = grey
+residue-brown = brown
\ No newline at end of file
tags:
- DroneUsable
- Mop
+ - CleansForensics
+ - type: Fiber
+ fiberColor: fibers-white
- type: Tag
tags:
- Soap
+ - CleansForensics
- type: Sprite
sprite: Objects/Specific/Janitorial/soap.rsi
layers:
- type: Food
solution: soap
- type: BadFood
+ - type: Residue
+ residueAdjective: residue-slippery
+ residueColor: residue-green
- type: entity
name: soap
reagents:
- ReagentId: SoapReagent
Quantity: 100
+ - type: Residue
+ residueAdjective: residue-slippery
+ residueColor: residue-grey
- type: entity
name: soap
fillBaseName: deluxe-
- type: Item
heldPrefix: deluxe
+ - type: Residue
+ residueAdjective: residue-slippery
+ residueColor: residue-brown
- type: entity
name: soap
flavors:
- clean
- punishment
+ - type: Residue
+ residueAdjective: residue-slippery
+ residueColor: residue-red
- type: entity
name: soaplet
flavors:
- clean
- meaty
+ - type: Residue
+ residueAdjective: residue-slippery
+ residueColor: residue-red
- type: entity
name: omega soap
reagents:
- ReagentId: SoapReagent
Quantity: 240
+ - type: Residue
+ residueAdjective: residue-slippery
+ residueColor: residue-blue
\ No newline at end of file
- type: Tag
id: boots
+
+- type: Tag
+ id: CleansForensics
\ No newline at end of file
projects / space-station-14.git / commitdiff