ECS verbs and update context menu (#4594)

* Functioning ECS verbs

Currently only ID card console works.

* Changed verb types and allow ID card insertions

* Verb GUI sorting and verb networking

* More networking, and shared components

* Clientside verbs work now.

* Verb enums changed to bitmask flags

* Verb Categories redo

* Fix range check

* GasTank Verb

* Remove unnecessary bodypart verb

* Buckle Verb

* buckle & unbuckle verbs

* Updated range checks

* Item cabinet verbs

* Add range user override

* construction verb

* Chemistry machine verbs

* Climb Verb

* Generalise pulled entity verbs

* ViewVariables Verb

* rejuvenate, delete, sentient, control verbs

* Outfit verb

* inrangeunoccluded and tubedirection verbs

* attach-to verbs

* remove unused verbs and move VV

* Rename DebugVerbSystem

* Ghost role and pointing verbs

* Remove global verbs

* Allow verbs to raise events

* Changing categories and simplifying debug verbs

* Add rotate and flip verbs

* fix rejuvenate test

* redo context menu

* new Add Gas debug verb

* Add Set Temperature debug verb

* Uncuff verb

* Disposal unit verbs

* Add pickup verb

* lock/unlock verb

* Remove verb type, add specific verb events

* rename verb messages -> events

* Context menu displays verbs by interaction type

* Updated context menu HandleMove

previously, checked if entities moved 1 tile from click location.

Now checks if entities moved out of view.

Now you can actually right-click interact with yourself while walking!

* Misc Verb menu GUI changes

* Fix non-human/ghost verbs

* Update types and categories

* Allow non-ghost/human to open context menu

* configuration verb

* tagger verb

* Morgue Verbs

* Medical Scanner Verbs

* Fix solution refactor merge issues

* Fix context menu in-view check

* Remove prepare GUI

* Redo verb restrictions

* Fix context menu UI

* Disposal Verbs

* Spill verb

* Light verb

* Hand Held light verb

* power cell verbs

* storage verbs

and adding names to insert/eject

* Pulling verb

* Close context menu on verb execution

* Strip verb

* AmmoBox verb

* fix pull verb

* gun barrel verbs

revolver verb
energy weapon verbs
Bolt action verb

* Magazine gun barrel  verbs

* Add charger verbs

* PDA verbs

* Transfer amount verb

* Add reagent verb

* make alt-click use ECS verbs

* Delete old verb files

* Magboot verb

* finalising tweaks

* context menu visibility changes

* code cleanup

* Update AdminAddReagentUI.cs

* Remove HasFlag

* Consistent verb keys

* Remove Linq, add comment

* Fix in-inventory check

* Update GUI text alignment and padding

* Added close-menu option

* Changed some "interaction" verbs to "activation"

* Remove verb keys, use sorted sets

* fix master merge

* update some verb text

* Undo Changes

Remove some new verbs that can be added later

undid some .ftl bugfixes, can and should be done separately

* fix merge

* Undo file rename

* fix merge

* Misc Cleanup

* remove contraction

* Fix keybinding issue

* fix comment

* merge fix

* fix merge

* fix merge

* fix merge

* fix merge

* fix open-close verbs

* adjust uncuff verb

* fix merge

and undo the renaming of SharedPullableComponent to PullableComponent. I'm tired of all of those merge conflicts
This commit is contained in:
Leon Friedrich
2021-10-05 14:29:03 +11:00
committed by GitHub
parent 1095c8fc08
commit 6cb58e608b
175 changed files with 3391 additions and 4305 deletions

View File

@@ -0,0 +1,188 @@
using Content.Server.Administration.Commands;
using Content.Server.Administration.Managers;
using Content.Server.Administration.UI;
using Content.Server.Configurable;
using Content.Server.Disposal.Tube.Components;
using Content.Server.EUI;
using Content.Server.Ghost.Roles;
using Content.Server.Inventory.Components;
using Content.Server.Mind.Commands;
using Content.Server.Mind.Components;
using Content.Server.Players;
using Content.Server.Verbs;
using Content.Shared.Administration;
using Content.Shared.Chemistry.Components.SolutionManager;
using Content.Shared.Interaction.Helpers;
using Content.Shared.Popups;
using Content.Shared.Verbs;
using Robust.Server.Console;
using Robust.Server.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
namespace Content.Server.Administration
{
/// <summary>
/// System to provide various global admin/debug verbs
/// </summary>
public class AdminVerbSystem : EntitySystem
{
[Dependency] private readonly IConGroupController _groupController = default!;
[Dependency] private readonly IAdminManager _adminManager = default!;
[Dependency] private readonly EuiManager _euiManager = default!;
[Dependency] private readonly GhostRoleSystem _ghostRoleSystem = default!;
[Dependency] private readonly VerbSystem _verbSystem = default!;
public override void Initialize()
{
SubscribeLocalEvent<GetOtherVerbsEvent>(AddDebugVerbs);
}
private void AddDebugVerbs(GetOtherVerbsEvent args)
{
if (!args.User.TryGetComponent<ActorComponent>(out var actor))
return;
var player = actor.PlayerSession;
// Delete verb
if (_groupController.CanCommand(player, "deleteentity"))
{
Verb verb = new();
verb.Text = Loc.GetString("delete-verb-get-data-text");
verb.Category = VerbCategory.Debug;
verb.IconTexture = "/Textures/Interface/VerbIcons/delete.svg.192dpi.png";
verb.Act = () => args.Target.Delete();
args.Verbs.Add(verb);
}
// Rejuvenate verb
if (_groupController.CanCommand(player, "rejuvenate"))
{
Verb verb = new();
verb.Text = Loc.GetString("rejuvenate-verb-get-data-text");
verb.Category = VerbCategory.Debug;
verb.IconTexture = "/Textures/Interface/VerbIcons/rejuvenate.svg.192dpi.png";
verb.Act = () => RejuvenateCommand.PerformRejuvenate(args.Target);
args.Verbs.Add(verb);
}
// Control mob verb
if (_groupController.CanCommand(player, "controlmob") &&
args.User != args.Target &&
args.User.HasComponent<MindComponent>() &&
args.Target.TryGetComponent<MindComponent>(out var targetMind))
{
Verb verb = new();
verb.Text = Loc.GetString("control-mob-verb-get-data-text");
verb.Category = VerbCategory.Debug;
// TODO VERB ICON control mob icon
verb.Act = () =>
{
targetMind.Mind?.TransferTo(null);
player.ContentData()?.Mind?.TransferTo(args.Target, ghostCheckOverride: true);
};
args.Verbs.Add(verb);
}
// Make Sentient verb
if (_groupController.CanCommand(player, "makesentient") &&
args.User != args.Target &&
!args.Target.HasComponent<MindComponent>())
{
Verb verb = new();
verb.Text = Loc.GetString("make-sentient-verb-get-data-text");
verb.Category = VerbCategory.Debug;
verb.IconTexture = "/Textures/Interface/VerbIcons/sentient.svg.192dpi.png";
verb.Act = () => MakeSentientCommand.MakeSentient(args.Target);
args.Verbs.Add(verb);
}
// Set clothing verb
if (_groupController.CanCommand(player, "setoutfit") &&
args.Target.HasComponent<InventoryComponent>())
{
Verb verb = new();
verb.Text = Loc.GetString("set-outfit-verb-get-data-text");
verb.Category = VerbCategory.Debug;
verb.IconTexture = "/Textures/Interface/VerbIcons/outfit.svg.192dpi.png";
verb.Act = () => _euiManager.OpenEui(new SetOutfitEui(args.Target), player);
args.Verbs.Add(verb);
}
// In range unoccluded verb
if (_groupController.CanCommand(player, "inrangeunoccluded"))
{
Verb verb = new();
verb.Text = Loc.GetString("in-range-unoccluded-verb-get-data-text");
verb.Category = VerbCategory.Debug;
verb.IconTexture = "/Textures/Interface/VerbIcons/information.svg.192dpi.png";
verb.Act = () =>
{
var message = args.User.InRangeUnOccluded(args.Target)
? Loc.GetString("in-range-unoccluded-verb-on-activate-not-occluded")
: Loc.GetString("in-range-unoccluded-verb-on-activate-occluded");
args.Target.PopupMessage(args.User, message);
};
args.Verbs.Add(verb);
}
// Get Disposal tube direction verb
if (_groupController.CanCommand(player, "tubeconnections") &&
args.Target.TryGetComponent<IDisposalTubeComponent>(out var tube))
{
Verb verb = new();
verb.Text = Loc.GetString("tube-direction-verb-get-data-text");
verb.Category = VerbCategory.Debug;
verb.IconTexture = "/Textures/Interface/VerbIcons/information.svg.192dpi.png";
verb.Act = () => tube.PopupDirections(args.User);
args.Verbs.Add(verb);
}
// Make ghost role verb
if (_groupController.CanCommand(player, "makeghostrole") &&
!(args.Target.GetComponentOrNull<MindComponent>()?.HasMind ?? false))
{
Verb verb = new();
verb.Text = Loc.GetString("make-ghost-role-verb-get-data-text");
verb.Category = VerbCategory.Debug;
// TODO VERB ICON add ghost icon
// Where is the national park service icon for haunted forests?
verb.Act = () => _ghostRoleSystem.OpenMakeGhostRoleEui(player, args.Target.Uid);
args.Verbs.Add(verb);
}
// Configuration verb. Is this even used for anything!?
if (_groupController.CanAdminMenu(player) &&
args.Target.TryGetComponent<ConfigurationComponent>(out var config))
{
Verb verb = new();
verb.Text = Loc.GetString("configure-verb-get-data-text");
verb.IconTexture = "/Textures/Interface/VerbIcons/settings.svg.192dpi.png";
verb.Category = VerbCategory.Debug;
verb.Act = () => config.OpenUserInterface(actor);
args.Verbs.Add(verb);
}
// Add reagent verb
if (_adminManager.HasAdminFlag(player, AdminFlags.Fun) &&
args.Target.HasComponent<SolutionContainerManagerComponent>())
{
Verb verb = new();
verb.Text = Loc.GetString("admin-add-reagent-verb-get-data-text");
verb.Category = VerbCategory.Debug;
verb.IconTexture = "/Textures/Interface/VerbIcons/spill.svg.192dpi.png";
verb.Act = () => _euiManager.OpenEui(new AdminAddReagentEui(args.Target), player);
// TODO CHEMISTRY
// Add reagent ui broke after solution refactor. Needs fixing
verb.Disabled = true;
verb.Tooltip = "Currently non functional after solution refactor.";
verb.Priority = -2;
args.Verbs.Add(verb);
}
}
}
}

View File

@@ -1,5 +1,12 @@
using Content.Server.Damage;
using Content.Server.Atmos.Components;
using Content.Server.Atmos.EntitySystems;
using Content.Server.Nutrition.Components;
using Content.Server.Nutrition.EntitySystems;
using Content.Server.Stunnable.Components;
using Content.Shared.Administration;
using Content.Shared.Damage;
using Content.Shared.MobState;
using Content.Shared.Nutrition.Components;
using Robust.Server.Player;
using Robust.Shared.Console;
using Robust.Shared.GameObjects;
@@ -9,7 +16,7 @@ using Robust.Shared.Localization;
namespace Content.Server.Administration.Commands
{
[AdminCommand(AdminFlags.Admin)]
class Rejuvenate : IConsoleCommand
public class RejuvenateCommand : IConsoleCommand
{
public string Command => "rejuvenate";
@@ -28,7 +35,7 @@ namespace Content.Server.Administration.Commands
shell.WriteLine(Loc.GetString("rejuvenate-command-no-entity-attached-message"));
return;
}
RejuvenateVerb.PerformRejuvenate(player.AttachedEntity);
PerformRejuvenate(player.AttachedEntity);
}
var entityManager = IoCManager.Resolve<IEntityManager>();
@@ -39,7 +46,27 @@ namespace Content.Server.Administration.Commands
shell.WriteLine(Loc.GetString("shell-could-not-find-entity",("entity", arg)));
continue;
}
RejuvenateVerb.PerformRejuvenate(entity);
PerformRejuvenate(entity);
}
}
public static void PerformRejuvenate(IEntity target)
{
target.GetComponentOrNull<IMobStateComponent>()?.UpdateState(0);
target.GetComponentOrNull<HungerComponent>()?.ResetFood();
target.GetComponentOrNull<ThirstComponent>()?.ResetThirst();
target.GetComponentOrNull<StunnableComponent>()?.ResetStuns();
EntitySystem.Get<FlammableSystem>().Extinguish(target.Uid);
if (target.TryGetComponent(out DamageableComponent? damageable))
{
EntitySystem.Get<DamageableSystem>().SetAllDamage(damageable, 0);
}
if (target.TryGetComponent(out CreamPiedComponent? creamPied))
{
EntitySystem.Get<CreamPieSystem>().SetCreamPied(target.Uid, creamPied, false);
}
}
}

View File

@@ -0,0 +1,94 @@
using Content.Server.Administration.Managers;
using Content.Server.EUI;
using Content.Shared.Administration;
using Content.Shared.Chemistry.Components;
using Content.Shared.Chemistry.Components.SolutionManager;
using Content.Shared.Chemistry.EntitySystems;
using Content.Shared.Chemistry.Reagent;
using Content.Shared.Eui;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
namespace Content.Server.Administration.UI
{
public sealed class AdminAddReagentEui : BaseEui
{
private readonly IEntity _target;
[Dependency] private readonly IAdminManager _adminManager = default!;
public AdminAddReagentEui(IEntity target)
{
_target = target;
IoCManager.InjectDependencies(this);
}
public override void Opened()
{
StateDirty();
}
public override EuiStateBase GetNewState()
{
if (EntitySystem.Get<SolutionContainerSystem>()
.TryGetSolution(_target, "default", out var container))
{
return new AdminAddReagentEuiState
{
CurVolume = container.CurrentVolume,
MaxVolume = container.MaxVolume
};
}
return new AdminAddReagentEuiState
{
CurVolume = ReagentUnit.Zero,
MaxVolume = ReagentUnit.Zero
};
}
public override void HandleMessage(EuiMessageBase msg)
{
switch (msg)
{
case AdminAddReagentEuiMsg.Close:
Close();
break;
case AdminAddReagentEuiMsg.DoAdd doAdd:
// Double check that user wasn't de-adminned in the mean time...
// Or the target was deleted.
if (!_adminManager.HasAdminFlag(Player, AdminFlags.Fun) || _target.Deleted)
{
Close();
return;
}
var id = doAdd.ReagentId;
var amount = doAdd.Amount;
var solutionsSys = EntitySystem.Get<SolutionContainerSystem>();
if (_target.TryGetComponent(out InjectableSolutionComponent? injectable)
&& solutionsSys.TryGetSolution(_target, injectable.Name, out var targetSolution))
{
var solution = new Solution(id, amount);
solutionsSys.Inject(_target.Uid, targetSolution, solution);
}
else
{
//TODO decide how to find the solution
if (solutionsSys.TryGetSolution(_target, "default", out var solution))
{
solutionsSys.TryAddReagent(_target.Uid,solution, id, amount, out _);
}
}
StateDirty();
if (doAdd.CloseAfter)
Close();
break;
}
}
}
}

View File

@@ -1,150 +0,0 @@
using Content.Server.Administration.Managers;
using Content.Server.EUI;
using Content.Shared.Administration;
using Content.Shared.Chemistry.Components;
using Content.Shared.Chemistry.Components.SolutionManager;
using Content.Shared.Chemistry.EntitySystems;
using Content.Shared.Chemistry.Reagent;
using Content.Shared.Eui;
using Content.Shared.Verbs;
using Robust.Server.GameObjects;
using Robust.Server.Player;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
namespace Content.Server.Administration.Verbs
{
[GlobalVerb]
internal sealed class AdminAddReagentVerb : GlobalVerb
{
public override bool RequireInteractionRange => false;
public override bool BlockedByContainers => false;
private const AdminFlags ReqFlags = AdminFlags.Fun;
private static void OpenAddReagentMenu(IPlayerSession player, IEntity target)
{
var euiMgr = IoCManager.Resolve<EuiManager>();
euiMgr.OpenEui(new AdminAddReagentEui(target), player);
}
public override void GetData(IEntity user, IEntity target, VerbData data)
{
// ISolutionInteractionsComponent doesn't exactly have an interface for "admin tries to refill this", so...
// Still have a path for SolutionContainerComponent in case it doesn't allow direct refilling.
if (!(target.HasComponent<SolutionContainerManagerComponent>()
&& target.HasComponent<InjectableSolutionComponent>()))
{
data.Visibility = VerbVisibility.Invisible;
return;
}
data.Text = Loc.GetString("admin-add-reagent-verb-get-data-text");
data.IconTexture = "/Textures/Interface/VerbIcons/spill.svg.192dpi.png";
data.CategoryData = VerbCategories.Debug;
data.Visibility = VerbVisibility.Invisible;
var adminManager = IoCManager.Resolve<IAdminManager>();
if (user.TryGetComponent<ActorComponent>(out var player))
{
if (adminManager.HasAdminFlag(player.PlayerSession, ReqFlags))
{
data.Visibility = VerbVisibility.Visible;
}
}
}
public override void Activate(IEntity user, IEntity target)
{
var groupController = IoCManager.Resolve<IAdminManager>();
if (user.TryGetComponent<ActorComponent>(out var player))
{
if (groupController.HasAdminFlag(player.PlayerSession, ReqFlags))
OpenAddReagentMenu(player.PlayerSession, target);
}
}
private sealed class AdminAddReagentEui : BaseEui
{
private readonly IEntity _target;
[Dependency] private readonly IAdminManager _adminManager = default!;
public AdminAddReagentEui(IEntity target)
{
_target = target;
IoCManager.InjectDependencies(this);
}
public override void Opened()
{
StateDirty();
}
public override EuiStateBase GetNewState()
{
if (EntitySystem.Get<SolutionContainerSystem>()
.TryGetSolution(_target, "default", out var container))
{
return new AdminAddReagentEuiState
{
CurVolume = container.CurrentVolume,
MaxVolume = container.MaxVolume
};
}
return new AdminAddReagentEuiState
{
CurVolume = ReagentUnit.Zero,
MaxVolume = ReagentUnit.Zero
};
}
public override void HandleMessage(EuiMessageBase msg)
{
switch (msg)
{
case AdminAddReagentEuiMsg.Close:
Close();
break;
case AdminAddReagentEuiMsg.DoAdd doAdd:
// Double check that user wasn't de-adminned in the mean time...
// Or the target was deleted.
if (!_adminManager.HasAdminFlag(Player, ReqFlags) || _target.Deleted)
{
Close();
return;
}
var id = doAdd.ReagentId;
var amount = doAdd.Amount;
var solutionsSys = EntitySystem.Get<SolutionContainerSystem>();
if (_target.TryGetComponent(out InjectableSolutionComponent? injectable)
&& solutionsSys.TryGetSolution(_target, injectable.Name, out var targetSolution))
{
var solution = new Solution(id, amount);
solutionsSys.Inject(_target.Uid, targetSolution, solution);
}
else
{
//TODO decide how to find the solution
if (solutionsSys.TryGetSolution(_target, "default", out var solution))
{
solutionsSys.TryAddReagent(_target.Uid,solution, id, amount, out _);
}
}
StateDirty();
if (doAdd.CloseAfter)
Close();
break;
}
}
}
}
}

View File

@@ -1,55 +0,0 @@
using Content.Shared.Verbs;
using Robust.Server.Console;
using Robust.Server.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
namespace Content.Server.Administration.Verbs
{
[GlobalVerb]
public class DeleteVerb : GlobalVerb
{
public override bool RequireInteractionRange => false;
public override bool BlockedByContainers => false;
public override void GetData(IEntity user, IEntity target, VerbData data)
{
data.Visibility = VerbVisibility.Invisible;
var groupController = IoCManager.Resolve<IConGroupController>();
if (!user.TryGetComponent(out ActorComponent? actor))
{
return;
}
if (!groupController.CanCommand(actor.PlayerSession, "deleteentity"))
{
return;
}
data.Text = Loc.GetString("delete-verb-get-data-text");
data.CategoryData = VerbCategories.Debug;
data.Visibility = VerbVisibility.Visible;
data.IconTexture = "/Textures/Interface/VerbIcons/delete.svg.192dpi.png";
}
public override void Activate(IEntity user, IEntity target)
{
var groupController = IoCManager.Resolve<IConGroupController>();
if (!user.TryGetComponent(out ActorComponent? actor))
{
return;
}
if (!groupController.CanCommand(actor.PlayerSession, "deleteentity"))
{
return;
}
target.Delete();
}
}
}