Fixed new warnings

Assets/Scripts/CardEffect/BT15/Black/BT15_066.cs

@@ -58,11 +58,6 @@ namespace DCGO.CardEffects.BT15
                 return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
             }
 
-            bool SharedCanActivateCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.IsExistOnBattleArea(card);
-            }
-
             IEnumerator SharedActivateCoroutine(Hashtable _hashtable, ActivateClass activateClass)
             {
                 if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))

Assets/Scripts/CardEffect/BT15/White/BT15_102.cs

@@ -3,6 +3,7 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
+// Apocalymon
 namespace DCGO.CardEffects.BT15
 {
     public class BT15_102 : CEntity_Effect
@@ -12,132 +13,186 @@ namespace DCGO.CardEffects.BT15
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Before Pay Cost - Condition Effect
-
             if (timing == EffectTiming.BeforePayCost)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Placing 1 [Dark Masters] to get Play Cost -4", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDescription());
                 activateClass.SetHashString("PlayCost-12_BT15_102");
                 cardEffects.Add(activateClass);
 
-                string EffectDiscription()
+                string EffectDescription()
                 {
                     return "When this card would be played, by placing up to 3 [Dark Masters] trait cards with different names from your battle area or trash under it, reduce the play cost by 4 for each one.";
                 }
 
-                bool CanSelectCardCondition(CardSource cardSource)
+                bool CardCondition(CardSource cardSource)
                 {
-                    if (cardSource.IsDigimon)
-                    {
-                        if (cardSource.CardTraits.Contains("Dark Masters") || cardSource.CardTraits.Contains("DarkMasters"))
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
+                    return cardSource == card;
                 }
 
-                bool CanSelectCardConditionPermenant(Permanent permanent)
+                bool CanNoSelect(CardSource cardSource, int placed)
                 {
-                    if (permanent.IsDigimon)
+                    if (cardSource != null
+                    && cardSource.PayingCost(SelectCardEffect.Root.Hand, null, checkAvailability: false) - (4 * placed) > cardSource.Owner.MaxMemoryCost)
                     {
-                        if (permanent.TopCard.ContainsTraits("Dark Masters") || permanent.TopCard.ContainsTraits("DarkMasters"))
-                        {
-                            return true;
-                        }
+                        return false;
                     }
-                    return false;
+
+                    return true;
                 }
 
-                bool CardCondition(CardSource cardSource)
+                bool CanUseCondition(Hashtable hashtable)
                 {
-                    if (cardSource == card)
-                    {
-                        if (CardEffectCommons.IsExistOnHand(cardSource))
-                        {
-                            return true;
-                        }
-                    }
+                    return CardEffectCommons.CanTriggerWhenPermanentWouldPlay(hashtable, CardCondition);
+                }
+
+                bool IsDarkMaster(CardSource cardSource) => cardSource.EqualsTraits("Dark Masters");
 
-                    return false;
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, IsDarkMaster)
+                            || CardEffectCommons.HasMatchConditionOwnersPermanent(card, permanent => IsDarkMaster(permanent.TopCard));
                 }
 
-                bool CanNoSelect(CardSource cardSource)
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    if (cardSource != null)
+                    #region Shared bool and stuff
+                    List<CardSource> digivolutionCards = new List<CardSource>();
+
+                    bool CanSelectCardCondition(CardSource cardSource)
                     {
-                        if (cardSource.PayingCost(SelectCardEffect.Root.Hand, null, checkAvailability: false) > cardSource.Owner.MaxMemoryCost)
+                        if (IsDarkMaster(cardSource))
                         {
-                            return false;
+                            List<CardSource> chosenCards = digivolutionCards.Clone();
+                            chosenCards.Add(cardSource);
+
+                            return Combinations.GetUniqueNameCardCount(chosenCards) == chosenCards.Count;// If the highest unique names does not match the number of cards in the list, something shares a name
                         }
-                    }
 
-                    return true;
-                }
+                        return false;
+                    }
 
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    if (CardEffectCommons.CanTriggerWhenPermanentWouldPlay(hashtable, CardCondition))
+                    bool CanSelectPermanentCondition(Permanent permanent)
                     {
-                        return true;
+                        return CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card)
+                            && CanSelectCardCondition(permanent.TopCard);
                     }
 
-                    return false;
-                }
+                    int validPermanentCount = CardEffectCommons.MatchConditionOwnersPermanentCount(card, CanSelectPermanentCondition);
+                    int validTrashCardCount = card.Owner.TrashCards.Count(CanSelectCardCondition);
 
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    if (CardEffectCommons.IsExistOnHand(card))
+                    int toPlace = Math.Min(3, validPermanentCount + validTrashCardCount);
+
+                    bool noSelect() => CanNoSelect(card, digivolutionCards.Count);
+
+                    bool ValidPermanentCombination(List<Permanent> permanents, Permanent permanent)
                     {
-                        if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
-                        {
-                            return true;
-                        }
+                        List<CardSource> chosenCards = permanents.Map(perm => perm.TopCard);
+                        chosenCards.Add(permanent.TopCard);
 
-                        if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, CanSelectCardConditionPermenant))
-                        {
-                            return true;
-                        }
+                        return ValidCardCombination(chosenCards);
                     }
 
-                    return false;
-                }
+                    bool ValidCardSourceCombination(List<CardSource> cardSources, CardSource cardSource)
+                    {
+                        List<CardSource> chosenCards = cardSources.Clone();
+                        chosenCards.Add(cardSource);
 
-                IEnumerator ActivateCoroutine(Hashtable _hashtable)
-                {
-                    List<CardSource> digivolutionCards = new List<CardSource>();
+                        return ValidCardCombination(chosenCards);
+                    }
 
-                    bool CanSelectTrashCardCondition(CardSource cardSource)
+                    bool ValidCardCombination(List<CardSource> cardSources)
                     {
-                        if (CanSelectCardCondition(cardSource))
+                        List<CardSource> chosenCards = digivolutionCards.Clone();
+                        chosenCards.AddRange(cardSources);
+
+                        return Combinations.GetUniqueNameCardCount(chosenCards) == chosenCards.Count;// If the highest unique names does not match the number of cards in the list, something shares a name
+                    }
+                    #endregion
+
+                    while (toPlace > 0)
+                    {
+                        if (validPermanentCount > 0 && validTrashCardCount > 0)
                         {
-                            if (digivolutionCards.Count((filteredCard) => filteredCard.CardID == cardSource.CardID) == 0)
+                            List<SelectionElement<int>> selectionElements = new List<SelectionElement<int>>()
                             {
-                                return true;
+                                new(message: "from Battle Area", value: 1, spriteIndex: 0),
+                                new(message: "from Trash", value: 2, spriteIndex: 0)
+                            };
+
+                            if (noSelect())
+                            {
+                                string message = digivolutionCards.Count > 0 ? "Finish Placing" : "Do not place";
+                                selectionElements.Add(new(message: message, value: 3, spriteIndex: 1));
                             }
+
+                            GManager.instance.userSelectionManager.SetIntSelection(
+                                selectionElements: selectionElements,
+                                selectPlayer: card.Owner,
+                                selectPlayerMessage: "From which area will you select a card?",
+                                notSelectPlayerMessage: "The opponent is choosing from which area to select a card.");
+                        }
+                        else
+                        {
+                            GManager.instance.userSelectionManager.SetInt(validPermanentCount > 0 ? 1 : 2);
                         }
 
-                        return false;
-                    }
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                    if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, (cardSource) => CanSelectTrashCardCondition(cardSource)))
-                    {
-                        bool noSelect = CanNoSelect(CardEffectCommons.GetCardFromHashtable(_hashtable));
-                        List<CardSource> selectedCards = new List<CardSource>();
+                        if (GManager.instance.userSelectionManager.SelectedIntValue == 3)
+                        {
+                            break;
+                        }
+                        if (GManager.instance.userSelectionManager.SelectedIntValue == 1)
+                        {
+                            bool canNoSelect = noSelect() && validTrashCardCount > 0;
+                            int maxCount = Math.Min(3 - digivolutionCards.Count, validPermanentCount);
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectPermanentCondition,
+                                canTargetCondition_ByPreSelecetedList: ValidPermanentCombination,
+                                canEndSelectCondition: CanEndSelectCondition,
+                                maxCount: maxCount,
+                                canNoSelect: canNoSelect, //if need to select cards and no valid trash cards
+                                canEndNotMax: true,
+                                selectPermanentCoroutine: SelectPermanentCoroutine,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
 
-                        int maxCount = Math.Min(3 - digivolutionCards.Count, card.Owner.TrashCards.Count((cardSource) => CanSelectTrashCardCondition(cardSource)));
+                            selectPermanentEffect.SetUpCustomMessage("Select Digimon to place.", "The opponent is selecting Digimon to place.");
 
-                        if (maxCount >= 1)
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                            bool CanEndSelectCondition(List<Permanent> permanents)
+                            {
+                                List<CardSource> chosenCards = permanents.Map(perm => perm.TopCard);
+
+                                return ValidCardCombination(chosenCards);
+                            }
+
+                            IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                            {
+                                digivolutionCards.Add(permanent.TopCard);
+
+                                yield return null;
+                            }
+                            validPermanentCount = CardEffectCommons.MatchConditionOwnersPermanentCount(card, CanSelectPermanentCondition);
+                        }
+                        else
                         {
+                            bool canNoSelect = noSelect() && validPermanentCount > 0;
+                            int maxCount = Math.Min(3 - digivolutionCards.Count, validTrashCardCount);
                             SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
 
                             selectCardEffect.SetUp(
-                                canTargetCondition: CanSelectTrashCardCondition,
-                                canTargetCondition_ByPreSelecetedList: CanTargetCondition_ByPreSelecetedList,
-                                canEndSelectCondition: CanEndSelectCondition,
-                                canNoSelect: () => noSelect,
+                                canTargetCondition: CanSelectCardCondition,
+                                canTargetCondition_ByPreSelecetedList: ValidCardSourceCombination,
+                                canEndSelectCondition: ValidCardCombination,
+                                canNoSelect: () => canNoSelect,
                                 selectCardCoroutine: SelectCardCoroutine,
                                 afterSelectCardCoroutine: null,
                                 message: "Select cards to place in Digivolution cards.",
@@ -153,87 +208,27 @@ namespace DCGO.CardEffects.BT15
 
                             yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
 
-                            bool CanTargetCondition_ByPreSelecetedList(List<CardSource> cardSources, CardSource cardSource)
-                            {
-                                List<string> cardIDs = new List<string>();
-
-                                foreach (CardSource cardSource1 in cardSources)
-                                {
-                                    if (!cardIDs.Contains(cardSource1.CardID))
-                                    {
-                                        cardIDs.Add(cardSource1.CardID);
-                                    }
-                                }
-
-                                foreach (CardSource cardSource1 in digivolutionCards)
-                                {
-                                    if (!cardIDs.Contains(cardSource1.CardID))
-                                    {
-                                        cardIDs.Add(cardSource1.CardID);
-                                    }
-                                }
-
-                                if (cardIDs.Contains(cardSource.CardID))
-                                {
-                                    return false;
-                                }
-
-                                return true;
-                            }
-
-                            bool CanEndSelectCondition(List<CardSource> cardSources)
-                            {
-                                List<string> cardIDs = new List<string>();
-
-                                foreach (CardSource cardSource1 in cardSources)
-                                {
-                                    if (!cardIDs.Contains(cardSource1.CardID))
-                                    {
-                                        cardIDs.Add(cardSource1.CardID);
-                                    }
-                                }
-
-                                foreach (CardSource cardSource1 in digivolutionCards)
-                                {
-                                    if (!cardIDs.Contains(cardSource1.CardID))
-                                    {
-                                        cardIDs.Add(cardSource1.CardID);
-                                    }
-                                }
-
-                                if (cardIDs.Count != cardSources.Count + digivolutionCards.Count)
-                                {
-                                    return false;
-                                }
-
-                                return true;
-                            }
-
                             IEnumerator SelectCardCoroutine(CardSource cardSource)
                             {
-                                selectedCards.Add(cardSource);
                                 digivolutionCards.Add(cardSource);
-                                yield return null;
-                            }
-
-                            if (selectedCards.Count >= 1)
-                            {
-                                GManager.instance.GetComponent<SelectDigiXrosClass>().AddDigivolutionCardInfos(new AddDigivolutionCardsInfo(activateClass, selectedCards));
 
-                                yield return StartCoroutine(AfterSelectCardCoroutine(selectedCards));
+                                yield return null;
                             }
+                            validTrashCardCount = card.Owner.TrashCards.Count(CanSelectCardCondition);
                         }
                     }
 
-                    IEnumerator AfterSelectCardCoroutine(List<CardSource> cardSources)
+                    if (digivolutionCards.Count >= 1)
                     {
+                        GManager.instance.GetComponent<SelectDigiXrosClass>().AddDigivolutionCardInfos(new AddDigivolutionCardsInfo(activateClass, digivolutionCards));
+
                         if (card.Owner.CanReduceCost(null, card))
                         {
                             ContinuousController.instance.PlaySE(GManager.instance.GetComponent<Effects>().BuffSE);
                         }
 
                         ChangeCostClass changeCostClass = new ChangeCostClass();
-                        changeCostClass.SetUpICardEffect("Play Cost -4", CanUseCondition1, card);
+                        changeCostClass.SetUpICardEffect($"Play Cost {-4 * digivolutionCards.Count}", CanUseCondition1, card);
                         changeCostClass.SetUpChangeCostClass(changeCostFunc: ChangeCost, cardSourceCondition: CardSourceCondition, rootCondition: RootCondition, isUpDown: isUpDown, isCheckAvailability: () => false, isChangePayingCost: () => true);
                         card.Owner.UntilCalculateFixedCostEffect.Add((_timing) => changeCostClass);
 
@@ -244,15 +239,11 @@ namespace DCGO.CardEffects.BT15
 
                         int ChangeCost(CardSource cardSource, int Cost, SelectCardEffect.Root root, List<Permanent> targetPermanents)
                         {
-                            if (CardSourceCondition(cardSource))
+                            if (CardSourceCondition(cardSource)
+                            && RootCondition(root)
+                            && PermanentsCondition(targetPermanents))
                             {
-                                if (RootCondition(root))
-                                {
-                                    if (PermanentsCondition(targetPermanents))
-                                    {
-                                        Cost -= cardSources.Count * 4;
-                                    }
-                                }
+                                Cost -= digivolutionCards.Count * 4;
                             }
 
                             return Cost;
@@ -260,19 +251,8 @@ namespace DCGO.CardEffects.BT15
 
                         bool PermanentsCondition(List<Permanent> targetPermanents)
                         {
-                            if (targetPermanents == null)
-                            {
-                                return true;
-                            }
-                            else
-                            {
-                                if (targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0)
-                                {
-                                    return true;
-                                }
-                            }
-
-                            return false;
+                            return targetPermanents == null
+                                    || targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0;
                         }
 
                         bool CardSourceCondition(CardSource cardSource)
@@ -291,16 +271,12 @@ namespace DCGO.CardEffects.BT15
                         }
 
                         yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ShowReducedCost(_hashtable));
-
-                        yield return null;
                     }
                 }
             }
-
             #endregion
 
             #region Reduce Play Cost - Not Shown
-
             if (timing == EffectTiming.None)
             {
                 ChangeCostClass changeCostClass = new ChangeCostClass();
@@ -311,49 +287,34 @@ namespace DCGO.CardEffects.BT15
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    if (cardSource.IsDigimon)
-                    {
-                        if (cardSource.CardTraits.Contains("Dark Masters") || cardSource.CardTraits.Contains("DarkMasters"))
-                        {
-                            return true;
-                        }
-                    }
+                    return cardSource.EqualsTraits("Dark Masters");
+                }
 
-                    return false;
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    return CanSelectCardCondition(permanent.TopCard);
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if (card.Owner.HandCards.Contains(card))
-                    {
-                        ICardEffect activateClass = card.EffectList(EffectTiming.BeforePayCost).Find(cardEffect => cardEffect.EffectName == "Placing 1 [Dark Masters] to get Play Cost -4");
+                    ICardEffect activateClass = card.EffectList(EffectTiming.BeforePayCost).Find(cardEffect => cardEffect.EffectName == "Placing 1 [Dark Masters] to get Play Cost -4");
 
-                        if (activateClass != null)
-                        {
-                            if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
-                            {
-                                return true;
-                            }
-                        }
-                    }
-
-                    return false;
+                    return activateClass != null
+                        && (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition)
+                            || CardEffectCommons.HasMatchConditionOwnersPermanent(card, CanSelectPermanentCondition));
                 }
 
                 int ChangeCost(CardSource cardSource, int Cost, SelectCardEffect.Root root, List<Permanent> targetPermanents)
                 {
-                    if (CardSourceCondition(cardSource))
+                    if (CardSourceCondition(cardSource)
+                    && RootCondition(root)
+                    && PermanentsCondition(targetPermanents))
                     {
-                        if (RootCondition(root))
-                        {
-                            if (PermanentsCondition(targetPermanents))
-                            {
-                                List<CardSource> trashSources = card.Owner.TrashCards.Filter(CanSelectCardCondition);
-                                int targetCount = (from trashCard in trashSources select trashCard.CardID).Distinct().Count();
+                        List<CardSource> validCards = card.Owner.GetBattleAreaDigimons().Filter(CanSelectPermanentCondition).Map(permanent => permanent.TopCard);
+                        validCards.AddRange(card.Owner.TrashCards.Filter(CanSelectCardCondition));
+                        int targetCount = Math.Min(3, Combinations.GetUniqueNameCardCount(validCards));
 
-                                Cost -= targetCount * 4;
-                            }
-                        }
+                        Cost -= targetCount * 4;
                     }
 
                     return Cost;
@@ -361,32 +322,14 @@ namespace DCGO.CardEffects.BT15
 
                 bool PermanentsCondition(List<Permanent> targetPermanents)
                 {
-                    if (targetPermanents == null)
-                    {
-                        return true;
-                    }
-                    else
-                    {
-                        if (targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
+                    return targetPermanents == null
+                            || targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0;
                 }
 
                 bool CardSourceCondition(CardSource cardSource)
                 {
-                    if (cardSource != null)
-                    {
-                        if (cardSource == card)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
+                    return cardSource != null
+                        && cardSource == card;
                 }
 
                 bool RootCondition(SelectCardEffect.Root root)
@@ -399,191 +342,155 @@ namespace DCGO.CardEffects.BT15
                     return true;
                 }
             }
-
             #endregion
 
             #region End of Your Turn
-
             if (timing == EffectTiming.OnEndTurn)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Place 1 digimon from trash under this Digimon's digivolution cards", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+                activateClass.SetUpICardEffect("Place 1 digimon from trash under this Digimon's digivolution cards and activate one of it's [On Play] effects", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDescription());
+                activateClass.SetIsDigimonEffect(true);
                 cardEffects.Add(activateClass);
 
-                string EffectDiscription()
+                string EffectDescription()
                 {
                     return "[End of Your Turn] [Once Per Turn] By placing 1 level 6 or lower card from your trash as this Digimon's bottom digivolution card, activate 1 [On Play] effect on that card as an effect. Then, trash the top 2 cards of your opponent's deck for each of this Digimon's level 6 digivolution cards.";
                 }
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    if (cardSource.IsDigimon)
-                    {
-                        if (cardSource.HasLevel)
-                        {
-                            if (cardSource.Level <= 6)
-                            {
-                                return true;
-                            }
-                        }
-                    }
-
-                    return false;
+                    return cardSource.HasLevel
+                        && cardSource.Level <= 6;
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if (CardEffectCommons.IsOwnerTurn(card))
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
+                    return CardEffectCommons.IsExistOnBattleAreaTrigger(card, activateClass)
+                        && CardEffectCommons.IsOwnerTurn(card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
+                    return CardEffectCommons.IsExistOnBattleAreaActivate(card, activateClass)
+                        && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
-                        {
-                            int maxCount = Math.Min(1, card.Owner.TrashCards.Count((cardSource) => CanSelectCardCondition(cardSource)));
-
-                            List<CardSource> selectedCards = new List<CardSource>();
-
-                            IEnumerator SelectCardCoroutine(CardSource cardSource)
-                            {
-                                selectedCards.Add(cardSource);
+                    List<CardSource> selectedCards = new List<CardSource>();
 
-                                yield return null;
-                            }
+                    IEnumerator SelectCardCoroutine(CardSource cardSource)
+                    {
+                        selectedCards.Add(cardSource);
 
-                            SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+                        yield return null;
+                    }
 
-                            selectCardEffect.SetUp(
-                                canTargetCondition: CanSelectCardCondition,
-                                canTargetCondition_ByPreSelecetedList: null,
-                                canEndSelectCondition: null,
-                                canNoSelect: () => true,
-                                selectCardCoroutine: SelectCardCoroutine,
-                                afterSelectCardCoroutine: null,
-                                message: "Select 1 card to place on bottom of digivolution cards.",
-                                maxCount: maxCount,
-                                canEndNotMax: false,
-                                isShowOpponent: true,
-                                mode: SelectCardEffect.Mode.Custom,
-                                root: SelectCardEffect.Root.Trash,
-                                customRootCardList: null,
-                                canLookReverseCard: true,
-                                selectPlayer: card.Owner,
-                                cardEffect: activateClass);
+                    SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                    selectCardEffect.SetUp(
+                        canTargetCondition: CanSelectCardCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        canNoSelect: () => true,
+                        selectCardCoroutine: SelectCardCoroutine,
+                        afterSelectCardCoroutine: null,
+                        message: "Select 1 card to place on bottom of digivolution cards.",
+                        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 on bottom of digivolution cards.",
+                        "The opponent is selecting 1 card to place on bottom of digivolution cards.");
+                    selectCardEffect.SetUpCustomMessage_ShowCard("Digivolution Card");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                    CardSource selectedCard = null;
+
+                    if (selectedCards.Count >= 1)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(
+                            selectedCards,
+                            activateClass));
 
-                            selectCardEffect.SetUpCustomMessage(
-                                "Select 1 card to place on bottom of digivolution cards.",
-                                "The opponent is selecting 1 card to place on bottom of digivolution cards.");
-                            selectCardEffect.SetUpCustomMessage_ShowCard("Digivolution Card");
+                        selectedCard = selectedCards[0];
+                    }
 
-                            yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+                    if (selectedCard != null)
+                    {
+                        List<ICardEffect> candidateEffects = selectedCard.EffectList_ForCard(EffectTiming.OnEnterFieldAnyone, card)
+                            .Clone()
+                            .Filter(cardEffect => cardEffect != null && cardEffect is ActivateICardEffect && !cardEffect.IsSecurityEffect && cardEffect.IsOnPlay);
 
-                            CardSource selectedCard = null;
+                        if (candidateEffects.Count >= 1)
+                        {
+                            ICardEffect selectedEffect = null;
 
-                            if (selectedCards.Count >= 1)
+                            if (candidateEffects.Count == 1)
                             {
-                                if (CardEffectCommons.IsExistOnBattleArea(card))
-                                {
-                                    yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(
-                                        selectedCards,
-                                        activateClass));
-
-                                    selectedCard = selectedCards[0];
-                                }
+                                selectedEffect = candidateEffects[0];
                             }
-
-                            if (selectedCard != null)
+                            else
                             {
-                                List<ICardEffect> candidateEffects = selectedCard.EffectList_ForCard(EffectTiming.OnEnterFieldAnyone, card)
-                                    .Clone()
-                                    .Filter(cardEffect => cardEffect != null && cardEffect is ActivateICardEffect && !cardEffect.IsSecurityEffect && cardEffect.IsOnPlay);
-
-                                if (candidateEffects.Count >= 1)
+                                List<SkillInfo> skillInfos = candidateEffects
+                                    .Map(cardEffect => new SkillInfo(cardEffect, null, EffectTiming.None));
+
+                                List<CardSource> cardSources = candidateEffects
+                                    .Map(cardEffect => cardEffect.EffectSourceCard);
+
+                                SelectCardEffect selectSourceCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                                selectSourceCardEffect.SetUp(
+                                    canTargetCondition: (cardSource) => true,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    canNoSelect: () => false,
+                                    selectCardCoroutine: null,
+                                    afterSelectCardCoroutine: null,
+                                    message: "Select 1 effect to activate.",
+                                    maxCount: 1,
+                                    canEndNotMax: false,
+                                    isShowOpponent: false,
+                                    mode: SelectCardEffect.Mode.Custom,
+                                    root: SelectCardEffect.Root.Custom,
+                                    customRootCardList: cardSources,
+                                    canLookReverseCard: true,
+                                    selectPlayer: card.Owner,
+                                    cardEffect: activateClass);
+
+                                selectSourceCardEffect.SetNotShowCard();
+                                selectSourceCardEffect.SetUpSkillInfos(skillInfos);
+                                selectSourceCardEffect.SetUpAfterSelectIndexCoroutine(AfterSelectIndexCoroutine);
+
+                                yield return ContinuousController.instance.StartCoroutine(selectSourceCardEffect.Activate());
+
+                                IEnumerator AfterSelectIndexCoroutine(List<int> selectedIndexes)
                                 {
-                                    ICardEffect selectedEffect = null;
-
-                                    if (candidateEffects.Count == 1)
-                                    {
-                                        selectedEffect = candidateEffects[0];
-                                    }
-                                    else
+                                    if (selectedIndexes.Count == 1)
                                     {
-                                        List<SkillInfo> skillInfos = candidateEffects
-                                            .Map(cardEffect => new SkillInfo(cardEffect, null, EffectTiming.None));
-
-                                        List<CardSource> cardSources = candidateEffects
-                                            .Map(cardEffect => cardEffect.EffectSourceCard);
-
-                                        SelectCardEffect selectSourceCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
-
-                                        selectSourceCardEffect.SetUp(
-                                            canTargetCondition: (cardSource) => true,
-                                            canTargetCondition_ByPreSelecetedList: null,
-                                            canEndSelectCondition: null,
-                                            canNoSelect: () => false,
-                                            selectCardCoroutine: null,
-                                            afterSelectCardCoroutine: null,
-                                            message: "Select 1 effect to activate.",
-                                            maxCount: 1,
-                                            canEndNotMax: false,
-                                            isShowOpponent: false,
-                                            mode: SelectCardEffect.Mode.Custom,
-                                            root: SelectCardEffect.Root.Custom,
-                                            customRootCardList: cardSources,
-                                            canLookReverseCard: true,
-                                            selectPlayer: card.Owner,
-                                            cardEffect: activateClass);
-
-                                        selectSourceCardEffect.SetNotShowCard();
-                                        selectSourceCardEffect.SetUpSkillInfos(skillInfos);
-                                        selectSourceCardEffect.SetUpAfterSelectIndexCoroutine(AfterSelectIndexCoroutine);
-
-                                        yield return ContinuousController.instance.StartCoroutine(selectSourceCardEffect.Activate());
-
-                                        IEnumerator AfterSelectIndexCoroutine(List<int> selectedIndexes)
-                                        {
-                                            if (selectedIndexes.Count == 1)
-                                            {
-                                                selectedEffect = candidateEffects[selectedIndexes[0]];
-                                                yield return null;
-                                            }
-                                        }
+                                        selectedEffect = candidateEffects[selectedIndexes[0]];
+                                        yield return null;
                                     }
+                                }
+                            }
 
-                                    if (selectedEffect != null)
-                                    {
-                                        Hashtable effectHashtable = CardEffectCommons.OnPlayCheckHashtableOfCard(card);
+                            if (selectedEffect != null)
+                            {
+                                Hashtable effectHashtable = CardEffectCommons.OnPlayCheckHashtableOfCard(card);
 
-                                        if (selectedEffect.CanUse(effectHashtable))
-                                        {
-                                            yield return ContinuousController.instance.StartCoroutine(
-                                                ((ActivateICardEffect)selectedEffect).Activate_Optional_Effect_Execute(effectHashtable));
-                                        }
-                                    }
+                                if (selectedEffect.CanUse(effectHashtable))
+                                {
+                                    yield return ContinuousController.instance.StartCoroutine(
+                                        ((ActivateICardEffect)selectedEffect).Activate_Optional_Effect_Execute(effectHashtable));
                                 }
                             }
                         }
@@ -594,7 +501,6 @@ namespace DCGO.CardEffects.BT15
                     yield return ContinuousController.instance.StartCoroutine(new IAddTrashCardsFromLibraryTop(trashCount, card.Owner.Enemy, activateClass).AddTrashCardsFromLibraryTop());
                 }
             }
-
             #endregion
 
             return cardEffects;

Assets/Scripts/CardEffect/BT19/Black/BT19_063.cs

@@ -272,6 +272,31 @@ namespace DCGO.CardEffects.BT19
                             yield return ContinuousController.instance.StartCoroutine(new IDegeneration(permanent, 1, activateClass).Degeneration());
                         }
                     }
+
+                    if (CardEffectCommons.IsDijiXros(_hashtable, card, (count) => count == 2))
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(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: true,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: null,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Destroy,
+                                cardEffect: activateClass);
+
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                        }
+                    }
                 }
             }
             #endregion

Assets/Scripts/CardEffect/BT25/Purple/BT25_080.cs

@@ -100,7 +100,9 @@ namespace DCGO.CardEffects.BT25
                             yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
                         }
 
-                        if (CardEffectCommons.IsByEffect(hashtable, null) && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectPermanentCondition))
+                        if (CardEffectCommons.IsByEffect(hashtable, null)
+                        && CardEffectCommons.CanTriggerOnPlay(hashtable, card)
+                        && CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                         {
                             SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
 
@@ -122,7 +124,7 @@ namespace DCGO.CardEffects.BT25
                     }
                     else activateClass.RemoveUse();
                 }
-                
+
             }
             #endregion
 
@@ -188,4 +190,4 @@ namespace DCGO.CardEffects.BT25
             return cardEffects;
         }
     }
-}
+}

Assets/Scripts/CardEffect/EX10/Black/EX10_035.cs

@@ -223,11 +223,6 @@ namespace DCGO.CardEffects.EX10
                 return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
             }
 
-            bool CanActivateSharedCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.IsExistOnBattleArea(card);
-            }
-
             IEnumerator SharedActivateCoroutine(Hashtable _hashtable, ActivateClass activateClass)
             {
                 if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))

Assets/Scripts/CardEffect/P/Red/P_220.cs

@@ -195,11 +195,6 @@ namespace DCGO.CardEffects.P
                 return $"[{tag}] <De-Digivolve 2> 1 of your opponent's Digimon. Then, you may delete 1 Digimon.";
             }
 
-            bool SharedCanActivateCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.IsExistOnBattleArea(card);
-            }
-
             bool PermanentSelectCondition(Permanent permanent)
             {
                 return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);

Assets/Scripts/Script/SelectDNACondition.cs

@@ -17,7 +17,6 @@ public class SelectDNACondition : MonoBehaviourPunCallbacks
         _targetDNA = targetDNA;
         _selectDNACoroutine = SelectDNACoroutine;
         _notDoSync = false;
-        _isDigivolutionCost = false;
         _isLocal = IsLocal;
 }
 
@@ -27,7 +26,6 @@ public class SelectDNACondition : MonoBehaviourPunCallbacks
     List<int> _candidates = new List<int>();
     public int _selectedCount = 0;
     bool _notDoSync = false;
-    bool _isDigivolutionCost = false;
     bool _isLocal = false;
 
     public void ResetSelectDNAConditionClass()