tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added sink (#14348)

Browse Source
This commit is contained in:
Topy
2023-07-01 00:10:47 +02:00
committed by GitHub
parent 7d89b9e253
commit b85c902189
36 changed files with 484 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

304
Content.Server/Fluids/EntitySystems/DrainSystem.cs
View File

@@ -1,101 +1,265 @@
using Content.Server.Chemistry.Components.SolutionManager;
using Content.Server.Fluids.Components;
using Content.Server.Chemistry.EntitySystems;
using Content.Server.DoAfter;
using Content.Server.Popups;
using Content.Shared.FixedPoint;
using Content.Shared.Audio;
using Content.Shared.Database;
using Content.Shared.DoAfter;
using Content.Shared.Examine;
using Content.Shared.Fluids;
using Content.Shared.Interaction;
using Content.Shared.Tag;
using Content.Shared.Verbs;
using Content.Shared.Fluids.Components;
using Robust.Shared.Collections;
using Robust.Shared.Random;
using Robust.Shared.Utility;
namespace Content.Server.Fluids.EntitySystems
namespace Content.Server.Fluids.EntitySystems;
public sealed class DrainSystem : SharedDrainSystem
{
public sealed class DrainSystem : EntitySystem
[Dependency] private readonly EntityLookupSystem _lookup = default!;
[Dependency] private readonly SolutionContainerSystem _solutionSystem = default!;
[Dependency] private readonly SharedAmbientSoundSystem _ambientSoundSystem = default!;
[Dependency] private readonly SharedAudioSystem _audioSystem = default!;
[Dependency] private readonly PopupSystem _popupSystem = default!;
[Dependency] private readonly TagSystem _tagSystem = default!;
[Dependency] private readonly DoAfterSystem _doAfterSystem = default!;
[Dependency] private readonly PuddleSystem _puddleSystem = default!;
[Dependency] private readonly IRobustRandom _random = default!;
public override void Initialize()
{
[Dependency] private readonly EntityLookupSystem _lookup = default!;
[Dependency] private readonly SolutionContainerSystem _solutionSystem = default!;
[Dependency] private readonly SharedAmbientSoundSystem _ambientSoundSystem = default!;
base.Initialize();
SubscribeLocalEvent<DrainComponent, GetVerbsEvent<Verb>>(AddEmptyVerb);
SubscribeLocalEvent<DrainComponent, ExaminedEvent>(OnExamined);
SubscribeLocalEvent<DrainComponent, AfterInteractUsingEvent>(OnInteract);
SubscribeLocalEvent<DrainComponent, DrainDoAfterEvent>(OnDoAfter);
}
public override void Update(float frameTime)
private void AddEmptyVerb(EntityUid uid, DrainComponent component, GetVerbsEvent<Verb> args)
{
if (!args.CanAccess || !args.CanInteract || args.Using == null)
return;
if (!TryComp(args.Using, out SpillableComponent? spillable) ||
!TryComp(args.Target, out DrainComponent? drain))
return;
Verb verb = new()
{
base.Update(frameTime);
var managerQuery = GetEntityQuery<SolutionContainerManagerComponent>();
var xformQuery = GetEntityQuery<TransformComponent>();
var puddleQuery = GetEntityQuery<PuddleComponent>();
var puddles = new ValueList<(EntityUid Entity, string Solution)>();
foreach (var drain in EntityQuery<DrainComponent>())
Text = Loc.GetString("drain-component-empty-verb-inhand", ("object", Name(args.Using.Value))),
Act = () =>
{
drain.Accumulator += frameTime;
if (drain.Accumulator < drain.DrainFrequency)
Empty(args.Using.Value, spillable, args.Target, drain);
},
Impact = LogImpact.Low,
Icon = new SpriteSpecifier.Texture(new ResPath("/Textures/Interface/VerbIcons/eject.svg.192dpi.png"))
};
args.Verbs.Add(verb);
}
private void Empty(EntityUid container, SpillableComponent spillable, EntityUid target, DrainComponent drain)
{
// Find the solution in the container that is emptied
if (!_solutionSystem.TryGetDrainableSolution(container, out var containerSolution) ||
containerSolution.Volume == FixedPoint2.Zero)
{
_popupSystem.PopupEntity(
Loc.GetString("drain-component-empty-verb-using-is-empty-message", ("object", container)),
container);
return;
}
// try to find the drain's solution
if (!_solutionSystem.TryGetSolution(target, DrainComponent.SolutionName, out var drainSolution))
{
return;
}
// Try to transfer as much solution as possible to the drain
var transferSolution = _solutionSystem.SplitSolution(container, containerSolution,
FixedPoint2.Min(containerSolution.Volume, drainSolution.AvailableVolume));
_solutionSystem.TryAddSolution(target, drainSolution, transferSolution);
_audioSystem.PlayPvs(drain.ManualDrainSound, target);
_ambientSoundSystem.SetAmbience(target, true);
// If drain is full, spill
if (drainSolution.MaxVolume == drainSolution.Volume)
{
_puddleSystem.TrySpillAt(Transform(target).Coordinates, containerSolution, out var puddle);
_popupSystem.PopupEntity(
Loc.GetString("drain-component-empty-verb-target-is-full-message", ("object", target)),
container);
}
}
public override void Update(float frameTime)
{
base.Update(frameTime);
var managerQuery = GetEntityQuery<SolutionContainerManagerComponent>();
var xformQuery = GetEntityQuery<TransformComponent>();
var puddleQuery = GetEntityQuery<PuddleComponent>();
var puddles = new ValueList<(EntityUid Entity, string Solution)>();
foreach (var drain in EntityQuery<DrainComponent>())
{
drain.Accumulator += frameTime;
if (drain.Accumulator < drain.DrainFrequency)
{
continue;
}
drain.Accumulator -= drain.DrainFrequency;
// Disable ambient sound from emptying manually
if (!drain.AutoDrain)
{
_ambientSoundSystem.SetAmbience(drain.Owner, false);
return;
}
if (!managerQuery.TryGetComponent(drain.Owner, out var manager))
continue;
// Best to do this one every second rather than once every tick...
_solutionSystem.TryGetSolution(drain.Owner, DrainComponent.SolutionName, out var drainSolution, manager);
if (drainSolution is null)
continue;
if (drainSolution.AvailableVolume <= 0)
{
_ambientSoundSystem.SetAmbience(drain.Owner, false);
continue;
}
// Remove a bit from the buffer
_solutionSystem.SplitSolution(drain.Owner, drainSolution, (drain.UnitsDestroyedPerSecond * drain.DrainFrequency));
// This will ensure that UnitsPerSecond is per second...
var amount = drain.UnitsPerSecond * drain.DrainFrequency;
if (!xformQuery.TryGetComponent(drain.Owner, out var xform))
continue;
puddles.Clear();
foreach (var entity in _lookup.GetEntitiesInRange(xform.MapPosition, drain.Range))
{
// No InRangeUnobstructed because there's no collision group that fits right now
// and these are placed by mappers and not buildable/movable so shouldnt really be a problem...
if (puddleQuery.TryGetComponent(entity, out var puddle))
{
continue;
puddles.Add((entity, puddle.SolutionName));
}
drain.Accumulator -= drain.DrainFrequency;
}
if (!managerQuery.TryGetComponent(drain.Owner, out var manager))
continue;
if (puddles.Count == 0)
{
_ambientSoundSystem.SetAmbience(drain.Owner, false);
continue;
}
// Best to do this one every second rather than once every tick...
_solutionSystem.TryGetSolution(drain.Owner, DrainComponent.SolutionName, out var drainSolution, manager);
_ambientSoundSystem.SetAmbience(drain.Owner, true);
if (drainSolution is null)
continue;
amount /= puddles.Count;
// Remove a bit from the buffer
_solutionSystem.SplitSolution(drain.Owner, drainSolution, (drain.UnitsDestroyedPerSecond * drain.DrainFrequency));
// This will ensure that UnitsPerSecond is per second...
var amount = drain.UnitsPerSecond * drain.DrainFrequency;
if (!xformQuery.TryGetComponent(drain.Owner, out var xform))
continue;
puddles.Clear();
foreach (var entity in _lookup.GetEntitiesInRange(xform.MapPosition, drain.Range))
foreach (var (puddle, solution) in puddles)
{
// Queue the solution deletion if it's empty. EvaporationSystem might also do this
// but queuedelete should be pretty safe.
if (!_solutionSystem.TryGetSolution(puddle, solution, out var puddleSolution))
{
// No InRangeUnobstructed because there's no collision group that fits right now
// and these are placed by mappers and not buildable/movable so shouldnt really be a problem...
if (puddleQuery.TryGetComponent(entity, out var puddle))
{
puddles.Add((entity, puddle.SolutionName));
}
}
if (puddles.Count == 0)
{
_ambientSoundSystem.SetAmbience(drain.Owner, false);
EntityManager.QueueDeleteEntity(puddle);
continue;
}
_ambientSoundSystem.SetAmbience(drain.Owner, true);
// Removes the lowest of:
// the drain component's units per second adjusted for # of puddles
// the puddle's remaining volume (making it cleanly zero)
// the drain's remaining volume in its buffer.
var transferSolution = _solutionSystem.SplitSolution(puddle, puddleSolution,
FixedPoint2.Min(FixedPoint2.New(amount), puddleSolution.Volume, drainSolution.AvailableVolume));
amount /= puddles.Count;
_solutionSystem.TryAddSolution(drain.Owner, drainSolution, transferSolution);
foreach (var (puddle, solution) in puddles)
if (puddleSolution.Volume <= 0)
{
// Queue the solution deletion if it's empty. EvaporationSystem might also do this
// but queuedelete should be pretty safe.
if (!_solutionSystem.TryGetSolution(puddle, solution, out var puddleSolution))
{
EntityManager.QueueDeleteEntity(puddle);
continue;
}
// Removes the lowest of:
// the drain component's units per second adjusted for # of puddles
// the puddle's remaining volume (making it cleanly zero)
// the drain's remaining volume in its buffer.
var transferSolution = _solutionSystem.SplitSolution(puddle, puddleSolution,
FixedPoint2.Min(FixedPoint2.New(amount), puddleSolution.Volume, drainSolution.AvailableVolume));
_solutionSystem.TryAddSolution(drain.Owner, drainSolution, transferSolution);
if (puddleSolution.Volume <= 0)
{
QueueDel(puddle);
}
QueueDel(puddle);
}
}
}
}
private void OnExamined(EntityUid uid, DrainComponent component, ExaminedEvent args)
{
if (!args.IsInDetailsRange ||
!TryComp(uid, out SolutionContainerManagerComponent? solutionComp) ||
!_solutionSystem.TryGetSolution(uid, DrainComponent.SolutionName, out var drainSolution))
{ return; }
var text = drainSolution.AvailableVolume != 0 ?
Loc.GetString("drain-component-examine-volume", ("volume", drainSolution.AvailableVolume)) :
Loc.GetString("drain-component-examine-hint-full");
args.Message.AddMarkup($"\n\n{text}");
}
private void OnInteract(EntityUid uid, DrainComponent component, InteractEvent args)
{
if (!args.CanReach || args.Target == null ||
!_tagSystem.HasTag(args.Used, DrainComponent.PlungerTag) ||
!_solutionSystem.TryGetSolution(args.Target.Value, DrainComponent.SolutionName, out var drainSolution))
{ return; }
if (drainSolution.AvailableVolume > 0)
{
_popupSystem.PopupEntity(Loc.GetString("drain-component-unclog-notapplicable", ("object", args.Target.Value)), args.Target.Value);
return;
}
_audioSystem.PlayPvs(component.PlungerSound, uid);
var doAfterArgs = new DoAfterArgs(args.User, component.UnclogDuration, new DrainDoAfterEvent(),uid, args.Used)
{
BreakOnTargetMove = true,
BreakOnUserMove = true,
BreakOnDamage = true,
BreakOnHandChange = true
};
_doAfterSystem.TryStartDoAfter(doAfterArgs);
}
private void OnDoAfter(EntityUid uid, DrainComponent component, DoAfterEvent args)
{
if (args.Target == null)
return;
if (!_random.Prob(component.UnclogProbability))
{
_popupSystem.PopupEntity(Loc.GetString("drain-component-unclog-fail", ("object", args.Target.Value)), args.Target.Value);
return;
}
if (!_solutionSystem.TryGetSolution(args.Target.Value, DrainComponent.SolutionName,
out var drainSolution))
{
return;
}
_solutionSystem.RemoveAllSolution(args.Target.Value, drainSolution);
_audioSystem.PlayPvs(component.UnclogSound, args.Target.Value);
_popupSystem.PopupEntity(Loc.GetString("drain-component-unclog-success", ("object", args.Target.Value)), args.Target.Value);
}
}