private void AddSpillVerb(EntityUid uid, SpillableComponent component, GetOtherVerbsEvent args)
        {
            if (!args.CanAccess || !args.CanInteract)
            {
                return;
            }

            if (!_solutionContainerSystem.TryGetDrainableSolution(args.Target.Uid, out var solution))
            {
                return;
            }

            if (solution.DrainAvailable == ReagentUnit.Zero)
            {
                return;
            }

            Verb verb = new();

            verb.Text = Loc.GetString("spill-target-verb-get-data-text");
            // TODO VERB ICONS spill icon? pouring out a glass/beaker?
            verb.Act = () => _solutionContainerSystem.SplitSolution(args.Target.Uid,
                                                                    solution, solution.DrainAvailable).SpillAt(args.Target.Transform.Coordinates, "PuddleSmear");
            args.Verbs.Add(verb);
        }
    private void AddSpillVerb(EntityUid uid, SpillableComponent component, GetOtherVerbsEvent args)
    {
        if (!args.CanAccess || !args.CanInteract)
        {
            return;
        }

        if (!_solutionContainerSystem.TryGetDrainableSolution(args.Target, out var solution))
        {
            return;
        }

        if (solution.DrainAvailable == FixedPoint2.Zero)
        {
            return;
        }

        Verb verb = new();

        verb.Text = Loc.GetString("spill-target-verb-get-data-text");
        // TODO VERB ICONS spill icon? pouring out a glass/beaker?
        verb.Act = () =>
        {
            var puddleSolution = _solutionContainerSystem.SplitSolution(args.Target,
                                                                        solution, solution.DrainAvailable);
            SpillAt(puddleSolution, Transform(args.Target).Coordinates, "PuddleSmear");
        };
        verb.Impact = LogImpact.Medium; // dangerous reagent reaction are logged separately.
        args.Verbs.Add(verb);
    }
        private void AddRotateVerbs(EntityUid uid, RotatableComponent component, GetOtherVerbsEvent args)
        {
            if (!args.CanAccess || !args.CanInteract)
            {
                return;
            }

            // Check if the object is anchored, and whether we are still allowed to rotate it.
            if (!component.RotateWhileAnchored &&
                EntityManager.TryGetComponent(component.Owner, out IPhysBody? physics) &&
                physics.BodyType == BodyType.Static)
            {
                return;
            }

            Verb resetRotation = new ()
            {
                Act         = () => EntityManager.GetComponent <TransformComponent>(component.Owner).LocalRotation = Angle.Zero,
                Category    = VerbCategory.Rotate,
                IconTexture = "/Textures/Interface/VerbIcons/refresh.svg.192dpi.png",
                Text        = "Reset",
                Priority    = -2, // show CCW, then CW, then reset
                CloseMenu   = false,
            };

            args.Verbs.Add(resetRotation);

            // rotate clockwise
            Verb rotateCW = new()
            {
                Act         = () => EntityManager.GetComponent <TransformComponent>(component.Owner).LocalRotation -= component.Increment,
                Category    = VerbCategory.Rotate,
                IconTexture = "/Textures/Interface/VerbIcons/rotate_cw.svg.192dpi.png",
                Priority    = -1,
                CloseMenu   = false, // allow for easy double rotations.
            };

            args.Verbs.Add(rotateCW);

            // rotate counter-clockwise
            Verb rotateCCW = new()
            {
                Act         = () => EntityManager.GetComponent <TransformComponent>(component.Owner).LocalRotation += component.Increment,
                Category    = VerbCategory.Rotate,
                IconTexture = "/Textures/Interface/VerbIcons/rotate_ccw.svg.192dpi.png",
                Priority    = 0,
                CloseMenu   = false, // allow for easy double rotations.
            };

            args.Verbs.Add(rotateCCW);
        }
        private void AddFlipVerb(EntityUid uid, FlippableComponent component, GetOtherVerbsEvent args)
        {
            if (!args.CanAccess || !args.CanInteract || component.MirrorEntity == null)
            {
                return;
            }

            Verb verb = new();

            verb.Act  = () => TryFlip(component, args.User);
            verb.Text = Loc.GetString("flippable-verb-get-data-text");
            // TODO VERB ICONS Add Uno reverse card style icon?
            args.Verbs.Add(verb);
        }
示例#5
0
        private void AddExamineVerb(GetOtherVerbsEvent args)
        {
            if (!CanExamine(args.User, args.Target))
            {
                return;
            }

            Verb verb = new();

            verb.Act         = () => DoExamine(args.Target);
            verb.Text        = Loc.GetString("examine-verb-name");
            verb.IconTexture = "/Textures/Interface/VerbIcons/examine.svg.192dpi.png";
            args.Verbs.Add(verb);
        }
示例#6
0
        private void AddAdminVerbs(GetOtherVerbsEvent args)
        {
            // Currently this is only the ViewVariables verb, but more admin-UI related verbs can be added here.

            // View variables verbs
            if (_clientConGroupController.CanViewVar())
            {
                Verb verb = new();
                verb.Category    = VerbCategory.Debug;
                verb.Text        = "View Variables";
                verb.IconTexture = "/Textures/Interface/VerbIcons/vv.svg.192dpi.png";
                verb.Act         = () => _viewVariablesManager.OpenVV(args.Target);
                args.Verbs.Add(verb);
            }
        }
        private void AddAdminVerbs(GetOtherVerbsEvent args)
        {
            // Currently this is only the ViewVariables verb, but more admin-UI related verbs can be added here.

            // View variables verbs
            if (_clientConGroupController.CanViewVar())
            {
                Verb verb = new();
                verb.Category        = VerbCategory.Debug;
                verb.Text            = "View Variables";
                verb.IconTexture     = "/Textures/Interface/VerbIcons/vv.svg.192dpi.png";
                verb.Act             = () => _clientConsoleHost.ExecuteCommand($"vv {args.Target}");
                verb.ClientExclusive = true; // opening VV window is client-side. Don't ask server to run this verb.
                args.Verbs.Add(verb);
            }
        }
示例#8
0
        private void AddRotateVerbs(EntityUid uid, RotatableComponent component, GetOtherVerbsEvent args)
        {
            if (!args.CanAccess || !args.CanInteract)
            {
                return;
            }

            // Check if the object is anchored, and whether we are still allowed to rotate it.
            if (!component.RotateWhileAnchored &&
                component.Owner.TryGetComponent(out IPhysBody? physics) &&
                physics.BodyType == BodyType.Static)
            {
                return;
            }

            Verb resetRotation = new();

            resetRotation.Act         = () => component.Owner.Transform.LocalRotation = Angle.Zero;
            resetRotation.Category    = VerbCategory.Rotate;
            resetRotation.IconTexture = "/Textures/Interface/VerbIcons/refresh.svg.192dpi.png";
            resetRotation.Text        = "Reset";
            resetRotation.Priority    = -2; // show CCW, then CW, then reset
            resetRotation.CloseMenu   = false;
            args.Verbs.Add(resetRotation);

            // rotate clockwise
            Verb rotateCW = new();

            rotateCW.Act         = () => component.Owner.Transform.LocalRotation += Angle.FromDegrees(-90);
            rotateCW.Category    = VerbCategory.Rotate;
            rotateCW.IconTexture = "/Textures/Interface/VerbIcons/rotate_cw.svg.192dpi.png";
            rotateCW.Priority    = -1;
            rotateCW.CloseMenu   = false; // allow for easy double rotations.
            args.Verbs.Add(rotateCW);

            // rotate counter-clockwise
            Verb rotateCCW = new();

            rotateCCW.Act         = () => component.Owner.Transform.LocalRotation += Angle.FromDegrees(90);
            rotateCCW.Category    = VerbCategory.Rotate;
            rotateCCW.IconTexture = "/Textures/Interface/VerbIcons/rotate_ccw.svg.192dpi.png";
            rotateCCW.Priority    = 0;
            rotateCCW.CloseMenu   = false; // allow for easy double rotations.
            args.Verbs.Add(rotateCCW);
        }
        private void AddStripVerb(EntityUid uid, StrippableComponent component, GetOtherVerbsEvent args)
        {
            if (args.Hands == null || !args.CanAccess || !args.CanInteract || args.Target == args.User)
            {
                return;
            }

            if (!args.User.TryGetComponent(out ActorComponent? actor))
            {
                return;
            }

            Verb verb = new();

            verb.Text        = Loc.GetString("strip-verb-get-data-text");
            verb.IconTexture = "/Textures/Interface/VerbIcons/outfit.svg.192dpi.png";
            verb.Act         = () => component.OpenUserInterface(actor.PlayerSession);
            args.Verbs.Add(verb);
        }
示例#10
0
        private void AddUncuffVerb(EntityUid uid, CuffableComponent component, GetOtherVerbsEvent args)
        {
            // Can the user access the cuffs, and is there even anything to uncuff?
            if (!args.CanAccess || component.CuffedHandCount == 0)
            {
                return;
            }

            // We only check can interact if the user is not uncuffing themselves. As a result, the verb will show up
            // when the user is incapacitated & trying to uncuff themselves, but TryUncuff() will still fail when
            // attempted.
            if (args.User != args.Target && !args.CanInteract)
            {
                return;
            }

            Verb verb = new();

            verb.Act  = () => component.TryUncuff(args.User);
            verb.Text = Loc.GetString("uncuff-verb-get-data-text");
            //TODO VERB ICON add uncuffing symbol? may re-use the alert symbol showing that you are currently cuffed?
            args.Verbs.Add(verb);
        }
        private void AddDeconstructVerb(EntityUid uid, ConstructionComponent component, GetOtherVerbsEvent args)
        {
            if (!args.CanAccess)
            {
                return;
            }

            if (component.TargetNode == component.DeconstructionNode ||
                component.Node == component.DeconstructionNode)
            {
                return;
            }

            Verb verb = new();

            //verb.Category = VerbCategories.Construction;
            //TODO VERBS add more construction verbs? Until then, removing construction category
            verb.Text        = Loc.GetString("deconstructible-verb-begin-deconstruct");
            verb.IconTexture = "/Textures/Interface/hammer_scaled.svg.192dpi.png";

            verb.Act = () =>
            {
                SetPathfindingTarget(uid, component.DeconstructionNode, component);
                if (component.TargetNode == null)
                {
                    // Maybe check, but on the flip-side a better solution might be to not make it undeconstructible in the first place, no?
                    component.Owner.PopupMessage(args.User, Loc.GetString("deconstructible-verb-activate-no-target-text"));
                }
                else
                {
                    component.Owner.PopupMessage(args.User, Loc.GetString("deconstructible-verb-activate-text"));
                }
            };

            args.Verbs.Add(verb);
        }
示例#12
0
        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);
            }

            if (_adminManager.HasAdminFlag(player, AdminFlags.Fun))
            {
                Verb verb = new();
                verb.Text     = Loc.GetString("explode-verb-get-data-text");
                verb.Category = VerbCategory.Debug;
                verb.Act      = () =>
                {
                    var coords = args.Target.Transform.Coordinates;
                    Timer.Spawn(_gameTiming.TickPeriod, () => ExplosionHelper.SpawnExplosion(coords, 0, 1, 2, 1), CancellationToken.None);
                    if (args.Target.TryGetComponent(out SharedBodyComponent? body))
                    {
                        body.Gib();
                    }
                };
                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);
            }
        }
    }