More bug fixes

Assets/CardEffect/BT23/Black/BT23_055.cs

@@ -67,7 +67,7 @@ namespace DCGO.CardEffects.BT23
                     selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to delete.", "The opponent is selecting 1 Digimon to delete.");
 
                     yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                }               
+                }
             }
             #endregion
 
@@ -97,13 +97,14 @@ namespace DCGO.CardEffects.BT23
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) && 
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
                            CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
                 }
             }
             #endregion
 
             #region All Turns - OPT
+
             if (timing == EffectTiming.WhenRemoveField)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -119,7 +120,7 @@ namespace DCGO.CardEffects.BT23
 
                 bool IsOptionCard(Permanent permanent)
                 {
-                    return CardEffectCommons.IsOwnerPermanent(permanent, card) &&
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card) &&
                            permanent.IsOption;
                 }
 
@@ -184,6 +185,7 @@ namespace DCGO.CardEffects.BT23
             #endregion
 
             #region All Turns - OPT - ESS
+
             if (timing == EffectTiming.WhenRemoveField)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -200,7 +202,7 @@ namespace DCGO.CardEffects.BT23
 
                 bool IsOptionCard(Permanent permanent)
                 {
-                    return CardEffectCommons.IsOwnerPermanent(permanent, card) &&
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card) &&
                            permanent.IsOption;
                 }
 

Assets/CardEffect/BT23/Black/BT23_058.cs

@@ -1,6 +1,5 @@
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
 
 //Craniamon
 namespace DCGO.CardEffects.BT23
@@ -60,8 +59,10 @@ namespace DCGO.CardEffects.BT23
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleArea(card) &&
-                           CardEffectCommons.CanTriggerWhenPermanentRemoveField(hashtable, RemovedPermanent);
+                    return CardEffectCommons.IsExistOnBattleArea(card)
+                        && CardEffectCommons.CanTriggerWhenPermanentRemoveField(hashtable, RemovedPermanent)
+                        && CardEffectCommons.IsByEffect(hashtable, cardEffect => CardEffectCommons.IsOpponentEffect(cardEffect, card));
+
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
@@ -151,33 +152,14 @@ namespace DCGO.CardEffects.BT23
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    Permanent selectedPermanent = card.PermanentOfThisCard();
-
-                    int maxCost = selectedPermanent.TopCard.GetCostItself;
-
                     bool PermanentCondition(Permanent permanent)
                     {
-                        if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, selectedPermanent.TopCard))
-                        {
-                            if (permanent.TopCard.GetCostItself <= maxCost)
-                            {
-                                if (permanent.TopCard.HasPlayCost)
-                                {
-                                    if (permanent.CanBeDestroyedBySkill(activateClass))
-                                    {
-                                        if (!permanent.TopCard.CanNotBeAffected(activateClass))
-                                        {
-                                            return true;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-
-                        return false;
+                        return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card)
+                            && permanent.TopCard.HasPlayCost
+                            && CardEffectCommons.IsMinCost(permanent, card.Owner.Enemy, true);
                     }
 
-                    List<Permanent> destroyTargetPermanents = selectedPermanent.TopCard.Owner.Enemy.GetBattleAreaDigimons().Filter(PermanentCondition);
+                    List<Permanent> destroyTargetPermanents = card.Owner.Enemy.GetBattleAreaDigimons().Filter(PermanentCondition);
                     yield return ContinuousController.instance.StartCoroutine(new DestroyPermanentsClass(destroyTargetPermanents, CardEffectCommons.CardEffectHashtable(activateClass)).Destroy());
                 }
             }

Assets/CardEffect/BT23/Black/BT23_060.cs

@@ -1,6 +1,5 @@
 using System.Collections;
 using System.Collections.Generic;
-using static UnityEngine.Rendering.DebugUI;
 
 //Machinedramon
 namespace DCGO.CardEffects.BT23
@@ -247,6 +246,7 @@ namespace DCGO.CardEffects.BT23
             #endregion
 
             #region When Attacking
+
             if (timing == EffectTiming.OnAllyAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -262,20 +262,22 @@ namespace DCGO.CardEffects.BT23
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    if (cardSource.EqualsTraits("Zaxon"))
+
+                    bool OnPlayEffectSecurityCondition(CardSource cardSource)
                     {
-                        if (!cardSource.IsFlipped)
-                        {
-                            List<ICardEffect> effects = cardSource.EffectList_ForCard(EffectTiming.OnEnterFieldAnyone, cardSource)
+                        List<ICardEffect> effects = cardSource.EffectList_ForCard(EffectTiming.OnEnterFieldAnyone, cardSource)
                                 .Clone()
                                 .Filter(cardEffect => cardEffect != null && cardEffect is ActivateICardEffect && !cardEffect.IsSecurityEffect && cardEffect.IsOnPlay);
 
-                            if (effects.Count > 0)
-                                return true;
-                        }
+                        if (effects.Count > 0)
+                            return true;
+
+                        return false;
                     }
 
-                    return false;
+                    return cardSource.EqualsTraits("Zaxon")
+                    && !cardSource.IsFlipped
+                    && OnPlayEffectSecurityCondition(cardSource);
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -300,10 +302,10 @@ namespace DCGO.CardEffects.BT23
                         canTargetCondition: CanSelectCardCondition,
                         canTargetCondition_ByPreSelecetedList: null,
                         canEndSelectCondition: null,
-                        canNoSelect: () => true,
+                        canNoSelect: () => false,
                         selectCardCoroutine: SelectCardCoroutine,
                         afterSelectCardCoroutine: null,
-                        message: "Select 1 card to replicate effect.",
+                        message: "Select 1 card to use their [On Play] effect.",
                         maxCount: 1,
                         canEndNotMax: false,
                         isShowOpponent: true,
@@ -315,8 +317,8 @@ namespace DCGO.CardEffects.BT23
                         cardEffect: activateClass);
 
                     selectCardEffect.SetUpCustomMessage(
-                        "Select 1 card to replicate effect.",
-                        "The opponent is selecting 1 card to replicate effect.");
+                        "Select 1 card to use their [On Play] effect.",
+                        "The opponent is selecting 1 card to use their [On Play] effect.");
 
                     yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
 
@@ -329,6 +331,7 @@ namespace DCGO.CardEffects.BT23
                     #endregion
 
                     #region Select Effect
+
                     if (selectedCard != null)
                     {
                         List<ICardEffect> candidateEffects = selectedCard.EffectList_ForCard(EffectTiming.OnEnterFieldAnyone, card)
@@ -404,6 +407,7 @@ namespace DCGO.CardEffects.BT23
 
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT23/Purple/BT23_070.cs

@@ -1,5 +1,6 @@
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 
 // Belphemon (X Antibody)
 namespace DCGO.CardEffects.BT23
@@ -93,7 +94,8 @@ namespace DCGO.CardEffects.BT23
                         failureProcess: null));
 
                     var thisPermament = card.PermanentOfThisCard();
-                    if (thisPermament.DigivolutionCards.Exists(HasBelphemonInName) && thisPermament.CanAttack(activateClass, withoutTap: true))
+
+                    if (thisPermament.DigivolutionCards.Any(HasBelphemonInName) && thisPermament.CanAttack(activateClass, withoutTap: true))
                     {
                         SelectAttackEffect selectAttackEffect = GManager.instance.GetComponent<SelectAttackEffect>();
 
@@ -104,7 +106,6 @@ namespace DCGO.CardEffects.BT23
                             cardEffect: activateClass);
 
                         selectAttackEffect.SetWithoutTap();
-                        selectAttackEffect.SetCanNotSelectNotAttack();
 
                         yield return ContinuousController.instance.StartCoroutine(selectAttackEffect.Activate());
                     }

Assets/CardEffect/BT23/Red/BT23_048.cs

@@ -53,7 +53,7 @@ namespace DCGO.CardEffects.BT23
                 bool CanSelectCardCondition1(CardSource cardSource)
                 {
                     return cardSource.HasCSTraits
-                        && (cardSource.IsTamer || cardSource.IsOption);
+                        && cardSource.IsTamer || cardSource.IsOption;
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -199,39 +199,24 @@ namespace DCGO.CardEffects.BT23
                                 }
                                 #endregion
 
-                                #region Delete EoOT
+                                #region Delete EOOT
+
                                 ActivateClass activateClass1 = new ActivateClass();
                                 activateClass1.SetUpICardEffect("Delete the Digimon", CanUseEndofOpponentTurnCondition, card);
-                                activateClass1.SetUpActivateClass(CanActivateCondition1, ActivateCoroutine1, -1, false, "");
-                                card.Owner.UntilOpponentTurnEndEffects.Add(GetCardEffect);
+                                activateClass1.SetUpActivateClass(CanActivateCondition1, ActivateCoroutine1, -1, false, "at the end of your opponent's turn, Delete this digimon");
+                                playedDigimon.EffectList(EffectTiming.OnEndTurn).Add(activateClass1);
 
                                 bool CanUseEndofOpponentTurnCondition(Hashtable hashtable)
                                 {
-                                    if (CardEffectCommons.IsPermanentExistsOnBattleArea(playedDigimon))
-                                    {
-                                        if (CardEffectCommons.IsOpponentTurn(card))
-                                        {
-                                            return true;
-                                        }
-                                    }
-
-                                    return false;
+                                    return CardEffectCommons.IsPermanentExistsOnBattleArea(playedDigimon)
+                                        && CardEffectCommons.IsOpponentTurn(card);
                                 }
 
                                 bool CanActivateCondition1(Hashtable hashtable)
                                 {
-                                    if (CardEffectCommons.IsPermanentExistsOnBattleArea(playedDigimon))
-                                    {
-                                        if (playedDigimon.CanBeDestroyedBySkill(activateClass1))
-                                        {
-                                            if (!playedDigimon.TopCard.CanNotBeAffected(activateClass1))
-                                            {
-                                                return true;
-                                            }
-                                        }
-                                    }
-
-                                    return false;
+                                    return CardEffectCommons.IsPermanentExistsOnBattleArea(playedDigimon)
+                                        && playedDigimon.CanBeDestroyedBySkill(activateClass1)
+                                        && !playedDigimon.TopCard.CanNotBeAffected(activateClass1);
                                 }
 
                                 IEnumerator ActivateCoroutine1(Hashtable _hashtable1)
@@ -239,15 +224,6 @@ namespace DCGO.CardEffects.BT23
                                     yield return ContinuousController.instance.StartCoroutine(new DestroyPermanentsClass(new List<Permanent>() { playedDigimon }, CardEffectCommons.CardEffectHashtable(activateClass1)).Destroy());
                                 }
 
-                                ICardEffect GetCardEffect(EffectTiming _timing)
-                                {
-                                    if (_timing == EffectTiming.OnEndTurn)
-                                    {
-                                        return activateClass1;
-                                    }
-
-                                    return null;
-                                }
                                 #endregion
                             }
                             #endregion

Assets/CardEffect/BT23/White/BT23_072.cs

@@ -1,7 +1,5 @@
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
-using System;
 
 //King Drasil_7D6
 namespace DCGO.CardEffects.BT23
@@ -57,16 +55,17 @@ namespace DCGO.CardEffects.BT23
             #endregion
 
             #region All Turns
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
-            { 
+            {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Gain ＜Rush＞, ＜Raid＞, ＜Reboot＞ and ＜Blocker＞", CanUseCondition, card);
+                activateClass.SetUpICardEffect("By suspending this digimon, 1 played digimon gains <Rush>, <Raid>, <Reboot> and <Blocker>", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDescription());
                 cardEffects.Add(activateClass);
 
                 string EffectDescription()
                 {
-                    return "[All Turns] When any of your Digimon with the [Royal Knight] or [CS] trait are played, by suspending this Digimon, 1 of the played Digimon gains ＜Rush＞, ＜Raid＞, ＜Reboot＞ and ＜Blocker＞ until your opponent's turn ends.";
+                    return "[All Turns] When any of your Digimon with the [Royal Knight] or [CS] trait are played, by suspending this Digimon, 1 of the played Digimon gains <Rush>, <Raid>, <Reboot> and <Blocker> until your opponent's turn ends.";
                 }
 
                 bool PlayedPermanentCondition(Permanent permanent)
@@ -89,85 +88,92 @@ namespace DCGO.CardEffects.BT23
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    yield return ContinuousController.instance.StartCoroutine(new SuspendPermanentsClass(
+                    if (!card.PermanentOfThisCard().IsSuspended)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(new SuspendPermanentsClass(
                         permanents: new List<Permanent>() { card.PermanentOfThisCard() },
-                        hashtable: _hashtable).Tap()
-                    );
+                        hashtable: _hashtable).Tap());
 
-                    List<Permanent> playedPermanents = new List<Permanent>();
-                    List<Hashtable> hashtables = CardEffectCommons.GetHashtablesFromHashtable(_hashtable);
-
-                    if (hashtables != null)
-                    {
-                        foreach (Hashtable hashtable1 in hashtables)
+                        if (card.PermanentOfThisCard().IsSuspended)
                         {
-                            Permanent permanent = CardEffectCommons.GetPermanentFromHashtable(hashtable1);
 
-                            if (permanent != null)
-                                playedPermanents.Add(permanent);
+                            List<Permanent> playedPermanents = new List<Permanent>();
+                            List<Hashtable> hashtables = CardEffectCommons.GetHashtablesFromHashtable(_hashtable);
+
+                            if (hashtables != null)
+                            {
+                                foreach (Hashtable hashtable1 in hashtables)
+                                {
+                                    Permanent permanent = CardEffectCommons.GetPermanentFromHashtable(hashtable1);
+
+                                    if (permanent != null)
+                                        playedPermanents.Add(permanent);
+                                }
+
+                                playedPermanents = playedPermanents.Filter(PermanentCondition);
+                            }
+
+                            Permanent selectedPermanent = null;
+
+                            bool PermanentCondition(Permanent permanent)
+                            {
+                                return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
+                                    && (permanent.TopCard.HasRoyalKnightTraits || permanent.TopCard.HasCSTraits)
+                                    && playedPermanents.Contains(permanent);
+                            }
+
+                            if (playedPermanents.Count == 1) selectedPermanent = playedPermanents[0];
+                            else
+                            {
+                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                                selectPermanentEffect.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: PermanentCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: 1,
+                                    canNoSelect: false,
+                                    canEndNotMax: false,
+                                    selectPermanentCoroutine: SelectPermanentCoroutine,
+                                    afterSelectPermanentCoroutine: null,
+                                    mode: SelectPermanentEffect.Mode.Custom,
+                                    cardEffect: activateClass);
+
+                                selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to gain effects.", "The opponent is selecting 1 Digimon to gain effects.");
+
+                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                                IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                                {
+                                    selectedPermanent = permanent;
+                                    yield return null;
+                                }
+                            }
+
+                            if (selectedPermanent != null)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainRush(
+                                        targetPermanent: selectedPermanent,
+                                        effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                                        activateClass: activateClass));
+
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainRaid(
+                                        targetPermanent: selectedPermanent,
+                                        effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                                        activateClass: activateClass));
+
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainReboot(
+                                        targetPermanent: selectedPermanent,
+                                        effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                                        activateClass: activateClass));
+
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainBlocker(
+                                        targetPermanent: selectedPermanent,
+                                        effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                                        activateClass: activateClass));
+                            }
                         }
-
-                        playedPermanents = playedPermanents.Filter(PermanentCondition);
-                    }
-
-                    Permanent selectedPermanent = null;
-
-                    bool PermanentCondition(Permanent permanent)
-                    {
-                        return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card) &&
-                               (permanent.TopCard.HasRoyalKnightTraits || permanent.TopCard.HasCSTraits);                    }
-
-                    if (playedPermanents.Count == 1) 
-                        selectedPermanent = playedPermanents[0];
-                    else
-                    {
-                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                        selectPermanentEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: PermanentCondition,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: 1,
-                            canNoSelect: false,
-                            canEndNotMax: false,
-                            selectPermanentCoroutine: SelectPermanentCoroutine,
-                            afterSelectPermanentCoroutine: null,
-                            mode: SelectPermanentEffect.Mode.Custom,
-                            cardEffect: activateClass);
-
-                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to gain effects.", "The opponent is selecting 1 Digimon to gain effects.");
-
-                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                        {
-                            selectedPermanent = permanent;
-                            yield return null;
-                        }
-                    }
-                    
-                    if(selectedPermanent != null)
-                    {
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainRush(
-                                targetPermanent: selectedPermanent,
-                                effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                                activateClass: activateClass));
-
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainRaid(
-                                targetPermanent: selectedPermanent,
-                                effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                                activateClass: activateClass));
-
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainReboot(
-                                targetPermanent: selectedPermanent,
-                                effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                                activateClass: activateClass));
-
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainBlocker(
-                                targetPermanent: selectedPermanent,
-                                effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                                activateClass: activateClass));
                     }
                 }
             }
@@ -191,7 +197,8 @@ namespace DCGO.CardEffects.BT23
                 {
                     return source.ContainsCardName("King Drasil") &&
                            source.IsDigimon &&
-                           CardEffectCommons.CanPlayAsNewPermanent(cardSource: source, payCost: false, cardEffect: activateClass);                }
+                           CardEffectCommons.CanPlayAsNewPermanent(cardSource: source, payCost: false, cardEffect: activateClass);
+                }
 
                 bool CanUseCondition(Hashtable hashtable)
                 {

Assets/CardEffect/BT23/White/BT23_073.cs

@@ -1,8 +1,8 @@
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEngine;
-using System;
 
 //Eater Bit
 namespace DCGO.CardEffects.BT23
@@ -88,8 +88,11 @@ namespace DCGO.CardEffects.BT23
             #endregion
 
             #region All Turns
+
             if (timing == EffectTiming.WhenRemoveField)
             {
+                List<Permanent> wouldBeRemovedPermaments = new List<Permanent>();
+
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Prevent a Digimon from leaving battle area", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
@@ -103,9 +106,16 @@ namespace DCGO.CardEffects.BT23
 
                 bool RemovedFromPlayPermanent(Permanent permanent)
                 {
-                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card) &&
-                           (permanent.TopCard.HasEaterTraits || permanent.TopCard.HasHudieTraits) &&
-                           permanent != card.PermanentOfThisCard();
+                    wouldBeRemovedPermaments.Add(permanent);
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
+                        && (permanent.TopCard.HasEaterTraits || permanent.TopCard.HasHudieTraits)
+                        && permanent != card.PermanentOfThisCard())
+                    {
+                        wouldBeRemovedPermaments.Add(permanent);
+                        return true;
+                    }
+                    return false;
+
                 }
 
                 bool HasMother(Permanent permanent)
@@ -127,13 +137,12 @@ namespace DCGO.CardEffects.BT23
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    Permanent selectedPermanent = CardEffectCommons.GetPermanentFromHashtable(_hashtable);
-                    bool canAddSource = CardEffectCommons.HasMatchConditionPermanent(HasMother, true);
+                    bool canAddSource = CardEffectCommons.HasMatchConditionOwnersBreedingPermanent(card, HasMother);
                     bool canDestroy = card.PermanentOfThisCard().CanBeDestroyed();
 
                     if (canAddSource || canDestroy)
                     {
-                        bool willDestroy = canDestroy;
+                        bool willDestroy = false;
 
                         if (canAddSource && canDestroy)
                         {
@@ -149,9 +158,12 @@ namespace DCGO.CardEffects.BT23
                             GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
                             yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
-
                             willDestroy = GManager.instance.userSelectionManager.SelectedBoolValue;
                         }
+                        else
+                        {
+                            willDestroy = canDestroy;
+                        }
 
                         if (willDestroy)
                         {
@@ -165,24 +177,53 @@ namespace DCGO.CardEffects.BT23
                         else
                         {
                             yield return ContinuousController.instance.StartCoroutine(new IPlacePermanentToDigivolutionCards(new List<Permanent[]>() { new Permanent[] { card.PermanentOfThisCard(), card.Owner.GetBreedingAreaPermanents()[0] } }, false, activateClass).PlacePermanentToDigivolutionCards());
-
-                            yield return ContinuousController.instance.StartCoroutine("SuccessProcess");
-                        }                        
+                            yield return ContinuousController.instance.StartCoroutine(SuccessProcess());
+                        }
 
                         IEnumerator SuccessProcess()
                         {
-                            selectedPermanent.willBeRemoveField = false;
+                            Permanent selectedPermanent = null;
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(perm => wouldBeRemovedPermaments.Contains(perm)));
+
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: perm => wouldBeRemovedPermaments.Contains(perm),
+                                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)
+                            {
+                                selectedPermanent = permanent;
+                                yield return null;
+                            }
+
+                            selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will not be removed from battle area.", "The opponent is selecting 1 Digimon that will not be removed from battle area.");
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
-                            selectedPermanent.HideDeleteEffect();
-                            selectedPermanent.HideHandBounceEffect();
-                            selectedPermanent.HideDeckBounceEffect();
-                            selectedPermanent.HideWillRemoveFieldEffect();
+                            if (selectedPermanent == null)
+                            {
+                                selectedPermanent.willBeRemoveField = false;
 
-                            yield return null;
+                                selectedPermanent.HideDeleteEffect();
+                                selectedPermanent.HideHandBounceEffect();
+                                selectedPermanent.HideDeckBounceEffect();
+                                selectedPermanent.HideWillRemoveFieldEffect();
+                                yield return null;
+                            }
                         }
                     }
                 }
             }
+
             #endregion
 
             #region ESS