Merge branch 'EX6' of https://github.com/DCGO2/DCGO into EX6

Assets/CardBaseEntity/EX6/Red/Digimon/RagnaLoardmon-EX6-011.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c800e459a37f351cabd23e2a80e7067f8744c5a3d641cde5a13eff1f81ba8099
-size 1720
+oid sha256:5c8e79e6012d1e13d617d3d71ac091f83274e5663ebced3acb311b20720011bd
+size 1723

Assets/CardBaseEntity/EX6/Red/Digimon/RagnaLoardmon-EX6-011_P1.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8c1a0fc96b5b57df3c49ab947a8f451e57b114a849cc01071b48dd7ac4256a92
-size 1726
+oid sha256:9869806a175b60750c5528ba13a1bcbdc5437e56625ed9bbaed84cedd63ed068
+size 1729

Assets/CardBaseEntity/EX6/Red/Digimon/RagnaLoardmon-EX6-011_P2.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:798980c2241e42916a9b1204af55067aefb9e3340229b360226be5b88ba9c1a3
-size 1726
+oid sha256:122f7b403cbaa1f821edf873ac89df04339ae1824614e46f5f8734881db7d5eb
+size 1729

Assets/CardEffect/EX6/Black/BryweLudramon_EX6_044.cs

@@ -199,7 +199,7 @@ namespace DCGO.CardEffects.EX6
                             mode: SelectPermanentEffect.Mode.Custom,
                             cardEffect: activateClass);
 
-                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to add bottom digivolution source.", "The opponent is selecting 1 Digimon to add bottom digivolution source.");
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will not be affected by the effect's of your opponent's Digimon.", "The opponent is selecting 1 Digimon that will not be affected by the effect's of your Digimon.");
 
                         yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
@@ -213,11 +213,11 @@ namespace DCGO.CardEffects.EX6
                     if(selectedPermanent != null)
                     {
                         CanNotAffectedClass canNotAffectedClass = new CanNotAffectedClass();
-                        canNotAffectedClass.SetUpICardEffect("Isn't affected by opponent's Digimon's effects", CanUseCondition, card);
+                        canNotAffectedClass.SetUpICardEffect("Isn't affected by opponent's Digimon's effects", CanUseConditionImmunity, card);
                         canNotAffectedClass.SetUpCanNotAffectedClass(CardCondition: CardCondition, SkillCondition: SkillCondition);
                         cardEffects.Add(canNotAffectedClass);
 
-                        bool CanUseCondition(Hashtable hashtable)
+                        bool CanUseConditionImmunity(Hashtable hashtable)
                         {
                             return CardEffectCommons.IsExistOnBattleArea(card);
                         }

Assets/CardEffect/EX6/Black/Ludomon_EX6_038.cs

@@ -172,7 +172,7 @@ namespace DCGO.CardEffects.EX6
                 {
                     if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
-                        if (!CardEffectCommons.IsOwnerTurn(card))
+                        if (CardEffectCommons.IsOpponentTurn(card))
                         {
                             return true;
                         }

Assets/CardEffect/EX6/Black/TiaLudomon_EX6_040.cs

@@ -45,7 +45,7 @@ namespace DCGO.CardEffects.EX6
                     return "[Hand] [Main] By paying 1 cost and placing this card as the bottom digivolution card of 1 of your Digimon that's level 4 or has the [Legend-Arms] trait, that Digimon gets +2000 DP until the end of your opponent's turn.";
                 }
 
-                bool IsLevel3OrHasLegendArmsTrait(Permanent targetPermanent)
+                bool IsLevel4OrHasLegendArmsTrait(Permanent targetPermanent)
                 {
                     if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(targetPermanent, card))
                     {
@@ -63,7 +63,7 @@ namespace DCGO.CardEffects.EX6
                 {
                     if (CardEffectCommons.IsExistOnHand(card))
                     {
-                        if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, IsLevel3OrHasLegendArmsTrait))
+                        if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, IsLevel4OrHasLegendArmsTrait))
                         {
                             return true;
                         }
@@ -74,17 +74,17 @@ namespace DCGO.CardEffects.EX6
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.HasMatchConditionPermanent(IsLevel3OrHasLegendArmsTrait))
+                    if (CardEffectCommons.HasMatchConditionPermanent(IsLevel4OrHasLegendArmsTrait))
                     {
                         Permanent selectedPermanent = null;
 
-                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(IsLevel3OrHasLegendArmsTrait));
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(IsLevel4OrHasLegendArmsTrait));
 
                         SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
 
                         selectPermanentEffect.SetUp(
                             selectPlayer: card.Owner,
-                            canTargetCondition: IsLevel3OrHasLegendArmsTrait,
+                            canTargetCondition: IsLevel4OrHasLegendArmsTrait,
                             canTargetCondition_ByPreSelecetedList: null,
                             canEndSelectCondition: null,
                             maxCount: maxCount,
@@ -185,7 +185,7 @@ namespace DCGO.CardEffects.EX6
                 {
                     if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
-                        if (!CardEffectCommons.IsOwnerTurn(card))
+                        if (CardEffectCommons.IsOpponentTurn(card))
                         {
                             return true;
                         }

Assets/CardEffect/EX6/Blue/Biyomon_EX6_012.cs

@@ -0,0 +1,34 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace DCGO.CardEffects.EX6
+{
+    public class Biyomon_EX6_012 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+            
+            #region Static Effect, Inherited Effect
+            
+            if (timing == EffectTiming.None)
+            {
+                // Blocker Static Effect
+                cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(
+                    isInheritedEffect: false,
+                    card: card,
+                    condition: null));
+                
+                // Jamming Inherited Effect
+                cardEffects.Add(CardEffectFactory.JammingSelfStaticEffect(
+                    isInheritedEffect: true,
+                    card: card,
+                    condition: null));
+            }
+            
+            #endregion
+            
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX6/Blue/Biyomon_EX6_012.cs.meta

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

Assets/CardEffect/EX6/Blue/Huankunmon_EX6_014.cs

@@ -0,0 +1,462 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System;
+
+namespace DCGO.CardEffects.EX6
+{
+    public class Huankunmon_EX6_014 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+            
+            #region On Play/ When Digivolving
+            
+            // On Play
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Play 1 digivolution card", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true,
+                    EffectDescription());
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[On Play] You may play 1 level 3 blue Digimon card from one of your blue Digimon's digivolution cards without paying the cost.";
+                }
+                
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                    {
+                        if (permanent.TopCard.CardColors.Contains(CardColor.Blue))
+                        {
+                            if (permanent.DigivolutionCards.Count(CanSelectCardCondition) >= 1)
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    if (cardSource.IsDigimon)
+                    {
+                        if (cardSource.CardColors.Contains(CardColor.Blue))
+                        {
+                            if (cardSource.IsLevel3)
+                            {
+                                if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false,
+                                        cardEffect: activateClass))
+                                {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+                
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                        {
+                            return true;
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    // If there is a blue Digimon in the owner Battle Area
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    {
+                        int maxCount = Math.Min(1,
+                            CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+                        
+                        SelectPermanentEffect selectPermanentEffect =
+                            GManager.instance.GetComponent<SelectPermanentEffect>();
+                        
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+                        
+                        selectPermanentEffect.SetUpCustomMessage(
+                            "Select 1 Digimon which has digivolution cards.",
+                            "The opponent is selecting 1 Digimon which has digivolution cards.");
+                        
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                        
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            Permanent selectedPermanent = permanent;
+                            
+                            // If the selected Digimon has a level 3 blue Digimon as a Digivolution card
+                            if (selectedPermanent != null)
+                            {
+                                if (selectedPermanent.DigivolutionCards.Count(CanSelectCardCondition) >= 1)
+                                {
+                                    maxCount = Math.Min(1,
+                                        selectedPermanent.DigivolutionCards.Count(CanSelectCardCondition));
+                                    
+                                    List<CardSource> selectedCards = new List<CardSource>();
+                                    
+                                    SelectCardEffect selectCardEffect =
+                                        GManager.instance.GetComponent<SelectCardEffect>();
+                                    
+                                    selectCardEffect.SetUp(
+                                        canTargetCondition: CanSelectCardCondition,
+                                        canTargetCondition_ByPreSelecetedList: null,
+                                        canEndSelectCondition: null,
+                                        canNoSelect: () => true,
+                                        selectCardCoroutine: SelectCardCoroutine,
+                                        afterSelectCardCoroutine: null,
+                                        message: "Select 1 digivolution card to play.",
+                                        maxCount: maxCount,
+                                        canEndNotMax: false,
+                                        isShowOpponent: true,
+                                        mode: SelectCardEffect.Mode.Custom,
+                                        root: SelectCardEffect.Root.Custom,
+                                        customRootCardList: selectedPermanent.DigivolutionCards,
+                                        canLookReverseCard: true,
+                                        selectPlayer: card.Owner,
+                                        cardEffect: activateClass);
+                                    
+                                    selectCardEffect.SetUpCustomMessage(
+                                        "Select 1 digivolution card to play.",
+                                        "The opponent is selecting 1 digivolution card to play.");
+                                    selectCardEffect.SetUpCustomMessage_ShowCard("Played Card");
+                                    
+                                    yield return StartCoroutine(selectCardEffect.Activate());
+                                    
+                                    IEnumerator SelectCardCoroutine(CardSource cardSource)
+                                    {
+                                        selectedCards.Add(cardSource);
+                                        
+                                        yield return null;
+                                    }
+                                    
+                                    // Play the selected Digivolution card
+                                    yield return ContinuousController.instance.StartCoroutine(
+                                        CardEffectCommons.PlayPermanentCards(
+                                            cardSources: selectedCards,
+                                            activateClass: activateClass,
+                                            payCost: false,
+                                            isTapped: false,
+                                            root: SelectCardEffect.Root.DigivolutionCards,
+                                            activateETB: true));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            
+            // When Digivolving
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Play 1 digivolution card", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true,
+                    EffectDescription());
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[When Digivolving] You may play 1 level 3 blue Digimon card from one of your blue Digimon's digivolution cards without paying the cost.";
+                }
+                
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                    {
+                        if (permanent.TopCard.CardColors.Contains(CardColor.Blue))
+                        {
+                            if (permanent.DigivolutionCards.Count(CanSelectCardCondition) >= 1)
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    if (cardSource.IsDigimon)
+                    {
+                        if (cardSource.CardColors.Contains(CardColor.Blue))
+                        {
+                            if (cardSource.IsLevel3)
+                            {
+                                if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false,
+                                        cardEffect: activateClass))
+                                {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+                
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                        {
+                            return true;
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    // If there is a blue Digimon in the owner Battle Area
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    {
+                        int maxCount = Math.Min(1,
+                            CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+                        
+                        SelectPermanentEffect selectPermanentEffect =
+                            GManager.instance.GetComponent<SelectPermanentEffect>();
+                        
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+                        
+                        selectPermanentEffect.SetUpCustomMessage(
+                            "Select 1 Digimon which has digivolution cards.",
+                            "The opponent is selecting 1 Digimon which has digivolution cards.");
+                        
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                        
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            Permanent selectedPermanent = permanent;
+                            
+                            // If the selected Digimon has a level 3 blue Digimon as a Digivolution card
+                            if (selectedPermanent != null)
+                            {
+                                if (selectedPermanent.DigivolutionCards.Count(CanSelectCardCondition) >= 1)
+                                {
+                                    maxCount = Math.Min(1,
+                                        selectedPermanent.DigivolutionCards.Count(CanSelectCardCondition));
+                                    
+                                    List<CardSource> selectedCards = new List<CardSource>();
+                                    
+                                    SelectCardEffect selectCardEffect =
+                                        GManager.instance.GetComponent<SelectCardEffect>();
+                                    
+                                    selectCardEffect.SetUp(
+                                        canTargetCondition: CanSelectCardCondition,
+                                        canTargetCondition_ByPreSelecetedList: null,
+                                        canEndSelectCondition: null,
+                                        canNoSelect: () => true,
+                                        selectCardCoroutine: SelectCardCoroutine,
+                                        afterSelectCardCoroutine: null,
+                                        message: "Select 1 digivolution card to play.",
+                                        maxCount: maxCount,
+                                        canEndNotMax: false,
+                                        isShowOpponent: true,
+                                        mode: SelectCardEffect.Mode.Custom,
+                                        root: SelectCardEffect.Root.Custom,
+                                        customRootCardList: selectedPermanent.DigivolutionCards,
+                                        canLookReverseCard: true,
+                                        selectPlayer: card.Owner,
+                                        cardEffect: activateClass);
+                                    
+                                    selectCardEffect.SetUpCustomMessage(
+                                        "Select 1 digivolution card to play.",
+                                        "The opponent is selecting 1 digivolution card to play.");
+                                    selectCardEffect.SetUpCustomMessage_ShowCard("Played Card");
+                                    
+                                    yield return StartCoroutine(selectCardEffect.Activate());
+                                    
+                                    IEnumerator SelectCardCoroutine(CardSource cardSource)
+                                    {
+                                        selectedCards.Add(cardSource);
+                                        
+                                        yield return null;
+                                    }
+                                    
+                                    // Play the selected Digivolution card
+                                    yield return ContinuousController.instance.StartCoroutine(
+                                        CardEffectCommons.PlayPermanentCards(
+                                            cardSources: selectedCards,
+                                            activateClass: activateClass,
+                                            payCost: false,
+                                            isTapped: false,
+                                            root: SelectCardEffect.Root.DigivolutionCards,
+                                            activateETB: true));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            
+            #endregion
+            
+            #region Inherited Effect
+            
+            if (timing == EffectTiming.OnAllyAttack)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect(
+                    "Place 1 of your other blue Digimon as this Digimon's bottom digivolution card to unsuspend this Digimon.",
+                    CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true,
+                    EffectDescription());
+                activateClass.SetIsInheritedEffect(true);
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[When Attacking][Once Per Turn] By placing 1 of your other blue Digimon as this Digimon's bottom digivolution card, unsuspend this Digimon.";
+                }
+                
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                    {
+                        if (permanent != card.PermanentOfThisCard())
+                        {
+                            if (permanent.TopCard.CardColors.Contains(CardColor.Blue))
+                            {
+                                if (!permanent.TopCard.Equals(card))
+                                    return true;
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnAttack(hashtable, card);
+                }
+                
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (!card.PermanentOfThisCard().IsToken)
+                        {
+                            if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        List<CardSource> selectedCards = new List<CardSource>();
+                        
+                        // If there is another blue Digimon in owner Battle Area  
+                        int maxCount = Math.Min(1,
+                            CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+                        
+                        SelectPermanentEffect selectPermanentEffect =
+                            GManager.instance.GetComponent<SelectPermanentEffect>();
+                        
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+                        
+                        selectPermanentEffect.SetUpCustomMessage(
+                            "Select 1 card to place on bottom of digivolution cards.",
+                            "The opponent is selecting 1 card to place on bottom of digivolution cards.");
+                        
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                        
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            selectedCards.Add(permanent.TopCard);
+                            
+                            yield return null;
+                        }
+                        
+                        if (selectedCards.Count >= 1)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard()
+                                .AddDigivolutionCardsBottom(
+                                    selectedCards,
+                                    activateClass));
+                            
+                            yield return ContinuousController.instance.StartCoroutine(
+                                new IUnsuspendPermanents(new List<Permanent>() { card.PermanentOfThisCard() },
+                                    activateClass).Unsuspend());
+                        }
+                    }
+                }
+            }
+            
+            #endregion
+            
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX6/Blue/Huankunmon_EX6_014.cs.meta

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

Assets/CardEffect/EX6/Blue/Sea_of_Destruction_EX6_066.cs

@@ -0,0 +1,197 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System;
+
+namespace DCGO.CardEffects.EX6
+{
+    public class Sea_of_Destruction_EX6_066 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+            
+            #region Main Effect
+            
+            if (timing == EffectTiming.OptionSkill)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect(card.BaseENGCardNameFromEntity, CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDescription());
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[Main] By placing 1 Digimon card with [Aqua]/[Sea Animal] in one of its traits from your hand as the bottom digivolution card of 1 of your blue Digimon, return all of your opponent's Digimon with the same level as the placed card to the hand.";
+                }
+                
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    if (cardSource.IsDigimon)
+                    {
+                        if (cardSource.HasAquaTraits)
+                        {
+                            return true;
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                    {
+                        if (permanent.TopCard.CardColors.Contains(CardColor.Blue))
+                        {
+                            if (!permanent.IsToken)
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOptionMainEffect(hashtable, card);
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    // If there is a Digimon card with Aqua traits in hand and blue Digimon on owner's field
+                    if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                        {
+                            CardSource selectedCard = null;
+                            
+                            int maxCount = 1;
+                            
+                            SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+                            
+                            selectHandEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectCardCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount,
+                                canNoSelect: true,
+                                canEndNotMax: false,
+                                isShowOpponent: true,
+                                selectCardCoroutine: SelectCardCoroutine,
+                                afterSelectCardCoroutine: null,
+                                mode: SelectHandEffect.Mode.Custom,
+                                cardEffect: activateClass);
+                            
+                            selectHandEffect.SetUpCustomMessage(
+                                "Select 1 card to place at the bottom of digivolution cards.",
+                                "The opponent is selecting 1 card to place at the bottom of digivolution cards.");
+                            
+                            yield return StartCoroutine(selectHandEffect.Activate());
+                            
+                            IEnumerator SelectCardCoroutine(CardSource cardSource)
+                            {
+                                selectedCard = cardSource;
+                                
+                                yield return null;
+                            }
+                            
+                            if (selectedCard != null)
+                            {
+                                maxCount = Math.Min(1,
+                                    CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+                                
+                                SelectPermanentEffect selectPermanentEffect =
+                                    GManager.instance.GetComponent<SelectPermanentEffect>();
+                                
+                                selectPermanentEffect.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: CanSelectPermanentCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: maxCount,
+                                    canNoSelect: true,
+                                    canEndNotMax: false,
+                                    selectPermanentCoroutine: SelectPermanentCoroutine,
+                                    afterSelectPermanentCoroutine: null,
+                                    mode: SelectPermanentEffect.Mode.Custom,
+                                    cardEffect: activateClass);
+                                
+                                selectPermanentEffect.SetUpCustomMessage(
+                                    "Select 1 Digimon that will get a bottom digivolution card.",
+                                    "The opponent is selecting 1 Digimon that will get a bottom digivolution card.");
+                                
+                                yield return ContinuousController.instance.StartCoroutine(
+                                    selectPermanentEffect.Activate());
+                                
+                                IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                                {
+                                    Permanent selectedPermanent = permanent;
+                                    
+                                    if (selectedPermanent != null)
+                                    {
+                                        // Add chosen card to Digimon's sources
+                                        yield return ContinuousController.instance.StartCoroutine(
+                                            selectedPermanent.AddDigivolutionCardsBottom(
+                                                new List<CardSource>() { selectedCard }, activateClass));
+                                        
+                                        bool PermanentConditionEnemy(Permanent enemyPermanent)
+                                        {
+                                            return enemyPermanent.Level == selectedCard.Level;
+                                        }
+                                        
+                                        // Return all opponent's Digimon with the same level as the chosen card to their hand
+                                        List<Permanent> bounceTargetPermanents = card.Owner.Enemy.GetBattleAreaDigimons()
+                                            .Filter(PermanentConditionEnemy);
+                                        yield return ContinuousController.instance.StartCoroutine(new HandBounceClaass(bounceTargetPermanents, CardEffectCommons.CardEffectHashtable(activateClass)).Bounce());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            
+            #endregion
+            
+            #region Security Effect
+            
+            if (timing == EffectTiming.SecuritySkill)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect($"Return all of your opponent's Digimon with the lowest level to the hand.", CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDescription());
+                activateClass.SetIsSecurityEffect(true);
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return "[Security] Return all of your opponent's Digimon with the lowest level to the hand.";
+                }
+                
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsMinLevel(permanent, card.Owner.Enemy);
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerSecurityEffect(hashtable, card);
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    List<Permanent> bounceTargetPermanents = card.Owner.Enemy.GetBattleAreaDigimons().Filter(PermanentCondition);
+                    yield return ContinuousController.instance.StartCoroutine(new HandBounceClaass(bounceTargetPermanents, CardEffectCommons.CardEffectHashtable(activateClass)).Bounce());
+                }
+            }
+            #endregion
+            
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX6/Blue/Sea_of_Destruction_EX6_066.cs.meta

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

Assets/CardEffect/EX6/Blue/Xiangpengmon_EX6_015.cs

@@ -0,0 +1,394 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System;
+
+namespace DCGO.CardEffects.EX6
+{
+    public class Xiangpengmon_EX6_015 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+            
+            #region Rule Text
+            
+            if (timing == EffectTiming.None)
+            {
+                // Trait Rule Aquatic Type
+                ChangeTraitsClass changeTraitsClass = new ChangeTraitsClass();
+                changeTraitsClass.SetUpICardEffect("Trait: Has [Aquatic] Type", CanUseCondition, card);
+                changeTraitsClass.SetUpChangeTraitsClass(changeeTraits: ChangeTraits);
+                cardEffects.Add(changeTraitsClass);
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return true;
+                }
+                
+                List<string> ChangeTraits(CardSource cardSource, List<string> cardTraits)
+                {
+                    if (cardSource == card)
+                    {
+                        cardTraits.Add("Aquatic");
+                    }
+                    
+                    return cardTraits;
+                }
+            }
+            
+            #endregion
+            
+            #region On Play/When Digivolving Shared
+            
+            string EffectSharedDescription()
+            {
+                return
+                    "[On Play] [When Digivolving] You may place up to 3 of your other blue Digimon as this Digimon's bottom digivolution cards. Then, return all other level 4 or lower Digimon to the hand. For each card placed in this Digimon's digivolution cards, add 1 to the level this effect may return.";
+            }
+            
+            bool CanSelectSharedOwnPermanentCondition(Permanent permanent)
+            {
+                if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                {
+                    if (permanent != card.PermanentOfThisCard())
+                    {
+                        if (permanent.TopCard.CardColors.Contains(CardColor.Blue))
+                        {
+                            if (!permanent.TopCard.Equals(card))
+                                return true;
+                        }
+                    }
+                }
+                
+                return false;
+            }
+            
+            bool CanActivateSharedCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (!card.PermanentOfThisCard().IsToken)
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectSharedOwnPermanentCondition))
+                        {
+                            return true;
+                        }
+                    }
+                }
+                
+                return false;
+            }
+            
+            #endregion
+            
+            #region On Play/ When Digivolving
+            
+            // On Play
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect(
+                    "You may place up to 3 of your other blue Digimon as this Digimon's bottom digivolution cards. Then, return all other level 4 or lower Digimon to the hand. For each card placed in this Digimon's digivolution cards, add 1 to the level this effect may return.",
+                    CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateSharedCondition, ActivateCoroutine, -1, true,
+                    EffectSharedDescription());
+                cardEffects.Add(activateClass);
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CanActivateSharedCondition(hashtable))
+                    {
+                        List<CardSource> selectedCards = new List<CardSource>();
+                        
+                        // If there is other blue Digimon in owner Battle Area  
+                        int maxCount = Math.Min(3,
+                            CardEffectCommons.MatchConditionPermanentCount(CanSelectSharedOwnPermanentCondition));
+                        
+                        SelectPermanentEffect selectPermanentEffect =
+                            GManager.instance.GetComponent<SelectPermanentEffect>();
+                        
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectSharedOwnPermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: CanEndSelectCondition,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: true,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+                        
+                        selectPermanentEffect.SetUpCustomMessage(
+                            "Select up to 3 Digimon to place on bottom of digivolution cards.",
+                            "The opponent is selecting up to 3 Digimon to place on bottom of digivolution cards.");
+                        
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                        
+                        bool CanEndSelectCondition(List<Permanent> permanents)
+                        {
+                            if (CardEffectCommons.HasNoElement(permanents))
+                            {
+                                return false;
+                            }
+                            
+                            return true;
+                        }
+                        
+                        IEnumerator SelectPermanentCoroutine(Permanent selectedPermanent)
+                        {
+                            selectedCards.Add(selectedPermanent.TopCard);
+                            
+                            yield return null;
+                        }
+                        
+                        if (selectedCards.Count >= 1)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard()
+                                .AddDigivolutionCardsBottom(
+                                    selectedCards,
+                                    activateClass));
+                            
+                            bool PermanentConditionEnemy(Permanent enemyPermanent)
+                            {
+                                return enemyPermanent.Level <= 4 + selectedCards.Count;
+                            }
+                            
+                            // Return all opponent's Digimon with a level lower or equal to 4 plus the number of chosen Digimon
+                            List<Permanent> bounceTargetPermanents = card.Owner.Enemy.GetBattleAreaDigimons()
+                                .Filter(PermanentConditionEnemy);
+                            yield return ContinuousController.instance.StartCoroutine(
+                                new HandBounceClaass(bounceTargetPermanents,
+                                    CardEffectCommons.CardEffectHashtable(activateClass)).Bounce());
+                        }
+                    }
+                }
+            }
+            
+            // When Digivolving
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect(
+                    "You may place up to 3 of your other blue Digimon as this Digimon's bottom digivolution cards. Then, return all other level 4 or lower Digimon to the hand. For each card placed in this Digimon's digivolution cards, add 1 to the level this effect may return.",
+                    CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateSharedCondition, ActivateCoroutine, -1, true,
+                    EffectSharedDescription());
+                cardEffects.Add(activateClass);
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CanActivateSharedCondition(hashtable))
+                    {
+                        List<CardSource> selectedCards = new List<CardSource>();
+                        
+                        // If there is other blue Digimon in owner Battle Area  
+                        int maxCount = Math.Min(3,
+                            CardEffectCommons.MatchConditionPermanentCount(CanSelectSharedOwnPermanentCondition));
+                        
+                        SelectPermanentEffect selectPermanentEffect =
+                            GManager.instance.GetComponent<SelectPermanentEffect>();
+                        
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectSharedOwnPermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: CanEndSelectCondition,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: true,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+                        
+                        selectPermanentEffect.SetUpCustomMessage(
+                            "Select up to 3 Digimon to place on bottom of digivolution cards.",
+                            "The opponent is selecting up to 3 Digimon to place on bottom of digivolution cards.");
+                        
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                        
+                        bool CanEndSelectCondition(List<Permanent> permanents)
+                        {
+                            if (CardEffectCommons.HasNoElement(permanents))
+                            {
+                                return false;
+                            }
+                            
+                            return true;
+                        }
+                        
+                        IEnumerator SelectPermanentCoroutine(Permanent selectedPermanent)
+                        {
+                            selectedCards.Add(selectedPermanent.TopCard);
+                            
+                            yield return null;
+                        }
+                        
+                        if (selectedCards.Count >= 1)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard()
+                                .AddDigivolutionCardsBottom(
+                                    selectedCards,
+                                    activateClass));
+                            
+                            bool PermanentConditionEnemy(Permanent enemyPermanent)
+                            {
+                                return enemyPermanent.Level <= 4 + selectedCards.Count;
+                            }
+                            
+                            // Return all opponent's Digimon with a level lower or equal to 4 plus the number of chosen Digimon
+                            List<Permanent> bounceTargetPermanents = card.Owner.Enemy.GetBattleAreaDigimons()
+                                .Filter(PermanentConditionEnemy);
+                            yield return ContinuousController.instance.StartCoroutine(
+                                new HandBounceClaass(bounceTargetPermanents,
+                                    CardEffectCommons.CardEffectHashtable(activateClass)).Bounce());
+                        }
+                    }
+                }
+            }
+            
+            #endregion
+            
+            #region All Turns
+            
+            if (timing == EffectTiming.OnAddDigivolutionCards)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Play 1 digivolution card", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true,
+                    EffectDescription());
+                activateClass.SetHashString("Play1DigivolutionCard_EX6_015");
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[Your Turn] [Once Per Turn] When an effect places a digivolution card under this Digimon, you may play 1 level 5 or lower Digimon card with [Aqua]/[Sea Animal] in one of its traits from this Digimon's digivolution cards without paying the cost.";
+                }
+                
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    if (cardSource.IsDigimon)
+                    {
+                        if (cardSource.Level <= 5)
+                        {
+                            if (cardSource.HasAquaTraits)
+                            {
+                                if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false,
+                                        cardEffect: activateClass))
+                                {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.IsOwnerTurn(card))
+                        {
+                            if (CardEffectCommons.CanTriggerOnAddDigivolutionCard(
+                                    hashtable: hashtable,
+                                    permanentCondition: permanent => permanent == card.PermanentOfThisCard(),
+                                    cardEffectCondition: cardEffect => cardEffect != null,
+                                    cardCondition: null))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        return true;
+                    }
+                    
+                    return false;
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (card.PermanentOfThisCard().DigivolutionCards.Count(CanSelectCardCondition) >= 1)
+                    {
+                        int maxCount = Math.Min(1,
+                            card.PermanentOfThisCard().DigivolutionCards.Count(CanSelectCardCondition));
+                        
+                        List<CardSource> selectedCards = new List<CardSource>();
+                        
+                        SelectCardEffect selectCardEffect =
+                            GManager.instance.GetComponent<SelectCardEffect>();
+                        
+                        selectCardEffect.SetUp(
+                            canTargetCondition: CanSelectCardCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            canNoSelect: () => true,
+                            selectCardCoroutine: SelectCardCoroutine,
+                            afterSelectCardCoroutine: null,
+                            message: "Select 1 digivolution card to play.",
+                            maxCount: maxCount,
+                            canEndNotMax: false,
+                            isShowOpponent: true,
+                            mode: SelectCardEffect.Mode.Custom,
+                            root: SelectCardEffect.Root.Custom,
+                            customRootCardList: card.PermanentOfThisCard().DigivolutionCards,
+                            canLookReverseCard: true,
+                            selectPlayer: card.Owner,
+                            cardEffect: activateClass);
+                        
+                        selectCardEffect.SetUpCustomMessage(
+                            "Select 1 digivolution card to play.",
+                            "The opponent is selecting 1 digivolution card to play.");
+                        selectCardEffect.SetUpCustomMessage_ShowCard("Played Card");
+                        
+                        yield return StartCoroutine(selectCardEffect.Activate());
+                        
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            selectedCards.Add(cardSource);
+                            
+                            yield return null;
+                        }
+                        
+                        // Play the selected Digivolution card
+                        yield return ContinuousController.instance.StartCoroutine(
+                            CardEffectCommons.PlayPermanentCards(
+                                cardSources: selectedCards,
+                                activateClass: activateClass,
+                                payCost: false,
+                                isTapped: false,
+                                root: SelectCardEffect.Root.DigivolutionCards,
+                                activateETB: true));
+                    }
+                }
+            }
+            
+            #endregion
+            
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX6/Blue/Xiangpengmon_EX6_015.cs.meta

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

Assets/CardEffect/EX6/Blue/Xiquemon_EX6_013.cs

@@ -0,0 +1,105 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace DCGO.CardEffects.EX6
+{
+    public class Xiquemon_EX6_013 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+            
+            #region Rule Text, Inherited Effect
+            
+            if (timing == EffectTiming.None)
+            {
+                // Trait Rule Aquatic Type
+                ChangeTraitsClass changeTraitsClass = new ChangeTraitsClass();
+                changeTraitsClass.SetUpICardEffect("Trait: Has [Aquatic] Type", CanUseCondition, card);
+                changeTraitsClass.SetUpChangeTraitsClass(changeeTraits: ChangeTraits);
+                cardEffects.Add(changeTraitsClass);
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return true;
+                }
+                
+                List<string> ChangeTraits(CardSource cardSource, List<string> cardTraits)
+                {
+                    if (cardSource == card)
+                    {
+                        cardTraits.Add("Aquatic");
+                    }
+                    
+                    return cardTraits;
+                }
+                
+                // Jamming Inherited Effect
+                cardEffects.Add(CardEffectFactory.JammingSelfStaticEffect(
+                    isInheritedEffect: true,
+                    card: card,
+                    condition: null));
+            }
+            
+            #endregion
+            
+            #region On Play
+            
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Draw 1 and gain 1 memory", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false,
+                    EffectDescription());
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[On Play] <Draw 1>. If played from digivolution cards, gain 1 memory.";
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+                
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (card.Owner.LibraryCards.Count >= 1)
+                        {
+                            return true;
+                        }
+                        
+                        if (CardEffectCommons.IsFromDigimonDigivolutionCards(hashtable))
+                        {
+                            return true;
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    // Draw 1
+                    yield return ContinuousController.instance.StartCoroutine(
+                        new DrawClass(card.Owner, 1, activateClass).Draw());
+                    
+                    // Gain 1 memory if played from digivolution cards
+                    if (CardEffectCommons.IsFromDigimonDigivolutionCards(hashtable))
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(
+                            card.Owner.AddMemory(1, activateClass));
+                    }
+                }
+            }
+            
+            #endregion
+            
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX6/Blue/Xiquemon_EX6_013.cs.meta

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

Assets/CardEffect/EX6/Blue/Yokomon_EX6_002.cs

@@ -0,0 +1,123 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DCGO.CardEffects.EX6
+{
+    public class Yokomon_EX6_002 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+            
+            #region Inherited Effect
+            
+            if (timing == EffectTiming.OnAllyAttack)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect(
+                    "Place 1 level 3 blue Digimon card from your hand as this Digimon's bottom digivolution card.",
+                    CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true,
+                    EffectDescription());
+                activateClass.SetIsInheritedEffect(true);
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[When Attacking][Once Per Turn] You may place 1 level 3 blue Digimon card from your hand as this Digimon's bottom digivolution card.";
+                }
+                
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    if (cardSource.IsDigimon)
+                    {
+                        if (cardSource.IsLevel3)
+                        {
+                            if (cardSource.CardColors.Contains(CardColor.Blue))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnAttack(hashtable, card);
+                }
+                
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (card.Owner.HandCards.Count >= 1)
+                        {
+                            return true;
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        // If there is a blue level 3 Digimon card in hand, select that card
+                        if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
+                        {
+                            List<CardSource> selectedCards = new List<CardSource>();
+                            
+                            int maxCount = 1;
+                            
+                            SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+                            
+                            selectHandEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectCardCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount,
+                                canNoSelect: true,
+                                canEndNotMax: false,
+                                isShowOpponent: true,
+                                selectCardCoroutine: SelectCardCoroutine,
+                                afterSelectCardCoroutine: null,
+                                mode: SelectHandEffect.Mode.Custom,
+                                cardEffect: activateClass);
+                            
+                            selectHandEffect.SetUpCustomMessage(
+                                "Select 1 card to place on the bottom of digivolution cards.",
+                                "The opponent is selecting 1 card to place on the bottom of digivolution cards.");
+                            selectHandEffect.SetUpCustomMessage_ShowCard("Digivolution Card");
+                            
+                            yield return StartCoroutine(selectHandEffect.Activate());
+                            
+                            IEnumerator SelectCardCoroutine(CardSource cardSource)
+                            {
+                                selectedCards.Add(cardSource);
+                                
+                                yield return null;
+                            }
+                            
+                            // Add that card to bottom of digivolution cards
+                            if (selectedCards.Count >= 1)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard()
+                                    .AddDigivolutionCardsBottom(selectedCards, activateClass));
+                            }
+                        }
+                    }
+                }
+            }
+            
+            #endregion
+            
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX6/Blue/Yokomon_EX6_002.cs.meta

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

Assets/CardEffect/EX6/Red/Duramon_EX6_009.cs

@@ -0,0 +1,256 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System;
+
+namespace DCGO.CardEffects.EX6
+{
+    public class Duramon_EX6_009 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+            
+            #region Alternate Digivolution
+            
+            if (timing == EffectTiming.None)
+            {
+                static bool PermanentCondition(Permanent targetPermanent)
+                {
+                    if (targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.Level == 4)
+                    {
+                        return targetPermanent.TopCard.ContainsTraits("Legend-Arms");
+                    }
+                    
+                    return false;
+                }
+                
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 3,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null));
+            }
+            
+            #endregion
+            
+            #region Hand - Main
+            
+            if (timing == EffectTiming.OnDeclaration)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Gain [Security Attack +1]", CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDescription());
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[Hand] [Main] By paying 2 cost and placing this card as the bottom digivolution card of 1 of your Digimon that's level 5 or has the [Legend-Arms] trait, that Digimon gains [Security Attack +1] for the turn.";
+                }
+                
+                bool IsLevel5OrHasLegendArmsTrait(Permanent targetPermanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(targetPermanent, card))
+                    {
+                        if (targetPermanent.TopCard.HasLevel && targetPermanent.Level == 5)
+                            return true;
+                        
+                        if (targetPermanent.TopCard.ContainsTraits("Legend-Arms"))
+                            return true;
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnHand(card))
+                    {
+                        if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, IsLevel5OrHasLegendArmsTrait))
+                        {
+                            return true;
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    Permanent selectedPermanent = null;
+                    
+                    if (CardEffectCommons.HasMatchConditionPermanent(IsLevel5OrHasLegendArmsTrait))
+                    {
+                        int maxCount = Math.Min(1,
+                            CardEffectCommons.MatchConditionPermanentCount(IsLevel5OrHasLegendArmsTrait));
+                        
+                        SelectPermanentEffect selectPermanentEffect =
+                            GManager.instance.GetComponent<SelectPermanentEffect>();
+                        
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: IsLevel5OrHasLegendArmsTrait,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+                        
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to add bottom digivolution source.",
+                            "The opponent is selecting 1 Digimon to add bottom digivolution source.");
+                        
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                        
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            selectedPermanent = permanent;
+                            yield return null;
+                        }
+                        
+                        if (selectedPermanent != null)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(
+                                card.Owner.AddMemory(-2, activateClass));
+                            
+                            yield return ContinuousController.instance.StartCoroutine(
+                                selectedPermanent.AddDigivolutionCardsBottom(
+                                    new List<CardSource>() { card },
+                                    activateClass));
+                            
+                            yield return ContinuousController.instance.StartCoroutine(
+                                CardEffectCommons.ChangeDigimonSAttack(
+                                    targetPermanent: selectedPermanent,
+                                    changeValue: 1,
+                                    effectDuration: EffectDuration.UntilEachTurnEnd,
+                                    activateClass: activateClass));
+                        }
+                    }
+                }
+            }
+            
+            #endregion
+            
+            #region Your Turn - Place Digivolution
+            
+            if (timing == EffectTiming.OnAddDigivolutionCards)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Gain <Raid> and <Piercing>", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false,
+                    EffectDiscription());
+                activateClass.SetHashString("GainEffects_EX6_009");
+                cardEffects.Add(activateClass);
+                
+                string EffectDiscription()
+                {
+                    return
+                        "[Your Turn] [Once Per Turn] When an effect places a digivolution card under this Digimon, it gains <Raid> and <Piercing> for the turn.";
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.IsOwnerTurn(card))
+                        {
+                            if (CardEffectCommons.CanTriggerOnAddDigivolutionCard(
+                                    hashtable: hashtable,
+                                    permanentCondition: permanent => permanent == card.PermanentOfThisCard(),
+                                    cardEffectCondition: cardEffect => cardEffect.EffectSourceCard != null,
+                                    cardCondition: null))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(card);
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainRaid(
+                        targetPermanent: card.PermanentOfThisCard(),
+                        effectDuration: EffectDuration.UntilEachTurnEnd,
+                        activateClass: activateClass));
+                    
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainPierce(
+                        targetPermanent: card.PermanentOfThisCard(),
+                        effectDuration: EffectDuration.UntilEachTurnEnd,
+                        activateClass: activateClass));
+                }
+            }
+            
+            #endregion
+            
+            #region Your Turn - ESS
+            
+            if (timing == EffectTiming.OnAttackTargetChanged)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Trash the top card of opponent's security", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false,
+                    EffectDescription());
+                activateClass.SetIsInheritedEffect(true);
+                activateClass.SetHashString("TrashSecurity_BT11_014");
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[Your Turn][Once Per Turn] When this Digimon's attack target is switched, trash the top card of your opponent's security stack.";
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.CanTriggerOnAttackTargetSwitch(hashtable, card))
+                        {
+                            if (CardEffectCommons.IsOwnerTurn(card))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        return true;
+                    }
+                    
+                    return false;
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
+                        player: card.Owner.Enemy,
+                        destroySecurityCount: 1,
+                        cardEffect: activateClass,
+                        fromTop: true).DestroySecurity());
+                }
+            }
+            
+            #endregion
+            
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX6/Red/Duramon_EX6_009.cs.meta

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

Assets/CardEffect/EX6/Red/Durandamon_EX6_010.cs

@@ -0,0 +1,336 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System;
+
+namespace DCGO.CardEffects.EX6
+{
+    public class Durandamon_EX6_010 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+            
+            #region Alternate Digivolution
+            
+            if (timing == EffectTiming.None)
+            {
+                static bool PermanentCondition(Permanent targetPermanent)
+                {
+                    if (targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.Level == 5)
+                    {
+                        return targetPermanent.TopCard.ContainsTraits("Legend-Arms");
+                    }
+                    
+                    return false;
+                }
+                
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 4,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null));
+            }
+            
+            #endregion
+            
+            #region Raid
+            
+            if (timing == EffectTiming.OnAllyAttack)
+            {
+                cardEffects.Add(CardEffectFactory.RaidSelfEffect(isInheritedEffect: false, card: card,
+                    condition: null));
+            }
+            
+            #endregion
+            
+            #region Piercing
+            
+            if (timing == EffectTiming.OnDetermineDoSecurityCheck)
+            {
+                cardEffects.Add(
+                    CardEffectFactory.PierceSelfEffect(isInheritedEffect: false, card: card, condition: null));
+                
+                cardEffects.Add(
+                    CardEffectFactory.PierceSelfEffect(isInheritedEffect: true, card: card, condition: null));
+            }
+            
+            #endregion
+            
+            #region Hand - Main
+            
+            if (timing == EffectTiming.OnDeclaration)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect(
+                    "Delete 1 of your opponent's Digimon with as much or less DP as that Digimon", CanUseCondition,
+                    card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDescription());
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[Hand] [Main] By paying 3 cost and placing this card as the bottom digivolution card of 1 of your Digimon that's level 6 or has the [Legend-Arms] trait, delete 1 of your opponent's Digimon with as much or less DP as that Digimon.";
+                }
+                
+                bool IsLevel6OrHasLegendArmsTrait(Permanent targetPermanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(targetPermanent, card))
+                    {
+                        if (targetPermanent.TopCard.HasLevel && targetPermanent.Level == 6)
+                            return true;
+                        
+                        if (targetPermanent.TopCard.ContainsTraits("Legend-Arms"))
+                            return true;
+                    }
+                    
+                    return false;
+                }
+                
+                bool IsEnemyPermanentWithAsMuchOrLessDp(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
+                    {
+                        if (CardEffectCommons.IsExistOnBattleArea(card))
+                        {
+                            if (permanent.DP <= card.PermanentOfThisCard().DP)
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnHand(card))
+                    {
+                        if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, IsLevel6OrHasLegendArmsTrait))
+                        {
+                            return true;
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    Permanent selectedPermanent = null;
+                    
+                    if (CardEffectCommons.HasMatchConditionPermanent(IsLevel6OrHasLegendArmsTrait))
+                    {
+                        int maxCount = Math.Min(1,
+                            CardEffectCommons.MatchConditionPermanentCount(IsLevel6OrHasLegendArmsTrait));
+                        
+                        SelectPermanentEffect selectPermanentEffect =
+                            GManager.instance.GetComponent<SelectPermanentEffect>();
+                        
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: IsLevel6OrHasLegendArmsTrait,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+                        
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to add bottom digivolution source.",
+                            "The opponent is selecting 1 Digimon to add bottom digivolution source.");
+                        
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                        
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            selectedPermanent = permanent;
+                            yield return null;
+                        }
+                    }
+                    
+                    if (selectedPermanent != null)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(
+                            card.Owner.AddMemory(-3, activateClass));
+                        
+                        yield return ContinuousController.instance.StartCoroutine(
+                            selectedPermanent.AddDigivolutionCardsBottom(
+                                new List<CardSource>() { card },
+                                activateClass));
+                        
+                        if (CardEffectCommons.HasMatchConditionPermanent(IsEnemyPermanentWithAsMuchOrLessDp))
+                        {
+                            int enemyCount = Math.Min(1,
+                                CardEffectCommons.MatchConditionPermanentCount(IsEnemyPermanentWithAsMuchOrLessDp));
+                            
+                            SelectPermanentEffect selectEnemyEffect =
+                                GManager.instance.GetComponent<SelectPermanentEffect>();
+                            
+                            selectEnemyEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: IsEnemyPermanentWithAsMuchOrLessDp,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: enemyCount,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: null,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Destroy,
+                                cardEffect: activateClass);
+                        }
+                    }
+                }
+            }
+            
+            #endregion
+            
+            #region When Digivolving
+            
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("May attack", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true,
+                    EffectDescription());
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[When Digivolving]  1 of your Digimon may attack.";
+                }
+                
+                bool IsYourDigimon(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+                
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    Permanent selectedPermanent = null;
+                    
+                    if (CardEffectCommons.HasMatchConditionPermanent(IsYourDigimon))
+                    {
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(IsYourDigimon));
+                        
+                        SelectPermanentEffect selectPermanentEffect =
+                            GManager.instance.GetComponent<SelectPermanentEffect>();
+                        
+                        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);
+                        
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will attack.",
+                            "The opponent is selecting 1 Digimon that will attack.");
+                        
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                        
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            selectedPermanent = permanent;
+                            yield return null;
+                        }
+                    }
+                    
+                    if (selectedPermanent != null)
+                    {
+                        if (selectedPermanent.CanAttack(activateClass))
+                        {
+                            SelectAttackEffect selectAttackEffect =
+                                GManager.instance.GetComponent<SelectAttackEffect>();
+                            
+                            selectAttackEffect.SetUp(
+                                attacker: selectedPermanent,
+                                canAttackPlayerCondition: () => true,
+                                defenderCondition: (permanent) => true,
+                                cardEffect: activateClass);
+                            
+                            yield return ContinuousController.instance.StartCoroutine(selectAttackEffect.Activate());
+                        }
+                    }
+                }
+            }
+            
+            #endregion
+            
+            #region Your Turn - ESS
+            
+            if (timing == EffectTiming.None)
+            {
+                DisableEffectClass invalidationClass = new DisableEffectClass();
+                invalidationClass.SetUpICardEffect("Ignore Security Effect", CanUseCondition, card);
+                invalidationClass.SetUpDisableEffectClass(DisableCondition: InvalidateCondition);
+                invalidationClass.SetIsInheritedEffect(true);
+                
+                cardEffects.Add(invalidationClass);
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return true;
+                }
+                
+                bool InvalidateCondition(ICardEffect cardEffect)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.IsOwnerTurn(card))
+                        {
+                            if (card.PermanentOfThisCard().TopCard.CardNames.Contains("RagnaLoardmon") ||
+                                card.PermanentOfThisCard().TopCard.CardNames.Contains("Ragnalordmon") ||
+                                card.PermanentOfThisCard().TopCard.CardNames.Contains("Lagnalordmon"))
+                            {
+                                if (cardEffect != null)
+                                {
+                                    if (cardEffect.EffectSourceCard != null)
+                                    {
+                                        if (cardEffect.IsSecurityEffect)
+                                        {
+                                            if (GManager.instance.attackProcess.AttackingPermanent ==
+                                                card.PermanentOfThisCard())
+                                            {
+                                                return true;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+            }
+            
+            #endregion
+            
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX6/Red/Durandamon_EX6_010.cs.meta

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

Assets/CardEffect/EX6/Red/Mythical_Arms_of_Salvation_EX6_065.cs

@@ -0,0 +1,374 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System;
+
+namespace DCGO.CardEffects.EX6
+{
+    public class Mythical_Arms_of_Salvation_EX6_065 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+            
+            #region Ignore Color Requirements
+            
+            if (timing == EffectTiming.None)
+            {
+                IgnoreColorConditionClass ignoreColorConditionClass = new IgnoreColorConditionClass();
+                ignoreColorConditionClass.SetUpICardEffect("Ignore color requirements", CanUseCondition, card);
+                ignoreColorConditionClass.SetUpIgnoreColorConditionClass(cardCondition: CardCondition);
+                
+                cardEffects.Add(ignoreColorConditionClass);
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (card.Owner.GetBattleAreaDigimons()
+                            .Count(permanent => permanent.TopCard.CardTraits.Contains("Legend-Arms")) >= 1)
+                    {
+                        return true;
+                    }
+                    
+                    return false;
+                }
+                
+                bool CardCondition(CardSource cardSource)
+                {
+                    if (cardSource == card)
+                    {
+                        return true;
+                    }
+                    
+                    return false;
+                }
+            }
+            
+            #endregion
+            
+            #region Main Effect
+            
+            if (timing == EffectTiming.OptionSkill)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect(card.BaseENGCardNameFromEntity, CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDescription());
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[Main] You may place 1 Digimon card with the [Legend-Arms] trait from your trash as 1 of your Digimon’s bottom digivolution card. Then, place this card in the battle area.";
+                }
+                
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    if (cardSource.IsDigimon)
+                    {
+                        if (cardSource.CardTraits.Contains("Legend-Arms"))
+                        {
+                            return true;
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                    {
+                        if (!permanent.IsToken)
+                        {
+                            return true;
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOptionMainEffect(hashtable, card);
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    {
+                        List<CardSource> selectedCards = new List<CardSource>();
+                        
+                        int maxCount = 1;
+                        
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+                        
+                        selectCardEffect.SetUp(
+                            canTargetCondition: CanSelectCardCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            canNoSelect: () => false,
+                            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.SetUpCustomMessage_ShowCard("Digivolution Card");
+                        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.");
+                        
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+                        
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            selectedCards.Add(cardSource);
+                            yield return null;
+                        }
+                        
+                        if (selectedCards.Count >= 1)
+                        {
+                            maxCount = Math.Min(1,
+                                CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+                            
+                            SelectPermanentEffect selectPermanentEffect =
+                                GManager.instance.GetComponent<SelectPermanentEffect>();
+                            
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectPermanentCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount,
+                                canNoSelect: true,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: SelectPermanentCoroutine,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+                            
+                            selectPermanentEffect.SetUpCustomMessage(
+                                "Select 1 Digimon that will get a bottom digivolution card.",
+                                "The opponent is selecting 1 Digimon that will get a bottom digivolution card.");
+                            
+                            yield return ContinuousController.instance.StartCoroutine(
+                                selectPermanentEffect.Activate());
+                            
+                            IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                            {
+                                if (permanent != null)
+                                {
+                                    yield return ContinuousController.instance.StartCoroutine(
+                                        permanent.AddDigivolutionCardsBottom(selectedCards, activateClass));
+                                    
+                                    yield return ContinuousController.instance.StartCoroutine(
+                                        CardEffectCommons.PlaceDelayOptionCards(card: card, cardEffect: activateClass));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            
+            #endregion
+            
+            #region Delay Effect
+            
+            if (timing == EffectTiming.WhenRemoveField)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect(
+                    "Play 1 card with the [Legend-Arms] trait from the removed Digimon's digivolution cards without paying the cost",
+                    CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, 1, true, EffectDescription());
+                activateClass.SetHashString("PlayDigivolutionCard_EX6_065");
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[All Turns] When one of your Digimon would leave the battle area other than by one of your effects,[Delay] • You may play 1 card with the [Legend-Arms] trait from that Digimon's digivolution cards without paying the cost.";
+                }
+                
+                bool IsOwnerPermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                    {
+                        if (permanent.DigivolutionCards.Count(CanSelectLegendArmsSourceCardCondition) >= 1)
+                        {
+                            return true;
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool IsOwnerPermanentToBeDeletedCondition(Permanent permanent)
+                {
+                    if (IsOwnerPermanentCondition(permanent))
+                    {
+                        if (permanent.willBeRemoveField)
+                        {
+                            return true;
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanSelectLegendArmsSourceCardCondition(CardSource cardSource)
+                {
+                    if (cardSource.IsDigimon)
+                    {
+                        if (cardSource.CardTraits.Contains("Legend-Arms"))
+                        {
+                            if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false,
+                                    cardEffect: activateClass))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.CanDeclareOptionDelayEffect(card))
+                    {
+                        if (CardEffectCommons.CanTriggerWhenPermanentRemoveField(hashtable, IsOwnerPermanentCondition))
+                        {
+                            if (!CardEffectCommons.IsByEffect(hashtable,
+                                    cardEffect => CardEffectCommons.IsOwnerEffect(cardEffect, card)))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(
+                        CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(
+                            targetPermanents: new List<Permanent>() { card.PermanentOfThisCard() },
+                            activateClass: activateClass, successProcess: permanents => SuccessProcess(),
+                            failureProcess: null));
+                }
+                
+                IEnumerator SuccessProcess()
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(IsOwnerPermanentToBeDeletedCondition))
+                    {
+                        int maxCount = Math.Min(1,
+                            CardEffectCommons.MatchConditionPermanentCount(IsOwnerPermanentToBeDeletedCondition));
+                        
+                        SelectPermanentEffect selectPermanentEffect =
+                            GManager.instance.GetComponent<SelectPermanentEffect>();
+                        
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: IsOwnerPermanentToBeDeletedCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+                        
+                        selectPermanentEffect.SetUpCustomMessage(
+                            "Select 1 Digimon which has digivolution cards.",
+                            "The opponent is selecting 1 Digimon which has digivolution cards.");
+                        
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                        
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            Permanent selectedPermanent = permanent;
+                            
+                            if (selectedPermanent != null)
+                            {
+                                if (selectedPermanent.DigivolutionCards.Count(CanSelectLegendArmsSourceCardCondition) >= 1)
+                                {
+                                    maxCount = Math.Min(1,
+                                        selectedPermanent.DigivolutionCards.Count(CanSelectLegendArmsSourceCardCondition));
+                                    
+                                    List<CardSource> selectedCards = new List<CardSource>();
+                                    
+                                    SelectCardEffect selectCardEffect =
+                                        GManager.instance.GetComponent<SelectCardEffect>();
+                                    
+                                    selectCardEffect.SetUp(
+                                        canTargetCondition: CanSelectLegendArmsSourceCardCondition,
+                                        canTargetCondition_ByPreSelecetedList: null,
+                                        canEndSelectCondition: null,
+                                        canNoSelect: () => true,
+                                        selectCardCoroutine: SelectCardCoroutine,
+                                        afterSelectCardCoroutine: null,
+                                        message: "Select 1 digivolution card to play.",
+                                        maxCount: maxCount,
+                                        canEndNotMax: false,
+                                        isShowOpponent: true,
+                                        mode: SelectCardEffect.Mode.Custom,
+                                        root: SelectCardEffect.Root.Custom,
+                                        customRootCardList: selectedPermanent.DigivolutionCards,
+                                        canLookReverseCard: true,
+                                        selectPlayer: card.Owner,
+                                        cardEffect: activateClass);
+                                    
+                                    selectCardEffect.SetUpCustomMessage(
+                                        "Select 1 digivolution card to play.",
+                                        "The opponent is selecting 1 digivolution card to play.");
+                                    selectCardEffect.SetUpCustomMessage_ShowCard("Played Card");
+                                    
+                                    yield return StartCoroutine(selectCardEffect.Activate());
+                                    
+                                    IEnumerator SelectCardCoroutine(CardSource cardSource)
+                                    {
+                                        selectedCards.Add(cardSource);
+                                        
+                                        yield return null;
+                                    }
+                                    
+                                    yield return ContinuousController.instance.StartCoroutine(
+                                        CardEffectCommons.PlayPermanentCards(
+                                            cardSources: selectedCards,
+                                            activateClass: activateClass,
+                                            payCost: false,
+                                            isTapped: false,
+                                            root: SelectCardEffect.Root.DigivolutionCards,
+                                            activateETB: true));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            
+            #endregion
+            
+            #region Security Effect
+            
+            if (timing == EffectTiming.SecuritySkill)
+            {
+                CardEffectCommons.AddActivateMainOptionSecurityEffect(card: card, cardEffects: ref cardEffects,
+                    effectName: card.BaseENGCardNameFromEntity);
+            }
+            
+            #endregion
+            
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX6/Red/Mythical_Arms_of_Salvation_EX6_065.cs.meta

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

Assets/CardEffect/EX6/Red/RagnaLoardmonAce_EX6_011.cs

@@ -0,0 +1,368 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System;
+
+namespace DCGO.CardEffects.EX6
+{
+    public class RagnaLoardmonAce_EX6_011 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+            
+            #region Blast Digivolve
+            
+            if (timing == EffectTiming.OnCounterTiming)
+            {
+                cardEffects.Add(CardEffectFactory.BlastDigivolveEffect(card: card, condition: null));
+            }
+            
+            #endregion
+            
+            #region DNA Digivolution
+            
+            if (timing == EffectTiming.None)
+            {
+                AddJogressConditionClass addJogressConditionClass = new AddJogressConditionClass();
+                addJogressConditionClass.SetUpICardEffect($"DNA Digivolution", CanUseCondition, card);
+                addJogressConditionClass.SetUpAddJogressConditionClass(getJogressCondition: GetJogress);
+                addJogressConditionClass.SetNotShowUI(true);
+                cardEffects.Add(addJogressConditionClass);
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return true;
+                }
+                
+                JogressCondition GetJogress(CardSource cardSource)
+                {
+                    if (cardSource == card)
+                    {
+                        bool PermanentCondition1(Permanent permanent)
+                        {
+                            if (permanent != null)
+                            {
+                                if (permanent.TopCard != null)
+                                {
+                                    if (permanent.TopCard.Owner == card.Owner)
+                                    {
+                                        if (permanent.IsDigimon)
+                                        {
+                                            if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent,
+                                                    card))
+                                            {
+                                                if (permanent.TopCard.CardColors.Contains(CardColor.Red))
+                                                {
+                                                    if (permanent.Levels_ForJogress(card).Contains(6))
+                                                    {
+                                                        return true;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            
+                            return false;
+                        }
+                        
+                        bool PermanentCondition2(Permanent permanent)
+                        {
+                            if (permanent != null)
+                            {
+                                if (permanent.TopCard != null)
+                                {
+                                    if (permanent.TopCard.Owner == card.Owner)
+                                    {
+                                        if (permanent.IsDigimon)
+                                        {
+                                            if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent,
+                                                    card))
+                                            {
+                                                if (permanent.TopCard.CardColors.Contains(CardColor.Black))
+                                                {
+                                                    if (permanent.Levels_ForJogress(card).Contains(6))
+                                                    {
+                                                        return true;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            
+                            return false;
+                        }
+                        
+                        JogressConditionElement[] elements = new JogressConditionElement[]
+                        {
+                            new JogressConditionElement(PermanentCondition1, "a level 6 Red Digimon"),
+                            
+                            new JogressConditionElement(PermanentCondition2, "a level 6 Black Digimon"),
+                        };
+                        
+                        JogressCondition jogressCondition = new JogressCondition(elements, 0);
+                        
+                        return jogressCondition;
+                    }
+                    
+                    return null;
+                }
+            }
+            
+            #endregion
+            
+            #region Raid
+            
+            if (timing == EffectTiming.OnAllyAttack)
+            {
+                cardEffects.Add(CardEffectFactory.RaidSelfEffect(isInheritedEffect: false, card: card,
+                    condition: null));
+            }
+            
+            #endregion
+            
+            #region Reboot
+            
+            if (timing == EffectTiming.None)
+            {
+                cardEffects.Add(CardEffectFactory.RebootSelfStaticEffect(
+                    isInheritedEffect: false,
+                    card: card,
+                    condition: null));
+            }
+            
+            #endregion
+            
+            #region Shared On Play / When Digivolving
+            
+            string EffectSharedDescription()
+            {
+                return
+                    "[On Play] [When Digivolving] Trash the top card of your opponent's security stack and this Digimon isn't affected by your opponent's effects until the end of their turn. Then, if DNA digivolving,  all of your opponent's Digimon (Trash the top card. You can't trash past level 3 cards) and delete 1 of their Digimon.";
+            }
+            
+            bool CanActivateSharedCondition(Hashtable hashtable)
+            {
+                return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+            }
+            
+            bool CanUseImmunitySharedCondition(Hashtable hashtableI)
+            {
+                return CardEffectCommons.IsPermanentExistsOnBattleArea(card.PermanentOfThisCard());
+            }
+            
+            bool CardImmunitySharedCondition(CardSource cardSource)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (cardSource == card.PermanentOfThisCard().TopCard)
+                    {
+                        return true;
+                    }
+                }
+                
+                return false;
+            }
+            
+            bool SkillImmunitySharedCondition(ICardEffect cardEffect)
+            {
+                if (cardEffect != null)
+                {
+                    if (cardEffect.EffectSourceCard)
+                    {
+                        if (CardEffectCommons.IsOpponentEffect(cardEffect, card))
+                        {
+                            if (cardEffect.IsDigimonEffect)
+                            {
+                                return true;
+                            }
+                            
+                            if (cardEffect.EffectSourceCard.IsOption)
+                            {
+                                return true;
+                            }
+                            
+                            if (cardEffect.IsTamerEffect)
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                }
+                
+                return false;
+            }
+            
+            bool IsEnemyPermanentShared(Permanent permanent)
+            {
+                if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        return true;
+                    }
+                }
+                
+                return false;
+            }
+            
+            #endregion
+            
+            #region On Play
+            
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect(
+                    "Trash the top card of your opponent's security stack and this Digimon isn't affected by your opponent's effects until the end of their turn.",
+                    CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateSharedCondition, ActivateCoroutine, -1, false,
+                    EffectSharedDescription());
+                cardEffects.Add(activateClass);
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    // Trash Top of Opponent's Security Stack
+                    yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
+                        player: card.Owner.Enemy,
+                        destroySecurityCount: 1,
+                        cardEffect: activateClass,
+                        fromTop: true).DestroySecurity());
+                    
+                    // This Digimon isn't affected by your opponent's effects until the end of their turn.
+                    CanNotAffectedClass canNotAffectedClass = new CanNotAffectedClass();
+                    canNotAffectedClass.SetUpICardEffect("Isn't affected by opponent's Digimon's effects",
+                        CanUseImmunitySharedCondition, card);
+                    canNotAffectedClass.SetUpCanNotAffectedClass(CardCondition: CardImmunitySharedCondition,
+                        SkillCondition: SkillImmunitySharedCondition);
+                    card.PermanentOfThisCard().UntilOpponentTurnEndEffects.Add(_ => canNotAffectedClass);
+                    
+                    
+                    // if DNA Digivolving
+                    if (CardEffectCommons.IsJogress(hashtable))
+                    {
+                        // De-Digivolve all Opponent's Digimon
+                        List<Permanent> enemyPermanents = card.Owner.Enemy.GetBattleAreaDigimons().ToList();
+                        
+                        foreach (Permanent permanent in enemyPermanents)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(
+                                new IDegeneration(permanent, 1, activateClass).Degeneration());
+                        }
+                        
+                        // Delete 1 Opponent's Digimon
+                        if (CardEffectCommons.HasMatchConditionPermanent(IsEnemyPermanentShared))
+                        {
+                            int enemyCount = Math.Min(1,
+                                CardEffectCommons.MatchConditionPermanentCount(IsEnemyPermanentShared));
+                            
+                            SelectPermanentEffect selectEnemyEffect =
+                                GManager.instance.GetComponent<SelectPermanentEffect>();
+                            
+                            selectEnemyEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: IsEnemyPermanentShared,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: enemyCount,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: null,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Destroy,
+                                cardEffect: activateClass);
+                        }
+                    }
+                }
+            }
+            
+            #endregion
+            
+            #region When Digivolving
+            
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect(
+                    "Trash the top card of your opponent's security stack and this Digimon isn't affected by your opponent's effects until the end of their turn.",
+                    CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateSharedCondition, ActivateCoroutine, -1, false,
+                    EffectSharedDescription());
+                cardEffects.Add(activateClass);
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    // Trash Top of Opponent's Security Stack
+                    yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
+                        player: card.Owner.Enemy,
+                        destroySecurityCount: 1,
+                        cardEffect: activateClass,
+                        fromTop: true).DestroySecurity());
+                    
+                    // This Digimon isn't affected by your opponent's effects until the end of their turn.
+                    CanNotAffectedClass canNotAffectedClass = new CanNotAffectedClass();
+                    canNotAffectedClass.SetUpICardEffect("Isn't affected by opponent's Digimon's effects",
+                        CanUseImmunitySharedCondition, card);
+                    canNotAffectedClass.SetUpCanNotAffectedClass(CardCondition: CardImmunitySharedCondition,
+                        SkillCondition: SkillImmunitySharedCondition);
+                    cardEffects.Add(canNotAffectedClass);
+                    
+                    
+                    // if DNA Digivolving
+                    if (CardEffectCommons.IsJogress(hashtable))
+                    {
+                        // De-Digivolve all Opponent's Digimon
+                        List<Permanent> enemyPermanents = card.Owner.Enemy.GetBattleAreaDigimons().ToList();
+                        
+                        foreach (Permanent permanent in enemyPermanents)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(
+                                new IDegeneration(permanent, 1, activateClass).Degeneration());
+                        }
+                        
+                        // Delete 1 Opponent's Digimon
+                        if (CardEffectCommons.HasMatchConditionPermanent(IsEnemyPermanentShared))
+                        {
+                            int enemyCount = Math.Min(1,
+                                CardEffectCommons.MatchConditionPermanentCount(IsEnemyPermanentShared));
+                            
+                            SelectPermanentEffect selectEnemyEffect =
+                                GManager.instance.GetComponent<SelectPermanentEffect>();
+                            
+                            selectEnemyEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: IsEnemyPermanentShared,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: enemyCount,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: null,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Destroy,
+                                cardEffect: activateClass);
+                        }
+                    }
+                }
+            }
+            
+            #endregion
+            
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX6/Red/RagnaLoardmonAce_EX6_011.cs.meta

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

Assets/CardEffect/EX6/Red/Sakuttomon_EX6_001.cs

@@ -0,0 +1,66 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace DCGO.CardEffects.EX6
+{
+    public class Sakuttomon_EX6_001 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+            
+            #region Your Turn - ESS
+            
+            if (timing == EffectTiming.OnAddDigivolutionCards)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Gain 1 Memory", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false,
+                    EffectDescription());
+                activateClass.SetIsInheritedEffect(true);
+                activateClass.SetHashString("Gain1Memory_EX6_001");
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[Your Turn] [Once Per Turn] When an effect places a card with the [Legend-Arms] trait in this Digimon's digivolution cards, gain 1 memory.";
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.IsOwnerTurn(card))
+                        {
+                            if (CardEffectCommons.CanTriggerOnAddDigivolutionCard(
+                                    hashtable: hashtable,
+                                    permanentCondition: permanent => permanent == card.PermanentOfThisCard(),
+                                    cardEffectCondition: cardEffect => cardEffect.EffectSourceCard != null,
+                                    cardCondition: cardSource => cardSource.ContainsTraits("Legend-Arms")))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(card);
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(1, activateClass));
+                }
+            }
+            
+            #endregion
+            
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX6/Red/Sakuttomon_EX6_001.cs.meta

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

Assets/CardEffect/EX6/Red/ZubaEagermon_EX6_008.cs

@@ -0,0 +1,208 @@
+using System.Collections;
+using System.Collections.Generic;
+using System;
+
+namespace DCGO.CardEffects.EX6
+{
+    public class ZubaEagermon_EX6_008 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Alternate Digivolution
+            if (timing == EffectTiming.None)
+            {
+                static bool PermanentCondition(Permanent targetPermanent)
+                {
+                    if (targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.Level == 3)
+                    {
+                        return targetPermanent.TopCard.ContainsTraits("Legend-Arms");
+                    }
+
+                    return false;
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 2,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null));
+            }
+            #endregion
+
+            #region Hand - Main
+            if (timing == EffectTiming.OnDeclaration)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("+4000 DP", CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDescription());
+                cardEffects.Add(activateClass);
+
+                string EffectDescription()
+                {
+                    return "[Hand] [Main] By paying 1 cost and placing this card as the bottom digivolution card of 1 of your Digimon that's level 4 or has the [Legend-Arms] trait, that Digimon gets +4000 DP for the turn.";
+                }
+
+                bool IsLevel4OrHasLegendArmsTrait(Permanent targetPermanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(targetPermanent, card))
+                    {
+                        if (targetPermanent.TopCard.HasLevel && targetPermanent.Level == 4)
+                            return true;
+
+                        if (targetPermanent.TopCard.ContainsTraits("Legend-Arms"))
+                            return true;
+                    }
+
+                    return false;
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnHand(card))
+                    {
+                        if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, IsLevel4OrHasLegendArmsTrait))
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(IsLevel4OrHasLegendArmsTrait))
+                    {
+                        Permanent selectedPermanent = null;
+
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(IsLevel4OrHasLegendArmsTrait));
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: IsLevel4OrHasLegendArmsTrait,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to add bottom digivolution source.", "The opponent is selecting 1 Digimon to add bottom digivolution source.");
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            selectedPermanent = permanent;
+                            yield return null;
+                        }
+
+                        if (selectedPermanent != null)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(-1, activateClass));
+
+                            yield return ContinuousController.instance.StartCoroutine(selectedPermanent.AddDigivolutionCardsBottom(
+                                new List<CardSource>() { card },
+                                activateClass));
+
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
+                                targetPermanent: selectedPermanent,
+                                changeValue: 4000,
+                                effectDuration: EffectDuration.UntilEachTurnEnd,
+                                activateClass: activateClass));
+                        }
+                    }
+                }
+            }
+            #endregion
+
+            #region Your Turn - Place Digivolution
+            if (timing == EffectTiming.OnAddDigivolutionCards)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Gain <Raid> and <Piercing>", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+                activateClass.SetHashString("GainEffects_EX6_008");
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[Your Turn] [Once Per Turn] When an effect places a digivolution card under this Digimon, it gains <Raid> and <Piercing> for the turn.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.IsOwnerTurn(card))
+                        {
+                            if (CardEffectCommons.CanTriggerOnAddDigivolutionCard(
+                                hashtable: hashtable,
+                                permanentCondition: permanent => permanent == card.PermanentOfThisCard(),
+                                cardEffectCondition: cardEffect => cardEffect.EffectSourceCard != null,
+                                cardCondition: null))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(card);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainRaid(
+                                targetPermanent: card.PermanentOfThisCard(),
+                                effectDuration: EffectDuration.UntilEachTurnEnd,
+                                activateClass: activateClass));
+
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainPierce(
+                                targetPermanent: card.PermanentOfThisCard(),
+                                effectDuration: EffectDuration.UntilEachTurnEnd,
+                                activateClass: activateClass));
+                }
+            }
+            #endregion
+
+            #region Your Turn - ESS
+            if (timing == EffectTiming.None)
+            {
+                bool Condition()
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.IsOwnerTurn(card))
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect(
+                    changeValue: 2000,
+                    isInheritedEffect: true,
+                    card: card,
+                    condition: Condition));
+            }
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX6/Red/ZubaEagermon_EX6_008.cs.meta

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

Assets/CardEffect/EX6/Red/Zubamon_EX6_007.cs

@@ -0,0 +1,213 @@
+using System.Collections;
+using System.Collections.Generic;
+using System;
+
+namespace DCGO.CardEffects.EX6
+{
+    public class Zubamon_EX6_007 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+            
+            #region Alternate Digivolution
+            
+            if (timing == EffectTiming.None)
+            {
+                static bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.CardNames.Contains("Sakuttomon") &&
+                           targetPermanent.TopCard.CardNames.Contains("Kakkinmon");
+                }
+                
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 0,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null));
+            }
+            
+            #endregion
+            
+            #region Hand - Main
+            
+            if (timing == EffectTiming.OnDeclaration)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("+4000 DP", CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDescription());
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[Hand] [Main] By paying 1 cost and placing this card as the bottom digivolution card of 1 of your Digimon that's level 3 or has the [Legend-Arms] trait, that Digimon gets +4000 DP for the turn.";
+                }
+                
+                bool IsLevel3OrHasLegendArmsTrait(Permanent targetPermanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(targetPermanent, card))
+                    {
+                        if (targetPermanent.TopCard.HasLevel && targetPermanent.Level == 3)
+                            return true;
+                        
+                        if (targetPermanent.TopCard.ContainsTraits("Legend-Arms"))
+                            return true;
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnHand(card))
+                    {
+                        if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, IsLevel3OrHasLegendArmsTrait))
+                        {
+                            return true;
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(IsLevel3OrHasLegendArmsTrait))
+                    {
+                        Permanent selectedPermanent = null;
+                        
+                        int maxCount = Math.Min(1,
+                            CardEffectCommons.MatchConditionPermanentCount(IsLevel3OrHasLegendArmsTrait));
+                        
+                        SelectPermanentEffect selectPermanentEffect =
+                            GManager.instance.GetComponent<SelectPermanentEffect>();
+                        
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: IsLevel3OrHasLegendArmsTrait,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+                        
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to add bottom digivolution source.",
+                            "The opponent is selecting 1 Digimon to add bottom digivolution source.");
+                        
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                        
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            selectedPermanent = permanent;
+                            yield return null;
+                        }
+                        
+                        if (selectedPermanent != null)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(
+                                card.Owner.AddMemory(-1, activateClass));
+                            
+                            yield return ContinuousController.instance.StartCoroutine(
+                                selectedPermanent.AddDigivolutionCardsBottom(
+                                    new List<CardSource>() { card },
+                                    activateClass));
+                            
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
+                                targetPermanent: selectedPermanent,
+                                changeValue: 4000,
+                                effectDuration: EffectDuration.UntilEachTurnEnd,
+                                activateClass: activateClass));
+                        }
+                    }
+                }
+            }
+            
+            #endregion
+            
+            #region Your Turn - Place Digivolution
+            
+            if (timing == EffectTiming.OnAddDigivolutionCards)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Draw 1", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false,
+                    EffectDescription());
+                activateClass.SetHashString("Draw1_EX6_007");
+                cardEffects.Add(activateClass);
+                
+                string EffectDescription()
+                {
+                    return
+                        "[Your Turn] [Once Per Turn] When an effect places a digivolution card under this Digimon, <Draw 1>.";
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.IsOwnerTurn(card))
+                        {
+                            if (CardEffectCommons.CanTriggerOnAddDigivolutionCard(
+                                    hashtable: hashtable,
+                                    permanentCondition: permanent => permanent == card.PermanentOfThisCard(),
+                                    cardEffectCondition: cardEffect => cardEffect.EffectSourceCard != null,
+                                    cardCondition: null))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(card);
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(
+                        new DrawClass(card.Owner, 1, activateClass).Draw());
+                }
+            }
+            
+            #endregion
+            
+            #region Your Turn - ESS
+            
+            if (timing == EffectTiming.None)
+            {
+                bool Condition()
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.IsOwnerTurn(card))
+                        {
+                            return true;
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect(
+                    changeValue: 2000,
+                    isInheritedEffect: true,
+                    card: card,
+                    condition: Condition));
+            }
+            
+            #endregion
+            
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/EX6/Red/Zubamon_EX6_007.cs.meta

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