var time = GameTiming.CurTime;
var comp = Comp<DoAfterComponent>(playerEntity.Value);
var xformQuery = GetEntityQuery<TransformComponent>();
- var handsQuery = GetEntityQuery<SharedHandsComponent>();
+ var handsQuery = GetEntityQuery<HandsComponent>();
Update(playerEntity.Value, active, comp, time, xformQuery, handsQuery);
}
}
+++ /dev/null
-using Content.Client.Hands.Systems;
-using Content.Client.Hands.UI;
-using Content.Shared.Hands.Components;
-
-namespace Content.Client.Hands
-{
- [RegisterComponent]
- [ComponentReference(typeof(SharedHandsComponent))]
- [Access(typeof(HandsSystem))]
- public sealed class HandsComponent : SharedHandsComponent
- {
- /// <summary>
- /// Whether or not to add in-hand sprites for held items. Some entities (e.g., drones) don't want these.
- /// </summary>
- [DataField("showInHands")]
- public bool ShowInHands = true;
-
- /// <summary>
- /// Data about the current sprite layers that the hand is contributing to the owner entity. Used for sprite in-hands.
- /// </summary>
- public readonly Dictionary<HandLocation, HashSet<string>> RevealedLayers = new();
- }
-}
+using System.Diagnostics.CodeAnalysis;
using Content.Client.Animations;
using Content.Client.Examine;
using Content.Client.Strip;
-using Content.Client.Verbs;
+using Content.Client.Verbs.UI;
using Content.Shared.Hands;
using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using JetBrains.Annotations;
using Robust.Client.GameObjects;
using Robust.Client.Player;
+using Robust.Client.UserInterface;
using Robust.Shared.Containers;
using Robust.Shared.GameStates;
using Robust.Shared.Map;
using Robust.Shared.Timing;
-using System.Diagnostics.CodeAnalysis;
-using Content.Client.Verbs.UI;
-using Robust.Client.UserInterface;
namespace Content.Client.Hands.Systems
{
{
base.Initialize();
- SubscribeLocalEvent<SharedHandsComponent, EntRemovedFromContainerMessage>(HandleItemRemoved);
- SubscribeLocalEvent<SharedHandsComponent, EntInsertedIntoContainerMessage>(HandleItemAdded);
+ SubscribeLocalEvent<HandsComponent, EntRemovedFromContainerMessage>(HandleItemRemoved);
+ SubscribeLocalEvent<HandsComponent, EntInsertedIntoContainerMessage>(HandleItemAdded);
SubscribeLocalEvent<HandsComponent, PlayerAttachedEvent>(HandlePlayerAttached);
SubscribeLocalEvent<HandsComponent, PlayerDetachedEvent>(HandlePlayerDetached);
OnPlayerHandsAdded?.Invoke(hands);
}
- public override void DoDrop(EntityUid uid, Hand hand, bool doDropInteraction = true, SharedHandsComponent? hands = null)
+ public override void DoDrop(EntityUid uid, Hand hand, bool doDropInteraction = true, HandsComponent? hands = null)
{
base.DoDrop(uid, hand, doDropInteraction, hands);
#region visuals
- private void HandleItemAdded(EntityUid uid, SharedHandsComponent handComp, ContainerModifiedMessage args)
+ private void HandleItemAdded(EntityUid uid, HandsComponent handComp, ContainerModifiedMessage args)
{
if (!handComp.Hands.TryGetValue(args.Container.ID, out var hand))
return;
OnPlayerHandBlocked?.Invoke(hand.Name);
}
- private void HandleItemRemoved(EntityUid uid, SharedHandsComponent handComp, ContainerModifiedMessage args)
+ private void HandleItemRemoved(EntityUid uid, HandsComponent handComp, ContainerModifiedMessage args)
{
if (!handComp.Hands.TryGetValue(args.Container.ID, out var hand))
return;
}
#endregion
- private void AddHand(EntityUid uid, Hand newHand, SharedHandsComponent? handsComp = null)
+ private void AddHand(EntityUid uid, Hand newHand, HandsComponent? handsComp = null)
{
AddHand(uid, newHand.Name, newHand.Location, handsComp);
}
- public override void AddHand(EntityUid uid, string handName, HandLocation handLocation, SharedHandsComponent? handsComp = null)
+ public override void AddHand(EntityUid uid, string handName, HandLocation handLocation, HandsComponent? handsComp = null)
{
base.AddHand(uid, handName, handLocation, handsComp);
if (handsComp.ActiveHand == null)
SetActiveHand(uid, handsComp.Hands[handName], handsComp);
}
- public override void RemoveHand(EntityUid uid, string handName, SharedHandsComponent? handsComp = null)
+ public override void RemoveHand(EntityUid uid, string handName, HandsComponent? handsComp = null)
{
if (uid == _playerManager.LocalPlayer?.ControlledEntity && handsComp != null &&
handsComp.Hands.ContainsKey(handName) && uid ==
base.RemoveHand(uid, handName, handsComp);
}
- private void OnHandActivated(SharedHandsComponent? handsComponent)
+ private void OnHandActivated(HandsComponent? handsComponent)
{
if (handsComponent == null)
return;
using Content.Client.Examine;
using Content.Client.Storage;
using Content.Client.UserInterface.Controls;
-using Content.Client.Verbs;
using Content.Client.Verbs.UI;
using Content.Shared.Clothing.Components;
using Content.Shared.Hands.Components;
// TODO hud refactor This should also live in a UI Controller
private void HoverInSlotButton(EntityUid uid, string slot, SlotControl control,
- InventoryComponent? inventoryComponent = null, SharedHandsComponent? hands = null)
+ InventoryComponent? inventoryComponent = null, HandsComponent? hands = null)
{
if (!Resolve(uid, ref inventoryComponent))
return;
using System.Linq;
-using Content.Client.Cuffs;
using Content.Client.Examine;
-using Content.Client.Hands;
using Content.Client.Strip;
using Content.Client.Stylesheets;
using Content.Client.UserInterface.Controls;
using Content.Client.UserInterface.Systems.Hands.Controls;
-using Content.Client.Verbs;
using Content.Client.Verbs.UI;
using Content.Shared.Cuffs;
using Content.Shared.Cuffs.Components;
using Content.Shared.Input;
using Content.Shared.Inventory;
using Content.Shared.Strip.Components;
-using Content.Shared.Verbs;
using JetBrains.Annotations;
using Robust.Client.GameObjects;
using Robust.Client.UserInterface;
using Robust.Shared.Input;
using Robust.Shared.Map;
using Robust.Shared.Prototypes;
-using Robust.Shared.Utility;
using static Content.Client.Inventory.ClientInventorySystem;
using static Robust.Client.UserInterface.Control;
using Content.Client.Gameplay;
-using Content.Client.Hands;
using Content.Client.Hands.Systems;
using Content.Client.UserInterface.Controls;
using Content.Client.UserInterface.Systems.Hands.Controls;
using Content.Shared.Hands.Components;
using Content.Shared.Input;
using Robust.Client.GameObjects;
+using Robust.Client.Player;
using Robust.Client.UserInterface;
using Robust.Client.UserInterface.Controllers;
using Robust.Shared.Input;
public sealed class HandsUIController : UIController, IOnStateEntered<GameplayState>, IOnSystemChanged<HandsSystem>
{
[Dependency] private readonly IEntityManager _entities = default!;
+ [Dependency] private readonly IPlayerManager _player = default!;
[UISystemDependency] private readonly HandsSystem _handsSystem = default!;
if (HandsGui != null &&
_playerHandsComponent != null &&
- _playerHandsComponent.Hands.TryGetValue(handName, out var hand))
+ _player.LocalPlayer?.ControlledEntity is { } playerEntity &&
+ _handsSystem.TryGetHand(playerEntity, handName, out var hand, _playerHandsComponent))
{
HandsGui.UpdatePanelEntity(hand.HeldEntity);
}
using Content.Client.Gameplay;
-using Content.Client.Hands;
using Content.Client.Hands.Systems;
using Content.Client.Inventory;
using Content.Client.Storage;
using Content.Client.UserInterface.Controls;
using Content.Client.UserInterface.Systems.Inventory.Controls;
using Content.Client.UserInterface.Systems.Inventory.Windows;
+using Content.Shared.Hands.Components;
using Content.Shared.Input;
using Robust.Client.GameObjects;
using Robust.Client.UserInterface;
using Content.Client.CombatMode;
using Content.Client.Gameplay;
-using Content.Client.Hands;
+using Content.Shared.Hands.Components;
using Content.Shared.Mobs.Components;
+using Content.Shared.StatusEffect;
using Content.Shared.Weapons.Melee;
using Content.Shared.Weapons.Melee.Events;
-using Content.Shared.StatusEffect;
using Robust.Client.GameObjects;
using Robust.Client.Graphics;
using Robust.Client.Input;
using Robust.Client.Player;
-using Robust.Client.ResourceManagement;
using Robust.Client.State;
using Robust.Shared.Input;
using Robust.Shared.Map;
-using Robust.Shared.Player;
using Robust.Shared.Players;
using Robust.Shared.Prototypes;
using Robust.Shared.Timing;
using System.Threading.Tasks;
using Content.Server.Body.Systems;
using Content.Server.Buckle.Systems;
-using Content.Server.Hands.Components;
using Content.Shared.ActionBlocker;
using Content.Shared.Body.Components;
using Content.Shared.Body.Part;
using Content.Shared.Buckle.Components;
+using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Standing;
using NUnit.Framework;
#nullable enable
using System.Threading.Tasks;
using Content.Server.Cuffs;
-using Content.Server.Hands.Components;
using Content.Shared.Body.Components;
using Content.Shared.Cuffs.Components;
+using Content.Shared.Hands.Components;
using NUnit.Framework;
using Robust.Server.Console;
using Robust.Shared.GameObjects;
#nullable enable annotations
using System.Threading.Tasks;
-using Content.Server.Hands.Components;
using Content.Server.Interaction;
using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using System.Linq;
using Content.Server.Administration.Logs;
using Content.Server.AME.Components;
-using Content.Server.Power.Components;
-using Content.Server.Hands.Components;
using Content.Server.Popups;
+using Content.Server.Power.Components;
using Content.Server.Tools;
using Content.Shared.Database;
+using Content.Shared.Hands.Components;
using Content.Shared.Interaction;
using Content.Shared.Popups;
+using JetBrains.Annotations;
+using Robust.Shared.Audio;
using Robust.Shared.Map;
using Robust.Shared.Player;
-using Robust.Shared.Audio;
-using JetBrains.Annotations;
namespace Content.Server.AME
{
using Content.Server.Administration.UI;
using Content.Server.EUI;
-using Content.Server.Hands.Components;
using Content.Server.Hands.Systems;
using Content.Server.Preferences.Managers;
using Content.Shared.Administration;
+using Content.Shared.Hands.Components;
using Content.Shared.Inventory;
using Content.Shared.PDA;
using Content.Shared.Preferences;
using Robust.Server.Player;
using Robust.Shared.Console;
using Robust.Shared.Prototypes;
-using InventoryComponent = Content.Shared.Inventory.InventoryComponent;
namespace Content.Server.Administration.Commands
{
using Content.Server.Atmos;
using Content.Server.Atmos.Components;
using Content.Server.Cargo.Components;
-using Content.Server.Cargo.Systems;
using Content.Server.Damage.Components;
-using Content.Server.Doors.Components;
using Content.Server.Doors.Systems;
-using Content.Server.Hands.Components;
using Content.Server.Hands.Systems;
using Content.Server.Power.Components;
using Content.Server.Stack;
using Content.Shared.Administration;
using Content.Shared.Atmos;
using Content.Shared.Construction.Components;
-using Content.Shared.Containers.ItemSlots;
using Content.Shared.Damage;
using Content.Shared.Database;
using Content.Shared.Doors.Components;
+using Content.Shared.Hands.Components;
using Content.Shared.Inventory;
using Content.Shared.PDA;
using Content.Shared.Stacks;
using Robust.Shared.Map.Components;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Components;
-using Robust.Shared.Prototypes;
using Robust.Shared.Utility;
namespace Content.Server.Administration.Systems;
using Content.Server.Atmos;
using Content.Server.Atmos.EntitySystems;
using Content.Server.Botany.Components;
-using Content.Server.Popups;
using Content.Server.Chemistry.EntitySystems;
+using Content.Server.Coordinates.Helpers;
using Content.Server.Fluids.Components;
using Content.Server.Ghost.Roles.Components;
-using Content.Server.Hands.Components;
using Content.Server.Kitchen.Components;
-using Content.Shared.Interaction;
-using Content.Shared.Examine;
-using Content.Shared.Tag;
-using Content.Shared.FixedPoint;
+using Content.Server.Popups;
using Content.Shared.Botany;
using Content.Shared.Chemistry.Components;
using Content.Shared.Chemistry.Reagent;
+using Content.Shared.Examine;
+using Content.Shared.FixedPoint;
+using Content.Shared.Hands.Components;
using Content.Shared.IdentityManagement;
+using Content.Shared.Interaction;
using Content.Shared.Popups;
using Content.Shared.Random.Helpers;
+using Content.Shared.Tag;
using Robust.Server.GameObjects;
-using Robust.Shared.Player;
-using Robust.Shared.Timing;
using Robust.Shared.Audio;
+using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
-using Content.Server.Coordinates.Helpers;
+using Robust.Shared.Timing;
namespace Content.Server.Botany.Systems
{
}
}
- if (!HasComp<SharedHandsComponent>(user))
+ if (!HasComp<HandsComponent>(user))
{
_popups.PopupEntity(Loc.GetString("buckle-component-no-hands-message"), user, user);
return false;
using Content.Server.Administration.Logs;
-using Content.Server.Hands.Components;
using Content.Server.Popups;
using Content.Shared.Damage;
using Content.Shared.Damage.Prototypes;
using Content.Shared.Database;
+using Content.Shared.Hands.Components;
using Content.Shared.Interaction.Events;
using Content.Shared.Item;
using Content.Shared.Mobs.Components;
-using Content.Server.Hands.Components;
using Content.Server.Hands.Systems;
using Content.Shared.Construction;
+using Content.Shared.Hands.Components;
using JetBrains.Annotations;
using Robust.Server.Containers;
using Robust.Shared.Containers;
-using Content.Server.Hands.Components;
using Content.Server.Hands.Systems;
using Content.Shared.Construction;
+using Content.Shared.Hands.Components;
using JetBrains.Annotations;
using Robust.Server.Containers;
using Robust.Shared.Containers;
using System.Linq;
using System.Threading.Tasks;
using Content.Server.Construction.Components;
-using Content.Server.DoAfter;
-using Content.Server.Hands.Components;
using Content.Server.Storage.Components;
using Content.Shared.ActionBlocker;
using Content.Shared.Construction;
using Content.Shared.Coordinates;
using Content.Shared.Database;
using Content.Shared.DoAfter;
+using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Interaction;
using Content.Shared.Inventory;
using Robust.Shared.Containers;
-using Robust.Shared.Player;
using Robust.Shared.Players;
using Robust.Shared.Timing;
using Content.Server.Disease.Components;
-using Content.Shared.Disease;
-using Content.Shared.Interaction;
-using Content.Shared.Inventory;
-using Content.Shared.Examine;
-using Content.Server.Popups;
-using Content.Server.Hands.Components;
using Content.Server.Nutrition.EntitySystems;
using Content.Server.Paper;
+using Content.Server.Popups;
using Content.Server.Power.Components;
using Content.Server.Power.EntitySystems;
-using Robust.Shared.Random;
-using Robust.Shared.Player;
-using Robust.Shared.Audio;
-using Robust.Shared.Utility;
-using Content.Shared.Tools.Components;
using Content.Server.Station.Systems;
+using Content.Shared.Disease;
using Content.Shared.DoAfter;
+using Content.Shared.Examine;
+using Content.Shared.Hands.Components;
using Content.Shared.IdentityManagement;
+using Content.Shared.Interaction;
+using Content.Shared.Inventory;
using Content.Shared.Swab;
+using Content.Shared.Tools.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Player;
+using Robust.Shared.Random;
+using Robust.Shared.Utility;
namespace Content.Server.Disease
{
using System.Text;
using Content.Server.Construction.Completions;
using Content.Server.Disposal.Tube.Components;
-using Content.Server.Hands.Components;
using Content.Server.Popups;
using Content.Server.UserInterface;
using Content.Shared.Destructible;
using Content.Shared.Disposal.Components;
+using Content.Shared.Hands.Components;
using Content.Shared.Movement.Events;
using Content.Shared.Popups;
using Robust.Shared.Audio;
using Content.Server.Atmos.EntitySystems;
using Content.Server.Disposal.Tube.Components;
using Content.Server.Disposal.Unit.Components;
-using Content.Server.Hands.Components;
using Content.Server.Popups;
using Content.Server.Power.Components;
using Content.Server.Power.EntitySystems;
using Content.Shared.Verbs;
using Robust.Server.GameObjects;
using Robust.Shared.Containers;
+using Robust.Shared.Map.Components;
using Robust.Shared.Physics.Components;
using Robust.Shared.Random;
-using Robust.Shared.Map.Components;
using Robust.Shared.Utility;
namespace Content.Server.Disposal.Unit.EntitySystems
if (!Resolve(unitId, ref unit))
return false;
- if (userId.HasValue && !HasComp<SharedHandsComponent>(userId) && toInsertId != userId) // Mobs like mouse can Jump inside even with no hands
+ if (userId.HasValue && !HasComp<HandsComponent>(userId) && toInsertId != userId) // Mobs like mouse can Jump inside even with no hands
{
_popupSystem.PopupEntity(Loc.GetString("disposal-unit-no-hands"), userId.Value, userId.Value, PopupType.SmallCaution);
return false;
using Content.Server.Chat.Systems;
using Content.Server.Emoting.Components;
-using Content.Server.Hands.Components;
using Content.Shared.Chat.Prototypes;
+using Content.Shared.Hands.Components;
using Robust.Shared.Prototypes;
namespace Content.Server.Emoting.Systems;
using System.Linq;
using Content.Server.Atmos.EntitySystems;
using Content.Server.Chat.Managers;
-using Content.Server.GameTicking.Rules.Configurations;
-using Content.Server.Hands.Components;
using Content.Server.PDA;
using Content.Server.Players;
using Content.Server.Spawners.Components;
using Content.Shared.CCVar;
using Content.Shared.Damage;
using Content.Shared.Damage.Prototypes;
-using Content.Shared.FixedPoint;
+using Content.Shared.Hands.Components;
using Content.Shared.Inventory;
using Content.Shared.Mobs.Components;
using Content.Shared.Mobs.Systems;
+++ /dev/null
-using Content.Shared.Hands.Components;
-
-namespace Content.Server.Hands.Components;
-
-[RegisterComponent]
-[ComponentReference(typeof(SharedHandsComponent))]
-public sealed class HandsComponent : SharedHandsComponent
-{
-}
-using Content.Server.Hands.Components;
using Content.Server.Popups;
using Content.Server.Pulling;
using Content.Server.Stack;
RaiseNetworkEvent(new PickupAnimationEvent(item, initialPosition, finalPosition), filter);
}
- private void HandleEntityRemoved(EntityUid uid, SharedHandsComponent component, EntRemovedFromContainerMessage args)
+ private void HandleEntityRemoved(EntityUid uid, HandsComponent component, EntRemovedFromContainerMessage args)
{
if (!Deleted(args.Entity) && TryComp(args.Entity, out HandVirtualItemComponent? @virtual))
_virtualSystem.Delete(@virtual, uid);
if (playerSession.AttachedEntity is not {Valid: true} player ||
!Exists(player) ||
player.IsInContainer() ||
- !TryComp(player, out SharedHandsComponent? hands) ||
+ !TryComp(player, out HandsComponent? hands) ||
hands.ActiveHandEntity is not EntityUid throwEnt ||
!_actionBlockerSystem.CanThrow(player, throwEnt))
return false;
if (!_actionBlockerSystem.CanInteract(plyEnt, null))
return;
- if (!TryComp<SharedHandsComponent>(plyEnt, out var hands) || hands.ActiveHand == null)
+ if (!TryComp<HandsComponent>(plyEnt, out var hands) || hands.ActiveHand == null)
return;
if (!_inventorySystem.TryGetSlotEntity(plyEnt, equipmentSlot, out var slotEntity) ||
using Content.Server.Body.Components;
using Content.Server.Body.Systems;
using Content.Server.Chemistry.EntitySystems;
-using Content.Server.Hands.Components;
using Content.Server.Nutrition.Components;
using Content.Server.Popups;
using Content.Shared.Administration.Logs;
using Content.Shared.Database;
using Content.Shared.DoAfter;
using Content.Shared.FixedPoint;
+using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.IdentityManagement;
using Content.Shared.Interaction;
using Content.Server.Chemistry.Components.SolutionManager;
using Content.Server.Chemistry.EntitySystems;
-using Content.Server.Hands.Components;
using Content.Server.Nutrition.Components;
using Content.Shared.Chemistry.Components;
using Content.Shared.Examine;
-using Content.Server.Power.Components;
-using Content.Server.Hands.Components;
using Content.Server.Administration.Logs;
+using Content.Server.Administration.Managers;
+using Content.Server.Power.Components;
+using Content.Shared.Administration;
+using Content.Shared.Database;
using Content.Shared.Examine;
+using Content.Shared.Hands.Components;
using Content.Shared.Power;
using Content.Shared.Verbs;
-using Content.Shared.Database;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
-using Content.Server.Administration.Managers;
-using Content.Shared.Administration;
using Robust.Shared.Utility;
namespace Content.Server.Power.EntitySystems
using System.Linq;
using Content.Server.GameTicking;
-using Content.Server.Hands.Components;
using Content.Shared.Access;
using Content.Shared.Access.Components;
using Content.Shared.Access.Systems;
using Content.Shared.Containers.ItemSlots;
+using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Inventory;
using Content.Shared.PDA;
using Content.Shared.Sandbox;
using Robust.Server.Console;
-using Robust.Server.GameObjects;
using Robust.Server.Placement;
using Robust.Server.Player;
using Robust.Shared.Enums;
var fellEvent = new FellDownEvent(uid);
RaiseLocalEvent(uid, fellEvent, false);
- if (!TryComp(uid, out SharedHandsComponent? handsComp))
+ if (!TryComp(uid, out HandsComponent? handsComp))
return;
var worldRotation = EntityManager.GetComponent<TransformComponent>(uid).WorldRotation.ToVec();
using Content.Server.Access.Systems;
using Content.Server.DetailExaminable;
-using Content.Server.Hands.Components;
using Content.Server.Hands.Systems;
using Content.Server.Humanoid;
using Content.Server.IdentityManagement;
+using Content.Server.Mind.Commands;
using Content.Server.PDA;
using Content.Server.Roles;
using Content.Server.Station.Components;
-using Content.Server.Mind.Commands;
using Content.Shared.Access.Systems;
using Content.Shared.CCVar;
+using Content.Shared.Hands.Components;
using Content.Shared.Humanoid;
using Content.Shared.Humanoid.Prototypes;
using Content.Shared.Inventory;
using Robust.Shared.Random;
using Robust.Shared.Utility;
-
namespace Content.Server.Station.Systems;
/// <summary>
/// <returns>True if item was hidden inside stash</returns>
public bool TryHideItem(EntityUid uid, EntityUid userUid, EntityUid itemToHideUid,
SecretStashComponent? component = null, ItemComponent? item = null,
- MetaDataComponent? itemMeta = null, SharedHandsComponent? hands = null)
+ MetaDataComponent? itemMeta = null, HandsComponent? hands = null)
{
if (!Resolve(uid, ref component))
return false;
/// </summary>
/// <returns>True if user received item</returns>
public bool TryGetItem(EntityUid uid, EntityUid userUid, SecretStashComponent? component = null,
- SharedHandsComponent? hands = null)
+ HandsComponent? hands = null)
{
if (!Resolve(uid, ref component))
return false;
using System.Linq;
-using Content.Server.Hands.Components;
+using Content.Server.Administration.Managers;
+using Content.Server.Ghost.Components;
+using Content.Server.Interaction;
+using Content.Server.Popups;
using Content.Server.Storage.Components;
+using Content.Shared.ActionBlocker;
+using Content.Shared.Administration;
+using Content.Shared.CombatMode;
+using Content.Shared.Containers.ItemSlots;
+using Content.Shared.Destructible;
+using Content.Shared.DoAfter;
+using Content.Shared.Hands.Components;
+using Content.Shared.Hands.EntitySystems;
+using Content.Shared.Implants.Components;
using Content.Shared.Interaction;
+using Content.Shared.Item;
+using Content.Shared.Lock;
+using Content.Shared.Placeable;
+using Content.Shared.Stacks;
using Content.Shared.Storage;
+using Content.Shared.Storage.Components;
using Content.Shared.Timing;
using Content.Shared.Verbs;
using JetBrains.Annotations;
+using Robust.Server.Containers;
using Robust.Server.GameObjects;
using Robust.Server.Player;
+using Robust.Shared.Audio;
using Robust.Shared.Containers;
+using Robust.Shared.Map;
+using Robust.Shared.Player;
using Robust.Shared.Random;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
-using Content.Server.Interaction;
-using Content.Shared.Hands.EntitySystems;
-using Content.Shared.Item;
-using Content.Shared.Placeable;
-using Content.Shared.Stacks;
-using Content.Shared.Storage.Components;
-using Robust.Shared.Audio;
-using Robust.Shared.Map;
-using Robust.Shared.Player;
-using Robust.Server.Containers;
-using Content.Server.Popups;
-using Content.Shared.Destructible;
using static Content.Shared.Storage.SharedStorageComponent;
-using Content.Shared.ActionBlocker;
-using Content.Shared.CombatMode;
-using Content.Shared.Containers.ItemSlots;
-using Content.Shared.DoAfter;
-using Content.Shared.Implants.Components;
-using Content.Shared.Lock;
-using Content.Server.Ghost.Components;
-using Content.Server.Administration.Managers;
-using Content.Shared.Administration;
namespace Content.Server.Storage.EntitySystems
{
using System.Linq;
+using Content.Server.Administration.Logs;
using Content.Server.Ensnaring;
-using Content.Server.Hands.Components;
using Content.Shared.CombatMode;
+using Content.Shared.Cuffs;
+using Content.Shared.Cuffs.Components;
+using Content.Shared.Database;
+using Content.Shared.DoAfter;
+using Content.Shared.Ensnaring.Components;
using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.IdentityManagement;
+using Content.Shared.Interaction;
using Content.Shared.Interaction.Events;
using Content.Shared.Inventory;
using Content.Shared.Popups;
+using Content.Shared.Strip;
using Content.Shared.Strip.Components;
using Content.Shared.Verbs;
using Robust.Server.GameObjects;
-using Content.Server.Administration.Logs;
-using Content.Shared.Cuffs;
-using Content.Shared.Cuffs.Components;
-using Content.Shared.Database;
-using Content.Shared.DoAfter;
-using Content.Shared.Ensnaring.Components;
-using Content.Shared.Interaction;
-using Content.Shared.Strip;
using Robust.Shared.Utility;
namespace Content.Server.Strip
private void StripHand(EntityUid target, EntityUid user, string handId, StrippableComponent component, HandsComponent userHands)
{
- if (!TryComp<HandsComponent>(target, out var targetHands)
- || !targetHands.Hands.TryGetValue(handId, out var hand))
+ if (!_handsSystem.TryGetHand(target, handId, out var hand))
return;
// is the target a handcuff?
return false;
}
- if (!hands.Hands.TryGetValue(handName, out var hand)
+ if (!_handsSystem.TryGetHand(target, handName, out var hand, hands)
|| !_handsSystem.CanPickupToHand(target, userHands.ActiveHandEntity.Value, hand, checkActionBlocker: false, hands))
{
_popup.PopupCursor(Loc.GetString("strippable-component-cannot-put-message",("owner", target)), user);
bool Check()
{
- if (!hands.Hands.TryGetValue(handName, out var hand) || hand.HeldEntity != item)
+ if (!_handsSystem.TryGetHand(target, handName, out var hand, hands) || hand.HeldEntity != item)
{
_popup.PopupCursor(Loc.GetString("strippable-component-item-slot-free-message",("owner", target)), user);
return false;
DuplicateCondition = DuplicateConditions.SameTool
};
- if (Check() && hands.Hands.TryGetValue(handName, out var handSlot) && handSlot.HeldEntity != null)
+ if (Check() && _handsSystem.TryGetHand(target, handName, out var handSlot, hands) && handSlot.HeldEntity != null)
{
_popup.PopupEntity(
Loc.GetString("strippable-component-alert-owner",
-
-using Content.Shared.Interaction.Components;
-using Content.Server.Hands.Components;
+using Content.Shared.Destructible;
+using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
+using Content.Shared.Interaction.Components;
using Content.Shared.Storage;
using Content.Shared.Tag;
-using Content.Shared.Destructible;
using Robust.Shared.Random;
namespace Content.Server.Tools.Innate
if (!comp.RequireHands)
return;
- if (!TryComp(ev.Sender.AttachedEntity, out SharedHandsComponent? hands) || hands.Hands.Count == 0)
+ if (!TryComp(ev.Sender.AttachedEntity, out HandsComponent? hands) || hands.Hands.Count == 0)
ev.Cancel();
}
if (!_blockerSystem.CanInteract(user, aui.Owner) && (!aui.AllowSpectator || !HasComp<GhostComponent>(user)))
return false;
- if (aui.RequireHands && !HasComp<SharedHandsComponent>(user))
+ if (aui.RequireHands && !HasComp<HandsComponent>(user))
return false;
if (!EntityManager.TryGetComponent(user, out ActorComponent? actor)) return false;
+using System.Linq;
using Content.Server.Administration.Managers;
using Content.Server.Popups;
using Content.Shared.Administration;
using Content.Shared.Hands.Components;
using Content.Shared.Verbs;
using Robust.Server.Player;
-using Robust.Shared.Player;
-using System.Linq;
namespace Content.Server.Verbs
{
{
// first get the held item. again.
EntityUid? holding = null;
- if (TryComp(user, out SharedHandsComponent? hands) &&
+ if (TryComp(user, out HandsComponent? hands) &&
hands.ActiveHandEntity is EntityUid heldEntity)
{
holding = heldEntity;
using System.Linq;
using Content.Server.Actions.Events;
-using Content.Server.Administration.Components;
using Content.Server.Body.Components;
using Content.Server.Body.Systems;
using Content.Server.Chemistry.Components;
using Content.Server.CombatMode.Disarm;
using Content.Server.Contests;
using Content.Server.Examine;
-using Content.Server.Hands.Components;
using Content.Server.Movement.Systems;
using Content.Shared.Administration.Components;
using Content.Shared.CombatMode;
using Content.Shared.Damage;
using Content.Shared.Database;
using Content.Shared.FixedPoint;
+using Content.Shared.Hands.Components;
using Content.Shared.IdentityManagement;
+using Content.Shared.StatusEffect;
using Content.Shared.Verbs;
using Content.Shared.Weapons.Melee;
using Content.Shared.Weapons.Melee.Events;
-using Content.Shared.StatusEffect;
using Robust.Server.Player;
using Robust.Shared.Audio;
using Robust.Shared.Map;
-using Content.Server.Hands.Components;
+using Content.Server.Actions.Events;
using Content.Server.Hands.Systems;
using Content.Server.Wieldable.Components;
+using Content.Shared.DoAfter;
using Content.Shared.Hands;
using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Item;
using Content.Shared.Popups;
using Content.Shared.Verbs;
-using Robust.Shared.Player;
-using Content.Server.Actions.Events;
-using Content.Shared.DoAfter;
using Content.Shared.Weapons.Melee.Events;
using Content.Shared.Wieldable;
-
+using Robust.Shared.Player;
namespace Content.Server.Wieldable
{
using System.Linq;
using System.Threading;
using Content.Server.Administration.Logs;
-using Content.Server.Hands.Components;
using Content.Server.Power.Components;
-using Content.Shared.DoAfter;
using Content.Shared.Database;
+using Content.Shared.DoAfter;
using Content.Shared.GameTicking;
+using Content.Shared.Hands.Components;
using Content.Shared.Interaction;
using Content.Shared.Popups;
using Content.Shared.Tools;
-using Content.Shared.Damage;
-using Content.Shared.Hands.EntitySystems;
-using Content.Server.Disease.Components;
-using Content.Server.Body.Components;
using Content.Server.Atmos.Components;
-using Content.Server.Nutrition.Components;
-using Content.Server.Popups;
-using Content.Server.Speech.Components;
+using Content.Server.Atmos.Miasma;
+using Content.Server.Body.Components;
using Content.Server.Body.Systems;
-using Content.Server.CombatMode;
-using Content.Server.Inventory;
-using Content.Server.Mind.Components;
+using Content.Server.Chat;
using Content.Server.Chat.Managers;
+using Content.Server.Chat.Systems;
+using Content.Server.CombatMode;
+using Content.Server.Disease.Components;
using Content.Server.Ghost.Roles.Components;
-using Content.Server.Hands.Components;
+using Content.Server.Humanoid;
+using Content.Server.IdentityManagement;
+using Content.Server.Inventory;
using Content.Server.Mind.Commands;
+using Content.Server.Mind.Components;
+using Content.Server.Nutrition.Components;
+using Content.Server.Popups;
+using Content.Server.Speech.Components;
using Content.Server.Temperature.Components;
-using Content.Shared.Movement.Components;
-using Robust.Shared.Prototypes;
-using Content.Shared.Roles;
using Content.Server.Traitor;
-using Content.Shared.Zombies;
-using Content.Shared.Popups;
-using Content.Server.Atmos.Miasma;
-using Content.Server.Humanoid;
-using Content.Server.IdentityManagement;
+using Content.Shared.Damage;
+using Content.Shared.Hands.Components;
+using Content.Shared.Hands.EntitySystems;
using Content.Shared.Humanoid;
using Content.Shared.Mobs;
using Content.Shared.Mobs.Components;
+using Content.Shared.Movement.Components;
using Content.Shared.Movement.Systems;
-using Content.Shared.Weapons.Melee;
-using Content.Server.Chat;
-using Content.Server.Chat.Systems;
using Content.Shared.Nutrition.Components;
+using Content.Shared.Popups;
+using Content.Shared.Roles;
+using Content.Shared.Weapons.Melee;
+using Content.Shared.Zombies;
+using Robust.Shared.Prototypes;
namespace Content.Server.Zombies
{
using Content.Shared.Hands.Components;
using Content.Shared.Inventory;
using Content.Shared.PDA;
-using Robust.Shared.GameStates;
namespace Content.Shared.Access.Systems;
public bool TryFindIdCard(EntityUid uid, [NotNullWhen(true)] out IdCardComponent? idCard)
{
// check held item?
- if (EntityManager.TryGetComponent(uid, out SharedHandsComponent? hands) &&
+ if (EntityManager.TryGetComponent(uid, out HandsComponent? hands) &&
hands.ActiveHandEntity is EntityUid heldItem &&
TryGetIdCard(heldItem, out idCard))
{
using Content.Shared.Toggleable;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Components;
-using Robust.Shared.Physics.Dynamics;
using Robust.Shared.Physics.Systems;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
return;
var blockQuery = GetEntityQuery<BlockingComponent>();
- var handQuery = GetEntityQuery<SharedHandsComponent>();
+ var handQuery = GetEntityQuery<HandsComponent>();
if (!handQuery.TryGetComponent(args.Performer, out var hands))
return;
StopBlocking(uid, component, user);
var userQuery = GetEntityQuery<BlockingUserComponent>();
- var handQuery = GetEntityQuery<SharedHandsComponent>();
+ var handQuery = GetEntityQuery<HandsComponent>();
if (!handQuery.TryGetComponent(user, out var hands))
return;
+using System.Diagnostics.CodeAnalysis;
using Content.Shared.ActionBlocker;
+using Content.Shared.Administration.Logs;
+using Content.Shared.Database;
using Content.Shared.Destructible;
using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Verbs;
using Robust.Shared.Containers;
using Robust.Shared.GameStates;
-using Robust.Shared.Player;
-using Robust.Shared.Utility;
-using System.Diagnostics.CodeAnalysis;
-using Content.Shared.Administration.Logs;
-using Content.Shared.Database;
using Robust.Shared.Network;
using Robust.Shared.Timing;
+using Robust.Shared.Utility;
namespace Content.Shared.Containers.ItemSlots
{
if (args.Handled)
return;
- if (!EntityManager.TryGetComponent(args.User, out SharedHandsComponent? hands))
+ if (!EntityManager.TryGetComponent(args.User, out HandsComponent? hands))
return;
foreach (var slot in itemSlots.Slots.Values)
/// Does not check action blockers.
/// </summary>
/// <returns>False if failed to insert item</returns>
- public bool TryInsertFromHand(EntityUid uid, ItemSlot slot, EntityUid user, SharedHandsComponent? hands = null)
+ public bool TryInsertFromHand(EntityUid uid, ItemSlot slot, EntityUid user, HandsComponent? hands = null)
{
if (!Resolve(user, ref hands, false))
return false;
public void UpdateCuffState(EntityUid uid, CuffableComponent component)
{
- var canInteract = TryComp(uid, out SharedHandsComponent? hands) && hands.Hands.Count > component.CuffedHandCount;
+ var canInteract = TryComp(uid, out HandsComponent? hands) && hands.Hands.Count > component.CuffedHandCount;
if (canInteract == component.CanStillInteract)
return;
}
var dirty = false;
- var handCount = CompOrNull<SharedHandsComponent>(owner)?.Count ?? 0;
+ var handCount = CompOrNull<HandsComponent>(owner)?.Count ?? 0;
while (cuffable.CuffedHandCount > handCount && cuffable.CuffedHandCount > 0)
{
// TODO we probably don't just want to use the generic virtual-item entity, and instead
// want to add our own item, so that use-in-hand triggers an uncuff attempt and the like.
- if (!TryComp<SharedHandsComponent>(uid, out var handsComponent))
+ if (!TryComp<HandsComponent>(uid, out var handsComponent))
return;
var freeHands = 0;
if (!Resolve(handcuff, ref handcuffComponent) || !Resolve(target, ref cuffable, false))
return;
- if (!TryComp<SharedHandsComponent?>(target, out var hands))
+ if (!TryComp<HandsComponent?>(target, out var hands))
{
if (_net.IsServer)
{
var time = GameTiming.CurTime;
var xformQuery = GetEntityQuery<TransformComponent>();
- var handsQuery = GetEntityQuery<SharedHandsComponent>();
+ var handsQuery = GetEntityQuery<HandsComponent>();
var enumerator = EntityQueryEnumerator<ActiveDoAfterComponent, DoAfterComponent>();
while (enumerator.MoveNext(out var uid, out var active, out var comp))
DoAfterComponent comp,
TimeSpan time,
EntityQuery<TransformComponent> xformQuery,
- EntityQuery<SharedHandsComponent> handsQuery)
+ EntityQuery<HandsComponent> handsQuery)
{
var dirty = false;
private bool ShouldCancel(DoAfter doAfter,
EntityQuery<TransformComponent> xformQuery,
- EntityQuery<SharedHandsComponent> handsQuery)
+ EntityQuery<HandsComponent> handsQuery)
{
var args = doAfter.Args;
// (or if there is no item there we need to keep it free).
if (args.NeedHand && args.BreakOnHandChange)
{
- if (!TryComp(args.User, out SharedHandsComponent? handsComponent))
+ if (!TryComp(args.User, out HandsComponent? handsComponent))
return false;
doAfter.InitialHand = handsComponent.ActiveHand?.Name;
}
// Inital checks
- if (ShouldCancel(doAfter, GetEntityQuery<TransformComponent>(), GetEntityQuery<SharedHandsComponent>()))
+ if (ShouldCancel(doAfter, GetEntityQuery<TransformComponent>(), GetEntityQuery<HandsComponent>()))
return false;
if (args.AttemptFrequency == AttemptFrequency.StartAndEnd && !TryAttemptEvent(doAfter))
+using System.Linq;
using Content.Shared.Access.Components;
using Content.Shared.Damage;
+using Content.Shared.DoAfter;
using Content.Shared.Doors.Components;
using Content.Shared.Hands.Components;
using Content.Shared.Interaction;
using Content.Shared.Stunnable;
+using Content.Shared.Tag;
using Robust.Shared.Audio;
using Robust.Shared.GameStates;
using Robust.Shared.Physics;
-using Robust.Shared.Physics.Dynamics;
-using Robust.Shared.Timing;
-using System.Linq;
-using Content.Shared.DoAfter;
-using Content.Shared.Tag;
-using Content.Shared.Tools.Components;
-using Content.Shared.Verbs;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Events;
using Robust.Shared.Physics.Systems;
using Robust.Shared.Serialization;
+using Robust.Shared.Timing;
namespace Content.Shared.Doors.Systems;
// component, but no actual hands!? What!? Is this the sound of them head-butting the door to get it to open??
// I'm 99% sure something is wrong here, but I kind of want to keep it this way.
- if (user != null && TryComp(user.Value, out SharedHandsComponent? hands) && hands.Hands.Count == 0)
+ if (user != null && TryComp(user.Value, out HandsComponent? hands) && hands.Hands.Count == 0)
PlaySound(uid, door.TryOpenDoorSound, AudioParams.Default.WithVolume(-2), user, predicted);
}
/// Returns true if any hand is free. This is a LinQ method, not a property, so
/// cache it instead of accessing this multiple times.
/// </summary>
- public static bool IsAnyHandFree(this SharedHandsComponent component) => component.Hands.Values.Any(hand => hand.IsEmpty);
+ public static bool IsAnyHandFree(this HandsComponent component) => component.Hands.Values.Any(hand => hand.IsEmpty);
/// <summary>
/// Get the number of hands that are not currently holding anything. This is a LinQ method, not a property, so
/// cache it instead of accessing this multiple times.
/// </summary>
- public static int CountFreeHands(this SharedHandsComponent component) => component.Hands.Values.Count(hand => hand.IsEmpty);
+ public static int CountFreeHands(this HandsComponent component) => component.Hands.Values.Count(hand => hand.IsEmpty);
/// <summary>
/// Get a list of hands that are currently holding nothing. This is a LinQ method, not a property, so cache
/// it instead of accessing this multiple times.
/// </summary>
- public static IEnumerable<Hand> GetFreeHands(this SharedHandsComponent component) => component.Hands.Values.Where(hand => !hand.IsEmpty);
+ public static IEnumerable<Hand> GetFreeHands(this HandsComponent component) => component.Hands.Values.Where(hand => !hand.IsEmpty);
/// <summary>
/// Get a list of hands that are currently holding nothing. This is a LinQ method, not a property, so cache
/// it instead of accessing this multiple times.
/// </summary>
- public static IEnumerable<string> GetFreeHandNames(this SharedHandsComponent component) => GetFreeHands(component).Select(hand => hand.Name);
+ public static IEnumerable<string> GetFreeHandNames(this HandsComponent component) => GetFreeHands(component).Select(hand => hand.Name);
}
+using Content.Shared.Hands.EntitySystems;
using Robust.Shared.Containers;
using Robust.Shared.GameStates;
using Robust.Shared.Serialization;
namespace Content.Shared.Hands.Components;
-[NetworkedComponent]
-public abstract class SharedHandsComponent : Component
+[RegisterComponent, NetworkedComponent]
+[Access(typeof(SharedHandsSystem))]
+public sealed class HandsComponent : Component
{
/// <summary>
/// The currently active hand.
[DataField("throwRange")]
[ViewVariables(VVAccess.ReadWrite)]
public float ThrowRange { get; set; } = 8f;
+
+ /// <summary>
+ /// Whether or not to add in-hand sprites for held items. Some entities (e.g., drones) don't want these.
+ /// Used by the client.
+ /// </summary>
+ [DataField("showInHands")]
+ public bool ShowInHands = true;
+
+ /// <summary>
+ /// Data about the current sprite layers that the hand is contributing to the owner entity. Used for sprite in-hands.
+ /// Used by the client.
+ /// </summary>
+ public readonly Dictionary<HandLocation, HashSet<string>> RevealedLayers = new();
}
[Serializable, NetSerializable]
public readonly List<string> HandNames;
public readonly string? ActiveHand;
- public HandsComponentState(SharedHandsComponent handComp)
+ public HandsComponentState(HandsComponent handComp)
{
Hands = new(handComp.Hands.Values);
HandNames = handComp.SortedHands;
-using Content.Shared.Hands.Components;
using System.Diagnostics.CodeAnalysis;
+using Content.Shared.Hands.Components;
namespace Content.Shared.Hands.EntitySystems;
public abstract partial class SharedHandsSystem : EntitySystem
{
- public bool TrySelect(EntityUid uid, EntityUid? entity, SharedHandsComponent? handsComp = null)
+ public bool TrySelect(EntityUid uid, EntityUid? entity, HandsComponent? handsComp = null)
{
if (!Resolve(uid, ref handsComp, false))
return false;
return true;
}
- public bool TrySelect<TComponent>(EntityUid uid, [NotNullWhen(true)] out TComponent? component, SharedHandsComponent? handsComp = null) where TComponent : Component
+ public bool TrySelect<TComponent>(EntityUid uid, [NotNullWhen(true)] out TComponent? component, HandsComponent? handsComp = null) where TComponent : Component
{
component = null;
if (!Resolve(uid, ref handsComp, false))
return false;
}
- public bool TrySelectEmptyHand(EntityUid uid, SharedHandsComponent? handsComp = null) => TrySelect(uid, null, handsComp);
+ public bool TrySelectEmptyHand(EntityUid uid, HandsComponent? handsComp = null) => TrySelect(uid, null, handsComp);
}
/// <summary>
/// Attempts to drop the item in the currently active hand.
/// </summary>
- public bool TryDrop(EntityUid uid, EntityCoordinates? targetDropLocation = null, bool checkActionBlocker = true, bool doDropInteraction = true, SharedHandsComponent? handsComp = null)
+ public bool TryDrop(EntityUid uid, EntityCoordinates? targetDropLocation = null, bool checkActionBlocker = true, bool doDropInteraction = true, HandsComponent? handsComp = null)
{
if (!Resolve(uid, ref handsComp))
return false;
/// <summary>
/// Drops an item at the target location.
/// </summary>
- public bool TryDrop(EntityUid uid, EntityUid entity, EntityCoordinates? targetDropLocation = null, bool checkActionBlocker = true, bool doDropInteraction = true, SharedHandsComponent? handsComp = null)
+ public bool TryDrop(EntityUid uid, EntityUid entity, EntityCoordinates? targetDropLocation = null, bool checkActionBlocker = true, bool doDropInteraction = true, HandsComponent? handsComp = null)
{
if (!Resolve(uid, ref handsComp))
return false;
/// <summary>
/// Drops a hands contents at the target location.
/// </summary>
- public bool TryDrop(EntityUid uid, Hand hand, EntityCoordinates? targetDropLocation = null, bool checkActionBlocker = true, bool doDropInteraction = true, SharedHandsComponent? handsComp = null)
+ public bool TryDrop(EntityUid uid, Hand hand, EntityCoordinates? targetDropLocation = null, bool checkActionBlocker = true, bool doDropInteraction = true, HandsComponent? handsComp = null)
{
if (!Resolve(uid, ref handsComp))
return false;
/// <summary>
/// Attempts to move a held item from a hand into a container that is not another hand, without dropping it on the floor in-between.
/// </summary>
- public bool TryDropIntoContainer(EntityUid uid, EntityUid entity, IContainer targetContainer, bool checkActionBlocker = true, SharedHandsComponent? handsComp = null)
+ public bool TryDropIntoContainer(EntityUid uid, EntityUid entity, IContainer targetContainer, bool checkActionBlocker = true, HandsComponent? handsComp = null)
{
if (!Resolve(uid, ref handsComp))
return false;
/// <summary>
/// Removes the contents of a hand from its container. Assumes that the removal is allowed. In general, you should not be calling this directly.
/// </summary>
- public virtual void DoDrop(EntityUid uid, Hand hand, bool doDropInteraction = true, SharedHandsComponent? handsComp = null)
+ public virtual void DoDrop(EntityUid uid, Hand hand, bool doDropInteraction = true, HandsComponent? handsComp = null)
{
if (!Resolve(uid, ref handsComp))
return;
SubscribeAllEvent<RequestMoveHandItemEvent>(HandleMoveItemFromHand);
SubscribeAllEvent<RequestHandAltInteractEvent>(HandleHandAltInteract);
- SubscribeLocalEvent<SharedHandsComponent, ExaminedEvent>(HandleExamined);
+ SubscribeLocalEvent<HandsComponent, ExaminedEvent>(HandleExamined);
CommandBinds.Builder
.Bind(ContentKeyFunctions.UseItemInHand, InputCmdHandler.FromDelegate(HandleUseItem, handle: false, outsidePrediction: false))
private void SwapHandsPressed(ICommonSession? session)
{
- if (!TryComp(session?.AttachedEntity, out SharedHandsComponent? component))
+ if (!TryComp(session?.AttachedEntity, out HandsComponent? component))
return;
if (!_actionBlocker.CanInteract(session.AttachedEntity.Value, null))
private bool DropPressed(ICommonSession? session, EntityCoordinates coords, EntityUid uid)
{
- if (TryComp(session?.AttachedEntity, out SharedHandsComponent? hands) && hands.ActiveHand != null)
+ if (TryComp(session?.AttachedEntity, out HandsComponent? hands) && hands.ActiveHand != null)
TryDrop(session.AttachedEntity!.Value, hands.ActiveHand, coords, handsComp: hands);
// always send to server.
}
#endregion
- public bool TryActivateItemInHand(EntityUid uid, SharedHandsComponent? handsComp = null, string? handName = null)
+ public bool TryActivateItemInHand(EntityUid uid, HandsComponent? handsComp = null, string? handName = null)
{
if (!Resolve(uid, ref handsComp, false))
return false;
return _interactionSystem.InteractionActivate(uid, held);
}
- public bool TryInteractHandWithActiveHand(EntityUid uid, string handName, SharedHandsComponent? handsComp = null)
+ public bool TryInteractHandWithActiveHand(EntityUid uid, string handName, HandsComponent? handsComp = null)
{
if (!Resolve(uid, ref handsComp, false))
return false;
return true;
}
- public bool TryUseItemInHand(EntityUid uid, bool altInteract = false, SharedHandsComponent? handsComp = null, string? handName = null)
+ public bool TryUseItemInHand(EntityUid uid, bool altInteract = false, HandsComponent? handsComp = null, string? handName = null)
{
if (!Resolve(uid, ref handsComp, false))
return false;
/// <summary>
/// Moves an entity from one hand to the active hand.
/// </summary>
- public bool TryMoveHeldEntityToActiveHand(EntityUid uid, string handName, bool checkActionBlocker = true, SharedHandsComponent? handsComp = null)
+ public bool TryMoveHeldEntityToActiveHand(EntityUid uid, string handName, bool checkActionBlocker = true, HandsComponent? handsComp = null)
{
if (!Resolve(uid, ref handsComp))
return false;
}
//TODO: Actually shows all items/clothing/etc.
- private void HandleExamined(EntityUid uid, SharedHandsComponent handsComp, ExaminedEvent args)
+ private void HandleExamined(EntityUid uid, HandsComponent handsComp, ExaminedEvent args)
{
foreach (var inhand in EnumerateHeld(uid, handsComp))
{
bool checkActionBlocker = true,
bool animateUser = false,
bool animate = true,
- SharedHandsComponent? handsComp = null,
+ HandsComponent? handsComp = null,
ItemComponent? item = null)
{
if (!Resolve(uid, ref handsComp, false))
bool checkActionBlocker = true,
bool animateUser = false,
bool animate = true,
- SharedHandsComponent? handsComp = null,
+ HandsComponent? handsComp = null,
ItemComponent? item = null)
{
if (!Resolve(uid, ref handsComp, false))
bool checkActionBlocker = true,
bool animateUser = false,
bool animate = true,
- SharedHandsComponent? handsComp = null,
+ HandsComponent? handsComp = null,
ItemComponent? item = null)
{
if (!Resolve(uid, ref handsComp, false))
return true;
}
- public bool CanPickupAnyHand(EntityUid uid, EntityUid entity, bool checkActionBlocker = true, SharedHandsComponent? handsComp = null, ItemComponent? item = null)
+ public bool CanPickupAnyHand(EntityUid uid, EntityUid entity, bool checkActionBlocker = true, HandsComponent? handsComp = null, ItemComponent? item = null)
{
if (!Resolve(uid, ref handsComp, false))
return false;
/// <summary>
/// Checks whether a given item will fit into a specific user's hand. Unless otherwise specified, this will also check the general CanPickup action blocker.
/// </summary>
- public bool CanPickupToHand(EntityUid uid, EntityUid entity, Hand hand, bool checkActionBlocker = true, SharedHandsComponent? handsComp = null, ItemComponent? item = null)
+ public bool CanPickupToHand(EntityUid uid, EntityUid entity, Hand hand, bool checkActionBlocker = true, HandsComponent? handsComp = null, ItemComponent? item = null)
{
if (!Resolve(uid, ref handsComp, false))
return false;
bool checkActionBlocker = true,
bool animateUser = false,
bool animate = true,
- SharedHandsComponent? handsComp = null,
+ HandsComponent? handsComp = null,
ItemComponent? item = null)
{
if (uid == null
/// <summary>
/// Puts an entity into the player's hand, assumes that the insertion is allowed. In general, you should not be calling this function directly.
/// </summary>
- public virtual void DoPickup(EntityUid uid, Hand hand, EntityUid entity, SharedHandsComponent? hands = null)
+ public virtual void DoPickup(EntityUid uid, Hand hand, EntityUid entity, HandsComponent? hands = null)
{
if (!Resolve(uid, ref hands))
return;
[Dependency] private readonly ActionBlockerSystem _actionBlocker = default!;
[Dependency] private readonly SharedContainerSystem _containerSystem = default!;
- protected event Action<SharedHandsComponent?>? OnHandSetActive;
+ protected event Action<HandsComponent?>? OnHandSetActive;
public override void Initialize()
{
CommandBinds.Unregister<SharedHandsSystem>();
}
- public virtual void AddHand(EntityUid uid, string handName, HandLocation handLocation, SharedHandsComponent? handsComp = null)
+ public virtual void AddHand(EntityUid uid, string handName, HandLocation handLocation, HandsComponent? handsComp = null)
{
if (!Resolve(uid, ref handsComp, false))
return;
Dirty(handsComp);
}
- public virtual void RemoveHand(EntityUid uid, string handName, SharedHandsComponent? handsComp = null)
+ public virtual void RemoveHand(EntityUid uid, string handName, HandsComponent? handsComp = null)
{
if (!Resolve(uid, ref handsComp, false))
return;
/// <summary>
/// Get any empty hand. Prioritizes the currently active hand.
/// </summary>
- public bool TryGetEmptyHand(EntityUid uid, [NotNullWhen(true)] out Hand? emptyHand, SharedHandsComponent? handComp = null)
+ public bool TryGetEmptyHand(EntityUid uid, [NotNullWhen(true)] out Hand? emptyHand, HandsComponent? handComp = null)
{
emptyHand = null;
if (!Resolve(uid, ref handComp, false))
/// <summary>
/// Enumerate over hands, starting with the currently active hand.
/// </summary>
- public IEnumerable<Hand> EnumerateHands(EntityUid uid, SharedHandsComponent? handsComp = null)
+ public IEnumerable<Hand> EnumerateHands(EntityUid uid, HandsComponent? handsComp = null)
{
if (!Resolve(uid, ref handsComp, false))
yield break;
/// <summary>
/// Enumerate over held items, starting with the item in the currently active hand (if there is one).
/// </summary>
- public IEnumerable<EntityUid> EnumerateHeld(EntityUid uid, SharedHandsComponent? handsComp = null)
+ public IEnumerable<EntityUid> EnumerateHeld(EntityUid uid, HandsComponent? handsComp = null)
{
if (!Resolve(uid, ref handsComp, false))
yield break;
/// </summary>
/// <returns>True if the active hand was set to a NEW value. Setting it to the same value returns false and does
/// not trigger interactions.</returns>
- public virtual bool TrySetActiveHand(EntityUid uid, string? name, SharedHandsComponent? handComp = null)
+ public virtual bool TrySetActiveHand(EntityUid uid, string? name, HandsComponent? handComp = null)
{
if (!Resolve(uid, ref handComp))
return false;
/// </summary>
/// <returns>True if the active hand was set to a NEW value. Setting it to the same value returns false and does
/// not trigger interactions.</returns>
- public bool SetActiveHand(EntityUid uid, Hand? hand, SharedHandsComponent? handComp = null)
+ public bool SetActiveHand(EntityUid uid, Hand? hand, HandsComponent? handComp = null)
{
if (!Resolve(uid, ref handComp))
return false;
return true;
}
- public bool IsHolding(EntityUid uid, EntityUid? entity, [NotNullWhen(true)] out Hand? inHand, SharedHandsComponent? handsComp = null)
+ public bool IsHolding(EntityUid uid, EntityUid? entity, [NotNullWhen(true)] out Hand? inHand, HandsComponent? handsComp = null)
{
inHand = null;
if (!Resolve(uid, ref handsComp, false))
return false;
}
+
+ public bool TryGetHand(EntityUid handsUid, string handId, [NotNullWhen(true)] out Hand? hand,
+ HandsComponent? hands = null)
+ {
+ hand = null;
+
+ if (!Resolve(handsUid, ref hands))
+ return false;
+
+ return hands.Hands.TryGetValue(handId, out hand);
+ }
}
using Robust.Shared.Physics;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Systems;
-using Robust.Shared.Player;
using Robust.Shared.Players;
using Robust.Shared.Random;
using Robust.Shared.Serialization;
: !checkAccess || InRangeUnobstructed(user, target.Value); // permits interactions with wall mounted entities
// Does the user have hands?
- if (!TryComp(user, out SharedHandsComponent? hands) || hands.ActiveHand == null)
+ if (!TryComp(user, out HandsComponent? hands) || hands.ActiveHand == null)
{
var ev = new InteractNoHandEvent(user, target, coordinates);
RaiseLocalEvent(user, ev);
return false;
// Does the user have hands?
- if (!HasComp<SharedHandsComponent>(user))
+ if (!HasComp<HandsComponent>(user))
return false;
var activateMsg = new ActivateInWorldEvent(user, used);
using System.Diagnostics.CodeAnalysis;
-using Content.Shared.ActionBlocker;
using Content.Shared.Clothing.Components;
using Content.Shared.Hands;
using Content.Shared.Hands.Components;
protected void QuickEquip(EntityUid uid, ClothingComponent component, UseInHandEvent args)
{
if (!TryComp(args.User, out InventoryComponent? inv)
- || !TryComp(args.User, out SharedHandsComponent? hands)
+ || !TryComp(args.User, out HandsComponent? hands)
|| !_prototypeManager.TryIndex<InventoryTemplatePrototype>(inv.TemplateId, out var prototype))
return;
if (eventArgs.SenderSession.AttachedEntity is not { Valid: true } actor)
return;
- if (!TryComp(actor, out InventoryComponent? inventory) || !TryComp<SharedHandsComponent>(actor, out var hands))
+ if (!TryComp(actor, out InventoryComponent? inventory) || !TryComp<HandsComponent>(actor, out var hands))
return;
var held = hands.ActiveHandEntity;
return actor != target &&
HasComp<StrippableComponent>(target) &&
HasComp<StrippingComponent>(actor) &&
- HasComp<SharedHandsComponent>(actor);
+ HasComp<HandsComponent>(actor);
}
public bool CanEquip(EntityUid uid, EntityUid itemUid, string slot, [NotNullWhen(false)] out string? reason,
using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Popups;
-using Robust.Shared.Player;
using Robust.Shared.Timing;
namespace Content.Shared.Item;
private void OnAttemptPickup(EntityUid uid, MultiHandedItemComponent component, GettingPickedUpAttemptEvent args)
{
- if (TryComp<SharedHandsComponent>(args.User, out var hands) && hands.CountFreeHands() >= component.HandsNeeded)
+ if (TryComp<HandsComponent>(args.User, out var hands) && hands.CountFreeHands() >= component.HandsNeeded)
return;
args.Cancel();
-using Content.Shared.Emag.Systems;
using Content.Shared.Access.Components;
using Content.Shared.Access.Systems;
+using Content.Shared.Emag.Systems;
using Content.Shared.Examine;
using Content.Shared.Hands.Components;
using Content.Shared.IdentityManagement;
/// </summary>
public bool CanToggleLock(EntityUid uid, EntityUid user, bool quiet = true)
{
- if (!HasComp<SharedHandsComponent>(user))
+ if (!HasComp<HandsComponent>(user))
return false;
var ev = new LockToggleAttemptEvent(user, quiet);
if (!Resolve(uid, ref component))
return false;
- return IsEmpty(component) && _actionBlocker.CanMove(toInsert) && HasComp<SharedHandsComponent>(toInsert);
+ return IsEmpty(component) && _actionBlocker.CanMove(toInsert) && HasComp<HandsComponent>(toInsert);
}
/// <summary>
EntityUid item,
EntityUid user,
StackComponent? itemStack = null,
- SharedHandsComponent? hands = null)
+ HandsComponent? hands = null)
{
if (!Resolve(user, ref hands, false))
return;
-using Content.Shared.Audio;
using Content.Shared.Hands.Components;
+using Content.Shared.Physics;
using Content.Shared.Rotation;
using Robust.Shared.Audio;
-using Robust.Shared.Player;
-using Robust.Shared.Timing;
-using Robust.Shared.Physics;
-using Content.Shared.Physics;
using Robust.Shared.GameStates;
-using Robust.Shared.Serialization;
-using Robust.Shared.Network;
+using Robust.Shared.Physics;
using Robust.Shared.Physics.Systems;
+using Robust.Shared.Serialization;
namespace Content.Shared.Standing
{
public bool Down(EntityUid uid, bool playSound = true, bool dropHeldItems = true,
StandingStateComponent? standingState = null,
AppearanceComponent? appearance = null,
- SharedHandsComponent? hands = null)
+ HandsComponent? hands = null)
{
// TODO: This should actually log missing comps...
if (!Resolve(uid, ref standingState, false))
private void OnRelayMovement(EntityUid uid, SharedEntityStorageComponent component, ref ContainerRelayMovementEntityEvent args)
{
- if (!HasComp<SharedHandsComponent>(args.Entity))
+ if (!HasComp<HandsComponent>(args.Entity))
return;
if (_timing.CurTime < component.LastInternalOpenAttempt + SharedEntityStorageComponent.InternalOpenAttemptDelay)
if (!Resolve(target, ref component))
return false;
- if (!HasComp<SharedHandsComponent>(user))
+ if (!HasComp<HandsComponent>(user))
return false;
if (component.IsWeldedShut)
args.Handled = true;
args.CanDrop |= uid == args.User &&
HasComp<StrippableComponent>(args.Dragged) &&
- HasComp<SharedHandsComponent>(args.User);
+ HasComp<HandsComponent>(args.User);
}
private void OnCanDrop(EntityUid uid, StrippableComponent component, ref CanDropDraggedEvent args)
{
args.CanDrop |= args.Target == args.User &&
HasComp<StrippingComponent>(args.User) &&
- HasComp<SharedHandsComponent>(args.User);
+ HasComp<HandsComponent>(args.User);
if (args.CanDrop)
args.Handled = true;
+using System.Diagnostics.CodeAnalysis;
using Content.Shared.ActionBlocker;
using Content.Shared.Hands.Components;
using Content.Shared.Interaction;
using Robust.Shared.GameStates;
using Robust.Shared.Map;
using Robust.Shared.Network;
-using Robust.Shared.Players;
using Robust.Shared.Serialization;
-using System.Diagnostics.CodeAnalysis;
namespace Content.Shared.Tabletop
{
// CanSeeTable checks interaction action blockers. So no need to check them here.
// If this ever changes, so that ghosts can spectate games, then the check needs to be moved here.
- return TryComp(playerEntity, out SharedHandsComponent? hands) && hands.Hands.Count > 0;
+ return TryComp(playerEntity, out HandsComponent? hands) && hands.Hands.Count > 0;
}
#endregion
}
+using System.Linq;
using Content.Shared.Administration.Logs;
using Content.Shared.Database;
using Content.Shared.Hands.Components;
using Robust.Shared.Containers;
using Robust.Shared.GameStates;
using Robust.Shared.Physics;
-using Robust.Shared.Physics.Dynamics;
-using System.Linq;
-using Content.Shared.Sound.Components;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Events;
using Robust.Shared.Physics.Systems;
// Unfortunately we can't check for hands containers as they have specific names.
if (uid.TryGetContainerMan(out var containerManager) &&
- EntityManager.HasComponent<SharedHandsComponent>(containerManager.Owner))
+ EntityManager.HasComponent<HandsComponent>(containerManager.Owner))
{
EntityManager.RemoveComponent(landing, thrownItem);
return;
var canInteract = force || _actionBlockerSystem.CanInteract(user, target);
EntityUid? @using = null;
- if (TryComp(user, out SharedHandsComponent? hands) && (force || _actionBlockerSystem.CanUseHeldEntity(user)))
+ if (TryComp(user, out HandsComponent? hands) && (force || _actionBlockerSystem.CanUseHeldEntity(user)))
{
@using = hands.ActiveHandEntity;
/// <remarks>
/// This may be null if the user has no hands.
/// </remarks>
- public readonly SharedHandsComponent? Hands;
+ public readonly HandsComponent? Hands;
/// <summary>
/// The entity currently being held by the active hand.
/// </remarks>
public readonly EntityUid? Using;
- public GetVerbsEvent(EntityUid user, EntityUid target, EntityUid? @using, SharedHandsComponent? hands, bool canInteract, bool canAccess)
+ public GetVerbsEvent(EntityUid user, EntityUid target, EntityUid? @using, HandsComponent? hands, bool canInteract, bool canAccess)
{
User = user;
Target = target;
}
// Use inhands entity if we got one.
- if (EntityManager.TryGetComponent(entity, out SharedHandsComponent? hands) &&
+ if (EntityManager.TryGetComponent(entity, out HandsComponent? hands) &&
hands.ActiveHandEntity is { } held)
{
if (EntityManager.TryGetComponent(held, out melee))
using Content.Shared.Interaction.Events;
using Content.Shared.Popups;
using Content.Shared.Projectiles;
+using Content.Shared.Tag;
using Content.Shared.Throwing;
using Content.Shared.Verbs;
using Content.Shared.Weapons.Ranged.Components;
using Content.Shared.Weapons.Ranged.Events;
-using Content.Shared.Tag;
using Robust.Shared.Audio;
using Robust.Shared.Containers;
using Robust.Shared.GameStates;
using Robust.Shared.Map;
using Robust.Shared.Network;
-using Robust.Shared.Physics.Systems;
using Robust.Shared.Physics.Components;
+using Robust.Shared.Physics.Systems;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Robust.Shared.Serialization;
if (!_combatMode.IsInCombatMode(entity))
return false;
- if (EntityManager.TryGetComponent(entity, out SharedHandsComponent? hands) &&
+ if (EntityManager.TryGetComponent(entity, out HandsComponent? hands) &&
hands.ActiveHandEntity is { } held &&
TryComp(held, out GunComponent? gun))
{
+using System.Diagnostics.CodeAnalysis;
using Content.Shared.Audio;
-using Content.Shared.Popups;
-using Robust.Shared.Random;
-using Robust.Shared.Physics.Systems;
using Content.Shared.Hands.Components;
-using Robust.Shared.GameStates;
-using Content.Shared.Weapons.Ranged.Events;
-using System.Diagnostics.CodeAnalysis;
+using Content.Shared.Popups;
using Content.Shared.Projectiles;
+using Content.Shared.Weapons.Ranged.Events;
+using Robust.Shared.GameStates;
+using Robust.Shared.Physics.Systems;
+using Robust.Shared.Random;
namespace Content.Shared.Weapons.Reflect;
public override void Initialize()
{
base.Initialize();
- SubscribeLocalEvent<SharedHandsComponent, ProjectileReflectAttemptEvent>(OnHandReflectProjectile);
- SubscribeLocalEvent<SharedHandsComponent, HitScanReflectAttemptEvent>(OnHandsReflectHitscan);
+ SubscribeLocalEvent<HandsComponent, ProjectileReflectAttemptEvent>(OnHandReflectProjectile);
+ SubscribeLocalEvent<HandsComponent, HitScanReflectAttemptEvent>(OnHandsReflectHitscan);
SubscribeLocalEvent<ReflectComponent, ComponentHandleState>(OnHandleState);
SubscribeLocalEvent<ReflectComponent, ComponentGetState>(OnGetState);
args.State = new ReflectComponentState(component.Enabled, component.EnergeticChance, component.KineticChance, component.Spread);
}
- private void OnHandReflectProjectile(EntityUid uid, SharedHandsComponent hands, ref ProjectileReflectAttemptEvent args)
+ private void OnHandReflectProjectile(EntityUid uid, HandsComponent hands, ref ProjectileReflectAttemptEvent args)
{
if (args.Cancelled)
return;
return false;
}
- private void OnHandsReflectHitscan(EntityUid uid, SharedHandsComponent hands, ref HitScanReflectAttemptEvent args)
+ private void OnHandsReflectHitscan(EntityUid uid, HandsComponent hands, ref HitScanReflectAttemptEvent args)
{
if (args.Reflected)
return;
projects / space-station-14.git / commitdiff