mike (10/6)

Assets/CardEffect/BT13/Yellow/BT13_046.cs

@@ -82,10 +82,6 @@ namespace DCGO.CardEffects.BT13
                             if (cardSource.CardColors.Contains(CardColor.Yellow))
                             {
                                 yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource));
-
-                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                                yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                             }
 
                             yield return null;
@@ -166,10 +162,6 @@ namespace DCGO.CardEffects.BT13
                             if (cardSource.CardColors.Contains(CardColor.Yellow))
                             {
                                 yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource));
-
-                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                                yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                             }
 
                             yield return null;

Assets/CardEffect/BT14/Yellow/BT14_032.cs

@@ -109,10 +109,6 @@ namespace DCGO.CardEffects.BT14
                             foreach (CardSource cardSource in selectedCards)
                             {
                                 yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource));
-
-                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                                yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                             }
                         }
                     }

Assets/CardEffect/BT14/Yellow/BT14_033.cs

@@ -190,10 +190,6 @@ namespace DCGO.CardEffects.BT14
                                             foreach (CardSource cardSource in selectedCards)
                                             {
                                                 yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource, toTop: false));
-
-                                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                                                yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                                             }
                                         }
                                     }

Assets/CardEffect/BT14/Yellow/BT14_038.cs

@@ -259,10 +259,6 @@ namespace DCGO.CardEffects.BT14
                         foreach (CardSource cardSource in selectedCards)
                         {
                             yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource, toTop: false));
-
-                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                            yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                         }
                     }
                 }

Assets/CardEffect/BT14/Yellow/BT14_040.cs

@@ -89,10 +89,6 @@ namespace DCGO.CardEffects.BT14
                             foreach (CardSource cardSource in selectedCards)
                             {
                                 yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource));
-
-                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                                yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                             }
                         }
                     }
@@ -178,10 +174,6 @@ namespace DCGO.CardEffects.BT14
                             foreach (CardSource cardSource in selectedCards)
                             {
                                 yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource));
-
-                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                                yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                             }
                         }
                     }

Assets/CardEffect/BT14/Yellow/BT14_084.cs

@@ -103,10 +103,6 @@ namespace DCGO.CardEffects.BT14
                             foreach (CardSource cardSource in selectedCards)
                             {
                                 yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource, toTop: false));
-
-                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                                yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                             }
                         }
                     }

Assets/CardEffect/BT14/Yellow/BT14_102.cs

@@ -327,10 +327,6 @@ namespace DCGO.CardEffects.BT14
                         foreach (CardSource cardSource in selectedCards)
                         {
                             yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource, toTop: false));
-
-                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                            yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                         }
                     }
                 }

Assets/CardEffect/BT18/Yellow/BT18_038.cs

@@ -95,10 +95,6 @@ namespace DCGO.CardEffects.BT18
                     IEnumerator SelectCardCoroutine(CardSource cardSource)
                     {
                         yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource, toTop: false));
-
-                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                        yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                     }
                 
 
@@ -188,10 +184,6 @@ namespace DCGO.CardEffects.BT18
                     IEnumerator SelectCardCoroutine(CardSource cardSource)
                     {
                         yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource, toTop: false));
-
-                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                        yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                     }
                     
                     if (card.Owner.SecurityCards.Count >= 4)

Assets/CardEffect/BT19/Yellow/BT19_036.cs

@@ -117,10 +117,6 @@ namespace DCGO.CardEffects.BT19
                                 foreach (CardSource cardSource in selectedCards)
                                 {
                                     yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource, toTop: false));
-
-                                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                                    yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                                 }
                             }
                         }
@@ -233,10 +229,6 @@ namespace DCGO.CardEffects.BT19
                                 foreach (CardSource cardSource in selectedCards)
                                 {
                                     yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource, toTop: false));
-
-                                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                                    yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                                 }
                             }
                         }

Assets/CardEffect/BT23/Black/BT23_003.cs

@@ -26,13 +26,13 @@ namespace DCGO.CardEffects.BT23
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnField(card)
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
                         && CardEffectCommons.CanTriggerOnPermanentPlay(hashtable, PermanentCondition);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnField(card)
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
                         && CardEffectCommons.IsOwnerTurn(card);
                 }
 

Assets/CardEffect/BT23/Black/BT23_051.cs

@@ -18,12 +18,12 @@ namespace DCGO.CardEffects.BT23
                 bool PermanentCondition(Permanent targetPermanent)
                 {
                     return targetPermanent.TopCard.HasCSTraits
-                        && targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.IsLevel2;
+                        && targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.IsLevel3;
                 }
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
                     permanentCondition: PermanentCondition,
-                    digivolutionCost: 0,
+                    digivolutionCost: 2,
                     ignoreDigivolutionRequirement: false,
                     card: card,
                     condition: null)

Assets/CardEffect/BT23/Blue/BT23_017.cs

@@ -67,63 +67,60 @@ namespace DCGO.CardEffects.BT23
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, _ => true))
+                    bool trashed = 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);
+
+                    IEnumerator AfterSelectCardCoroutine(List<CardSource> cardSources)
                     {
-                        bool trashed = false;
-                        SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+                        if (cardSources.Any()) trashed = true;
+                        yield return null;
+                    }
 
-                        selectHandEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: (cardSource) => true,
+                    selectHandEffect.SetUpCustomMessage("Select 1 card to trash", "Your opponent is selecting 1 card to trash");
+                    selectHandEffect.SetUpCustomMessage_ShowCard("Selected Card");
+                    yield return ContinuousController.instance.StartCoroutine(selectHandEffect.Activate());
+
+                    if (trashed && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
+                    {
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOwnersCardCountInTrash(card, CanSelectCardCondition));
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                        selectCardEffect.SetUp(
+                            canTargetCondition: CanSelectCardCondition,
                             canTargetCondition_ByPreSelecetedList: null,
                             canEndSelectCondition: null,
-                            maxCount: 1,
-                            canNoSelect: true,
+                            canNoSelect: () => true,
+                            selectCardCoroutine: null,
+                            afterSelectCardCoroutine: null,
+                            message: "Select 1 [CS] card to add to hand.",
+                            maxCount: maxCount,
                             canEndNotMax: false,
                             isShowOpponent: true,
-                            selectCardCoroutine: null,
-                            afterSelectCardCoroutine: AfterSelectCardCoroutine,
-                            mode: SelectHandEffect.Mode.Discard,
+                            mode: SelectCardEffect.Mode.AddHand,
+                            root: SelectCardEffect.Root.Trash,
+                            customRootCardList: null,
+                            canLookReverseCard: true,
+                            selectPlayer: card.Owner,
                             cardEffect: activateClass);
 
-                        IEnumerator AfterSelectCardCoroutine(List<CardSource> cardSources)
-                        {
-                            if (cardSources.Any()) trashed = true;
-                            yield return null;
-                        }
+                        selectCardEffect.SetUpCustomMessage("Select 1 [CS] card to add to hand.", "The opponent is selecting 1 card to add to hand.");
+                        selectCardEffect.SetUpCustomMessage_ShowCard("Selected Card");
 
-                        selectHandEffect.SetUpCustomMessage("Select 1 card to trash", "Your opponent is selecting 1 card to trash");
-                        selectHandEffect.SetUpCustomMessage_ShowCard("Selected Card");
-                        yield return ContinuousController.instance.StartCoroutine(selectHandEffect.Activate());
-
-                        if (trashed && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
-                        {
-                            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOwnersCardCountInTrash(card, CanSelectCardCondition));
-                            SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
-
-                            selectCardEffect.SetUp(
-                                canTargetCondition: CanSelectCardCondition,
-                                canTargetCondition_ByPreSelecetedList: null,
-                                canEndSelectCondition: null,
-                                canNoSelect: () => true,
-                                selectCardCoroutine: null,
-                                afterSelectCardCoroutine: null,
-                                message: "Select 1 [CS] card to add to hand.",
-                                maxCount: maxCount,
-                                canEndNotMax: false,
-                                isShowOpponent: true,
-                                mode: SelectCardEffect.Mode.AddHand,
-                                root: SelectCardEffect.Root.Trash,
-                                customRootCardList: null,
-                                canLookReverseCard: true,
-                                selectPlayer: card.Owner,
-                                cardEffect: activateClass);
-
-                            selectCardEffect.SetUpCustomMessage("Select 1 [CS] card to add to hand.", "The opponent is selecting 1 card to add to hand.");
-                            selectCardEffect.SetUpCustomMessage_ShowCard("Selected Card");
-
-                            yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
-                        }
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
                     }
                 }
             }

Assets/CardEffect/BT23/Blue/BT23_092.cs

@@ -170,7 +170,7 @@ namespace DCGO.CardEffects.BT23
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("1 digimon and tamer cant suspend until their turn ends", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, hash => SharedActivateCoroutine(hash, activateClass), -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -196,6 +196,16 @@ namespace DCGO.CardEffects.BT23
                     return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
                         && permanent.TopCard.HasCSTraits;
                 }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: new List<Permanent>() { card.PermanentOfThisCard() }, activateClass: activateClass, successProcess: permanents => SuccessProcess(), failureProcess: null));
+
+                    IEnumerator SuccessProcess()
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(SharedActivateCoroutine(hashtable, activateClass));
+                    }
+                }
             }
 
             #endregion

Assets/CardEffect/BT23/Green/BT23_039.cs

@@ -69,7 +69,7 @@ namespace DCGO.CardEffects.BT23
 
                 string EffectDiscription()
                 {
-                    return "[On Play] Reveal the top 3 cards of your deck. Add 1 card with the [Appmon] trait and 1 card with the [Game] or [Invincible (App Name)] trait among them to the hand. Return the rest to the bottom of the deck.";
+                    return "[On Play] Reveal the top 3 cards of your deck. Add 1 card with the [Appmon] trait and 1 card with the [Game] or [Invincible] trait among them to the hand. Return the rest to the bottom of the deck.";
                 }
 
                 bool CanSelectCardCondition(CardSource cardSource)
@@ -79,7 +79,7 @@ namespace DCGO.CardEffects.BT23
 
                 bool CanSelectCardCondition1(CardSource cardSource)
                 {
-                    return cardSource.EqualsTraits("Game") || cardSource.EqualsTraits("Invincible (App Name)");
+                    return cardSource.EqualsTraits("Game") || cardSource.EqualsTraits("Invincible");
                 }
 
                 bool CanUseCondition(Hashtable hashtable)

Assets/CardEffect/BT23/Purple/BT23_069.cs

@@ -167,8 +167,8 @@ namespace DCGO.CardEffects.BT23
 
                 bool AttackingPermament(Permanent permanent)
                 {
-                    attackingPermament = permanent;
-                    return CardEffectCommons.IsPermanentExistsOnBattleArea(permanent);
+                    return CardEffectCommons.IsPermanentExistsOnBattleArea(permanent) &&
+                           permanent != card.PermanentOfThisCard();
                 }
 
                 bool CanSelectPermanentCondition(Permanent permanent)
@@ -179,105 +179,99 @@ namespace DCGO.CardEffects.BT23
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if (attackingPermament == null)
-                    {
-                        Permanent thisPermament = card.PermanentOfThisCard();
+                    Permanent thisPermament = card.PermanentOfThisCard();
 
-                        #region Setup User Selection
+                    #region Setup User Selection
 
-                        List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                    List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                         {
                             new SelectionElement<bool>(message: $"Yes", value : true, spriteIndex: 0),
                             new SelectionElement<bool>(message: $"No", value : false, spriteIndex: 1),
                         };
 
-                        string selectPlayerMessage = "Will you delete Necromon?";
-                        string notSelectPlayerMessage = "The opponent is choosing to delete Necromon.";
+                    string selectPlayerMessage = "Will you delete Necromon?";
+                    string notSelectPlayerMessage = "The opponent is choosing to delete Necromon.";
 
-                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                    GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
-                        #endregion
+                    #endregion
 
-                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
-                        bool isDeleting = GManager.instance.userSelectionManager.SelectedBoolValue;
+                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+                    bool isDeleting = GManager.instance.userSelectionManager.SelectedBoolValue;
 
-                        if (isDeleting) yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(
-                            targetPermanents: new List<Permanent>() { thisPermament },
-                            activateClass: activateClass,
-                            successProcess: DeleteNecromonSuccessProcess,
-                            failureProcess: null));
+                    if (isDeleting) yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(
+                        targetPermanents: new List<Permanent>() { thisPermament },
+                        activateClass: activateClass,
+                        successProcess: DeleteNecromonSuccessProcess,
+                        failureProcess: null));
 
-                        IEnumerator DeleteNecromonSuccessProcess(List<Permanent> permanents)
+                    IEnumerator DeleteNecromonSuccessProcess(List<Permanent> permanents)
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                         {
-                            if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                            Permanent selectedPermament = null;
+
+                            #region Select Opponent Permament
+
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
+                            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);
+
+                            IEnumerator SelectPermanentCoroutine(Permanent permanent)
                             {
-                                Permanent selectedPermament = null;
-
-                                #region Select Opponent Permament
-
-                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-                                int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-                                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);
-
-                                IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                                {
-                                    selectedPermament = permanent;
-                                    yield return null;
-                                }
+                                selectedPermament = permanent;
+                                yield return null;
+                            }
 
-                                selectPermanentEffect.SetUpCustomMessage("Select 1 digimon to delete", "Your opponent is selecting 1 digimon to delete");
+                            selectPermanentEffect.SetUpCustomMessage("Select 1 digimon to delete", "Your opponent is selecting 1 digimon to delete");
 
-                                #endregion
+                            #endregion
 
-                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
-                                if (selectPermanentEffect != null) yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(
-                                    new List<Permanent>() { selectedPermament },
-                                    activateClass: activateClass,
-                                    successProcess: null,
-                                    failureProcess: OpponentLevel6FailureProcess));
+                            if (selectPermanentEffect != null) yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(
+                                new List<Permanent>() { selectedPermament },
+                                activateClass: activateClass,
+                                successProcess: null,
+                                failureProcess: OpponentLevel6FailureProcess));
+                        }
+                    }
 
-                                IEnumerator OpponentLevel6FailureProcess()
-                                {
-                                    #region Setup User Selection
+                    IEnumerator OpponentLevel6FailureProcess()
+                    {
+                        #region Setup User Selection
 
-                                    List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                        List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                                     {
                                         new SelectionElement<bool>(message: $"Yes", value : true, spriteIndex: 0),
                                         new SelectionElement<bool>(message: $"No", value : false, spriteIndex: 1),
                                     };
 
-                                    string selectPlayerMessage = "Will you end the attack?";
-                                    string notSelectPlayerMessage = "The opponent is choosing to end the attack.";
+                        string selectPlayerMessage = "Will you end the attack?";
+                        string notSelectPlayerMessage = "The opponent is choosing to end the attack.";
 
-                                    GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
-                                    #endregion
+                        #endregion
 
-                                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
-                                    bool endAttack = GManager.instance.userSelectionManager.SelectedBoolValue;
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+                        bool endAttack = GManager.instance.userSelectionManager.SelectedBoolValue;
 
-                                    if (endAttack)
-                                    {
-                                        GManager.instance.attackProcess.IsEndAttack = true;
-                                        yield return null;
-                                    }
-                                    yield return null;
-                                }
-                            }
-                            yield return null;
+                        if (endAttack)
+                        {
+                            GManager.instance.attackProcess.IsEndAttack = true;
                         }
                     }
                 }

Assets/CardEffect/BT23/Purple/BT23_097.cs

@@ -11,9 +11,60 @@ namespace DCGO.CardEffects.BT23
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
-            #region Shared Main Effect
+            #region [Trash] Your Turn
 
-            ActivateClass SharedActivateClass()
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("By returning this card to deck, Activate [Main] effect", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[Trash] [Your Turn] When any of your Digimon digivolve into [Belphemon (X Antibody)], by returning this card to the bottom of the deck, activate this card's [Main] effects.";
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
+                        && permanent.TopCard.EqualsCardName("Belphemon (X Antibody)");
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnTrash(card)
+                        && CardEffectCommons.CanTriggerWhenPermanentDigivolving(hashtable, PermanentCondition);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnTrash(card);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    List<CardSource> cardSources = new List<CardSource>() { card };
+                    yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddLibraryBottomCards(cardSources));
+                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect2(cardSources, "Deck Bottom Card", true, true));
+
+                    if (card.Owner.LibraryCards.Contains(card))
+                    {
+                        ActivateClass mainActivateClass = CardEffectCommons.OptionMainEffect(card);
+
+                        if (mainActivateClass != null)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(mainActivateClass.Activate(CardEffectCommons.OptionMainCheckHashtable(card)));
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            #region Main
+
+            if (timing == EffectTiming.OptionSkill)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Delete 1 digimon with equal or high level then cards in hand", CanUseCondition, card);
@@ -59,66 +110,6 @@ namespace DCGO.CardEffects.BT23
                         yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
                     }
                 }
-
-                return activateClass;
-            }
-
-            #endregion
-
-            #region [Trash] Your Turn
-
-            if (timing == EffectTiming.OnEnterFieldAnyone)
-            {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("By returning this card to deck, Activate [Main] effect", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
-                cardEffects.Add(activateClass);
-
-                string EffectDiscription()
-                {
-                    return "[Trash] [Your Turn] When any of your Digimon digivolve into [Belphemon (X Antibody)], by returning this card to the bottom of the deck, activate this card's [Main] effects.";
-                }
-
-                bool PermanentCondition(Permanent permanent)
-                {
-                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card)
-                        && permanent.TopCard.CardNames.Contains("Belphemon (X Antibody)") || permanent.TopCard.CardNames.Contains("Belphemon(X Antibody)");
-                }
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnTrash(card)
-                        && CardEffectCommons.CanTriggerWhenPermanentDigivolving(hashtable, PermanentCondition);
-                }
-
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnTrash(card);
-                }
-
-                IEnumerator ActivateCoroutine(Hashtable _hashtable)
-                {
-                    if (CardEffectCommons.IsExistOnTrash(card))
-                    {
-                        List<CardSource> cardSources = new List<CardSource>() { card };
-                        yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddLibraryBottomCards(cardSources));
-                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect2(cardSources, "Deck Bottom Card", true, true));
-
-                        if (card.Owner.LibraryCards[-1] == card)
-                        {
-                            yield return ContinuousController.instance.StartCoroutine(SharedActivateClass().Activate_Effect());
-                        }
-                    }
-                }
-            }
-
-            #endregion
-
-            #region Main
-
-            if (timing == EffectTiming.OptionSkill)
-            {
-                cardEffects.Add(SharedActivateClass());
             }
 
             #endregion
@@ -127,7 +118,10 @@ namespace DCGO.CardEffects.BT23
 
             if (timing == EffectTiming.SecuritySkill)
             {
-                cardEffects.Add(SharedActivateClass());
+                CardEffectCommons.AddActivateMainOptionSecurityEffect(
+                    card: card,
+                    cardEffects: ref cardEffects,
+                    effectName: "Delete 1 digimon with equal or high level then cards in hand");
             }
 
             #endregion

Assets/CardEffect/BT23/Red/BT23_013.cs

@@ -19,8 +19,8 @@ namespace DCGO.CardEffects.BT23
             {
                 bool PermanentCondition(Permanent targetPermanent)
                 {
-                    return targetPermanent.TopCard.HasCSTraits
-                        && (targetPermanent.TopCard.EqualsCardName("SaviorHuckmon") || targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.IsLevel5);
+                    return targetPermanent.TopCard.EqualsCardName("SaviorHuckmon")
+                        || (targetPermanent.TopCard.HasCSTraits && targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.IsLevel5);
                 }
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
@@ -45,7 +45,7 @@ namespace DCGO.CardEffects.BT23
 
                 bool Condition()
                 {
-                    return card.Owner.Enemy.GetBattleAreaDigimons().Filter(x => x.DP >= 1000).Count >= 1;
+                    return card.Owner.Enemy.GetBattleAreaDigimons().Filter(x => x.DP >= 10000).Count >= 1;
                 }
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(

Assets/CardEffect/BT23/Red/BT23_014.cs

@@ -46,8 +46,8 @@ namespace DCGO.CardEffects.BT23
 
                 bool CardCondition(CardSource cardSource)
                 {
-                    return card.Owner.Enemy.TrashCards.Contains(cardSource)
-                            && cardSource.IsDigimon || cardSource.IsTamer;
+                    return CardEffectCommons.IsExistInAnyTrash(cardSource)
+                            && (cardSource.IsDigimon || cardSource.IsTamer);
                 }
 
                 bool CardEffectCondition(ICardEffect cardEffect)
@@ -77,7 +77,7 @@ namespace DCGO.CardEffects.BT23
 
                 string EffectDiscription()
                 {
-                    return "[When Digivolving] Until your opponent's turn ends, their effects can't play Digimon or Tamers from the trash.";
+                    return "[On Play] Until your opponent's turn ends, their effects can't play Digimon or Tamers from the trash.";
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -134,8 +134,8 @@ namespace DCGO.CardEffects.BT23
             {
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
-                        && permanent.DP <= DPThreshold();
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card)
+                        && permanent.DP <= card.Owner.MaxDP_DeleteEffect(DPThreshold(), activateClass);
                 }
 
                 if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
@@ -169,7 +169,7 @@ namespace DCGO.CardEffects.BT23
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect($"Delete 1 digimon with {DPThreshold()} DP or less", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, hash => SharedActivateCoroutine(hash, activateClass), -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, hash => SharedActivateCoroutine(hash, activateClass), -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -197,7 +197,7 @@ namespace DCGO.CardEffects.BT23
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect($"Delete 1 digimon with {DPThreshold()} DP or less", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, hash => SharedActivateCoroutine(hash, activateClass), -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, hash => SharedActivateCoroutine(hash, activateClass), -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -225,7 +225,7 @@ namespace DCGO.CardEffects.BT23
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect($"Delete 1 digimon with {DPThreshold()} DP or less", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, hash => SharedActivateCoroutine(hash, activateClass), -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, hash => SharedActivateCoroutine(hash, activateClass), -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()

Assets/CardEffect/BT23/White/BT23_075.cs

@@ -191,8 +191,9 @@ namespace DCGO.CardEffects.BT23
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
-                        && CardEffectCommons.CanTriggerWhenRemoveField(hashtable, card);
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
+                           CardEffectCommons.CanTriggerWhenRemoveField(hashtable, card) &&
+                           !CardEffectCommons.IsByEffect(hashtable, cardEffect => CardEffectCommons.IsOwnerEffect(cardEffect, card));
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
@@ -241,7 +242,7 @@ namespace DCGO.CardEffects.BT23
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Delete 1 Digimon with the lowest play cost", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
                 activateClass.SetHashString("Delete_BT23_075");
                 cardEffects.Add(activateClass);
 

Assets/CardEffect/BT23/Yellow/BT23_029.cs

@@ -177,13 +177,13 @@ namespace DCGO.CardEffects.BT23
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnField(card)
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
                         && CardEffectCommons.CanTriggerWhenPermanentSuspends(hashtable, IsYourDigimon);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnField(card);
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
                 }
 
                 bool IsYourDigimon(Permanent permanent)

Assets/CardEffect/BT23/Yellow/BT23_033.cs

@@ -88,7 +88,7 @@ namespace DCGO.CardEffects.BT23
                         && cardSource.CanLinkToTargetPermanent(thisPermament, false);
                 }
 
-                bool canSelectSources = thisPermament.StackCards.Exists(CanSelectCardSource);
+                bool canSelectSources = thisPermament.DigivolutionCards.Exists(CanSelectCardSource);
                 bool canSelectTrash = CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardSource);
 
                 if (canSelectSources || canSelectTrash)

Assets/CardEffect/BT6/Yellow/BT6_100.cs

@@ -56,10 +56,6 @@ public class BT6_100 : CEntity_Effect
                 IEnumerator SelectCardCoroutine(CardSource cardSource)
                 {
                     yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource));
-
-                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                    yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                 }
 
                 yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlaceDelayOptionCards(card: card, cardEffect: activateClass));

Assets/CardEffect/BT9/Yellow/BT9_044.cs

@@ -139,10 +139,6 @@ public class BT9_044 : CEntity_Effect
                         {
                             yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource));
 
-                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                            yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
-
                             permanent.willBeRemoveField = false;
 
                             if (permanent.ShowingPermanentCard != null)

Assets/CardEffect/EX5/Black/EX5_054.cs

@@ -289,10 +289,6 @@ namespace DCGO.CardEffects.EX5
                             {
                                 yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource, toTop: true));
 
-                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                                yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
-
                                 added = true;
                             }
                         }

Assets/CardEffect/EX5/White/EX5_070.cs

@@ -308,10 +308,6 @@ public class EX5_070 : CEntity_Effect
                             yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().RemoveDigivolveRootEffect(cardSource, cardSource.PermanentOfThisCard()));
 
                             yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource, toTop: true));
-
-                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                            yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                         }
                     }
                 }

Assets/CardEffect/EX5/Yellow/EX5_031.cs

@@ -138,10 +138,6 @@ public class EX5_031 : CEntity_Effect
                     foreach (CardSource cardSource in selectedCards)
                     {
                         yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource, toTop: true));
-
-                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                        yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                     }
                 }
             }

Assets/CardEffect/LM/Yellow/LM_023.cs

@@ -107,11 +107,6 @@ namespace DCGO.CardEffects.LM
                     {
                         yield return ContinuousController.instance.StartCoroutine(
                             CardObjectController.AddSecurityCard(cardSource, toTop: true));
-
-                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>()
-                            .CreateRecoveryEffect(cardSource.Owner));
-
-                        yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                     }
                 }
             }
@@ -182,11 +177,6 @@ namespace DCGO.CardEffects.LM
                     {
                         yield return ContinuousController.instance.StartCoroutine(
                             CardObjectController.AddSecurityCard(cardSource, toTop: true));
-
-                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>()
-                            .CreateRecoveryEffect(cardSource.Owner));
-
-                        yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
                     }
                 }
             }

Assets/CardEffect/P/Green/P_200.cs

@@ -76,91 +76,71 @@ namespace DCGO.CardEffects.P
 
             #region Your Turn
 
-            #region Reduce Cost Effect
-
-            ActivateClass activateClass2 = new ActivateClass();
-            activateClass2.SetUpICardEffect("Reduce play cost", CanUseCondition2, card);
-            activateClass2.SetUpActivateClass(CanActivateCondition2, ActivateCoroutine2, -1, true, EffectDiscription2());
-
-            string EffectDiscription2()
+            if (timing == EffectTiming.BeforePayCost)
             {
-                return "[Your Turn] When any of your Digimon would digivolve into a Digimon card with the [TS] trait, by suspending this Tamer, reduce the digivolution cost by 1.";
-            }
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Digivolution Cost -1", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetHashString("Digivolve-1_P_200");
+                cardEffects.Add(activateClass);
 
-            bool CardCondition(CardSource cardSource)
-            {
-                if (cardSource.Owner == card.Owner)
+                string EffectDiscription()
                 {
-                    if (cardSource.IsDigimon)
-                    {
-                        if (cardSource.HasTSTraits)
-                        {
-                            return true;
-                        }
-                    }
+                    return "[Your Turn] When any of your Digimon would digivolve into a Digimon card with the [TS] trait, by suspending this Tamer, reduce the digivolution cost by 1.";
                 }
 
-                return false;
-            }
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
+                }
 
-            bool PermamentCondition(Permanent permanent)
-            {
-                return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
-            }
+                bool CardCondition(CardSource cardSource)
+                {
+                    return cardSource.HasTSTraits;
+                }
 
-            bool CanUseCondition2(Hashtable hashtable)
-            {
-                if (CardEffectCommons.IsExistOnBattleArea(card))
+                bool CanUseCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.CanActivateSuspendCostEffect(card))
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
                         if (CardEffectCommons.IsOwnerTurn(card))
                         {
-                            if (CardEffectCommons.CanTriggerWhenPermanentWouldDigivolve(hashtable, PermamentCondition, CardCondition))
+                            if (CardEffectCommons.CanTriggerWhenPermanentWouldDigivolve(hashtable, PermanentCondition, CardCondition))
                             {
                                 return true;
                             }
                         }
                     }
-                }
 
-                return false;
-            }
+                    return false;
+                }
 
-            bool CanActivateCondition2(Hashtable hashtable)
-            {
-                if (CardEffectCommons.IsExistOnBattleArea(card))
+                bool CanActivateCondition(Hashtable hashtable)
                 {
-                    PlayCardClass playCardClass = CardEffectCommons.GetPlayCardClassFromHashtable(hashtable);
-
-                    if (playCardClass != null)
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
-                        if (playCardClass.PayCost)
+                        if (CardEffectCommons.CanActivateSuspendCostEffect(card))
                         {
                             return true;
                         }
                     }
-                }
 
-                return false;
-            }
+                    return false;
+                }
 
-            IEnumerator ActivateCoroutine2(Hashtable _hashtable)
-            {
-                if (CardEffectCommons.IsExistOnBattleArea(card))
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
                     yield return ContinuousController.instance.StartCoroutine(new SuspendPermanentsClass(
-                        permanents: new List<Permanent> { card.PermanentOfThisCard() },
-                        hashtable: _hashtable).Tap());
+                        new List<Permanent>() { card.PermanentOfThisCard() },
+                        CardEffectCommons.CardEffectHashtable(activateClass)).Tap());
 
                     ContinuousController.instance.PlaySE(GManager.instance.GetComponent<Effects>().BuffSE);
 
                     ChangeCostClass changeCostClass = new ChangeCostClass();
-                    changeCostClass.SetUpICardEffect($"Play Cost -1", CanUseCondition1, card);
+                    changeCostClass.SetUpICardEffect("Digivolution Cost -1", CanUseCondition1, card);
                     changeCostClass.SetUpChangeCostClass(changeCostFunc: ChangeCost, cardSourceCondition: CardSourceCondition, rootCondition: RootCondition, isUpDown: isUpDown, isCheckAvailability: () => false, isChangePayingCost: () => true);
                     card.Owner.UntilCalculateFixedCostEffect.Add((_timing) => changeCostClass);
 
-                    yield return new WaitForSeconds(0.4f);
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ShowReducedCost(_hashtable));
 
                     bool CanUseCondition1(Hashtable hashtable)
@@ -186,32 +166,9 @@ namespace DCGO.CardEffects.P
 
                     bool PermanentsCondition(List<Permanent> targetPermanents)
                     {
-                        if (targetPermanents == null)
-                        {
-                            return true;
-                        }
-                        else
-                        {
-                            if (targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0)
-                            {
-                                targetPermanents.Filter(x => CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(x, card));
-                                if (targetPermanents.Count == 0)
-                                {
-                                    return true;
-                                }
-                            }
-                        }
-
-                        return false;
-                    }
-
-                    bool CardSourceCondition(CardSource cardSource)
-                    {
-                        CardSource Card = CardEffectCommons.GetCardFromHashtable(_hashtable);
-
-                        if (Card != null)
+                        if (targetPermanents != null)
                         {
-                            if (cardSource == Card)
+                            if (targetPermanents.Count(PermanentCondition) >= 1)
                             {
                                 return true;
                             }
@@ -220,131 +177,30 @@ namespace DCGO.CardEffects.P
                         return false;
                     }
 
-                    bool RootCondition(SelectCardEffect.Root root)
+                    bool PermanentCondition(Permanent targetPermanent)
                     {
-                        return true;
+                        return CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(targetPermanent, card);
                     }
 
-                    bool isUpDown()
+                    bool CardSourceCondition(CardSource cardSource)
                     {
                         return true;
                     }
-                }
-            }
-
-            #endregion
-
-            #region Before Pay Cost
-
-            if (timing == EffectTiming.BeforePayCost)
-            {
-                cardEffects.Add(activateClass2);
-            }
-
-            #endregion
-
-            #region Before Pay Cost (Not Shown)
-
-            if (timing == EffectTiming.None)
-            {
-                ChangeCostClass changeCostClass = new ChangeCostClass();
-                changeCostClass.SetUpICardEffect("Play Cost -1", CanUseCondition, card);
-                changeCostClass.SetUpChangeCostClass(changeCostFunc: ChangeCost, cardSourceCondition: CardSourceCondition, rootCondition: RootCondition, isUpDown: isUpDown, isCheckAvailability: () => true, isChangePayingCost: () => true);
-                changeCostClass.SetNotShowUI(true);
-                cardEffects.Add(changeCostClass);
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    if (!card.Owner.isYou && GManager.instance.IsAI)
-                    {
-                        return false;
-                    }
-
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if (CardEffectCommons.IsOwnerTurn(card))
-                        {
-                            if (CardEffectCommons.CanActivateSuspendCostEffect(card))
-                            {
-                                if (activateClass2 != null)
-                                {
-                                    if (!card.cEntity_EffectController.isOverMaxCountPerTurn(activateClass2, activateClass2.MaxCountPerTurn))
-                                    {
-                                        return true;
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    return false;
-                }
-
-                int ChangeCost(CardSource cardSource, int Cost, SelectCardEffect.Root root, List<Permanent> targetPermanents)
-                {
-                    if (CardSourceCondition(cardSource))
-                    {
-                        if (RootCondition(root))
-                        {
-                            if (PermanentsCondition(targetPermanents))
-                            {
-                                Cost -= 1;
-                            }
-                        }
-                    }
-
-                    return Cost;
-                }
 
-                bool PermanentsCondition(List<Permanent> targetPermanents)
-                {
-                    if (targetPermanents == null)
+                    bool RootCondition(SelectCardEffect.Root root)
                     {
                         return true;
                     }
-                    else
-                    {
-                        if (targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0)
-                        {
-                            targetPermanents.Filter(x => CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(x, card));
-                            if (targetPermanents.Count == 0)
-                            {
-                                return true;
-                            }
-                        }
-                    }
-
-                    return false;
-                }
 
-                bool CardSourceCondition(CardSource cardSource)
-                {
-                    if (cardSource.IsDigimon)
+                    bool isUpDown()
                     {
-                        if (cardSource.HasTSTraits)
-                        {
-                            return true;
-                        }
+                        return true;
                     }
-
-                    return false;
-                }
-
-                bool RootCondition(SelectCardEffect.Root root)
-                {
-                    return true;
-                }
-
-                bool isUpDown()
-                {
-                    return true;
                 }
             }
 
             #endregion
 
-            #endregion
-
             #region Security
 
             if (timing == EffectTiming.SecuritySkill)

Assets/CardEffect/P/White/P_206.cs

@@ -94,7 +94,7 @@ namespace DCGO.CardEffects.P
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Play 1 tamer with same colour as any of your digimon on the field, from your hand with 4 reduced cost", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -107,11 +107,6 @@ namespace DCGO.CardEffects.P
                     return CardEffectCommons.CanDeclareOptionDelayEffect(card);
                 }
 
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnField(card);
-                }
-
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
                     var digimonColours = card.Owner.GetBattleAreaDigimons().SelectMany(digimon => digimon.TopCard.BaseCardColors).Distinct();
@@ -161,18 +156,85 @@ namespace DCGO.CardEffects.P
                             selectHandEffect.SetUpCustomMessage_ShowCard("Played Card");
                             yield return ContinuousController.instance.StartCoroutine(selectHandEffect.Activate());
 
+                            #region Reduce Play Cost
+
+                            ChangeCostClass changeCostClass = new ChangeCostClass();
+                            changeCostClass.SetUpICardEffect($"Play Cost -4", _ => true, card);
+                            changeCostClass.SetUpChangeCostClass(changeCostFunc: ChangeCost, cardSourceCondition: CardSourceCondition,
+                                rootCondition: RootCondition, isUpDown: () => true, isCheckAvailability: () => false,
+                                isChangePayingCost: () => true);
+                            Func<EffectTiming, ICardEffect> getCardEffect = GetCardEffect;
+                            card.Owner.UntilCalculateFixedCostEffect.Add(getCardEffect);
+
+                            ICardEffect GetCardEffect(EffectTiming rcTiming)
+                            {
+                                if (rcTiming == EffectTiming.None)
+                                {
+                                    return changeCostClass;
+                                }
+
+                                return null;
+                            }
+
+                            int ChangeCost(CardSource cardSource, int cost, SelectCardEffect.Root root, List<Permanent> targetPermanents)
+                            {
+                                if (CardSourceCondition(cardSource))
+                                {
+                                    if (RootCondition(root))
+                                    {
+                                        if (PermanentsCondition(targetPermanents))
+                                        {
+                                            cost -= 4;
+                                        }
+                                    }
+                                }
+
+                                return cost;
+                            }
+
+                            bool PermanentsCondition(List<Permanent> targetPermanents)
+                            {
+                                if (targetPermanents == null)
+                                {
+                                    return true;
+                                }
+
+                                return targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0;
+                            }
+
+                            bool CardSourceCondition(CardSource cardSource)
+                            {
+                                if (cardSource.HasPlayCost)
+                                {
+                                    return selectedCard == cardSource;
+                                }
+
+                                return false;
+                            }
+
+                            bool RootCondition(SelectCardEffect.Root root)
+                            {
+                                return true;
+                            }
+
+                            #endregion
+
                             if (selectedCard != null)
                             {
-                                var cost = selectedCard.BasePlayCostFromEntity - 4;
                                 yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
                                 cardSources: new List<CardSource>() { selectedCard },
                                 activateClass: activateClass,
                                 payCost: true,
                                 isTapped: false,
                                 root: SelectCardEffect.Root.Hand,
-                                activateETB: true,
-                                fixedCost: cost));
+                                activateETB: true));
                             }
+
+                            #region Remove Reduce Cost effect
+
+                            card.Owner.UntilCalculateFixedCostEffect.Remove(getCardEffect);
+
+                            #endregion
                         }
                     }
                 }

Assets/CardEffect/P/Yellow/P_146.cs

@@ -264,10 +264,6 @@ namespace DCGO.CardEffects.P
 
                         yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource, toTop: false));
 
-                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                        yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
-
                         thisCardPermanent.willBeRemoveField = false;
 
                         thisCardPermanent.HideDeleteEffect();

Assets/Scripts/CardEffectCommons/GameContextDeterminarion.cs

@@ -134,6 +134,26 @@ public partial class CardEffectCommons
 
     #endregion
 
+    #region Whether the card is in trash
+
+    public static bool IsExistInAnyTrash(CardSource card)
+    {
+        if (card.Owner.TrashCards.Contains(card))
+        {
+            return true;
+        }
+
+        if (card.Owner.Enemy.TrashCards.Contains(card))
+        {
+            return true;
+        }
+
+
+        return false;
+    }
+
+    #endregion
+
     #region Whether the card is in Executing Area
 
     public static bool IsExistOnExecutingArea(CardSource card)

Assets/Scripts/CardObjectController.cs

@@ -986,6 +986,11 @@ public class CardObjectController : MonoBehaviour
                     cardSource.Owner.SecurityCards.Remove(cardSource);
                     cardSource.Owner.SecurityCards.Add(cardSource);
                 }
+
+                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>()
+                                                    .CreateRecoveryEffect(cardSource.Owner));
+
+                yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
             }
         }
     }