public void TriggerSelectedTarget(object target, object sender, object arg, BlockingTriggerYieldInstruction instruction = null)
 {
     if (target is IProxy)
     {
         target = (target as IProxy).GetTarget();
     }
     if (target != null && target is ITriggerableMechanism)
     {
         if (instruction != null && target is IBlockingTriggerableMechanism)
         {
             var t = target as IBlockingTriggerableMechanism;
             if (t.CanTrigger)
             {
                 t.Trigger(sender, arg);
             }
         }
         else
         {
             var t = target as ITriggerableMechanism;
             if (t.CanTrigger)
             {
                 t.Trigger(sender, arg);
             }
         }
     }
 }
Example #2
0
        public void TriggerYielding(object arg, BlockingTriggerYieldInstruction instruction)
        {
            if (this._triggerable == null)
            {
                return;
            }

            var arg0 = (this._triggerableArgs != null && this._triggerableArgs.Length > 0) ? this._triggerableArgs[0].Value : arg;

            this.Trigger_Imp(arg0, instruction);
        }
Example #3
0
        public void TriggerYielding(object sender, BlockingTriggerYieldInstruction instruction)
        {
            if (this._triggerable == null)
            {
                return;
            }

            var arg = (this._triggerableArgs != null && this._triggerableArgs.Length > 0) ? this._triggerableArgs[0].Value : null;

            this.Trigger_Imp(sender, null, arg, instruction);
        }
        public void DaisyChainTriggerYielding(object arg, BlockingTriggerYieldInstruction instruction)
        {
            if (_targets.Count > 0)
            {
                var e = _targets.GetEnumerator();
                while (e.MoveNext())
                {
                    if (e.Current != null)
                    {
                        e.Current.Trigger(arg);
                    }
                }

                this.OnTriggerActivated(arg);
            }
        }
        protected void DaisyChainTriggerYielding(object sender, object arg, BlockingTriggerYieldInstruction instruction)
        {
            if (_targets.Count > 0 && !this.CurrentlyHijacked)
            {
                var e = _targets.GetEnumerator();
                while (e.MoveNext())
                {
                    if (e.Current != null)
                    {
                        e.Current.Trigger(sender, arg);
                    }
                }

                this.OnTriggerActivated(sender, arg);
            }
        }
        public IRadicalYieldInstruction ActivateTriggerYielding(object arg)
        {
            if (_yield && _targets.Count > 0)
            {
                var instruction = BlockingTriggerYieldInstruction.Create();

                var e = _targets.GetEnumerator();
                while (e.MoveNext())
                {
                    if (e.Current != null)
                    {
                        e.Current.Trigger(arg);
                    }
                }

                this.OnTriggerActivated(arg);

                return((instruction.Count > 0) ? instruction : null);
            }
            else
            {
                if (_targets.Count > 0)
                {
                    var e = _targets.GetEnumerator();
                    while (e.MoveNext())
                    {
                        if (e.Current != null)
                        {
                            e.Current.Trigger(arg);
                        }
                    }
                }

                this.OnTriggerActivated(arg);

                return(null);
            }
        }
Example #7
0
 public new void DaisyChainTriggerYielding(object sender, object arg, BlockingTriggerYieldInstruction instruction)
 {
     base.DaisyChainTriggerYielding(sender, arg, instruction);
 }
Example #8
0
 public void DaisyChainTriggerYielding(object sender, T arg, BlockingTriggerYieldInstruction instruction)
 {
     base.DaisyChainTriggerYielding(sender, arg, instruction);
     this.OnTriggerActivated(sender, arg);
 }
Example #9
0
        private void Trigger_Imp(object arg, BlockingTriggerYieldInstruction instruction)
        {
            switch (this._activationType)
            {
            case TriggerActivationType.TriggerAllOnTarget:
            {
                if (_triggerAllCache == null)
                {
                    //_triggerAllCache = (from t in this._triggerable.GetComponentsAlt<ITriggerableMechanism>() orderby t.Order ascending select t).ToArray();
                    _triggerAllCache = _triggerable.GetComponentsAlt <ITriggerableMechanism>();
                    System.Array.Sort(_triggerableArgs, MechanismComparer.Default);
                }
                if (instruction != null)
                {
                    foreach (var t in _triggerAllCache)
                    {
                        if (t.component != null && t.CanTrigger)
                        {
                            if (t is IBlockingTriggerableMechanism)
                            {
                                (t as IBlockingTriggerableMechanism).Trigger(arg, instruction);
                            }
                            else
                            {
                                t.Trigger(arg);
                            }
                        }
                    }
                }
                else
                {
                    foreach (var t in _triggerAllCache)
                    {
                        if (t.component != null && t.CanTrigger)
                        {
                            t.Trigger(arg);
                        }
                    }
                }
            }
            break;

            case TriggerActivationType.TriggerSelectedTarget:
            {
                if (_triggerable != null && _triggerable is ITriggerableMechanism)
                {
                    if (instruction != null && _triggerable is IBlockingTriggerableMechanism)
                    {
                        var t = _triggerable as IBlockingTriggerableMechanism;
                        if (t.CanTrigger)
                        {
                            t.Trigger(arg);
                        }
                    }
                    else
                    {
                        var t = _triggerable as ITriggerableMechanism;
                        if (t.CanTrigger)
                        {
                            t.Trigger(arg);
                        }
                    }
                }
            }
            break;

            case TriggerActivationType.SendMessage:
            {
                var go = GameObjectUtil.GetGameObjectFromSource(this._triggerable);
                if (go != null && this._methodName != null)
                {
                    go.SendMessage(this._methodName, arg, SendMessageOptions.DontRequireReceiver);
                }
            }
            break;

            case TriggerActivationType.CallMethodOnSelectedTarget:
            {
                if (this._methodName != null)
                {
                    //CallMethod does not support using the passed in arg
                    //var args = (from a in this._triggerableArgs select (a != null) ? a.Value : null).ToArray();

                    object[] args = null;
                    if (_triggerableArgs != null && _triggerableArgs.Length > 0)
                    {
                        args = new object[_triggerableArgs.Length];
                        for (int i = 0; i < args.Length; i++)
                        {
                            if (_triggerableArgs[i] != null)
                            {
                                args[i] = _triggerableArgs[i].Value;
                            }
                        }
                    }

                    if (args != null && args.Length == 1)
                    {
                        DynamicUtil.SetValue(this._triggerable, this._methodName, args[0]);
                    }
                    else
                    {
                        DynamicUtil.InvokeMethod(this._triggerable, this._methodName, args);
                    }
                }
            }
            break;

            case TriggerActivationType.EnableTarget:
            {
                var go = GameObjectUtil.GetGameObjectFromSource(_triggerable);
                if (go != null)
                {
                    switch (ConvertUtil.ToEnum <EnableMode>(_methodName))
                    {
                    case EnableMode.Disable:
                        go.SetActive(false);
                        break;

                    case EnableMode.Enable:
                        go.SetActive(true);
                        break;

                    case EnableMode.Toggle:
                        go.SetActive(!go.activeSelf);
                        break;
                    }
                }
            }
            break;
            }
        }
Example #10
0
        /*
         *
         * private void Trigger_Imp_Old(object sender, object arg, BlockingTriggerYieldInstruction instruction)
         * {
         *  switch (this._activationType)
         *  {
         *      case TriggerActivationType.TriggerAllOnTarget:
         *          {
         *              if (_triggerAllCache == null)
         *              {
         *                  //_triggerAllCache = (from t in this._triggerable.GetComponentsAlt<ITriggerableMechanism>() orderby t.Order ascending select t).ToArray();
         *                  _triggerAllCache = _triggerable.GetComponentsAlt<ITriggerableMechanism>();
         *                  System.Array.Sort(_triggerableArgs, MechanismComparer.Default);
         *              }
         *              if (instruction != null)
         *              {
         *                  foreach (var t in _triggerAllCache)
         *                  {
         *                      if (t.component != null && t.CanTrigger)
         *                      {
         *                          if (t is IBlockingTriggerableMechanism)
         *                              (t as IBlockingTriggerableMechanism).Trigger(arg, instruction);
         *                          else
         *                              t.Trigger(arg);
         *                      }
         *                  }
         *              }
         *              else
         *              {
         *                  foreach (var t in _triggerAllCache)
         *                  {
         *                      if (t.component != null && t.CanTrigger)
         *                      {
         *                          t.Trigger(arg);
         *                      }
         *                  }
         *              }
         *          }
         *          break;
         *      case TriggerActivationType.TriggerSelectedTarget:
         *          {
         *              if (_triggerable != null && _triggerable is ITriggerableMechanism)
         *              {
         *                  if (instruction != null && _triggerable is IBlockingTriggerableMechanism)
         *                  {
         *                      var t = _triggerable as IBlockingTriggerableMechanism;
         *                      if (t.CanTrigger) t.Trigger(arg);
         *                  }
         *                  else
         *                  {
         *                      var t = _triggerable as ITriggerableMechanism;
         *                      if (t.CanTrigger) t.Trigger(arg);
         *                  }
         *              }
         *          }
         *          break;
         *      case TriggerActivationType.SendMessage:
         *          {
         *              var go = GameObjectUtil.GetGameObjectFromSource(this._triggerable);
         *              if (go != null && this._methodName != null)
         *              {
         *                  go.SendMessage(this._methodName, arg, SendMessageOptions.DontRequireReceiver);
         *              }
         *          }
         *          break;
         *      case TriggerActivationType.CallMethodOnSelectedTarget:
         *          {
         *              if (this._methodName != null)
         *              {
         *                  //CallMethod does not support using the passed in arg
         *                  //var args = (from a in this._triggerableArgs select (a != null) ? a.Value : null).ToArray();
         *
         *                  object[] args = null;
         *                  if (_triggerableArgs != null && _triggerableArgs.Length > 0)
         *                  {
         *                      args = new object[_triggerableArgs.Length];
         *                      for (int i = 0; i < args.Length; i++)
         *                      {
         *                          if (_triggerableArgs[i] != null) args[i] = _triggerableArgs[i].Value;
         *                      }
         *                  }
         *
         *                  if (args != null && args.Length == 1)
         *                  {
         *                      DynamicUtil.SetValue(this._triggerable, this._methodName, args[0]);
         *                  }
         *                  else
         *                  {
         *                      DynamicUtil.InvokeMethod(this._triggerable, this._methodName, args);
         *                  }
         *              }
         *          }
         *          break;
         *      case TriggerActivationType.EnableTarget:
         *          {
         *              var go = GameObjectUtil.GetGameObjectFromSource(_triggerable);
         *              if (go != null)
         *              {
         *                  switch (ConvertUtil.ToEnum<EnableMode>(_methodName))
         *                  {
         *                      case EnableMode.Disable:
         *                          go.SetActive(false);
         *                          break;
         *                      case EnableMode.Enable:
         *                          go.SetActive(true);
         *                          break;
         *                      case EnableMode.Toggle:
         *                          go.SetActive(!go.activeSelf);
         *                          break;
         *                  }
         *              }
         *          }
         *          break;
         *      case TriggerActivationType.DestroyTarget:
         *          {
         *              var go = GameObjectUtil.GetGameObjectFromSource(_triggerable);
         *              if (go != null)
         *              {
         *                  ObjUtil.SmartDestroy(go);
         *              }
         *          }
         *          break;
         *  }
         * }
         *
         */

        #endregion



        #region Static Methods

        public static void TriggerAllOnTarget(object target, object sender, object arg, BlockingTriggerYieldInstruction instruction = null)
        {
            //var go = GameObjectUtil.GetGameObjectFromSource(target);
            //if (go == null) return;

            using (var lst = com.spacepuppy.Collections.TempCollection.GetList <ITriggerableMechanism>())
            {
                var go = GameObjectUtil.GetGameObjectFromSource(target);
                if (go != null)
                {
                    go.GetComponents <ITriggerableMechanism>(lst);
                    lst.Sort(TriggerableMechanismOrderComparer.Default);
                }
                else if (target is ITriggerableMechanism)
                {
                    lst.Add(target as ITriggerableMechanism);
                }

                if (instruction != null)
                {
                    var e = lst.GetEnumerator();
                    while (e.MoveNext())
                    {
                        var t = e.Current;
                        if (t.CanTrigger)
                        {
                            if (t is IBlockingTriggerableMechanism)
                            {
                                (t as IBlockingTriggerableMechanism).Trigger(sender, arg, instruction);
                            }
                            else
                            {
                                t.Trigger(sender, arg);
                            }
                        }
                    }
                }
                else
                {
                    var e = lst.GetEnumerator();
                    while (e.MoveNext())
                    {
                        var t = e.Current;
                        if (t.CanTrigger)
                        {
                            t.Trigger(sender, arg);
                        }
                    }
                }
            }
        }
Example #11
0
        private void Trigger_Imp(object sender, object incomingArg, object outgoingArg, BlockingTriggerYieldInstruction instruction)
        {
            switch (this._activationType)
            {
            case TriggerActivationType.TriggerAllOnTarget:
            {
                if (_triggerAllCache == null)
                {
                    //_triggerAllCache = _triggerable.GetComponentsAlt<ITriggerableMechanism>();
                    var go = GameObjectUtil.GetGameObjectFromSource(_triggerable);
                    if (go != null)
                    {
                        _triggerAllCache = go.GetComponents <ITriggerableMechanism>();
                    }
                    else if (_triggerable is ITriggerableMechanism)
                    {
                        _triggerAllCache = new ITriggerableMechanism[] { _triggerable as ITriggerableMechanism }
                    }
                    ;
                    else
                    {
                        _triggerAllCache = ArrayUtil.Empty <ITriggerableMechanism>();
                    }

                    if (_triggerableArgs.Length > 1)
                    {
                        System.Array.Sort(_triggerableArgs, TriggerableMechanismOrderComparer.Default);
                    }
                }
                if (instruction != null)
                {
                    foreach (var t in _triggerAllCache)
                    {
                        if (t.CanTrigger)
                        {
                            if (t is IBlockingTriggerableMechanism)
                            {
                                (t as IBlockingTriggerableMechanism).Trigger(sender, outgoingArg, instruction);
                            }
                            else
                            {
                                t.Trigger(sender, outgoingArg);
                            }
                        }
                    }
                }
                else
                {
                    foreach (var t in _triggerAllCache)
                    {
                        if (t.CanTrigger)
                        {
                            t.Trigger(sender, outgoingArg);
                        }
                    }
                }
            }
            break;

            case TriggerActivationType.TriggerSelectedTarget:
            {
                //UnityEngine.Object targ = _triggerable;
                //if (targ is IProxy) targ = (targ as IProxy).GetTarget(incomingArg);
                //TriggerSelectedTarget(targ, sender, outgoingArg, instruction);
                TriggerSelectedTarget(_triggerable, sender, outgoingArg, instruction);
            }
            break;

            case TriggerActivationType.SendMessage:
            {
                object targ = _triggerable;
                if (targ is IProxy)
                {
                    targ = (targ as IProxy).GetTarget(incomingArg);
                }
                SendMessageToTarget(targ, _methodName, outgoingArg);
            }
            break;

            case TriggerActivationType.CallMethodOnSelectedTarget:
            {
                CallMethodOnSelectedTarget(_triggerable, _methodName, _triggerableArgs);
            }
            break;

            case TriggerActivationType.EnableTarget:
            {
                object targ = _triggerable;
                if (targ is IProxy)
                {
                    targ = (targ as IProxy).GetTarget(incomingArg);
                }
                EnableTarget(_triggerable, ConvertUtil.ToEnum <EnableMode>(_methodName));
            }
            break;

            case TriggerActivationType.DestroyTarget:
            {
                object targ = _triggerable;
                if (targ is IProxy)
                {
                    targ = (targ as IProxy).GetTarget(incomingArg);
                }
                DestroyTarget(_triggerable);
            }
            break;
            }
        }
        public void TriggerAllOnTarget(object target, object sender, object arg, BlockingTriggerYieldInstruction instruction = null)
        {
            if (target is IProxy)
            {
                target = (target as IProxy).GetTarget();
            }
            var go = GameObjectUtil.GetGameObjectFromSource(target);

            if (go != null)
            {
                var arr = this.GetCache(go);

                if (instruction != null)
                {
                    foreach (var t in arr)
                    {
                        if (t.CanTrigger)
                        {
                            if (t is IBlockingTriggerableMechanism)
                            {
                                (t as IBlockingTriggerableMechanism).Trigger(sender, arg, instruction);
                            }
                            else
                            {
                                t.Trigger(sender, arg);
                            }
                        }
                    }
                }
                else
                {
                    foreach (var t in arr)
                    {
                        if (t.CanTrigger)
                        {
                            t.Trigger(sender, arg);
                        }
                    }
                }
            }
            else
            {
                var targ = target as ITriggerableMechanism;
                if (targ != null)
                {
                    if (instruction != null)
                    {
                        if (targ.CanTrigger)
                        {
                            if (targ is IBlockingTriggerableMechanism)
                            {
                                (targ as IBlockingTriggerableMechanism).Trigger(sender, arg, instruction);
                            }
                            else
                            {
                                targ.Trigger(sender, arg);
                            }
                        }
                    }
                    else
                    {
                        if (targ.CanTrigger)
                        {
                            targ.Trigger(sender, arg);
                        }
                    }
                }
            }
        }
        private void Trigger_Imp(object sender, object incomingArg, object outgoingArg, BlockingTriggerYieldInstruction instruction)
        {
            try
            {
                switch (this._activationType)
                {
                case TriggerActivationType.TriggerAllOnTarget:
                {
                    EventTriggerEvaluator.Current.TriggerAllOnTarget((_triggerable is IProxy) ? (_triggerable as IProxy).GetTarget(incomingArg) : _triggerable,
                                                                     sender, outgoingArg, instruction);
                }
                break;

                case TriggerActivationType.TriggerSelectedTarget:
                {
                    EventTriggerEvaluator.Current.TriggerSelectedTarget((_triggerable is IProxy) ? (_triggerable as IProxy).GetTarget(incomingArg) : _triggerable,
                                                                        sender, outgoingArg, instruction);
                }
                break;

                case TriggerActivationType.SendMessage:
                {
                    EventTriggerEvaluator.Current.SendMessageToTarget((_triggerable is IProxy) ? (_triggerable as IProxy).GetTarget(incomingArg) : _triggerable,
                                                                      _methodName, outgoingArg);
                }
                break;

                case TriggerActivationType.CallMethodOnSelectedTarget:
                {
                    EventTriggerEvaluator.Current.CallMethodOnSelectedTarget((_triggerable is IProxy) ? (_triggerable as IProxy).GetTarget(incomingArg) : _triggerable,
                                                                             _methodName, _triggerableArgs);
                }
                break;

                case TriggerActivationType.EnableTarget:
                {
                    EventTriggerEvaluator.Current.EnableTarget((_triggerable is IProxy) ? (_triggerable as IProxy).GetTarget(incomingArg) : _triggerable,
                                                               ConvertUtil.ToEnum <EnableMode>(_methodName));
                }
                break;

                case TriggerActivationType.DestroyTarget:
                {
                    EventTriggerEvaluator.Current.DestroyTarget((_triggerable is IProxy) ? (_triggerable as IProxy).GetTarget(incomingArg) : _triggerable);
                }
                break;
                }
            }
            catch (System.Exception ex)
            {
                Debug.LogException(ex, sender as UnityEngine.Object);
            }
        }