several bug fixes (14)

Assets/CardEffect/BT16/Black/Darkdramon_BT16_065.cs

@@ -116,7 +116,7 @@ namespace DCGO.CardEffects.BT16
                             canNoSelect: () => noSelect,
                             selectCardCoroutine: SelectCardCoroutine,
                             afterSelectCardCoroutine: null,
-                            message: "Select cards to place on top of deck.",
+                            message: "Select cards to add to the top your deck\n(cards will be placed back to the top of the deck so that cards with lower numbers are on top).",
                             maxCount: maxCount,
                             canEndNotMax: false,
                             isShowOpponent: true,
@@ -137,6 +137,7 @@ namespace DCGO.CardEffects.BT16
 
                         if (selectedCards.Count == 6)
                         {
+                            selectedCards.Reverse();
                             yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddLibraryTopCards(selectedCards));
                         }
                     }

Assets/CardEffect/BT16/Black/Shakkoumon_BT16_063.cs

@@ -15,28 +15,30 @@ namespace DCGO.CardEffects.BT16
             partitionConditions.Add(new PartitionCondition(4, CardColor.Yellow));
 
             #region Rule - Trait: Also has [Angel]
+
             if (timing == EffectTiming.None)
             {
-                ChangeCardNamesClass changeCardNamesClass = new ChangeCardNamesClass();
-                changeCardNamesClass.SetUpICardEffect("Trait: Also has [Angel]", CanUseCondition, card);
-                changeCardNamesClass.SetUpChangeCardNamesClass(changeCardNames: changeCardNames);
-                cardEffects.Add(changeCardNamesClass);
+                ChangeTraitsClass changeTraitsClass = new ChangeTraitsClass();
+                changeTraitsClass.SetUpICardEffect("Trait: Also has [Angel]", CanUseCondition, card);
+                changeTraitsClass.SetUpChangeTraitsClass(changeeTraits: ChangeTraits);
+                cardEffects.Add(changeTraitsClass);
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
                     return true;
                 }
 
-                List<string> changeCardNames(CardSource cardSource, List<string> CardNames)
+                List<string> ChangeTraits(CardSource cardSource, List<string> cardTraits)
                 {
                     if (cardSource == card)
                     {
-                        cardSource.CardTraits.Add("Angel");
+                        cardTraits.Add("Angel");
                     }
 
-                    return CardNames;
+                    return cardTraits;
                 }
             }
+
             #endregion
 
             #region DNA Digivolution - Black Lv.4 + Yellow Lv.4: Cost 0

Assets/CardEffect/BT16/Black/Zanmetsumon_BT16_062.cs

@@ -39,7 +39,7 @@ namespace DCGO.CardEffects.BT16
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("<De-Digivolve 1>, then delete 3 cost", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -99,7 +99,7 @@ namespace DCGO.CardEffects.BT16
                                 canTargetCondition_ByPreSelecetedList: null,
                                 canEndSelectCondition: null,
                                 maxCount: maxCount,
-                                canNoSelect: true,
+                                canNoSelect: false,
                                 canEndNotMax: false,
                                 selectPermanentCoroutine: null,
                                 afterSelectPermanentCoroutine: AfterSelectDedigivolvePermanentCoroutine,
@@ -146,7 +146,7 @@ namespace DCGO.CardEffects.BT16
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("<De-Digivolve 1>, then delete 3 cost", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -206,7 +206,7 @@ namespace DCGO.CardEffects.BT16
                                 canTargetCondition_ByPreSelecetedList: null,
                                 canEndSelectCondition: null,
                                 maxCount: maxCount,
-                                canNoSelect: true,
+                                canNoSelect: false,
                                 canEndNotMax: false,
                                 selectPermanentCoroutine: null,
                                 afterSelectPermanentCoroutine: AfterSelectDedigivolvePermanentCoroutine,

Assets/CardEffect/BT16/Blue/InvincibleDragonInsectFusion_BT16_092.cs

@@ -93,123 +93,123 @@ namespace DCGO.CardEffects.BT16
                         }
 
                         yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: selectedCards, activateClass: activateClass, payCost: false, isTapped: false, root: SelectCardEffect.Root.Hand, activateETB: true));
+                    }
 
-                        // DNA digivolve
-                        if (card.Owner.GetBattleAreaDigimons().Count >= 2)
+                    // DNA digivolve
+                    if (card.Owner.GetBattleAreaDigimons().Count >= 2)
+                    {
+                        if (card.Owner.HandCards.Count(CanSelectDNACardCondition) >= 1)
                         {
-                            if (card.Owner.HandCards.Count(CanSelectDNACardCondition) >= 1)
+                            List<CardSource> selectedDNACards = new List<CardSource>();
+
+                            SelectHandEffect selectDNAEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                            selectDNAEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectDNACardCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: 1,
+                                canNoSelect: true,
+                                canEndNotMax: false,
+                                isShowOpponent: true,
+                                selectCardCoroutine: SelectDNACoroutine,
+                                afterSelectCardCoroutine: null,
+                                mode: SelectHandEffect.Mode.Custom,
+                                cardEffect: activateClass);
+
+                            selectDNAEffect.SetUpCustomMessage("Select 1 card to DNA digivolve.", "The opponent is selecting 1 card to DNA digivolve.");
+                            selectDNAEffect.SetNotShowCard();
+
+                            yield return StartCoroutine(selectDNAEffect.Activate());
+
+                            IEnumerator SelectDNACoroutine(CardSource cardSource)
                             {
-                                List<CardSource> selectedDNACards = new List<CardSource>();
-
-                                SelectHandEffect selectDNAEffect = GManager.instance.GetComponent<SelectHandEffect>();
+                                selectedDNACards.Add(cardSource);
 
-                                selectDNAEffect.SetUp(
-                                    selectPlayer: card.Owner,
-                                    canTargetCondition: CanSelectDNACardCondition,
-                                    canTargetCondition_ByPreSelecetedList: null,
-                                    canEndSelectCondition: null,
-                                    maxCount: 1,
-                                    canNoSelect: true,
-                                    canEndNotMax: false,
-                                    isShowOpponent: true,
-                                    selectCardCoroutine: SelectDNACoroutine,
-                                    afterSelectCardCoroutine: null,
-                                    mode: SelectHandEffect.Mode.Custom,
-                                    cardEffect: activateClass);
-
-                                selectDNAEffect.SetUpCustomMessage("Select 1 card to DNA digivolve.", "The opponent is selecting 1 card to DNA digivolve.");
-                                selectDNAEffect.SetNotShowCard();
-
-                                yield return StartCoroutine(selectDNAEffect.Activate());
+                                yield return null;
+                            }
 
-                                IEnumerator SelectDNACoroutine(CardSource cardSource)
+                            if (selectedDNACards.Count >= 1)
+                            {
+                                foreach (CardSource selectedCard in selectedDNACards)
                                 {
-                                    selectedDNACards.Add(cardSource);
+                                    if (selectedCard.CanPlayJogress(true))
+                                    {
+                                        _jogressEvoRootsFrameIDs = new int[0];
 
-                                    yield return null;
-                                }
+                                        yield return GManager.instance.photonWaitController.StartWait("AncientAngelOfSteel_BT16_097");
 
-                                if (selectedDNACards.Count >= 1)
-                                {
-                                    foreach (CardSource selectedCard in selectedDNACards)
-                                    {
-                                        if (selectedCard.CanPlayJogress(true))
+                                        if (card.Owner.isYou || GManager.instance.IsAI)
                                         {
-                                            _jogressEvoRootsFrameIDs = new int[0];
+                                            GManager.instance.selectJogressEffect.SetUp_SelectDigivolutionRoots
+                                                                        (card: selectedCard,
+                                                                        isLocal: true,
+                                                                        isPayCost: true,
+                                                                        canNoSelect: true,
+                                                                        endSelectCoroutine_SelectDigivolutionRoots: EndSelectCoroutine_SelectDigivolutionRoots,
+                                                                        noSelectCoroutine: null);
 
-                                            yield return GManager.instance.photonWaitController.StartWait("AncientAngelOfSteel_BT16_097");
+                                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.selectJogressEffect.SelectDigivolutionRoots());
 
-                                            if (card.Owner.isYou || GManager.instance.IsAI)
+                                            IEnumerator EndSelectCoroutine_SelectDigivolutionRoots(List<Permanent> permanents)
                                             {
-                                                GManager.instance.selectJogressEffect.SetUp_SelectDigivolutionRoots
-                                                                            (card: selectedCard,
-                                                                            isLocal: true,
-                                                                            isPayCost: true,
-                                                                            canNoSelect: true,
-                                                                            endSelectCoroutine_SelectDigivolutionRoots: EndSelectCoroutine_SelectDigivolutionRoots,
-                                                                            noSelectCoroutine: null);
-
-                                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.selectJogressEffect.SelectDigivolutionRoots());
-
-                                                IEnumerator EndSelectCoroutine_SelectDigivolutionRoots(List<Permanent> permanents)
+                                                if (permanents.Count == 2)
                                                 {
-                                                    if (permanents.Count == 2)
-                                                    {
-                                                        _jogressEvoRootsFrameIDs = permanents.Distinct().ToArray().Map(permanent => permanent.PermanentFrame.FrameID);
-                                                    }
-
-                                                    yield return null;
+                                                    _jogressEvoRootsFrameIDs = permanents.Distinct().ToArray().Map(permanent => permanent.PermanentFrame.FrameID);
                                                 }
 
-                                                photonView.RPC("SetJogressEvoRootsFrameIDs", RpcTarget.All, _jogressEvoRootsFrameIDs);
+                                                yield return null;
                                             }
 
-                                            else
-                                            {
-                                                GManager.instance.commandText.OpenCommandText("The opponent is choosing a card to DNA digivolve.");
-                                            }
+                                            photonView.RPC("SetJogressEvoRootsFrameIDs", RpcTarget.All, _jogressEvoRootsFrameIDs);
+                                        }
+
+                                        else
+                                        {
+                                            GManager.instance.commandText.OpenCommandText("The opponent is choosing a card to DNA digivolve.");
+                                        }
 
-                                            yield return new WaitWhile(() => !_endSelect);
-                                            _endSelect = false;
+                                        yield return new WaitWhile(() => !_endSelect);
+                                        _endSelect = false;
 
-                                            GManager.instance.commandText.CloseCommandText();
-                                            yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+                                        GManager.instance.commandText.CloseCommandText();
+                                        yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
 
-                                            if (_jogressEvoRootsFrameIDs.Length == 2)
-                                            {
-                                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect(new List<CardSource>() { selectedCard }, "Played Card", true, true));
+                                        if (_jogressEvoRootsFrameIDs.Length == 2)
+                                        {
+                                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect(new List<CardSource>() { selectedCard }, "Played Card", true, true));
 
-                                                PlayCardClass playCard = new PlayCardClass(
-                                                    cardSources: new List<CardSource>() { selectedCard },
-                                                    hashtable: CardEffectCommons.CardEffectHashtable(activateClass),
-                                                    payCost: true,
-                                                    targetPermanent: null,
-                                                    isTapped: false,
-                                                    root: SelectCardEffect.Root.Hand,
-                                                    activateETB: true);
+                                            PlayCardClass playCard = new PlayCardClass(
+                                                cardSources: new List<CardSource>() { selectedCard },
+                                                hashtable: CardEffectCommons.CardEffectHashtable(activateClass),
+                                                payCost: true,
+                                                targetPermanent: null,
+                                                isTapped: false,
+                                                root: SelectCardEffect.Root.Hand,
+                                                activateETB: true);
 
-                                                playCard.SetJogress(_jogressEvoRootsFrameIDs);
+                                            playCard.SetJogress(_jogressEvoRootsFrameIDs);
 
-                                                yield return ContinuousController.instance.StartCoroutine(playCard.PlayCard());
+                                            yield return ContinuousController.instance.StartCoroutine(playCard.PlayCard());
 
-                                                if (CardEffectCommons.IsExistOnBattleArea(selectedCard))
+                                            if (CardEffectCommons.IsExistOnBattleArea(selectedCard))
+                                            {
+                                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainBlocker(
+                                                    targetPermanent: selectedCard.PermanentOfThisCard(),
+                                                    effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                                                    activateClass: activateClass));
+
+                                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotBeDeletedByBattle(
+                                                    targetPermanent: selectedCard.PermanentOfThisCard(),
+                                                    canNotBeDestroyedByBattleCondition: CanNotBeDestroyedByBattleCondition,
+                                                    effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                                                    activateClass: activateClass,
+                                                    effectName: "Can't be deleted in battle"));
+
+                                                bool CanNotBeDestroyedByBattleCondition(Permanent permanent1, Permanent attackingPermanent, Permanent defendingPermanent, CardSource defendingCard)
                                                 {
-                                                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainBlocker(
-                                                        targetPermanent: selectedCard.PermanentOfThisCard(),
-                                                        effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                                                        activateClass: activateClass));
-
-                                                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotBeDeletedByBattle(
-                                                        targetPermanent: selectedCard.PermanentOfThisCard(),
-                                                        canNotBeDestroyedByBattleCondition: CanNotBeDestroyedByBattleCondition,
-                                                        effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                                                        activateClass: activateClass,
-                                                        effectName: "Can't be deleted in battle"));
-
-                                                    bool CanNotBeDestroyedByBattleCondition(Permanent permanent1, Permanent attackingPermanent, Permanent defendingPermanent, CardSource defendingCard)
-                                                    {
-                                                        return permanent1 == attackingPermanent || permanent1 == defendingPermanent;
-                                                    }
+                                                    return permanent1 == attackingPermanent || permanent1 == defendingPermanent;
                                                 }
                                             }
                                         }

Assets/CardEffect/BT16/Red/GarudamonXAntibody_BT16_011.cs

@@ -34,7 +34,7 @@ namespace DCGO.CardEffects.BT16
             }
             #endregion
 
-            #region On Play | When Digivolving
+            #region On Play
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -44,7 +44,7 @@ namespace DCGO.CardEffects.BT16
 
                 string EffectDiscription()
                 {
-                    return "[On Play] [When Digivolving] You may return 1 red Digimon card from your trash to the hand. Then, if [Garudamon] or [X-Antibody] is in this Digimon's digivolution cards, delete 1 of your opponent's Digimon with DP less than or equal to this Digimon's DP.";
+                    return "[On Play] You may return 1 red Digimon card from your trash to the hand. Then, if [Garudamon] or [X-Antibody] is in this Digimon's digivolution cards, delete 1 of your opponent's Digimon with DP less than or equal to this Digimon's DP.";
                 }
 
                 bool CanSelectCardCondition(CardSource cardSource)
@@ -53,8 +53,7 @@ namespace DCGO.CardEffects.BT16
                     {
                         if (cardSource.CardColors.Contains(CardColor.Red))
                         {
-                            if (cardSource.HasAvianBeastAnimalTraits)
-                                return true;
+                            return true;
                         }
                     }
 
@@ -63,14 +62,131 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable,card) || CardEffectCommons.CanTriggerOnPlay(hashtable,card);
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable,card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    return CardEffectCommons.IsExistOnBattleArea(card);
+                }
+
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
                     {
-                        if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
+                        if (CardEffectCommons.IsExistOnBattleArea(card))
+                        {
+                            if (card.PermanentOfThisCard().HasDP)
+                            {
+                                if (permanent.TopCard.HasDP)
+                                {
+                                    if (permanent.DP <= card.PermanentOfThisCard().DP)
+                                    {
+                                        return true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
+                    {
+
+                        List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                        {
+                            new SelectionElement<bool>(message: $"Yes", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"No", value : false, spriteIndex: 1),
+                        };
+
+                        string selectPlayerMessage = "Will you return a Digimon from your trash to your hand?";
+                        string notSelectPlayerMessage = "The opponent is choosing whether or not to return a card to their hand.";
+
+                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                        bool willReturn = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+
+                        if (willReturn)
+                        {
+                            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: () => false,
+                                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());
+                        }
+                    }
+
+                    if(CardEffectCommons.IsExistOnBattleArea(card) && card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) => cardSource.CardNames.Contains("Garudamon") || cardSource.CardNames.Contains("X Antibody") || cardSource.CardNames.Contains("XAntibody")) >= 1)
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                        {
+                            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectPermanentCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: null,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Destroy,
+                                cardEffect: activateClass);
+
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                        }
+                    }
+                }
+            }
+            #endregion
+
+            #region When Digivolving
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Return 1 red Digimon card from the trash to your hand and delete a Digimon.", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] You may return 1 red Digimon card from your trash to the hand. Then, if [Garudamon] or [X-Antibody] is in this Digimon's digivolution cards, delete 1 of your opponent's Digimon with DP less than or equal to this Digimon's DP.";
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    if (cardSource.IsDigimon)
+                    {
+                        if (cardSource.CardColors.Contains(CardColor.Red))
                         {
                             return true;
                         }
@@ -79,6 +195,16 @@ namespace DCGO.CardEffects.BT16
                     return false;
                 }
 
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(card);
+                }
+
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
                     if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
@@ -150,7 +276,7 @@ namespace DCGO.CardEffects.BT16
                         }
                     }
 
-                    if(CardEffectCommons.IsExistOnBattleArea(card) && card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) => cardSource.CardNames.Contains("Garudamon") || cardSource.CardNames.Contains("X Antibody") || cardSource.CardNames.Contains("XAntibody")) >= 1)
+                    if (CardEffectCommons.IsExistOnBattleArea(card) && card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) => cardSource.CardNames.Contains("Garudamon") || cardSource.CardNames.Contains("X Antibody") || cardSource.CardNames.Contains("XAntibody")) >= 1)
                     {
                         if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                         {
@@ -199,7 +325,7 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    if (CardEffectCommons.CanActivateOnDeletionInherited(hashtable, card))
                     {
                         if (card.Owner.Enemy.SecurityCards.Count >= 1)
                         {

Assets/CardEffect/BT16/Red/Silphymon_BT16_012.cs

@@ -226,19 +226,91 @@ namespace DCGO.CardEffects.BT16
             }
             #endregion
 
-            #region When Digivolving | When Attacking
+            #region When Digivolving - Delete opponents 4k <
 
-            if (timing == EffectTiming.OnEnterFieldAnyone || timing == EffectTiming.OnAllyAttack)
+            if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Delete 1 of your opponent's Digimon with 4000 DP or less.", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetHashString("Delete4000DPorLess_BT16_012");
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] Delete 1 of your opponent's Digimon with 4000 DP or less.";
+                }
+
+
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
+                    {
+                        if (permanent.DP <= card.Owner.MaxDP_DeleteEffect(4000, activateClass))
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        return true;
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    {
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: null,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Destroy,
+                            cardEffect: activateClass);
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                    }
+                }
+            }
+
+            #endregion
+
+            #region When Attacking
+
+            if (timing == EffectTiming.OnAllyAttack)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Delete 1 of your opponent's Digimon with 4000 DP or less.", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 activateClass.SetHashString("Delete4000DPorLess_BT16_012");
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
                 {
-                    return "[When Digivolving] [When Attacking] Delete 1 of your opponent's Digimon with 4000 DP or less.";
+                    return "[When Attacking] Delete 1 of your opponent's Digimon with 4000 DP or less.";
                 }
 
 
@@ -257,7 +329,7 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card) || CardEffectCommons.CanTriggerOnAttack(hashtable,card);
+                    return CardEffectCommons.CanTriggerOnAttack(hashtable, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)

Assets/CardEffect/BT5/Purple/DemonsDisaster_BT5_106.cs

@@ -107,13 +107,13 @@ public class DemonsDisaster_BT5_106 : CEntity_Effect
         {
             ActivateClass activateClass = new ActivateClass();
             activateClass.SetUpICardEffect($"Play 1 level 3 Digimon from trash", CanUseCondition, card);
-            activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
+            activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDiscription());
             activateClass.SetIsSecurityEffect(true);
             cardEffects.Add(activateClass);
 
             string EffectDiscription()
             {
-                return "[Security] Play 1 purple level 3 Digimon card from your trash without paying its memory cost. Any [On Play] effects on the Digimon played with this effect don't activate.";
+                return "[Security] You may play 1 level 3 purple Digimon card from your trash without paying its memory cost. Any [On Play] effects on Digimon played with this effect don't activate.";
             }
 
             bool CanSelectCardCondition(CardSource cardSource)

Assets/CardEffect/EX6/Purple/Barbamon_EX6_059.cs

@@ -17,7 +17,7 @@ namespace DCGO.CardEffects.EX6
             #region Scapegoat
             if (timing == EffectTiming.WhenPermanentWouldBeDeleted)
             { 
-                cardEffects.Add(CardEffectFactory.ScapegoatSelfEffect(isInheritedEffect: true, card: card, condition: null, effectName: "<Scapegoat>", effectDiscription: null));
+                cardEffects.Add(CardEffectFactory.ScapegoatSelfEffect(isInheritedEffect: false, card: card, condition: null, effectName: "<Scapegoat>", effectDiscription: null));
             }
             #endregion
 

Assets/CardEffect/EX6/Purple/Lucemon_Chaos_Mode_EX6_054.cs

@@ -26,7 +26,7 @@ namespace DCGO.CardEffects.EX6
                     return false;
                 }
 
-                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 5, ignoreDigivolutionRequirement: false, card: card, condition: null));
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 6, ignoreDigivolutionRequirement: true, card: card, condition: null));
             }
             #endregion
 

Assets/CardEffect/EX6/Purple/Rise_of_the_Seven_Great_Demon_Lords_EX6_069.cs

@@ -16,7 +16,7 @@ namespace DCGO.CardEffects.EX6
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Place 1 Digimon with [Seven Great Demon Lords] trait as bottom digivolution source in breeding area.", CanUseCondition, card);
-                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -63,114 +63,126 @@ namespace DCGO.CardEffects.EX6
                             #region Selecting Hand or Trash
                             if (validCardInTrash && validCardInHand)
                             {
-                                List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                                List<SelectionElement<int>> selectionElements = new List<SelectionElement<int>>()
                                 {
-                                    new SelectionElement<bool>(message: $"Trash", value : true, spriteIndex: 0),
-                                    new SelectionElement<bool>(message: $"Hand", value : false, spriteIndex: 1),
+                                    new SelectionElement<int>(message: $"Trash", value : 0, spriteIndex: 0),
+                                    new SelectionElement<int>(message: $"Hand", value : 1, spriteIndex: 0),
+                                    new SelectionElement<int>(message: $"No Selection", value : 2, spriteIndex: 1),
                                 };
 
                                 string selectPlayerMessage = "Will you use a card from hand or trash?";
                                 string notSelectPlayerMessage = "The opponent is choosing whether use a card from hand or trash.";
 
-                                GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                                GManager.instance.userSelectionManager.SetIntSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                            }
+                            else if(validCardInTrash && !validCardInHand)
+                            {
+                                GManager.instance.userSelectionManager.SetInt(0);
+                            }
+                            else if (!validCardInTrash && validCardInHand)
+                            {
+                                GManager.instance.userSelectionManager.SetInt(1);
                             }
                             else
                             {
-                                GManager.instance.userSelectionManager.SetBool(validCardInTrash);
+                                GManager.instance.userSelectionManager.SetInt(2);
                             }
 
                             yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                            useTrash = GManager.instance.userSelectionManager.SelectedBoolValue;
+                            useTrash = (GManager.instance.userSelectionManager.SelectedIntValue == 1);
                             #endregion
 
-                            #region Card Selection
-                            CardSource selectedCard = null;
-
-                            IEnumerator SelectCardCoroutine(CardSource cardSource)
+                            if(GManager.instance.userSelectionManager.SelectedIntValue != 2)
                             {
-                                selectedCard = cardSource;
+                                #region Card Selection
+                                CardSource selectedCard = null;
 
-                                yield return null;
-                            }
+                                IEnumerator SelectCardCoroutine(CardSource cardSource)
+                                {
+                                    selectedCard = cardSource;
 
-                            
-                            if (!useTrash)
-                            {
-                                SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
-
-                                selectHandEffect.SetUp(
-                                    selectPlayer: card.Owner,
-                                    canTargetCondition: HasSevenGreatDemonLordTrait,
-                                    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 place at the bottom of digivolution cards.",
-                        "The opponent is selecting 1 card to place at the bottom of digivolution cards.");
-                                selectHandEffect.SetUpCustomMessage_ShowCard("Place bottom digivolution card");
-
-                                yield return StartCoroutine(selectHandEffect.Activate());
-                            }
+                                    yield return null;
+                                }
 
-                            else
-                            {
-                                SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
-
-                                selectCardEffect.SetUp(
-                                    canTargetCondition: HasSevenGreatDemonLordTrait,
-                                    canTargetCondition_ByPreSelecetedList: null,
-                                    canEndSelectCondition: null,
-                                    canNoSelect: () => true,
-                                    selectCardCoroutine: SelectCardCoroutine,
-                                    afterSelectCardCoroutine: null,
-                                    message: "Select 1 card to play.",
-                                    maxCount: 1,
-                                    canEndNotMax: false,
-                                    isShowOpponent: true,
-                                    mode: SelectCardEffect.Mode.Custom,
-                                    root: SelectCardEffect.Root.Trash,
-                                    customRootCardList: null,
-                                    canLookReverseCard: true,
-                                    selectPlayer: card.Owner,
-                                    cardEffect: activateClass);
-
-                                selectCardEffect.SetUpCustomMessage(
-                        "Select 1 card to place at the bottom of digivolution cards.",
-                        "The opponent is selecting 1 card to place at the bottom of digivolution cards.");
-                                selectCardEffect.SetUpCustomMessage_ShowCard("Place bottom digivolution card");
-
-                                yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
-                            }
-                            #endregion
 
-                            #region Place As Source
-                            if (selectedCard != null)
-                            {
-                                if (card.Owner.GetBreedingAreaPermanents().Count(CanSelectPermanentCondition) >= 1)
+                                if (!useTrash)
                                 {
-                                    Permanent selectedPermanent = card.Owner.GetBreedingAreaPermanents()[0];
+                                    SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                                    selectHandEffect.SetUp(
+                                        selectPlayer: card.Owner,
+                                        canTargetCondition: HasSevenGreatDemonLordTrait,
+                                        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 place at the bottom of digivolution cards.",
+                            "The opponent is selecting 1 card to place at the bottom of digivolution cards.");
+                                    selectHandEffect.SetUpCustomMessage_ShowCard("Place bottom digivolution card");
+
+                                    yield return StartCoroutine(selectHandEffect.Activate());
+                                }
 
-                                    if (CanSelectPermanentCondition(selectedPermanent))
+                                else
+                                {
+                                    SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                                    selectCardEffect.SetUp(
+                                        canTargetCondition: HasSevenGreatDemonLordTrait,
+                                        canTargetCondition_ByPreSelecetedList: null,
+                                        canEndSelectCondition: null,
+                                        canNoSelect: () => true,
+                                        selectCardCoroutine: SelectCardCoroutine,
+                                        afterSelectCardCoroutine: null,
+                                        message: "Select 1 card to play.",
+                                        maxCount: 1,
+                                        canEndNotMax: false,
+                                        isShowOpponent: true,
+                                        mode: SelectCardEffect.Mode.Custom,
+                                        root: SelectCardEffect.Root.Trash,
+                                        customRootCardList: null,
+                                        canLookReverseCard: true,
+                                        selectPlayer: card.Owner,
+                                        cardEffect: activateClass);
+
+                                    selectCardEffect.SetUpCustomMessage(
+                            "Select 1 card to place at the bottom of digivolution cards.",
+                            "The opponent is selecting 1 card to place at the bottom of digivolution cards.");
+                                    selectCardEffect.SetUpCustomMessage_ShowCard("Place bottom digivolution card");
+
+                                    yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+                                }
+                                #endregion
+
+                                #region Place As Source
+                                if (selectedCard != null)
+                                {
+                                    if (card.Owner.GetBreedingAreaPermanents().Count(CanSelectPermanentCondition) >= 1)
                                     {
-                                        if (selectedPermanent != null)
+                                        Permanent selectedPermanent = card.Owner.GetBreedingAreaPermanents()[0];
+
+                                        if (CanSelectPermanentCondition(selectedPermanent))
                                         {
-                                            yield return ContinuousController.instance.StartCoroutine(selectedPermanent.AddDigivolutionCardsBottom(
-                                                new List<CardSource>() { selectedCard },
-                                                activateClass));
+                                            if (selectedPermanent != null)
+                                            {
+                                                yield return ContinuousController.instance.StartCoroutine(selectedPermanent.AddDigivolutionCardsBottom(
+                                                    new List<CardSource>() { selectedCard },
+                                                    activateClass));
+                                            }
                                         }
                                     }
                                 }
+                                #endregion
                             }
-                            #endregion
                         }
                     }
                         

Assets/CardEffect/EX6/Red/Mythical_Arms_of_Salvation_EX6_065.cs

@@ -165,13 +165,13 @@ namespace DCGO.CardEffects.EX6
                                 {
                                     yield return ContinuousController.instance.StartCoroutine(
                                         permanent.AddDigivolutionCardsBottom(selectedCards, activateClass));
-                                    
-                                    yield return ContinuousController.instance.StartCoroutine(
-                                        CardEffectCommons.PlaceDelayOptionCards(card: card, cardEffect: activateClass));
                                 }
                             }
                         }
                     }
+
+                    yield return ContinuousController.instance.StartCoroutine(
+                                        CardEffectCommons.PlaceDelayOptionCards(card: card, cardEffect: activateClass));
                 }
             }
             

Assets/CardEffect/EX6/White/UltimateChaosmon_EX6_062.cs

@@ -127,17 +127,17 @@ namespace DCGO.CardEffects.EX6
 
                 string EffectDiscription()
                 {
-                    return "[When Digivolving] If DNA digivolving, you may place up to 2 level 6 cards from your trash as this Digimon's bottom digivolution cards.";
+                    return "[When Digivolving] If DNA digivolving, you may place up to 2 level 6 cards from your trash as this Digimon's bottom digivolution cards. Then, for each of this Digimon's level 6 digivolution cards, return 1 of your opponent's Digimon to the bottom of the deck.";
                 }
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    if(cardSource.HasLevel && cardSource.Level == 6)
-                    {
-                        return true;
-                    }
+                    return (cardSource.HasLevel && cardSource.Level == 6);
+                }
 
-                    return false;
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -203,47 +203,8 @@ namespace DCGO.CardEffects.EX6
                             }
                         }
                     }
-                }
-            }
-
-            if (timing == EffectTiming.OnEnterFieldAnyone)
-            {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Return 1 Digimon to the bottom of deck", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-                cardEffects.Add(activateClass);
-
-                string EffectDiscription()
-                {
-                    return "[When Digivolving] Then, for each level 6 card in this Digimon's digivolution cards, return 1 of your opponent's Digimon to the bottom of the deck.";
-                }
 
-                bool CanSelectPermanentCondition(Permanent permanent)
-                {
-                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
-                }
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
-                }
-
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-
-                IEnumerator ActivateCoroutine(Hashtable _hashtable)
-                {
-                    int count = card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) =>  cardSource.HasLevel && cardSource.Level == 6);
+                    int count = card.PermanentOfThisCard().DigivolutionCards.Count(CanSelectCardCondition);
 
                     if (count >= 1)
                     {
@@ -270,12 +231,7 @@ namespace DCGO.CardEffects.EX6
 
                             bool CanEndSelectCondition(List<Permanent> permanents)
                             {
-                                if (permanents.Count <= 0)
-                                {
-                                    return false;
-                                }
-
-                                return true;
+                                return (permanents.Count > 0);
                             }
                         }
                     }

Assets/CardEffect/LM/Purple/Regulusmon_LM_017.cs

@@ -28,31 +28,29 @@ namespace DCGO.CardEffects.LM
                 cardEffects.Add(CardEffectFactory.BlastDigivolveEffect(card: card, condition: null));
             }
 
-            #region On Play/When Digivolving Shared
-            string EffectSharedDiscription()
-            {
-                return "[On Play] [When Digivolving] Trash 1 card in your hand. Then, you may place 1 card with [Gammamon] in its text from your trash as this Digimon's bottom digivolution card.";
-            }
-
-            bool CanSelectSharedCardCondition(CardSource cardSource)
-            {
-                if (CardEffectCommons.IsExistOnTrash(cardSource))
-                {
-                    return cardSource.HasText("Gammamon");
-                }
-                return false;
-            }
-            #endregion
-
             #region On Play
 
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Trash 1 card from your hand", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectSharedDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
+                bool CanSelectSharedCardCondition(CardSource cardSource)
+                {
+                    if (CardEffectCommons.IsExistOnTrash(cardSource))
+                    {
+                        return cardSource.HasText("Gammamon");
+                    }
+                    return false;
+                }
+
+                string EffectDiscription()
+                {
+                    return "[On Play] Trash 1 card in your hand. Then, you may place 1 card with [Gammamon] in its text from your trash as this Digimon's bottom digivolution card.";
+                }
+
                 bool CanUseCondition(Hashtable hashtable)
                 {
                     return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
@@ -99,7 +97,7 @@ namespace DCGO.CardEffects.LM
                         canTargetCondition_ByPreSelecetedList: null,
                         canEndSelectCondition: null,
                         maxCount: 1,
-                        canNoSelect: true,
+                        canNoSelect: false,
                         canEndNotMax: false,
                         isShowOpponent: true,
                         selectCardCoroutine: null,
@@ -118,7 +116,7 @@ namespace DCGO.CardEffects.LM
                 {
                     ActivateClass activateClass = new ActivateClass();
                     activateClass.SetUpICardEffect("Place a Card from hand to digivolution cards to get effects", CanUseCondition, card);
-                    activateClass.SetUpActivateClass(CanActivateThenCondition, ActivateCoroutine, -1, true, EffectSharedDiscription());
+                    activateClass.SetUpActivateClass(CanActivateThenCondition, ActivateCoroutine, -1, true, EffectDiscription());
                     cardEffects.Add(activateClass);
 
                     SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
@@ -174,14 +172,28 @@ namespace DCGO.CardEffects.LM
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Trash 1 card from your hand", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectSharedDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
+                bool CanSelectSharedCardCondition(CardSource cardSource)
+                {
+                    if (CardEffectCommons.IsExistOnTrash(cardSource))
+                    {
+                        return cardSource.HasText("Gammamon");
+                    }
+                    return false;
+                }
+
                 bool CanUseCondition(Hashtable hashtable)
                 {
                     return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
                 }
 
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] Trash 1 card in your hand. Then, you may place 1 card with [Gammamon] in its text from your trash as this Digimon's bottom digivolution card.";
+                }
+
                 bool CanActivateCondition(Hashtable hashtable)
                 {
                     if (CardEffectCommons.IsExistOnBattleArea(card))
@@ -242,7 +254,7 @@ namespace DCGO.CardEffects.LM
                 {
                     ActivateClass activateClass = new ActivateClass();
                     activateClass.SetUpICardEffect("Place a Card from hand to digivolution cards to get effects", CanUseCondition, card);
-                    activateClass.SetUpActivateClass(CanActivateThenCondition, ActivateCoroutine, -1, true, EffectSharedDiscription());
+                    activateClass.SetUpActivateClass(CanActivateThenCondition, ActivateCoroutine, -1, true, EffectDiscription());
                     cardEffects.Add(activateClass);
 
                     SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();

Assets/Scripts/CardController.cs

@@ -3261,7 +3261,9 @@ public class IDestroySecurity
             {
                 string log = "";
 
-                log += $"\nDiscarded Security Cards:";
+                string fromString = _fromTop ? "Top" : "Bottom";
+
+                log += $"\nDiscarded From {fromString} Security Cards:";
 
                 foreach (CardSource cardSource in discardedCards)
                 {