Implement 055, 056, 059

Assets/CardEffect/EX10/Purple/EX10_055.cs

@@ -0,0 +1,458 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+// Tactimon
+namespace DCGO.CardEffects.EX10
+{
+    public class EX10_055 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region DigiXros
+
+            if (timing == EffectTiming.None)
+            {
+                AddDigiXrosConditionClass addDigiXrosConditionClass = new AddDigiXrosConditionClass();
+                addDigiXrosConditionClass.SetUpICardEffect($"DigiXros", CanUseCondition, card);
+                addDigiXrosConditionClass.SetUpAddDigiXrosConditionClass(getDigiXrosCondition: GetDigiXros);
+                addDigiXrosConditionClass.SetNotShowUI(true);
+                cardEffects.Add(addDigiXrosConditionClass);
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return true;
+                }
+
+                DigiXrosCondition GetDigiXros(CardSource cardSource)
+                {
+                    if (cardSource == card)
+                    {
+                        bool CanSelectCardCondition(CardSource cardSource)
+                        {
+                            if (cardSource != null)
+                            {
+                                if (cardSource.Owner == card.Owner)
+                                {
+                                    if (cardSource.IsDigimon)
+                                    {
+                                        if (cardSource.CardTraits.Contains("BagraArmy"))
+                                        {
+                                            return true;
+                                        }
+
+                                        if (cardSource.CardTraits.Contains("Bagra Army"))
+                                        {
+                                            return true;
+                                        }
+                                    }
+                                }
+                            }
+
+                            return false;
+                        }
+
+                        DigiXrosConditionElement element = new DigiXrosConditionElement(CanSelectCardCondition, "[Bagra Army] Digimon");
+                        List<DigiXrosConditionElement> elements = new List<DigiXrosConditionElement>();
+
+                        for (int i = 0; i < 2; i++)
+                        {
+                            elements.Add(element);
+                        }
+
+                        DigiXrosCondition digiXrosCondition = new DigiXrosCondition(elements, null, 2);
+
+                        return digiXrosCondition;
+                    }
+
+                    return null;
+                }
+            }
+
+            #endregion
+
+            #region On Play
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Choose 1 of your digimon, delete it and 1 opponent digimon with equal or less level", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[On Play] You may choose 1 of your Digimon. Delete the chosen Digimon and 1 of your opponent’s Digimon with as high or lower a level as it.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                }
+
+                bool IsYourDigimon(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
+                }
+
+                bool IsOpponentDigimon(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                }
+
+                bool CanSelectOpponentDigimon(Permanent permanent, Permanent yourDigimon)
+                {
+                    return IsOpponentDigimon(permanent)
+                        && permanent.TopCard.HasLevel
+                        && permanent.TopCard.Level <= yourDigimon.Level;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, IsYourDigimon))
+                    {
+                        Permanent selectedYourDigimon = null;
+
+                        #region Select Your Digimon to Destroy
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOwnersPermanentCount(card, IsYourDigimon));
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: IsYourDigimon,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            selectedYourDigimon = permanent;
+                            yield return null;
+                        }
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to destroy", "The opponent is selecting 1 Digimon to destroy");
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        #endregion
+
+                        if (selectedYourDigimon != null && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, opponentDigimon => CanSelectOpponentDigimon(opponentDigimon, selectedYourDigimon)))
+                        {
+                            Permanent selectedOpponentDigimon = null;
+
+                            #region Select Opponent Digimon to Destroy
+
+                            SelectPermanentEffect selectPermanentEffect1 = GManager.instance.GetComponent<SelectPermanentEffect>();
+                            int maxCount1 = Math.Min(1, CardEffectCommons.MatchConditionOpponentsPermanentCount(card, opponentDigimon => CanSelectOpponentDigimon(opponentDigimon, selectedYourDigimon)));
+
+                            selectPermanentEffect1.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: opponentDigimon => CanSelectOpponentDigimon(opponentDigimon, selectedYourDigimon),
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount1,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: SelectPermanentCoroutine1,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+
+                            IEnumerator SelectPermanentCoroutine1(Permanent permanent)
+                            {
+                                selectedOpponentDigimon = permanent;
+                                yield return null;
+                            }
+
+                            selectPermanentEffect1.SetUpCustomMessage("Select 1 Digimon to destroy", "The opponent is selecting 1 Digimon to destroy");
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect1.Activate());
+
+                            #endregion
+
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(
+                                targetPermanents: new List<Permanent> { selectedYourDigimon },
+                                activateClass: activateClass,
+                                successProcess: SuccessProcess,
+                                failureProcess: null));
+
+                            IEnumerator SuccessProcess(List<Permanent> deletedPermanents)
+                            {
+                                if (selectedOpponentDigimon != null)
+                                {
+                                    yield return ContinuousController.instance.StartCoroutine(new DestroyPermanentsClass(
+                                        destroyTargetPermanents: new List<Permanent>() { selectedOpponentDigimon },
+                                        hashtable).Destroy());
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            #region When Digivolving
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Choose 1 of your digimon, delete it and 1 opponent digimon with equal or less level", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] You may choose 1 of your Digimon. Delete the chosen Digimon and 1 of your opponent’s Digimon with as high or lower a level as it.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                }
+
+                bool IsYourDigimon(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
+                }
+
+                bool IsOpponentDigimon(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                }
+
+                bool CanSelectOpponentDigimon(Permanent permanent, Permanent yourDigimon)
+                {
+                    return IsOpponentDigimon(permanent)
+                        && permanent.TopCard.HasLevel
+                        && permanent.TopCard.Level <= yourDigimon.Level;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, IsYourDigimon))
+                    {
+                        Permanent selectedYourDigimon = null;
+
+                        #region Select Your Digimon to Destroy
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOwnersPermanentCount(card, IsYourDigimon));
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: IsYourDigimon,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            selectedYourDigimon = permanent;
+                            yield return null;
+                        }
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to destroy", "The opponent is selecting 1 Digimon to destroy");
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        #endregion
+
+                        if (selectedYourDigimon != null && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, opponentDigimon => CanSelectOpponentDigimon(opponentDigimon, selectedYourDigimon)))
+                        {
+                            Permanent selectedOpponentDigimon = null;
+
+                            #region Select Opponent Digimon to Destroy
+
+                            SelectPermanentEffect selectPermanentEffect1 = GManager.instance.GetComponent<SelectPermanentEffect>();
+                            int maxCount1 = Math.Min(1, CardEffectCommons.MatchConditionOpponentsPermanentCount(card, opponentDigimon => CanSelectOpponentDigimon(opponentDigimon, selectedYourDigimon)));
+
+                            selectPermanentEffect1.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: opponentDigimon => CanSelectOpponentDigimon(opponentDigimon, selectedYourDigimon),
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount1,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: SelectPermanentCoroutine1,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+
+                            IEnumerator SelectPermanentCoroutine1(Permanent permanent)
+                            {
+                                selectedOpponentDigimon = permanent;
+                                yield return null;
+                            }
+
+                            selectPermanentEffect1.SetUpCustomMessage("Select 1 Digimon to destroy", "The opponent is selecting 1 Digimon to destroy");
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect1.Activate());
+
+                            #endregion
+
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(
+                                targetPermanents: new List<Permanent> { selectedYourDigimon },
+                                activateClass: activateClass,
+                                successProcess: SuccessProcess,
+                                failureProcess: null));
+
+                            IEnumerator SuccessProcess(List<Permanent> deletedPermanents)
+                            {
+                                if (selectedOpponentDigimon != null)
+                                {
+                                    yield return ContinuousController.instance.StartCoroutine(new DestroyPermanentsClass(
+                                        destroyTargetPermanents: new List<Permanent>() { selectedOpponentDigimon },
+                                        hashtable).Destroy());
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            #region All Turns - Once Per Turn
+
+            if (timing == EffectTiming.WhenRemoveField)
+            {
+                List<Permanent> removedPermanents = new List<Permanent>();
+
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Trash 2 source cards, prevent deletion", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
+                activateClass.SetHashString("EX10_055_Subsitute");
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[All Turns] [Once Per Turn] When any of your [Bagra Army] trait Digimon would leave the battle area by effects, by trashing any 2 of this Digimon's digivolution cards, they don't leave.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && CardEffectCommons.CanTriggerWhenPermanentRemoveField(hashtable, IsBagraArmyDigimon)
+                        && CardEffectCommons.IsByEffect(hashtable, null);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    removedPermanents = CardEffectCommons.GetPermanentsFromHashtable(hashtable).Filter(IsBagraArmyDigimon);
+
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && card.PermanentOfThisCard().StackCards.Count >= 2;
+                }
+
+                bool IsBagraArmyDigimon(Permanent permanent)
+                {
+                    return permanent.IsDigimon && permanent.TopCard.HasBagraArmyTraits;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (card.PermanentOfThisCard().StackCards.Count >= 2)
+                    {
+                        Permanent thisPermanent = card.PermanentOfThisCard();
+                        List<CardSource> selectedCards = new List<CardSource>();
+
+                        #region Trash Digivolution Cards
+
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                        selectCardEffect.SetUp(
+                                    canTargetCondition: _ => true,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    canNoSelect: () => true,
+                                    selectCardCoroutine: SelectCardCoroutine,
+                                    afterSelectCardCoroutine: null,
+                                    message: "Select 2 digivolution cards to trash.",
+                                    maxCount: 2,
+                                    canEndNotMax: false,
+                                    isShowOpponent: true,
+                                    mode: SelectCardEffect.Mode.Custom,
+                                    root: SelectCardEffect.Root.Custom,
+                                    customRootCardList: thisPermanent.DigivolutionCards,
+                                    canLookReverseCard: true,
+                                    selectPlayer: card.Owner,
+                                    cardEffect: activateClass);
+
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            selectedCards.Add(cardSource);
+                            yield return null;
+                        }
+
+                        selectCardEffect.SetUpCustomMessage("Select 2 digivolution cards to trash.", "The opponent is selecting 2 digivolution cards to trash.");
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                        #endregion
+
+                        if (selectedCards.Count == 2)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.TrashDigivolutionCardsAndProcessAccordingToResult(
+                                targetPermanent: thisPermanent,
+                                targetDigivolutionCards: selectedCards,
+                                activateClass: activateClass,
+                                successProcess: SuccessProcess,
+                                failureProcess: null));
+
+                            IEnumerator SuccessProcess(List<CardSource> trashedSources)
+                            {
+                                foreach (Permanent permanent in removedPermanents)
+                                {
+                                    #region Remove Events from Permanent
+
+                                    permanent.HideDeleteEffect();
+                                    permanent.HideHandBounceEffect();
+                                    permanent.HideDeckBounceEffect();
+                                    permanent.HideWillRemoveFieldEffect();
+
+                                    permanent.DestroyingEffect = null;
+                                    permanent.IsDestroyedByBattle = false;
+                                    permanent.HandBounceEffect = null;
+                                    permanent.LibraryBounceEffect = null;
+                                    permanent.willBeRemoveField = false;
+
+                                    #endregion
+                                }
+
+                                yield return null;
+                            }
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX10/Purple/EX10_055.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a1c2265c223d4db419c7d764b0c235ba
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CardEffect/EX10/Purple/EX10_056.cs

@@ -0,0 +1,531 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+// Bagramon
+namespace DCGO.CardEffects.EX10
+{
+    public class EX10_056 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region DigiXros
+
+            if (timing == EffectTiming.None)
+            {
+                AddDigiXrosConditionClass addDigiXrosConditionClass = new AddDigiXrosConditionClass();
+                addDigiXrosConditionClass.SetUpICardEffect($"DigiXros", CanUseCondition, card);
+                addDigiXrosConditionClass.SetUpAddDigiXrosConditionClass(getDigiXrosCondition: GetDigiXros);
+                addDigiXrosConditionClass.SetNotShowUI(true);
+                cardEffects.Add(addDigiXrosConditionClass);
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return true;
+                }
+
+                DigiXrosCondition GetDigiXros(CardSource cardSource)
+                {
+                    if (cardSource == card)
+                    {
+                        bool CanSelectCardCondition(CardSource cardSource)
+                        {
+                            if (cardSource != null)
+                            {
+                                if (cardSource.Owner == card.Owner)
+                                {
+                                    if (cardSource.IsDigimon)
+                                    {
+                                        if (cardSource.CardTraits.Contains("BagraArmy"))
+                                        {
+                                            return true;
+                                        }
+
+                                        if (cardSource.CardTraits.Contains("Bagra Army"))
+                                        {
+                                            return true;
+                                        }
+                                    }
+                                }
+                            }
+
+                            return false;
+                        }
+
+                        DigiXrosConditionElement element = new DigiXrosConditionElement(CanSelectCardCondition, "[Bagra Army] Digimon");
+                        List<DigiXrosConditionElement> elements = new List<DigiXrosConditionElement>();
+
+                        for (int i = 0; i < 2; i++)
+                        {
+                            elements.Add(element);
+                        }
+
+                        DigiXrosCondition digiXrosCondition = new DigiXrosCondition(elements, null, 2);
+
+                        return digiXrosCondition;
+                    }
+
+                    return null;
+                }
+            }
+
+            #endregion
+
+            #region On Play
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Place 1 opponent digimon under a digimon or tamer", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[On Play] You may place 1 of your opponent's Digimon as any of their other Digimon's bottom digivolution card or under any of their Tamers.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && HasValidEnemyPermanents();
+                }
+
+                bool HasValidEnemyPermanents()
+                {
+                    int digimon = card.Owner.Enemy.GetBattleAreaDigimons().Count;
+                    int tamers = card.Owner.Enemy.GetBattleAreaPermanents().Filter(x => x.IsTamer).Count;
+
+                    return digimon >= 1 && digimon + tamers >= 2;
+                }
+
+                bool IsEnemyDigimon(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                }
+
+                bool IsEnemyPermanent(Permanent permanent, Permanent targetPermament)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card)
+                        && permanent != targetPermament;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (HasValidEnemyPermanents())
+                    {
+                        Permanent selectedPermamentToSource = null;
+
+                        #region Select Enemy Digimon to add as Source
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOwnersPermanentCount(card, IsEnemyDigimon));
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: IsEnemyDigimon,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            selectedPermamentToSource = permanent;
+                            yield return null;
+                        }
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to move under a digimon/tamer", "The opponent is selecting 1 Digimon move under a digimon/tamer");
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        #endregion
+
+                        if (selectedPermamentToSource != null && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, permament => IsEnemyPermanent(permament, selectedPermamentToSource)))
+                        {
+                            Permanent selectedPermanent = null;
+
+                            #region Select Enemy Permament to add source
+
+                            SelectPermanentEffect selectPermanentEffect1 = GManager.instance.GetComponent<SelectPermanentEffect>();
+                            int maxCount1 = Math.Min(1, CardEffectCommons.MatchConditionOwnersPermanentCount(card, permament => IsEnemyPermanent(permament, selectedPermamentToSource)));
+
+                            selectPermanentEffect1.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: permament => IsEnemyPermanent(permament, selectedPermamentToSource),
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount1,
+                                canNoSelect: true,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: SelectPermanentCoroutine1,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+
+                            IEnumerator SelectPermanentCoroutine1(Permanent permanent)
+                            {
+                                selectedPermanent = permanent;
+                                yield return null;
+                            }
+
+                            selectPermanentEffect1.SetUpCustomMessage("Select 1 Digimon or tamer to add the source card underneath", "The opponent is selecting 1 Digimon or tamer to add the source card underneath");
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect1.Activate());
+
+                            #endregion
+
+                            if (selectedPermanent != null)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(new IPlacePermanentToDigivolutionCards(
+                                    permanentArrays: new List<Permanent[]>() { new Permanent[] { selectedPermanent, selectedPermamentToSource } },
+                                    toTop: false,
+                                    cardEffect: activateClass).PlacePermanentToDigivolutionCards());
+                            }
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            #region When Digivolving
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Place 1 opponent digimon under a digimon or tamer", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] You may place 1 of your opponent's Digimon as any of their other Digimon's bottom digivolution card or under any of their Tamers.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && HasValidEnemyPermanents();
+                }
+
+                bool HasValidEnemyPermanents()
+                {
+                    int digimon = card.Owner.Enemy.GetBattleAreaDigimons().Count;
+                    int tamers = card.Owner.Enemy.GetBattleAreaPermanents().Filter(x => x.IsTamer).Count;
+
+                    return digimon >= 1 && digimon + tamers >= 2;
+                }
+
+                bool IsEnemyDigimon(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                }
+
+                bool IsEnemyPermanent(Permanent permanent, Permanent targetPermament)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card)
+                        && permanent != targetPermament;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (HasValidEnemyPermanents())
+                    {
+                        Permanent selectedPermamentToSource = null;
+
+                        #region Select Enemy Digimon to add as Source
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOwnersPermanentCount(card, IsEnemyDigimon));
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: IsEnemyDigimon,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            selectedPermamentToSource = permanent;
+                            yield return null;
+                        }
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to move under a digimon/tamer", "The opponent is selecting 1 Digimon move under a digimon/tamer");
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        #endregion
+
+                        if (selectedPermamentToSource != null && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, permament => IsEnemyPermanent(permament, selectedPermamentToSource)))
+                        {
+                            Permanent selectedPermanent = null;
+
+                            #region Select Enemy Permament to add source
+
+                            SelectPermanentEffect selectPermanentEffect1 = GManager.instance.GetComponent<SelectPermanentEffect>();
+                            int maxCount1 = Math.Min(1, CardEffectCommons.MatchConditionOwnersPermanentCount(card, permament => IsEnemyPermanent(permament, selectedPermamentToSource)));
+
+                            selectPermanentEffect1.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: permament => IsEnemyPermanent(permament, selectedPermamentToSource),
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount1,
+                                canNoSelect: true,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: SelectPermanentCoroutine1,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+
+                            IEnumerator SelectPermanentCoroutine1(Permanent permanent)
+                            {
+                                selectedPermanent = permanent;
+                                yield return null;
+                            }
+
+                            selectPermanentEffect1.SetUpCustomMessage("Select 1 Digimon or tamer to add the source card underneath", "The opponent is selecting 1 Digimon or tamer to add the source card underneath");
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect1.Activate());
+
+                            #endregion
+
+                            if (selectedPermanent != null)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(new IPlacePermanentToDigivolutionCards(
+                                    permanentArrays: new List<Permanent[]>() { new Permanent[] { selectedPermanent, selectedPermamentToSource } },
+                                    toTop: false,
+                                    cardEffect: activateClass).PlacePermanentToDigivolutionCards());
+                            }
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            #region All Turns - Once Per Turn
+
+            #region Digivolving
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("By trashing 2 source cards, trash opponent top security", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
+                activateClass.SetHashString("EX10_056_AllTurns");
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[All Turns] [Once Per Turn] When any of your opponent's Digimon or Tamers digivolve or effects place cards under them, by trashing any 2 of this Digimon's digivolution cards, trash your opponent's top security card.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && CardEffectCommons.CanTriggerWhenPermanentWouldDigivolve(hashtable, PermamentCondition, null);
+                }
+
+                bool PermamentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && card.PermanentOfThisCard().StackCards.Count >= 2;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (card.PermanentOfThisCard().StackCards.Count >= 2)
+                    {
+                        Permanent thisPermanent = card.PermanentOfThisCard();
+                        List<CardSource> selectedCards = new List<CardSource>();
+
+                        #region Trash Digivolution Cards
+
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                        selectCardEffect.SetUp(
+                                    canTargetCondition: _ => true,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    canNoSelect: () => true,
+                                    selectCardCoroutine: SelectCardCoroutine,
+                                    afterSelectCardCoroutine: null,
+                                    message: "Select 2 digivolution cards to trash.",
+                                    maxCount: 2,
+                                    canEndNotMax: false,
+                                    isShowOpponent: true,
+                                    mode: SelectCardEffect.Mode.Custom,
+                                    root: SelectCardEffect.Root.Custom,
+                                    customRootCardList: thisPermanent.DigivolutionCards,
+                                    canLookReverseCard: true,
+                                    selectPlayer: card.Owner,
+                                    cardEffect: activateClass);
+
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            selectedCards.Add(cardSource);
+                            yield return null;
+                        }
+
+                        selectCardEffect.SetUpCustomMessage("Select 2 digivolution cards to trash.", "The opponent is selecting 2 digivolution cards to trash.");
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                        #endregion
+
+                        if (selectedCards.Count == 2)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.TrashDigivolutionCardsAndProcessAccordingToResult(
+                                targetPermanent: thisPermanent,
+                                targetDigivolutionCards: selectedCards,
+                                activateClass: activateClass,
+                                successProcess: SuccessProcess,
+                                failureProcess: null));
+
+                            IEnumerator SuccessProcess(List<CardSource> trashedSources)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
+                                    player: card.Owner.Enemy,
+                                    destroySecurityCount: 1,
+                                    cardEffect: activateClass,
+                                    fromTop: true).DestroySecurity());
+                            }
+                        }
+                    }
+                    yield return null;
+                }
+            }
+
+            #endregion
+
+            #region Add Digivolution Cards
+
+            if (timing == EffectTiming.OnAddDigivolutionCards)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("By trashing 2 source cards, trash opponent top security", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
+                activateClass.SetHashString("EX10_056_AllTurns");
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[All Turns] [Once Per Turn] When any of your opponent's Digimon or Tamers digivolve or effects place cards under them, by trashing any 2 of this Digimon's digivolution cards, trash your opponent's top security card.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && CardEffectCommons.CanTriggerOnAddDigivolutionCard(hashtable, PermamentCondition, cardEffect => cardEffect.EffectSourceCard != null, null);
+                }
+
+                bool PermamentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && card.PermanentOfThisCard().StackCards.Count >= 2;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (card.PermanentOfThisCard().StackCards.Count >= 2)
+                    {
+                        Permanent thisPermanent = card.PermanentOfThisCard();
+                        List<CardSource> selectedCards = new List<CardSource>();
+
+                        #region Trash Digivolution Cards
+
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                        selectCardEffect.SetUp(
+                                    canTargetCondition: _ => true,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    canNoSelect: () => true,
+                                    selectCardCoroutine: SelectCardCoroutine,
+                                    afterSelectCardCoroutine: null,
+                                    message: "Select 2 digivolution cards to trash.",
+                                    maxCount: 2,
+                                    canEndNotMax: false,
+                                    isShowOpponent: true,
+                                    mode: SelectCardEffect.Mode.Custom,
+                                    root: SelectCardEffect.Root.Custom,
+                                    customRootCardList: thisPermanent.DigivolutionCards,
+                                    canLookReverseCard: true,
+                                    selectPlayer: card.Owner,
+                                    cardEffect: activateClass);
+
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            selectedCards.Add(cardSource);
+                            yield return null;
+                        }
+
+                        selectCardEffect.SetUpCustomMessage("Select 2 digivolution cards to trash.", "The opponent is selecting 2 digivolution cards to trash.");
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                        #endregion
+
+                        if (selectedCards.Count == 2)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.TrashDigivolutionCardsAndProcessAccordingToResult(
+                                targetPermanent: thisPermanent,
+                                targetDigivolutionCards: selectedCards,
+                                activateClass: activateClass,
+                                successProcess: SuccessProcess,
+                                failureProcess: null));
+
+                            IEnumerator SuccessProcess(List<CardSource> trashedSources)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
+                                    player: card.Owner.Enemy,
+                                    destroySecurityCount: 1,
+                                    cardEffect: activateClass,
+                                    fromTop: true).DestroySecurity());
+                            }
+                        }
+                    }
+                    yield return null;
+                }
+            }
+
+            #endregion
+
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX10/Purple/EX10_056.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d38f76d1b662e894fafe31941f042061
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CardEffect/EX10/Purple/EX10_059.cs

@@ -0,0 +1,544 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+// DarknessBagramon
+namespace DCGO.CardEffects.EX10
+{
+    public class EX10_059 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region DigiXros
+
+            if (timing == EffectTiming.None)
+            {
+                AddDigiXrosConditionClass addDigiXrosConditionClass = new AddDigiXrosConditionClass();
+                addDigiXrosConditionClass.SetUpICardEffect($"DigiXros -3", _ => true, card);
+                addDigiXrosConditionClass.SetUpAddDigiXrosConditionClass(getDigiXrosCondition: GetDigiXros);
+                addDigiXrosConditionClass.SetNotShowUI(true);
+                cardEffects.Add(addDigiXrosConditionClass);
+
+                DigiXrosCondition GetDigiXros(CardSource cardSource)
+                {
+                    if (cardSource == card)
+                    {
+                        DigiXrosConditionElement elementAgunimon =
+                            new DigiXrosConditionElement(CanSelectCardConditionBagramon, "Bagramon");
+
+                        bool CanSelectCardConditionBagramon(CardSource conditionCardSource)
+                        {
+                            if (conditionCardSource != null)
+                            {
+                                if (conditionCardSource.Owner == card.Owner)
+                                {
+                                    if (conditionCardSource.IsDigimon)
+                                    {
+                                        if (conditionCardSource.CardNames_DigiXros.Contains("Bagramon"))
+                                        {
+                                            return true;
+                                        }
+                                    }
+                                }
+                            }
+
+                            return false;
+                        }
+
+                        DigiXrosConditionElement elementBurningGreymon =
+                            new DigiXrosConditionElement(CanSelectCardConditionDarkKnightmon, "DarkKnightmon");
+
+                        bool CanSelectCardConditionDarkKnightmon(CardSource conditionCardSource)
+                        {
+                            if (conditionCardSource != null)
+                            {
+                                if (conditionCardSource.Owner == card.Owner)
+                                {
+                                    if (conditionCardSource.IsDigimon)
+                                    {
+                                        if (conditionCardSource.CardNames_DigiXros.Contains("DarkKnightmon"))
+                                        {
+                                            return true;
+                                        }
+                                    }
+                                }
+                            }
+
+                            return false;
+                        }
+
+                        List<DigiXrosConditionElement> elements = new List<DigiXrosConditionElement>()
+                            { elementAgunimon, elementBurningGreymon };
+
+                        DigiXrosCondition digiXrosCondition = new DigiXrosCondition(elements, null, 3);
+
+                        return digiXrosCondition;
+                    }
+
+                    return null;
+                }
+            }
+
+            #endregion
+
+            #region On Play
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Place 1 opponent hand card uneranth a digimon or tamer, then by placing 3 [Bagra Army] digimon from trash under this, delete 1 digimon/tamer with sources", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[On Play] Choose 1 card in your opponent's hand without looking and place it as any of their Digimon's bottom digivolution card or under any of their Tamers. Then, by placing 3 [Bagra Army] trait Digimon cards from your trash as this Digimon's top digivolution cards, delete 1 of their Digimon or Tamers with cards under it.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                }
+
+                bool IsOpponentPermament(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card);
+                }
+
+                bool IsOpponentPermamentWithSources(Permanent permanent)
+                {
+                    return IsOpponentPermament(permanent) && permanent.StackCards.Count >= 1;
+                }
+
+                bool IsBagraArmyDigimon(CardSource cardSource)
+                {
+                    return cardSource.IsDigimon && cardSource.HasBagraArmyTraits;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (card.Owner.Enemy.HandCards.Count >= 1 && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, IsOpponentPermament))
+                    {
+                        CardSource selectedHandCard = null;
+
+                        #region Select 1 card in opponent's hand
+
+                        if (card.Owner.isYou)
+                        {
+                            foreach (CardSource cardSource in card.Owner.Enemy.HandCards)
+                            {
+                                cardSource.SetReverse();
+                            }
+                        }
+
+                        card.Owner.Enemy.HandCards = RandomUtility.ShuffledDeckCards(card.Owner.Enemy.HandCards);
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                        selectCardEffect.SetUp(
+                            canTargetCondition: (cardSource) => true,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            canNoSelect: () => false,
+                            selectCardCoroutine: SelectCardCoroutine,
+                            afterSelectCardCoroutine: null,
+                            message: "Select 1 card in your opponent's hand to add as a source card.",
+                            maxCount: 1,
+                            canEndNotMax: false,
+                            isShowOpponent: false,
+                            mode: SelectCardEffect.Mode.Custom,
+                            root: SelectCardEffect.Root.Custom,
+                            customRootCardList: card.Owner.Enemy.HandCards,
+                            canLookReverseCard: false,
+                            selectPlayer: card.Owner,
+                            cardEffect: activateClass);
+
+                        selectCardEffect.SetNotShowCard();
+                        selectCardEffect.SetUseFaceDown();
+
+                        if (card.Owner.isYou)
+                        {
+                            selectCardEffect.SetNotAddLog();
+                        }
+
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            selectedHandCard = cardSource;
+                            yield return null;
+                        }
+
+                        selectCardEffect.SetUpCustomMessage("Select 1 card to add as a source card.", "The opponent is selecting 1 to add as a source card.");
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                        #endregion
+
+                        if (selectedHandCard != null)
+                        {
+                            Permanent selectedPermanent = null;
+
+                            #region Select Enemy Permament to add source
+
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOpponentsPermanentCount(card, IsOpponentPermament));
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: IsOpponentPermament,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: SelectPermanentCoroutine1,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+
+                            IEnumerator SelectPermanentCoroutine1(Permanent permanent)
+                            {
+                                selectedPermanent = permanent;
+                                yield return null;
+                            }
+
+                            selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon or tamer to add the source card underneath", "The opponent is selecting 1 Digimon or tamer to add the source card underneath");
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                            #endregion
+
+                            if (selectedPermanent != null) yield return ContinuousController.instance.StartCoroutine(selectedPermanent.AddDigivolutionCardsBottom(
+                                addedDigivolutionCards: new List<CardSource>() { selectedHandCard },
+                                cardEffect: activateClass));
+                        }
+                    }
+
+                    if (CardEffectCommons.MatchConditionOwnersCardCountInTrash(card, IsBagraArmyDigimon) >= 3
+                        && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, IsOpponentPermamentWithSources))
+                    {
+                        Permanent thisPermament = card.PermanentOfThisCard();
+                        List<CardSource> selectedCards = new List<CardSource>();
+
+                        #region Select 3 Bagra Army Digimon in Trash
+
+                        int maxCount = Math.Min(3, CardEffectCommons.MatchConditionOwnersCardCountInTrash(card, IsBagraArmyDigimon));
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                        selectCardEffect.SetUp(
+                            canTargetCondition: IsBagraArmyDigimon,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            canNoSelect: () => true,
+                            selectCardCoroutine: SelectCardCoroutine,
+                            afterSelectCardCoroutine: null,
+                            message: "Select 3 [Bagra Army] digimon",
+                            maxCount: maxCount,
+                            canEndNotMax: false,
+                            isShowOpponent: true,
+                            mode: SelectCardEffect.Mode.Custom,
+                            root: SelectCardEffect.Root.Trash,
+                            customRootCardList: null,
+                            canLookReverseCard: true,
+                            selectPlayer: card.Owner,
+                            cardEffect: activateClass);
+
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            selectedCards.Add(cardSource);
+                            yield return null;
+                        }
+
+                        selectCardEffect.SetUpCustomMessage("Select 3 [Bagra Army] digimon to add as source", "The opponent is selecting 3 [Bagra Army] digimon to add as source");
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                        #endregion
+
+                        if (selectedCards.Count == 3)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(thisPermament.AddDigivolutionCardsTop(
+                                addedDigivolutionCards: selectedCards,
+                                cardEffect: activateClass));
+
+                            #region Select Enemy Permament to add source
+
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                            int maxCount1 = Math.Min(1, CardEffectCommons.MatchConditionOpponentsPermanentCount(card, IsOpponentPermament));
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: IsOpponentPermament,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount1,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: null,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Destroy,
+                                cardEffect: activateClass);
+
+                            selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon or tamer with sources to destroy", "The opponent is selecting 1 Digimon or tamer with sources to destroy");
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                            #endregion
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            #region When Digivolving
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Place 1 opponent hand card uneranth a digimon or tamer, then by placing 3 [Bagra Army] digimon from trash under this, delete 1 digimon/tamer with sources", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] Choose 1 card in your opponent's hand without looking and place it as any of their Digimon's bottom digivolution card or under any of their Tamers. Then, by placing 3 [Bagra Army] trait Digimon cards from your trash as this Digimon's top digivolution cards, delete 1 of their Digimon or Tamers with cards under it.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                }
+
+                bool IsOpponentPermament(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card);
+                }
+
+                bool IsOpponentPermamentWithSources(Permanent permanent)
+                {
+                    return IsOpponentPermament(permanent) && permanent.StackCards.Count >= 1;
+                }
+
+                bool IsBagraArmyDigimon(CardSource cardSource)
+                {
+                    return cardSource.IsDigimon && cardSource.HasBagraArmyTraits;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (card.Owner.Enemy.HandCards.Count >= 1 && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, IsOpponentPermament))
+                    {
+                        CardSource selectedHandCard = null;
+
+                        #region Select 1 card in opponent's hand
+
+                        if (card.Owner.isYou)
+                        {
+                            foreach (CardSource cardSource in card.Owner.Enemy.HandCards)
+                            {
+                                cardSource.SetReverse();
+                            }
+                        }
+
+                        card.Owner.Enemy.HandCards = RandomUtility.ShuffledDeckCards(card.Owner.Enemy.HandCards);
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                        selectCardEffect.SetUp(
+                            canTargetCondition: (cardSource) => true,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            canNoSelect: () => false,
+                            selectCardCoroutine: SelectCardCoroutine,
+                            afterSelectCardCoroutine: null,
+                            message: "Select 1 card in your opponent's hand to add as a source card.",
+                            maxCount: 1,
+                            canEndNotMax: false,
+                            isShowOpponent: false,
+                            mode: SelectCardEffect.Mode.Custom,
+                            root: SelectCardEffect.Root.Custom,
+                            customRootCardList: card.Owner.Enemy.HandCards,
+                            canLookReverseCard: false,
+                            selectPlayer: card.Owner,
+                            cardEffect: activateClass);
+
+                        selectCardEffect.SetNotShowCard();
+                        selectCardEffect.SetUseFaceDown();
+
+                        if (card.Owner.isYou)
+                        {
+                            selectCardEffect.SetNotAddLog();
+                        }
+
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            selectedHandCard = cardSource;
+                            yield return null;
+                        }
+
+                        selectCardEffect.SetUpCustomMessage("Select 1 card to add as a source card.", "The opponent is selecting 1 to add as a source card.");
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                        #endregion
+
+                        if (selectedHandCard != null)
+                        {
+                            Permanent selectedPermanent = null;
+
+                            #region Select Enemy Permament to add source
+
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOpponentsPermanentCount(card, IsOpponentPermament));
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: IsOpponentPermament,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: SelectPermanentCoroutine1,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+
+                            IEnumerator SelectPermanentCoroutine1(Permanent permanent)
+                            {
+                                selectedPermanent = permanent;
+                                yield return null;
+                            }
+
+                            selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon or tamer to add the source card underneath", "The opponent is selecting 1 Digimon or tamer to add the source card underneath");
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                            #endregion
+
+                            if (selectedPermanent != null) yield return ContinuousController.instance.StartCoroutine(selectedPermanent.AddDigivolutionCardsBottom(
+                                addedDigivolutionCards: new List<CardSource>() { selectedHandCard },
+                                cardEffect: activateClass));
+                        }
+                    }
+
+                    if (CardEffectCommons.MatchConditionOwnersCardCountInTrash(card, IsBagraArmyDigimon) >= 3
+                        && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, IsOpponentPermamentWithSources))
+                    {
+                        Permanent thisPermament = card.PermanentOfThisCard();
+                        List<CardSource> selectedCards = new List<CardSource>();
+
+                        #region Select 3 Bagra Army Digimon in Trash
+
+                        int maxCount = Math.Min(3, CardEffectCommons.MatchConditionOwnersCardCountInTrash(card, IsBagraArmyDigimon));
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                        selectCardEffect.SetUp(
+                            canTargetCondition: IsBagraArmyDigimon,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            canNoSelect: () => true,
+                            selectCardCoroutine: SelectCardCoroutine,
+                            afterSelectCardCoroutine: null,
+                            message: "Select 3 [Bagra Army] digimon",
+                            maxCount: maxCount,
+                            canEndNotMax: false,
+                            isShowOpponent: true,
+                            mode: SelectCardEffect.Mode.Custom,
+                            root: SelectCardEffect.Root.Trash,
+                            customRootCardList: null,
+                            canLookReverseCard: true,
+                            selectPlayer: card.Owner,
+                            cardEffect: activateClass);
+
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            selectedCards.Add(cardSource);
+                            yield return null;
+                        }
+
+                        selectCardEffect.SetUpCustomMessage("Select 3 [Bagra Army] digimon to add as source", "The opponent is selecting 3 [Bagra Army] digimon to add as source");
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                        #endregion
+
+                        if (selectedCards.Count == 3)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(thisPermament.AddDigivolutionCardsTop(
+                                addedDigivolutionCards: selectedCards,
+                                cardEffect: activateClass));
+
+                            #region Select Enemy Permament to add source
+
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                            int maxCount1 = Math.Min(1, CardEffectCommons.MatchConditionOpponentsPermanentCount(card, IsOpponentPermament));
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: IsOpponentPermament,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount1,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: null,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Destroy,
+                                cardEffect: activateClass);
+
+                            selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon or tamer with sources to destroy", "The opponent is selecting 1 Digimon or tamer with sources to destroy");
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                            #endregion
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            // TODO: Need Mike Help
+            // [All Turns] This Digimon gains all [All Turns] effects on all level 6 [Bagra Army] trait Digimon cards in its digivolution cards.
+
+            #region All Turns
+
+            //if (timing == EffectTiming.None)
+            //{
+            //    ActivateClass activateClass = new ActivateClass();
+            //    activateClass.SetUpICardEffect("", CanUseCondition, card);
+            //    activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+            //    cardEffects.Add(activateClass);
+
+            //    string EffectDiscription()
+            //    {
+            //        return "[All Turns] This Digimon gains all [All Turns] effects on all level 6 [Bagra Army] trait Digimon cards in its digivolution cards.";
+            //    }
+
+            //    bool CanUseCondition(Hashtable hashtable)
+            //    {
+            //        return true;
+            //    }
+
+            //    bool CanActivateCondition(Hashtable hashtable)
+            //    {
+            //        return true;
+            //    }
+
+            //    IEnumerator ActivateCoroutine(Hashtable hashtable)
+            //    {
+            //        yield return null;
+            //    }
+            //}
+
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX10/Purple/EX10_059.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f0ba0240b83ec124abb28d8470d50e27
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: