removing switch, currently causes issues with variable declarations.

Assets/CardEffect/BT16/Blue/Angemon_BT16_019.cs

@@ -1,5 +1,7 @@
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
+using System;
 
 namespace DCGO.CardEffects.BT16
 {
@@ -9,175 +11,241 @@ namespace DCGO.CardEffects.BT16
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             var cardEffects = new List<ICardEffect>();
-            
-            switch (timing)
+
+            #region Alternate Digivolution Requirement
+            if(timing == EffectTiming.None)
             {
-                case EffectTiming.None:
-                    #region Alternate Digivolution Requirement
-                    
-                    bool PermanentCondition(Permanent targetPermanent)
-                    {
-                        return targetPermanent.TopCard.CardNames.Contains("Patamon");
-                    }
-                    
-                    cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
-                        permanentCondition: PermanentCondition,
-                        digivolutionCost: 2,
-                        ignoreDigivolutionRequirement: false,
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.CardNames.Contains("Patamon");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 2,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null)
+                );
+            }
+            #endregion
+
+            #region Raid
+            if(timing == EffectTiming.OnAllyAttack)
+            {
+                cardEffects.Add(CardEffectFactory.RaidSelfEffect(
+                        isInheritedEffect: false,
                         card: card,
                         condition: null)
                     );
-                    
-                    #endregion
-                    
-                    
-                    #region Inherited Effect
-                    
-                    ActivateClass activateClass = new ActivateClass();
-                    activateClass.SetUpICardEffect("Trash 1 digivolution card", CanUseCondition, card);
-                    activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false,
-                        EffectDiscription());
-                    activateClass.SetIsInheritedEffect(true);
-                    cardEffects.Add(activateClass);
-                    
-                    string EffectDiscription()
-                    {
-                        return "[When Attacking] Trash the top digivolution card of 1 of your opponent's Digimon.";
-                    }
-                    
-                    bool CanSelectPermanentCondition(Permanent permanent)
-                    {
-                        return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card)
-                               && permanent.DigivolutionCards.Count(cardSource =>
-                                   !cardSource.CanNotTrashFromDigivolutionCards(activateClass)) >= 1;
-                    }
-                    
-                    bool CanUseCondition(Hashtable hashtable)
-                    {
-                        return CardEffectCommons.CanTriggerOnAttack(hashtable, card);
-                    }
-                    
-                    bool CanActivateCondition(Hashtable hashtable)
-                    {
-                        return CardEffectCommons.IsExistOnBattleArea(card) &&
-                               CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition);
-                    }
-                    
-                    IEnumerator ActivateCoroutine(Hashtable hashtable)
+            }
+            #endregion
+
+            #region On Play
+            if(timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Select 1 of your Digimon to gain effects", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[On Play] 1 of your Digimon can't be deleted in battle until the end of your opponent's turn.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(card);
+                }
+
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectPermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: SelectPermanentCoroutine,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Custom,
+                        cardEffect: activateClass);
+
+                    selectPermanentEffect.SetUpCustomMessage(
+                        "Select 1 Digimon that will get effects.",
+                        "The opponent is selecting 1 Digimon that will get effects.");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
                     {
-                        var maxCount = Math.Min(1,
-                            CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-                        var selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-                        
-                        selectPermanentEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: CanSelectPermanentCondition,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: maxCount,
-                            canNoSelect: false,
-                            canEndNotMax: false,
-                            selectPermanentCoroutine: SelectPermanentCoroutine,
-                            afterSelectPermanentCoroutine: null,
-                            mode: SelectPermanentEffect.Mode.Custom,
-                            cardEffect: activateClass);
-                        
-                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will trash digivolution cards.",
-                            "The opponent is selecting 1 Digimon that will trash digivolution cards.");
-                        
-                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                        yield break;
-                        
-                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotBeDeletedByBattle(
+                            targetPermanent: permanent,
+                            canNotBeDestroyedByBattleCondition: CanNotBeDestroyedByBattleCondition,
+                            effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                            activateClass: activateClass,
+                            effectName: "Can't be deleted in battle"));
+
+                        bool CanNotBeDestroyedByBattleCondition(Permanent permanent1, Permanent attackingPermanent, Permanent defendingPermanent, CardSource defendingCard)
                         {
-                            yield return ContinuousController.instance.StartCoroutine(
-                                CardEffectCommons.TrashDigivolutionCardsFromTopOrBottom(targetPermanent: permanent,
-                                    trashCount: 1, isFromTop: true, activateClass: activateClass));
+                            return permanent == attackingPermanent || permanent == defendingPermanent;
                         }
                     }
-                    
-                    #endregion
-                    
-                    
-                    
-                    
-                    break;
-                case EffectTiming.OnAllyAttack:
-                    cardEffects.Add(CardEffectFactory.RaidSelfEffect(
-                        isInheritedEffect: false,
-                        card: card,
-                        condition: null)
-                    );
-                    break;
-                case EffectTiming.OnEnterFieldAnyone:
-                    var activateClass = new ActivateClass();
-                    activateClass.SetUpICardEffect("Select 1 of your Digimon to gain effects", CanUseCondition, card);
-                    activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
-                    cardEffects.Add(activateClass);
-
-                    string EffectDiscription()
-                    {
-                        return "[On Play] [When Digivolving] 1 of your Digimon can't be deleted in battle until the end of your opponent's turn.";
-                    }
+                }
+            }
+            #endregion
 
-                    bool CanUseCondition(Hashtable hashtable)
-                    {
-                        return CardEffectCommons.CanTriggerOnPlay(hashtable, card)
-                               || CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
-                    }
+            #region When Digivolving
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Select 1 of your Digimon to gain effects", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                cardEffects.Add(activateClass);
 
-                    bool CanActivateCondition(Hashtable hashtable)
-                    {
-                        return CardEffectCommons.IsExistOnBattleArea(card);
-                    }
-                    
-                    bool CanSelectPermanentCondition(Permanent permanent)
-                    {
-                        return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
-                    }
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] 1 of your Digimon can't be deleted in battle until the end of your opponent's turn.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(card);
+                }
+
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectPermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: SelectPermanentCoroutine,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Custom,
+                        cardEffect: activateClass);
+
+                    selectPermanentEffect.SetUpCustomMessage(
+                        "Select 1 Digimon that will get effects.",
+                        "The opponent is selecting 1 Digimon that will get effects.");
 
-                    IEnumerator ActivateCoroutine(Hashtable hashtable)
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
                     {
-                        var selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-                        
-                        selectPermanentEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: CanSelectPermanentCondition,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: 1,
-                            canNoSelect: false,
-                            canEndNotMax: false,
-                            selectPermanentCoroutine: SelectPermanentCoroutine,
-                            afterSelectPermanentCoroutine: null,
-                            mode: SelectPermanentEffect.Mode.Custom,
-                            cardEffect: activateClass);
-                        
-                        selectPermanentEffect.SetUpCustomMessage(
-                            "Select 1 Digimon that will get effects.",
-                            "The opponent is selecting 1 Digimon that will get effects.");
-                        
-                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                        yield break;
-                        
-                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotBeDeletedByBattle(
+                            targetPermanent: permanent,
+                            canNotBeDestroyedByBattleCondition: CanNotBeDestroyedByBattleCondition,
+                            effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                            activateClass: activateClass,
+                            effectName: "Can't be deleted in battle"));
+
+                        bool CanNotBeDestroyedByBattleCondition(Permanent permanent1, Permanent attackingPermanent, Permanent defendingPermanent, CardSource defendingCard)
                         {
-                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotBeDeletedByBattle(
-                                targetPermanent: permanent,
-                                canNotBeDestroyedByBattleCondition: CanNotBeDestroyedByBattleCondition,
-                                effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                                activateClass: activateClass,
-                                effectName: "Can't be deleted in battle"));
-                            yield break;
-                            
-                            bool CanNotBeDestroyedByBattleCondition(Permanent permanent1, Permanent attackingPermanent, Permanent defendingPermanent, CardSource defendingCard)
-                            {
-                                return permanent == attackingPermanent || permanent == defendingPermanent;
-                            }
+                            return permanent == attackingPermanent || permanent == defendingPermanent;
                         }
                     }
-                    break;
+                }
+            }
+            #endregion
+
+            #region Inherited Effect
+            if (timing == EffectTiming.OnAllyAttack)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Trash 1 digivolution card", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false,
+                    EffectDiscription());
+                activateClass.SetIsInheritedEffect(true);
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Attacking] Trash the top digivolution card of 1 of your opponent's Digimon.";
+                }
+
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card)
+                           && permanent.DigivolutionCards.Count(cardSource =>
+                               !cardSource.CanNotTrashFromDigivolutionCards(activateClass)) >= 1;
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnAttack(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(card) &&
+                           CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    var maxCount = Math.Min(1,
+                        CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+                    var selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectPermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: maxCount,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: SelectPermanentCoroutine,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Custom,
+                        cardEffect: activateClass);
+
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will trash digivolution cards.",
+                        "The opponent is selecting 1 Digimon that will trash digivolution cards.");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                    yield break;
+
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(
+                            CardEffectCommons.TrashDigivolutionCardsFromTopOrBottom(targetPermanent: permanent,
+                                trashCount: 1, isFromTop: true, activateClass: activateClass));
+                    }
+                }
             }
+            #endregion
 
             return cardEffects;
         }

Assets/CardEffect/BT16/Blue/DemiVeemon_BT16_002.cs

@@ -8,25 +8,22 @@ namespace DCGO.CardEffects.BT16
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
-            
-            switch (timing)
+
+            if(timing == EffectTiming.None)
             {
-                case EffectTiming.None:
+                bool PermanentCondition()
                 {
-                    string EffectDiscription()
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
-                        return "[All Turns] While this Digimon has 2 or more colors, it gets +1000 DP.";
+                        if(card.PermanentOfThisCard().TopCard.CardColors.Count >= 2)
+                        {
+                            return true;
+                        }
                     }
-                    
-                    bool PermanentCondition()
-                    {
-                        return CardEffectCommons.IsExistOnBattleArea(card)
-                               && card.PermanentOfThisCard().TopCard.CardColors.Count >= 2;
-                    }
-                    
-                    cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect(1000, true, card, PermanentCondition));
-                    break;
+                    return false;
                 }
+
+                cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect(1000, true, card, PermanentCondition));
             }
             
             return cardEffects;

Assets/CardEffect/BT16/Blue/Veemon_BT16_017.cs

@@ -8,94 +8,84 @@ namespace DCGO.CardEffects.BT16
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
-            
-            switch (timing)
+
+            #region Alternate Digivolution Requirement
+            if(timing == EffectTiming.None)
             {
-                case EffectTiming.None:
+                bool PermanentCondition(Permanent targetPermanent)
                 {
-                    #region Alternate Digivolution Requirement
-                    
-                    bool PermanentCondition(Permanent targetPermanent)
-                    {
-                        return targetPermanent.TopCard.ContainsCardName("DemiVeemon");
-                    }
-                    
-                    cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
-                        permanentCondition: PermanentCondition,
-                        digivolutionCost: 0,
-                        ignoreDigivolutionRequirement: false,
-                        card: card,
-                        condition: null));
-                    
-                    #endregion
-                    
-                    #region Inherited Effect
-                    
-                    bool InheritedEffectCondition()
-                    {
-                        return CardEffectCommons.IsOwnerTurn(card);
-                    }
-                    
-                    cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect(
-                        changeValue: 2000,
-                        isInheritedEffect: true,
-                        card: card,
-                        condition: InheritedEffectCondition));
-                    
-                    #endregion
-                    
-                    break;
+                    return targetPermanent.TopCard.ContainsCardName("DemiVeemon");
                 }
-                    
-                case EffectTiming.OnEnterFieldAnyone:
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 0,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null));
+            }
+            #endregion
+
+            #region Your turn - When enter field
+            if(timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Memory +1", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false,
+                    EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[Your Turn] [Once Per Turn] When one of your other Digimon is played or digivolves, if that Digimon is green or has the [Free] trait, gain 1 memory.";
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card)
+                           && permanent != card.PermanentOfThisCard()
+                           && (permanent.TopCard.CardColors.Contains(CardColor.Green)
+                               || permanent.TopCard.ContainsTraits("Free"));
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
                 {
-                    #region Your Turn Effect
-                    ActivateClass activateClass = new ActivateClass();
-                    activateClass.SetUpICardEffect("Memory +1", CanUseCondition, card);
-                    activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false,
-                        EffectDiscription());
-                    cardEffects.Add(activateClass);
-                    
-                    string EffectDiscription()
-                    {
-                        return
-                            "[Your Turn] [Once Per Turn] When one of your other Digimon is played or digivolves, if that Digimon is green or has the [Free] trait, gain 1 memory.";
-                    }
-                    
-                    bool PermanentCondition(Permanent permanent)
-                    {
-                        return CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card)
-                               && permanent != card.PermanentOfThisCard()
-                               && (permanent.TopCard.CardColors.Contains(CardColor.Green)
-                                   || permanent.TopCard.ContainsTraits("Free"));
-                    }
-                    
-                    bool CanUseCondition(Hashtable hashtable)
-                    {
-                        return CardEffectCommons.IsOwnerTurn(card)
-                               && CardEffectCommons.IsExistOnBattleArea(card)
-                               && (CardEffectCommons.CanTriggerOnPermanentPlay(hashtable, PermanentCondition)
-                                   || CardEffectCommons.CanTriggerWhenPermanentDigivolving(hashtable,
-                                       PermanentCondition));
-                    }
-                    
-                    bool CanActivateCondition(Hashtable hashtable)
-                    {
-                        return CardEffectCommons.IsExistOnBattleArea(card)
-                               && card.Owner.CanAddMemory(activateClass);
-                    }
-                    
-                    IEnumerator ActivateCoroutine(Hashtable hashtable)
-                    {
-                        yield return ContinuousController.instance.StartCoroutine(
-                            card.Owner.AddMemory(1, activateClass));
-                    }
-                    
-                    break;
-                    
-                    #endregion
+                    return CardEffectCommons.IsOwnerTurn(card)
+                           && CardEffectCommons.IsExistOnBattleArea(card)
+                           && (CardEffectCommons.CanTriggerOnPermanentPlay(hashtable, PermanentCondition)
+                               || CardEffectCommons.CanTriggerWhenPermanentDigivolving(hashtable,
+                                   PermanentCondition));
                 }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(card)
+                           && card.Owner.CanAddMemory(activateClass);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(
+                        card.Owner.AddMemory(1, activateClass));
+                }
+            }
+            #endregion
+
+            #region Inherited Effect
+            if (timing == EffectTiming.None)
+            {
+                bool InheritedEffectCondition()
+                {
+                    return CardEffectCommons.IsOwnerTurn(card);
+                }
+
+                cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect(
+                    changeValue: 2000,
+                    isInheritedEffect: true,
+                    card: card,
+                    condition: InheritedEffectCondition));
             }
+            #endregion
             
             return cardEffects;
         }