fixes to witchmon (EX6) and Hexeblau

Assets/CardEffect/EX6/Purple/Witchmon_EX6_048.cs

@@ -34,12 +34,15 @@ namespace DCGO.CardEffects.EX6
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                        return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+
+                    return false;
                 }                
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
                     {
                         if (card.Owner.HandCards.Count >= 1)
                         {
@@ -51,149 +54,135 @@ namespace DCGO.CardEffects.EX6
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if (card.Owner.HandCards.Count >= 1)
+                    bool discarded = false;
+
+                    SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                    selectHandEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: (cardSource) => true,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: true,
+                        canEndNotMax: false,
+                        isShowOpponent: true,
+                        selectCardCoroutine: null,
+                        afterSelectCardCoroutine: AfterSelectCardCoroutine,
+                        mode: SelectHandEffect.Mode.Discard,
+                        cardEffect: activateClass);
+
+                    yield return StartCoroutine(selectHandEffect.Activate());
+
+                    IEnumerator AfterSelectCardCoroutine(List<CardSource> cardSources)
                     {
-                        bool discarded = false;
-
-                        int discardCount = 1;
-
-                        SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
-
-                        selectHandEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: (cardSource) => true,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: discardCount,
-                            canNoSelect: true,
-                            canEndNotMax: false,
-                            isShowOpponent: true,
-                            selectCardCoroutine: null,
-                            afterSelectCardCoroutine: AfterSelectCardCoroutine,
-                            mode: SelectHandEffect.Mode.Discard,
-                            cardEffect: activateClass);
-
-                        yield return StartCoroutine(selectHandEffect.Activate());
-
-                        IEnumerator AfterSelectCardCoroutine(List<CardSource> cardSources)
+                        if (cardSources.Count >= 1)
                         {
-                            if (cardSources.Count >= 1)
-                            {
-                                discarded = true;
+                            discarded = true;
 
-                                yield return null;
-                            }
+                            yield return null;
                         }
+                    }
 
-                        if (discarded)
+                    if (discarded)
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                         {
-                            if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
+                            SelectPermanentEffect 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 get [End of Attack] Delete this Digimon.",
+                                "The opponent is selecting 1 Digimon that will get [End of Attack] Delete this Digimon.");
+
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                            IEnumerator SelectPermanentCoroutine(Permanent permanent)
                             {
-                                int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-                                SelectPermanentEffect 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 get [End of Attack] Delete this Digimon.",
-                                    "The opponent is selecting 1 Digimon that will get [End of Attack] Delete this Digimon.");
-
-                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                                IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                                if (permanent != null)
                                 {
-                                    Permanent selectedPermanent = permanent;
-
-                                    if (selectedPermanent != null)
+                                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(permanent));
+                                    ActivateClass activateClass1 = new ActivateClass();
+                                    activateClass1.SetUpICardEffect("Delete this Digimon", CanUseCondition1, permanent.TopCard);
+                                    activateClass1.SetUpActivateClass(CanActivateCondition1, ActivateCoroutine1, -1, false, EffectDiscription1());
+                                    activateClass1.SetEffectSourcePermanent(permanent);
+                                    permanent.UntilOwnerTurnEndEffects.Add(GetCardEffect);
+
+                                    if (!permanent.TopCard.CanNotBeAffected(activateClass))
                                     {
-                                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(selectedPermanent));
+                                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(permanent));
                                     }
 
-                                    if (selectedPermanent != null)
+                                    string EffectDiscription1()
                                     {
-                                        ActivateClass activateClass1 = new ActivateClass();
-                                        activateClass1.SetUpICardEffect("Delete this Digimon", CanUseCondition1, selectedPermanent.TopCard);
-                                        activateClass1.SetUpActivateClass(CanActivateCondition1, ActivateCoroutine1, -1, false, EffectDiscription1());
-                                        activateClass1.SetEffectSourcePermanent(selectedPermanent);
-                                        selectedPermanent.UntilOwnerTurnEndEffects.Add(GetCardEffect);
-
-                                        if (!permanent.TopCard.CanNotBeAffected(activateClass))
-                                        {
-                                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(selectedPermanent));
-                                        }
-
-                                        string EffectDiscription1()
-                                        {
-                                            return "[End of Attack] Delete this Digimon.";
-                                        }
+                                        return "[End of Attack] Delete this Digimon.";
+                                    }
 
-                                        bool CanUseCondition1(Hashtable hashtable1)
+                                    bool CanUseCondition1(Hashtable hashtable1)
+                                    {
+                                        if (CardEffectCommons.IsOpponentTurn(card))
                                         {
-                                            if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent))
+                                            if (CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, permanent.TopCard))
                                             {
-                                                if (CardEffectCommons.CanTriggerOnAttack(hashtable, selectedPermanent.TopCard))
+                                                if (CardEffectCommons.CanTriggerOnEndAttack(hashtable1, permanent.TopCard))
                                                 {
-                                                    if (selectedPermanent.TopCard.Owner.GetBattleAreaDigimons().Contains(selectedPermanent))
-                                                    {
-                                                        if (GManager.instance.turnStateMachine.gameContext.TurnPlayer == selectedPermanent.TopCard.Owner)
-                                                        {
-                                                            return true;
-                                                        }
-                                                    }
+                                                    return true;
                                                 }
                                             }
-
-                                            return false;
                                         }
 
-                                        bool CanActivateCondition1(Hashtable hashtable1)
+                                        return false;
+                                    }
+
+                                    bool CanActivateCondition1(Hashtable hashtable1)
+                                    {
+                                        if (CardEffectCommons.IsPermanentExistsOnBattleArea(permanent))
                                         {
-                                            if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent))
+                                            if (!permanent.TopCard.CanNotBeAffected(activateClass))
                                             {
-                                                if (!permanent.TopCard.CanNotBeAffected(activateClass))
-                                                {
-                                                    return true;
-                                                }
+                                                return true;
                                             }
-
-                                            return false;
                                         }
 
-                                        IEnumerator ActivateCoroutine1(Hashtable _hashtable1)
+                                        return false;
+                                    }
+
+                                    IEnumerator ActivateCoroutine1(Hashtable _hashtable1)
+                                    {
+                                        if (CardEffectCommons.IsPermanentExistsOnBattleArea(permanent))
                                         {
-                                            if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent))
-                                            {
-                                                yield return ContinuousController.instance.StartCoroutine(new DestroyPermanentsClass(
-                                                new List<Permanent>() { selectedPermanent },
-                                                CardEffectCommons.CardEffectHashtable(activateClass1)).Destroy());
-                                            }
+                                            yield return ContinuousController.instance.StartCoroutine(new DestroyPermanentsClass(
+                                            new List<Permanent>() { permanent },
+                                            CardEffectCommons.CardEffectHashtable(activateClass1)).Destroy());
                                         }
+                                    }
 
-                                        ICardEffect GetCardEffect(EffectTiming _timing)
+                                    ICardEffect GetCardEffect(EffectTiming _timing)
+                                    {
+                                        if (_timing == EffectTiming.OnEndAttack)
                                         {
-                                            if (_timing == EffectTiming.OnEndAttack)
-                                            {
-                                                return activateClass1;
-                                            }
-
-                                            return null;
+                                            return activateClass1;
                                         }
+
+                                        return null;
                                     }
+
                                 }
                             }
-
                         }
                     }
                 }
@@ -220,7 +209,10 @@ namespace DCGO.CardEffects.EX6
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                        return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+
+                    return false;
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
@@ -237,149 +229,135 @@ namespace DCGO.CardEffects.EX6
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if (card.Owner.HandCards.Count >= 1)
+                    bool discarded = false;
+
+                    SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                    selectHandEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: (cardSource) => true,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: true,
+                        canEndNotMax: false,
+                        isShowOpponent: true,
+                        selectCardCoroutine: null,
+                        afterSelectCardCoroutine: AfterSelectCardCoroutine,
+                        mode: SelectHandEffect.Mode.Discard,
+                        cardEffect: activateClass);
+
+                    yield return StartCoroutine(selectHandEffect.Activate());
+
+                    IEnumerator AfterSelectCardCoroutine(List<CardSource> cardSources)
                     {
-                        bool discarded = false;
-
-                        int discardCount = 1;
-
-                        SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
-
-                        selectHandEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: (cardSource) => true,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: discardCount,
-                            canNoSelect: true,
-                            canEndNotMax: false,
-                            isShowOpponent: true,
-                            selectCardCoroutine: null,
-                            afterSelectCardCoroutine: AfterSelectCardCoroutine,
-                            mode: SelectHandEffect.Mode.Discard,
-                            cardEffect: activateClass);
-
-                        yield return StartCoroutine(selectHandEffect.Activate());
-
-                        IEnumerator AfterSelectCardCoroutine(List<CardSource> cardSources)
+                        if (cardSources.Count >= 1)
                         {
-                            if (cardSources.Count >= 1)
-                            {
-                                discarded = true;
+                            discarded = true;
 
-                                yield return null;
-                            }
+                            yield return null;
                         }
+                    }
 
-                        if (discarded)
+                    if (discarded)
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                         {
-                            if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
+                            SelectPermanentEffect 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 get [End of Attack] Delete this Digimon.",
+                                "The opponent is selecting 1 Digimon that will get [End of Attack] Delete this Digimon.");
+
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                            IEnumerator SelectPermanentCoroutine(Permanent permanent)
                             {
-                                int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-                                SelectPermanentEffect 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 get [End of Attack] Delete this Digimon.",
-                                    "The opponent is selecting 1 Digimon that will get [End of Attack] Delete this Digimon.");
-
-                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                                IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                                if (permanent != null)
                                 {
-                                    Permanent selectedPermanent = permanent;
-
-                                    if (selectedPermanent != null)
+                                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(permanent));
+                                    ActivateClass activateClass1 = new ActivateClass();
+                                    activateClass1.SetUpICardEffect("Delete this Digimon", CanUseCondition1, permanent.TopCard);
+                                    activateClass1.SetUpActivateClass(CanActivateCondition1, ActivateCoroutine1, -1, false, EffectDiscription1());
+                                    activateClass1.SetEffectSourcePermanent(permanent);
+                                    permanent.UntilOwnerTurnEndEffects.Add(GetCardEffect);
+
+                                    if (!permanent.TopCard.CanNotBeAffected(activateClass))
                                     {
-                                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(selectedPermanent));
+                                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(permanent));
                                     }
 
-                                    if (selectedPermanent != null)
+                                    string EffectDiscription1()
                                     {
-                                        ActivateClass activateClass1 = new ActivateClass();
-                                        activateClass1.SetUpICardEffect("Delete this Digimon", CanUseCondition1, selectedPermanent.TopCard);
-                                        activateClass1.SetUpActivateClass(CanActivateCondition1, ActivateCoroutine1, -1, false, EffectDiscription1());
-                                        activateClass1.SetEffectSourcePermanent(selectedPermanent);
-                                        selectedPermanent.UntilOwnerTurnEndEffects.Add(GetCardEffect);
-
-                                        if (!permanent.TopCard.CanNotBeAffected(activateClass))
-                                        {
-                                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(selectedPermanent));
-                                        }
-
-                                        string EffectDiscription1()
-                                        {
-                                            return "[End of Attack] Delete this Digimon.";
-                                        }
+                                        return "[End of Attack] Delete this Digimon.";
+                                    }
 
-                                        bool CanUseCondition1(Hashtable hashtable1)
+                                    bool CanUseCondition1(Hashtable hashtable1)
+                                    {
+                                        if (CardEffectCommons.IsOpponentTurn(card))
                                         {
-                                            if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent))
+                                            if (CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, permanent.TopCard))
                                             {
-                                                if (CardEffectCommons.CanTriggerOnAttack(hashtable, selectedPermanent.TopCard))
+                                                if (CardEffectCommons.CanTriggerOnEndAttack(hashtable1, permanent.TopCard))
                                                 {
-                                                    if (selectedPermanent.TopCard.Owner.GetBattleAreaDigimons().Contains(selectedPermanent))
-                                                    {
-                                                        if (GManager.instance.turnStateMachine.gameContext.TurnPlayer == selectedPermanent.TopCard.Owner)
-                                                        {
-                                                            return true;
-                                                        }
-                                                    }
+                                                    return true;
                                                 }
                                             }
-
-                                            return false;
                                         }
 
-                                        bool CanActivateCondition1(Hashtable hashtable1)
+                                        return false;
+                                    }
+
+                                    bool CanActivateCondition1(Hashtable hashtable1)
+                                    {
+                                        if (CardEffectCommons.IsPermanentExistsOnBattleArea(permanent))
                                         {
-                                            if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent))
+                                            if (!permanent.TopCard.CanNotBeAffected(activateClass))
                                             {
-                                                if (!permanent.TopCard.CanNotBeAffected(activateClass))
-                                                {
-                                                    return true;
-                                                }
+                                                return true;
                                             }
-
-                                            return false;
                                         }
 
-                                        IEnumerator ActivateCoroutine1(Hashtable _hashtable1)
+                                        return false;
+                                    }
+
+                                    IEnumerator ActivateCoroutine1(Hashtable _hashtable1)
+                                    {
+                                        if (CardEffectCommons.IsPermanentExistsOnBattleArea(permanent))
                                         {
-                                            if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent))
-                                            {
-                                                yield return ContinuousController.instance.StartCoroutine(new DestroyPermanentsClass(
-                                                new List<Permanent>() { selectedPermanent },
-                                                CardEffectCommons.CardEffectHashtable(activateClass1)).Destroy());
-                                            }
+                                            yield return ContinuousController.instance.StartCoroutine(new DestroyPermanentsClass(
+                                            new List<Permanent>() { permanent },
+                                            CardEffectCommons.CardEffectHashtable(activateClass1)).Destroy());
                                         }
+                                    }
 
-                                        ICardEffect GetCardEffect(EffectTiming _timing)
+                                    ICardEffect GetCardEffect(EffectTiming _timing)
+                                    {
+                                        if (_timing == EffectTiming.OnEndAttack)
                                         {
-                                            if (_timing == EffectTiming.OnEndAttack)
-                                            {
-                                                return activateClass1;
-                                            }
-
-                                            return null;
+                                            return activateClass1;
                                         }
+
+                                        return null;
                                     }
+
                                 }
                             }
-
                         }
                     }
                 }

Assets/CardEffect/EX7/Blue/Hexeblaumon_EX7_023.cs

@@ -108,25 +108,25 @@ namespace DCGO.CardEffects.EX7
             
             #region Opponent's Turn Effect
 
-            if (timing == EffectTiming.OnStartTurn)
+            if (timing == EffectTiming.None)
             {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Opponent's digimon can't suspend", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-                activateClass.SetIsBackgroundProcess(true);
-                cardEffects.Add(activateClass);
-
-                string EffectDiscription()
-                {
-                    return "[Opponent's Turn] None of your opponent's Digimon with as many or fewer digivolution cards as this Digimon can suspend.";
-                }
+                CanNotSuspendClass canNotSuspendClass = new CanNotSuspendClass();
+                canNotSuspendClass.SetUpICardEffect("Can't Suspend", CanUseCondition, card);
+                canNotSuspendClass.SetUpCanNotSuspendClass(PermanentCondition: CantSuspendCondition);
+                cardEffects.Add(canNotSuspendClass);
 
                 bool CantSuspendCondition(Permanent permanent)
                 {
                     if (CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card))
                     {
-                        if (permanent.IsDigimon && permanent.DigivolutionCards.Count <= card.PermanentOfThisCard().DigivolutionCards.Count)
-                            return true;
+                        if (permanent.IsDigimon)
+                        {
+                            if(permanent.DigivolutionCards.Count <= card.PermanentOfThisCard().DigivolutionCards.Count)
+                            {
+                                if (!permanent.TopCard.CanNotBeAffected(canNotSuspendClass))
+                                    return true;
+                            }
+                        }
                     }
 
                     return false;
@@ -141,59 +141,6 @@ namespace DCGO.CardEffects.EX7
 
                     return false;
                 }
-                
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
-                }               
-
-                IEnumerator ActivateCoroutine(Hashtable hashtable)
-                {
-                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotSuspendPlayerEffect(
-                        permanentCondition: CantSuspendCondition,
-                        effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                        activateClass: activateClass,
-                        isOnlyActivePhase: false,
-                        effectName: "Can't Suspend"));
-
-                    /*if (card.Owner.Enemy.GetBattleAreaPermanents().Count(CanSelectPermanentToNoSuspend) >= 1)
-                    {
-                        foreach (Permanent affected in card.Owner.Enemy.GetBattleAreaPermanents())
-                        {
-                            if (!affected.IsDigimon)
-                                continue;
-
-                            if (affected.TopCard.CanNotBeAffected(activateClass))
-                                continue;
-
-                            if (affected.DigivolutionCards.Count > card.PermanentOfThisCard().DigivolutionCards.Count)
-                            {
-                                StartCoroutine(SelectPermanentCoroutine(affected));
-                            }
-                                
-                        }
-                        
-                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                        {
-                            CanNotSuspendClass canNotSuspendClass = new CanNotSuspendClass();
-                            canNotSuspendClass.SetUpICardEffect("Can't Suspend", CanUseCondition1, card);
-                            canNotSuspendClass.SetUpCanNotSuspendClass(PermanentCondition: PermanentCondition);
-                            permanent.UntilOwnerTurnEndEffects.Add((_timing) => canNotSuspendClass);
-
-                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(permanent));
-
-                            bool CanUseCondition1(Hashtable hashtable)
-                            {
-                                return true;
-                            }
-
-                            bool PermanentCondition(Permanent permanent)
-                            {
-                                return true;
-                            }
-                        }
-                    }*/
-                }
             }
 
             #endregion