403 lines
17 KiB
C#
403 lines
17 KiB
C#
using System.Linq;
|
|
using System.Text;
|
|
using Content.Server.Popups;
|
|
using Content.Shared.UserInterface;
|
|
using Content.Shared.DoAfter;
|
|
using Content.Shared.Forensics;
|
|
using Content.Shared.Hands.EntitySystems;
|
|
using Content.Shared.Interaction;
|
|
using Content.Shared.Paper;
|
|
using Content.Shared.Verbs;
|
|
using Content.Shared.Tag;
|
|
using Robust.Shared.Audio.Systems;
|
|
using Robust.Server.GameObjects;
|
|
using Robust.Shared.Audio;
|
|
using Robust.Shared.Timing;
|
|
using Content.Server.Chemistry.Containers.EntitySystems;
|
|
using Robust.Shared.Prototypes;
|
|
using Content.Server._NF.SectorServices; // Frontier
|
|
using Content.Server._NF.Smuggling; // Frontier
|
|
using Content.Server._NF.Smuggling.Components; // Frontier
|
|
using Content.Server.Radio.EntitySystems; // Frontier
|
|
using Content.Server.Stack; // Frontier
|
|
using Content.Shared._NF.Bank; // Frontier
|
|
using Content.Shared._NF.Bank.Components; // Frontier
|
|
using Content.Server._NF.Bank; // Frontier
|
|
using Content.Shared._NF.Bank.BUI; // Frontier
|
|
using Content.Shared._NF.CCVar; // Frontier
|
|
using Content.Shared.Containers.ItemSlots; // Frontier
|
|
using Content.Shared.FixedPoint; // Frontier
|
|
using Content.Shared.Stacks; // Frontier
|
|
using Content.Shared.Radio; // Frontier
|
|
using Robust.Shared.Configuration; // Frontier
|
|
// todo: remove this stinky LINQy
|
|
|
|
namespace Content.Server.Forensics
|
|
{
|
|
public sealed class ForensicScannerSystem : EntitySystem
|
|
{
|
|
[Dependency] private readonly IGameTiming _gameTiming = default!;
|
|
[Dependency] private readonly SharedDoAfterSystem _doAfterSystem = default!;
|
|
[Dependency] private readonly UserInterfaceSystem _uiSystem = default!;
|
|
[Dependency] private readonly PopupSystem _popupSystem = default!;
|
|
[Dependency] private readonly PaperSystem _paperSystem = default!;
|
|
[Dependency] private readonly SharedHandsSystem _handsSystem = default!;
|
|
[Dependency] private readonly SharedAudioSystem _audioSystem = default!;
|
|
[Dependency] private readonly MetaDataSystem _metaData = default!;
|
|
[Dependency] private readonly ForensicsSystem _forensicsSystem = default!;
|
|
[Dependency] private readonly TagSystem _tag = default!;
|
|
[Dependency] private readonly StackSystem _stackSystem = default!; // Frontier
|
|
[Dependency] private readonly IPrototypeManager _prototypeManager = default!; // Frontier
|
|
[Dependency] private readonly RadioSystem _radio = default!; // Frontier
|
|
[Dependency] private readonly DeadDropSystem _deadDrop = default!; // Frontier
|
|
[Dependency] private readonly ItemSlotsSystem _itemSlots = default!; // Frontier
|
|
[Dependency] private readonly SectorServiceSystem _service = default!; // Frontier
|
|
[Dependency] private readonly IConfigurationManager _cfg = default!; // Frontier
|
|
[Dependency] private readonly BankSystem _bank = default!; // Frontier
|
|
|
|
// Frontier: payout constants
|
|
// Temporary values, sane defaults, will be overwritten by CVARs.
|
|
private int _minFUCPayout = 2;
|
|
|
|
private SoundSpecifier _confirmSound = new SoundPathSpecifier("/Audio/Effects/Cargo/ping.ogg");
|
|
|
|
private const int ActiveUnusedDeadDropSpesoReward = 20000;
|
|
private const float ActiveUnusedDeadDropFUCReward = 2.0f;
|
|
private const int ActiveUsedDeadDropSpesoReward = 10000;
|
|
private const float ActiveUsedDeadDropFUCReward = 1.0f;
|
|
private const int InactiveUsedDeadDropSpesoReward = 5000;
|
|
private const float InactiveUsedDeadDropFUCReward = 0.5f;
|
|
private const int DropPodSpesoReward = 10000;
|
|
private const float DropPodFUCReward = 1.0f;
|
|
// End Frontier: payout constants
|
|
|
|
private static readonly ProtoId<TagPrototype> DNASolutionScannableTag = "DNASolutionScannable";
|
|
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
|
|
SubscribeLocalEvent<ForensicScannerComponent, AfterInteractEvent>(OnAfterInteract);
|
|
SubscribeLocalEvent<ForensicScannerComponent, AfterInteractUsingEvent>(OnAfterInteractUsing);
|
|
SubscribeLocalEvent<ForensicScannerComponent, BeforeActivatableUIOpenEvent>(OnBeforeActivatableUIOpen);
|
|
SubscribeLocalEvent<ForensicScannerComponent, GetVerbsEvent<UtilityVerb>>(OnUtilityVerb);
|
|
SubscribeLocalEvent<ForensicScannerComponent, ForensicScannerPrintMessage>(OnPrint);
|
|
SubscribeLocalEvent<ForensicScannerComponent, ForensicScannerClearMessage>(OnClear);
|
|
SubscribeLocalEvent<ForensicScannerComponent, ForensicScannerDoAfterEvent>(OnDoAfter);
|
|
|
|
Subs.CVar(_cfg, NFCCVars.SmugglingMinFucPayout, OnMinFucPayoutChanged, true); // Frontier
|
|
}
|
|
|
|
private void OnMinFucPayoutChanged(int newMin)
|
|
{
|
|
_minFUCPayout = newMin;
|
|
}
|
|
|
|
// Frontier: add dead drop rewards
|
|
/// <summary>
|
|
/// Rewards the NFSD department for scanning a dead drop.
|
|
/// Gives some amount of spesos and FUC to the
|
|
/// </summary>
|
|
private void GiveReward(EntityUid uidOrigin, EntityUid target, int spesoAmount, FixedPoint2 fucAmount, string msg)
|
|
{
|
|
_audioSystem.PlayPvs(_audioSystem.ResolveSound(_confirmSound), uidOrigin);
|
|
|
|
if (spesoAmount > 0)
|
|
_bank.TrySectorDeposit(SectorBankAccount.Nfsd, spesoAmount, LedgerEntryType.AntiSmugglingBonus);
|
|
else
|
|
spesoAmount = 0;
|
|
|
|
if (fucAmount > 0)
|
|
{
|
|
// Accumulate sector-wide FUCs, pay out if min threshold met
|
|
if (TryComp<SectorDeadDropComponent>(_service.GetServiceEntity(), out var sectorDD))
|
|
{
|
|
sectorDD.FUCAccumulator += fucAmount;
|
|
if (sectorDD.FUCAccumulator >= _minFUCPayout)
|
|
{
|
|
// inherent floor
|
|
int payout = sectorDD.FUCAccumulator.Int();
|
|
sectorDD.FUCAccumulator -= payout;
|
|
|
|
var stackPrototype = _prototypeManager.Index<StackPrototype>("FrontierUplinkCoin");
|
|
_stackSystem.Spawn(payout, stackPrototype, Transform(target).Coordinates);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
fucAmount = 0;
|
|
|
|
var channel = _prototypeManager.Index<RadioChannelPrototype>("Nfsd");
|
|
string msgString = Loc.GetString(msg);
|
|
if (fucAmount >= 1)
|
|
{
|
|
msgString = msgString + " " + Loc.GetString("forensic-reward-amount",
|
|
("spesos", BankSystemExtensions.ToSpesoString(spesoAmount)),
|
|
("fuc", BankSystemExtensions.ToFUCString(fucAmount.Int())));
|
|
}
|
|
else
|
|
{
|
|
msgString = msgString + " " + Loc.GetString("forensic-reward-amount-speso-only",
|
|
("spesos", BankSystemExtensions.ToSpesoString(spesoAmount)));
|
|
}
|
|
_radio.SendRadioMessage(uidOrigin, msgString, channel, uidOrigin);
|
|
}
|
|
// End Frontier: add dead drop rewards
|
|
|
|
private void UpdateUserInterface(EntityUid uid, ForensicScannerComponent component)
|
|
{
|
|
var state = new ForensicScannerBoundUserInterfaceState(
|
|
component.Fingerprints,
|
|
component.Fibers,
|
|
component.TouchDNAs,
|
|
component.SolutionDNAs,
|
|
component.Residues,
|
|
component.LastScannedName,
|
|
component.PrintCooldown,
|
|
component.PrintReadyAt);
|
|
|
|
_uiSystem.SetUiState(uid, ForensicScannerUiKey.Key, state);
|
|
}
|
|
|
|
private void OnDoAfter(EntityUid uid, ForensicScannerComponent component, DoAfterEvent args)
|
|
{
|
|
if (args.Handled || args.Cancelled)
|
|
return;
|
|
|
|
if (!EntityManager.TryGetComponent(uid, out ForensicScannerComponent? scanner))
|
|
return;
|
|
|
|
if (args.Args.Target != null)
|
|
{
|
|
if (!TryComp<ForensicsComponent>(args.Args.Target, out var forensics))
|
|
{
|
|
scanner.Fingerprints = new();
|
|
scanner.Fibers = new();
|
|
scanner.TouchDNAs = new();
|
|
scanner.Residues = new();
|
|
}
|
|
else
|
|
{
|
|
scanner.Fingerprints = forensics.Fingerprints.ToList();
|
|
scanner.Fibers = forensics.Fibers.ToList();
|
|
scanner.TouchDNAs = forensics.DNAs.ToList();
|
|
scanner.Residues = forensics.Residues.ToList();
|
|
}
|
|
|
|
// Frontier: contraband poster/pod scanning
|
|
if (_itemSlots.TryGetSlot(uid, "forensics_cartridge", out var itemSlot) && itemSlot.HasItem)
|
|
{
|
|
EntityUid target = args.Args.Target.Value;
|
|
if (TryComp<DeadDropComponent>(target, out var deadDrop))
|
|
{
|
|
// If there's a dead drop note present, pay out regardless and compromise the dead drop.
|
|
if (_gameTiming.CurTime >= deadDrop.NextDrop)
|
|
{
|
|
int spesoReward;
|
|
FixedPoint2 fucReward;
|
|
string msg;
|
|
if (deadDrop.DeadDropCalled)
|
|
{
|
|
spesoReward = ActiveUsedDeadDropSpesoReward;
|
|
fucReward = ActiveUsedDeadDropFUCReward;
|
|
msg = "forensic-reward-dead-drop-used-present";
|
|
}
|
|
else
|
|
{
|
|
spesoReward = ActiveUnusedDeadDropSpesoReward;
|
|
fucReward = ActiveUnusedDeadDropFUCReward;
|
|
msg = "forensic-reward-dead-drop-unused";
|
|
}
|
|
GiveReward(uid, target, spesoReward, fucReward, msg);
|
|
_deadDrop.CompromiseDeadDrop(target, deadDrop);
|
|
}
|
|
// Otherwise, if it's been used, pay out at a reduced rate and compromise it.
|
|
else if (deadDrop.DeadDropCalled)
|
|
{
|
|
GiveReward(uid, target, InactiveUsedDeadDropSpesoReward, InactiveUsedDeadDropFUCReward, "forensic-reward-dead-drop-used-gone");
|
|
_deadDrop.CompromiseDeadDrop(target, deadDrop);
|
|
}
|
|
}
|
|
else if (TryComp<ContrabandPodGridComponent>(Transform(target).GridUid, out var pod) && !pod.Scanned)
|
|
{
|
|
GiveReward(uid, target, DropPodSpesoReward, DropPodFUCReward, "forensic-reward-pod");
|
|
pod.Scanned = true;
|
|
}
|
|
}
|
|
// End Frontier: contraband poster/pod scanning
|
|
|
|
if (_tag.HasTag(args.Args.Target.Value, DNASolutionScannableTag))
|
|
{
|
|
scanner.SolutionDNAs = _forensicsSystem.GetSolutionsDNA(args.Args.Target.Value);
|
|
} else
|
|
{
|
|
scanner.SolutionDNAs = new();
|
|
}
|
|
|
|
scanner.LastScannedName = MetaData(args.Args.Target.Value).EntityName;
|
|
}
|
|
|
|
OpenUserInterface(args.Args.User, (uid, scanner));
|
|
}
|
|
|
|
/// <remarks>
|
|
/// Hosts logic common between OnUtilityVerb and OnAfterInteract.
|
|
/// </remarks>
|
|
private void StartScan(EntityUid uid, ForensicScannerComponent component, EntityUid user, EntityUid target)
|
|
{
|
|
_doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, user, component.ScanDelay, new ForensicScannerDoAfterEvent(), uid, target: target, used: uid)
|
|
{
|
|
BreakOnMove = true,
|
|
NeedHand = true
|
|
});
|
|
}
|
|
|
|
private void OnUtilityVerb(EntityUid uid, ForensicScannerComponent component, GetVerbsEvent<UtilityVerb> args)
|
|
{
|
|
if (!args.CanInteract || !args.CanAccess || component.CancelToken != null)
|
|
return;
|
|
|
|
var verb = new UtilityVerb()
|
|
{
|
|
Act = () => StartScan(uid, component, args.User, args.Target),
|
|
IconEntity = GetNetEntity(uid),
|
|
Text = Loc.GetString("forensic-scanner-verb-text"),
|
|
Message = Loc.GetString("forensic-scanner-verb-message")
|
|
};
|
|
|
|
args.Verbs.Add(verb);
|
|
}
|
|
|
|
private void OnAfterInteract(EntityUid uid, ForensicScannerComponent component, AfterInteractEvent args)
|
|
{
|
|
if (component.CancelToken != null || args.Target == null || !args.CanReach)
|
|
return;
|
|
|
|
StartScan(uid, component, args.User, args.Target.Value);
|
|
}
|
|
|
|
private void OnAfterInteractUsing(EntityUid uid, ForensicScannerComponent component, AfterInteractUsingEvent args)
|
|
{
|
|
if (args.Handled || !args.CanReach)
|
|
return;
|
|
|
|
if (!TryComp<ForensicPadComponent>(args.Used, out var pad))
|
|
return;
|
|
|
|
foreach (var fiber in component.Fibers)
|
|
{
|
|
if (fiber == pad.Sample)
|
|
{
|
|
_audioSystem.PlayPvs(component.SoundMatch, uid);
|
|
_popupSystem.PopupEntity(Loc.GetString("forensic-scanner-match-fiber"), uid, args.User);
|
|
return;
|
|
}
|
|
}
|
|
|
|
foreach (var fingerprint in component.Fingerprints)
|
|
{
|
|
if (fingerprint == pad.Sample)
|
|
{
|
|
_audioSystem.PlayPvs(component.SoundMatch, uid);
|
|
_popupSystem.PopupEntity(Loc.GetString("forensic-scanner-match-fingerprint"), uid, args.User);
|
|
return;
|
|
}
|
|
}
|
|
|
|
_audioSystem.PlayPvs(component.SoundNoMatch, uid);
|
|
_popupSystem.PopupEntity(Loc.GetString("forensic-scanner-match-none"), uid, args.User);
|
|
}
|
|
|
|
private void OnBeforeActivatableUIOpen(EntityUid uid, ForensicScannerComponent component, BeforeActivatableUIOpenEvent args)
|
|
{
|
|
UpdateUserInterface(uid, component);
|
|
}
|
|
|
|
private void OpenUserInterface(EntityUid user, Entity<ForensicScannerComponent> scanner)
|
|
{
|
|
UpdateUserInterface(scanner, scanner.Comp);
|
|
|
|
_uiSystem.OpenUi(scanner.Owner, ForensicScannerUiKey.Key, user);
|
|
}
|
|
|
|
private void OnPrint(EntityUid uid, ForensicScannerComponent component, ForensicScannerPrintMessage args)
|
|
{
|
|
var user = args.Actor;
|
|
|
|
if (_gameTiming.CurTime < component.PrintReadyAt)
|
|
{
|
|
// This shouldn't occur due to the UI guarding against it, but
|
|
// if it does, tell the user why nothing happened.
|
|
_popupSystem.PopupEntity(Loc.GetString("forensic-scanner-printer-not-ready"), uid, user);
|
|
return;
|
|
}
|
|
|
|
// Spawn a piece of paper.
|
|
var printed = EntityManager.SpawnEntity(component.MachineOutput, Transform(uid).Coordinates);
|
|
_handsSystem.PickupOrDrop(args.Actor, printed, checkActionBlocker: false);
|
|
|
|
if (!TryComp<PaperComponent>(printed, out var paperComp))
|
|
{
|
|
Log.Error("Printed paper did not have PaperComponent.");
|
|
return;
|
|
}
|
|
|
|
_metaData.SetEntityName(printed, Loc.GetString("forensic-scanner-report-title", ("entity", component.LastScannedName)));
|
|
|
|
var text = new StringBuilder();
|
|
|
|
text.AppendLine(Loc.GetString("forensic-scanner-interface-fingerprints"));
|
|
foreach (var fingerprint in component.Fingerprints)
|
|
{
|
|
text.AppendLine(fingerprint);
|
|
}
|
|
text.AppendLine();
|
|
text.AppendLine(Loc.GetString("forensic-scanner-interface-fibers"));
|
|
foreach (var fiber in component.Fibers)
|
|
{
|
|
text.AppendLine(fiber);
|
|
}
|
|
text.AppendLine();
|
|
text.AppendLine(Loc.GetString("forensic-scanner-interface-dnas"));
|
|
foreach (var dna in component.TouchDNAs)
|
|
{
|
|
text.AppendLine(dna);
|
|
}
|
|
foreach (var dna in component.SolutionDNAs)
|
|
{
|
|
Log.Debug(dna);
|
|
if (component.TouchDNAs.Contains(dna))
|
|
continue;
|
|
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, paperComp), text.ToString());
|
|
_audioSystem.PlayPvs(component.SoundPrint, uid,
|
|
AudioParams.Default
|
|
.WithVariation(0.25f)
|
|
.WithVolume(3f)
|
|
.WithRolloffFactor(2.8f)
|
|
.WithMaxDistance(4.5f));
|
|
|
|
component.PrintReadyAt = _gameTiming.CurTime + component.PrintCooldown;
|
|
}
|
|
|
|
private void OnClear(EntityUid uid, ForensicScannerComponent component, ForensicScannerClearMessage args)
|
|
{
|
|
component.Fingerprints = new();
|
|
component.Fibers = new();
|
|
component.TouchDNAs = new();
|
|
component.SolutionDNAs = new();
|
|
component.LastScannedName = string.Empty;
|
|
|
|
UpdateUserInterface(uid, component);
|
|
}
|
|
}
|
|
}
|