878 lines
36 KiB
C#
878 lines
36 KiB
C#
using Content.Server.Access.Systems;
|
|
using Content.Server.Damage.Components;
|
|
using Content.Server._DV.Cargo.Components;
|
|
using Content.Server._DV.Cargo.Systems;
|
|
using Content.Server._DV.Mail.Components;
|
|
using Content.Server.Destructible.Thresholds.Behaviors;
|
|
using Content.Server.Destructible.Thresholds.Triggers;
|
|
using Content.Server.Destructible.Thresholds;
|
|
using Content.Server.Destructible;
|
|
using Content.Server.Mind;
|
|
using Content.Server.Popups;
|
|
using Content.Server.Spawners.EntitySystems;
|
|
using Content.Server.Station.Systems;
|
|
using Content.Shared.Access.Components;
|
|
using Content.Shared.Access.Systems;
|
|
using Content.Shared.Access;
|
|
using Content.Shared.Chemistry.EntitySystems;
|
|
using Content.Shared.Damage;
|
|
using Content.Shared._DV.Mail;
|
|
using Content.Shared.Destructible;
|
|
using Content.Shared.Emag.Components;
|
|
using Content.Shared.Emag.Systems;
|
|
using Content.Shared.Examine;
|
|
using Content.Shared.Fluids.Components;
|
|
using Content.Shared.Hands.EntitySystems;
|
|
using Content.Shared.Interaction.Events;
|
|
using Content.Shared.Interaction;
|
|
using Content.Shared.Nutrition.Components;
|
|
using Content.Shared.Nutrition.EntitySystems;
|
|
using Content.Shared.PDA;
|
|
using Content.Shared.Roles;
|
|
using Content.Shared.Storage;
|
|
using Content.Shared.Tag;
|
|
using Robust.Shared.Audio.Systems;
|
|
using Robust.Shared.Audio;
|
|
using Robust.Shared.Containers;
|
|
using Robust.Shared.Prototypes;
|
|
using Robust.Shared.Random;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using Timer = Robust.Shared.Timing.Timer;
|
|
using Content.Server._NF.Bank; // Frontier
|
|
using Content.Server._NF.SectorServices; // Frontier
|
|
using Content.Server.Station.Components; // Frontier
|
|
using Robust.Shared.Enums; // Frontier
|
|
using Content.Shared._NF.Bank.Components; // Frontier
|
|
using Content.Shared._NF.Bank.BUI; // Frontier
|
|
using Content.Shared.SSDIndicator; // Frontier
|
|
using Content.Server.Power.EntitySystems; // Frontier
|
|
using Content.Server._NF.Mail.Components; // Frontier
|
|
using Robust.Server.Player; // Frontier
|
|
using Content.Server._Horizon.Mail.Components; // Horizon: NoMailStation
|
|
|
|
namespace Content.Server._DV.Mail.EntitySystems
|
|
{
|
|
public sealed class MailSystem : EntitySystem
|
|
{
|
|
[Dependency] private readonly AccessReaderSystem _accessSystem = default!;
|
|
[Dependency] private readonly DamageableSystem _damageableSystem = default!;
|
|
[Dependency] private readonly EntityLookupSystem _lookup = default!;
|
|
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
|
|
[Dependency] private readonly IRobustRandom _random = default!;
|
|
[Dependency] private readonly IdCardSystem _idCardSystem = default!;
|
|
[Dependency] private readonly MetaDataSystem _metaDataSystem = default!;
|
|
// [Dependency] private readonly MindSystem _mindSystem = default!; // Frontier: warning suppression
|
|
[Dependency] private readonly OpenableSystem _openable = default!;
|
|
[Dependency] private readonly PopupSystem _popupSystem = default!;
|
|
[Dependency] private readonly SharedAppearanceSystem _appearanceSystem = default!;
|
|
[Dependency] private readonly SharedAudioSystem _audioSystem = default!;
|
|
[Dependency] private readonly SharedContainerSystem _containerSystem = default!;
|
|
[Dependency] private readonly SharedHandsSystem _handsSystem = default!;
|
|
[Dependency] private readonly SharedSolutionContainerSystem _solution = default!;
|
|
[Dependency] private readonly StationSystem _stationSystem = default!;
|
|
[Dependency] private readonly TagSystem _tagSystem = default!;
|
|
[Dependency] private readonly LogisticStatsSystem _logisticsStatsSystem = default!;
|
|
[Dependency] private readonly EmagSystem _emag = default!;
|
|
[Dependency] private readonly SectorServiceSystem _sectorService = default!; // Frontier
|
|
[Dependency] private readonly BankSystem _bank = default!; // Frontier
|
|
[Dependency] private readonly PowerReceiverSystem _powerReceiver = default!; // Frontier
|
|
[Dependency] private readonly IPlayerManager _player = default!; // Frontier
|
|
|
|
private ISawmill _sawmill = default!;
|
|
private static readonly ProtoId<TagPrototype> MailTag = "Mail"; // Frontier
|
|
private static readonly ProtoId<TagPrototype> TrashTag = "Trash"; // Frontier
|
|
private static readonly ProtoId<TagPrototype> RecyclableTag = "Recyclable"; // Frontier
|
|
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
|
|
_sawmill = Logger.GetSawmill("mail");
|
|
|
|
SubscribeLocalEvent<PlayerSpawningEvent>(OnSpawnPlayer, after: new[] { typeof(SpawnPointSystem) });
|
|
|
|
SubscribeLocalEvent<MailComponent, ComponentRemove>(OnRemove);
|
|
SubscribeLocalEvent<MailComponent, UseInHandEvent>(OnUseInHand);
|
|
SubscribeLocalEvent<MailComponent, AfterInteractUsingEvent>(OnAfterInteractUsing);
|
|
SubscribeLocalEvent<MailComponent, ExaminedEvent>(OnExamined);
|
|
SubscribeLocalEvent<MailComponent, DestructionEventArgs>(OnDestruction);
|
|
SubscribeLocalEvent<MailComponent, DamageChangedEvent>(OnDamage);
|
|
SubscribeLocalEvent<MailComponent, BreakageEventArgs>(OnBreak);
|
|
SubscribeLocalEvent<MailComponent, GotEmaggedEvent>(OnMailEmagged);
|
|
}
|
|
|
|
public override void Update(float frameTime)
|
|
{
|
|
base.Update(frameTime);
|
|
|
|
// Frontier: sector-wide mail
|
|
if (TryComp(_sectorService.GetServiceEntity(), out SectorMailComponent? mail))
|
|
{
|
|
mail.Accumulator += frameTime;
|
|
if (mail.Accumulator < mail.TeleportInterval.TotalSeconds)
|
|
return;
|
|
|
|
mail.Accumulator -= (float)mail.TeleportInterval.TotalSeconds;
|
|
SpawnMail(mail);
|
|
}
|
|
// End Frontier
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dynamically add the MailReceiver component to appropriate entities.
|
|
/// </summary>
|
|
private void OnSpawnPlayer(PlayerSpawningEvent args)
|
|
{
|
|
if (args.SpawnResult == null ||
|
|
args.Job == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//if (!HasComp<StationMailRouterComponent>(station)) // Frontier - We dont need to test this.
|
|
// return;
|
|
|
|
// Horizon: Check if station has NoMailStationComponent - if so, disable mail for this player
|
|
if (args.Station != null && HasComp<NoMailStationComponent>(args.Station.Value))
|
|
{
|
|
EnsureComp<MailDisabledComponent>(args.SpawnResult.Value);
|
|
return;
|
|
}
|
|
// End Horizon
|
|
|
|
EnsureComp<MailReceiverComponent>(args.SpawnResult.Value);
|
|
}
|
|
|
|
private static void OnRemove(EntityUid uid, MailComponent component, ComponentRemove args)
|
|
{
|
|
component.PriorityCancelToken?.Cancel();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Try to open the mail.
|
|
/// </summary>
|
|
private void OnUseInHand(EntityUid uid, MailComponent component, UseInHandEvent args)
|
|
{
|
|
if (!component.IsEnabled)
|
|
return;
|
|
if (component.IsLocked)
|
|
{
|
|
_popupSystem.PopupEntity(Loc.GetString("mail-locked"), uid, args.User);
|
|
return;
|
|
}
|
|
OpenMail(uid, component, args.User);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle logic similar between a normal mail unlock and an emag
|
|
/// frying out the lock.
|
|
/// </summary>
|
|
private void UnlockMail(EntityUid uid, MailComponent component)
|
|
{
|
|
component.IsLocked = false;
|
|
UpdateAntiTamperVisuals(uid, false);
|
|
|
|
if (!component.IsPriority)
|
|
return;
|
|
|
|
// This is a successful delivery. Keep the failure timer from triggering.
|
|
component.PriorityCancelToken?.Cancel();
|
|
|
|
// The priority tape is visually considered to be a part of the
|
|
// anti-tamper lock, so remove that too.
|
|
_appearanceSystem.SetData(uid, MailVisuals.IsPriority, false);
|
|
|
|
// The examination code depends on this being false to not show
|
|
// the priority tape description anymore.
|
|
component.IsPriority = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check the ID against the mail's lock
|
|
/// </summary>
|
|
private void OnAfterInteractUsing(EntityUid uid, MailComponent component, AfterInteractUsingEvent args)
|
|
{
|
|
if (!args.CanReach || !component.IsLocked)
|
|
return;
|
|
|
|
if (!HasComp<AccessReaderComponent>(uid))
|
|
return;
|
|
|
|
IdCardComponent? idCard = null; // We need an ID card.
|
|
|
|
if (HasComp<PdaComponent>(args.Used)) // Can we find it in a PDA if the user is using that?
|
|
{
|
|
_idCardSystem.TryGetIdCard(args.Used, out var pdaId);
|
|
idCard = pdaId;
|
|
}
|
|
if (idCard == null && HasComp<IdCardComponent>(args.Used)) // If we still don't have an ID, check if the item itself is one
|
|
idCard = Comp<IdCardComponent>(args.Used);
|
|
|
|
if (idCard == null) // Return if we still haven't found an id card.
|
|
return;
|
|
|
|
if (!_emag.CheckFlag(uid, EmagType.Interaction))
|
|
{
|
|
if (idCard.FullName != component.Recipient /*|| idCard.LocalizedJobTitle != component.RecipientJob*/) // Frontier - Only match the name
|
|
{
|
|
_popupSystem.PopupEntity(Loc.GetString("mail-recipient-mismatch-name"), uid, args.User);
|
|
return;
|
|
}
|
|
|
|
if (!_accessSystem.IsAllowed(uid, args.User))
|
|
{
|
|
_popupSystem.PopupEntity(Loc.GetString("mail-invalid-access"), uid, args.User);
|
|
return;
|
|
}
|
|
}
|
|
|
|
UnlockMail(uid, component);
|
|
if (component.IsProfitable) // Frontier: update only when profitable, run after unlocking mail
|
|
{
|
|
// DeltaV - Add earnings to logistic stats
|
|
ExecuteForEachLogisticsStats((logisticStats) =>
|
|
{
|
|
_logisticsStatsSystem.AddOpenedMailEarnings(logisticStats,
|
|
component.Bounty);
|
|
});
|
|
}
|
|
|
|
if (!component.IsProfitable)
|
|
{
|
|
_popupSystem.PopupEntity(Loc.GetString("mail-unlocked"), uid, args.User);
|
|
return;
|
|
}
|
|
|
|
_popupSystem.PopupEntity(Loc.GetString("mail-unlocked-reward", ("bounty", component.Bounty)), uid, args.User); // Frontier - Remove the mention of station income
|
|
component.IsProfitable = false;
|
|
|
|
_bank.TrySectorDeposit(SectorBankAccount.Frontier, component.Bounty, LedgerEntryType.MailDelivered);
|
|
}
|
|
|
|
private void OnExamined(EntityUid uid, MailComponent component, ExaminedEvent args)
|
|
{
|
|
var mailEntityStrings = component.IsLarge ? MailConstants.MailLarge : MailConstants.Mail;
|
|
|
|
if (!args.IsInDetailsRange)
|
|
{
|
|
args.PushMarkup(Loc.GetString(mailEntityStrings.DescFar));
|
|
return;
|
|
}
|
|
|
|
args.PushMarkup(Loc.GetString(mailEntityStrings.DescClose,
|
|
("name", component.Recipient),
|
|
("job", component.RecipientJob),
|
|
("station", component.RecipientStation))); // Frontier: add station
|
|
|
|
if (component.IsFragile)
|
|
args.PushMarkup(Loc.GetString("mail-desc-fragile"));
|
|
|
|
if (component.IsPriority)
|
|
args.PushMarkup(Loc.GetString(component.IsProfitable ? "mail-desc-priority" : "mail-desc-priority-inactive"));
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Penalize a station for a failed delivery.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// This will mark a parcel as no longer being profitable, which will
|
|
/// prevent multiple failures on different conditions for the same
|
|
/// delivery.
|
|
///
|
|
/// The standard penalization is breaking the anti-tamper lock,
|
|
/// but this allows a delivery to fail for other reasons too
|
|
/// while having a generic function to handle different messages.
|
|
/// </remarks>
|
|
private void PenalizeStationFailedDelivery(EntityUid uid, MailComponent component, string localizationString)
|
|
{
|
|
if (!component.IsProfitable)
|
|
return;
|
|
|
|
//_chatSystem.TrySendInGameICMessage(uid, Loc.GetString(localizationString, ("credits", component.Penalty)), InGameICChatType.Speak, false); // Frontier - Dont show message.
|
|
//_audioSystem.PlayPvs(component.PenaltySound, uid); // Frontier - Dont show message. // Frontier - Dont play sound.
|
|
|
|
component.IsProfitable = false;
|
|
|
|
if (component.IsPriority)
|
|
_appearanceSystem.SetData(uid, MailVisuals.IsPriorityInactive, true);
|
|
|
|
// Frontier: no need for this, but this uses our sector bank accounts
|
|
//_bank.TrySectorWithdraw(SectorBankAccount.Frontier, component.Penalty, LedgerEntryType.MailPenalty); // Frontier - Dont remove money.
|
|
}
|
|
|
|
private void OnDestruction(EntityUid uid, MailComponent component, DestructionEventArgs args)
|
|
{
|
|
if (component.IsLocked)
|
|
{
|
|
// DeltaV - Tampered mail recorded to logistic stats
|
|
if (component.IsProfitable) // Frontier: update only when profitable
|
|
{
|
|
PenalizeStationFailedDelivery(uid, component, "mail-penalty-lock");
|
|
|
|
component.IsLocked = false; // Frontier: do not count this package as unopened.
|
|
ExecuteForEachLogisticsStats((logisticStats) =>
|
|
{
|
|
_logisticsStatsSystem.AddDamagedMailLosses(logisticStats, // Frontier:consider mail as damaged, not tampered
|
|
component.Penalty);
|
|
});
|
|
}
|
|
}
|
|
|
|
// if (component.IsEnabled)
|
|
// OpenMail(uid, component); // Frontier - Dont open the mail on destruction.
|
|
|
|
UpdateAntiTamperVisuals(uid, false);
|
|
}
|
|
|
|
private void OnDamage(EntityUid uid, MailComponent component, DamageChangedEvent args)
|
|
{
|
|
if (args.DamageDelta == null)
|
|
return;
|
|
|
|
if (!_containerSystem.TryGetContainer(uid, "contents", out var contents))
|
|
return;
|
|
|
|
// Transfer damage to the contents.
|
|
// This should be a general-purpose feature for all containers in the future.
|
|
foreach (var entity in contents.ContainedEntities.ToArray())
|
|
{
|
|
_damageableSystem.TryChangeDamage(entity, args.DamageDelta);
|
|
}
|
|
}
|
|
|
|
private void OnBreak(EntityUid uid, MailComponent component, BreakageEventArgs args)
|
|
{
|
|
_appearanceSystem.SetData(uid, MailVisuals.IsBroken, true);
|
|
|
|
if (component.IsFragile || !component.IsProfitable) // Frontier: update only when profitable
|
|
return;
|
|
// DeltaV - Broken mail recorded to logistic stats
|
|
ExecuteForEachLogisticsStats((logisticStats) => // Frontier: no station
|
|
{
|
|
_logisticsStatsSystem.AddDamagedMailLosses(logisticStats,
|
|
component.Penalty);
|
|
});
|
|
|
|
PenalizeStationFailedDelivery(uid, component, "mail-penalty-fragile");
|
|
}
|
|
|
|
private void OnMailEmagged(EntityUid uid, MailComponent component, ref GotEmaggedEvent args)
|
|
{
|
|
// Frontier: emag type check
|
|
if (args.Handled || !_emag.CheckFlag(uid, EmagType.Access))
|
|
return;
|
|
// End Frontier
|
|
|
|
if (!component.IsLocked)
|
|
return;
|
|
|
|
UnlockMail(uid, component);
|
|
|
|
// Frontier: penalize station on emag, but only if profitable
|
|
if (component.IsProfitable)
|
|
{
|
|
PenalizeStationFailedDelivery(uid, component, "mail-penalty-lock");
|
|
|
|
// DeltaV - Tampered mail recorded to logistic stats
|
|
ExecuteForEachLogisticsStats((logisticStats) =>
|
|
{
|
|
_logisticsStatsSystem.AddTamperedMailLosses(logisticStats,
|
|
component.Penalty);
|
|
});
|
|
}
|
|
// End Frontier
|
|
|
|
_popupSystem.PopupEntity(Loc.GetString("mail-unlocked-by-emag"), uid, args.UserUid);
|
|
|
|
_audioSystem.PlayPvs(component.EmagSound, uid, AudioParams.Default.WithVolume(4));
|
|
component.IsProfitable = false;
|
|
args.Handled = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if the given entity is considered fragile for delivery.
|
|
/// </summary>
|
|
private bool IsEntityFragile(EntityUid uid, int fragileDamageThreshold)
|
|
{
|
|
// It takes damage on falling.
|
|
if (HasComp<DamageOnLandComponent>(uid))
|
|
return true;
|
|
|
|
// It can be spilled easily and has something to spill.
|
|
if (HasComp<SpillableComponent>(uid)
|
|
&& TryComp<OpenableComponent>(uid, out var openable)
|
|
&& !_openable.IsClosed(uid, null, openable)
|
|
&& _solution.PercentFull(uid) > 0)
|
|
return true;
|
|
|
|
// It might be made of non-reinforced glass.
|
|
if (TryComp<DamageableComponent>(uid, out var damageableComponent)
|
|
&& damageableComponent.DamageModifierSetId == "Glass")
|
|
return true;
|
|
|
|
// Fallback: It breaks or is destroyed in less than a damage
|
|
// threshold dictated by the teleporter.
|
|
if (!TryComp<DestructibleComponent>(uid, out var destructibleComp))
|
|
return false;
|
|
|
|
foreach (var threshold in destructibleComp.Thresholds)
|
|
{
|
|
if (threshold.Trigger is not DamageTrigger trigger || trigger.Damage >= fragileDamageThreshold)
|
|
continue;
|
|
|
|
foreach (var behavior in threshold.Behaviors)
|
|
{
|
|
if (behavior is not DoActsBehavior doActs)
|
|
continue;
|
|
|
|
if (doActs.Acts.HasFlag(ThresholdActs.Breakage) || doActs.Acts.HasFlag(ThresholdActs.Destruction))
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private bool TryMatchJobTitleToDepartment(string jobTitle, [NotNullWhen(true)] out string? jobDepartment)
|
|
{
|
|
jobDepartment = null;
|
|
|
|
var departments = _prototypeManager.EnumeratePrototypes<DepartmentPrototype>();
|
|
|
|
foreach (var department in departments)
|
|
{
|
|
var foundJob = department.Roles
|
|
.Any(role =>
|
|
_prototypeManager.TryIndex(role, out var jobPrototype)
|
|
&& jobPrototype.LocalizedName == jobTitle);
|
|
|
|
if (!foundJob)
|
|
continue;
|
|
|
|
jobDepartment = department.ID;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private bool TryMatchJobTitleToPrototype(string jobTitle, [NotNullWhen(true)] out JobPrototype? jobPrototype)
|
|
{
|
|
jobPrototype = _prototypeManager
|
|
.EnumeratePrototypes<JobPrototype>()
|
|
.FirstOrDefault(job => job.LocalizedName == jobTitle);
|
|
|
|
return jobPrototype != null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle all the gritty details particular to a new mail entity.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// This is separate mostly so the unit tests can get to it.
|
|
/// </remarks>
|
|
public void SetupMail(EntityUid uid, SectorMailComponent component, MailRecipient recipient) // Frontier: MailTeleporterComponent<SectorMailComponent
|
|
{
|
|
var mailComp = EnsureComp<MailComponent>(uid);
|
|
|
|
var container = _containerSystem.EnsureContainer<Container>(uid, "contents");
|
|
foreach (var entity in EntitySpawnCollection.GetSpawns(mailComp.Contents, _random).Select(item => EntityManager.SpawnEntity(item, Transform(uid).Coordinates)))
|
|
{
|
|
if (!_containerSystem.Insert(entity, container))
|
|
{
|
|
_sawmill.Error($"Can't insert {ToPrettyString(entity)} into new mail delivery {ToPrettyString(uid)}! Deleting it.");
|
|
QueueDel(entity);
|
|
}
|
|
else if (!mailComp.IsFragile && IsEntityFragile(entity, component.FragileDamageThreshold))
|
|
{
|
|
mailComp.IsFragile = true;
|
|
}
|
|
}
|
|
|
|
if (_random.Prob(component.PriorityChance))
|
|
mailComp.IsPriority = true;
|
|
|
|
// This needs to override both the random probability and the
|
|
// entity prototype, so this is fine.
|
|
if (!recipient.MayReceivePriorityMail)
|
|
mailComp.IsPriority = false;
|
|
|
|
mailComp.RecipientJob = recipient.Job;
|
|
mailComp.Recipient = recipient.Name;
|
|
mailComp.RecipientStation = recipient.Ship; // Frontier
|
|
|
|
// Frontier: Large mail bonus
|
|
var mailEntityStrings = mailComp.IsLarge ? MailConstants.MailLarge : MailConstants.Mail;
|
|
if (mailComp.IsLarge)
|
|
{
|
|
mailComp.Bounty += component.LargeBonus;
|
|
//mailComp.Penalty += component.LargeMalus; // Frontier - Setting penalty to stay 0
|
|
}
|
|
// End Frontier
|
|
|
|
if (mailComp.IsFragile)
|
|
{
|
|
mailComp.Bounty += component.FragileBonus;
|
|
//mailComp.Penalty += component.FragileMalus; // Frontier - Setting penalty to stay 0
|
|
_appearanceSystem.SetData(uid, MailVisuals.IsFragile, true);
|
|
}
|
|
|
|
if (mailComp.IsPriority)
|
|
{
|
|
mailComp.Bounty += component.PriorityBonus;
|
|
//mailComp.Penalty += component.PriorityMalus; // Frontier - Setting penalty to stay 0
|
|
_appearanceSystem.SetData(uid, MailVisuals.IsPriority, true);
|
|
|
|
mailComp.PriorityCancelToken = new CancellationTokenSource();
|
|
|
|
Timer.Spawn((int)component.PriorityDuration.TotalMilliseconds,
|
|
() =>
|
|
{
|
|
if (!mailComp.IsProfitable) // Frontier: only penalize and adjust stats if profitable
|
|
return;
|
|
|
|
PenalizeStationFailedDelivery(uid, mailComp, "mail-penalty-expired"); // Frontier: penalize first
|
|
|
|
// DeltaV - Expired mail recorded to logistic stats
|
|
ExecuteForEachLogisticsStats((logisticStats) =>
|
|
{
|
|
_logisticsStatsSystem.AddExpiredMailLosses(logisticStats,
|
|
mailComp.Penalty);
|
|
});
|
|
},
|
|
mailComp.PriorityCancelToken.Token);
|
|
}
|
|
|
|
_appearanceSystem.SetData(uid, MailVisuals.JobIcon, recipient.JobIcon);
|
|
|
|
_metaDataSystem.SetEntityName(uid,
|
|
Loc.GetString(mailEntityStrings.NameAddressed, // Frontier: move constant to MailEntityString
|
|
("recipient", recipient.Name)));
|
|
|
|
var accessReader = EnsureComp<AccessReaderComponent>(uid);
|
|
// Frontier: TODO - should this be removed for Frontier?
|
|
foreach (var access in recipient.AccessTags)
|
|
{
|
|
accessReader.AccessLists.Add([access]);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the parcels waiting for delivery.
|
|
/// </summary>
|
|
/// <param name="uid">The mail teleporter to check.</param>
|
|
private List<EntityUid> GetUndeliveredParcels(EntityUid uid)
|
|
{
|
|
// An alternative solution would be to keep a list of the unopened
|
|
// parcels spawned by the teleporter and see if they're not carried
|
|
// by someone, but this is simple, and simple is good.
|
|
var coordinates = Transform(uid).Coordinates;
|
|
const LookupFlags lookupFlags = LookupFlags.Dynamic | LookupFlags.Sundries;
|
|
|
|
var entitiesInTile = _lookup.GetEntitiesIntersecting(coordinates, lookupFlags);
|
|
|
|
return entitiesInTile.Where(HasComp<MailComponent>).ToList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return how many parcels are waiting for delivery.
|
|
/// </summary>
|
|
/// <param name="uid">The mail teleporter to check.</param>
|
|
private uint GetUndeliveredParcelCount(EntityUid uid)
|
|
{
|
|
return (uint)GetUndeliveredParcels(uid).Count;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Try to match a mail receiver to a mail teleporter.
|
|
/// </summary>
|
|
public bool TryGetMailTeleporterForReceiver(EntityUid receiverUid, [NotNullWhen(true)] out MailTeleporterComponent? teleporterComponent, [NotNullWhen(true)] out EntityUid? teleporterUid)
|
|
{
|
|
var query = EntityQueryEnumerator<MailTeleporterComponent>();
|
|
//var receiverStation = _stationSystem.GetOwningStation(receiverUid); // Frontier: skip station checks
|
|
|
|
while (query.MoveNext(out var uid, out var mailTeleporter))
|
|
{
|
|
// Frontier: skip station checks, ensure teleporter is powered
|
|
// var teleporterStation = _stationSystem.GetOwningStation(uid);
|
|
// if (receiverStation != teleporterStation)
|
|
// continue;
|
|
if (!_powerReceiver.IsPowered(uid))
|
|
continue;
|
|
// End Frontier
|
|
teleporterComponent = mailTeleporter;
|
|
teleporterUid = uid;
|
|
return true;
|
|
}
|
|
|
|
teleporterComponent = null;
|
|
teleporterUid = null;
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Try to construct a recipient struct for a mail parcel based on a receiver.
|
|
/// </summary>
|
|
public bool TryGetMailRecipientForReceiver(EntityUid receiverUid, [NotNullWhen(true)] out MailRecipient? recipient)
|
|
{
|
|
recipient = null; // Frontier
|
|
if (_idCardSystem.TryFindIdCard(receiverUid, out var idCard)
|
|
&& TryComp<AccessComponent>(idCard.Owner, out var access)
|
|
&& idCard.Comp.FullName != null)
|
|
{
|
|
// Frontier: get name of station recipient is on, check recipient isn't SSD
|
|
string stationName;
|
|
if (_stationSystem.GetOwningStation(receiverUid) is { Valid: true } station
|
|
&& TryComp<StationDataComponent>(station, out var stationData)
|
|
&& _stationSystem.GetLargestGrid(stationData) is { Valid: true } stationGrid
|
|
&& TryName(stationGrid, out var gridName)
|
|
&& gridName != null)
|
|
{
|
|
stationName = gridName;
|
|
}
|
|
else
|
|
{
|
|
stationName = "Unknown";
|
|
}
|
|
|
|
// Mail recipients requires a connected player
|
|
if (!_player.TryGetSessionByEntity(receiverUid, out var session)
|
|
|| session.State.Status != SessionStatus.InGame)
|
|
return false;
|
|
|
|
// Antagonists (pirates and the like) don't get mail.
|
|
if (HasComp<MailDisabledComponent>(receiverUid))
|
|
return false;
|
|
// End Frontier
|
|
|
|
var accessTags = access.Tags;
|
|
//var mayReceivePriorityMail = !(_mindSystem.GetMind(receiverUid) == null);
|
|
|
|
recipient = new MailRecipient(
|
|
idCard.Comp.FullName,
|
|
idCard.Comp.LocalizedJobTitle ?? idCard.Comp.JobTitle ?? "Unknown",
|
|
idCard.Comp.JobIcon,
|
|
accessTags,
|
|
true, // Frontier: all recipients can receive priority mail
|
|
stationName); // Frontier: add stationName
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the list of valid mail recipients for a mail teleporter.
|
|
/// </summary>
|
|
private List<MailRecipient> GetMailRecipientCandidates() // Frontier: remove EntityUid arg
|
|
{
|
|
var candidateList = new List<MailRecipient>();
|
|
var query = EntityQueryEnumerator<MailReceiverComponent>();
|
|
//var teleporterStation = _stationSystem.GetOwningStation(uid); // Frontier: unnecessary
|
|
|
|
while (query.MoveNext(out var receiverUid, out _))
|
|
{
|
|
var location = Transform(receiverUid);
|
|
|
|
// Frontier: sector-wide mail
|
|
// var receiverStation = _stationSystem.GetOwningStation(receiverUid);
|
|
// if (receiverStation != teleporterStation)
|
|
// continue;
|
|
|
|
// Are you on expedition or in FTL? No mail for you.
|
|
if (location.MapID != Transform(receiverUid).MapID)
|
|
continue;
|
|
|
|
// Is this player displaying as SSD? If so, skip 'em.
|
|
if (TryComp(receiverUid, out SSDIndicatorComponent? ssd) && ssd.IsSSD)
|
|
continue;
|
|
// End Frontier
|
|
|
|
if (TryGetMailRecipientForReceiver(receiverUid, out var recipient))
|
|
candidateList.Add(recipient.Value);
|
|
}
|
|
|
|
return candidateList;
|
|
}
|
|
|
|
// Frontier: sector-wide mail
|
|
sealed class MailTeleporterSpawnData(Entity<MailTeleporterComponent> entity)
|
|
{
|
|
public Entity<MailTeleporterComponent> Entity = entity;
|
|
public bool HadMail = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle the spawning of all the mail for a mail teleporter.
|
|
/// </summary>
|
|
private void SpawnMail(SectorMailComponent component)
|
|
{
|
|
// Get list of valid teleporters.
|
|
List<MailTeleporterSpawnData> validTeleporters = new();
|
|
var teleporterQuery = EntityQueryEnumerator<MailTeleporterComponent>();
|
|
while (teleporterQuery.MoveNext(out var uid, out var mailTeleporter))
|
|
{
|
|
if (_powerReceiver.IsPowered(uid)
|
|
&& GetUndeliveredParcelCount(uid) < mailTeleporter.MaximumUndeliveredParcels)
|
|
{
|
|
validTeleporters.Add(new MailTeleporterSpawnData((uid, mailTeleporter)));
|
|
}
|
|
}
|
|
|
|
// If list of teleporters is empty, return.
|
|
if (validTeleporters.Count <= 0)
|
|
{
|
|
_sawmill.Info("List of valid mail teleporters was empty!");
|
|
return;
|
|
}
|
|
|
|
var candidateList = GetMailRecipientCandidates();
|
|
|
|
if (candidateList.Count <= 0)
|
|
{
|
|
_sawmill.Info("List of mail candidates was empty!");
|
|
return;
|
|
}
|
|
|
|
if (!_prototypeManager.TryIndex<MailDeliveryPoolPrototype>(component.MailPool, out var pool))
|
|
{
|
|
_sawmill.Error($"Can't find MailPool {component.MailPool}!");
|
|
return;
|
|
}
|
|
|
|
var deliveryCount = component.MinimumDeliveriesPerTeleport + candidateList.Count / component.CandidatesPerDelivery;
|
|
|
|
for (var i = 0; i < deliveryCount; i++)
|
|
{
|
|
var candidate = _random.Pick(candidateList);
|
|
var possibleParcels = new Dictionary<string, float>(pool.Everyone);
|
|
|
|
if (TryMatchJobTitleToPrototype(candidate.Job, out var jobPrototype)
|
|
&& pool.Jobs.TryGetValue(jobPrototype.ID, out var jobParcels))
|
|
{
|
|
possibleParcels = possibleParcels
|
|
.Concat(jobParcels)
|
|
.GroupBy(g => g.Key)
|
|
.ToDictionary(pair => pair.Key, pair => pair.First().Value);
|
|
}
|
|
|
|
if (TryMatchJobTitleToDepartment(candidate.Job, out var department)
|
|
&& pool.Departments.TryGetValue(department, out var departmentParcels))
|
|
{
|
|
possibleParcels = possibleParcels
|
|
.Concat(departmentParcels)
|
|
.GroupBy(g => g.Key)
|
|
.ToDictionary(pair => pair.Key, pair => pair.First().Value);
|
|
}
|
|
|
|
var accumulated = 0f;
|
|
var randomPoint = _random.NextFloat(possibleParcels.Values.Sum());
|
|
string? chosenParcel = null;
|
|
|
|
foreach (var parcel in possibleParcels)
|
|
{
|
|
accumulated += parcel.Value;
|
|
if (!(accumulated >= randomPoint))
|
|
continue;
|
|
chosenParcel = parcel.Key;
|
|
break;
|
|
}
|
|
|
|
if (chosenParcel == null)
|
|
{
|
|
_sawmill.Error($"MailSystem wasn't able to find a deliverable parcel for {candidate.Name}, {candidate.Job}!");
|
|
return;
|
|
}
|
|
|
|
var index = _random.Next(validTeleporters.Count);
|
|
|
|
var coordinates = Transform(validTeleporters[index].Entity).Coordinates;
|
|
var mail = EntityManager.SpawnEntity(chosenParcel, coordinates);
|
|
SetupMail(mail, component, candidate);
|
|
validTeleporters[index].HadMail = true;
|
|
|
|
_tagSystem.AddTag(mail, MailTag); // Frontier
|
|
}
|
|
|
|
for (int i = 0; i < validTeleporters.Count; i++)
|
|
{
|
|
// Remove queued contents (e.g. from admemes)
|
|
if (_containerSystem.TryGetContainer(validTeleporters[i].Entity, "queued", out var queued))
|
|
validTeleporters[i].HadMail |= _containerSystem.EmptyContainer(queued).Count > 0;
|
|
|
|
if (validTeleporters[i].HadMail)
|
|
_audioSystem.PlayPvs(validTeleporters[i].Entity.Comp.TeleportSound, validTeleporters[i].Entity);
|
|
}
|
|
}
|
|
// End Frontier: sector-wide mail
|
|
|
|
private void OpenMail(EntityUid uid, MailComponent? component = null, EntityUid? user = null)
|
|
{
|
|
if (!Resolve(uid, ref component))
|
|
return;
|
|
|
|
_audioSystem.PlayPvs(component.OpenSound, uid);
|
|
|
|
if (user != null)
|
|
_handsSystem.TryDrop((EntityUid)user);
|
|
|
|
if (!_containerSystem.TryGetContainer(uid, "contents", out var contents))
|
|
{
|
|
// I silenced this error because it fails non deterministically in tests and doesn't seem to effect anything else.
|
|
// _sawmill.Error($"Mail {ToPrettyString(uid)} was missing contents container!");
|
|
return;
|
|
}
|
|
|
|
foreach (var entity in contents.ContainedEntities.ToArray())
|
|
{
|
|
_handsSystem.PickupOrDrop(user, entity);
|
|
}
|
|
|
|
_tagSystem.AddTag(uid, TrashTag);
|
|
_tagSystem.AddTag(uid, RecyclableTag);
|
|
component.IsEnabled = false;
|
|
UpdateMailTrashState(uid, true);
|
|
}
|
|
|
|
private void UpdateAntiTamperVisuals(EntityUid uid, bool isLocked)
|
|
{
|
|
_appearanceSystem.SetData(uid, MailVisuals.IsLocked, isLocked);
|
|
}
|
|
|
|
private void UpdateMailTrashState(EntityUid uid, bool isTrash)
|
|
{
|
|
_appearanceSystem.SetData(uid, MailVisuals.IsTrash, isTrash);
|
|
}
|
|
|
|
// DeltaV - Helper function that executes for each StationLogisticsStatsComponent
|
|
// For updating MailMetrics stats
|
|
private void ExecuteForEachLogisticsStats(Action<SectorLogisticStatsComponent> action)
|
|
{
|
|
// Frontier: use service entity - there should be only one
|
|
if (TryComp(_sectorService.GetServiceEntity(), out SectorLogisticStatsComponent? logisticStats))
|
|
action(logisticStats);
|
|
// End Frontier
|
|
}
|
|
}
|
|
|
|
public struct MailRecipient(
|
|
string name,
|
|
string job,
|
|
string jobIcon,
|
|
HashSet<ProtoId<AccessLevelPrototype>> accessTags,
|
|
bool mayReceivePriorityMail,
|
|
string ship) // Frontier: add ship
|
|
{
|
|
public readonly string Name = name;
|
|
public readonly string Job = job;
|
|
public readonly string JobIcon = jobIcon;
|
|
public readonly HashSet<ProtoId<AccessLevelPrototype>> AccessTags = accessTags;
|
|
public readonly bool MayReceivePriorityMail = mayReceivePriorityMail;
|
|
public readonly string Ship = ship; // Frontier
|
|
}
|
|
}
|