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

Remove IAfterInteract (#9715)

Browse Source 
* remove gas analyzer iafterinteract

* solution transfer + obsolete

* cuffable

* remove
This commit is contained in:
Kara
2022-07-14 04:45:31 -07:00
committed by GitHub
parent a2d22837c6
commit fab331742a
11 changed files with 163 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
Content.Server/Atmos/Components/GasAnalyzerComponent.cs
View File

@@ -15,7 +15,7 @@ namespace Content.Server.Atmos.Components
{
[RegisterComponent]
[ComponentReference(typeof(SharedGasAnalyzerComponent))]
public sealed class GasAnalyzerComponent : SharedGasAnalyzerComponent, IAfterInteract
public sealed class GasAnalyzerComponent : SharedGasAnalyzerComponent
{
[Dependency] private readonly IEntityManager _entities = default!;
@@ -245,21 +245,5 @@ namespace Content.Server.Atmos.Components
break;
}
}
async Task<bool> IAfterInteract.AfterInteract(AfterInteractEventArgs eventArgs)
{
if (!eventArgs.CanReach)
{
eventArgs.User.PopupMessage(Loc.GetString("gas-analyzer-component-player-cannot-reach-message"));
return true;
}
if (_entities.TryGetComponent(eventArgs.User, out ActorComponent? actor))
{
OpenInterface(actor.PlayerSession, eventArgs.ClickLocation);
}
return true;
}
}
}

29
Content.Server/Atmos/EntitySystems/GasAnalyzerSystem.cs
View File

@@ -1,11 +1,24 @@
using Content.Server.Atmos.Components;
using Content.Server.Popups;
using Content.Shared.Interaction;
using JetBrains.Annotations;
using Robust.Server.GameObjects;
using Robust.Shared.Player;
namespace Content.Server.Atmos.EntitySystems
{
[UsedImplicitly]
public sealed class GasAnalyzerSystem : EntitySystem
{
[Dependency] private readonly PopupSystem _popup = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<GasAnalyzerComponent, AfterInteractEvent>(OnAfterInteract);
}
public override void Update(float frameTime)
{
foreach (var analyzer in EntityManager.EntityQuery<GasAnalyzerComponent>(true))
@@ -13,5 +26,21 @@ namespace Content.Server.Atmos.EntitySystems
analyzer.Update(frameTime);
}
}
private void OnAfterInteract(EntityUid uid, GasAnalyzerComponent component, AfterInteractEvent args)
{
if (!args.CanReach)
{
_popup.PopupEntity(Loc.GetString("gas-analyzer-component-player-cannot-reach-message"), args.User, Filter.Entities(args.User));
return;
}
if (TryComp(args.User, out ActorComponent? actor))
{
component.OpenInterface(actor.PlayerSession, args.ClickLocation);
}
args.Handled = true;
}
}
}

74
Content.Server/Chemistry/Components/SolutionTransferComponent.cs
View File

@@ -14,15 +14,8 @@ namespace Content.Server.Chemistry.Components
/// Gives click behavior for transferring to/from other reagent containers.
/// </summary>
[RegisterComponent]
public sealed class SolutionTransferComponent : Component, IAfterInteract
public sealed class SolutionTransferComponent : Component
{
[Dependency] private readonly IEntityManager _entities = default!;
// Behavior is as such:
// If it's a reagent tank, TAKE reagent.
// If it's anything else, GIVE reagent.
// Of course, only if possible.
/// <summary>
/// The amount of solution to be transferred from this solution when clicking on other solutions with it.
/// </summary>
@@ -102,70 +95,5 @@ namespace Content.Server.Chemistry.Components
MaximumTransferAmount.Int()));
TransferAmount = amount;
}
async Task<bool> IAfterInteract.AfterInteract(AfterInteractEventArgs eventArgs)
{
if (!eventArgs.CanReach || eventArgs.Target == null)
return false;
var target = eventArgs.Target!.Value;
var solutionsSys = EntitySystem.Get<SolutionContainerSystem>();
var transferSystem = EntitySystem.Get<SolutionTransferSystem>();
//Special case for reagent tanks, because normally clicking another container will give solution, not take it.
if (CanReceive && !_entities.HasComponent<RefillableSolutionComponent>(target) // target must not be refillable (e.g. Reagent Tanks)
&& solutionsSys.TryGetDrainableSolution(target, out var targetDrain) // target must be drainable
&& _entities.TryGetComponent(Owner, out RefillableSolutionComponent? refillComp)
&& solutionsSys.TryGetRefillableSolution(Owner, out var ownerRefill, refillable: refillComp))
{
var transferAmount = TransferAmount; // This is the player-configurable transfer amount of "Owner," not the target reagent tank.
if (_entities.TryGetComponent(Owner, out RefillableSolutionComponent? refill) && refill.MaxRefill != null) // Owner is the entity receiving solution from target.
{
transferAmount = FixedPoint2.Min(transferAmount, (FixedPoint2) refill.MaxRefill); // if the receiver has a smaller transfer limit, use that instead
}
var transferred = transferSystem.Transfer(eventArgs.User, target, targetDrain, Owner, ownerRefill, transferAmount);
if (transferred > 0)
{
var toTheBrim = ownerRefill.AvailableVolume == 0;
var msg = toTheBrim
? "comp-solution-transfer-fill-fully"
: "comp-solution-transfer-fill-normal";
target.PopupMessage(eventArgs.User,
Loc.GetString(msg, ("owner", eventArgs.Target), ("amount", transferred), ("target", Owner)));
return true;
}
}
// if target is refillable, and owner is drainable
if (CanSend && solutionsSys.TryGetRefillableSolution(target, out var targetRefill)
&& solutionsSys.TryGetDrainableSolution(Owner, out var ownerDrain))
{
var transferAmount = TransferAmount;
if (_entities.TryGetComponent(target, out RefillableSolutionComponent? refill) && refill.MaxRefill != null)
{
transferAmount = FixedPoint2.Min(transferAmount, (FixedPoint2) refill.MaxRefill);
}
var transferred = transferSystem.Transfer(eventArgs.User, Owner, ownerDrain, target, targetRefill, transferAmount);
if (transferred > 0)
{
Owner.PopupMessage(eventArgs.User,
Loc.GetString("comp-solution-transfer-transfer-solution",
("amount", transferred),
("target", target)));
return true;
}
}
return false;
}
}
}

69
Content.Server/Chemistry/EntitySystems/SolutionTransferSystem.cs
View File

@@ -1,9 +1,11 @@
using Content.Shared.Verbs;
using Content.Server.Chemistry.Components;
using Content.Server.Chemistry.Components.SolutionManager;
using JetBrains.Annotations;
using Robust.Server.GameObjects;
using Content.Shared.Chemistry.Components;
using Content.Shared.FixedPoint;
using Content.Shared.Interaction;
using Content.Shared.Popups;
namespace Content.Server.Chemistry.EntitySystems
@@ -11,6 +13,8 @@ namespace Content.Server.Chemistry.EntitySystems
[UsedImplicitly]
public sealed class SolutionTransferSystem : EntitySystem
{
[Dependency] private readonly SolutionContainerSystem _solutionContainer = default!;
/// <summary>
/// Default transfer amounts for the set-transfer verb.
/// </summary>
@@ -21,6 +25,7 @@ namespace Content.Server.Chemistry.EntitySystems
base.Initialize();
SubscribeLocalEvent<SolutionTransferComponent, GetVerbsEvent<AlternativeVerb>>(AddSetTransferVerbs);
SubscribeLocalEvent<SolutionTransferComponent, AfterInteractEvent>(OnAfterInteract);
}
private void AddSetTransferVerbs(EntityUid uid, SolutionTransferComponent component, GetVerbsEvent<AlternativeVerb> args)
@@ -63,6 +68,70 @@ namespace Content.Server.Chemistry.EntitySystems
}
}
private void OnAfterInteract(EntityUid uid, SolutionTransferComponent component, AfterInteractEvent args)
{
if (!args.CanReach || args.Target == null)
return;
var target = args.Target!.Value;
//Special case for reagent tanks, because normally clicking another container will give solution, not take it.
if (component.CanReceive && !EntityManager.HasComponent<RefillableSolutionComponent>(target) // target must not be refillable (e.g. Reagent Tanks)
&& _solutionContainer.TryGetDrainableSolution(target, out var targetDrain) // target must be drainable
&& EntityManager.TryGetComponent(uid, out RefillableSolutionComponent? refillComp)
&& _solutionContainer.TryGetRefillableSolution(uid, out var ownerRefill, refillable: refillComp))
{
var transferAmount = component.TransferAmount; // This is the player-configurable transfer amount of "uid," not the target reagent tank.
if (EntityManager.TryGetComponent(uid, out RefillableSolutionComponent? refill) && refill.MaxRefill != null) // uid is the entity receiving solution from target.
{
transferAmount = FixedPoint2.Min(transferAmount, (FixedPoint2) refill.MaxRefill); // if the receiver has a smaller transfer limit, use that instead
}
var transferred = Transfer(args.User, target, targetDrain, uid, ownerRefill, transferAmount);
if (transferred > 0)
{
var toTheBrim = ownerRefill.AvailableVolume == 0;
var msg = toTheBrim
? "comp-solution-transfer-fill-fully"
: "comp-solution-transfer-fill-normal";
target.PopupMessage(args.User,
Loc.GetString(msg, ("owner", args.Target), ("amount", transferred), ("target", uid)));
args.Handled = true;
return;
}
}
// if target is refillable, and owner is drainable
if (component.CanSend && _solutionContainer.TryGetRefillableSolution(target, out var targetRefill)
&& _solutionContainer.TryGetDrainableSolution(uid, out var ownerDrain))
{
var transferAmount = component.TransferAmount;
if (EntityManager.TryGetComponent(target, out RefillableSolutionComponent? refill) && refill.MaxRefill != null)
{
transferAmount = FixedPoint2.Min(transferAmount, (FixedPoint2) refill.MaxRefill);
}
var transferred = Transfer(args.User, uid, ownerDrain, target, targetRefill, transferAmount);
if (transferred > 0)
{
uid.PopupMessage(args.User,
Loc.GetString("comp-solution-transfer-transfer-solution",
("amount", transferred),
("target", target)));
args.Handled = true;
return;
}
}
}
/// <summary>
/// Transfer from a solution to another.
/// </summary>

59
Content.Server/Cuffs/Components/HandcuffComponent.cs
View File

@@ -13,7 +13,7 @@ namespace Content.Server.Cuffs.Components
{
[RegisterComponent]
[ComponentReference(typeof(SharedHandcuffComponent))]
public sealed class HandcuffComponent : SharedHandcuffComponent, IAfterInteract
public sealed class HandcuffComponent : SharedHandcuffComponent
{
[Dependency] private readonly IEntityManager _entities = default!;
@@ -128,66 +128,17 @@ namespace Content.Server.Cuffs.Components
/// <summary>
/// Used to prevent DoAfter getting spammed.
/// </summary>
private bool _cuffing;
public bool Cuffing;
public override ComponentState GetComponentState()
{
return new HandcuffedComponentState(Broken ? BrokenState : string.Empty);
}
async Task<bool> IAfterInteract.AfterInteract(AfterInteractEventArgs eventArgs)
{
if (_cuffing) return true;
if (eventArgs.Target is not {Valid: true} target ||
!_entities.TryGetComponent<CuffableComponent?>(eventArgs.Target.Value, out var cuffed))
{
return false;
}
if (Broken)
{
eventArgs.User.PopupMessage(Loc.GetString("handcuff-component-cuffs-broken-error"));
return true;
}
if (!_entities.TryGetComponent<HandsComponent?>(target, out var hands))
{
eventArgs.User.PopupMessage(Loc.GetString("handcuff-component-target-has-no-hands-error",("targetName", eventArgs.Target)));
return true;
}
if (cuffed.CuffedHandCount >= hands.Count)
{
eventArgs.User.PopupMessage(Loc.GetString("handcuff-component-target-has-no-free-hands-error",("targetName", eventArgs.Target)));
return true;
}
if (!eventArgs.CanReach)
{
eventArgs.User.PopupMessage(Loc.GetString("handcuff-component-too-far-away-error"));
return true;
}
if (eventArgs.Target == eventArgs.User)
{
eventArgs.User.PopupMessage(Loc.GetString("handcuff-component-target-self"));
}
else
{
eventArgs.User.PopupMessage(Loc.GetString("handcuff-component-start-cuffing-target-message",("targetName", eventArgs.Target)));
eventArgs.User.PopupMessage(target, Loc.GetString("handcuff-component-start-cuffing-by-other-message",("otherName", eventArgs.User)));
}
SoundSystem.Play(StartCuffSound.GetSound(), Filter.Pvs(Owner), Owner);
TryUpdateCuff(eventArgs.User, target, cuffed);
return true;
}
/// <summary>
/// Update the cuffed state of an entity
/// </summary>
private async void TryUpdateCuff(EntityUid user, EntityUid target, CuffableComponent cuffs)
public async void TryUpdateCuff(EntityUid user, EntityUid target, CuffableComponent cuffs)
{
var cuffTime = CuffTime;
@@ -205,11 +156,11 @@ namespace Content.Server.Cuffs.Components
NeedHand = true
};
_cuffing = true;
Cuffing = true;
var result = await EntitySystem.Get<DoAfterSystem>().WaitDoAfter(doAfterEventArgs);
_cuffing = false;
Cuffing = false;
if (result != DoAfterStatus.Cancelled)
{

54
Content.Server/Cuffs/CuffableSystem.cs
View File

@@ -9,6 +9,8 @@ using Content.Shared.Verbs;
using JetBrains.Annotations;
using Robust.Shared.Player;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Interaction;
using Robust.Shared.Audio;
namespace Content.Server.Cuffs
{
@@ -25,6 +27,7 @@ namespace Content.Server.Cuffs
SubscribeLocalEvent<HandCountChangedEvent>(OnHandCountChanged);
SubscribeLocalEvent<UncuffAttemptEvent>(OnUncuffAttempt);
SubscribeLocalEvent<CuffableComponent, GetVerbsEvent<Verb>>(AddUncuffVerb);
SubscribeLocalEvent<HandcuffComponent, AfterInteractEvent>(OnCuffAfterInteract);
}
private void AddUncuffVerb(EntityUid uid, CuffableComponent component, GetVerbsEvent<Verb> args)
@@ -46,6 +49,57 @@ namespace Content.Server.Cuffs
args.Verbs.Add(verb);
}
private void OnCuffAfterInteract(EntityUid uid, HandcuffComponent component, AfterInteractEvent args)
{
if (component.Cuffing)
return;
if (args.Target is not {Valid: true} target ||
!EntityManager.TryGetComponent<CuffableComponent>(args.Target.Value, out var cuffed))
{
return;
}
if (component.Broken)
{
args.User.PopupMessage(Loc.GetString("handcuff-component-cuffs-broken-error"));
return;
}
if (!EntityManager.TryGetComponent<HandsComponent?>(target, out var hands))
{
args.User.PopupMessage(Loc.GetString("handcuff-component-target-has-no-hands-error",("targetName", args.Target)));
return;
}
if (cuffed.CuffedHandCount >= hands.Count)
{
args.User.PopupMessage(Loc.GetString("handcuff-component-target-has-no-free-hands-error",("targetName", args.Target)));
return;
}
if (!args.CanReach)
{
args.User.PopupMessage(Loc.GetString("handcuff-component-too-far-away-error"));
return;
}
if (args.Target == args.User)
{
args.User.PopupMessage(Loc.GetString("handcuff-component-target-self"));
}
else
{
args.User.PopupMessage(Loc.GetString("handcuff-component-start-cuffing-target-message",("targetName", args.Target)));
args.User.PopupMessage(target, Loc.GetString("handcuff-component-start-cuffing-by-other-message",("otherName", args.User)));
}
SoundSystem.Play(component.StartCuffSound.GetSound(), Filter.Pvs(uid), uid);
component.TryUpdateCuff(args.User, target, cuffed);
args.Handled = true;
}
private void OnUncuffAttempt(UncuffAttemptEvent args)
{
if (args.Cancelled)

28
Content.Shared/Examine/ExamineSystemShared.cs
View File

@@ -208,34 +208,6 @@ namespace Content.Shared.Examine
return InRangeUnOccluded(originPos, other, range, predicate, ignoreInsideBlocker);
}
public static bool InRangeUnOccluded(ITargetedInteractEventArgs args, float range, Ignored? predicate, bool ignoreInsideBlocker = true)
{
var entMan = IoCManager.Resolve<IEntityManager>();
var originPos = entMan.GetComponent<TransformComponent>(args.User).MapPosition;
var otherPos = entMan.GetComponent<TransformComponent>(args.Target).MapPosition;
return InRangeUnOccluded(originPos, otherPos, range, predicate, ignoreInsideBlocker);
}
public static bool InRangeUnOccluded(DragDropEvent args, float range, Ignored? predicate, bool ignoreInsideBlocker = true)
{
var entMan = IoCManager.Resolve<IEntityManager>();
var originPos = entMan.GetComponent<TransformComponent>(args.User).MapPosition;
var otherPos = args.DropLocation.ToMap(entMan);
return InRangeUnOccluded(originPos, otherPos, range, predicate, ignoreInsideBlocker);
}
public static bool InRangeUnOccluded(AfterInteractEventArgs args, float range, Ignored? predicate, bool ignoreInsideBlocker = true)
{
var entityManager = IoCManager.Resolve<IEntityManager>();;
var originPos = entityManager.GetComponent<TransformComponent>(args.User).MapPosition;
var target = args.Target;
var otherPos = (target != null ? entityManager.GetComponent<TransformComponent>(target.Value).MapPosition : args.ClickLocation.ToMap(entityManager));
return InRangeUnOccluded(originPos, otherPos, range, predicate, ignoreInsideBlocker);
}
public FormattedMessage GetExamineText(EntityUid entity, EntityUid? examiner)
{
var message = new FormattedMessage();

37
Content.Shared/Interaction/IAfterInteract.cs → Content.Shared/Interaction/AfterInteract.cs
View File

@@ -5,43 +5,6 @@ using Robust.Shared.Map;
namespace Content.Shared.Interaction
{
/// <summary>
/// This interface gives components a behavior when their entity is in the active hand, when
/// clicking on another object and no interaction occurs, at any range. This includes
/// clicking on an object in the world as well as clicking on an object in inventory.
/// </summary>
[RequiresExplicitImplementation]
public interface IAfterInteract
{
/// <summary>
/// The interaction priority. Higher numbers get called first.
/// </summary>
/// <value>Priority defaults to 0</value>
int Priority => 0;
/// <summary>
/// Called when we interact with nothing, or when we interact with an entity out of range that has no behavior
/// </summary>
[Obsolete("Use AfterInteractMessage instead")]
Task<bool> AfterInteract(AfterInteractEventArgs eventArgs);
}
public sealed class AfterInteractEventArgs : EventArgs
{
public EntityUid User { get; }
public EntityCoordinates ClickLocation { get; }
public EntityUid? Target { get; }
public bool CanReach { get; }
public AfterInteractEventArgs(EntityUid user, EntityCoordinates clickLocation, EntityUid? target, bool canReach)
{
User = user;
ClickLocation = clickLocation;
Target = target;
CanReach = canReach;
}
}
[PublicAPI]
public abstract class InteractEvent : HandledEntityEventArgs
{

32
Content.Shared/Interaction/Helpers/SharedUnoccludedExtensions.cs
View File

@@ -343,37 +343,5 @@ namespace Content.Shared.Interaction.Helpers
ignoreInsideBlocker);
}
#endregion
#region EventArgs
public static bool InRangeUnOccluded(
this ITargetedInteractEventArgs args,
float range = InteractionRange,
Ignored? predicate = null,
bool ignoreInsideBlocker = true)
{
return ExamineSystemShared.InRangeUnOccluded(args, range, predicate,
ignoreInsideBlocker);
}
public static bool InRangeUnOccluded(
this DragDropEvent args,
float range = InteractionRange,
Ignored? predicate = null,
bool ignoreInsideBlocker = true)
{
return ExamineSystemShared.InRangeUnOccluded(args, range, predicate,
ignoreInsideBlocker);
}
public static bool InRangeUnOccluded(
this AfterInteractEventArgs args,
float range = InteractionRange,
Ignored? predicate = null,
bool ignoreInsideBlocker = true)
{
return ExamineSystemShared.InRangeUnOccluded(args, range, predicate,
ignoreInsideBlocker);
}
#endregion
}
}

0
Content.Shared/Interaction/IRangedInteract.cs → Content.Shared/Interaction/RangedInteract.cs
View File

4
Content.Shared/Popups/SharedPopupExtensions.cs
View File

@@ -12,6 +12,7 @@ namespace Content.Shared.Popups
/// <param name="source">The entity above which the message will appear.</param>
/// <param name="viewer">The entity that will see the message.</param>
/// <param name="message">The message to show.</param>
[Obsolete("Use PopupSystem.PopupEntity instead.")]
public static void PopupMessage(this EntityUid source, EntityUid viewer, string message)
{
var popupSystem = EntitySystem.Get<SharedPopupSystem>();
@@ -24,6 +25,7 @@ namespace Content.Shared.Popups
/// </summary>
/// <param name="viewer">The entity that will see the message.</param>
/// <param name="message">The message to be seen.</param>
[Obsolete("Use PopupSystem.PopupEntity instead.")]
public static void PopupMessage(this EntityUid viewer, string message)
{
viewer.PopupMessage(viewer, message);
@@ -35,6 +37,7 @@ namespace Content.Shared.Popups
/// <param name="coordinates">Location on a grid that the message floats up from.</param>
/// <param name="viewer">The client attached entity that the message is being sent to.</param>
/// <param name="message">Text contents of the message.</param>
[Obsolete("Use PopupSystem.PopupCoordinates instead.")]
public static void PopupMessage(this EntityCoordinates coordinates, EntityUid viewer, string message)
{
var popupSystem = EntitySystem.Get<SharedPopupSystem>();
@@ -48,6 +51,7 @@ namespace Content.Shared.Popups
/// The client attached entity that the message is being sent to.
/// </param>
/// <param name="message">Text contents of the message.</param>
[Obsolete("Use PopupSystem.PopupCursor instead.")]
public static void PopupMessageCursor(this EntityUid viewer, string message)
{
var popupSystem = EntitySystem.Get<SharedPopupSystem>();