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

Fix foldable-pickup interactions. (#6057)

Browse Source
This commit is contained in:
Leon Friedrich
2022-01-07 19:09:42 +13:00
committed by GitHub
parent 106f176d13
commit c29489ff4d
10 changed files with 145 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Content.Client/Entry/IgnoredComponents.cs
View File

@@ -293,7 +293,6 @@ namespace Content.Client.Entry
"IncreaseDamageOnWield",
"TabletopGame",
"LitOnPowered",
"Foldable",
"TriggerOnSignalReceived",
"ToggleDoorOnTrigger",
"DeviceNetworkComponent",

10
Content.Client/Foldable/FoldableSystem.cs Normal file
View File

@@ -0,0 +1,10 @@
using Content.Shared.Foldable;
using JetBrains.Annotations;
namespace Content.Client.Foldable;
[UsedImplicitly]
public sealed class FoldableSystem : SharedFoldableSystem
{
// classic.
}

25
Content.Server/Foldable/FoldableComponent.cs
View File

@@ -1,25 +0,0 @@
#nullable enable
using Robust.Shared.Containers;
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.ViewVariables;
namespace Content.Server.Foldable
{
/// <summary>
/// Used to create "foldable structures" that you can pickup like an item when folded. Used for rollerbeds and wheelchairs
/// </summary>
[RegisterComponent]
public class FoldableComponent : Component
{
public override string Name => "Foldable";
[DataField("folded")]
[ViewVariables]
public bool IsFolded = false;
public bool CanBeFolded = true;
}
}

75
Content.Server/Foldable/FoldableSystem.cs
View File

@@ -1,8 +1,7 @@
using System.Linq;
using Content.Server.Buckle.Components;
using Content.Server.Storage.Components;
using Content.Shared.Interaction;
using Content.Shared.Item;
using Content.Shared.Foldable;
using Content.Shared.Verbs;
using JetBrains.Annotations;
using Robust.Shared.Containers;
@@ -13,19 +12,15 @@ using Robust.Shared.Localization;
namespace Content.Server.Foldable
{
[UsedImplicitly]
public sealed class FoldableSystem : EntitySystem
public sealed class FoldableSystem : SharedFoldableSystem
{
[Dependency] private SharedContainerSystem _container = default!;
private const string FoldKey = "FoldedState";
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<FoldableComponent, ComponentInit>(OnFoldableInit);
SubscribeLocalEvent<FoldableComponent, StorageOpenAttemptEvent>(OnFoldableOpenAttempt);
SubscribeLocalEvent<FoldableComponent, AttemptItemPickupEvent>(OnPickedUpAttempt);
SubscribeLocalEvent<FoldableComponent, GetAlternativeVerbsEvent>(AddFoldVerb);
}
@@ -35,38 +30,43 @@ namespace Content.Server.Foldable
args.Cancel();
}
private void OnFoldableInit(EntityUid uid, FoldableComponent component, ComponentInit args)
{
SetFolded(component, component.IsFolded);
}
private bool TryToggleFold(FoldableComponent comp)
public bool TryToggleFold(FoldableComponent comp)
{
return TrySetFolded(comp, !comp.IsFolded);
}
public bool CanToggleFold(EntityUid uid, FoldableComponent? fold = null)
{
if (!Resolve(uid, ref fold))
return false;
// Can't un-fold in hands / inventory
if (_container.IsEntityInContainer(uid))
return false;
// If an entity is buckled to the object we can't pick it up or fold it
if (TryComp(uid, out StrapComponent? strap) && strap.BuckledEntities.Any())
return false;
// Also check if this entity is "open" (e.g., body bags)
return !TryComp(uid, out EntityStorageComponent? storage) || !storage.Open;
}
/// <summary>
/// Try to fold/unfold
/// </summary>
/// <param name="comp"></param>
/// <param name="state">Folded state we want</param>
/// <returns>True if successful</returns>
private bool TrySetFolded(FoldableComponent comp, bool state)
public bool TrySetFolded(FoldableComponent comp, bool state)
{
if (state == comp.IsFolded)
return false;
if (_container.IsEntityInContainer(comp.Owner))
if (!CanToggleFold(comp.Owner, comp))
return false;
// First we check if the foldable object has a strap component
if (EntityManager.TryGetComponent(comp.Owner, out StrapComponent? strap))
{
// If an entity is buckled to the object we can't pick it up or fold it
if (strap.BuckledEntities.Any())
return false;
}
SetFolded(comp, state);
return true;
}
@@ -76,41 +76,20 @@ namespace Content.Server.Foldable
/// </summary>
/// <param name="component"></param>
/// <param name="folded">If true, the component will become folded, else unfolded</param>
private void SetFolded(FoldableComponent component, bool folded)
public override void SetFolded(FoldableComponent component, bool folded)
{
component.IsFolded = folded;
component.CanBeFolded = !_container.IsEntityInContainer(component.Owner);
base.SetFolded(component, folded);
// You can't buckle an entity to a folded object
if (EntityManager.TryGetComponent(component.Owner, out StrapComponent? strap))
if (TryComp(component.Owner, out StrapComponent? strap))
strap.Enabled = !component.IsFolded;
// Update visuals only if the value has changed
if (EntityManager.TryGetComponent(component.Owner, out AppearanceComponent? appearance))
appearance.SetData(FoldKey, folded);
}
#region Event handlers
/// <summary>
/// Prevents foldable objects to be picked up when unfolded
/// </summary>
/// <param name="uid"></param>
/// <param name="component"></param>
/// <param name="args"></param>
private void OnPickedUpAttempt(EntityUid uid, FoldableComponent component, AttemptItemPickupEvent args)
{
if (!component.IsFolded)
args.Cancel();
}
#endregion
#region Verb
private void AddFoldVerb(EntityUid uid, FoldableComponent component, GetAlternativeVerbsEvent args)
{
if (!args.CanAccess || !args.CanInteract)
if (!args.CanAccess || !args.CanInteract || !CanToggleFold(uid, component))
return;
Verb verb = new()

35
Content.Shared/Foldable/FoldableComponent.cs Normal file
View File

@@ -0,0 +1,35 @@
using Robust.Shared.Analyzers;
using Robust.Shared.GameObjects;
using Robust.Shared.GameStates;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.ViewVariables;
using System;
namespace Content.Shared.Foldable;
/// <summary>
/// Used to create "foldable structures" that you can pickup like an item when folded. Used for rollerbeds and wheelchairs
/// </summary>
[RegisterComponent]
[NetworkedComponent]
[Friend(typeof(SharedFoldableSystem))]
public class FoldableComponent : Component
{
public override string Name => "Foldable";
[DataField("folded")]
public bool IsFolded = false;
}
// ahhh, the ol' "state thats just a copy of the component".
[Serializable, NetSerializable]
public class FoldableComponentState : ComponentState
{
public readonly bool IsFolded;
public FoldableComponentState(bool isFolded)
{
IsFolded = isFolded;
}
}

62
Content.Shared/Foldable/SharedFoldableSystem.cs Normal file
View File

@@ -0,0 +1,62 @@
using Content.Shared.Item;
using JetBrains.Annotations;
using Robust.Shared.GameObjects;
using Robust.Shared.GameStates;
namespace Content.Shared.Foldable;
[UsedImplicitly]
public abstract class SharedFoldableSystem : EntitySystem
{
private const string FoldKey = "FoldedState";
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<FoldableComponent, ComponentGetState>(OnGetState);
SubscribeLocalEvent<FoldableComponent, ComponentHandleState>(OnHandleState);
SubscribeLocalEvent<FoldableComponent, ComponentInit>(OnFoldableInit);
SubscribeLocalEvent<FoldableComponent, AttemptItemPickupEvent>(OnPickedUpAttempt);
}
private void OnGetState(EntityUid uid, FoldableComponent component, ref ComponentGetState args)
{
args.State = new FoldableComponentState(component.IsFolded);
}
private void OnHandleState(EntityUid uid, FoldableComponent component, ref ComponentHandleState args)
{
if (args.Current is not FoldableComponentState state)
return;
if (state.IsFolded != component.IsFolded)
SetFolded(component, state.IsFolded);
}
private void OnFoldableInit(EntityUid uid, FoldableComponent component, ComponentInit args)
{
SetFolded(component, component.IsFolded);
}
/// <summary>
/// Set the folded state of the given <see cref="FoldableComponent"/>
/// </summary>
/// <param name="component"></param>
/// <param name="folded">If true, the component will become folded, else unfolded</param>
public virtual void SetFolded(FoldableComponent component, bool folded)
{
component.IsFolded = folded;
component.Dirty();
if (TryComp(component.Owner, out AppearanceComponent? appearance))
appearance.SetData(FoldKey, folded);
}
private void OnPickedUpAttempt(EntityUid uid, FoldableComponent component, AttemptItemPickupEvent args)
{
if (!component.IsFolded)
args.Cancel();
}
}

8
Content.Shared/Hands/Components/SharedHandsComponent.cs
View File

@@ -14,6 +14,7 @@ using Robust.Shared.IoC;
using Robust.Shared.Log;
using Robust.Shared.Map;
using Robust.Shared.Maths;
using Robust.Shared.Physics;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.ViewVariables;
@@ -497,11 +498,14 @@ namespace Content.Shared.Hands.Components
/// </summary>
protected bool CanInsertEntityIntoHand(Hand hand, EntityUid entity)
{
var handContainer = hand.Container;
if (handContainer == null) return false;
if (!_entMan.HasComponent<SharedItemComponent>(entity))
return false;
var handContainer = hand.Container;
if (handContainer == null) return false;
if (_entMan.TryGetComponent(entity, out IPhysBody? physics) && physics.BodyType == BodyType.Static)
return false;
if (!handContainer.CanInsert(entity)) return false;

6
Content.Shared/Hands/SharedHandsSystem.cs
View File

@@ -81,9 +81,6 @@ namespace Content.Shared.Hands
return;
}
if (TryComp(entity, out SharedSpriteComponent? component))
component.Visible = true;
hands.Dirty();
var unequippedHandMessage = new UnequippedHandEvent(uid, entity, hand);
@@ -115,9 +112,6 @@ namespace Content.Shared.Hands
_adminLogSystem.Add(LogType.Pickup, LogImpact.Low, $"{ToPrettyString(uid):user} picked up {ToPrettyString(entity):entity}");
if (TryComp(entity, out SharedSpriteComponent? component))
component.Visible = false;
hands.Dirty();
var equippedHandMessage = new EquippedHandEvent(uid, entity, hand);

4
Content.Shared/Item/ItemSystem.cs
View File

@@ -53,11 +53,11 @@ namespace Content.Shared.Item
args.Using != null ||
!args.CanAccess ||
!args.CanInteract ||
!component.CanPickup(args.User, popup: false))
!args.Hands.CanPickupEntityToActiveHand(args.Target))
return;
Verb verb = new();
verb.Act = () => args.Hands.PutInHand(args.Target);
verb.Act = () => args.Hands.TryPickupEntityToActiveHand(args.Target);
verb.IconTexture = "/Textures/Interface/VerbIcons/pickup.svg.192dpi.png";
// if the item already in a container (that is not the same as the user's), then change the text.

25
Content.Shared/Item/SharedItemComponent.cs
View File

@@ -1,5 +1,4 @@
using System;
using Content.Shared.ActionBlocker;
using Content.Shared.Hands;
using Content.Shared.Hands.Components;
using Content.Shared.Interaction;
@@ -11,7 +10,6 @@ using Robust.Shared.GameObjects;
using Robust.Shared.GameStates;
using Robust.Shared.IoC;
using Robust.Shared.Maths;
using Robust.Shared.Physics;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.ViewVariables;
@@ -101,28 +99,11 @@ namespace Content.Shared.Item
[DataField("sprite")]
private string? _rsiPath;
/// <summary>
/// If a player can pick up this item.
/// </summary>
public bool CanPickup(EntityUid user, bool popup = true)
{
if (!EntitySystem.Get<ActionBlockerSystem>().CanPickup(user))
return false;
if (_entMan.GetComponent<TransformComponent>(user).MapID != _entMan.GetComponent<TransformComponent>(Owner).MapID)
return false;
if (!_entMan.TryGetComponent(Owner, out IPhysBody? physics) || physics.BodyType == BodyType.Static)
return false;
return user.InRangeUnobstructed(Owner, ignoreInsideBlocker: true, popup: popup);
}
bool IInteractHand.InteractHand(InteractHandEventArgs eventArgs)
{
var user = eventArgs.User;
if (!CanPickup(user))
if (!user.InRangeUnobstructed(Owner, ignoreInsideBlocker: true))
return false;
if (!_entMan.TryGetComponent(user, out SharedHandsComponent hands))
@@ -133,8 +114,8 @@ namespace Content.Shared.Item
if (activeHand == null)
return false;
hands.TryPickupEntityToActiveHand(Owner, animateUser: true);
return true;
// hands checks action blockers
return hands.TryPickupEntityToActiveHand(Owner, animateUser: true);
}
private void OnEquippedPrefixChange()