1.9.0.4 updates/bug fixes

Assets/CardBaseEntity/CardEntity_JSONLoader.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:35d059279fc028cc5e4e4d7e89b723a0ee141f646c08fae62af2bb0b736e431b
+oid sha256:d1e8edf002a5e5e4317312cb82789d2fecf09e5f009985bfae0b255fd8bed218
 size 477

Assets/CardBaseEntity/EX9/Green/Digimon/EX9_037.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e9b50788e203ec71e099c1a721e2adb0f74afa34e5952c7b10565a439e6c791c
-size 1422
+oid sha256:904f3dc11c7999828c9a905fb9036d5e293753faf440a4464097b113bb2eac29
+size 1470

Assets/CardBaseEntity/EX9/Green/Digimon/EX9_037_P1.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:dfda996fb3ec843d11ebf6e7913a5711f73aaa5f7a0a92fa3c9bc3e267fa0804
-size 1428
+oid sha256:cd315fb38a7686f07118fd2fade805bc7ccf936a0162984f938965e762a62d04
+size 1476

Assets/CardBaseEntity/EX9/White/Digimon/EX9_074.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0e9b1888708978fd09a233d892bff93dfb2c956dcb994c0b4c136f333d5d32b5
-size 1897
+oid sha256:a99b2b2a9eeac80166e30f24d23bc46ffcf48bd399163eae758c447c519c7a75
+size 1945

Assets/CardBaseEntity/EX9/White/Digimon/EX9_074_P1.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:661fc7f09ad07717d79cacf0bbf6017fc8597419c1661697d7b1375de369c94d
-size 1903
+oid sha256:200d0bdc204ff9619c3737b14ab29636216390a888bbebfff2ab30634c0b0c71
+size 1951

Assets/CardBaseEntity/EX9/Yellow/Digimon/EX9_026.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d2a99c65fa4b56636c9a21e0dfb6c756a24e8d966d51c783ae0af1782e0de8c9
+oid sha256:b9a261c137b47a27812e0b800b47124412aa6e31b238464a58c91f17b23bfaec
 size 1484

Assets/CardBaseEntity/EX9/Yellow/Digimon/EX9_026_P1.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a2e2cd5f3d30ac9f5c31b569449969a6b53646a7d341090c3c5cfab625e95b97
+oid sha256:cba4d2d7f56721c0afee627b00343eb1699b4fb7e565f670df18b192ea620f5a
 size 1490

Assets/CardEffect/EX9/Black/EX9_047.cs

@@ -39,63 +39,6 @@ namespace DCGO.CardEffects.EX9
 
             #endregion
 
-            #region On Deletion
-            if (timing == EffectTiming.OnDestroyedAnyone)
-            {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Return a card from trash", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDescription());
-                cardEffects.Add(activateClass);
-
-                string EffectDescription() => "[On Deletion] You may return 1 Digimon card with [Negamon] in its text from your trash to the hand.";
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.CanTriggerOnDeletion(hashtable, card);
-                }
-
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
-                }
-
-                bool CanSelectCardCondition(CardSource cardSource)
-                {
-                    return cardSource.HasText("Negamon");
-                }
-
-                IEnumerator ActivateCoroutine(Hashtable hashtable)
-                {
-                    if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
-                    {
-                        int maxCount = Math.Min(1, card.Owner.TrashCards.Count(CanSelectCardCondition));
-
-                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
-
-                        selectCardEffect.SetUp(
-                            canTargetCondition: CanSelectCardCondition,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            canNoSelect: () => true,
-                            selectCardCoroutine: null,
-                            afterSelectCardCoroutine: null,
-                            message: "Select 1 card to add to your hand.",
-                            maxCount: maxCount,
-                            canEndNotMax: false,
-                            isShowOpponent: true,
-                            mode: SelectCardEffect.Mode.AddHand,
-                            root: SelectCardEffect.Root.Trash,
-                            customRootCardList: null,
-                            canLookReverseCard: true,
-                            selectPlayer: card.Owner,
-                            cardEffect: activateClass);
-
-                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
-                    }
-                }
-            }
-            #endregion
-
             #region Assembly
             if (timing == EffectTiming.None)
             {
@@ -144,17 +87,20 @@ namespace DCGO.CardEffects.EX9
 
                         bool CanTargetCondition_ByPreSelecetedList(List<CardSource> cardSources, CardSource cardSource)
                         {
-                            List<string> cardIDs = new List<string>();
+                            List<string> cardNames = new List<string>();
 
                             foreach (CardSource cardSource1 in cardSources)
                             {
-                                if (!cardIDs.Contains(cardSource1.CardID))
+                                foreach (string cardName in cardSource1.CardNames)
                                 {
-                                    cardIDs.Add(cardSource1.CardID);
+                                    if (!cardNames.Contains(cardName))
+                                    {
+                                        cardNames.Add(cardName);
+                                    }
                                 }
                             }
 
-                            if (cardIDs.Contains(cardSource.CardID))
+                            if (cardSource.CardNames.Count((cardName) => cardNames.Contains(cardName)) >= 1)
                             {
                                 return false;
                             }
@@ -172,6 +118,63 @@ namespace DCGO.CardEffects.EX9
             }
             #endregion
 
+            #region On Deletion
+            if (timing == EffectTiming.OnDestroyedAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Return a card from trash", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDescription());
+                cardEffects.Add(activateClass);
+
+                string EffectDescription() => "[On Deletion] You may return 1 Digimon card with [Negamon] in its text from your trash to the hand.";
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnDeletion(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanActivateOnDeletion(card);
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    return cardSource.HasText("Negamon");
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
+                    {
+                        int maxCount = Math.Min(1, card.Owner.TrashCards.Count(CanSelectCardCondition));
+
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                        selectCardEffect.SetUp(
+                            canTargetCondition: CanSelectCardCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            canNoSelect: () => true,
+                            selectCardCoroutine: null,
+                            afterSelectCardCoroutine: null,
+                            message: "Select 1 card to add to your hand.",
+                            maxCount: maxCount,
+                            canEndNotMax: false,
+                            isShowOpponent: true,
+                            mode: SelectCardEffect.Mode.AddHand,
+                            root: SelectCardEffect.Root.Trash,
+                            customRootCardList: null,
+                            canLookReverseCard: true,
+                            selectPlayer: card.Owner,
+                            cardEffect: activateClass);
+
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+                    }
+                }
+            }
+            #endregion
+
             #region Inherit
             if (timing == EffectTiming.None)
             {

Assets/CardEffect/EX9/Black/EX9_051.cs

@@ -128,8 +128,7 @@ namespace DCGO.CardEffects.EX9
                     {
                         Permanent permanent = card.PermanentOfThisCard();
                         yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddExecutingCard(selectedCard));
-                        selectedCard.SetReverse();
-                        yield return ContinuousController.instance.StartCoroutine(permanent.AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass));
+                        yield return ContinuousController.instance.StartCoroutine(permanent.AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
 
                         if (CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectPermanentCondition))
                         {

Assets/CardEffect/EX9/Black/EX9_052.cs

@@ -105,12 +105,9 @@ namespace DCGO.CardEffects.EX9
                     if (selectedCards.Count >= 3)
                     {
                         foreach (CardSource card in selectedCards)
-                        {
                             yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddExecutingCard(card));
-                            card.SetReverse();
-                        }
                         
-                        yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(selectedCards, activateClass));
+                        yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(selectedCards, activateClass, isFacedown:true));
 
                         added = true;
                     }

Assets/CardEffect/EX9/Black/EX9_054.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using UnityEngine;
 
-namespace DCGO.CardEffects
+namespace DCGO.CardEffects.EX9
 {
     public class EX9_054 : CEntity_Effect
     {

Assets/CardEffect/EX9/Black/EX9_055.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 
 //Abbadomon
-namespace DCGO.CardEffects
+namespace DCGO.CardEffects.EX9
 {
     public class EX9_055 : CEntity_Effect
     {

Assets/CardEffect/EX9/Black/EX9_073.cs

@@ -32,19 +32,92 @@ namespace DCGO.CardEffects.EX9
             #endregion
 
             #region Assembly
-
             if (timing == EffectTiming.None)
             {
-                // TODO Implement Assembly
-            }
+                AddAssemblyConditionClass addAssemblyConditionClass = new AddAssemblyConditionClass();
+                addAssemblyConditionClass.SetUpICardEffect($"Assembly", CanUseCondition, card);
+                addAssemblyConditionClass.SetUpAddAssemblyConditionClass(getAssemblyCondition: GetAssembly);
+                addAssemblyConditionClass.SetNotShowUI(true);
+                cardEffects.Add(addAssemblyConditionClass);
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return true;
+                }
+
+                AssemblyCondition GetAssembly(CardSource cardSource)
+                {
+                    if (cardSource == card)
+                    {
+                        AssemblyConditionElement element = new AssemblyConditionElement(CanSelectCardCondition, "4 level 5 [Cyborg] trait Digimon cards w/different names");
+
+                        bool CanSelectCardCondition(CardSource cardSource)
+                        {
+                            if (cardSource != null)
+                            {
+                                if (cardSource.Owner == card.Owner)
+                                {
+                                    if (cardSource.IsDigimon)
+                                    {
+                                        if (cardSource.IsLevel5)
+                                        {
+                                            if (cardSource.EqualsTraits("Cyborg"))
+                                            {
+                                                return true;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
 
+                            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;
+                        }
+
+                        List<AssemblyConditionElement> elements = new List<AssemblyConditionElement>();
+
+                        for (int i = 0; i < 4; i++)
+                        {
+                            elements.Add(element);
+                        }
+
+                        AssemblyCondition assemblyCondition = new AssemblyCondition(elements, CanTargetCondition_ByPreSelecetedList, 6);
+
+                        return assemblyCondition;
+                    }
+
+                    return null;
+                }
+            }
             #endregion
 
             #region On Play/ When Digivolving/ When Attacking Shared
 
             bool CanSelectCardConditionShared(CardSource cardSource)
             {
-                return cardSource.HasLevel && cardSource.IsLevel5 &&
+                return cardSource.IsLevel5 &&
                        (cardSource.EqualsTraits("Cyborg") || cardSource.EqualsTraits("Ver.5"));
             }
 
@@ -230,9 +303,7 @@ namespace DCGO.CardEffects.EX9
                                 }
                             }
 
-                            if (selectedEffect != null &&
-                                selectedEffect.EffectSourceCard &&
-                                selectedEffect.EffectSourceCard.PermanentOfThisCard() != null)
+                            if (selectedEffect != null)
                             {
                                 Hashtable effectHashtable = CardEffectCommons.OnPlayCheckHashtableOfCard(card);
 
@@ -424,9 +495,7 @@ namespace DCGO.CardEffects.EX9
                                 }
                             }
 
-                            if (selectedEffect != null &&
-                                selectedEffect.EffectSourceCard &&
-                                selectedEffect.EffectSourceCard.PermanentOfThisCard() != null)
+                            if (selectedEffect != null)
                             {
                                 Hashtable effectHashtable = CardEffectCommons.OnPlayCheckHashtableOfCard(card);
 
@@ -618,9 +687,7 @@ namespace DCGO.CardEffects.EX9
                                 }
                             }
 
-                            if (selectedEffect != null &&
-                                selectedEffect.EffectSourceCard &&
-                                selectedEffect.EffectSourceCard.PermanentOfThisCard() != null)
+                            if (selectedEffect != null)
                             {
                                 Hashtable effectHashtable = CardEffectCommons.OnPlayCheckHashtableOfCard(card);
 
@@ -658,34 +725,120 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanSelectTrashSourceCardCondition(CardSource cardSource)
                 {
-                    return (cardSource.IsFlipped || cardSource.EqualsTraits("Cyborg")) &&
+                    return cardSource.IsFlipped &&
+                           !cardSource.CanNotTrashFromDigivolutionCards(activateClass);
+                }
+
+                bool CanSelectCyborgSourceCondition(CardSource cardSource)
+                {
+                    return cardSource.EqualsTraits("Cyborg") &&
                            !cardSource.CanNotTrashFromDigivolutionCards(activateClass);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
                     return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
-                           card.PermanentOfThisCard().DigivolutionCards.Count(CanSelectTrashSourceCardCondition) >= 2;
+                           (card.PermanentOfThisCard().DigivolutionCards.Count(CanSelectTrashSourceCardCondition) >= 2 ||
+                           card.PermanentOfThisCard().DigivolutionCards.Count(CanSelectCyborgSourceCondition) > 0);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
                     Permanent thisPermanent = card.PermanentOfThisCard();
 
-                    List<CardSource> selectedCards = thisPermanent.DigivolutionCards.Filter(CanSelectTrashSourceCardCondition)
-                        .GetRange(thisPermanent.DigivolutionCards.Count - 2, 2);
+                    bool hasFaceDownSources = thisPermanent.DigivolutionCards.Count(CanSelectTrashSourceCardCondition) >= 2;
+                    bool hasCyborgSources = thisPermanent.DigivolutionCards.Count(CanSelectCyborgSourceCondition) > 0;
 
-                    if (selectedCards.Count == 2)
+                    if(hasCyborgSources || hasFaceDownSources)
                     {
-                        yield return ContinuousController.instance.StartCoroutine(
-                            new ITrashDigivolutionCards(thisPermanent, selectedCards, activateClass).TrashDigivolutionCards());
-
-                        thisPermanent.willBeRemoveField = false;
-                        thisPermanent.HideDeleteEffect();
-                        thisPermanent.HideHandBounceEffect();
-                        thisPermanent.HideDeckBounceEffect();
-                        thisPermanent.HideWillRemoveFieldEffect();
+                        if(hasCyborgSources && hasCyborgSources)
+                        {
+                            List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                        {
+                            new SelectionElement<bool>(message: $"Bottom 2 Face down", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"Cyborg", value : false, spriteIndex: 1),
+                        };
+
+                            string selectPlayerMessage = "What will you trash?";
+                            string notSelectPlayerMessage = "The opponent is choosing what cards they will trash.";
+
+                            GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+                        }
+                        else
+                        {
+                            GManager.instance.userSelectionManager.SetBool(hasFaceDownSources);
+                        }
+
+                        bool willTrashFacedown = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+                        if (willTrashFacedown)
+                        {
+                            int startingSources = thisPermanent.DigivolutionCards.Count;
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.TrashDigivolutionCardsFromTopOrBottom(targetPermanent: thisPermanent, trashCount: 2, isFromTop: false, activateClass: activateClass, CanSelectTrashSourceCardCondition));
+
+                            if (thisPermanent.DigivolutionCards.Count == startingSources - 2)
+                            {
+                                thisPermanent.willBeRemoveField = false;
+                                thisPermanent.HideDeleteEffect();
+                                thisPermanent.HideHandBounceEffect();
+                                thisPermanent.HideDeckBounceEffect();
+                                thisPermanent.HideWillRemoveFieldEffect();
+                            }
+                        }
+                        else
+                        {
+                            CardSource selectedCard = null;
+                            SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+                            selectCardEffect.SetUp(
+                                    canTargetCondition: CanSelectCyborgSourceCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    canNoSelect: () => true,
+                                    selectCardCoroutine: SelectCardCoroutine,
+                                    afterSelectCardCoroutine: null,
+                                    message: "Select 1 card to trash.",
+                                    maxCount: 1,
+                                    canEndNotMax: true,
+                                    isShowOpponent: true,
+                                    mode: SelectCardEffect.Mode.Custom,
+                                    root: SelectCardEffect.Root.Custom,
+                                    customRootCardList: thisPermanent.DigivolutionCards,
+                                    canLookReverseCard: true,
+                                    selectPlayer: card.Owner,
+                                    cardEffect: activateClass);
+
+                            selectCardEffect.SetUpCustomMessage("Select 1 card to trash.", "The opponent is selecting 1 card to trash.");
+
+                            yield return StartCoroutine(selectCardEffect.Activate());
+
+
+                            IEnumerator SelectCardCoroutine (CardSource source)
+                            {
+                                selectedCard = source;
+                                yield return null;
+                            }
+
+                            if (selectedCard != null)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(new ITrashDigivolutionCards(card.PermanentOfThisCard(), new List<CardSource> { selectedCard }, activateClass).TrashDigivolutionCards());
+
+                                thisPermanent.willBeRemoveField = false;
+                                thisPermanent.HideDeleteEffect();
+                                thisPermanent.HideHandBounceEffect();
+                                thisPermanent.HideDeckBounceEffect();
+                                thisPermanent.HideWillRemoveFieldEffect();
+                            }
+                        }
                     }
+                    
+
+                    
+
+                    
+
+                    
                 }
             }
 

Assets/CardEffect/EX9/Blue/EX9_018.cs

@@ -183,7 +183,7 @@ namespace DCGO.CardEffects.EX9
 
                             if (selectedCards.Count >= 1)
                             {
-                                yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(selectedCards, activateClass));
+                                yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(selectedCards, activateClass, isFacedown: true));
 
                                 added = true;
                             }
@@ -352,7 +352,7 @@ namespace DCGO.CardEffects.EX9
 
                             if (selectedCards.Count >= 1)
                             {
-                                yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(selectedCards, activateClass));
+                                yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(selectedCards, activateClass, isFacedown: true));
 
                                 added = true;
                             }
@@ -426,48 +426,32 @@ namespace DCGO.CardEffects.EX9
 
                 bool PermanentCondition(Permanent _permanent)
                 {
-                    if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, (permanent) => permanent.IsDigimon && permanent.IsSuspended))
-                    {
-                        return true;
-                    }
-                    return false;
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(_permanent, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
-                    {
-                        if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, (permanent) => permanent.IsDigimon && permanent.IsSuspended))
-                        {
-                            return true;
-                        }
-                    }
-                    return false;
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.HasMatchConditionPermanent(PermanentCondition))
-                    {
-                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(PermanentCondition));
-
-                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                        selectPermanentEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: PermanentCondition,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: maxCount,
-                            canNoSelect: false,
-                            canEndNotMax: false,
-                            selectPermanentCoroutine: null,
-                            afterSelectPermanentCoroutine: null,
-                            mode: SelectPermanentEffect.Mode.UnTap,
-                            cardEffect: activateClass);
-
-                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                    }
+                    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: null,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.UnTap,
+                        cardEffect: activateClass);
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
                 }
             }
             #endregion

Assets/CardEffect/EX9/Blue/EX9_071.cs

@@ -62,7 +62,7 @@ namespace DCGO.CardEffects.EX9
             if (timing == EffectTiming.OnDeclaration)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Play 1 card from trash", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Unsuspend", CanUseCondition, card);
                 activateClass.SetUpActivateClass(null, ActivateCoroutine, 1, true, EffectDiscription());
                 cardEffects.Add(activateClass);
 
@@ -120,7 +120,7 @@ namespace DCGO.CardEffects.EX9
                             mode: SelectPermanentEffect.Mode.Custom,
                             cardEffect: activateClass);
 
-                        selectPermanentEffect.SetUpCustomMessage("Select 1 option to trash.", "The opponent is selecting 1 option to trash.");
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 digimon to trash sources.", "The opponent is selecting 1 digimon to trash sources.");
 
                         yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
@@ -130,52 +130,14 @@ namespace DCGO.CardEffects.EX9
                             yield return null;
                         }
 
-                        List<CardSource> selectedCards = new List<CardSource>();
+                        int startingSources = selectedPermanent.DigivolutionCards.Count;
 
-                        if (selectedPermanent.DigivolutionCards.Count(FaceDownDigivolutionSource) > 1)
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.TrashDigivolutionCardsFromTopOrBottom(targetPermanent: selectedPermanent, trashCount: 2, isFromTop: false, activateClass: activateClass, FaceDownDigivolutionSource));
+                        
+                        if(selectedPermanent.DigivolutionCards.Count == startingSources - 2)
                         {
-
-                            SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
-
-                            selectCardEffect.SetUp(
-                                selectPlayer: card.Owner,
-                                canTargetCondition: FaceDownDigivolutionSource,
-                                canTargetCondition_ByPreSelecetedList: null,
-                                canEndSelectCondition: null,
-                                maxCount: 1,
-                                message: "Select 1 card to trash.",
-                                canNoSelect: () => true,
-                                canEndNotMax: false,
-                                isShowOpponent: true,
-                                selectCardCoroutine: SelectCardCoroutine,
-                                afterSelectCardCoroutine: null,
-                                mode: SelectCardEffect.Mode.Custom,
-                                root: SelectCardEffect.Root.Custom,
-                                customRootCardList: selectedPermanent.DigivolutionCards.Filter(FaceDownDigivolutionSource).ToArray()[^2..].ToList(),
-                                canLookReverseCard: false,
-                                cardEffect: activateClass);
-
-                            selectCardEffect.SetUpCustomMessage("Select 1 card to trash.", "The opponent is selecting 1 card to trash.");
-                            selectCardEffect.SetUpCustomMessage_ShowCard("Played Trash");
-
-                            yield return StartCoroutine(selectCardEffect.Activate());
-
-                            IEnumerator SelectCardCoroutine(CardSource cardSource)
-                            {
-                                selectedCards.Add(cardSource);
-
-                                yield return null;
-                            }
-                        }
-                        else
-                        {
-                            selectedCards.Add(selectedPermanent.DigivolutionCards.Where(FaceDownDigivolutionSource).First());
+                            yield return ContinuousController.instance.StartCoroutine(new IUnsuspendPermanents(new List<Permanent> { selectedPermanent }, activateClass).Unsuspend());
                         }
-
-                        yield return ContinuousController.instance.StartCoroutine(new ITrashDigivolutionCards(
-                            selectedPermanent,
-                            selectedCards,
-                            activateClass).TrashDigivolutionCards());
                     }
                 }
             }

Assets/CardEffect/EX9/Green/EX9_041.cs

@@ -41,7 +41,7 @@ namespace DCGO.CardEffects.EX9
 
             #region Ver.5 Digivolution Cost Reduction
 
-            if (timing == EffectTiming.None)
+            if (timing == EffectTiming.BeforePayCost)
             {
                 Permanent selectedPermanent = null;
                 bool Condition()
@@ -66,12 +66,12 @@ namespace DCGO.CardEffects.EX9
 
                 int ReduceCost()
                 {
-                    return selectedPermanent.DigivolutionCards.Filter(x => x.IsFlipped).Count;
+                    return card.PermanentOfThisCard().DigivolutionCards.Filter(x => x.IsFlipped).Count;
                 }
 
                 cardEffects.Add(CardEffectFactory.ChangeDigivolutionCostStaticEffect<Func<int>>(
                     changeValue: () => -ReduceCost(),
-                    permanentCondition: (permanent) => { selectedPermanent = permanent; return PermanentCondition(permanent); },
+                    permanentCondition: PermanentCondition,
                     cardCondition: CardSourceCondition,
                     rootCondition: RootCondition,
                     isInheritedEffect: false,

Assets/CardEffect/EX9/Green/EX9_043.cs

@@ -96,7 +96,7 @@ namespace DCGO.CardEffects.EX9
 
                             int ChangeCost(CardSource cardSource, int cost, SelectCardEffect.Root root, List<Permanent> targetPermanents)
                             {
-                                if (CardSourceCondition(cardSource) && RootCondition(root)) cost -= 4;
+                                if (CardSourceCondition(cardSource) && RootCondition(root)) cost -= 2;
                                 return cost;
                             }
 
@@ -208,9 +208,10 @@ namespace DCGO.CardEffects.EX9
                     return cardSource.IsDigimon && CardEffectCommons.IsExistOnTrash(cardSource);
                 }
 
+                CardSource selectedCard = null;
+
                 if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CardCondition))
                 {
-                    CardSource selectedCard = null;
                     SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
                     selectCardEffect.SetUp(
                         canTargetCondition: CardCondition,
@@ -239,79 +240,78 @@ namespace DCGO.CardEffects.EX9
                         selectedCard = cardSource;
                         yield return null;
                     }
+                }
+
+                if (selectedCard != null)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddExecutingCard(selectedCard));
+                    yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
 
-                    if (selectedCard != null)
+                    bool CanSelectPermanentCondition(Permanent permanent)
                     {
-                        yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddExecutingCard(selectedCard));
-                        yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
+                        return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                    }
 
-                        bool CanSelectPermanentCondition(Permanent permanent)
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    {
+                        Permanent selectedPermanent = null;
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: 1,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to de-digivolve", "The opponent is selecting 1 Digimon to de-digivolve");
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
                         {
-                            return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                            selectedPermanent = permanent;
+                            yield return null;
                         }
 
-                        if (CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectPermanentCondition))
+                        if (selectedPermanent != null)
                         {
-                            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 de-digivolve", "The opponent is selecting 1 Digimon to de-digivolve");
-                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                            IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                            {
-                                Permanent selectedPermanent = permanent;
-                                yield return null;
-                            }
-
-                            if (selectedPermanent != null)
-                            {
-                                var degenCount = card.PermanentOfThisCard().DigivolutionCards.Filter(x => x.IsFlipped).Count;
-                                yield return ContinuousController.instance.StartCoroutine(new IDegeneration(selectedPermanent, degenCount, activateClass).Degeneration());
-                            }
+                            var degenCount = card.PermanentOfThisCard().DigivolutionCards.Filter(x => x.IsFlipped).Count;
+                            yield return ContinuousController.instance.StartCoroutine(new IDegeneration(selectedPermanent, degenCount, activateClass).Degeneration());
                         }
+                    }
+                }
 
-                        bool CanSelectPermanentCondition1(Permanent permanent)
-                        {
-                            return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) && permanent.DP <= 3000;
-                        }
+                bool CanSelectPermanentDeleteCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) &&
+                        permanent.DP <= 3000;
+                }
 
-                        if (CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectPermanentCondition1))
-                        {
-                            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition1));
-                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                            selectPermanentEffect.SetUp(
-                                selectPlayer: card.Owner,
-                                canTargetCondition: CanSelectPermanentCondition1,
-                                canTargetCondition_ByPreSelecetedList: null,
-                                canEndSelectCondition: null,
-                                maxCount: maxCount,
-                                canNoSelect: false,
-                                canEndNotMax: false,
-                                selectPermanentCoroutine: null,
-                                afterSelectPermanentCoroutine: null,
-                                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());
-                        }
-                    }
+                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentDeleteCondition))
+                {
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectPermanentDeleteCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: null,
+                        afterSelectPermanentCoroutine: null,
+                        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());
                 }
             }
 

Assets/CardEffect/EX9/Purple/EX9_059.cs

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

Assets/CardEffect/EX9/Purple/EX9_060.cs

@@ -47,7 +47,7 @@ namespace DCGO.CardEffects.EX9
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Place 1 hand card FD as bottom source, Draw 1", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
                 activateClass.SetHashString("EX9_060_Draw");
                 cardEffects.Add(activateClass);
 
@@ -58,52 +58,50 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
+                           CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
+                           card.Owner.HandCards.Count > 0;
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if (card.Owner.HandCards.Any())
+                    CardSource selectedCard = null;
+                    SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                    selectHandEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: null,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: true,
+                        canEndNotMax: false,
+                        isShowOpponent: true,
+                        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("Added Card");
+                    yield return StartCoroutine(selectHandEffect.Activate());
+
+                    IEnumerator SelectCardCoroutine(CardSource cardSource)
                     {
-                        CardSource selectedCard = null;
-                        int maxCount = Math.Min(1, card.Owner.HandCards.Count);
-                        SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
-
-                        selectHandEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: null,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: maxCount,
-                            canNoSelect: true,
-                            canEndNotMax: true,
-                            isShowOpponent: true,
-                            selectCardCoroutine: SelectCardCoroutine,
-                            afterSelectCardCoroutine: null,
-                            mode: SelectHandEffect.Mode.Custom,
-                            cardEffect: activateClass);
+                        selectedCard = cardSource;
+                        yield return null;
+                    }
 
-                        selectHandEffect.SetUpCustomMessage("Select 1 card to add as FD Source", "The opponent is selecting 1 card to add as FD source");
-                        selectHandEffect.SetUpCustomMessage_ShowCard("Added Card");
-                        yield return StartCoroutine(selectHandEffect.Activate());
-
-                        IEnumerator SelectCardCoroutine(CardSource cardSource)
-                        {
-                            selectedCard = cardSource;
-                            yield return null;
-                        }
-
-                        if (selectedCard != null)
-                        {
-                            yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddExecutingCard(selectedCard));
-                            yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
-                            yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
-                        }
+                    if (selectedCard != null)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddExecutingCard(selectedCard));
+                        yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
+                        yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
                     }
                 }
             }
@@ -116,7 +114,7 @@ namespace DCGO.CardEffects.EX9
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Place 1 hand card FD as bottom source, Draw 1", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
                 activateClass.SetHashString("EX9_060_Draw");
                 cardEffects.Add(activateClass);
 
@@ -132,47 +130,44 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
+                           card.Owner.HandCards.Count > 0;
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if (card.Owner.HandCards.Any())
+                    CardSource selectedCard = null;
+                    SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                    selectHandEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: null,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: true,
+                        canEndNotMax: false,
+                        isShowOpponent: true,
+                        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("Added Card");
+                    yield return StartCoroutine(selectHandEffect.Activate());
+
+                    IEnumerator SelectCardCoroutine(CardSource cardSource)
                     {
-                        CardSource selectedCard = null;
-                        int maxCount = Math.Min(1, card.Owner.HandCards.Count);
-                        SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
-
-                        selectHandEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: null,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: maxCount,
-                            canNoSelect: true,
-                            canEndNotMax: true,
-                            isShowOpponent: true,
-                            selectCardCoroutine: SelectCardCoroutine,
-                            afterSelectCardCoroutine: null,
-                            mode: SelectHandEffect.Mode.Custom,
-                            cardEffect: activateClass);
+                        selectedCard = cardSource;
+                        yield return null;
+                    }
 
-                        selectHandEffect.SetUpCustomMessage("Select 1 card to add as FD Source", "The opponent is selecting 1 card to add as FD source");
-                        selectHandEffect.SetUpCustomMessage_ShowCard("Added Card");
-                        yield return StartCoroutine(selectHandEffect.Activate());
-
-                        IEnumerator SelectCardCoroutine(CardSource cardSource)
-                        {
-                            selectedCard = cardSource;
-                            yield return null;
-                        }
-
-                        if (selectedCard != null)
-                        {
-                            yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddExecutingCard(selectedCard));
-                            yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
-                            yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
-                        }
+                    if (selectedCard != null)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddExecutingCard(selectedCard));
+                        yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
+                        yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
                     }
                 }
             }

Assets/CardEffect/EX9/Purple/EX9_061.cs

@@ -30,7 +30,7 @@ namespace DCGO.CardEffects.EX9
 
             if (timing == EffectTiming.OnDeclaration)
             {
-                // To be implemented
+                cardEffects.Add(CardEffectFactory.TrainingEffect(card: card));
             }
 
             #endregion
@@ -76,46 +76,29 @@ namespace DCGO.CardEffects.EX9
                 {
                     if (card.Owner.LibraryCards.Count >= 1)
                     {
-                        List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
-                    {
-                        new SelectionElement<bool>(message: $"Yes", value : true, spriteIndex: 0),
-                        new SelectionElement<bool>(message: $"No", value : false, spriteIndex: 1),
-                    };
-                        string selectPlayerMessage = "Place top card from deck as FD bottom source card?";
-                        string notSelectPlayerMessage = "The opponent is choosing to use effect";
-                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
-
-                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
-                        bool usingEffect = GManager.instance.userSelectionManager.SelectedBoolValue;
+                        CardSource 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));
 
-                        if (usingEffect)
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                         {
-                            CardSource 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));
-
-                            if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-                            {
-                                int maxCount1 = 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: maxCount1,
-                                    canNoSelect: false,
-                                    canEndNotMax: false,
-                                    selectPermanentCoroutine: null,
-                                    afterSelectPermanentCoroutine: null,
-                                    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());
-                            }
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectPermanentCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: 1,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: null,
+                                afterSelectPermanentCoroutine: null,
+                                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());
                         }
                     }
                 }

Assets/CardEffect/EX9/Purple/EX9_062.cs

@@ -61,7 +61,7 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    return cardSource.IsDigimon && cardSource.EqualsTraits("DM") && cardSource.Level <= 4;
+                    return cardSource.IsDigimon && cardSource.EqualsTraits("DM");
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
@@ -77,7 +77,6 @@ namespace DCGO.CardEffects.EX9
 
                     if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                     {
-                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOwnersCardCountInTrash(card, CanSelectCardCondition));
                         SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
 
                         selectCardEffect.SetUp(
@@ -88,7 +87,7 @@ namespace DCGO.CardEffects.EX9
                                     selectCardCoroutine: null,
                                     afterSelectCardCoroutine: null,
                                     message: "Select 1 [DM] digimon to add to hand",
-                                    maxCount: maxCount,
+                                    maxCount: 1,
                                     canEndNotMax: true,
                                     isShowOpponent: true,
                                     mode: SelectCardEffect.Mode.AddHand,
@@ -132,7 +131,7 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    return cardSource.IsDigimon && cardSource.EqualsTraits("DM") && cardSource.Level <= 4;
+                    return cardSource.IsDigimon && cardSource.EqualsTraits("DM");
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
@@ -148,7 +147,6 @@ namespace DCGO.CardEffects.EX9
 
                     if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                     {
-                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOwnersCardCountInTrash(card, CanSelectCardCondition));
                         SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
 
                         selectCardEffect.SetUp(
@@ -159,7 +157,7 @@ namespace DCGO.CardEffects.EX9
                                     selectCardCoroutine: null,
                                     afterSelectCardCoroutine: null,
                                     message: "Select 1 [DM] digimon to add to hand",
-                                    maxCount: maxCount,
+                                    maxCount: 1,
                                     canEndNotMax: true,
                                     isShowOpponent: true,
                                     mode: SelectCardEffect.Mode.AddHand,
@@ -283,7 +281,7 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    if (cardSource.Level <= 4 && cardSource.EqualsTraits("DM"))
+                    if (cardSource.IsDigimon && cardSource.Level <= 4 && cardSource.EqualsTraits("DM"))
                     {
                         if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass))
                         {
@@ -299,7 +297,6 @@ namespace DCGO.CardEffects.EX9
                     if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                     {
                         CardSource selectedCard = null;
-                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOwnersCardCountInTrash(card, CanSelectCardCondition));
                         SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
 
                         selectCardEffect.SetUp(
@@ -310,7 +307,7 @@ namespace DCGO.CardEffects.EX9
                                     selectCardCoroutine: SelectCardCoroutine,
                                     afterSelectCardCoroutine: null,
                                     message: "Select 1 [DM] digimon to play",
-                                    maxCount: maxCount,
+                                    maxCount: 1,
                                     canEndNotMax: true,
                                     isShowOpponent: true,
                                     mode: SelectCardEffect.Mode.Custom,

Assets/CardEffect/EX9/Purple/EX9_064.cs

@@ -19,7 +19,7 @@ namespace DCGO.CardEffects.EX9
                 static bool PermanentCondition(Permanent targetPermanent)
                 {
                     return targetPermanent.TopCard.IsLevel4 &&
-                        targetPermanent.TopCard.EqualsTraits("DM") || targetPermanent.TopCard.EqualsTraits("Cyborg");
+                        (targetPermanent.TopCard.EqualsTraits("DM") || targetPermanent.TopCard.EqualsTraits("Cyborg"));
                 }
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 3, ignoreDigivolutionRequirement: false, card: card, condition: null));
@@ -389,7 +389,8 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) && CardEffectCommons.IsMinLevel(permanent, card.Owner.Enemy);
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card) && 
+                           CardEffectCommons.IsMinLevel(permanent, card.Owner);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)

Assets/CardEffect/EX9/Red/EX9_010.cs

@@ -62,7 +62,8 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) && CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) && 
+                           CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
@@ -122,9 +123,8 @@ namespace DCGO.CardEffects.EX9
                     if (selectedCard)
                     {
                         yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddExecutingCard(selectedCard));
-                        selectedCard.SetReverse();
                         yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard()
-                            .AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass));
+                            .AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
 
                         if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                         {
@@ -229,9 +229,8 @@ namespace DCGO.CardEffects.EX9
                     if (selectedCard)
                     {
                         yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddExecutingCard(selectedCard));
-                        selectedCard.SetReverse();
                         yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard()
-                            .AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass));
+                            .AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown:true));
 
                         if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                         {

Assets/CardEffect/EX9/Red/EX9_066.cs

@@ -44,7 +44,7 @@ namespace DCGO.CardEffects.EX9
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    CardSource selectedSource = null;
+                    bool cardAdded = false;
 
                     if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, ReturnCard))
                     {
@@ -72,15 +72,15 @@ namespace DCGO.CardEffects.EX9
 
                         IEnumerator SelectCardCoroutine(CardSource source)
                         {
-                            selectedSource = source;
+                            if(source != null)
+                                cardAdded = true;
+
                             yield return null;
                         }
                     }
 
-                    if (selectedSource == null)
-                    {
+                    if (cardAdded)
                         yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
-                    }
                 }
             }
 

Assets/CardEffect/EX9/Red/EX9_070.cs

@@ -100,7 +100,7 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    if (CardEffectCommons.IsPermanentExistsOnBattleAreaDigimon(permanent))
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
                     {
                         if (permanent.TopCard.HasDMTraits)
                         {

Assets/CardEffect/EX9/White/EX9_072.cs

@@ -119,13 +119,13 @@ namespace DCGO.CardEffects.EX9
             if (timing == EffectTiming.SecuritySkill)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Play 1 5 cost or lower card", CanUseCondition, card);
                 activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
                 {
-                    return "";
+                    return "[Security] You may play 1 play cost 5 or lower card with the [DM] trait from your hand or trash without paying the cost.";
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -135,7 +135,7 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    return cardSource.IsDigimon && cardSource.HasLevel && cardSource.Level <= 5 &&
+                    return cardSource.HasPlayCost && cardSource.GetCostItself <= 5 &&
                            cardSource.EqualsTraits("DM") &&
                            CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass);
                 }

Assets/CardEffect/EX9/White/EX9_074.cs

@@ -13,12 +13,85 @@ namespace DCGO.CardEffects.EX9
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Assembly
-
-            if (timing == EffectTiming.BeforePayCost)
+            if (timing == EffectTiming.None)
             {
-                // To be implemented
-            }
+                AddAssemblyConditionClass addAssemblyConditionClass = new AddAssemblyConditionClass();
+                addAssemblyConditionClass.SetUpICardEffect($"Assembly", CanUseCondition, card);
+                addAssemblyConditionClass.SetUpAddAssemblyConditionClass(getAssemblyCondition: GetAssembly);
+                addAssemblyConditionClass.SetNotShowUI(true);
+                cardEffects.Add(addAssemblyConditionClass);
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return true;
+                }
+
+                AssemblyCondition GetAssembly(CardSource cardSource)
+                {
+                    if (cardSource == card)
+                    {
+                        AssemblyConditionElement element = new AssemblyConditionElement(CanSelectCardCondition, "7 level 4 [DM] trait Digimon cards w/different names");
+
+                        bool CanSelectCardCondition(CardSource cardSource)
+                        {
+                            if (cardSource != null)
+                            {
+                                if (cardSource.Owner == card.Owner)
+                                {
+                                    if (cardSource.IsDigimon)
+                                    {
+                                        if (cardSource.IsLevel4)
+                                        {
+                                            if (cardSource.HasDMTraits)
+                                            {
+                                                return true;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+
+                            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;
+                        }
+
+                        List<AssemblyConditionElement> elements = new List<AssemblyConditionElement>();
+
+                        for (int i = 0; i < 7; i++)
+                        {
+                            elements.Add(element);
+                        }
+
+                        AssemblyCondition assemblyCondition = new AssemblyCondition(elements, CanTargetCondition_ByPreSelecetedList, 7);
+
+                        return assemblyCondition;
+                    }
 
+                    return null;
+                }
+            }
             #endregion
 
             #region Sec +1
@@ -69,7 +142,7 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    return cardSource.IsDigimon && cardSource.HasLevel && cardSource.Level <= 4 && !cardSource.EqualsTraits("DM");
+                    return cardSource.IsDigimon && cardSource.HasLevel && cardSource.Level <= 4 && cardSource.HasDMTraits;
                 }
 
                 bool CanSelectPermanentCondition(Permanent permanent, List<CardColor> cardColors)
@@ -216,12 +289,7 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    return cardSource.IsDigimon && cardSource.HasLevel && cardSource.Level <= 4 && !cardSource.EqualsTraits("DM");
-                }
-
-                bool CanSelectPermanentCondition(Permanent permanent, List<CardColor> cardColors)
-                {
-                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) && permanent.TopCard.CardColors.Exists(color => cardColors.Contains(color));
+                    return cardSource.IsDigimon && cardSource.HasLevel && cardSource.Level <= 4 && cardSource.HasDMTraits;
                 }
 
                 bool CanTargetCondition_ByPreSelecetedList(List<Permanent> permanents, Permanent permanent, List<CardColor> cardColors)
@@ -283,53 +351,64 @@ namespace DCGO.CardEffects.EX9
                             yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddExecutingCard(selectedCard));
                             selectedCard.SetReverse();
                             yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsTop(new List<CardSource>() { selectedCard }, activateClass));
+                        }
+                    }
 
-                            List<CardColor> colours = card.PermanentOfThisCard().DigivolutionCards
+                    List<CardColor> colours = card.PermanentOfThisCard().DigivolutionCards
                                 .SelectMany(e => e.CardColors)
                                 .Distinct()
                                 .ToList();
 
-                            if (colours.Count <= 5 && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, permanent => CanSelectPermanentCondition(permanent, colours)))
-                            {
-                                int maxCount1 = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(permanent => CanSelectPermanentCondition(permanent, colours)));
-                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                                selectPermanentEffect.SetUp(
-                                    selectPlayer: card.Owner,
-                                    canTargetCondition: permanent => CanSelectPermanentCondition(permanent, colours),
-                                    canTargetCondition_ByPreSelecetedList: null,
-                                    canEndSelectCondition: null,
-                                    maxCount: maxCount1,
-                                    canNoSelect: false,
-                                    canEndNotMax: false,
-                                    selectPermanentCoroutine: null,
-                                    afterSelectPermanentCoroutine: null,
-                                    mode: SelectPermanentEffect.Mode.Destroy,
-                                    cardEffect: activateClass);
-
-                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                            }
-
-                            if (colours.Count >= 6 && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, permanent => CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card)))
-                            {
-                                int maxCount2 = 7;
-                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                    bool OpponentsDigimonWithMatchingColor(Permanent permanent)
+                    {
+                        return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) &&
+                               permanent.TopCard.CardColors.Exists(x => colours.Contains(x));
+                    }
 
-                                selectPermanentEffect.SetUp(
-                                    selectPlayer: card.Owner,
-                                    canTargetCondition: null,
-                                    canTargetCondition_ByPreSelecetedList: (permanents, permament) => CanTargetCondition_ByPreSelecetedList(permanents, permament, colours),
-                                    canEndSelectCondition: CanEndSelectCondition,
-                                    maxCount: maxCount2,
-                                    canNoSelect: false,
-                                    canEndNotMax: true,
-                                    selectPermanentCoroutine: null,
-                                    afterSelectPermanentCoroutine: null,
-                                    mode: SelectPermanentEffect.Mode.Destroy,
-                                    cardEffect: activateClass);
+                    if (colours.Count <= 5)
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(OpponentsDigimonWithMatchingColor))
+                        {
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: OpponentsDigimonWithMatchingColor,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: 1,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: null,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Destroy,
+                                cardEffect: activateClass);
+
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                        }                        
+                    }
 
-                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                            }
+                    if (colours.Count >= 6)
+                    {
+                        if(CardEffectCommons.HasMatchConditionOpponentsPermanent(card, permanent => CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card)))
+                        {
+                            int maxCount2 = 7;
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: null,
+                                canTargetCondition_ByPreSelecetedList: (permanents, permament) => CanTargetCondition_ByPreSelecetedList(permanents, permament, colours),
+                                canEndSelectCondition: CanEndSelectCondition,
+                                maxCount: maxCount2,
+                                canNoSelect: false,
+                                canEndNotMax: true,
+                                selectPermanentCoroutine: null,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Destroy,
+                                cardEffect: activateClass);
+
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
                         }
                     }
                 }

Assets/CardEffect/EX9/Yellow/EX9_026.cs

@@ -51,12 +51,13 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
+                           card.Owner.HandCards.Count > 0;
                 }
             }
 
@@ -78,12 +79,14 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
+                           CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card); ;
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
+                           card.Owner.HandCards.Count > 0;
                 }
             }
 
@@ -98,72 +101,69 @@ 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 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)
-                    {
-                        Permanent permanent = card.PermanentOfThisCard();
-                        yield return ContinuousController.instance.StartCoroutine(permanent.AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
+                if (selectedCard != null)
+                {
+                    Permanent permanent = card.PermanentOfThisCard();
+                    yield return ContinuousController.instance.StartCoroutine(permanent.AddDigivolutionCardsBottom(new List<CardSource>() { selectedCard }, activateClass, isFacedown: true));
 
-                        if (CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectPermanentCondition))
+                    if (CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectPermanentCondition))
+                    {
+                        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 a Digimon to give SEC -1 & -3k DP", "Opponent is selecting a Digimon to give SEC -1 & -3k DP");
+                        selectHandEffect.SetUpCustomMessage_ShowCard("Selected Digimon");
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
                         {
-                            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 a Digimon to give SEC -1 & -3k DP", "Opponent is selecting a Digimon to give SEC -1 & -3k DP");
-                            selectHandEffect.SetUpCustomMessage_ShowCard("Selected Digimon");
-                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                            IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                            {
-                                selectedPermanent = permanent;
-                                yield return null;
-                            }
+                            selectedPermanent = permanent;
+                            yield return null;
+                        }
 
-                            if (selectedPermanent != null)
-                            {
-                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonSAttack(targetPermanent: selectedPermanent, changeValue: -1, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
-                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: selectedPermanent, changeValue: -3000, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
-                            }
+                        if (selectedPermanent != null)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonSAttack(targetPermanent: selectedPermanent, changeValue: -1, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: selectedPermanent, changeValue: -3000, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
                         }
                     }
                 }

Assets/CardEffect/EX9/Yellow/EX9_027.cs

@@ -31,7 +31,7 @@ namespace DCGO.CardEffects.EX9
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("By trashing 1 card, give 1 digimon -4k", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -46,16 +46,13 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
+                           card.Owner.HandCards.Count > 0;
                 }
 
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
-                    {
-                        return true;
-                    }
-                    return false;
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
@@ -90,39 +87,41 @@ namespace DCGO.CardEffects.EX9
 
                     if (cardDiscarded)
                     {
-                        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 -4k DP", $"The opponent is selecting 1 card to give -4k DP");
-                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                         {
-                            selectedPermanent = permanent;
-                            yield return null;
-                        }
+                            Permanent selectedPermanent = null;
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectPermanentCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: 1,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: SelectPermanentCoroutine,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+
+                            selectPermanentEffect.SetUpCustomMessage($"Select 1 Digimon to give -4k DP", $"The opponent is selecting 1 card to give -4k DP");
+                            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.ChangeDigimonDP(
-                                targetPermanent: selectedPermanent,
-                                changeValue: -4000,
-                                effectDuration: EffectDuration.UntilEachTurnEnd,
-                                activateClass: activateClass));
+                            if (selectedPermanent != null)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
+                                    targetPermanent: selectedPermanent,
+                                    changeValue: -4000,
+                                    effectDuration: EffectDuration.UntilEachTurnEnd,
+                                    activateClass: activateClass));
+                            }
                         }
                     }
                 }
@@ -136,7 +135,7 @@ namespace DCGO.CardEffects.EX9
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("By trashing 1 card, give 1 digimon -4k", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -151,16 +150,13 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanActivateOnDeletion(card) && card.Owner.HandCards.Count >= 1;
+                    return CardEffectCommons.CanActivateOnDeletion(card) && 
+                           card.Owner.HandCards.Count > 0;
                 }
 
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
-                    {
-                        return true;
-                    }
-                    return false;
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
@@ -195,39 +191,41 @@ namespace DCGO.CardEffects.EX9
 
                     if (cardDiscarded)
                     {
-                        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 -4k DP", $"The opponent is selecting 1 card to give -4k DP");
-                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                         {
-                            selectedPermanent = permanent;
-                            yield return null;
-                        }
+                            Permanent selectedPermanent = null;
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectPermanentCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: 1,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: SelectPermanentCoroutine,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+
+                            selectPermanentEffect.SetUpCustomMessage($"Select 1 Digimon to give -4k DP", $"The opponent is selecting 1 card to give -4k DP");
+                            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.ChangeDigimonDP(
-                                targetPermanent: selectedPermanent,
-                                changeValue: -4000,
-                                effectDuration: EffectDuration.UntilEachTurnEnd,
-                                activateClass: activateClass));
+                            if (selectedPermanent != null)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
+                                    targetPermanent: selectedPermanent,
+                                    changeValue: -4000,
+                                    effectDuration: EffectDuration.UntilEachTurnEnd,
+                                    activateClass: activateClass));
+                            }
                         }
                     }
                 }

Assets/CardEffect/EX9/Yellow/EX9_033.cs

@@ -71,16 +71,43 @@ namespace DCGO.CardEffects.EX9
 
             if (timing == EffectTiming.None)
             {
-                bool CanUseCondition()
+                AddSkillClass addSkillClass = new AddSkillClass();
+                addSkillClass.SetUpICardEffect("Your Digimons gain Alliance", CanUseCondition, card);
+                addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
+                cardEffects.Add(addSkillClass);
+
+                bool CanUseCondition(Hashtable hashtable)
                 {
                     return CardEffectCommons.IsExistOnBattleArea(card);
                 }
 
-                cardEffects.Add(CardEffectFactory.AllianceStaticEffect(
-                    permanentCondition: SharedPermanentCondition,
-                    isInheritedEffect: false,
-                    card: card,
-                    condition: CanUseCondition));
+                bool CardSourceCondition(CardSource cardSource)
+                {
+                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(cardSource))
+                    {
+                        if (cardSource == cardSource.PermanentOfThisCard().TopCard)
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
+                {
+                    if (_timing == EffectTiming.OnAllyAttack)
+                    {
+                        bool Condition()
+                        {
+                            return CardSourceCondition(cardSource);
+                        }
+
+                        cardEffects.Add(CardEffectFactory.AllianceSelfEffect(false, cardSource, Condition));
+                    }
+
+                    return cardEffects;
+                }
             }
 
             #endregion

Assets/Scripts/CardEffectCommons.cs

@@ -437,7 +437,7 @@ public partial class CardEffectCommons
     #endregion
 
     #region Trash digivolution cards from top or bottom
-    public static IEnumerator TrashDigivolutionCardsFromTopOrBottom(Permanent targetPermanent, int trashCount, bool isFromTop, ICardEffect activateClass)
+    public static IEnumerator TrashDigivolutionCardsFromTopOrBottom(Permanent targetPermanent, int trashCount, bool isFromTop, ICardEffect activateClass, Func<CardSource, bool> cardCondition = null)
     {
         if (activateClass == null) yield break;
         if (targetPermanent == null) yield break;
@@ -455,7 +455,13 @@ public partial class CardEffectCommons
                 int index = isFromTop ? i : targetPermanent.DigivolutionCards.Count - 1 - i;
                 CardSource trashTargetCard = targetPermanent.DigivolutionCards[index];
 
-                trashTargetCards.Add(trashTargetCard);
+                bool trashCard = true;
+
+                if (cardCondition != null)
+                    trashCard = cardCondition(trashTargetCard);
+
+                if(trashCard)
+                    trashTargetCards.Add(trashTargetCard);
             }
         }