using Content.Shared.IdentityManagement;
using Content.Shared.Interaction;
using Content.Shared.Popups;
+using Content.Shared.Storage;
using Content.Shared.Storage.Components;
using Content.Shared.Verbs;
using Content.Shared.Wires;
SubscribeLocalEvent<LockComponent, GotEmaggedEvent>(OnEmagged);
SubscribeLocalEvent<LockComponent, LockDoAfter>(OnDoAfterLock);
SubscribeLocalEvent<LockComponent, UnlockDoAfter>(OnDoAfterUnlock);
+ SubscribeLocalEvent<LockComponent, StorageInteractAttemptEvent>(OnStorageInteractAttempt);
SubscribeLocalEvent<LockedWiresPanelComponent, LockToggleAttemptEvent>(OnLockToggleAttempt);
SubscribeLocalEvent<LockedWiresPanelComponent, AttemptChangePanelEvent>(OnAttemptChangePanel);
SubscribeLocalEvent<LockedAnchorableComponent, UnanchorAttemptEvent>(OnUnanchorAttempt);
}
+
private void OnStartup(EntityUid uid, LockComponent lockComp, ComponentStartup args)
{
_appearanceSystem.SetData(uid, LockVisuals.Locked, lockComp.Locked);
TryUnlock(uid, args.User, skipDoAfter: true);
}
+ private void OnStorageInteractAttempt(Entity<LockComponent> ent, ref StorageInteractAttemptEvent args)
+ {
+ if (ent.Comp.Locked)
+ args.Cancelled = true;
+ }
+
private void OnLockToggleAttempt(Entity<LockedWiresPanelComponent> ent, ref LockToggleAttemptEvent args)
{
if (args.Cancelled)
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using Content.Shared.ActionBlocker;
-using Content.Shared.Administration;
-using Content.Shared.Administration.Managers;
using Content.Shared.Containers.ItemSlots;
using Content.Shared.Destructible;
using Content.Shared.DoAfter;
-using Content.Shared.Ghost;
using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Implants.Components;
using Content.Shared.Input;
using Content.Shared.Interaction;
+using Content.Shared.Interaction.Components;
using Content.Shared.Inventory;
using Content.Shared.Item;
using Content.Shared.Lock;
{
[Dependency] private readonly IPrototypeManager _prototype = default!;
[Dependency] protected readonly IRobustRandom Random = default!;
- [Dependency] private readonly ISharedAdminManager _admin = default!;
[Dependency] protected readonly ActionBlockerSystem ActionBlocker = default!;
[Dependency] private readonly EntityLookupSystem _entityLookupSystem = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
private void AddUiVerb(EntityUid uid, StorageComponent component, GetVerbsEvent<ActivationVerb> args)
{
- var silent = false;
- if (!args.CanAccess || !args.CanInteract || TryComp<LockComponent>(uid, out var lockComponent) && lockComponent.Locked)
- {
- // we allow admins to open the storage anyways
- if (!_admin.HasAdminFlag(args.User, AdminFlags.Admin))
- return;
-
- silent = true;
- }
-
- silent |= HasComp<GhostComponent>(args.User);
+ if (!CanInteract(args.User, (uid, component), args.CanAccess && args.CanInteract))
+ return;
// Does this player currently have the storage UI open?
var uiOpen = _ui.IsUiOpen(uid, StorageComponent.StorageUiKey.Key, args.User);
}
else
{
- OpenStorageUI(uid, args.User, component, silent);
+ OpenStorageUI(uid, args.User, component);
}
}
};
/// Opens the storage UI for an entity
/// </summary>
/// <param name="entity">The entity to open the UI for</param>
- public void OpenStorageUI(EntityUid uid, EntityUid entity, StorageComponent? storageComp = null, bool silent = false)
+ public void OpenStorageUI(EntityUid uid, EntityUid entity, StorageComponent? storageComp = null, bool silent = true)
{
if (!Resolve(uid, ref storageComp, false))
return;
// prevent spamming bag open / honkerton honk sound
silent |= TryComp<UseDelayComponent>(uid, out var useDelay) && UseDelay.IsDelayed((uid, useDelay));
+ if (!CanInteract(entity, (uid, storageComp), silent: silent))
+ return;
+
if (!silent)
{
if (!_ui.IsUiOpen(uid, StorageComponent.StorageUiKey.Key))
var entities = component.Container.ContainedEntities;
- if (entities.Count == 0 || TryComp(uid, out LockComponent? lockComponent) && lockComponent.Locked)
+ if (entities.Count == 0 || !CanInteract(args.User, (uid, component)))
return;
// if the target is storage, add a verb to transfer storage.
{
Text = Loc.GetString("storage-component-transfer-verb"),
IconEntity = GetNetEntity(args.Using),
- Act = () => TransferEntities(uid, args.Target, args.User, component, lockComponent, targetStorage, targetLock)
+ Act = () => TransferEntities(uid, args.Target, args.User, component, null, targetStorage, targetLock)
};
args.Verbs.Add(verb);
/// <returns>true if inserted, false otherwise</returns>
private void OnInteractUsing(EntityUid uid, StorageComponent storageComp, InteractUsingEvent args)
{
- if (args.Handled || !storageComp.ClickInsert || TryComp(uid, out LockComponent? lockComponent) && lockComponent.Locked)
+ if (args.Handled || !CanInteract(args.User, (uid, storageComp), storageComp.ClickInsert, false))
return;
if (HasComp<PlaceableSurfaceComponent>(uid))
/// </summary>
private void OnActivate(EntityUid uid, StorageComponent storageComp, ActivateInWorldEvent args)
{
- if (args.Handled || TryComp<LockComponent>(uid, out var lockComponent) && lockComponent.Locked)
+ if (args.Handled || !CanInteract(args.User, (uid, storageComp), storageComp.ClickInsert))
return;
// Toggle
}
else
{
- OpenStorageUI(uid, args.User, storageComp);
+ OpenStorageUI(uid, args.User, storageComp, false);
}
args.Handled = true;
if (args.Handled)
return;
- OpenStorageUI(uid, args.Performer, storageComp);
+ OpenStorageUI(uid, args.Performer, storageComp, false);
args.Handled = true;
}
}
/// <summary>
- /// Checks if a storage's UI is open by anyone when locked, and closes it unless they're an admin.
+ /// Checks if a storage's UI is open by anyone when locked, and closes it.
/// </summary>
private void OnLockToggled(EntityUid uid, StorageComponent component, ref LockToggledEvent args)
{
// Gets everyone looking at the UI
foreach (var actor in _ui.GetActors(uid, StorageComponent.StorageUiKey.Key).ToList())
{
- if (_admin.HasAdminFlag(actor, AdminFlags.Admin))
- continue;
-
- // And closes it unless they're an admin
- _ui.CloseUi(uid, StorageComponent.StorageUiKey.Key, actor);
+ if (!CanInteract(actor, (uid, component)))
+ _ui.CloseUi(uid, StorageComponent.StorageUiKey.Key, actor);
}
}
if (!_ui.IsUiOpen(storageEnt.Value, StorageComponent.StorageUiKey.Key, playerEnt))
{
- OpenStorageUI(storageEnt.Value, playerEnt);
+ OpenStorageUI(storageEnt.Value, playerEnt, silent: false);
}
else
{
#endif
}
+ private bool CanInteract(EntityUid user, Entity<StorageComponent> storage, bool canInteract = true, bool silent = true)
+ {
+ if (HasComp<BypassInteractionChecksComponent>(user))
+ return true;
+
+ if (!canInteract)
+ return false;
+
+ var ev = new StorageInteractAttemptEvent(silent);
+ RaiseLocalEvent(storage, ref ev);
+
+ return !ev.Cancelled;
+ }
+
/// <summary>
/// Plays a clientside pickup animation for the specified uid.
/// </summary>