private void InteractionActivate(IEntity user, IEntity used)
{
if (!_actionBlockerSystem.CanInteract(user) || !_actionBlockerSystem.CanUse(user))
{
return;
}
// all activates should only fire when in range / unobstructed
if (!InRangeUnobstructed(user, used, ignoreInsideBlocker: true, popup: true))
{
return;
}
var activateMsg = new ActivateInWorldEvent(user, used);
RaiseLocalEvent(used.Uid, activateMsg);
if (activateMsg.Handled)
{
return;
}
if (!used.TryGetComponent(out IActivate? activateComp))
{
return;
}
var activateEventArgs = new ActivateEventArgs(user, used);
activateComp.Activate(activateEventArgs);
}
protected void InteractionActivate(EntityUid user, EntityUid used)
{
if (EntityManager.TryGetComponent <UseDelayComponent?>(used, out var delayComponent))
{
if (delayComponent.ActiveDelay)
{
return;
}
delayComponent.BeginDelay();
}
if (!_actionBlockerSystem.CanInteract(user) || !_actionBlockerSystem.CanUse(user))
{
return;
}
// all activates should only fire when in range / unobstructed
if (!InRangeUnobstructed(user, used, ignoreInsideBlocker: true, popup: true))
{
return;
}
// Check if interacted entity is in the same container, the direct child, or direct parent of the user.
// This is bypassed IF the interaction happened through an item slot (e.g., backpack UI)
if (!user.IsInSameOrParentContainer(used) && !CanAccessViaStorage(user, used))
{
return;
}
var activateMsg = new ActivateInWorldEvent(user, used);
RaiseLocalEvent(used, activateMsg);
if (activateMsg.Handled)
{
_adminLogSystem.Add(LogType.InteractActivate, LogImpact.Low, $"{user} activated {used}");
return;
}
if (!EntityManager.TryGetComponent(used, out IActivate? activateComp))
{
return;
}
var activateEventArgs = new ActivateEventArgs(user, used);
activateComp.Activate(activateEventArgs);
_adminLogSystem.Add(LogType.InteractActivate, LogImpact.Low, $"{user} activated {used}"); // No way to check success.
}
private void HandleAfterInteract(EntityUid uid, LightReplacerComponent component, AfterInteractMessage eventArgs)
{
// standard interaction checks
if (!ActionBlockerSystem.CanUse(eventArgs.User))
{
return;
}
if (!eventArgs.CanReach)
{
return;
}
// behaviour will depends on target type
if (eventArgs.Attacked != null)
{
// replace broken light in fixture?
if (eventArgs.Attacked.TryGetComponent(out PoweredLightComponent? fixture))
{
component.TryReplaceBulb(fixture, eventArgs.User);
}
// add new bulb to light replacer container?
else if (eventArgs.Attacked.TryGetComponent(out LightBulbComponent? bulb))
{
component.TryInsertBulb(bulb, eventArgs.User, true);
}
}
}
private void HandleAfterInteract(EntityUid uid, LightReplacerComponent component, AfterInteractEvent eventArgs)
{
if (eventArgs.Handled)
{
return;
}
// standard interaction checks
if (!_blocker.CanUse(eventArgs.User))
{
return;
}
if (!eventArgs.CanReach)
{
return;
}
// behaviour will depends on target type
if (eventArgs.Target != null)
{
var targetUid = (EntityUid)eventArgs.Target;
// replace broken light in fixture?
if (EntityManager.TryGetComponent(targetUid, out PoweredLightComponent? fixture))
{
eventArgs.Handled = TryReplaceBulb(uid, targetUid, eventArgs.User, component, fixture);
}
// add new bulb to light replacer container?
else if (EntityManager.TryGetComponent(targetUid, out LightBulbComponent? bulb))
{
eventArgs.Handled = TryInsertBulb(uid, targetUid, eventArgs.User, true, component, bulb);
}
}
}
/// <summary>
/// Activates the Activate behavior of an object
/// Verifies that the user is capable of doing the use interaction first
/// </summary>
/// <param name="user"></param>
/// <param name="used"></param>
public void TryInteractionActivate(IEntity user, IEntity used)
{
if (user != null && used != null && ActionBlockerSystem.CanUse(user))
{
InteractionActivate(user, used);
}
}
public bool ToggleStatus(IEntity user)
{
if (!ActionBlockerSystem.CanUse(user))
{
return(false);
}
return(Activated ? TurnOff() : TurnOn(user));
}
/// <summary>
/// Eat item
/// </summary>
private void OnUseFoodInHand(EntityUid uid, FoodComponent foodComponent, UseInHandEvent ev)
{
if (ev.Handled)
{
return;
}
if (!_actionBlockerSystem.CanInteract(ev.User) || !_actionBlockerSystem.CanUse(ev.User))
{
return;
}
if (!ev.User.InRangeUnobstructed(uid, popup: true))
{
ev.Handled = true;
return;
}
ev.Handled = TryUseFood(uid, ev.User);
}
async Task <bool> IAfterInteract.AfterInteract(AfterInteractEventArgs eventArgs)
{
if (_cuffing)
{
return(true);
}
if (eventArgs.Target == null || !ActionBlockerSystem.CanUse(eventArgs.User) || !eventArgs.Target.TryGetComponent <CuffableComponent>(out var cuffed))
{
return(false);
}
if (eventArgs.Target == eventArgs.User)
{
eventArgs.User.PopupMessage(Loc.GetString("You can't cuff yourself!"));
return(true);
}
if (Broken)
{
eventArgs.User.PopupMessage(Loc.GetString("The cuffs are broken!"));
return(true);
}
if (!eventArgs.Target.TryGetComponent <HandsComponent>(out var hands))
{
eventArgs.User.PopupMessage(Loc.GetString("{0:theName} has no hands!", eventArgs.Target));
return(true);
}
if (cuffed.CuffedHandCount == hands.Count)
{
eventArgs.User.PopupMessage(Loc.GetString("{0:theName} has no free hands to handcuff!", eventArgs.Target));
return(true);
}
if (!eventArgs.InRangeUnobstructed(ignoreInsideBlocker: true))
{
eventArgs.User.PopupMessage(Loc.GetString("You are too far away to use the cuffs!"));
return(true);
}
eventArgs.User.PopupMessage(Loc.GetString("You start cuffing {0:theName}.", eventArgs.Target));
eventArgs.User.PopupMessage(eventArgs.Target, Loc.GetString("{0:theName} starts cuffing you!", eventArgs.User));
if (StartCuffSound != null)
{
EntitySystem.Get <AudioSystem>().PlayFromEntity(StartCuffSound, Owner);
}
TryUpdateCuff(eventArgs.User, eventArgs.Target, cuffed);
return(true);
}
private void AfterInteract(EntityUid uid, DrinkComponent component, AfterInteractEvent args)
{
if (args.Handled || args.Target == null)
{
return;
}
if (!_actionBlockerSystem.CanInteract(args.User) || !_actionBlockerSystem.CanUse(args.User))
{
return;
}
if (!args.User.InRangeUnobstructed(uid, popup: true))
{
args.Handled = true;
return;
}
if (args.User == args.Target)
{
args.Handled = TryUseDrink(uid, args.User);
return;
}
if (!args.User.InRangeUnobstructed(args.Target.Value, popup: true))
{
args.Handled = true;
return;
}
if (args.User == args.Target)
{
args.Handled = TryUseDrink(uid, args.User, component);
}
else
{
args.Handled = TryForceDrink(uid, args.User, args.Target.Value, component);
}
}
private bool CheckInteract(ICommonSession session)
{
if (session.AttachedEntity is not {
Valid : true
} uid ||
!_actionBlockerSystem.CanInteract(uid) ||
!_actionBlockerSystem.CanUse(uid))
{
return(false);
}
return(true);
}
internal void ToggleInternals()
{
if (!ActionBlockerSystem.CanUse(GetInternalsComponent()?.Owner))
{
return;
}
if (IsConnected)
{
DisconnectFromInternals();
return;
}
ConnectToInternals();
}
/// <summary>
/// Checks whether the player entity is able to use the chem dispenser.
/// </summary>
/// <param name="playerEntity">The player entity.</param>
/// <returns>Returns true if the entity can use the dispenser, and false if it cannot.</returns>
private bool PlayerCanUseDispenser(IEntity playerEntity)
{
//Need player entity to check if they are still able to use the dispenser
if (playerEntity == null)
{
return(false);
}
//Check if player can interact in their current state
if (!ActionBlockerSystem.CanInteract(playerEntity) || !ActionBlockerSystem.CanUse(playerEntity))
{
return(false);
}
return(true);
}
private void OnUseInHand(EntityUid uid, StunbatonComponent comp, UseInHandEvent args)
{
if (!ActionBlockerSystem.CanUse(args.User))
{
return;
}
if (comp.Activated)
{
TurnOff(comp);
}
else
{
TurnOn(comp, args.User);
}
}
void IAfterInteract.AfterInteract(AfterInteractEventArgs eventArgs)
{
if (eventArgs.Target == null || !ActionBlockerSystem.CanUse(eventArgs.User) || !eventArgs.Target.TryGetComponent <CuffableComponent>(out var cuffed))
{
return;
}
if (eventArgs.Target == eventArgs.User)
{
_notifyManager.PopupMessage(eventArgs.User, eventArgs.User, Loc.GetString("You can't cuff yourself!"));
return;
}
if (Broken)
{
_notifyManager.PopupMessage(eventArgs.User, eventArgs.User, Loc.GetString("The cuffs are broken!"));
return;
}
if (!eventArgs.Target.TryGetComponent <HandsComponent>(out var hands))
{
_notifyManager.PopupMessage(eventArgs.User, eventArgs.User, Loc.GetString("{0:theName} has no hands!", eventArgs.Target));
return;
}
if (cuffed.CuffedHandCount == hands.Count)
{
_notifyManager.PopupMessage(eventArgs.User, eventArgs.User, Loc.GetString("{0:theName} has no free hands to handcuff!", eventArgs.Target));
return;
}
if (!EntitySystem.Get <SharedInteractionSystem>().InRangeUnobstructed(
eventArgs.User.Transform.MapPosition,
eventArgs.Target.Transform.MapPosition,
_interactRange,
ignoredEnt: Owner))
{
_notifyManager.PopupMessage(eventArgs.User, eventArgs.User, Loc.GetString("You are too far away to use the cuffs!"));
return;
}
_notifyManager.PopupMessage(eventArgs.User, eventArgs.User, Loc.GetString("You start cuffing {0:theName}.", eventArgs.Target));
_notifyManager.PopupMessage(eventArgs.User, eventArgs.Target, Loc.GetString("{0:theName} starts cuffing you!", eventArgs.User));
_audioSystem.PlayFromEntity(StartCuffSound, Owner);
TryUpdateCuff(eventArgs.User, eventArgs.Target, cuffed);
}
private bool ToggleStatus(IEntity user)
{
if (!ActionBlockerSystem.CanUse(user))
{
return(false);
}
if (Activated)
{
TurnOff();
}
else
{
TurnOn(user);
}
return(true);
}
/// <summary>
/// Checks whether the player entity is able to use the chem master.
/// </summary>
/// <param name="playerEntity">The player entity.</param>
/// <returns>Returns true if the entity can use the chem master, and false if it cannot.</returns>
private bool PlayerCanUseChemMaster(IEntity playerEntity, bool needsPower = true)
{
//Need player entity to check if they are still able to use the chem master
if (playerEntity == null)
{
return(false);
}
//Check if player can interact in their current state
if (!ActionBlockerSystem.CanInteract(playerEntity) || !ActionBlockerSystem.CanUse(playerEntity))
{
return(false);
}
//Check if device is powered
if (needsPower && !Powered)
{
return(false);
}
return(true);
}
/// <summary>
/// Raises a number of events in order to get all verbs of the given type(s) defined in local systems. This
/// does not request verbs from the server.
/// </summary>
public virtual Dictionary <VerbType, SortedSet <Verb> > GetLocalVerbs(EntityUid target, EntityUid user, VerbType verbTypes, bool force = false)
{
Dictionary <VerbType, SortedSet <Verb> > verbs = new();
// accessibility checks
bool canAccess = false;
if (force || target == user)
{
canAccess = true;
}
else if (_interactionSystem.InRangeUnobstructed(user, target, ignoreInsideBlocker: true))
{
if (user.IsInSameOrParentContainer(target))
{
canAccess = true;
}
else
{
// the item might be in a backpack that the user has open
canAccess = _interactionSystem.CanAccessViaStorage(user, target);
}
}
// A large number of verbs need to check action blockers. Instead of repeatedly having each system individually
// call ActionBlocker checks, just cache it for the verb request.
var canInteract = force || _actionBlockerSystem.CanInteract(user);
EntityUid @using = default;
if (EntityManager.TryGetComponent(user, out SharedHandsComponent? hands) && (force || _actionBlockerSystem.CanUse(user)))
{
hands.TryGetActiveHeldEntity(out @using);
// Check whether the "Held" entity is a virtual pull entity. If yes, set that as the entity being "Used".
// This allows you to do things like buckle a dragged person onto a surgery table, without click-dragging
// their sprite.
if (@using != default && EntityManager.TryGetComponent <HandVirtualItemComponent?>(@using, out var pull))
{
@using = pull.BlockingEntity;
}
}
if ((verbTypes & VerbType.Interaction) == VerbType.Interaction)
{
GetInteractionVerbsEvent getVerbEvent = new(user, target, @using, hands, canInteract, canAccess);
RaiseLocalEvent(target, getVerbEvent);
verbs.Add(VerbType.Interaction, getVerbEvent.Verbs);
}
if ((verbTypes & VerbType.Activation) == VerbType.Activation)
{
GetActivationVerbsEvent getVerbEvent = new(user, target, @using, hands, canInteract, canAccess);
RaiseLocalEvent(target, getVerbEvent);
verbs.Add(VerbType.Activation, getVerbEvent.Verbs);
}
if ((verbTypes & VerbType.Alternative) == VerbType.Alternative)
{
GetAlternativeVerbsEvent getVerbEvent = new(user, target, @using, hands, canInteract, canAccess);
RaiseLocalEvent(target, getVerbEvent);
verbs.Add(VerbType.Alternative, getVerbEvent.Verbs);
}
if ((verbTypes & VerbType.Other) == VerbType.Other)
{
GetOtherVerbsEvent getVerbEvent = new(user, target, @using, hands, canInteract, canAccess);
RaiseLocalEvent(target, getVerbEvent);
verbs.Add(VerbType.Other, getVerbEvent.Verbs);
}
return(verbs);
}
