Add RGB staff (#13125)

Content.Server/Actions/ActionOnInteractSystem.cs

@@ -0,0 +1,131 @@
+using Content.Shared.Actions;
+using Content.Shared.Actions.ActionTypes;
+using Content.Shared.Interaction;
+using Robust.Shared.Random;
+using Robust.Shared.Timing;
+
+namespace Content.Server.Actions;
+
+/// <summary>
+///     This System handled interactions for the <see cref="ActionOnInteractComponent"/>.
+/// </summary>
+public sealed class ActionOnInteractSystem : EntitySystem
+{
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly SharedActionsSystem _actions = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ActionOnInteractComponent, ActivateInWorldEvent>(OnActivate);
+        SubscribeLocalEvent<ActionOnInteractComponent, AfterInteractEvent>(OnAfterInteract);
+    }
+
+    private void OnActivate(EntityUid uid, ActionOnInteractComponent component, ActivateInWorldEvent args)
+    {
+        if (args.Handled || component.ActivateActions == null)
+            return;
+
+        var options = new List<InstantAction>();
+        foreach (var action in component.ActivateActions)
+        {
+            if (ValidAction(action))
+                options.Add(action);
+        }
+
+        if (options.Count == 0)
+            return;
+
+        var act = _random.Pick(options);
+        if (act.Event != null)
+            act.Event.Performer = args.User;
+
+        act.Provider = uid;
+        _actions.PerformAction(args.User, null, act, act.Event, _timing.CurTime, false);
+        args.Handled = true;
+    }
+
+    private void OnAfterInteract(EntityUid uid, ActionOnInteractComponent component, AfterInteractEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        // First, try entity target actions
+        if (args.Target != null && component.EntityActions != null)
+        {
+            var entOptions = new List<EntityTargetAction>();
+            foreach (var action in component.EntityActions)
+            {
+                if (!ValidAction(action, args.CanReach))
+                    continue;
+
+                if (!_actions.ValidateEntityTarget(args.User, args.Target.Value, action))
+                    continue;
+
+                entOptions.Add(action);
+            }
+
+            if (entOptions.Count > 0)
+            {
+                var entAct = _random.Pick(entOptions);
+                if (entAct.Event != null)
+                {
+                    entAct.Event.Performer = args.User;
+                    entAct.Event.Target = args.Target.Value;
+                }
+
+                entAct.Provider = uid;
+                _actions.PerformAction(args.User, null, entAct, entAct.Event, _timing.CurTime, false);
+                args.Handled = true;
+                return;
+            }
+        }
+
+        // else: try world target actions
+        if (component.WorldActions == null)
+            return;
+
+        var options = new List<WorldTargetAction>();
+        foreach (var action in component.WorldActions)
+        {
+            if (!ValidAction(action, args.CanReach))
+                continue;
+
+            if (!_actions.ValidateWorldTarget(args.User, args.ClickLocation, action))
+                continue;
+
+            options.Add(action);
+        }
+
+        if (options.Count == 0)
+            return;
+
+        var act = _random.Pick(options);
+        if (act.Event != null)
+        {
+            act.Event.Performer = args.User;
+            act.Event.Target = args.ClickLocation;
+        }
+
+        act.Provider = uid;
+        _actions.PerformAction(args.User, null, act, act.Event, _timing.CurTime, false);
+        args.Handled = true;
+    }
+
+    private bool ValidAction(ActionType act, bool canReach = true)
+    {
+        if (!act.Enabled)
+            return false;
+
+        if (act.Charges.HasValue && act.Charges <= 0)
+            return false;
+
+        var curTime = _timing.CurTime;
+        if (act.Cooldown.HasValue && act.Cooldown.Value.End > curTime)
+            return false;
+
+        return canReach || act is TargetedAction { CheckCanAccess: false };
+    }
+}