public override void Effect(ReagentEffectArgs args)
    {
        if (args.EntityManager.TryGetComponent(args.SolutionEntity, out SharedActionsComponent? actions))
        {
            if (!IoCManager.Resolve <IPrototypeManager>().TryIndex <ActionPrototype>(Action, out var proto))
            {
                return;
            }

            if (actions.IsGranted(proto.ActionType))
            {
                var attempt = new ActionAttempt(proto);
                attempt.DoInstantAction(args.SolutionEntity);
            }
        }
    }
        private IActionAttempt?ActionAttempt(BasePerformActionMessage message, ICommonSession session)
        {
            IActionAttempt?attempt;

            switch (message)
            {
            case PerformActionMessage performActionMessage:
                if (!ActionManager.TryGet(performActionMessage.ActionType, out var action))
                {
                    Logger.DebugS("action", "user {0} attempted to perform" +
                                  " unrecognized action {1}", session.AttachedEntity,
                                  performActionMessage.ActionType);
                    return(null);
                }
                attempt = new ActionAttempt(action);
                break;

            case PerformItemActionMessage performItemActionMessage:
                if (!ActionManager.TryGet(performItemActionMessage.ActionType, out var itemAction))
                {
                    Logger.DebugS("action", "user {0} attempted to perform" +
                                  " unrecognized item action {1}",
                                  session.AttachedEntity, performItemActionMessage.ActionType);
                    return(null);
                }

                if (!EntityManager.TryGetEntity(performItemActionMessage.Item, out var item))
                {
                    Logger.DebugS("action", "user {0} attempted to perform" +
                                  " item action {1} for unknown item {2}",
                                  session.AttachedEntity, performItemActionMessage.ActionType, performItemActionMessage.Item);
                    return(null);
                }

                if (!item.TryGetComponent <ItemActionsComponent>(out var actionsComponent))
                {
                    Logger.DebugS("action", "user {0} attempted to perform" +
                                  " item action {1} for item {2} which has no ItemActionsComponent",
                                  session.AttachedEntity, performItemActionMessage.ActionType, item);
                    return(null);
                }

                if (actionsComponent.Holder != session.AttachedEntity)
                {
                    Logger.DebugS("action", "user {0} attempted to perform" +
                                  " item action {1} for item {2} which they are not holding",
                                  session.AttachedEntity, performItemActionMessage.ActionType, item);
                    return(null);
                }

                attempt = new ItemActionAttempt(itemAction, item, actionsComponent);
                break;

            default:
                return(null);
            }

            if (message.BehaviorType != attempt.Action.BehaviorType)
            {
                Logger.DebugS("action", "user {0} attempted to" +
                              " perform action {1} as a {2} behavior, but this action is actually a" +
                              " {3} behavior", session.AttachedEntity, attempt, message.BehaviorType,
                              attempt.Action.BehaviorType);
                return(null);
            }

            return(attempt);
        }