Exemple #1
0
        public override Trigger Activate(IPlayable source, TriggerActivation activation = TriggerActivation.PLAY, bool cloning = false, bool asAncillary = false)
        {
            if (source.ActivatedTrigger != null && !IsAncillaryTrigger)
            {
                throw new Exceptions.EntityException($"{source} already has an activated trigger.");
            }

            var triggers = new Trigger[_triggers.Count];

            bool flag = false;

            for (int i = 0; i < triggers.Length; i++)
            {
                triggers[i] = _triggers[i]?.Activate(source, activation, cloning, true);
                if (triggers[i] != null)
                {
                    flag = true;
                }
            }

            if (!flag)
            {
                return(null);
            }

            var instance = new MultiTrigger(triggers, this, source);

            if (!IsAncillaryTrigger)
            {
                source.ActivatedTrigger = instance;
            }

            return(instance);
        }
        public bool SetTriggerActivation(TriggerActivation activation)
        {
            try
            {
                if (!mDevice.RemoteNodeList["TriggerActivation"].IsAvailable)
                {
                    return(true);;
                }

                //mDataStream.StopAcquisition();
                //mDevice.RemoteNodeList["AcquisitionStop"].Execute();
                mDevice.RemoteNodeList["TriggerActivation"].Value = Enum.GetName(typeof(TriggerActivation), activation);
                //}
                //mDataStream.StartAcquisition();
                //mDevice.RemoteNodeList["AcquisitionStart"].Execute();
                return(true);
            }
            catch (BGAPI2.Exceptions.IException ex)
            {
                string str;
                str = string.Format("ExceptionType:{0}! ErrorDescription:{1} in function:{2}", ex.GetType(), ex.GetErrorDescription(), ex.GetFunctionName());
                MessageBox.Show(str);

                return(false);
            }
        }
Exemple #3
0
        /// <summary>
        /// Create a new instance of <see cref="Trigger"/> object in source's Game. During activation, the instance's <see cref="Process(IEntity)"/> subscribes to the events in <see cref="TriggerManager"/>.
        /// </summary>
        public virtual Trigger Activate(IPlayable source, TriggerActivation activation = TriggerActivation.PLAY, bool cloning = false, bool asAncillary = false)
        {
            if (source.ActivatedTrigger != null && !IsAncillaryTrigger && !asAncillary)
            {
                throw new Exceptions.EntityException($"{source} already has an activated trigger.");
            }

            if (!cloning && activation != TriggerActivation)
            {
                if (TriggerActivation != TriggerActivation.HAND_OR_PLAY)
                {
                    return(null);
                }

                if (activation == TriggerActivation.DECK)
                {
                    return(null);
                }
            }

            var instance = new Trigger(this, source);

            if (asAncillary)
            {
                instance.IsAncillaryTrigger = true;
            }
            else if (!IsAncillaryTrigger)
            {
                source.ActivatedTrigger = instance;
            }

            if (_sequenceType != SequenceType.None)
            {
                source.Game.Triggers.Add(instance);
            }

            switch (_triggerType)
            {
            case TriggerType.DEAL_DAMAGE:
                source.Game.TriggerManager.DealDamageTrigger += instance._processHandler;
                break;

            case TriggerType.TAKE_DAMAGE:
                if (TriggerSource == TriggerSource.SELF)
                {
                    if (source is Minion m)
                    {
                        m.TakeDamageTrigger += instance._processHandler;
                    }
                    else
                    {
                        throw new NotImplementedException();
                    }
                    break;
                }
                if (TriggerSource == TriggerSource.HERO)
                {
                    source.Controller.Hero.TakeDamageTrigger += instance._processHandler;
                    break;
                }
                source.Game.TriggerManager.DamageTrigger += instance._processHandler;
                break;

            case TriggerType.HEAL:
                source.Game.TriggerManager.HealTrigger += instance._processHandler;
                break;

            case TriggerType.TURN_END:
            case TriggerType.WORGEN_TRANSFORM:
                source.Game.TriggerManager.EndTurnTrigger += instance._processHandler;
                break;

            case TriggerType.TURN_START:
                source.Game.TriggerManager.TurnStartTrigger += instance._processHandler;
                break;

            case TriggerType.SUMMON:
                source.Game.TriggerManager.SummonTrigger += instance._processHandler;
                break;

            case TriggerType.AFTER_SUMMON:
                source.Game.TriggerManager.AfterSummonTrigger += instance._processHandler;
                break;

            case TriggerType.ATTACK:
                source.Game.TriggerManager.AttackTrigger += instance._processHandler;
                break;

            case TriggerType.AFTER_ATTACK:
                switch (TriggerSource)
                {
                case TriggerSource.HERO:
                    source.Controller.Hero.AfterAttackTrigger += instance._processHandler;
                    break;

                case TriggerSource.SELF:
                    ((Minion)source).AfterAttackTrigger += instance._processHandler;
                    break;

                case TriggerSource.ENCHANTMENT_TARGET:
                    ((Minion)((Enchantment)source).Target).AfterAttackTrigger += instance._processHandler;
                    break;

                default:
                    throw new NotImplementedException();
                }
                break;

            case TriggerType.DEATH:
                source.Game.TriggerManager.DeathTrigger += instance._processHandler;
                break;

            case TriggerType.PLAY_CARD:
                source.Game.TriggerManager.PlayCardTrigger += instance._processHandler;
                break;

            case TriggerType.AFTER_PLAY_CARD:
                source.Game.TriggerManager.AfterPlayCardTrigger += instance._processHandler;
                break;

            case TriggerType.PLAY_MINION:
                source.Game.TriggerManager.PlayMinionTrigger += instance._processHandler;
                break;

            case TriggerType.AFTER_PLAY_MINION:
                source.Game.TriggerManager.AfterPlayMinionTrigger += instance._processHandler;
                break;

            case TriggerType.CAST_SPELL:
                source.Game.TriggerManager.CastSpellTrigger += instance._processHandler;
                break;

            case TriggerType.AFTER_CAST:
                source.Game.TriggerManager.AfterCastTrigger += instance._processHandler;
                break;

            case TriggerType.PREDAMAGE:
                switch (TriggerSource)
                {
                case TriggerSource.HERO:
                    source.Controller.Hero.PreDamageTrigger += instance._processHandler;
                    break;

                case TriggerSource.SELF:
                    ((Minion)source).PreDamageTrigger += instance._processHandler;
                    break;

                case TriggerSource.ENCHANTMENT_TARGET:
                    ((Minion)((Enchantment)source).Target).PreDamageTrigger += instance._processHandler;
                    break;
                }
                break;

            case TriggerType.SECRET_REVEALED:
                source.Game.TriggerManager.SecretRevealedTrigger += instance._processHandler;
                break;

            case TriggerType.ZONE:
                source.Game.TriggerManager.ZoneTrigger += instance._processHandler;
                break;

            case TriggerType.DISCARD:
                source.Game.TriggerManager.DiscardTrigger += instance._processHandler;
                break;

            case TriggerType.GAME_START:
                source.Game.TriggerManager.GameStartTrigger += instance._processHandler;
                break;

            case TriggerType.DRAW:
                source.Game.TriggerManager.DrawTrigger += instance._processHandler;
                break;

            case TriggerType.TARGET:
                source.Game.TriggerManager.TargetTrigger += instance._processHandler;
                break;

            case TriggerType.LOSE_DIVINE_SHIELD:
                source.Game.TriggerManager.LoseDivineShield += instance._processHandler;
                break;

            case TriggerType.INSPIRE:
                source.Game.TriggerManager.InspireTrigger += instance._processHandler;
                break;

            case TriggerType.FROZEN:
                source.Game.TriggerManager.FreezeTrigger += instance._processHandler;
                break;

            case TriggerType.ARMOR:
                source.Game.TriggerManager.ArmorTrigger += instance._processHandler;
                break;

            case TriggerType.EQUIP_WEAPON:
                source.Game.TriggerManager.EquipWeaponTrigger += instance._processHandler;
                break;

            case TriggerType.SHUFFLE_INTO_DECK:
                source.Game.TriggerManager.ShuffleIntoDeckTrigger += instance._processHandler;
                break;

            case TriggerType.OVERLOAD:
                source.Game.TriggerManager.OverloadTrigger += instance._processHandler;
                break;
            }

            return(instance);
        }
 public TriggerBuilder SetActivation(TriggerActivation activation)
 {
     _trigger.TriggerActivation = activation;
     return(this);
 }
Exemple #5
0
        /// <summary>
        /// Create a new instance of <see cref="Trigger"/> object in source's Game. During activation, the instance's <see cref="Process(IEntity)"/> subscribes to the events in <see cref="Game.GamesEventManager"/>.
        /// </summary>
        public void Activate(IPlayable source, TriggerActivation activation = TriggerActivation.PLAY)
        {
            if (source.ActivatedTrigger != null && !IsAncillaryTrigger)
            {
                return;
            }

            if (activation != TriggerActivation)
            {
                if (TriggerActivation != TriggerActivation.HAND_OR_PLAY)
                {
                    return;
                }

                if (activation == TriggerActivation.DECK)
                {
                    return;
                }
            }

            var instance = new Trigger(this, source);

            if (!IsAncillaryTrigger)
            {
                source.ActivatedTrigger = instance;
            }

            if (_sequenceType != SequenceType.None)
            {
                source.Game.Triggers.Add(instance);
            }

            switch (_triggerType)
            {
            case TriggerType.DEAL_DAMAGE:
                source.Game.TriggerManager.DealDamageTrigger += instance.Process;
                break;

            case TriggerType.TAKE_DAMAGE:
                if (TriggerSource == TriggerSource.SELF)
                {
                    if (source is Minion m)
                    {
                        m.PreDamageTrigger += instance.Process;
                    }
                    else
                    {
                        throw new NotImplementedException();
                    }
                    break;
                }
                source.Game.TriggerManager.DamageTrigger += instance.Process;
                break;

            case TriggerType.HEAL:
                source.Game.TriggerManager.HealTrigger += instance.Process;
                break;

            case TriggerType.TURN_END:
                source.Game.TriggerManager.EndTurnTrigger += instance.Process;
                break;

            case TriggerType.TURN_START:
                source.Game.TriggerManager.TurnStartTrigger += instance.Process;
                break;

            case TriggerType.SUMMON:
                source.Game.TriggerManager.SummonTrigger += instance.Process;
                break;

            case TriggerType.AFTER_SUMMON:
                source.Game.TriggerManager.AfterSummonTrigger += instance.Process;
                break;

            case TriggerType.ATTACK:
                source.Game.TriggerManager.AttackTrigger += instance.Process;
                break;

            case TriggerType.AFTER_ATTACK:
                switch (TriggerSource)
                {
                case TriggerSource.HERO:
                    source.Controller.Hero.AfterAttackTrigger += instance.Process;
                    break;

                case TriggerSource.SELF:
                    ((Minion)source).AfterAttackTrigger += instance.Process;
                    break;

                case TriggerSource.ENCHANTMENT_TARGET:
                    ((Minion)((Enchantment)source).Target).AfterAttackTrigger += instance.Process;
                    break;

                default:
                    throw new NotImplementedException();
                }
                break;

            case TriggerType.DEATH:
                source.Game.TriggerManager.DeathTrigger += instance.Process;
                break;

            case TriggerType.PLAY_CARD:
                source.Game.TriggerManager.PlayCardTrigger += instance.Process;
                break;

            case TriggerType.AFTER_PLAY_CARD:
                source.Game.TriggerManager.AfterPlayCardTrigger += instance.Process;
                break;

            case TriggerType.PLAY_MINION:
                source.Game.TriggerManager.PlayMinionTrigger += instance.Process;
                break;

            case TriggerType.AFTER_PLAY_MINION:
                source.Game.TriggerManager.AfterPlayMinionTrigger += instance.Process;
                break;

            case TriggerType.CAST_SPELL:
                source.Game.TriggerManager.CastSpellTrigger += instance.Process;
                break;

            case TriggerType.AFTER_CAST:
                source.Game.TriggerManager.AfterCastTrigger += instance.Process;
                break;

            case TriggerType.PREDAMAGE:
                switch (TriggerSource)
                {
                case TriggerSource.HERO:
                    source.Controller.Hero.PreDamageTrigger += instance.Process;
                    break;

                case TriggerSource.SELF:
                    ((Minion)source).PreDamageTrigger += instance.Process;
                    break;

                case TriggerSource.ENCHANTMENT_TARGET:
                    ((Minion)((Enchantment)source).Target).PreDamageTrigger += instance.Process;
                    break;
                }
                break;

            case TriggerType.SECRET_REVEALED:
                source.Game.TriggerManager.SecretRevealedTrigger += instance.Process;
                break;

            case TriggerType.ZONE:
                source.Game.TriggerManager.ZoneTrigger += instance.Process;
                break;

            case TriggerType.DISCARD:
                source.Game.TriggerManager.DiscardTrigger += instance.Process;
                break;

            case TriggerType.GAME_START:
                source.Game.TriggerManager.GameStartTrigger += instance.Process;
                break;

            case TriggerType.DRAW:
                source.Game.TriggerManager.DrawTrigger += instance.Process;
                break;

            case TriggerType.TARGET:
                source.Game.TriggerManager.TargetTrigger += instance.Process;
                break;

            case TriggerType.LOSE_DIVINE_SHIELD:
                source.Game.TriggerManager.LoseDivineShield += instance.Process;
                break;

            case TriggerType.INSPIRE:
                source.Game.TriggerManager.InspireTrigger += instance.Process;
                break;

            case TriggerType.FROZEN:
                source.Game.TriggerManager.FreezeTrigger += instance.Process;
                break;

            case TriggerType.CUSTOMTRIGGER_SHADOW_REFLECTION:
                source.Game.TriggerManager.PlayCardTrigger += instance.Process;
                source.Game.TriggerManager.EndTurnTrigger  += instance.Process;
                break;
            }
        }