Day 1 updates

Assets/CardBaseEntity/EX7/Blue/Digimon/SnowAgumon-EX7-017.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:589c8cee2e6bc12262889f164512a500d4afe1f384ff07722387711bb97f630b
-size 1317
+oid sha256:e54e0accc26ff134c2bf333d2ae414aab9067d914d34f4a07a82a0ec043a9fdd
+size 1362

Assets/CardBaseEntity/EX7/Blue/Digimon/SnowAgumon-EX7-017_P1.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:aa5639e6f9c2a26403fc5da8be60e67e9ad327f6ac4e8f17a038b4ae218933e2
-size 1323
+oid sha256:6c221fe89c6f8e578bb7e814563361824fac8087cb69f4363597d7095c70af6e
+size 1368

Assets/CardBaseEntity/EX7/Purple/Digimon/Loudmon-EX7-057.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:221f02d8fb52bc17e43c36506fb39a85d296e68987a185dba6d0888acce3af21
-size 1529
+oid sha256:0664c2bcb316946a7e4e67fd453c60030002bdc30a3af3fb825e6e0ba5fc12f2
+size 1545

Assets/CardBaseEntity/EX7/Purple/Digimon/Loudmon-EX7-057_P1.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:34c4f9a6408cf6a1c36b5537a6de508f81e72450a270b7bb41f60a9c7a023b31
-size 1535
+oid sha256:f10ae7d3b48321b5f1ef44bc33195e0d3b00d4203fced7b68cd6f0e9ff843658
+size 1551

Assets/CardEffect/EX7/Black/Gigadramon_EX7_044.cs

@@ -204,7 +204,7 @@ namespace DCGO.CardEffects.EX7
 
             #region Collision - ESS
 
-            if (timing == EffectTiming.None)
+            if (timing == EffectTiming.OnCounterTiming)
             {
                 cardEffects.Add(CardEffectFactory.CollisionSelfStaticEffect(
                     isInheritedEffect: true,

Assets/CardEffect/EX7/Black/Gundramon_EX7_048.cs

@@ -16,7 +16,7 @@ namespace DCGO.CardEffects.EX7
             {
                 bool PermanentCondition(Permanent targetPermanent)
                 {
-                    return targetPermanent.TopCard.IsLevel5 && targetPermanent.TopCard.ContainsTraits("Three Musketeers");
+                    return targetPermanent.TopCard.IsLevel5 && targetPermanent.TopCard.HasText("Three Musketeers");
                 }
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(

Assets/CardEffect/EX7/Black/Tankmon_EX7_043.cs

@@ -16,7 +16,7 @@ namespace DCGO.CardEffects.EX7
             {
                 bool PermanentCondition(Permanent targetPermanent)
                 {
-                    return targetPermanent.TopCard.IsLevel3 && targetPermanent.TopCard.ContainsTraits("Three Musketeers");
+                    return targetPermanent.TopCard.IsLevel3 && targetPermanent.TopCard.HasText("Three Musketeers");
                 }
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(

Assets/CardEffect/EX7/Blue/Gekomon_EX7_018.cs

@@ -14,7 +14,10 @@ namespace DCGO.CardEffects.EX7
             {
                 bool PermanentCondition(Permanent targetPermanent)
                 {
-                    return targetPermanent.TopCard.CardTraits.Contains("NSp");
+                    if(targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.Level == 3)
+                        return targetPermanent.TopCard.ContainsTraits("NSp");
+
+                    return false;
                 }
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
@@ -53,12 +56,7 @@ namespace DCGO.CardEffects.EX7
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
-                    {
-                        return true;
-                    }
-
-                    return false;
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
@@ -88,7 +86,7 @@ namespace DCGO.CardEffects.EX7
                 {
                     if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
                     {
-                        return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                        return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
                     }
 
                     return false;
@@ -96,12 +94,7 @@ namespace DCGO.CardEffects.EX7
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
-                    {
-                        return true;
-                    }
-
-                    return false;
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)

Assets/CardEffect/EX7/Blue/Hexeblaumon_EX7_023.cs

@@ -170,48 +170,36 @@ namespace DCGO.CardEffects.EX7
                     {
                         foreach (Permanent affected in card.Owner.Enemy.GetBattleAreaPermanents())
                         {
-                            if (CanSelectPermanentToNoSuspend(affected))
+                            if (!affected.IsDigimon)
+                                continue;
+
+                            if (affected.TopCard.CanNotBeAffected(activateClass))
+                                continue;
+
+                            if (affected.DigivolutionCards.Count > card.PermanentOfThisCard().DigivolutionCards.Count)
+                            {
                                 StartCoroutine(SelectPermanentCoroutine(affected));
+                            }
+                                
                         }
                         
                         IEnumerator SelectPermanentCoroutine(Permanent permanent)
                         {
-                            Permanent selectedPermanent = permanent;
+                            CanNotSuspendClass canNotSuspendClass = new CanNotSuspendClass();
+                            canNotSuspendClass.SetUpICardEffect("Can't Suspend", CanUseCondition1, card);
+                            canNotSuspendClass.SetUpCanNotSuspendClass(PermanentCondition: PermanentCondition);
+                            permanent.UntilOwnerTurnEndEffects.Add((_timing) => canNotSuspendClass);
+
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(permanent));
+
+                            bool CanUseCondition1(Hashtable hashtable)
+                            {
+                                return true;
+                            }
 
-                            if (selectedPermanent != null)
+                            bool PermanentCondition(Permanent permanent)
                             {
-                                CanNotSuspendClass canNotSuspendClass = new CanNotSuspendClass();
-                                canNotSuspendClass.SetUpICardEffect("Can't Suspend", CanUseCondition1, card);
-                                canNotSuspendClass.SetUpCanNotSuspendClass(PermanentCondition: PermanentCondition);
-                                selectedPermanent.UntilOwnerTurnEndEffects.Add((_timing) => canNotSuspendClass);
-
-                                if (!selectedPermanent.TopCard.CanNotBeAffected(activateClass))
-                                {
-                                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(selectedPermanent));
-                                }
-
-                                bool CanUseCondition1(Hashtable hashtable)
-                                {
-                                    if (selectedPermanent.TopCard != null)
-                                    {
-                                        if (!selectedPermanent.TopCard.CanNotBeAffected(activateClass))
-                                        {
-                                            return true;
-                                        }
-                                    }
-
-                                    return false;
-                                }
-
-                                bool PermanentCondition(Permanent permanent)
-                                {
-                                    if (permanent == selectedPermanent)
-                                    {
-                                        return true;
-                                    }
-
-                                    return false;
-                                }
+                                return true;
                             }
                         }
                     }

Assets/CardEffect/EX7/Blue/Sorcermon_EX7_019.cs

@@ -10,12 +10,15 @@ namespace DCGO.CardEffects.EX7
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
-            
+
+            #region Blocker
             if (timing == EffectTiming.None)
             {
                 cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(isInheritedEffect: false, card: card, condition: null));
             }
-            
+            #endregion
+
+            #region On Play
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -25,40 +28,37 @@ namespace DCGO.CardEffects.EX7
 
                 string EffectDiscription()
                 {
-                    return " If your opponent has no Digimon with digivolution cards, unsuspend 1 of your Digimon.";
+                    return "[On Play] If your opponent has no Digimon with digivolution cards, unsuspend 1 of your Digimon.";
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return true;
+                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                        return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+
+                    return false;
                 }
 
                 bool CanSelectDigimonCondition(Permanent permanent)
                 {
-                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card))
-                    {
-                        if (permanent.IsDigimon)
-                        {
-                            return true;
-                        }
-                    }
-                    return false;
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.HasMatchConditionOwnersPermanent(card,
-                            ((permanent) => permanent.IsDigimon && permanent.HasNoDigivolutionCards)))
+                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
                     {
-                        return true;
+                        if (CardEffectCommons.HasMatchConditionOpponentsPermanent(card,(permanent) => permanent.IsDigimon && permanent.HasNoDigivolutionCards))
+                        {
+                            return true;
+                        }
                     }
+                        
                     return false;
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
-                {
-                    Permanent selectedPermanent = null;
-                    
+                {                   
                     if (CardEffectCommons.HasMatchConditionPermanent(CanSelectDigimonCondition))
                     {
                         int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectDigimonCondition));
@@ -73,38 +73,20 @@ namespace DCGO.CardEffects.EX7
                             maxCount: maxCount,
                             canNoSelect: false,
                             canEndNotMax: false,
-                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            selectPermanentCoroutine: null,
                             afterSelectPermanentCoroutine: null,
-                            mode: SelectPermanentEffect.Mode.Custom,
+                            mode: SelectPermanentEffect.Mode.UnTap,
                             cardEffect: activateClass);
 
                         selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will unsuspend", "The opponent is selecting 1 Digimon to unsuspend.");
 
                         yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                        {
-                            selectedPermanent = permanent;
-
-                            yield return null;
-                        }
-
-                        if (selectedPermanent != null)
-                        {
-                            if (selectedPermanent.TopCard != null)
-                            {
-                                if (selectedPermanent.TopCard.CanNotBeAffected(activateClass))
-                                {
-                                    Permanent suspendTargetPermanent = selectedPermanent;
-
-                                    yield return ContinuousController.instance.StartCoroutine(new SuspendPermanentsClass(new List<Permanent>() { suspendTargetPermanent }, CardEffectCommons.CardEffectHashtable(activateClass)).Tap());
-                                }
-                            }
-                        }
                     }
                 }
             }
+            #endregion
 
+            #region When Attacking
             if (timing == EffectTiming.OnAllyAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -183,6 +165,8 @@ namespace DCGO.CardEffects.EX7
                     }
                 }
             }
+            #endregion
+
             return cardEffects;
         }
     }

Assets/CardEffect/EX7/Purple/BlackGatomon_EX7_054.cs

@@ -27,7 +27,7 @@ namespace DCGO.CardEffects.EX7
                 {
                     if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
                     {
-                        return true;
+                        return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
                     }
 
                     return false;

Assets/CardEffect/EX7/Purple/LadyDevimonXAntibody_EX7_058.cs

@@ -43,21 +43,181 @@ namespace DCGO.CardEffects.EX7
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                        return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+
+                    return false;
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                }
+
+                bool CanActivateSecondEffectCondition(Hashtable hashtable)
                 {
                     if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
                     {
-                        if (card.Owner.HandCards.Count >= 1)
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                         {
-                            return true;
+                            if (card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) => cardSource.CardNames.Contains("LadyDevimon") || cardSource.CardNames.Contains("X Antibody") || cardSource.CardNames.Contains("XAntibody")) >= 1)
+                            {
+                                return true;
+                            }
                         }
                     }
+
                     return false;
                 }
 
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    {
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect.SetUpCustomMessage(
+                            "Select 1 Digimon that will get [End of Attack] Delete this Digimon.",
+                            "The opponent is selecting 1 Digimon that will get [End of Attack] Delete this Digimon.");
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            Permanent selectedPermanent = permanent;
+
+                            if (selectedPermanent != null)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(selectedPermanent));
+                            }
+
+                            if (selectedPermanent != null)
+                            {
+                                ActivateClass activateClass1 = new ActivateClass();
+                                activateClass1.SetUpICardEffect("Delete this Digimon", CanUseCondition1, selectedPermanent.TopCard);
+                                activateClass1.SetUpActivateClass(CanActivateCondition1, ActivateCoroutine1, -1, false, EffectDiscription1());
+                                activateClass1.SetEffectSourcePermanent(selectedPermanent);
+                                selectedPermanent.UntilOwnerTurnEndEffects.Add(GetCardEffect);
+
+                                if (!permanent.TopCard.CanNotBeAffected(activateClass))
+                                {
+                                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(selectedPermanent));
+                                }
+
+                                string EffectDiscription1()
+                                {
+                                    return "[End of Attack] Delete this Digimon.";
+                                }
+
+                                bool CanUseCondition1(Hashtable hashtable1)
+                                {
+                                    if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent))
+                                    {
+                                        if (CardEffectCommons.CanTriggerOnAttack(hashtable, selectedPermanent.TopCard))
+                                        {
+                                            if (selectedPermanent.TopCard.Owner.GetBattleAreaDigimons().Contains(selectedPermanent))
+                                            {
+                                                if (GManager.instance.turnStateMachine.gameContext.TurnPlayer == selectedPermanent.TopCard.Owner)
+                                                {
+                                                    return true;
+                                                }
+                                            }
+                                        }
+                                    }
+
+                                    return false;
+                                }
+
+                                bool CanActivateCondition1(Hashtable hashtable1)
+                                {
+                                    if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent))
+                                    {
+                                        if (!permanent.TopCard.CanNotBeAffected(activateClass))
+                                        {
+                                            return true;
+                                        }
+                                    }
+
+                                    return false;
+                                }
+
+                                IEnumerator ActivateCoroutine1(Hashtable _hashtable1)
+                                {
+                                    if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent))
+                                    {
+                                        yield return ContinuousController.instance.StartCoroutine(new DestroyPermanentsClass(
+                                        new List<Permanent>() { selectedPermanent },
+                                        CardEffectCommons.CardEffectHashtable(activateClass1)).Destroy());
+                                    }
+                                }
+
+                                ICardEffect GetCardEffect(EffectTiming _timing)
+                                {
+                                    if (_timing == EffectTiming.OnEndAttack)
+                                    {
+                                        return activateClass1;
+                                    }
+
+                                    return null;
+                                }
+                            }
+                        }
+                    }
+
+                    if (CanActivateSecondEffectCondition(hashtable))
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayVoléeZerdrücken(activateClass));
+                    }
+                }
+            }
+            #endregion
+
+            #region When Digivolving
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Give effects to opponent's Digimon and play a Token", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] 1 of your opponent's Digimon gains \" Delete this Digimon.\" until the end of their turn. Then, if this Digimon has [LadyDevimon]/[X Antibody] in its digivolution cards, you may play 1 [Volée & Zerdrücken] Token (Digimon/Lv.4/Purple/5000 DP/<Blocker>/<Retaliation>).";
+                }
+
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if(CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                        return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+
+                    return false;
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                }
+
                 bool CanActivateSecondEffectCondition(Hashtable hashtable)
                 {
                     if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))

Assets/CardEffect/EX7/Purple/Loudmon_EX7_057.cs

@@ -30,31 +30,6 @@ namespace DCGO.CardEffects.EX7
             }
             #endregion
 
-            #region Rule Text
-            if (timing == EffectTiming.None)
-            {
-                ChangeTraitsClass changeTraitsClass = new ChangeTraitsClass();
-                changeTraitsClass.SetUpICardEffect("Has the [Dark Dragon] 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("Dark Dragon");
-                    }
-
-                    return CardTraits;
-                }
-            }
-            #endregion
-
             #region On Play
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
@@ -70,20 +45,15 @@ namespace DCGO.CardEffects.EX7
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                    if(CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                        return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+
+                    return false;
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
-                    {
-                        if (card.Owner.HandCards.Count >= 1)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
                 }
 
                 bool CanSelectPermanentCondition(Permanent permanent)
@@ -254,36 +224,36 @@ namespace DCGO.CardEffects.EX7
             #region Inherit
             if (timing == EffectTiming.None)
             {
-                bool CanUseCondition()
+                bool PermanentCondition(Permanent permanent)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
                     {
-                        if (CardEffectCommons.IsOwnerTurn(card))
+                        if (permanent.TopCard.ContainsTraits("Dark Dragon") || permanent.TopCard.ContainsTraits("Evil Dragon"))
                         {
-                            if (card.Owner.HandCards.Count <= 4)
-                            {
-                                return true;
-                            }
+                            return true;
                         }
                     }
 
                     return false;
                 }
 
-                bool PermanentCondition(Permanent permanent)
+                bool CanUseCondition()
                 {
-                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
                     {
-                        if (permanent.TopCard.CardTraits.Contains("Dark Dragon") || permanent.TopCard.CardTraits.Contains("Evil Dragon"))
+                        if (CardEffectCommons.IsOwnerTurn(card))
                         {
-                            return true;
+                            if (card.Owner.HandCards.Count <= 4)
+                            {
+                                return true;
+                            }
                         }
                     }
 
                     return false;
                 }
 
-                cardEffects.Add(CardEffectFactory.BlockerStaticEffect(permanentCondition: PermanentCondition, isInheritedEffect: true, card: card, condition: CanUseCondition));
+                cardEffects.Add(CardEffectFactory.ChangeSAttackStaticEffect(PermanentCondition, 1, true, card, CanUseCondition));
             }
             #endregion
 

Assets/CardEffect/EX7/Red/Deputymon_EX7_010.cs

@@ -42,13 +42,10 @@ namespace DCGO.CardEffects.EX7
                 {
                     if(!cardSource.CanNotTrashFromDigivolutionCards(activateClass))
                     {
-                        foreach (CardSource card in cardSource.PermanentOfThisCard().DigivolutionCards)
+                        if (cardSource.IsOption)
                         {
-                            if (card.IsOption)
-                            {
-                                return true;
-                            }
-                        }                                            
+                            return true;
+                        }
                     }
 
                     return false;
@@ -56,18 +53,7 @@ namespace DCGO.CardEffects.EX7
 
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card))
-                    {
-                        if (permanent.IsDigimon)
-                        {
-                            if (permanent.DigivolutionCards.Count(CanSelectCardCondition) >= 1)
-                            {
-                                return true;
-                            }
-                        }
-                    }
-
-                    return false;
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -85,12 +71,7 @@ namespace DCGO.CardEffects.EX7
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
-                    {                      
-                        return true;                       
-                    }
-
-                    return false;
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
@@ -126,12 +107,9 @@ namespace DCGO.CardEffects.EX7
                 {
                     if (!cardSource.CanNotTrashFromDigivolutionCards(activateClass))
                     {
-                        foreach (CardSource card in cardSource.PermanentOfThisCard().DigivolutionCards)
+                        if (cardSource.IsOption)
                         {
-                            if (card.IsOption)
-                            {
-                                return true;
-                            }
+                            return true;
                         }
                     }
 
@@ -140,18 +118,7 @@ namespace DCGO.CardEffects.EX7
 
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card))
-                    {
-                        if (permanent.IsDigimon)
-                        {
-                            if (permanent.DigivolutionCards.Count(CanSelectCardCondition) >= 1)
-                            {
-                                return true;
-                            }
-                        }
-                    }
-
-                    return false;
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -169,12 +136,7 @@ namespace DCGO.CardEffects.EX7
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
-                    {
-                        return true;
-                    }
-
-                    return false;
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
@@ -202,11 +164,14 @@ namespace DCGO.CardEffects.EX7
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                    if (CardEffectCommons.IsOwnerTurn(card))
                     {
-                        if (CardEffectCommons.IsOwnerTurn(card))
+                        if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
                         {
-                           return true;
+                            if(card.PermanentOfThisCard().TopCard == card)
+                            { 
+                                return true;
+                            }
                         }
                     }
 

Assets/CardEffect/EX7/Red/Lavorvomon_EX7_009.cs

@@ -43,7 +43,7 @@ namespace DCGO.CardEffects.EX7
                         {
                             if (cardSource.Owner == card.Owner)
                             {
-                                if (cardSource.CardNames.Contains("Hina Kurihara") || cardSource.CardNames.Contains("HinaKurihara"))
+                                if (cardSource.EqualsCardName("Hina Kurihara"))
                                 {
                                     return true;
                                 }
@@ -132,7 +132,7 @@ namespace DCGO.CardEffects.EX7
                 {
                     if (cardSource != null)
                     {
-                        if (cardSource.CardNames.Contains("Hina Kurihara") || cardSource.CardNames.Contains("Hina Kurihara"))
+                        if (cardSource.EqualsCardName("Hina Kurihara"))
                         {
                             if (cardSource.Owner == card.Owner)
                             {
@@ -149,7 +149,10 @@ namespace DCGO.CardEffects.EX7
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                        return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+
+                    return false;
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)

Assets/CardEffect/EX7/Red/MagnaKidmon_EX7_013.cs

@@ -254,7 +254,7 @@ namespace DCGO.CardEffects.EX7
             if (timing == EffectTiming.OnEndTurn)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Return 1 digivolution card to place 1 Digimon into the bottom of Security", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Trash 1 digivolution card to give <Security Atk +1> and attack", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
                 activateClass.SetHashString("ReturnOption_EX7-013");
                 cardEffects.Add(activateClass);
@@ -320,7 +320,7 @@ namespace DCGO.CardEffects.EX7
                                  canTargetCondition: CanSelectCardCondition,
                                  canTargetCondition_ByPreSelecetedList: null,
                                  canEndSelectCondition: null,
-                                 canNoSelect: () => true,
+                                 canNoSelect: () => false,
                                  selectCardCoroutine: SelectCardCoroutine,
                                  afterSelectCardCoroutine: null,
                                  message: "Select 1 Option card to discard.",
@@ -381,78 +381,18 @@ namespace DCGO.CardEffects.EX7
                              {
                                  yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonSAttack(targetPermanent: permanent, changeValue: 1, effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
 
-                                 Permanent selectedPermanent = permanent;
-
-                                 if (selectedPermanent != null)
-                                 {
-                                     ActivateClass activateClass1 = new ActivateClass();
-                                     activateClass1.SetUpICardEffect("Attack with this Digimon", CanUseCondition1, selectedPermanent.TopCard);
-                                     activateClass1.SetUpActivateClass(CanActivateCondition1, ActivateCoroutine1, -1, false, EffectDiscription1());
-                                     activateClass1.SetEffectSourcePermanent(selectedPermanent);
-
-                                     if (!permanent.TopCard.CanNotBeAffected(activateClass))
-                                     {
-                                         yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(selectedPermanent));
-                                     }
-
-                                     string EffectDiscription1()
-                                     {
-                                         return "[Start of Your Main Phase] Attack with this Digimon.";
-                                     }
-
-                                     bool CanUseCondition1(Hashtable hashtable1)
-                                     {
-                                         if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent))
-                                         {
-                                             if (selectedPermanent.TopCard.Owner.GetBattleAreaDigimons().Contains(selectedPermanent))
-                                             {
-                                                 if (GManager.instance.turnStateMachine.gameContext.TurnPlayer == selectedPermanent.TopCard.Owner)
-                                                 {
-                                                     return true;
-                                                 }
-                                             }
-                                         }
-
-                                         return false;
-                                     }
-
-                                     bool CanActivateCondition1(Hashtable hashtable1)
-                                     {
-                                         if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent))
-                                         {
-                                             if (!permanent.TopCard.CanNotBeAffected(activateClass))
-                                             {
-                                                 if (permanent.CanAttack(activateClass1))
-                                                 {
-                                                     return true;
-                                                 }
-                                             }
-                                         }
-
-                                         return false;
-                                     }
-
-                                     IEnumerator ActivateCoroutine1(Hashtable _hashtable1)
-                                     {
-                                         if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent))
-                                         {
-                                             if (permanent.CanAttack(activateClass1))
-                                             {
-                                                 SelectAttackEffect selectAttackEffect = GManager.instance.GetComponent<SelectAttackEffect>();
-
-                                                 selectAttackEffect.SetUp(
-                                                     attacker: selectedPermanent,
-                                                     canAttackPlayerCondition: () => true,
-                                                     defenderCondition: (permanent) => true,
-                                                     cardEffect: activateClass1);
-
-                                                 selectAttackEffect.SetCanNotSelectNotAttack();
-
-                                                 yield return ContinuousController.instance.StartCoroutine(selectAttackEffect.Activate());
-                                             }
-                                         }
-                                     }
-                                 }
+                                if (permanent.CanAttack(activateClass))
+                                {
+                                    SelectAttackEffect selectAttackEffect = GManager.instance.GetComponent<SelectAttackEffect>();
+
+                                    selectAttackEffect.SetUp(
+                                        attacker: permanent,
+                                        canAttackPlayerCondition: () => true,
+                                        defenderCondition: (permanent) => true,
+                                        cardEffect: activateClass);
+
+                                    yield return ContinuousController.instance.StartCoroutine(selectAttackEffect.Activate());
+                                }
                              }
                          }
                      }                    

Assets/CardEffect/EX7/Red/Megadramon_EX7_011.cs

@@ -11,6 +11,18 @@ namespace DCGO.CardEffects.EX7
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
+            #region Digivolution Condition
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.HasText("Three Musketeers") && targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.Level == 4;
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 3, ignoreDigivolutionRequirement: false, card: card, condition: null));
+            }
+            #endregion
+
             #region On Play
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {

Assets/CardEffect/EX7/Red/ToyAgumon_EX7_008.cs

@@ -14,7 +14,7 @@ namespace DCGO.CardEffects.EX7
             {
                 bool PermanentCondition(Permanent targetPermanent)
                 {
-                    return targetPermanent.TopCard.HasText("Three Musketeers") && targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.Level == 2 || targetPermanent.TopCard.HasText("ThreeMusketeers") && targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.Level == 2;
+                    return targetPermanent.TopCard.HasText("Three Musketeers") && targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.Level == 2;
                 }
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 0, ignoreDigivolutionRequirement: false, card: card, condition: null));
@@ -38,7 +38,7 @@ namespace DCGO.CardEffects.EX7
                 {
                     if (cardSource.IsDigimon)
                     {
-                        if (cardSource.CardTraits.Contains("Three Musketeers") || cardSource.CardTraits.Contains("ThreeMusketeers"))
+                        if (cardSource.HasText("Three Musketeers"))
                         {
                             return true;
                         }

Assets/Scripts/CardController.cs

@@ -3850,6 +3850,8 @@ public class ITrashDigivolutionCards
             {
                 yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddTrashCard(cardSource));
             }
+
+            cardSource.willBeRemoveSources = false;
         }
     }
 }