test build 1.9.1.3

Assets/CardEffect/BT17/Green/BT17_043.cs

@@ -74,8 +74,9 @@ namespace DCGO.CardEffects.BT17
                 {
                     if(CardEffectCommons.IsExistOnBattleArea(card))
                     {
-                        return true;
+                        return CardEffectCommons.IsOwnerTurn(card);
                     }
+
                     return false;
                 }
 

Assets/CardEffect/BT20/Red/BT20_019.cs

@@ -357,7 +357,8 @@ namespace DCGO.CardEffects.BT20
 
                 bool CardSourceCondition(CardSource cardSource)
                 {
-                    return PermanentCondition(cardSource.PermanentOfThisCard());
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(cardSource) &&
+                           CardEffectCommons.IsOwnerPermanent(cardSource.PermanentOfThisCard(), card);
                 }
 
                 List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
@@ -366,7 +367,8 @@ namespace DCGO.CardEffects.BT20
                     {
                         bool Condition()
                         {
-                            return CardSourceCondition(cardSource);
+                            return card.PermanentOfThisCard().TopCard.EqualsCardName("Jesmon GX") &&
+                                   CardSourceCondition(cardSource);
                         }
 
                         cardEffects.Add(CardEffectFactory.PierceSelfEffect(isInheritedEffect: false, card: card, condition: Condition));

Assets/CardEffect/BT21/Blue/BT21_039.cs

@@ -190,6 +190,7 @@ namespace DCGO.CardEffects.BT21
                 {
                     return CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card) &&
                            permanent.IsDigimon &&
+                           permanent != card.PermanentOfThisCard() &&
                            card.Owner.HandCards.Where(DigivolveToCardCondition).Any(cardSource =>
                                cardSource.CanPlayCardTargetFrame(permanent.PermanentFrame, false, activateClass));
                 }

Assets/CardEffect/BT21/Red/BT21_022.cs

@@ -262,7 +262,7 @@ namespace DCGO.CardEffects.BT21
                                 mode: SelectCardEffect.Mode.Custom,
                                 root: SelectCardEffect.Root.Custom,
                                 customRootCardList: permanent.DigivolutionCards,
-                                canLookReverseCard: true,
+                                canLookReverseCard: false,
                                 selectPlayer: card.Owner,
                                 cardEffect: null);
 

Assets/CardEffect/EX9/Black/EX9_047.cs

@@ -78,32 +78,9 @@ namespace DCGO.CardEffects.EX9
                             return false;
                         }
 
-                        bool CanTargetCondition_ByPreSelecetedList(List<CardSource> cardSources, CardSource cardSource)
-                        {
-                            List<string> cardNames = new List<string>();
-
-                            foreach (CardSource cardSource1 in cardSources)
-                            {
-                                foreach (string cardName in cardSource1.CardNames)
-                                {
-                                    if (!cardNames.Contains(cardName))
-                                    {
-                                        cardNames.Add(cardName);
-                                    }
-                                }
-                            }
-
-                            if (cardSource.CardNames.Count((cardName) => cardNames.Contains(cardName)) >= 1)
-                            {
-                                return false;
-                            }
-
-                            return true;
-                        }
-
                         AssemblyCondition assemblyCondition = new AssemblyCondition(
                             element: element,
-                            CanTargetCondition_ByPreSelecetedList: CanTargetCondition_ByPreSelecetedList,
+                            CanTargetCondition_ByPreSelecetedList: null,
                             selectMessage: "4 Digimon cards with [Eyesmon: Scatter Mode] in their names",
                             elementCount: 4,
                             reduceCost: 3);

Assets/CardEffect/EX9/Black/EX9_051.cs

@@ -56,7 +56,8 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card) &&
+                           card.Owner.HandCards.Count > 0;
                 }
             }
 
@@ -83,7 +84,8 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
+                           card.Owner.HandCards.Count > 0;
                 }
             }
 
@@ -98,71 +100,71 @@ namespace DCGO.CardEffects.EX9
 
             IEnumerator SharedActivateCoroutine(Hashtable hashtable, ActivateClass activateClass)
             {
-                if (card.Owner.HandCards.Any())
+                CardSource selectedCard = null;
+
+                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: false,
+                    selectCardCoroutine: SelectCardCoroutine,
+                    afterSelectCardCoroutine: null,
+                    mode: SelectHandEffect.Mode.Custom,
+                    cardEffect: activateClass);
+
+                yield return ContinuousController.instance.StartCoroutine(selectHandEffect.Activate());
+                selectHandEffect.SetUpCustomMessage("Select a card to add face down as a source", "Opponent is selecting a card to add face down as a source");
+
+                IEnumerator SelectCardCoroutine(CardSource cardSource)
                 {
-                    CardSource selectedCard = null;
-                    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: false,
-                        selectCardCoroutine: SelectCardCoroutine,
-                        afterSelectCardCoroutine: null,
-                        mode: SelectHandEffect.Mode.Custom,
-                        cardEffect: activateClass);
-                    yield return StartCoroutine(selectHandEffect.Activate());
-                    selectHandEffect.SetUpCustomMessage("Select a card to add face down as a source", "Opponent is selecting a card to add face down as a source");
-
-                    IEnumerator SelectCardCoroutine(CardSource cardSource)
-                    {
-                        selectedCard = cardSource;
-                        yield return null;
-                    }
+                    selectedCard = cardSource;
+                    yield return null;
+                }
 
-                    if (selectedCard != null)
+                if (selectedCard != null)
+                {
+                    Permanent permanent = card.PermanentOfThisCard();
+                    yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddExecutingCard(selectedCard));
+                    yield return ContinuousController.instance.StartCoroutine(permanent.AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
+
+                    if (CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectPermanentCondition))
                     {
-                        Permanent permanent = card.PermanentOfThisCard();
-                        yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddExecutingCard(selectedCard));
-                        yield return ContinuousController.instance.StartCoroutine(permanent.AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
+                        Permanent selectedPermanent = null;
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOpponentsPermanentCount(card, CanSelectPermanentCondition));
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass
+                        );
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to De-Digivolve", "Opponent is selecting 1 Digimon to De-Digivolve");
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            selectedPermanent = permanent;
+                            yield return null;
+                        }
 
-                        if (CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectPermanentCondition))
+                        if (selectedPermanent != null)
                         {
-                            Permanent selectedPermanent = null;
-                            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOpponentsPermanentCount(card, CanSelectPermanentCondition));
-
-                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-                            selectPermanentEffect.SetUp(
-                                selectPlayer: card.Owner,
-                                canTargetCondition: CanSelectPermanentCondition,
-                                canTargetCondition_ByPreSelecetedList: null,
-                                canEndSelectCondition: null,
-                                maxCount: maxCount,
-                                canNoSelect: false,
-                                canEndNotMax: false,
-                                selectPermanentCoroutine: SelectPermanentCoroutine,
-                                afterSelectPermanentCoroutine: null,
-                                mode: SelectPermanentEffect.Mode.Custom,
-                                cardEffect: activateClass
-                            );
-
-                            selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to De-Digivolve", "Opponent is selecting 1 Digimon to De-Digivolve");
-                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                            IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                            {
-                                selectedPermanent = permanent;
-                                yield return null;
-                            }
-
-                            if (selectedPermanent != null)
-                            {
-                                yield return ContinuousController.instance.StartCoroutine(new IDegeneration(selectedPermanent, 1, activateClass).Degeneration());
-                            }
+                            yield return ContinuousController.instance.StartCoroutine(new IDegeneration(selectedPermanent, 1, activateClass).Degeneration());
                         }
                     }
                 }

Assets/CardEffect/EX9/Black/EX9_055.cs

@@ -52,7 +52,7 @@ namespace DCGO.CardEffects.EX9
                             CanTargetCondition_ByPreSelecetedList: null,
                             selectMessage: "4 [Negamon]",
                             elementCount: 4,
-                            reduceCost: 3);
+                            reduceCost: 6);
 
                         return assemblyCondition;
                     }

Assets/CardEffect/EX9/Black/EX9_057.cs

@@ -219,7 +219,7 @@ namespace DCGO.CardEffects.EX9
                     afterSelectCardCoroutine: AfterSelectCardCoroutine,
                     message: "Select cards to place as the top digivolution sources",
                     maxCount: 3,
-                    canEndNotMax: true,
+                    canEndNotMax: false,
                     isShowOpponent: false,
                     mode: SelectCardEffect.Mode.Custom,
                     root: SelectCardEffect.Root.Trash,
@@ -287,7 +287,7 @@ namespace DCGO.CardEffects.EX9
                     afterSelectCardCoroutine: AfterSelectCardCoroutine,
                     message: "Select cards to place as the top digivolution sources",
                     maxCount: 3,
-                    canEndNotMax: true,
+                    canEndNotMax: false,
                     isShowOpponent: false,
                     mode: SelectCardEffect.Mode.Custom,
                     root: SelectCardEffect.Root.Trash,
@@ -354,7 +354,7 @@ namespace DCGO.CardEffects.EX9
                     afterSelectCardCoroutine: AfterSelectCardCoroutine,
                     message: "Select cards to place as the top digivolution sources",
                     maxCount: 3,
-                    canEndNotMax: true,
+                    canEndNotMax: false,
                     isShowOpponent: false,
                     mode: SelectCardEffect.Mode.Custom,
                     root: SelectCardEffect.Root.Trash,

Assets/CardEffect/EX9/Black/EX9_068.cs

@@ -34,8 +34,8 @@ namespace DCGO.CardEffects.EX9
                 bool EnterFieldPermanent(Permanent permanent)
                 {
                     return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card) &&
-                           permanent.IsDigimon && permanent.TopCard.HasPlayCost && permanent.TopCard.GetCostItself >= 7 && 
-                           (permanent.TopCard.EqualsTraits("Cyborg") || permanent.TopCard.EqualsTraits("Machine") && permanent.TopCard.EqualsTraits("DM"));
+                           permanent.IsDigimon && permanent.TopCard.HasPlayCost && permanent.TopCard.GetCostItself >= 7 &&
+                           (permanent.TopCard.EqualsTraits("Cyborg") || permanent.TopCard.EqualsTraits("Machine") || permanent.TopCard.EqualsTraits("DM"));
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -90,18 +90,27 @@ namespace DCGO.CardEffects.EX9
 
                         if (selectedCard != null)
                         {
-                            if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, EnterFieldPermanent))
+                            List<Hashtable> hash = CardEffectCommons.GetHashtablesFromHashtable(hashtable);
+                            List<Permanent> playedPermanents = new List<Permanent>();
+
+                            foreach (Hashtable ht in hash)
+                                playedPermanents.Add(CardEffectCommons.GetPermanentFromHashtable(ht));
+
+                            bool PlayedPermanent(Permanent permanent)
                             {
-                                Permanent selectedPermanent = null;
-                                int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOwnersPermanentCount(card, EnterFieldPermanent));
+                                return playedPermanents.Contains(permanent) &&
+                                       PlayedPermanent(permanent);                            }
 
+                            if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, PlayedPermanent))
+                            {
+                                Permanent selectedPermanent = null;
                                 SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
                                 selectPermanentEffect.SetUp(
                                     selectPlayer: card.Owner,
-                                    canTargetCondition: EnterFieldPermanent,
+                                    canTargetCondition: PlayedPermanent,
                                     canTargetCondition_ByPreSelecetedList: null,
                                     canEndSelectCondition: null,
-                                    maxCount: maxCount,
+                                    maxCount: 1,
                                     canNoSelect: false,
                                     canEndNotMax: false,
                                     selectPermanentCoroutine: SelectPermanentCoroutine,

Assets/CardEffect/EX9/Blue/EX9_021.cs

@@ -207,9 +207,12 @@ namespace DCGO.CardEffects.EX9
                 {
                     if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass))
                     {
-                        if (cardSource.HasGreymonName || cardSource.EqualsTraits("Ver.1"))
+                        if (cardSource.IsDigimon)
                         {
-                            return true;
+                            if (cardSource.HasGreymonName || cardSource.EqualsTraits("Ver.1"))
+                            {
+                                return true;
+                            }
                         }
                     }
 
@@ -220,9 +223,12 @@ namespace DCGO.CardEffects.EX9
                 {
                     if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass))
                     {
-                        if (cardSource.HasGarurumonName || cardSource.EqualsTraits("Ver.2"))
+                        if (cardSource.IsDigimon)
                         {
-                            return true;
+                            if (cardSource.HasGarurumonName || cardSource.EqualsTraits("Ver.2"))
+                            {
+                                return true;
+                            }
                         }
                     }
 
@@ -261,7 +267,7 @@ namespace DCGO.CardEffects.EX9
                             mode: SelectCardEffect.Mode.Custom,
                             root: SelectCardEffect.Root.Custom,
                             customRootCardList: card.PermanentOfThisCard().DigivolutionCards,
-                            canLookReverseCard: true,
+                            canLookReverseCard: false,
                             selectPlayer: card.Owner,
                             cardEffect: activateClass);
 
@@ -293,7 +299,7 @@ namespace DCGO.CardEffects.EX9
                             mode: SelectCardEffect.Mode.Custom,
                             root: SelectCardEffect.Root.Custom,
                             customRootCardList: card.PermanentOfThisCard().DigivolutionCards,
-                            canLookReverseCard: true,
+                            canLookReverseCard: false,
                             selectPlayer: card.Owner,
                             cardEffect: activateClass);
 

Assets/CardEffect/EX9/Green/EX9_037.cs

@@ -36,7 +36,7 @@ namespace DCGO.CardEffects.EX9
 
             if (timing == EffectTiming.OnDeclaration)
             {
-                // To be implemented
+                cardEffects.Add(CardEffectFactory.TrainingEffect(card: card));
             }
 
             #endregion

Assets/CardEffect/EX9/Green/EX9_038.cs

@@ -84,15 +84,15 @@ namespace DCGO.CardEffects.EX9
                         maxCount: maxCount,
                         canNoSelect: true,
                         canEndNotMax: true,
-                        isShowOpponent: true,
+                        isShowOpponent: false,
                         selectCardCoroutine: SelectCardCoroutine,
                         afterSelectCardCoroutine: null,
                         mode: SelectHandEffect.Mode.Custom,
                         cardEffect: activateClass);
 
                     selectHandEffect.SetUpCustomMessage("Select 1 card to add as FD Source", "The opponent is selecting 1 card to add as FD source");
-                    selectHandEffect.SetUpCustomMessage_ShowCard("Played Card");
-                    yield return StartCoroutine(selectHandEffect.Activate());
+
+                    yield return ContinuousController.instance.StartCoroutine(selectHandEffect.Activate());
 
                     IEnumerator SelectCardCoroutine(CardSource cardSource)
                     {

Assets/CardEffect/EX9/Green/EX9_039.cs

@@ -156,7 +156,6 @@ namespace DCGO.CardEffects.EX9
                     if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition1))
                     {
                         List<Permanent> selectedPermanents = new List<Permanent>();
-                        int maxCount2 = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition1));
 
                         SelectPermanentEffect selectPermanentEffect1 = GManager.instance.GetComponent<SelectPermanentEffect>();
                         selectPermanentEffect1.SetUp(
@@ -164,7 +163,7 @@ namespace DCGO.CardEffects.EX9
                             canTargetCondition: CanSelectPermanentCondition1,
                             canTargetCondition_ByPreSelecetedList: null,
                             canEndSelectCondition: null,
-                            maxCount: maxCount2,
+                            maxCount: 1,
                             canNoSelect: true,
                             canEndNotMax: false,
                             selectPermanentCoroutine: null,
@@ -213,7 +212,7 @@ namespace DCGO.CardEffects.EX9
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Place 1 hand card as FD bottom source, suspend 1 digimon, then attack", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -322,7 +321,6 @@ namespace DCGO.CardEffects.EX9
                     if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition1))
                     {
                         List<Permanent> selectedPermanents = new List<Permanent>();
-                        int maxCount2 = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition1));
 
                         SelectPermanentEffect selectPermanentEffect1 = GManager.instance.GetComponent<SelectPermanentEffect>();
                         selectPermanentEffect1.SetUp(
@@ -330,7 +328,7 @@ namespace DCGO.CardEffects.EX9
                             canTargetCondition: CanSelectPermanentCondition1,
                             canTargetCondition_ByPreSelecetedList: null,
                             canEndSelectCondition: null,
-                            maxCount: maxCount2,
+                            maxCount: 1,
                             canNoSelect: true,
                             canEndNotMax: false,
                             selectPermanentCoroutine: null,

Assets/CardEffect/EX9/Purple/EX9_064.cs

@@ -185,7 +185,8 @@ namespace DCGO.CardEffects.EX9
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
                     var playCost = 4 + card.PermanentOfThisCard().DigivolutionCards.Filter(x => x.IsFlipped).Count;
-                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) && permanent.TopCard.BasePlayCostFromEntity <= playCost;
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) && 
+                           permanent.TopCard.HasPlayCost && permanent.TopCard.BasePlayCostFromEntity <= playCost;
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
@@ -241,7 +242,7 @@ namespace DCGO.CardEffects.EX9
                                     canEndSelectCondition: null,
                                     maxCount: maxCount1,
                                     canNoSelect: false,
-                                    canEndNotMax: true,
+                                    canEndNotMax: false,
                                     selectPermanentCoroutine: null,
                                     afterSelectPermanentCoroutine: null,
                                     mode: SelectPermanentEffect.Mode.Destroy,
@@ -289,7 +290,8 @@ namespace DCGO.CardEffects.EX9
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
                     var playCost = 4 + card.PermanentOfThisCard().DigivolutionCards.Filter(x => x.IsFlipped).Count;
-                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) && permanent.TopCard.BasePlayCostFromEntity <= playCost;
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) &&
+                           permanent.TopCard.HasPlayCost && permanent.TopCard.BasePlayCostFromEntity <= playCost;
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
@@ -345,7 +347,7 @@ namespace DCGO.CardEffects.EX9
                                     canEndSelectCondition: null,
                                     maxCount: maxCount1,
                                     canNoSelect: false,
-                                    canEndNotMax: true,
+                                    canEndNotMax: false,
                                     selectPermanentCoroutine: null,
                                     afterSelectPermanentCoroutine: null,
                                     mode: SelectPermanentEffect.Mode.Destroy,

Assets/CardEffect/EX9/Red/EX9_009.cs

@@ -78,30 +78,15 @@ namespace DCGO.CardEffects.EX9
                     return false;
                 }
 
-                bool CanSelectPermanentCondition(Permanent permanent)
-                {
-                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
-                    {
-                        if (card.PermanentOfThisCard() == permanent)
-                        {
-                            return true;
-                        }
-                    }
-                    return false;
-                }
-
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, CanSelectPermanentCondition))
-                    {
-                        var selectedCard = card.Owner.LibraryCards[0];
-                        yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddExecutingCard(selectedCard));
-                        yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
+                    var selectedCard = card.Owner.LibraryCards[0];
+                    yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddExecutingCard(selectedCard));
+                    yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
 
-                        var flippedCards = card.PermanentOfThisCard().DigivolutionCards.Count(x => x.IsFlipped);
-                        var dpBonus = flippedCards * 1000;
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: card.PermanentOfThisCard(), changeValue: dpBonus, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
-                    }
+                    var flippedCards = card.PermanentOfThisCard().DigivolutionCards.Count(x => x.IsFlipped);
+                    var dpBonus = flippedCards * 1000;
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: card.PermanentOfThisCard(), changeValue: dpBonus, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
                 }
             }
 

Assets/CardEffect/EX9/Red/EX9_013.cs

@@ -245,7 +245,7 @@ namespace DCGO.CardEffects.EX9
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("DNA into [Omnimon Alter-S]", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()

Assets/CardEffect/EX9/White/EX9_072.cs

@@ -35,31 +35,38 @@ namespace DCGO.CardEffects.EX9
             #endregion
 
             #region All Turns - Security
-
             if (timing == EffectTiming.None)
             {
-                bool CanUseCondition()
+                bool Condition()
                 {
-                    return CardEffectCommons.IsExistInSecurity(card);
+                    return CardEffectCommons.IsExistInSecurity(card, false);
                 }
 
                 bool PermanentCondition(Permanent permanent)
                 {
-                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card) &&
-                           permanent.TopCard.EqualsTraits("DM") && permanent.DigivolutionCards.Exists(x => x.IsFlipped);
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card))
+                    {
+                        if (permanent.TopCard.EqualsTraits("DM"))
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
                 }
 
-                foreach (Permanent permanent in card.Owner.GetBattleAreaPermanents().Filter(PermanentCondition))
+                foreach (Permanent permanent in card.Owner.GetBattleAreaPermanents())
                 {
-                    int dpValue = permanent.DigivolutionCards.Filter(x => x.IsFlipped).Count * 1000;
-
-                    if (CanUseCondition())
-                        permanent.AddBoost(new Permanent.DPBoost("EX9_072", dpValue, CanUseCondition));
+                    if (Condition() && PermanentCondition(permanent))
+                    {
+                        int dpValue = permanent.DigivolutionCards.Filter(x => x.IsFlipped).Count * 1000;
+                        permanent.AddBoost(new Permanent.DPBoost("EX9_072", dpValue, Condition));
+                    }
+                        
                     else
                         permanent.RemoveBoost("EX9_072");
                 }
             }
-
             #endregion
 
             #region Main Effect

Assets/CardEffect/EX9/White/EX9_074.cs

@@ -253,7 +253,8 @@ namespace DCGO.CardEffects.EX9
                             bool CanSelectOpponentDigimon(Permanent permanent)
                             {
                                 return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) &&
-                                       permanent.TopCard.CardColors.Contains(deletableColor);
+                                       permanent.TopCard.CardColors.Contains(deletableColor) &&
+                                       CanTargetCondition_ByPreSelecetedList(permanentToDelete, permanent);
                             }
 
                             if (CardEffectCommons.HasMatchConditionPermanent(CanSelectOpponentDigimon))
@@ -443,7 +444,8 @@ namespace DCGO.CardEffects.EX9
                             bool CanSelectOpponentDigimon(Permanent permanent)
                             {
                                 return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) &&
-                                       permanent.TopCard.CardColors.Contains(deletableColor);
+                                       permanent.TopCard.CardColors.Contains(deletableColor) &&
+                                       CanTargetCondition_ByPreSelecetedList(permanentToDelete, permanent);
                             }
 
                             if (CardEffectCommons.HasMatchConditionPermanent(CanSelectOpponentDigimon))

Assets/CardEffect/EX9/Yellow/EX9_025.cs

@@ -56,7 +56,7 @@ namespace DCGO.CardEffects.EX9
             if (timing == EffectTiming.OnAllyAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect($"By Placing top card of deck FD as bottom source card, give -{DPMinus() + 2000}k DP to 1 digimon", CanUseCondition, card);
+                activateClass.SetUpICardEffect($"By Placing top card FD as bottom source card, give -2000 DP to 1 digimon for each FD source", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
                 activateClass.SetHashString("EX9_025_WA");
                 cardEffects.Add(activateClass);
@@ -66,7 +66,7 @@ namespace DCGO.CardEffects.EX9
                     return "[When Attacking] [Once Per Turn] By placing your deck's top card face down as this Digimon's bottom digivolution card, to 1 of your opponent's Digimon, give -2000 DP for the turn for each of this Digimon's face-down digivolution cards.";
                 }
 
-                int DPMinus() => card.PermanentOfThisCard().DigivolutionCards.Filter(x => x.IsFlipped).Count * 2000;
+                
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
@@ -85,68 +85,22 @@ namespace DCGO.CardEffects.EX9
                     return false;
                 }
 
-                bool CanSelectPermanentCondition(Permanent permanent)
-                {
-                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
-                    {
-                        return true;
-                    }
-                    return false;
-                }
-
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    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),
-                    };
+                    CardSource selectedCard = card.Owner.LibraryCards[0];
+                    yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
 
-                    string selectPlayerMessage = "Will you place the top deck card face down as bottom source of this digimon?";
-                    string notSelectPlayerMessage = "The opponent is choosing to use the effect";
-                    GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
-                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+                    Permanent selectedPermanent = card.PermanentOfThisCard();
 
-                    bool useEffect = GManager.instance.userSelectionManager.SelectedBoolValue;
-                    if (useEffect)
-                    {
-                        CardSource selectedCard = card.Owner.LibraryCards[0];
-                        yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
-
-                        Permanent selectedPermanent = null;
-                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                        selectPermanentEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: CanSelectPermanentCondition,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: maxCount,
-                            canNoSelect: false,
-                            canEndNotMax: false,
-                            selectPermanentCoroutine: SelectPermanentCoroutine,
-                            afterSelectPermanentCoroutine: null,
-                            mode: SelectPermanentEffect.Mode.Custom,
-                            cardEffect: activateClass);
-
-                        selectPermanentEffect.SetUpCustomMessage($"Select 1 Digimon to give -{DPMinus()}k DP", $"The opponent is selecting 1 card to give -{DPMinus()}k DP");
-                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                        {
-                            selectedPermanent = permanent;
-                            yield return null;
-                        }
+                    int DPMinus() => selectedPermanent.DigivolutionCards.Filter(x => x.IsFlipped).Count * 2000;
 
-                        if (selectedPermanent != null)
-                        {
-                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
-                                targetPermanent: selectedPermanent,
-                                changeValue: -DPMinus(),
-                                effectDuration: EffectDuration.UntilEachTurnEnd,
-                                activateClass: activateClass));
-                        }
+                    if (selectedPermanent != null && selectedPermanent.DigivolutionCards.Contains(selectedCard))
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
+                            targetPermanent: selectedPermanent,
+                            changeValue: -DPMinus(),
+                            effectDuration: EffectDuration.UntilEachTurnEnd,
+                            activateClass: activateClass));
                     }
                 }
             }

Assets/CardEffect/EX9/Yellow/EX9_029.cs

@@ -77,14 +77,14 @@ namespace DCGO.CardEffects.EX9
                         maxCount: 1,
                         canNoSelect: true,
                         canEndNotMax: false,
-                        isShowOpponent: true,
+                        isShowOpponent: false,
                         selectCardCoroutine: SelectCardCoroutine,
                         afterSelectCardCoroutine: null,
                         mode: SelectHandEffect.Mode.Custom,
                         cardEffect: activateClass);
 
                     selectHandEffect.SetUpCustomMessage("Select 1 card to place face-down on bottom of digivolution cards.", "The opponent is selecting 1 card to place face-down on bottom of digivolution cards.");
-                    selectHandEffect.SetUpCustomMessage_ShowCard("Digivolution Card");
+
                     yield return ContinuousController.instance.StartCoroutine(selectHandEffect.Activate());
 
                     IEnumerator SelectCardCoroutine(CardSource cardSource)
@@ -153,7 +153,7 @@ namespace DCGO.CardEffects.EX9
                         maxCount: 1,
                         canNoSelect: true,
                         canEndNotMax: false,
-                        isShowOpponent: true,
+                        isShowOpponent: false,
                         selectCardCoroutine: SelectCardCoroutine,
                         afterSelectCardCoroutine: null,
                         mode: SelectHandEffect.Mode.Custom,
@@ -161,7 +161,8 @@ namespace DCGO.CardEffects.EX9
 
                     selectHandEffect.SetUpCustomMessage("Select 1 card to place face-down on bottom of digivolution cards.",
                         "The opponent is selecting 1 card to place face-down on bottom of digivolution cards.");
-                    selectHandEffect.SetUpCustomMessage_ShowCard("Digivolution Card");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectHandEffect.Activate());
 
                     IEnumerator SelectCardCoroutine(CardSource cardSource)
                     {

Assets/CardEffect/EX9/Yellow/EX9_032.cs

@@ -53,55 +53,62 @@ namespace DCGO.CardEffects.EX9
                 bool CanSelectPermantentCondition(Permanent permanent)
                 {
                     return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card) &&
-                           (permanent.IsToken || (permanent.TopCard.EqualsTraits("Puppet")) && 
-                           permanent.TopCard != card);
+                           (permanent.IsToken || (permanent.TopCard.EqualsTraits("Puppet") && permanent.TopCard != card));
                 }
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    return cardSource.IsDigimon && cardSource.EqualsTraits("Puppet");
+                    return cardSource.IsDigimon && cardSource.EqualsTraits("Puppet") &&
+                           cardSource.CanPlayCardTargetFrame(card.PermanentOfThisCard().PermanentFrame,false,activateClass);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    bool deleted = false;
-                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermantentCondition));
-                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                    selectPermanentEffect.SetUp(
-                        selectPlayer: card.Owner,
-                        canTargetCondition: CanSelectPermantentCondition,
-                        canTargetCondition_ByPreSelecetedList: null,
-                        canEndSelectCondition: null,
-                        maxCount: maxCount,
-                        canNoSelect: true,
-                        canEndNotMax: true,
-                        selectPermanentCoroutine: null,
-                        afterSelectPermanentCoroutine: AfterSelectPermanentCoroutine,
-                        mode: SelectPermanentEffect.Mode.Destroy,
-                        cardEffect: activateClass);
-
-                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to delete", "The opponent is selecting 1 Digimon to delete");
-                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                    IEnumerator AfterSelectPermanentCoroutine(List<Permanent> permanents)
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermantentCondition))
                     {
-                        if (permanents.Any()) deleted = true;
-                        yield return null;
+                        List<Permanent> deleteTargetPermanents = new List<Permanent>();
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermantentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: 1,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: null,
+                            afterSelectPermanentCoroutine: AfterSelectPermanentCoroutine,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to delete.", "The opponent is selecting 1 Digimon to delete.");
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        IEnumerator AfterSelectPermanentCoroutine(List<Permanent> permanents)
+                        {
+                            deleteTargetPermanents = permanents.Clone();
+
+                            yield return null;
+                        }
+
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: deleteTargetPermanents, activateClass: activateClass, successProcess: SuccessProcess, failureProcess: null));
                     }
 
-                    if (deleted)
+                    IEnumerator SuccessProcess(List<Permanent> permanents)
                     {
                         yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DigivolveIntoHandOrTrashCard(
-                                targetPermanent: card.PermanentOfThisCard(),
-                                cardCondition: CanSelectCardCondition,
-                                payCost: false,
-                                reduceCostTuple: null,
-                                fixedCostTuple: null,
-                                ignoreDigivolutionRequirementFixedCost: -1,
-                                isHand: true,
-                                activateClass: activateClass,
-                                successProcess: null));
+                                    targetPermanent: card.PermanentOfThisCard(),
+                                    cardCondition: CanSelectCardCondition,
+                                    payCost: false,
+                                    reduceCostTuple: null,
+                                    fixedCostTuple: null,
+                                    ignoreDigivolutionRequirementFixedCost: -1,
+                                    isHand: true,
+                                    activateClass: activateClass,
+                                    successProcess: null));
                     }
                 }
             }
@@ -135,61 +142,62 @@ namespace DCGO.CardEffects.EX9
                 bool CanSelectPermantentCondition(Permanent permanent)
                 {
                     return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card) &&
-                           (permanent.IsToken || (permanent.TopCard.EqualsTraits("Puppet")) &&
-                           permanent.TopCard != card);
+                           (permanent.IsToken || (permanent.TopCard.EqualsTraits("Puppet") && permanent.TopCard != card));
                 }
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    return cardSource.IsDigimon && cardSource.EqualsTraits("Puppet");
+                    return cardSource.IsDigimon && cardSource.EqualsTraits("Puppet") &&
+                           cardSource.CanPlayCardTargetFrame(card.PermanentOfThisCard().PermanentFrame, false, activateClass);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    Permanent selectedPermanent = null;
-                    bool deleted = false;
-                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermantentCondition));
-                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                    selectPermanentEffect.SetUp(
-                        selectPlayer: card.Owner,
-                        canTargetCondition: CanSelectPermantentCondition,
-                        canTargetCondition_ByPreSelecetedList: null,
-                        canEndSelectCondition: null,
-                        maxCount: maxCount,
-                        canNoSelect: true,
-                        canEndNotMax: true,
-                        selectPermanentCoroutine: SelectPermanentCoroutine,
-                        afterSelectPermanentCoroutine: null,
-                        mode: SelectPermanentEffect.Mode.Custom,
-                        cardEffect: activateClass);
-
-                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to delete", "The opponent is selecting 1 Digimon to delete");
-                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermantentCondition))
                     {
-                        selectedPermanent = permanent;
-                        yield return null;
-                    }
+                        List<Permanent> deleteTargetPermanents = new List<Permanent>();
 
-                    if(selectedPermanent != null)
-                    {
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: new List<Permanent>() { selectedPermanent }, activateClass: activateClass, successProcess: permanents => SuccessProcess(), failureProcess: null));
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
 
-                        IEnumerator SuccessProcess()
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermantentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: 1,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: null,
+                            afterSelectPermanentCoroutine: AfterSelectPermanentCoroutine,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to delete.", "The opponent is selecting 1 Digimon to delete.");
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        IEnumerator AfterSelectPermanentCoroutine(List<Permanent> permanents)
                         {
-                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DigivolveIntoHandOrTrashCard(
-                                targetPermanent: card.PermanentOfThisCard(),
-                                cardCondition: CanSelectCardCondition,
-                                payCost: false,
-                                reduceCostTuple: null,
-                                fixedCostTuple: null,
-                                ignoreDigivolutionRequirementFixedCost: -1,
-                                isHand: true,
-                                activateClass: activateClass,
-                                successProcess: null));
+                            deleteTargetPermanents = permanents.Clone();
+
+                            yield return null;
                         }
+
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: deleteTargetPermanents, activateClass: activateClass, successProcess: SuccessProcess, failureProcess: null));
+                    }
+
+                    IEnumerator SuccessProcess(List<Permanent> permanents)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DigivolveIntoHandOrTrashCard(
+                                    targetPermanent: card.PermanentOfThisCard(),
+                                    cardCondition: CanSelectCardCondition,
+                                    payCost: false,
+                                    reduceCostTuple: null,
+                                    fixedCostTuple: null,
+                                    ignoreDigivolutionRequirementFixedCost: -1,
+                                    isHand: true,
+                                    activateClass: activateClass,
+                                    successProcess: null));
                     }
                 }
             }
@@ -202,7 +210,7 @@ namespace DCGO.CardEffects.EX9
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Delete your 1 other token or [Puppet] Digimon to prevent this Digimon from leaving Battle Area", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
                 activateClass.SetIsInheritedEffect(true);
                 activateClass.SetHashString("Substitute_EX9_032");
                 cardEffects.Add(activateClass);

Assets/CardEffect/EX9/Yellow/EX9_067.cs

@@ -38,7 +38,7 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    return cardSource.EqualsTraits("Pupper") || cardSource.EqualsTraits("LIBERATOR");
+                    return cardSource.EqualsTraits("Puppet") || cardSource.EqualsTraits("LIBERATOR");
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)

Assets/Scripts/CardController.cs

@@ -4857,15 +4857,12 @@ public class AceOverflowClass
     public IEnumerator Overflow()
     {
         _cardSources = _cardSources
-        .Filter(cardSource => cardSource.IsACE && CardEffectCommons.IsExistOnBattleArea(cardSource) || CardEffectCommons.IsExistOnBreedingAreaDigimon(cardSource))
+        .Filter(cardSource => cardSource.IsACE && !cardSource.IsFlipped && CardEffectCommons.IsExistOnBattleArea(cardSource) || CardEffectCommons.IsExistOnBreedingAreaDigimon(cardSource))
         .OrderBy(cardSource => cardSource.Owner == GManager.instance.turnStateMachine.gameContext.TurnPlayer ? -1 : 1)
         .ToList();
 
         foreach (CardSource cardSource in _cardSources)
         {
-            if (cardSource.IsFlipped)
-                continue;
-
             yield return ContinuousController.instance.StartCoroutine(cardSource.Owner.AddMemory(-cardSource.OverflowMemory, null));
 
             string log = $"\nOverflow -{cardSource.OverflowMemory}:\n{cardSource.BaseENGCardNameFromEntity}({cardSource.CardID})\n";

Assets/Scripts/CardEffectCommons/TrashDigivolutionCards.cs

@@ -134,7 +134,7 @@ public partial class CardEffectCommons
                                     mode: SelectCardEffect.Mode.Custom,
                                     root: SelectCardEffect.Root.Custom,
                                     customRootCardList: selectedPermanent.DigivolutionCards,
-                                    canLookReverseCard: true,
+                                    canLookReverseCard: false,
                                     selectPlayer: card.Owner,
                                     cardEffect: activateClass);
 

Assets/Scripts/CardObjectController.cs

@@ -369,7 +369,9 @@ public class CardObjectController : MonoBehaviour
     #region Remove cards from all areas
     public static IEnumerator RemoveFromAllArea(CardSource cardSource)
     {
-        cardSource.SetFace("CardObjectController.RemoveFromAllArea");
+        //TODO: This might not even be necessary at all? - MB
+        if(!cardSource.IsFlipped || cardSource.IsBeingRevealed)
+            cardSource.SetFace("CardObjectController.RemoveFromAllArea");
 
         if (cardSource.Owner.HandCards.Contains(cardSource))
         {

Assets/Scripts/CardSource.cs

@@ -638,7 +638,7 @@ public class CardSource : MonoBehaviour
     {
         get
         {
-            if (IsFlipped && !IsBeingRevealed)
+            if (IsFlipped && !IsBeingRevealed && !GManager.instance.turnStateMachine.gameContext.IsSecurityLooking)
                 return -1;
             else
                 return _cEntity_Base.PlayCost;
@@ -1309,7 +1309,7 @@ public class CardSource : MonoBehaviour
     {
         get
         {
-            if (IsFlipped && !IsBeingRevealed)
+            if (IsFlipped && !IsBeingRevealed && !GManager.instance.turnStateMachine.gameContext.IsSecurityLooking)
                 return new List<string>();
 
             List<string> cardNames = BaseCardNames.Clone();
@@ -2340,7 +2340,7 @@ public class CardSource : MonoBehaviour
     {
         get
         {
-            if (IsFlipped && !IsBeingRevealed)
+            if (IsFlipped && !IsBeingRevealed && !GManager.instance.turnStateMachine.gameContext.IsSecurityLooking)
                 return new List<string>();
 
             List<string> traits =
@@ -2665,7 +2665,7 @@ public class CardSource : MonoBehaviour
         {
             if(_cEntity_Base == null || _cEntity_Base.HasLevel)
             {
-                if (IsFlipped && !IsBeingRevealed)
+                if (IsFlipped && !IsBeingRevealed && !GManager.instance.turnStateMachine.gameContext.IsSecurityLooking)
                     return false;
 
                 return true;

Assets/Scripts/Permanent.cs

@@ -886,7 +886,10 @@ public class Permanent
             if (!this.IsToken && !addedDigivolutionCard.IsToken)
             {
                 this.cardSources.Insert(1, addedDigivolutionCard);
-                addedDigivolutionCard.SetFace("Permanent.AddDigivolutionCardsTop");
+
+                if(!addedDigivolutionCard.IsFlipped || addedDigivolutionCard.IsBeingRevealed)
+                    addedDigivolutionCard.SetFace("Permanent.AddDigivolutionCardsTop");
+
                 addedCards.Add(addedDigivolutionCard);
             }
         }

ProjectSettings/ProjectSettings.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2bbed0701ea930f2c6016cafa6c1f9d9bcaf5ad9a09f949800ec59f1d084688c
+oid sha256:fc244be9bebefda1084cdeaa4b4b0e9b4fe5b45aa461e96a7c6e82f363fdfcbe
 size 20168