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

Verb predict (#5638)

Browse Source
This commit is contained in:
Leon Friedrich
2021-12-16 23:42:02 +13:00
committed by GitHub
parent 2e141347ed
commit 7e49b22a74
40 changed files with 551 additions and 395 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Content.Client/Access/IdCardConsoleSystem.cs
View File

@@ -1,4 +1,4 @@
using Content.Shared.Access;
using Content.Shared.Access.Systems;
using JetBrains.Annotations;
namespace Content.Client.Access

3
Content.Client/Access/UI/IdCardConsoleBoundUserInterface.cs
View File

@@ -1,10 +1,9 @@
using System.Collections.Generic;
using Content.Shared.Access;
using Robust.Client.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Prototypes;
using static Content.Shared.Access.SharedIdCardConsoleComponent;
using static Content.Shared.Access.Components.SharedIdCardConsoleComponent;
namespace Content.Client.Access.UI
{

2
Content.Client/Access/UI/IdCardConsoleWindow.xaml.cs
View File

@@ -8,7 +8,7 @@ using Robust.Client.UserInterface.XAML;
using Robust.Shared.Localization;
using Robust.Shared.Maths;
using Robust.Shared.Prototypes;
using static Content.Shared.Access.SharedIdCardConsoleComponent;
using static Content.Shared.Access.Components.SharedIdCardConsoleComponent;
namespace Content.Client.Access.UI
{

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

@@ -46,7 +46,6 @@ namespace Content.Client.Entry
"ResearchServer",
"ResearchPointSource",
"ResearchClient",
"IdCard",
"Access",
"AccessReader",
"IdCardConsole",
@@ -155,7 +154,6 @@ namespace Content.Client.Entry
"RefillableSolution",
"DrainableSolution",
"ExaminableSolution",
"FitsInDispenser",
"DrawableSolution",
"InjectableSolution",
"Barotrauma",
@@ -295,7 +293,6 @@ namespace Content.Client.Entry
"BatteryCharger",
"UnpoweredFlashlight",
"Uplink",
"PDA",
"SpawnItemsOnUse",
"AmbientOnPowered",
"Wieldable",

2
Content.Client/Items/Managers/ItemSlotManager.cs
View File

@@ -80,7 +80,7 @@ namespace Content.Client.Items.Managers
}
else if (args.Function == ContentKeyFunctions.AltActivateItemInWorld)
{
_entityManager.EntityNetManager?.SendSystemNetworkMessage(new InteractInventorySlotEvent(item, altInteract: true));
_entityManager.RaisePredictiveEvent(new InteractInventorySlotEvent(item, altInteract: true));
}
else
{

10
Content.Client/PDA/PDASystem.cs Normal file
View File

@@ -0,0 +1,10 @@
using Content.Shared.PDA;
using Robust.Shared.GameObjects;
namespace Content.Client.PDA
{
public sealed class PDASystem : SharedPDASystem
{
// Nothing here. Have a lovely day.
}
}

42
Content.Client/Verbs/VerbSystem.cs
View File

@@ -192,27 +192,43 @@ namespace Content.Client.Verbs
/// Execute actions associated with the given verb.
/// </summary>
/// <remarks>
/// Unless this is a client-exclusive verb, this will also tell the server to run the same verb. However, if the verb
/// is disabled and has a tooltip, this function will only generate a pop-up-message instead of executing anything.
/// Unless this is a client-exclusive verb, this will also tell the server to run the same verb.
/// </remarks>
public void ExecuteVerb(EntityUid target, Verb verb, VerbType verbType)
{
if (verb.Disabled)
{
if (verb.Message != null)
_popupSystem.PopupCursor(verb.Message);
return;
}
var user = _playerManager.LocalPlayer?.ControlledEntity;
if (user == null)
return;
ExecuteVerb(verb, user.Value, target);
if (!verb.ClientExclusive)
// is this verb actually valid?
if (verb.Disabled)
{
RaiseNetworkEvent(new ExecuteVerbEvent(target, verb, verbType));
// maybe send an informative pop-up message.
if (!string.IsNullOrWhiteSpace(verb.Message))
_popupSystem.PopupEntity(verb.Message, user.Value);
return;
}
if (verb.ClientExclusive)
// is this a client exclusive (gui) verb?
ExecuteVerb(verb, user.Value, target);
else
EntityManager.RaisePredictiveEvent(new ExecuteVerbEvent(target, verb, verbType));
}
public override void ExecuteVerb(Verb verb, EntityUid user, EntityUid target, bool forced = false)
{
// invoke any relevant actions
verb.Act?.Invoke();
// Maybe raise a local event
if (verb.ExecutionEventArgs != null)
{
if (verb.EventTarget.IsValid())
RaiseLocalEvent(verb.EventTarget, verb.ExecutionEventArgs);
else
RaiseLocalEvent(verb.ExecutionEventArgs);
}
}

5
Content.IntegrationTests/Tests/PDA/PDAExtensionsTests.cs
View File

@@ -1,11 +1,12 @@
using System.Linq;
using System.Threading.Tasks;
using Content.Server.Access.Components;
using Content.Server.Hands.Components;
using Content.Server.Inventory.Components;
using Content.Server.Items;
using Content.Server.PDA;
using Content.Shared.Access.Components;
using Content.Shared.Containers.ItemSlots;
using Content.Shared.PDA;
using NUnit.Framework;
using Robust.Server.Player;
using Robust.Shared.GameObjects;
@@ -78,7 +79,7 @@ namespace Content.IntegrationTests.Tests.PDA
var itemSlots = sEntityManager.GetComponent<ItemSlotsComponent>(dummyPda);
sEntityManager.EntitySysManager.GetEntitySystem<ItemSlotsSystem>()
.TryInsert(dummyPda, pdaComponent.IdSlot, pdaIdCard);
.TryInsert(dummyPda, pdaComponent.IdSlot, pdaIdCard, null);
var pdaContainedId = pdaComponent.ContainedID;
// The PDA in the hand should be found first

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

@@ -4,6 +4,7 @@ using Content.Server.Access.Systems;
using Content.Server.Power.Components;
using Content.Server.UserInterface;
using Content.Shared.Access;
using Content.Shared.Access.Components;
using Content.Shared.Containers.ItemSlots;
using Robust.Server.GameObjects;
using Robust.Shared.GameObjects;
@@ -115,6 +116,9 @@ namespace Content.Server.Access.Components
public void UpdateUserInterface()
{
if (!Initialized)
return;
IdCardConsoleBoundUserInterfaceState newState;
// this could be prettier
if (TargetIdSlot.Item is not {Valid: true} targetIdEntity)

2
Content.Server/Access/Systems/AccessReaderSystem.cs
View File

@@ -5,10 +5,10 @@ using System.Linq;
using Content.Server.Access.Components;
using Content.Server.Inventory.Components;
using Content.Server.Items;
using Content.Server.PDA;
using Content.Shared.Access;
using Content.Shared.Hands.Components;
using Content.Shared.Inventory;
using Content.Shared.PDA;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Log;

2
Content.Server/Access/Systems/IdCardConsoleSystem.cs
View File

@@ -1,5 +1,5 @@
using Content.Server.Access.Components;
using Content.Shared.Access;
using Content.Shared.Access.Systems;
using JetBrains.Annotations;
using Robust.Shared.Containers;
using Robust.Shared.GameObjects;

9
Content.Server/Access/Systems/IdCardSystem.cs
View File

@@ -1,18 +1,17 @@
using Content.Server.Access.Components;
using Content.Server.Inventory.Components;
using Content.Server.Items;
using Content.Server.PDA;
using Content.Shared.Access;
using Content.Shared.Hands.Components;
using Content.Shared.Inventory;
using Content.Shared.PDA;
using Robust.Shared.GameObjects;
using Robust.Shared.Localization;
using System.Diagnostics.CodeAnalysis;
using Robust.Shared.IoC;
using Content.Shared.Access.Components;
using Content.Shared.Access.Systems;
namespace Content.Server.Access.Systems
{
public class IdCardSystem : EntitySystem
public class IdCardSystem : SharedIdCardSystem
{
public override void Initialize()
{

2
Content.Server/Administration/Commands/SetOutfitCommand.cs
View File

@@ -2,10 +2,10 @@ using Content.Server.Administration.UI;
using Content.Server.EUI;
using Content.Server.Inventory.Components;
using Content.Server.Items;
using Content.Server.PDA;
using Content.Server.Preferences.Managers;
using Content.Shared.Administration;
using Content.Shared.Inventory;
using Content.Shared.PDA;
using Content.Shared.Preferences;
using Content.Shared.Roles;
using Robust.Server.GameObjects;

2
Content.Server/Cabinet/ItemCabinetSystem.cs
View File

@@ -59,6 +59,8 @@ namespace Content.Server.Cabinet
private void OnContainerModified(EntityUid uid, ItemCabinetComponent cabinet, ContainerModifiedMessage args)
{
if (!cabinet.Initialized) return;
if (args.Container.ID == cabinet.CabinetSlot.ID)
UpdateAppearance(uid, cabinet);
}

2
Content.Server/Cargo/Components/CargoTelepadComponent.cs
View File

@@ -142,7 +142,7 @@ namespace Content.Server.Cargo.Components
// attempt to attach the label
if (_entMan.TryGetComponent(product, out PaperLabelComponent label))
{
EntitySystem.Get<ItemSlotsSystem>().TryInsert(Owner, label.LabelSlot, printed);
EntitySystem.Get<ItemSlotsSystem>().TryInsert(Owner, label.LabelSlot, printed, null);
}
}

2
Content.Server/Chemistry/Components/ChemMasterComponent.cs
View File

@@ -197,6 +197,8 @@ namespace Content.Server.Chemistry.Components
public void UpdateUserInterface()
{
if (!Initialized) return;
var state = GetUserInterfaceState();
UserInterface?.SetState(state);
}

2
Content.Server/Chemistry/Components/ReagentDispenserComponent.cs
View File

@@ -241,6 +241,8 @@ namespace Content.Server.Chemistry.Components
public void UpdateUserInterface()
{
if (!Initialized) return;
var state = GetUserInterfaceState();
UserInterface?.SetState(state);
}

1
Content.Server/Chemistry/Components/TransformableContainerComponent.cs
View File

@@ -1,4 +1,5 @@
using Content.Server.Chemistry.Components.SolutionManager;
using Content.Shared.Chemistry.Components;
using Content.Shared.Chemistry.Reagent;
using Robust.Server.GameObjects;
using Robust.Shared.GameObjects;

2
Content.Server/Chemistry/EntitySystems/HypospraySystem.cs
View File

@@ -1,4 +1,4 @@
using Content.Server.Chemistry.Components;
using Content.Server.Chemistry.Components;
using Content.Shared.Interaction;
using Content.Shared.Weapons.Melee;
using JetBrains.Annotations;

1
Content.Server/GameTicking/GameTicker.Spawning.cs
View File

@@ -21,6 +21,7 @@ using Content.Shared.Database;
using Content.Shared.GameTicking;
using Content.Shared.Ghost;
using Content.Shared.Inventory;
using Content.Shared.PDA;
using Content.Shared.Preferences;
using Content.Shared.Roles;
using Content.Shared.Station;

1
Content.Server/GameTicking/Presets/PresetTraitorDeathMatch.cs
View File

@@ -20,6 +20,7 @@ using Content.Shared.Damage;
using Content.Shared.Damage.Prototypes;
using Content.Shared.Inventory;
using Content.Shared.MobState.Components;
using Content.Shared.PDA;
using Content.Shared.Traitor.Uplink;
using Robust.Server.Player;
using Robust.Shared.Configuration;

194
Content.Server/Interaction/InteractionSystem.cs
View File

@@ -41,19 +41,17 @@ namespace Content.Server.Interaction
{
[Dependency] private readonly ActionBlockerSystem _actionBlockerSystem = default!;
[Dependency] private readonly PullingSystem _pullSystem = default!;
[Dependency] private readonly RotateToFaceSystem _rotateToFaceSystem = default!;
[Dependency] private readonly AdminLogSystem _adminLogSystem = default!;
public override void Initialize()
{
base.Initialize();
SubscribeNetworkEvent<DragDropRequestEvent>(HandleDragDropRequestEvent);
SubscribeNetworkEvent<InteractInventorySlotEvent>(HandleInteractInventorySlotEvent);
CommandBinds.Builder
.Bind(EngineKeyFunctions.Use,
new PointerInputCmdHandler(HandleUseInteraction))
.Bind(ContentKeyFunctions.AltActivateItemInWorld,
new PointerInputCmdHandler(HandleAltUseInteraction))
.Bind(ContentKeyFunctions.WideAttack,
new PointerInputCmdHandler(HandleWideAttack))
.Bind(ContentKeyFunctions.ActivateItemInWorld,
@@ -69,36 +67,6 @@ namespace Content.Server.Interaction
base.Shutdown();
}
#region Client Input Validation
private bool ValidateClientInput(ICommonSession? session, EntityCoordinates coords, EntityUid uid, [NotNullWhen(true)] out EntityUid? userEntity)
{
userEntity = null;
if (!coords.IsValid(EntityManager))
{
Logger.InfoS("system.interaction", $"Invalid Coordinates: client={session}, coords={coords}");
return false;
}
if (uid.IsClientSide())
{
Logger.WarningS("system.interaction",
$"Client sent interaction with client-side entity. Session={session}, Uid={uid}");
return false;
}
userEntity = ((IPlayerSession?) session)?.AttachedEntity;
if (userEntity == null || !userEntity.Value.IsValid())
{
Logger.WarningS("system.interaction",
$"Client sent interaction with no attached entity. Session={session}");
return false;
}
return true;
}
public override bool CanAccessViaStorage(EntityUid user, EntityUid target)
{
if (Deleted(target))
@@ -119,37 +87,6 @@ namespace Content.Server.Interaction
// we don't check if the user can access the storage entity itself. This should be handed by the UI system.
return storage.SubscribedSessions.Contains(actor.PlayerSession);
}
#endregion
/// <summary>
/// Handles the event were a client uses an item in their inventory or in their hands, either by
/// alt-clicking it or pressing 'E' while hovering over it.
/// </summary>
private void HandleInteractInventorySlotEvent(InteractInventorySlotEvent msg, EntitySessionEventArgs args)
{
if (Deleted(msg.ItemUid))
{
Logger.WarningS("system.interaction",
$"Client sent inventory interaction with an invalid target item. Session={args.SenderSession}");
return;
}
var itemCoords = Transform(msg.ItemUid).Coordinates;
// client sanitization
if (!ValidateClientInput(args.SenderSession, itemCoords, msg.ItemUid, out var userEntity))
{
Logger.InfoS("system.interaction", $"Inventory interaction validation failed. Session={args.SenderSession}");
return;
}
if (msg.AltInteract)
// Use 'UserInteraction' function - behaves as if the user alt-clicked the item in the world.
UserInteraction(userEntity.Value, itemCoords, msg.ItemUid, msg.AltInteract);
else
// User used 'E'. We want to activate it, not simulate clicking on the item
InteractionActivate(userEntity.Value, msg.ItemUid);
}
#region Drag drop
private void HandleDragDropRequestEvent(DragDropRequestEvent msg, EntitySessionEventArgs args)
@@ -258,20 +195,6 @@ namespace Content.Server.Interaction
return true;
}
public bool HandleAltUseInteraction(ICommonSession? session, EntityCoordinates coords, EntityUid uid)
{
// client sanitization
if (!ValidateClientInput(session, coords, uid, out var userEntity))
{
Logger.InfoS("system.interaction", $"Alt-use input validation failed");
return true;
}
UserInteraction(userEntity.Value, coords, !Deleted(uid) ? uid : null, altInteract : true );
return true;
}
private bool HandleTryPullObject(ICommonSession? session, EntityCoordinates coords, EntityUid uid)
{
if (!ValidateClientInput(session, coords, uid, out var userEntity))
@@ -295,97 +218,14 @@ namespace Content.Server.Interaction
return _pullSystem.TogglePull(userEntity.Value, pull);
}
/// <summary>
/// Resolves user interactions with objects.
/// </summary>
/// <remarks>
/// Checks Whether combat mode is enabled and whether the user can actually interact with the given entity.
/// </remarks>
/// <param name="altInteract">Whether to use default or alternative interactions (usually as a result of
/// alt+clicking). If combat mode is enabled, the alternative action is to perform the default non-combat
/// interaction. Having an item in the active hand also disables alternative interactions.</param>
public async void UserInteraction(EntityUid user, EntityCoordinates coordinates, EntityUid? target, bool altInteract = false)
{
// TODO COMBAT Consider using alt-interact for advanced combat? maybe alt-interact disarms?
if (!altInteract && TryComp(user, out CombatModeComponent? combatMode) && combatMode.IsInCombatMode)
{
DoAttack(user, coordinates, false, target);
return;
}
if (!ValidateInteractAndFace(user, coordinates))
return;
if (!_actionBlockerSystem.CanInteract(user))
return;
// Check if interacted entity is in the same container, the direct child, or direct parent of the user.
// This is bypassed IF the interaction happened through an item slot (e.g., backpack UI)
if (target != null && !Deleted(target.Value) && !user.IsInSameOrParentContainer(target.Value) && !CanAccessViaStorage(user, target.Value))
{
Logger.WarningS("system.interaction",
$"User entity {ToPrettyString(user):user} clicked on object {ToPrettyString(target.Value):target} that isn't the parent, child, or in the same container");
return;
}
// Verify user has a hand, and find what object they are currently holding in their active hand
if (!TryComp(user, out HandsComponent? hands))
return;
var item = hands.GetActiveHand?.Owner;
// TODO: Replace with body interaction range when we get something like arm length or telekinesis or something.
var inRangeUnobstructed = user.InRangeUnobstructed(coordinates, ignoreInsideBlocker: true);
if (target == null || Deleted(target.Value) || !inRangeUnobstructed)
{
if (item == null)
return;
if (!await InteractUsingRanged(user, item.Value, target, coordinates, inRangeUnobstructed) &&
!inRangeUnobstructed)
{
var message = Loc.GetString("interaction-system-user-interaction-cannot-reach");
user.PopupMessage(message);
}
return;
}
// We are close to the nearby object.
if (altInteract)
// Perform alternative interactions, using context menu verbs.
AltInteract(user, target.Value);
else if (item != null && item != target)
// We are performing a standard interaction with an item, and the target isn't the same as the item
// currently in our hand. We will use the item in our hand on the nearby object via InteractUsing
await InteractUsing(user, item.Value, target.Value, coordinates);
else if (item == null)
// Since our hand is empty we will use InteractHand/Activate
InteractHand(user, target.Value);
}
private bool ValidateInteractAndFace(EntityUid user, EntityCoordinates coordinates)
{
// Verify user is on the same map as the entity they clicked on
if (coordinates.GetMapId(EntityManager) != Transform(user).MapID)
{
Logger.WarningS("system.interaction",
$"User entity {ToPrettyString(user):user} clicked on a map they aren't located on");
return false;
}
_rotateToFaceSystem.TryFaceCoordinates(user, coordinates.ToMapPos(EntityManager));
return true;
}
/// <summary>
/// Uses an empty hand on an entity
/// Finds components with the InteractHand interface and calls their function
/// NOTE: Does not have an InRangeUnobstructed check
/// </summary>
public void InteractHand(EntityUid user, EntityUid target)
public override void InteractHand(EntityUid user, EntityUid target)
{
// TODO PREDICTION move server-side interaction logic into the shared system for interaction prediction.
if (!_actionBlockerSystem.CanInteract(user))
return;
@@ -416,8 +256,9 @@ namespace Content.Server.Interaction
/// Will have two behaviors, either "uses" the used entity at range on the target entity if it is capable of accepting that action
/// Or it will use the used entity itself on the position clicked, regardless of what was there
/// </summary>
public async Task<bool> InteractUsingRanged(EntityUid user, EntityUid used, EntityUid? target, EntityCoordinates clickLocation, bool inRangeUnobstructed)
public override async Task<bool> InteractUsingRanged(EntityUid user, EntityUid used, EntityUid? target, EntityCoordinates clickLocation, bool inRangeUnobstructed)
{
// TODO PREDICTION move server-side interaction logic into the shared system for interaction prediction.
if (InteractDoBefore(user, used, inRangeUnobstructed ? target : null, clickLocation, false))
return true;
@@ -445,8 +286,9 @@ namespace Content.Server.Interaction
return await InteractDoAfter(user, used, inRangeUnobstructed ? target : null, clickLocation, false);
}
public void DoAttack(EntityUid user, EntityCoordinates coordinates, bool wideAttack, EntityUid? targetUid = null)
public override void DoAttack(EntityUid user, EntityCoordinates coordinates, bool wideAttack, EntityUid? target = null)
{
// TODO PREDICTION move server-side interaction logic into the shared system for interaction prediction.
if (!ValidateInteractAndFace(user, coordinates))
return;
@@ -456,10 +298,10 @@ namespace Content.Server.Interaction
if (!wideAttack)
{
// Check if interacted entity is in the same container, the direct child, or direct parent of the user.
if (targetUid != null && !Deleted(targetUid.Value) && !user.IsInSameOrParentContainer(targetUid.Value) && !CanAccessViaStorage(user, targetUid.Value))
if (target != null && !Deleted(target.Value) && !user.IsInSameOrParentContainer(target.Value) && !CanAccessViaStorage(user, target.Value))
{
Logger.WarningS("system.interaction",
$"User entity {ToPrettyString(user):user} clicked on object {ToPrettyString(targetUid.Value):target} that isn't the parent, child, or in the same container");
$"User entity {ToPrettyString(user):user} clicked on object {ToPrettyString(target.Value):target} that isn't the parent, child, or in the same container");
return;
}
@@ -488,15 +330,15 @@ namespace Content.Server.Interaction
}
else
{
var ev = new ClickAttackEvent(item.Value, user, coordinates, targetUid);
var ev = new ClickAttackEvent(item.Value, user, coordinates, target);
RaiseLocalEvent(item.Value, ev, false);
if (ev.Handled)
{
if (targetUid != null)
if (target != null)
{
_adminLogSystem.Add(LogType.AttackArmedClick, LogImpact.Medium,
$"{ToPrettyString(user):user} attacked {ToPrettyString(targetUid.Value):target} with {ToPrettyString(item.Value):used} at {coordinates}");
$"{ToPrettyString(user):user} attacked {ToPrettyString(target.Value):target} with {ToPrettyString(item.Value):used} at {coordinates}");
}
else
{
@@ -508,10 +350,10 @@ namespace Content.Server.Interaction
}
}
}
else if (!wideAttack && targetUid != null && HasComp<ItemComponent>(targetUid.Value))
else if (!wideAttack && target != null && HasComp<ItemComponent>(target.Value))
{
// We pick up items if our hand is empty, even if we're in combat mode.
InteractHand(user, targetUid.Value);
InteractHand(user, target.Value);
return;
}
}
@@ -527,14 +369,14 @@ namespace Content.Server.Interaction
}
else
{
var ev = new ClickAttackEvent(user, user, coordinates, targetUid);
var ev = new ClickAttackEvent(user, user, coordinates, target);
RaiseLocalEvent(user, ev, false);
if (ev.Handled)
{
if (targetUid != null)
if (target != null)
{
_adminLogSystem.Add(LogType.AttackUnarmedClick, LogImpact.Medium,
$"{ToPrettyString(user):user} attacked {ToPrettyString(targetUid.Value):target} at {coordinates}");
$"{ToPrettyString(user):user} attacked {ToPrettyString(target.Value):target} at {coordinates}");
}
else
{

3
Content.Server/Labels/Label/LabelSystem.cs
View File

@@ -85,9 +85,10 @@ namespace Content.Server.Labels
args.PushMarkup(text.TrimEnd());
}
private void OnContainerModified(EntityUid uid, PaperLabelComponent label, ContainerModifiedMessage args)
{
if (!label.Initialized) return;
if (args.Container.ID != label.LabelSlot.ID)
return;

5
Content.Server/Nuke/NukeSystem.cs
View File

@@ -62,6 +62,9 @@ namespace Content.Server.Nuke
{
component.RemainingTime = component.Timer;
_itemSlots.AddItemSlot(uid, component.Name, component.DiskSlot);
UpdateStatus(uid, component);
UpdateUserInterface(uid, component);
}
public override void Update(float frameTime)
@@ -101,6 +104,8 @@ namespace Content.Server.Nuke
private void OnItemSlotChanged(EntityUid uid, NukeComponent component, ContainerModifiedMessage args)
{
if (!component.Initialized) return;
if (args.Container.ID != component.DiskSlot.ID)
return;

5
Content.Server/PDA/PDAExtensions.cs
View File

@@ -1,7 +1,8 @@
using System.Diagnostics.CodeAnalysis;
using Content.Server.Access.Components;
using System.Diagnostics.CodeAnalysis;
using Content.Server.Hands.Components;
using Content.Server.Inventory.Components;
using Content.Shared.Access.Components;
using Content.Shared.PDA;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;

45
Content.Server/PDA/PDASystem.cs
View File

@@ -1,4 +1,3 @@
using Content.Server.Access.Components;
using Content.Server.Light.Components;
using Content.Server.Light.EntitySystems;
using Content.Server.Light.Events;
@@ -15,9 +14,8 @@ using Robust.Shared.IoC;
namespace Content.Server.PDA
{
public class PDASystem : EntitySystem
public sealed class PDASystem : SharedPDASystem
{
[Dependency] private readonly ItemSlotsSystem _itemSlotsSystem = default!;
[Dependency] private readonly UplinkSystem _uplinkSystem = default!;
[Dependency] private readonly UnpoweredFlashlightSystem _unpoweredFlashlight = default!;
@@ -25,36 +23,21 @@ namespace Content.Server.PDA
{
base.Initialize();
SubscribeLocalEvent<PDAComponent, ComponentInit>(OnComponentInit);
SubscribeLocalEvent<PDAComponent, ComponentRemove>(OnComponentRemove);
SubscribeLocalEvent<PDAComponent, ActivateInWorldEvent>(OnActivateInWorld);
SubscribeLocalEvent<PDAComponent, UseInHandEvent>(OnUse);
SubscribeLocalEvent<PDAComponent, EntInsertedIntoContainerMessage>(OnItemInserted);
SubscribeLocalEvent<PDAComponent, EntRemovedFromContainerMessage>(OnItemRemoved);
SubscribeLocalEvent<PDAComponent, LightToggleEvent>(OnLightToggle);
SubscribeLocalEvent<PDAComponent, UplinkInitEvent>(OnUplinkInit);
SubscribeLocalEvent<PDAComponent, UplinkRemovedEvent>(OnUplinkRemoved);
}
private void OnComponentInit(EntityUid uid, PDAComponent pda, ComponentInit args)
protected override void OnComponentInit(EntityUid uid, PDAComponent pda, ComponentInit args)
{
base.OnComponentInit(uid, pda, args);
var ui = pda.Owner.GetUIOrNull(PDAUiKey.Key);
if (ui != null)
ui.OnReceiveMessage += (msg) => OnUIMessage(pda, msg);
if (pda.IdCard != null)
pda.IdSlot.StartingItem = pda.IdCard;
_itemSlotsSystem.AddItemSlot(uid, $"{pda.Name}-id", pda.IdSlot);
_itemSlotsSystem.AddItemSlot(uid, $"{pda.Name}-pen", pda.PenSlot);
}
private void OnComponentRemove(EntityUid uid, PDAComponent pda, ComponentRemove args)
{
_itemSlotsSystem.RemoveItemSlot(uid, pda.IdSlot);
_itemSlotsSystem.RemoveItemSlot(uid, pda.PenSlot);
}
private void OnUse(EntityUid uid, PDAComponent pda, UseInHandEvent args)
{
@@ -70,21 +53,15 @@ namespace Content.Server.PDA
args.Handled = OpenUI(pda, args.User);
}
private void OnItemInserted(EntityUid uid, PDAComponent pda, EntInsertedIntoContainerMessage args)
protected override void OnItemInserted(EntityUid uid, PDAComponent pda, EntInsertedIntoContainerMessage args)
{
if (args.Container.ID == pda.IdSlot.ID)
pda.ContainedID = EntityManager.GetComponentOrNull<IdCardComponent>(args.Entity);
UpdatePDAAppearance(pda);
base.OnItemInserted(uid, pda, args);
UpdatePDAUserInterface(pda);
}
private void OnItemRemoved(EntityUid uid, PDAComponent pda, EntRemovedFromContainerMessage args)
protected override void OnItemRemoved(EntityUid uid, PDAComponent pda, EntRemovedFromContainerMessage args)
{
if (args.Container.ID == pda.IdSlot.ID)
pda.ContainedID = null;
UpdatePDAAppearance(pda);
base.OnItemRemoved(uid, pda, args);
UpdatePDAUserInterface(pda);
}
@@ -162,12 +139,12 @@ namespace Content.Server.PDA
case PDAEjectIDMessage _:
{
_itemSlotsSystem.TryEjectToHands(pda.Owner, pda.IdSlot, playerUid);
ItemSlotsSystem.TryEjectToHands(pda.Owner, pda.IdSlot, playerUid);
break;
}
case PDAEjectPenMessage _:
{
_itemSlotsSystem.TryEjectToHands(pda.Owner, pda.PenSlot, playerUid);
ItemSlotsSystem.TryEjectToHands(pda.Owner, pda.PenSlot, playerUid);
break;
}
case PDAShowUplinkMessage _:

5
Content.Server/Sandbox/SandboxManager.cs
View File

@@ -5,9 +5,10 @@ using Content.Server.GameTicking;
using Content.Server.Hands.Components;
using Content.Server.Inventory.Components;
using Content.Server.Items;
using Content.Server.PDA;
using Content.Shared.Access;
using Content.Shared.Access.Components;
using Content.Shared.Containers.ItemSlots;
using Content.Shared.PDA;
using Content.Shared.Sandbox;
using Robust.Server.Console;
using Robust.Server.GameObjects;
@@ -139,7 +140,7 @@ namespace Content.Server.Sandbox
if (_entityManager.TryGetComponent(pda.Owner, out ItemSlotsComponent? itemSlots))
{
_entityManager.EntitySysManager.GetEntitySystem<ItemSlotsSystem>().
TryInsert(wornItem.Owner, pda.IdSlot, newID);
TryInsert(wornItem.Owner, pda.IdSlot, newID, null);
}
}
else

2
Content.Server/Traitor/Uplink/UplinkSystem.cs
View File

@@ -2,13 +2,13 @@ using System.Linq;
using Content.Server.Hands.Components;
using Content.Server.Inventory.Components;
using Content.Server.Items;
using Content.Server.PDA;
using Content.Server.Traitor.Uplink.Account;
using Content.Server.Traitor.Uplink.Components;
using Content.Server.UserInterface;
using Content.Shared.ActionBlocker;
using Content.Shared.Hands.Components;
using Content.Shared.Interaction;
using Content.Shared.PDA;
using Content.Shared.Traitor.Uplink;
using Robust.Server.GameObjects;
using Robust.Server.Player;

110
Content.Server/Verbs/VerbSystem.cs
View File

@@ -1,53 +1,26 @@
using Content.Server.Popups;
using Content.Shared.Administration.Logs;
using Content.Shared.Database;
using Content.Shared.Hands.Components;
using Content.Shared.Verbs;
using Robust.Server.Player;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Log;
using Robust.Shared.Player;
namespace Content.Server.Verbs
{
public sealed class VerbSystem : SharedVerbSystem
{
[Dependency] private readonly SharedAdminLogSystem _logSystem = default!;
[Dependency] private readonly PopupSystem _popupSystem = default!;
public override void Initialize()
{
base.Initialize();
SubscribeNetworkEvent<RequestServerVerbsEvent>(HandleVerbRequest);
SubscribeNetworkEvent<ExecuteVerbEvent>(HandleTryExecuteVerb);
}
/// <summary>
/// Called when asked over the network to run a given verb.
/// </summary>
public void HandleTryExecuteVerb(ExecuteVerbEvent args, EntitySessionEventArgs eventArgs)
{
var session = eventArgs.SenderSession;
if (session.AttachedEntity is not {} userEntity)
{
Logger.Warning($"{nameof(HandleTryExecuteVerb)} called by player {session} with no attached entity.");
return;
}
if (!EntityManager.EntityExists(args.Target))
{
return;
}
// Get the list of verbs. This effectively also checks that the requested verb is in fact a valid verb that
// the user can perform.
var verbs = GetLocalVerbs(args.Target, userEntity, args.Type)[args.Type];
// Note that GetLocalVerbs might waste time checking & preparing unrelated verbs even though we know
// precisely which one we want to run. However, MOST entities will only have 1 or 2 verbs of a given type.
// The one exception here is the "other" verb type, which has 3-4 verbs + all the debug verbs.
// Find the requested verb.
if (verbs.TryGetValue(args.RequestedVerb, out var verb))
ExecuteVerb(verb, userEntity, args.Target);
else
// 404 Verb not found. Note that this could happen due to something as simple as opening the verb menu, walking away, then trying
// to run the pickup-item verb. So maybe this shouldn't even be logged?
Logger.Info($"{nameof(HandleTryExecuteVerb)} called by player {session} with an invalid verb: {args.RequestedVerb.Category?.Text} {args.RequestedVerb.Text}");
}
private void HandleVerbRequest(RequestServerVerbsEvent args, EntitySessionEventArgs eventArgs)
@@ -73,5 +46,70 @@ namespace Content.Server.Verbs
var response = new VerbsResponseEvent(args.EntityUid, GetLocalVerbs(args.EntityUid, attached, args.Type));
RaiseNetworkEvent(response, player.ConnectedClient);
}
/// <summary>
/// Execute the provided verb.
/// </summary>
/// <remarks>
/// This will try to call the action delegates and raise the local events for the given verb.
/// </remarks>
public override void ExecuteVerb(Verb verb, EntityUid user, EntityUid target, bool forced = false)
{
// is this verb actually valid?
if (verb.Disabled)
{
// Send an informative pop-up message
if (!string.IsNullOrWhiteSpace(verb.Message))
_popupSystem.PopupEntity(verb.Message, user, Filter.Entities(user));
return;
}
// first, lets log the verb. Just in case it ends up crashing the server or something.
LogVerb(verb, user, target, forced);
// then invoke any relevant actions
verb.Act?.Invoke();
// Maybe raise a local event
if (verb.ExecutionEventArgs != null)
{
if (verb.EventTarget.IsValid())
RaiseLocalEvent(verb.EventTarget, verb.ExecutionEventArgs);
else
RaiseLocalEvent(verb.ExecutionEventArgs);
}
}
public void LogVerb(Verb verb, EntityUid user, EntityUid target, bool forced)
{
// first get the held item. again.
EntityUid? holding = null;
if (TryComp(user, out SharedHandsComponent? hands) &&
hands.TryGetActiveHeldEntity(out var heldEntity))
{
holding = heldEntity;
}
// if this is a virtual pull, get the held entity
if (holding != null && TryComp(holding, out HandVirtualItemComponent? pull))
holding = pull.BlockingEntity;
var verbText = $"{verb.Category?.Text} {verb.Text}".Trim();
// lets not frame people, eh?
var executionText = forced ? "was forced to execute" : "executed";
if (holding == null)
{
_logSystem.Add(LogType.Verb, verb.Impact,
$"{ToPrettyString(user):user} {executionText} the [{verbText:verb}] verb targeting {ToPrettyString(target):target}");
}
else
{
_logSystem.Add(LogType.Verb, verb.Impact,
$"{ToPrettyString(user):user} {executionText} the [{verbText:verb}] verb targeting {ToPrettyString(target):target} while holding {ToPrettyString(holding.Value):held}");
}
}
}
}

10
Content.Server/Access/Components/IdCardComponent.cs → Content.Shared/Access/Components/IdCardComponent.cs
View File

@@ -1,13 +1,15 @@
using Content.Server.Access.Systems;
using Content.Server.PDA;
using Content.Shared.Access.Systems;
using Content.Shared.PDA;
using Robust.Shared.Analyzers;
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Access.Components
namespace Content.Shared.Access.Components
{
// TODO BUI NETWORKING if ever clients can open their own BUI's (id card console, pda), then this data should be
// networked.
[RegisterComponent]
[Friend(typeof(IdCardSystem), typeof(PDASystem))]
[Friend(typeof(SharedIdCardSystem), typeof(SharedPDASystem))]
public class IdCardComponent : Component
{
public override string Name => "IdCard";

2
Content.Shared/Access/SharedIdCardConsoleComponent.cs → Content.Shared/Access/Components/SharedIdCardConsoleComponent.cs
View File

@@ -5,7 +5,7 @@ using Robust.Shared.GameObjects;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Shared.Access
namespace Content.Shared.Access.Components
{
public class SharedIdCardConsoleComponent : Component
{

3
Content.Shared/Access/SharedIdCardConsoleSystem.cs → Content.Shared/Access/Systems/SharedIdCardConsoleSystem.cs
View File

@@ -1,9 +1,10 @@
using Content.Shared.Access.Components;
using Content.Shared.Containers.ItemSlots;
using JetBrains.Annotations;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
namespace Content.Shared.Access
namespace Content.Shared.Access.Systems
{
[UsedImplicitly]
public abstract class SharedIdCardConsoleSystem : EntitySystem

8
Content.Shared/Access/Systems/SharedIdCardSystem.cs Normal file
View File

@@ -0,0 +1,8 @@
using Robust.Shared.GameObjects;
namespace Content.Shared.Access.Systems;
public abstract class SharedIdCardSystem : EntitySystem
{
// this class just exists to make friends. Will you be its friend?
}

8
Content.Server/Chemistry/Components/SolutionManager/FitsInDispenserComponent.cs → Content.Shared/Chemistry/Components/FitsInDispenserComponent.cs
View File

@@ -1,15 +1,17 @@
using Robust.Shared.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.GameStates;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.ViewVariables;
namespace Content.Server.Chemistry.Components.SolutionManager
namespace Content.Shared.Chemistry.Components
{
/// Allows the entity with this component to be placed in a <c>SharedReagentDispenserComponent</c>.
/// <para>Otherwise it's considered to be too large or the improper shape to fit.</para>
/// <para>Allows us to have obscenely large containers that are harder to abuse in chem dispensers
/// since they can't be placed directly in them.</para>
/// <see cref="Content.Shared.Chemistry.Dispenser.SharedReagentDispenserComponent"/>
/// <see cref="Dispenser.SharedReagentDispenserComponent"/>
[RegisterComponent]
[NetworkedComponent] // only needed for white-lists. Client doesn't actually need Solution data;
public class FitsInDispenserComponent : Component
{
public override string Name => "FitsInDispenser";

60
Content.Shared/Containers/ItemSlot/ItemSlotsSystem.cs
View File

@@ -3,6 +3,7 @@ using Content.Shared.Acts;
using Content.Shared.Hands.Components;
using Content.Shared.Interaction;
using Content.Shared.Popups;
using Content.Shared.Sound;
using Content.Shared.Verbs;
using Robust.Shared.Audio;
using Robust.Shared.Containers;
@@ -12,6 +13,7 @@ using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Log;
using Robust.Shared.Player;
using Robust.Shared.Timing;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
@@ -24,6 +26,7 @@ namespace Content.Shared.Containers.ItemSlots
{
[Dependency] private readonly ActionBlockerSystem _actionBlockerSystem = default!;
[Dependency] private readonly SharedPopupSystem _popupSystem = default!;
[Dependency] private readonly IGameTiming _gameTiming = default!;
public override void Initialize()
{
@@ -174,7 +177,7 @@ namespace Content.Shared.Containers.ItemSlots
if (slot.Item != null)
hands.TryPutInAnyHand(slot.Item.Value);
Insert(uid, slot, args.Used);
Insert(uid, slot, args.Used, args.User, true);
args.Handled = true;
return;
}
@@ -186,13 +189,32 @@ namespace Content.Shared.Containers.ItemSlots
/// Insert an item into a slot. This does not perform checks, so make sure to also use <see
/// cref="CanInsert"/> or just use <see cref="TryInsert"/> instead.
/// </summary>
private void Insert(EntityUid uid, ItemSlot slot, EntityUid item)
private void Insert(EntityUid uid, ItemSlot slot, EntityUid item, EntityUid? user, bool userAudio = false)
{
slot.ContainerSlot.Insert(item);
// ContainerSlot automatically raises a directed EntInsertedIntoContainerMessage
if (slot.InsertSound != null)
SoundSystem.Play(Filter.Pvs(uid), slot.InsertSound.GetSound(), uid, slot.SoundOptions);
PlaySound(uid, slot.InsertSound, slot.SoundOptions, userAudio ? null : user);
}
/// <summary>
/// Plays a sound
/// </summary>
/// <param name="uid">Source of the sound</param>
/// <param name="sound">The sound</param>
/// <param name="excluded">Optional (server-side) argument used to prevent sending the audio to a specific
/// user.</param>
private void PlaySound(EntityUid uid, SoundSpecifier? sound, AudioParams audioParams, EntityUid? excluded)
{
if (sound == null || !_gameTiming.IsFirstTimePredicted)
return;
var filter = Filter.Pvs(uid);
if (excluded != null)
filter = filter.RemoveWhereAttachedEntity(entity => entity == excluded.Value);
SoundSystem.Play(filter, sound.GetSound(), uid, audioParams);
}
/// <summary>
@@ -228,7 +250,7 @@ namespace Content.Shared.Containers.ItemSlots
/// Tries to insert item into a specific slot.
/// </summary>
/// <returns>False if failed to insert item</returns>
public bool TryInsert(EntityUid uid, string id, EntityUid item, ItemSlotsComponent? itemSlots = null)
public bool TryInsert(EntityUid uid, string id, EntityUid item, EntityUid? user, ItemSlotsComponent? itemSlots = null)
{
if (!Resolve(uid, ref itemSlots))
return false;
@@ -236,19 +258,19 @@ namespace Content.Shared.Containers.ItemSlots
if (!itemSlots.Slots.TryGetValue(id, out var slot))
return false;
return TryInsert(uid, slot, item);
return TryInsert(uid, slot, item, user);
}
/// <summary>
/// Tries to insert item into a specific slot.
/// </summary>
/// <returns>False if failed to insert item</returns>
public bool TryInsert(EntityUid uid, ItemSlot slot, EntityUid item)
public bool TryInsert(EntityUid uid, ItemSlot slot, EntityUid item, EntityUid? user)
{
if (!CanInsert(uid, item, slot))
return false;
Insert(uid, slot, item);
Insert(uid, slot, item, user);
return true;
}
@@ -271,7 +293,7 @@ namespace Content.Shared.Containers.ItemSlots
if (!_actionBlockerSystem.CanInteract(user) && hands.Drop(item))
return false;
Insert(uid, slot, item);
Insert(uid, slot, item, user);
return true;
}
#endregion
@@ -281,20 +303,19 @@ namespace Content.Shared.Containers.ItemSlots
/// Eject an item into a slot. This does not perform checks (e.g., is the slot locked?), so you should
/// probably just use <see cref="TryEject"/> instead.
/// </summary>
private void Eject(EntityUid uid, ItemSlot slot, EntityUid item)
private void Eject(EntityUid uid, ItemSlot slot, EntityUid item, EntityUid? user)
{
slot.ContainerSlot.Remove(item);
// ContainerSlot automatically raises a directed EntRemovedFromContainerMessage
if (slot.EjectSound != null)
SoundSystem.Play(Filter.Pvs(uid), slot.EjectSound.GetSound(), uid, slot.SoundOptions);
PlaySound(uid, slot.EjectSound, slot.SoundOptions, user);
}
/// <summary>
/// Try to eject an item from a slot.
/// </summary>
/// <returns>False if item slot is locked or has no item inserted</returns>
public bool TryEject(EntityUid uid, ItemSlot slot, [NotNullWhen(true)] out EntityUid? item)
public bool TryEject(EntityUid uid, ItemSlot slot, EntityUid? user, [NotNullWhen(true)] out EntityUid? item)
{
item = null;
@@ -302,7 +323,7 @@ namespace Content.Shared.Containers.ItemSlots
return false;
item = slot.Item;
Eject(uid, slot, item.Value);
Eject(uid, slot, item.Value, user);
return true;
}
@@ -310,7 +331,8 @@ namespace Content.Shared.Containers.ItemSlots
/// Try to eject item from a slot.
/// </summary>
/// <returns>False if the id is not valid, the item slot is locked, or it has no item inserted</returns>
public bool TryEject(EntityUid uid, string id, [NotNullWhen(true)] out EntityUid? item, ItemSlotsComponent? itemSlots = null)
public bool TryEject(EntityUid uid, string id, EntityUid user,
[NotNullWhen(true)] out EntityUid? item, ItemSlotsComponent? itemSlots = null)
{
item = null;
@@ -320,7 +342,7 @@ namespace Content.Shared.Containers.ItemSlots
if (!itemSlots.Slots.TryGetValue(id, out var slot))
return false;
return TryEject(uid, slot, out item);
return TryEject(uid, slot, user, out item);
}
/// <summary>
@@ -333,7 +355,7 @@ namespace Content.Shared.Containers.ItemSlots
/// </returns>
public bool TryEjectToHands(EntityUid uid, ItemSlot slot, EntityUid? user)
{
if (!TryEject(uid, slot, out var item))
if (!TryEject(uid, slot, user, out var item))
return false;
if (user != null && EntityManager.TryGetComponent(user.Value, out SharedHandsComponent? hands))
@@ -428,7 +450,7 @@ namespace Content.Shared.Containers.ItemSlots
: EntityManager.GetComponent<MetaDataComponent>(args.Using.Value).EntityName ?? string.Empty;
Verb insertVerb = new();
insertVerb.Act = () => Insert(uid, slot, args.Using.Value);
insertVerb.Act = () => Insert(uid, slot, args.Using.Value, args.User);
if (slot.InsertVerbText != null)
{
@@ -461,7 +483,7 @@ namespace Content.Shared.Containers.ItemSlots
foreach (var slot in component.Slots.Values)
{
if (slot.EjectOnBreak && slot.HasItem)
TryEject(uid, slot, out var _);
TryEject(uid, slot, null, out var _);
}
}

227
Content.Shared/Interaction/SharedInteractionSystem.cs
View File

@@ -1,12 +1,16 @@
using System;
using System.Diagnostics.CodeAnalysis;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Content.Shared.ActionBlocker;
using Content.Shared.Administration.Logs;
using Content.Shared.CombatMode;
using Content.Shared.Database;
using Content.Shared.Hands;
using Content.Shared.Hands.Components;
using Content.Shared.Input;
using Content.Shared.Interaction.Helpers;
using Content.Shared.Inventory;
using Content.Shared.Physics;
using Content.Shared.Popups;
@@ -16,13 +20,14 @@ using Content.Shared.Verbs;
using JetBrains.Annotations;
using Robust.Shared.Containers;
using Robust.Shared.GameObjects;
using Robust.Shared.Input.Binding;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Log;
using Robust.Shared.Map;
using Robust.Shared.Maths;
using Robust.Shared.Physics;
using Robust.Shared.Players;
using Robust.Shared.Random;
using Robust.Shared.Serialization;
#pragma warning disable 618
@@ -39,12 +44,166 @@ namespace Content.Shared.Interaction
[Dependency] private readonly ActionBlockerSystem _actionBlockerSystem = default!;
[Dependency] private readonly SharedVerbSystem _verbSystem = default!;
[Dependency] private readonly SharedAdminLogSystem _adminLogSystem = default!;
[Dependency] private readonly RotateToFaceSystem _rotateToFaceSystem = default!;
public const float InteractionRange = 2;
public const float InteractionRangeSquared = InteractionRange * InteractionRange;
public delegate bool Ignored(EntityUid entity);
public override void Initialize()
{
SubscribeAllEvent<InteractInventorySlotEvent>(HandleInteractInventorySlotEvent);
CommandBinds.Builder
.Bind(ContentKeyFunctions.AltActivateItemInWorld,
new PointerInputCmdHandler(HandleAltUseInteraction))
.Register<SharedInteractionSystem>();
}
public override void Shutdown()
{
CommandBinds.Unregister<SharedInteractionSystem>();
base.Shutdown();
}
/// <summary>
/// Handles the event were a client uses an item in their inventory or in their hands, either by
/// alt-clicking it or pressing 'E' while hovering over it.
/// </summary>
private void HandleInteractInventorySlotEvent(InteractInventorySlotEvent msg, EntitySessionEventArgs args)
{
var coords = Transform(msg.ItemUid).Coordinates;
// client sanitization
if (!ValidateClientInput(args.SenderSession, coords, msg.ItemUid, out var user))
{
Logger.InfoS("system.interaction", $"Inventory interaction validation failed. Session={args.SenderSession}");
return;
}
if (msg.AltInteract)
// Use 'UserInteraction' function - behaves as if the user alt-clicked the item in the world.
UserInteraction(user.Value, coords, msg.ItemUid, msg.AltInteract);
else
// User used 'E'. We want to activate it, not simulate clicking on the item
InteractionActivate(user.Value, msg.ItemUid);
}
public bool HandleAltUseInteraction(ICommonSession? session, EntityCoordinates coords, EntityUid uid)
{
// client sanitization
if (!ValidateClientInput(session, coords, uid, out var user))
{
Logger.InfoS("system.interaction", $"Alt-use input validation failed");
return true;
}
UserInteraction(user.Value, coords, uid, altInteract: true);
return false;
}
/// <summary>
/// Resolves user interactions with objects.
/// </summary>
/// <remarks>
/// Checks Whether combat mode is enabled and whether the user can actually interact with the given entity.
/// </remarks>
/// <param name="altInteract">Whether to use default or alternative interactions (usually as a result of
/// alt+clicking). If combat mode is enabled, the alternative action is to perform the default non-combat
/// interaction. Having an item in the active hand also disables alternative interactions.</param>
public async void UserInteraction(EntityUid user, EntityCoordinates coordinates, EntityUid? target, bool altInteract = false)
{
if (target != null && Deleted(target.Value))
return;
// TODO COMBAT Consider using alt-interact for advanced combat? maybe alt-interact disarms?
if (!altInteract && TryComp(user, out SharedCombatModeComponent? combatMode) && combatMode.IsInCombatMode)
{
DoAttack(user, coordinates, false, target);
return;
}
if (!ValidateInteractAndFace(user, coordinates))
return;
if (!_actionBlockerSystem.CanInteract(user))
return;
// Check if interacted entity is in the same container, the direct child, or direct parent of the user.
// This is bypassed IF the interaction happened through an item slot (e.g., backpack UI)
if (target != null && !user.IsInSameOrParentContainer(target.Value) && !CanAccessViaStorage(user, target.Value))
return;
// Verify user has a hand, and find what object they are currently holding in their active hand
if (!TryComp(user, out SharedHandsComponent? hands))
return;
// TODO remove invalid/default uid and use nullable.
hands.TryGetActiveHeldEntity(out var heldEntity);
EntityUid? held = heldEntity.Valid ? heldEntity : null;
// TODO: Replace with body interaction range when we get something like arm length or telekinesis or something.
var inRangeUnobstructed = user.InRangeUnobstructed(coordinates, ignoreInsideBlocker: true);
if (target == null || !inRangeUnobstructed)
{
if (held == null)
return;
if (!await InteractUsingRanged(user, held.Value, target, coordinates, inRangeUnobstructed) &&
!inRangeUnobstructed)
{
var message = Loc.GetString("interaction-system-user-interaction-cannot-reach");
user.PopupMessage(message);
}
return;
}
else
{
// We are close to the nearby object.
if (altInteract)
// Perform alternative interactions, using context menu verbs.
AltInteract(user, target.Value);
else if (held != null && held != target)
// We are performing a standard interaction with an item, and the target isn't the same as the item
// currently in our hand. We will use the item in our hand on the nearby object via InteractUsing
await InteractUsing(user, held.Value, target.Value, coordinates);
else if (held == null)
// Since our hand is empty we will use InteractHand/Activate
InteractHand(user, target.Value);
}
}
public virtual void InteractHand(EntityUid user, EntityUid target)
{
// TODO PREDICTION move server-side interaction logic into the shared system for interaction prediction.
}
public virtual void DoAttack(EntityUid user, EntityCoordinates coordinates, bool wideAttack,
EntityUid? targetUid = null)
{
// TODO PREDICTION move server-side interaction logic into the shared system for interaction prediction.
}
public virtual async Task<bool> InteractUsingRanged(EntityUid user, EntityUid used, EntityUid? target,
EntityCoordinates clickLocation, bool inRangeUnobstructed)
{
// TODO PREDICTION move server-side interaction logic into the shared system for interaction prediction.
return await Task.FromResult(true);
}
protected bool ValidateInteractAndFace(EntityUid user, EntityCoordinates coordinates)
{
// Verify user is on the same map as the entity they clicked on
if (coordinates.GetMapId(EntityManager) != Transform(user).MapID)
return false;
_rotateToFaceSystem.TryFaceCoordinates(user, coordinates.ToMapPos(EntityManager));
return true;
}
/// <summary>
/// Traces a ray from coords to otherCoords and returns the length
/// of the vector between coords and the ray's first hit.
@@ -154,7 +313,7 @@ namespace Content.Shared.Interaction
foreach (var result in rayResults)
{
if (!EntityManager.TryGetComponent(result.HitEntity, out IPhysBody? p))
if (!TryComp(result.HitEntity, out IPhysBody? p))
{
continue;
}
@@ -213,7 +372,7 @@ namespace Content.Shared.Interaction
bool popup = false)
{
predicate ??= e => e == origin || e == other;
return InRangeUnobstructed(origin, EntityManager.GetComponent<TransformComponent>(other).MapPosition, range, collisionMask, predicate, ignoreInsideBlocker, popup);
return InRangeUnobstructed(origin, Transform(other).MapPosition, range, collisionMask, predicate, ignoreInsideBlocker, popup);
}
/// <summary>
@@ -345,7 +504,7 @@ namespace Content.Shared.Interaction
bool ignoreInsideBlocker = false,
bool popup = false)
{
var originPosition = EntityManager.GetComponent<TransformComponent>(origin).MapPosition;
var originPosition = Transform(origin).MapPosition;
predicate ??= e => e == origin;
var inRange = InRangeUnobstructed(originPosition, other, range, collisionMask, predicate, ignoreInsideBlocker);
@@ -392,7 +551,7 @@ namespace Content.Shared.Interaction
var interactUsingEventArgs = new InteractUsingEventArgs(user, clickLocation, used, target);
var interactUsings = EntityManager.GetComponents<IInteractUsing>(target).OrderByDescending(x => x.Priority);
var interactUsings = AllComps<IInteractUsing>(target).OrderByDescending(x => x.Priority);
foreach (var interactUsing in interactUsings)
{
// If an InteractUsing returns a status completion we finish our interaction
@@ -418,7 +577,7 @@ namespace Content.Shared.Interaction
return true;
var afterInteractEventArgs = new AfterInteractEventArgs(user, clickLocation, target, canReach);
var afterInteracts = EntityManager.GetComponents<IAfterInteract>(used).OrderByDescending(x => x.Priority).ToList();
var afterInteracts = AllComps<IAfterInteract>(used).OrderByDescending(x => x.Priority).ToList();
foreach (var afterInteract in afterInteracts)
{
@@ -444,7 +603,7 @@ namespace Content.Shared.Interaction
protected void InteractionActivate(EntityUid user, EntityUid used)
{
if (EntityManager.TryGetComponent<UseDelayComponent?>(used, out var delayComponent))
if (TryComp(used, out UseDelayComponent? delayComponent))
{
if (delayComponent.ActiveDelay)
return;
@@ -472,7 +631,7 @@ namespace Content.Shared.Interaction
return;
}
if (!EntityManager.TryGetComponent(used, out IActivate? activateComp))
if (!TryComp(used, out IActivate? activateComp))
return;
var activateEventArgs = new ActivateEventArgs(user, used);
@@ -506,7 +665,7 @@ namespace Content.Shared.Interaction
/// </summary>
public void UseInteraction(EntityUid user, EntityUid used)
{
if (EntityManager.TryGetComponent<UseDelayComponent?>(used, out var delayComponent))
if (TryComp(used, out UseDelayComponent? delayComponent))
{
if (delayComponent.ActiveDelay)
return;
@@ -519,7 +678,7 @@ namespace Content.Shared.Interaction
if (useMsg.Handled)
return;
var uses = EntityManager.GetComponents<IUse>(used).ToList();
var uses = AllComps<IUse>(used).ToList();
// Try to use item on any components which have the interface
foreach (var use in uses)
@@ -560,7 +719,7 @@ namespace Content.Shared.Interaction
return;
}
var comps = EntityManager.GetComponents<IThrown>(thrown).ToList();
var comps = AllComps<IThrown>(thrown).ToList();
var args = new ThrownEventArgs(user);
// Call Thrown on all components that implement the interface
@@ -584,7 +743,7 @@ namespace Content.Shared.Interaction
if (equipMsg.Handled)
return;
var comps = EntityManager.GetComponents<IEquipped>(equipped).ToList();
var comps = AllComps<IEquipped>(equipped).ToList();
// Call Thrown on all components that implement the interface
foreach (var comp in comps)
@@ -604,7 +763,7 @@ namespace Content.Shared.Interaction
if (unequipMsg.Handled)
return;
var comps = EntityManager.GetComponents<IUnequipped>(equipped).ToList();
var comps = AllComps<IUnequipped>(equipped).ToList();
// Call Thrown on all components that implement the interface
foreach (var comp in comps)
@@ -625,7 +784,7 @@ namespace Content.Shared.Interaction
if (equippedHandMessage.Handled)
return;
var comps = EntityManager.GetComponents<IEquippedHand>(item).ToList();
var comps = AllComps<IEquippedHand>(item).ToList();
foreach (var comp in comps)
{
@@ -644,7 +803,7 @@ namespace Content.Shared.Interaction
if (unequippedHandMessage.Handled)
return;
var comps = EntityManager.GetComponents<IUnequippedHand>(item).ToList();
var comps = AllComps<IUnequippedHand>(item).ToList();
foreach (var comp in comps)
{
@@ -681,9 +840,9 @@ namespace Content.Shared.Interaction
return;
}
EntityManager.GetComponent<TransformComponent>(item).LocalRotation = Angle.Zero;
Transform(item).LocalRotation = Angle.Zero;
var comps = EntityManager.GetComponents<IDropped>(item).ToList();
var comps = AllComps<IDropped>(item).ToList();
// Call Land on all components that implement the interface
foreach (var comp in comps)
@@ -706,7 +865,7 @@ namespace Content.Shared.Interaction
if (handSelectedMsg.Handled)
return;
var comps = EntityManager.GetComponents<IHandSelected>(item).ToList();
var comps = AllComps<IHandSelected>(item).ToList();
// Call Land on all components that implement the interface
foreach (var comp in comps)
@@ -726,7 +885,7 @@ namespace Content.Shared.Interaction
if (handDeselectedMsg.Handled)
return;
var comps = EntityManager.GetComponents<IHandDeselected>(item).ToList();
var comps = AllComps<IHandDeselected>(item).ToList();
// Call Land on all components that implement the interface
foreach (var comp in comps)
@@ -742,6 +901,36 @@ namespace Content.Shared.Interaction
/// </summary>
public abstract bool CanAccessViaStorage(EntityUid user, EntityUid target);
protected bool ValidateClientInput(ICommonSession? session, EntityCoordinates coords,
EntityUid uid, [NotNullWhen(true)] out EntityUid? userEntity)
{
userEntity = null;
if (!coords.IsValid(EntityManager))
{
Logger.InfoS("system.interaction", $"Invalid Coordinates: client={session}, coords={coords}");
return false;
}
if (uid.IsClientSide())
{
Logger.WarningS("system.interaction",
$"Client sent interaction with client-side entity. Session={session}, Uid={uid}");
return false;
}
userEntity = session?.AttachedEntity;
if (userEntity == null || !userEntity.Value.Valid)
{
Logger.WarningS("system.interaction",
$"Client sent interaction with no attached entity. Session={session}");
return false;
}
return true;
}
#endregion
}

6
Content.Server/PDA/PDAComponent.cs → Content.Shared/PDA/PDAComponent.cs
View File

@@ -1,6 +1,4 @@
using System;
using System.Collections.Generic;
using Content.Server.Access.Components;
using Content.Shared.Access.Components;
using Content.Shared.Containers.ItemSlots;
using Robust.Shared.GameObjects;
using Robust.Shared.Prototypes;
@@ -8,7 +6,7 @@ using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
using Robust.Shared.ViewVariables;
namespace Content.Server.PDA
namespace Content.Shared.PDA
{
[RegisterComponent]
public class PDAComponent : Component

65
Content.Shared/PDA/SharedPDASystem.cs Normal file
View File

@@ -0,0 +1,65 @@
using Content.Shared.Access.Components;
using Content.Shared.Containers.ItemSlots;
using Robust.Shared.Containers;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
namespace Content.Shared.PDA
{
public abstract class SharedPDASystem : EntitySystem
{
[Dependency] protected readonly ItemSlotsSystem ItemSlotsSystem = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<PDAComponent, ComponentInit>(OnComponentInit);
SubscribeLocalEvent<PDAComponent, ComponentRemove>(OnComponentRemove);
SubscribeLocalEvent<PDAComponent, EntInsertedIntoContainerMessage>(OnItemInserted);
SubscribeLocalEvent<PDAComponent, EntRemovedFromContainerMessage>(OnItemRemoved);
}
protected virtual void OnComponentInit(EntityUid uid, PDAComponent pda, ComponentInit args)
{
if (pda.IdCard != null)
pda.IdSlot.StartingItem = pda.IdCard;
ItemSlotsSystem.AddItemSlot(uid, $"{pda.Name}-id", pda.IdSlot);
ItemSlotsSystem.AddItemSlot(uid, $"{pda.Name}-pen", pda.PenSlot);
UpdatePDAAppearance(pda);
}
private void OnComponentRemove(EntityUid uid, PDAComponent pda, ComponentRemove args)
{
ItemSlotsSystem.RemoveItemSlot(uid, pda.IdSlot);
ItemSlotsSystem.RemoveItemSlot(uid, pda.PenSlot);
}
protected virtual void OnItemInserted(EntityUid uid, PDAComponent pda, EntInsertedIntoContainerMessage args)
{
if (!pda.Initialized) return;
if (args.Container.ID == pda.IdSlot.ID)
pda.ContainedID = CompOrNull<IdCardComponent>(args.Entity);
UpdatePDAAppearance(pda);
}
protected virtual void OnItemRemoved(EntityUid uid, PDAComponent pda, EntRemovedFromContainerMessage args)
{
if (args.Container.ID == pda.IdSlot.ID)
pda.ContainedID = null;
UpdatePDAAppearance(pda);
}
private void UpdatePDAAppearance(PDAComponent pda)
{
if (TryComp(pda.Owner, out AppearanceComponent ? appearance))
appearance.SetData(PDAVisuals.IDCardInserted, pda.ContainedID != null);
}
}
}

85
Content.Shared/Verbs/SharedVerbSystem.cs
View File

@@ -1,7 +1,5 @@
using System.Collections.Generic;
using Content.Shared.ActionBlocker;
using Content.Shared.Administration.Logs;
using Content.Shared.Database;
using Content.Shared.Hands.Components;
using Content.Shared.Interaction;
using Robust.Shared.Containers;
@@ -12,10 +10,35 @@ namespace Content.Shared.Verbs
{
public abstract class SharedVerbSystem : EntitySystem
{
[Dependency] private readonly SharedAdminLogSystem _logSystem = default!;
[Dependency] private readonly SharedInteractionSystem _interactionSystem = default!;
[Dependency] private readonly ActionBlockerSystem _actionBlockerSystem = default!;
public override void Initialize()
{
base.Initialize();
SubscribeAllEvent<ExecuteVerbEvent>(HandleExecuteVerb);
}
private void HandleExecuteVerb(ExecuteVerbEvent args, EntitySessionEventArgs eventArgs)
{
var user = eventArgs.SenderSession.AttachedEntity;
if (user == null)
return;
// Get the list of verbs. This effectively also checks that the requested verb is in fact a valid verb that
// the user can perform.
var verbs = GetLocalVerbs(args.Target, user.Value, args.Type)[args.Type];
// Note that GetLocalVerbs might waste time checking & preparing unrelated verbs even though we know
// precisely which one we want to run. However, MOST entities will only have 1 or 2 verbs of a given type.
// The one exception here is the "other" verb type, which has 3-4 verbs + all the debug verbs.
// Find the requested verb.
if (verbs.TryGetValue(args.RequestedVerb, out var verb))
ExecuteVerb(verb, user.Value, args.Target);
}
/// <summary>
/// Raises a number of events in order to get all verbs of the given type(s) defined in local systems. This
/// does not request verbs from the server.
@@ -92,60 +115,6 @@ namespace Content.Shared.Verbs
/// <remarks>
/// This will try to call the action delegates and raise the local events for the given verb.
/// </remarks>
public void ExecuteVerb(Verb verb, EntityUid user, EntityUid target, bool forced = false)
{
// first, lets log the verb. Just in case it ends up crashing the server or something.
LogVerb(verb, user, target, forced);
// then invoke any relevant actions
verb.Act?.Invoke();
// Maybe raise a local event
if (verb.ExecutionEventArgs != null)
{
if (verb.EventTarget.IsValid())
RaiseLocalEvent(verb.EventTarget, verb.ExecutionEventArgs);
else
RaiseLocalEvent(verb.ExecutionEventArgs);
}
}
public void LogVerb(Verb verb, EntityUid user, EntityUid target, bool forced)
{
// first get the held item. again.
EntityUid usedUid = default;
if (EntityManager.TryGetComponent(user, out SharedHandsComponent? hands) &&
hands.TryGetActiveHeldEntity(out var heldEntity))
{
usedUid = heldEntity;
if (usedUid != default && EntityManager.TryGetComponent(usedUid, out HandVirtualItemComponent? pull))
usedUid = pull.BlockingEntity;
}
// get all the entities
if (!user.IsValid() || !target.IsValid())
return;
EntityUid? used = null;
if (usedUid != default)
EntityManager.EntityExists(usedUid);
var verbText = $"{verb.Category?.Text} {verb.Text}".Trim();
// lets not frame people, eh?
var executionText = forced ? "was forced to execute" : "executed";
if (used == null)
{
_logSystem.Add(LogType.Verb, verb.Impact,
$"{ToPrettyString(user):user} {executionText} the [{verbText:verb}] verb targeting {ToPrettyString(target):target}");
}
else
{
_logSystem.Add(LogType.Verb, verb.Impact,
$"{ToPrettyString(user):user} {executionText} the [{verbText:verb}] verb targeting {ToPrettyString(target):target} while holding {ToPrettyString(used.Value):held}");
}
}
public abstract void ExecuteVerb(Verb verb, EntityUid user, EntityUid target, bool forced = false);
}
}

2
Content.Shared/Weapons/Melee/AttackEvent.cs
View File

@@ -25,7 +25,7 @@ namespace Content.Shared.Weapons.Melee
public EntityCoordinates ClickLocation { get; }
/// <summary>
/// UID of the entity that was attacked.
/// The entity that was attacked.
/// </summary>
public EntityUid? Target { get; }