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

Make chemistry machines and IdCardConsole use item slots (#5428)

Browse Source 
* chemistry item slots

* item slots id card console
This commit is contained in:
Leon Friedrich
2021-11-24 20:03:07 +13:00
committed by GitHub
parent 355625bded
commit 3b29ffdfa0
26 changed files with 371 additions and 560 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
Content.Server/Access/Components/IdCardConsoleComponent.cs
View File

@@ -1,19 +1,14 @@
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Content.Server.Access.Systems;
using Content.Server.Power.Components;
using Content.Server.UserInterface;
using Content.Shared.Access;
using Content.Shared.Acts;
using Content.Shared.Hands.Components;
using Content.Shared.Containers.ItemSlots;
using Content.Shared.Interaction;
using Content.Shared.Popups;
using Robust.Server.GameObjects;
using Robust.Shared.Containers;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Log;
using Robust.Shared.Prototypes;
using Robust.Shared.ViewVariables;
@@ -21,26 +16,18 @@ using Robust.Shared.ViewVariables;
namespace Content.Server.Access.Components
{
[RegisterComponent]
public class IdCardConsoleComponent : SharedIdCardConsoleComponent, IInteractUsing, IBreakAct
[ComponentReference(typeof(SharedIdCardConsoleComponent))]
public sealed class IdCardConsoleComponent : SharedIdCardConsoleComponent
{
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
public ContainerSlot PrivilegedIdContainer = default!;
public ContainerSlot TargetIdContainer = default!;
[ViewVariables] private BoundUserInterface? UserInterface => Owner.GetUIOrNull(IdCardConsoleUiKey.Key);
[ViewVariables] private bool Powered => !Owner.TryGetComponent(out ApcPowerReceiverComponent? receiver) || receiver.Powered;
public bool PrivilegedIDEmpty => PrivilegedIdContainer.ContainedEntities.Count < 1;
public bool TargetIDEmpty => TargetIdContainer.ContainedEntities.Count < 1;
protected override void Initialize()
{
base.Initialize();
PrivilegedIdContainer = ContainerHelpers.EnsureContainer<ContainerSlot>(Owner, $"{Name}-privilegedId");
TargetIdContainer = ContainerHelpers.EnsureContainer<ContainerSlot>(Owner, $"{Name}-targetId");
Owner.EnsureComponentWarn<AccessReader>();
Owner.EnsureComponentWarn<ServerUserInterfaceComponent>();
@@ -48,8 +35,6 @@ namespace Content.Server.Access.Components
{
UserInterface.OnReceiveMessage += OnUiReceiveMessage;
}
UpdateUserInterface();
}
private void OnUiReceiveMessage(ServerBoundUserInterfaceMessage obj)
@@ -65,23 +50,22 @@ namespace Content.Server.Access.Components
switch (msg.Button)
{
case UiButton.PrivilegedId:
HandleId(obj.Session.AttachedEntity, PrivilegedIdContainer);
HandleIdButton(obj.Session.AttachedEntity, PrivilegedIdSlot);
break;
case UiButton.TargetId:
HandleId(obj.Session.AttachedEntity, TargetIdContainer);
HandleIdButton(obj.Session.AttachedEntity, TargetIdSlot);
break;
}
break;
case WriteToTargetIdMessage msg:
TryWriteToTargetId(msg.FullName, msg.JobTitle, msg.AccessList);
UpdateUserInterface();
break;
}
UpdateUserInterface();
}
/// <summary>
/// Returns true if there is an ID in <see cref="PrivilegedIdContainer"/> and said ID satisfies the requirements of <see cref="AccessReader"/>.
/// Returns true if there is an ID in <see cref="PrivilegedIdSlot"/> and said ID satisfies the requirements of <see cref="AccessReader"/>.
/// </summary>
private bool PrivilegedIdIsAuthorized()
{
@@ -90,23 +74,20 @@ namespace Content.Server.Access.Components
return true;
}
var privilegedIdEntity = PrivilegedIdContainer.ContainedEntity;
var privilegedIdEntity = PrivilegedIdSlot.Item;
var accessSystem = EntitySystem.Get<AccessReaderSystem>();
return privilegedIdEntity != null && accessSystem.IsAllowed(reader, privilegedIdEntity.Uid);
}
/// <summary>
/// Called when the "Submit" button in the UI gets pressed.
/// Writes data passed from the UI into the ID stored in <see cref="TargetIdContainer"/>, if present.
/// Writes data passed from the UI into the ID stored in <see cref="TargetIdSlot"/>, if present.
/// </summary>
private void TryWriteToTargetId(string newFullName, string newJobTitle, List<string> newAccessList)
{
if (!PrivilegedIdIsAuthorized() || TargetIdContainer.ContainedEntity == null)
{
var targetIdEntity = TargetIdSlot.Item;
if (targetIdEntity == null || !PrivilegedIdIsAuthorized())
return;
}
var targetIdEntity = TargetIdContainer.ContainedEntity;
var cardSystem = EntitySystem.Get<IdCardSystem>();
cardSystem.TryChangeFullName(targetIdEntity.Uid, newFullName);
@@ -125,125 +106,46 @@ namespace Content.Server.Access.Components
/// <summary>
/// Called when one of the insert/remove ID buttons gets pressed.
/// </summary>
private void HandleId(IEntity user, ContainerSlot container)
private void HandleIdButton(IEntity user, ItemSlot slot)
{
if (!user.TryGetComponent(out SharedHandsComponent? hands))
{
Owner.PopupMessage(user, Loc.GetString("access-id-card-console-component-no-hands-error"));
return;
}
if (container.ContainedEntity == null)
{
InsertIdFromHand(user, container, hands);
}
if (slot.HasItem)
EntitySystem.Get<ItemSlotsSystem>().TryEjectToHands(OwnerUid, slot, user.Uid);
else
{
PutIdInHand(container, hands);
}
EntitySystem.Get<ItemSlotsSystem>().TryInsertFromHand(OwnerUid, slot, user.Uid);
}
public void InsertIdFromHand(IEntity user, ContainerSlot container, SharedHandsComponent hands)
public void UpdateUserInterface()
{
if (!hands.TryGetActiveHeldEntity(out var heldEntity))
return;
if (!heldEntity.HasComponent<IdCardComponent>())
return;
if (!hands.TryPutHandIntoContainer(hands.ActiveHand!, container))
{
Owner.PopupMessage(user, Loc.GetString("access-id-card-console-component-cannot-let-go-error"));
return;
}
UpdateUserInterface();
}
public void PutIdInHand(ContainerSlot container, SharedHandsComponent hands)
{
var idEntity = container.ContainedEntity;
if (idEntity == null || !container.Remove(idEntity))
{
return;
}
UpdateUserInterface();
hands.TryPutInActiveHandOrAny(idEntity);
}
private void UpdateUserInterface()
{
var isPrivilegedIdPresent = PrivilegedIdContainer.ContainedEntity != null;
var targetIdEntity = TargetIdContainer.ContainedEntity;
var targetIdEntity = TargetIdSlot.Item;
IdCardConsoleBoundUserInterfaceState newState;
// this could be prettier
if (targetIdEntity == null)
{
newState = new IdCardConsoleBoundUserInterfaceState(
isPrivilegedIdPresent,
PrivilegedIdSlot.HasItem,
PrivilegedIdIsAuthorized(),
false,
null,
null,
null,
PrivilegedIdContainer.ContainedEntity?.Name ?? string.Empty,
TargetIdContainer.ContainedEntity?.Name ?? string.Empty);
PrivilegedIdSlot.Item?.Name ?? string.Empty,
string.Empty);
}
else
{
var targetIdComponent = targetIdEntity.GetComponent<IdCardComponent>();
var targetAccessComponent = targetIdEntity.GetComponent<AccessComponent>();
newState = new IdCardConsoleBoundUserInterfaceState(
isPrivilegedIdPresent,
PrivilegedIdSlot.HasItem,
PrivilegedIdIsAuthorized(),
true,
targetIdComponent.FullName,
targetIdComponent.JobTitle,
targetAccessComponent.Tags.ToArray(),
PrivilegedIdContainer.ContainedEntity?.Name ?? string.Empty,
TargetIdContainer.ContainedEntity?.Name ?? string.Empty);
PrivilegedIdSlot.Item?.Name ?? string.Empty,
targetIdEntity.Name);
}
UserInterface?.SetState(newState);
}
async Task<bool> IInteractUsing.InteractUsing(InteractUsingEventArgs eventArgs)
{
var item = eventArgs.Using;
var user = eventArgs.User;
if (!PrivilegedIDEmpty && !TargetIDEmpty)
{
return false;
}
if (!item.HasComponent<IdCardComponent>() || !user.TryGetComponent(out SharedHandsComponent? hand))
{
return false;
}
if (PrivilegedIDEmpty)
{
InsertIdFromHand(user, PrivilegedIdContainer, hand);
}
else if (TargetIDEmpty)
{
InsertIdFromHand(user, TargetIdContainer, hand);
}
UpdateUserInterface();
return true;
}
public void OnBreak(BreakageEventArgs eventArgs)
{
var privileged = PrivilegedIdContainer.ContainedEntity;
if (privileged != null)
PrivilegedIdContainer.Remove(privileged);
var target = TargetIdContainer.ContainedEntity;
if (target != null)
TargetIdContainer.Remove(target);
}
}
}