/// <summary>
        /// Loops through all the Options of the minion. The action has 4 useful parameters to use.
        /// The first parameter refers to the Option/Multiple itself. It is a GameObject.
        /// The second parameter refers to the OptionBehavior component in the Option/Multiple.
        /// The third parameter refers to the target of the Option/Multiple owner. It is also a GameObject.
        /// The last parameter refers to the direction from the option to the target. It is a normalized Vector3.
        /// </summary>
        /// <param name="optionOwner">The owner of the option.</param>
        /// <param name="actionToRun">An action to execute for each Option. The inputs are as follows:
        /// GameObject option, OptionBehavior behavior, GameObject target, Vector3 direction.</param>
        public void FireForAllOptions(CharacterBody optionOwner, Action <GameObject, OptionBehavior, GameObject, Vector3> actionToRun)
        {
            if (!optionOwner)
            {
                return;
            }
            OptionTracker optionTracker = optionOwner.GetComponent <OptionTracker>();

            if (!optionTracker)
            {
                return;
            }

            GameObject target       = null;
            GameObject masterObject = optionOwner.masterObject;

            if (masterObject)
            {
                BaseAI        ai         = masterObject.GetComponent <BaseAI>();
                BaseAI.Target mainTarget = ai.currentEnemy;
                if (mainTarget != null && mainTarget.gameObject)
                {
                    target = mainTarget.gameObject;
                }
            }

            foreach (GameObject option in optionTracker.existingOptions)
            {
                OptionBehavior behavior = option.GetComponent <OptionBehavior>();
                if (behavior)
                {
                    Vector3 direction;
                    if (target)
                    {
                        direction = (target.transform.position - option.transform.position).normalized;
                        if (includeModelInsideOrb)
                        {
                            behavior.target = target;
                            NetworkIdentity targetNetworkIdentity = target.GetComponent <NetworkIdentity>();
                            if (targetNetworkIdentity)
                            {
                                OptionSync(optionOwner, (networkIdentity, nullTracker) =>
                                {
                                    optionTracker.targetIds.Add(Tuple.Create(
                                                                    GameObjectType.Body, networkIdentity.netId,
                                                                    (short)behavior.numbering, targetNetworkIdentity.netId
                                                                    ));
                                }, false);
                            }
                        }
                    }
                    else
                    {
                        direction = optionOwner.inputBank.GetAimRay().direction.normalized;
                    }
                    actionToRun(option, behavior, target, direction);
                }
            }
        }
Beispiel #2
0
        private void SetTarget(OptionTracker tracker, GameObject target)
        {
            GameObject     option   = tracker.existingOptions[numbering - 1];
            OptionBehavior behavior = option.GetComponent <OptionBehavior>();

            if (!behavior)
            {
                return;
            }
            behavior.target = target;
        }