Merge branch 'develop' into x89rt2-patch-21

Assets/Scripts/CardEffect/BT10/Red/BT10_011.cs

@@ -85,113 +85,12 @@ namespace DCGO.CardEffects.BT10
                 }
             }
 
-            if (timing == EffectTiming.None)
-            {
-                AddSkillClass addSkillClass = new AddSkillClass();
-                addSkillClass.SetUpICardEffect("This Digimon gains all effects of [Gammamon] in digivolution cards", CanUseCondition, card);
-                addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
-
-                cardEffects.Add(addSkillClass);
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
-                }
-
-                bool PermanentCondition(Permanent permanent)
-                {
-                    return permanent == card.PermanentOfThisCard();
-                }
-
-                bool CardSourceCondition(CardSource cardSource)
-                {
-                    if (PermanentCondition(cardSource.PermanentOfThisCard()))
-                    {
-                        if (cardSource == cardSource.PermanentOfThisCard().TopCard)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-
-                List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
-                {
-                    if (CardSourceCondition(cardSource))
-                    {
-                        foreach (CardSource cardSource1 in cardSource.PermanentOfThisCard().DigivolutionCards)
-                        {
-                            if (cardSource1.ContainsCardName("Gammamon"))
-                            {
-                                foreach (ICardEffect cardEffect in cardSource1.cEntity_EffectController.GetCardEffects_ExceptAddedEffects(_timing, card))
-                                {
-                                    if (!cardEffect.IsSecurityEffect && !cardEffect.IsInheritedEffect)
-                                    {
-                                        cardEffects.Add(cardEffect);
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    return cardEffects;
-                }
-            }
+            #region All Turns Copy effects of Gammamon in digivolution cards
+            bool CopyCardCondition(CardSource cardSource) => cardSource.ContainsCardName("Gammamon");
 
-            if (timing == EffectTiming.None)
-            {
-                AddSkillClass addSkillClass = new AddSkillClass();
-                addSkillClass.SetUpICardEffect("This Digimon gains all effects of [Gammamon] in digivolution cards", CanUseCondition, card);
-                addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
-                addSkillClass.SetIsInheritedEffect(true);
-                cardEffects.Add(addSkillClass);
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
-                }
-
-                bool PermanentCondition(Permanent permanent)
-                {
-                    return permanent == card.PermanentOfThisCard();
-                }
-
-                bool CardSourceCondition(CardSource cardSource)
-                {
-                    if (PermanentCondition(cardSource.PermanentOfThisCard()))
-                    {
-                        if (cardSource == cardSource.PermanentOfThisCard().TopCard)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-
-                List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
-                {
-                    if (CardSourceCondition(cardSource))
-                    {
-                        foreach (CardSource cardSource1 in cardSource.PermanentOfThisCard().DigivolutionCards)
-                        {
-                            if (cardSource1.ContainsCardName("Gammamon"))
-                            {
-                                foreach (ICardEffect cardEffect in cardSource1.cEntity_EffectController.GetCardEffects_ExceptAddedEffects(_timing, card))
-                                {
-                                    if (!cardEffect.IsSecurityEffect && !cardEffect.IsInheritedEffect)
-                                    {
-                                        cardEffects.Add(cardEffect);
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    return cardEffects;
-                }
-            }
+            CardEffectFactory.CopyDigivolutionCardEffects(ref cardEffects, timing, card, cardCondition: CopyCardCondition);
+            CardEffectFactory.CopyDigivolutionCardEffects(ref cardEffects, timing, card, isInheritedEffect: true, cardCondition: CopyCardCondition);
+            #endregion
 
             return cardEffects;
         }

Assets/Scripts/CardEffect/BT12/Black/BT12_072.cs

@@ -132,62 +132,11 @@ namespace DCGO.CardEffects.BT12
                 }
             }
 
-            if (timing == EffectTiming.None)
-            {
-                AddSkillClass addSkillClass = new AddSkillClass();
-                addSkillClass.SetUpICardEffect("This Digimon gains all effects of [Machinedramon] and [Chaosdramon] in digivolution cards", CanUseCondition, card);
-                addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
-
-                cardEffects.Add(addSkillClass);
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
-                }
-
-                bool PermanentCondition(Permanent permanent)
-                {
-                    return permanent == card.PermanentOfThisCard();
-                }
-
-                bool CardSourceCondition(CardSource cardSource)
-                {
-                    if (PermanentCondition(cardSource.PermanentOfThisCard()))
-                    {
-                        if (cardSource == cardSource.PermanentOfThisCard().TopCard)
-                        {
-                            return true;
-                        }
-                    }
+            #region Copy effects of Machinedramon and Chaosdramon in digivolution cards
+            bool CopyCardCondition(CardSource cardSource) => cardSource.EqualsCardName("Machinedramon") || cardSource.EqualsCardName("Chaosdramon");
 
-                    return false;
-                }
-
-                List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
-                {
-                    if (CardSourceCondition(cardSource))
-                    {
-                        foreach (CardSource cardSource1 in cardSource.PermanentOfThisCard().DigivolutionCards)
-                        {
-                            if (!cardSource1.IsFlipped)
-                            {
-                                if (cardSource1.EqualsCardName("Machinedramon") || cardSource1.EqualsCardName("Chaosdramon"))
-                                {
-                                    foreach (ICardEffect cardEffect in cardSource1.cEntity_EffectController.GetCardEffects_ExceptAddedEffects(_timing, card))
-                                    {
-                                        if (!cardEffect.IsSecurityEffect && !cardEffect.IsInheritedEffect)
-                                        {
-                                            cardEffects.Add(cardEffect);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    return cardEffects;
-                }
-            }
+            CardEffectFactory.CopyDigivolutionCardEffects(ref cardEffects, timing, card, cardCondition: CopyCardCondition);
+            #endregion
 
             if (timing == EffectTiming.WhenPermanentWouldBeDeleted)
             {

Assets/Scripts/CardEffect/BT12/White/BT12_112.cs

@@ -402,7 +402,7 @@ namespace DCGO.CardEffects.BT12
                 {
                     if (cardSource == card)
                     {
-                        DigiXrosConditionElement element = new DigiXrosConditionElement(CanSelectCardCondition, "1 Digimon card with [Xros Heart] or [Blue Flare] trait");
+                        DigiXrosConditionElement element = new DigiXrosConditionElement(CanSelectCardCondition, "1 Digimon card with [Xros Heart] or [Blue Flare] trait", true);
 
                         bool CanSelectCardCondition(CardSource cardSource)
                         {

Assets/Scripts/CardEffect/BT15/Yellow/BT15_039.cs

@@ -281,120 +281,11 @@ namespace DCGO.CardEffects.BT15
 
             #endregion
 
-            #region All Turns
-
-            if (timing == EffectTiming.None)
-            {
-                AddSkillClass addSkillClass = new AddSkillClass();
-                addSkillClass.SetUpICardEffect("This Digimon gains all effects of [Gammamon] in digivolution cards", CanUseCondition, card);
-                addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
-
-                cardEffects.Add(addSkillClass);
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
-                }
-
-                bool PermanentCondition(Permanent permanent)
-                {
-                    return permanent == card.PermanentOfThisCard();
-                }
-
-                bool CardSourceCondition(CardSource cardSource)
-                {
-                    if (PermanentCondition(cardSource.PermanentOfThisCard()))
-                    {
-                        if (cardSource == cardSource.PermanentOfThisCard().TopCard)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-
-                List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
-                {
-                    if (CardSourceCondition(cardSource))
-                    {
-                        foreach (CardSource cardSource1 in cardSource.PermanentOfThisCard().DigivolutionCards)
-                        {
-                            if (cardSource1.ContainsCardName("Gammamon"))
-                            {
-                                foreach (ICardEffect cardEffect in cardSource1.cEntity_EffectController.GetCardEffects_ExceptAddedEffects(_timing, card))
-                                {
-                                    if (!cardEffect.IsSecurityEffect && !cardEffect.IsInheritedEffect)
-                                    {
-                                        cardEffects.Add(cardEffect);
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    return cardEffects;
-                }
-            }
-
-            #endregion
-
-            #region Inheritable
-
-            if (timing == EffectTiming.None)
-            {
-                AddSkillClass addSkillClass = new AddSkillClass();
-                addSkillClass.SetUpICardEffect("This Digimon gains all effects of [Gammamon] in digivolution cards", CanUseCondition, card);
-                addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
-                addSkillClass.SetIsInheritedEffect(true);
-                cardEffects.Add(addSkillClass);
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
-                }
-
-                bool PermanentCondition(Permanent permanent)
-                {
-                    return permanent == card.PermanentOfThisCard();
-                }
-
-                bool CardSourceCondition(CardSource cardSource)
-                {
-                    if (PermanentCondition(cardSource.PermanentOfThisCard()))
-                    {
-                        if (cardSource == cardSource.PermanentOfThisCard().TopCard)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-
-                List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
-                {
-                    if (CardSourceCondition(cardSource))
-                    {
-                        foreach (CardSource cardSource1 in cardSource.PermanentOfThisCard().DigivolutionCards)
-                        {
-                            if (cardSource1.ContainsCardName("Gammamon"))
-                            {
-                                foreach (ICardEffect cardEffect in cardSource1.cEntity_EffectController.GetCardEffects_ExceptAddedEffects(_timing, card))
-                                {
-                                    if (!cardEffect.IsSecurityEffect && !cardEffect.IsInheritedEffect)
-                                    {
-                                        cardEffects.Add(cardEffect);
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    return cardEffects;
-                }
-            }
+            #region All Turns Copy effects of Gammamon in digivolution cards
+            bool CopyCardCondition(CardSource cardSource) => cardSource.ContainsCardName("Gammamon");
 
+            CardEffectFactory.CopyDigivolutionCardEffects(ref cardEffects, timing, card, cardCondition: CopyCardCondition);
+            CardEffectFactory.CopyDigivolutionCardEffects(ref cardEffects, timing, card, isInheritedEffect: true, cardCondition: CopyCardCondition);
             #endregion
 
             return cardEffects;

Assets/Scripts/CardEffect/BT16/Red/BT16_014.cs

@@ -33,62 +33,10 @@ namespace DCGO.CardEffects.BT16
 
             #endregion
 
-            #region All Turns
-
-            if (timing == EffectTiming.None)
-            {
-                AddSkillClass addSkillClass = new AddSkillClass();
-                addSkillClass.SetUpICardEffect("This Digimon gains all effects of [Goldramon] in digivolution cards", CanUseCondition, card);
-                addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
-
-                cardEffects.Add(addSkillClass);
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
-                }
-
-                bool PermanentCondition(Permanent permanent)
-                {
-                    return permanent == card.PermanentOfThisCard();
-                }
-
-                bool CardSourceCondition(CardSource cardSource)
-                {
-                    if (PermanentCondition(cardSource.PermanentOfThisCard()))
-                    {
-                        if (cardSource == cardSource.PermanentOfThisCard().TopCard)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-
-                List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
-                {
-                    if (CardSourceCondition(cardSource))
-                    {
-                        foreach (CardSource cardSource1 in cardSource.PermanentOfThisCard().DigivolutionCards)
-                        {
-                            if (cardSource1.CardNames.Contains("Goldramon"))
-                            {
-                                foreach (ICardEffect cardEffect in cardSource1.cEntity_EffectController.GetCardEffects_ExceptAddedEffects(_timing, card))
-                                {
-                                    if (!cardEffect.IsSecurityEffect && !cardEffect.IsInheritedEffect)
-                                    {
-                                        cardEffects.Add(cardEffect);
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    return cardEffects;
-                }
-            }
+            #region All Turns Copy effects of Goldramon in digivolution cards
+            bool CopyCardCondition(CardSource cardSource) => cardSource.EqualsCardName("Goldramon");
 
+            CardEffectFactory.CopyDigivolutionCardEffects(ref cardEffects, timing, card, cardCondition: CopyCardCondition);
             #endregion
 
             #region When Digivolving || When Attacking

Assets/Scripts/CardEffect/BT21/Red/BT21_030.cs

@@ -55,7 +55,7 @@ namespace DCGO.CardEffects.BT21
                 {
                     if (cardSource == card)
                     {
-                        DigiXrosConditionElement element = new DigiXrosConditionElement(CanSelectCardCondition, "1 Digimon card with [Xros Heart] or [Blue Flare] trait");
+                        DigiXrosConditionElement element = new DigiXrosConditionElement(CanSelectCardCondition, "1 Digimon card with [Xros Heart] or [Blue Flare] trait", true);
 
                         bool CanSelectCardCondition(CardSource cardSource)
                         {

Assets/Scripts/CardEffect/BT25/Green/BT25_050.cs

@@ -100,7 +100,7 @@ namespace DCGO.CardEffects.BT25
                         yield return null;
                     }
 
-                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to gain cannot suspend.", "The opponent is selecting 1 Digimon to gain cannot suspend.");
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to gain cannot unsuspend.", "The opponent is selecting 1 Digimon to gain cannot unsuspend.");
                     yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
                     if (selectedPermanent != null) yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotUnsuspend(

Assets/Scripts/CardEffect/EX12/Black/EX12_003.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+// Kapurimon
+namespace DCGO.CardEffects.EX12
+{
+    public class EX12_003 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Inherit
+            if (timing == EffectTiming.WhenRemoveField)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("May DNA 1 of the leaving Digimon and another Digimon into an [ME] in hand", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDescription());
+                activateClass.SetIsInheritedEffect(true);
+                activateClass.SetIsSkippable(true);
+                cardEffects.Add(activateClass);
+
+                string EffectDescription()
+                {
+                    return "[All Turns] When any of your [ME] trait Digimon would leave the battle area other than by your effects, 1 of them and any of your other Digimon may DNA digivolve into an [ME] trait Digimon card in the hand.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimonTrigger(card, activateClass)
+                        && CardEffectCommons.CanTriggerWhenPermanentRemoveField(hashtable, PermanentCondition)
+                        && !CardEffectCommons.IsByEffect(hashtable, cardEffect => CardEffectCommons.IsOwnerEffect(cardEffect, card));
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimonActivate(card, activateClass)
+                        && CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectDNACondition)
+                        && CardEffectCommons.HasMatchConditionOwnersPermanent(card, (permanent) => permanent.IsDigimon && permanent != card.PermanentOfThisCard());
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
+                        && permanent.TopCard.EqualsTraits("ME");
+                }
+
+                bool CanSelectDNACondition(CardSource cardSource)
+                {
+                    return cardSource.EqualsTraits("ME")
+                        && cardSource.jogressCondition.Count > 0;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    List<Permanent> allowedPermanents = CardEffectCommons.GetPermanentsFromHashtable(hashtable).Filter(PermanentCondition);
+
+                    Func<Permanent, bool>[] permanentConditions = new Func<Permanent, bool>[] { allowedPermanents.Contains };//one of the 2 must be a to be removed digimon
+
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DNADigivolvePermanentsIntoHandOrTrashCard(
+                        canSelectDNACardCondition: CanSelectDNACondition,
+                        payCost: true,
+                        isHand: true,
+                        activateClass,
+                        permanentConditions
+                    ));
+                }
+            }
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/Scripts/CardEffect/EX12/Black/EX12_003.cs.meta

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

Assets/Scripts/CardEffect/EX12/Black/EX12_056.cs

@@ -0,0 +1,214 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+// Cho-Hakkaimon
+namespace DCGO.CardEffects.EX12
+{
+    public class EX12_056 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Alternative Digivolve Condition
+            if (timing == EffectTiming.None)
+            {
+                static bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.EqualsTraits("Shambala");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(PermanentCondition, 3, false, card, null, level: 4));
+            }
+            #endregion
+
+            #region Guard
+            if (timing == EffectTiming.OnAllyAttack)
+            {
+                cardEffects.Add(CardEffectFactory.GuardSelfEffect(isInheritedEffect: false, card: card, condition: null));
+            }
+            #endregion
+
+            #region Shared OP / WD
+            string SharedEffectName = "<De-Digivolve 1> 1 enemy Digimon, then 1 of your other [SW] Digimon may gain <Alliance> and attack.";
+
+            CardEffectFactory.ActivateClassesForSharedEffects
+                (ref cardEffects, timing, card,
+                    SharedEffectName,
+                    SharedActivateCoroutine,
+                    SharedEffectDescription,
+                    optional: false,
+                    onPlay: true,
+                    whenDigivolving: true);
+
+            string SharedEffectDescription(string tag) => $"[{tag}] <De-Digivolve 1> 1 of your opponent's Digimon. Then, 1 of your other [SW] trait Digimon may gain <Alliance> for the turn and attack.";
+
+            bool CanSelectEnemyPermanentCondition(Permanent permanent)
+            {
+                return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+            }
+
+            bool CanSelectOwnerPermanentCondition(Permanent permanent)
+            {
+                return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
+                    && permanent.TopCard.EqualsTraits("SW")
+                    && permanent != card.PermanentOfThisCard();
+            }
+
+            IEnumerator SharedActivateCoroutine(Hashtable hashtable, ActivateClass activateClass)
+            {
+                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectEnemyPermanentCondition))
+                {
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectEnemyPermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: null,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Degenerate,
+                        cardEffect: activateClass);
+
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 opponent's Digimon to De-Digivolve", "The opponent is selecting 1 Digimon to De-Digivolve");
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                }
+
+                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectOwnerPermanentCondition))
+                {
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectOwnerPermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: true,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: SelectPermanentCoroutine,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Custom,
+                        cardEffect: activateClass);
+
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to gain <Alliance> and attack", "The opponent is selecting 1 Digimon to gain <Alliance> and attack");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    {
+                        if (permanent != null)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainAlliance(targetPermanent: permanent, effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
+
+                            SelectAttackEffect selectAttackEffect = GManager.instance.GetComponent<SelectAttackEffect>();
+
+                            selectAttackEffect.SetUp(
+                                attacker: permanent,
+                                canAttackPlayerCondition: () => true,
+                                defenderCondition: _ => true,
+                                cardEffect: activateClass);
+
+                            yield return ContinuousController.instance.StartCoroutine(selectAttackEffect.Activate());
+                        }
+                    }
+                }
+            }
+            #endregion
+
+            #region DigiXros
+            if (timing == EffectTiming.None)
+            {
+                AddDigiXrosConditionClass addDigiXrosConditionClass = new AddDigiXrosConditionClass();
+                addDigiXrosConditionClass.SetUpICardEffect($"DigiXros -2", CanUseCondition, card);
+                addDigiXrosConditionClass.SetUpAddDigiXrosConditionClass(getDigiXrosCondition: GetDigiXros);
+                addDigiXrosConditionClass.SetNotShowUI(true);
+                cardEffects.Add(addDigiXrosConditionClass);
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return true;
+                }
+
+                DigiXrosCondition GetDigiXros(CardSource cardSource)
+                {
+                    if (cardSource == card)
+                    {
+                        DigiXrosConditionElement element = new DigiXrosConditionElement(CanSelectCardCondition,
+                            "1 Lv.5 or lower Digimon card w/[Gokuumon] in text or w/[SW] trait");
+
+                        bool CanSelectCardCondition(CardSource xrosCardSource)
+                        {
+                            return xrosCardSource != null
+                                && xrosCardSource.Owner == card.Owner
+                                && xrosCardSource.IsDigimon
+                                && xrosCardSource.HasLevel
+                                && xrosCardSource.Level <= 5
+                                && (xrosCardSource.HasText("Gokuumon")
+                                    || xrosCardSource.EqualsTraits("SW"));
+                        }
+
+                        List<DigiXrosConditionElement> elements = new List<DigiXrosConditionElement>() { element };
+
+                        DigiXrosCondition digiXrosCondition = new DigiXrosCondition(elements, null, 2);
+
+                        return digiXrosCondition;
+                    }
+
+                    return null;
+                }
+            }
+            #endregion
+
+            #region Inherited
+            if (timing == EffectTiming.OnAllyAttack)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Change attack target to this Digimon", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDescription());
+                activateClass.SetHashString("EX12_056_Inherited");
+                activateClass.SetIsInheritedEffect(true);
+                cardEffects.Add(activateClass);
+
+                string EffectDescription()
+                {
+                    return "[Opponent's Turn] [Once Per Turn] When one of your opponent's Digimon attacks, you may change the attack target to this Digimon.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimonTrigger(card, activateClass)
+                        && CardEffectCommons.IsOpponentTurn(card)
+                        && CardEffectCommons.CanTriggerOnPermanentAttack(hashtable, PermanentCondition);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimonActivate(card, activateClass)
+                        && GManager.instance.attackProcess.IsAttacking
+                        && GManager.instance.attackProcess.AttackingPermanent.CanSwitchAttackTarget;
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsOpponentPermanent(permanent, card);
+                }
+                
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.attackProcess.SwitchDefender(
+                        activateClass,
+                        false,
+                        card.PermanentOfThisCard()));
+
+                }
+            }
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/Scripts/CardEffect/EX12/Black/EX12_056.cs.meta

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

Assets/Scripts/CardEffect/EX12/Blue/EX12_029.cs

@@ -0,0 +1,305 @@
+using System.Collections;
+using System.Collections.Generic;
+
+// Sagomon
+namespace DCGO.CardEffects.EX12
+{
+    public class EX12_029 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Alternative Digivolve Condition
+            if (timing == EffectTiming.None)
+            {
+                static bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.EqualsTraits("Shambala");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(PermanentCondition, 3, false, card, null, level: 4));
+            }
+            #endregion
+
+            #region Blocker
+            if (timing == EffectTiming.None) cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(isInheritedEffect: false, card: card, condition: null));
+            #endregion
+
+            #region Shared OP / WD
+            string SharedEffectName = "Stun 1 enemy Digimon/Tamer, then 1 of your other [SW] Digimon may gain <Alliance> and attack.";
+
+            CardEffectFactory.ActivateClassesForSharedEffects
+                (ref cardEffects, timing, card,
+                    SharedEffectName,
+                    SharedActivateCoroutine,
+                    SharedEffectDescription,
+                    optional: false,
+                    onPlay: true,
+                    whenDigivolving: true);
+
+            string SharedEffectDescription(string tag) => $"[{tag}] 1 of your opponent's Digimon or Tamers can't suspend until their turn ends. Then, 1 of your other [SW] trait Digimon may gain <Alliance> for the turn and attack.";
+
+            bool CanSelectEnemyPermanentCondition(Permanent permanent)
+            {
+                return CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card)
+                    && (permanent.IsDigimon
+                        || permanent.IsTamer);
+            }
+
+            bool CanSelectOwnerPermanentCondition(Permanent permanent)
+            {
+                return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
+                    && permanent.TopCard.EqualsTraits("SW")
+                    && permanent != card.PermanentOfThisCard();
+            }
+
+            IEnumerator SharedActivateCoroutine(Hashtable hashtable, ActivateClass activateClass)
+            {
+                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectEnemyPermanentCondition))
+                {
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectEnemyPermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: SelectPermanentCoroutine,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Custom,
+                        cardEffect: activateClass);
+
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon or Tamer that will get unable to suspend.", "The opponent is selecting 1 Digimon or Tamer that will get unable to suspend.");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    {
+                        Permanent selectedPermanent = permanent;
+
+                        if (selectedPermanent != null)
+                        {
+                            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)
+                            {
+                                return selectedPermanent.TopCard != null
+                                    && !selectedPermanent.TopCard.CanNotBeAffected(activateClass);
+                            }
+
+                            bool PermanentCondition(Permanent permanent)
+                            {
+                                return permanent == selectedPermanent;
+                            }
+                        }
+                    }
+                }
+
+                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectOwnerPermanentCondition))
+                {
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectOwnerPermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: true,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: SelectPermanentCoroutine,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Custom,
+                        cardEffect: activateClass);
+
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to gain <Alliance> and attack", "The opponent is selecting 1 Digimon to gain <Alliance> and attack");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    {
+                        if (permanent != null)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainAlliance(targetPermanent: permanent, effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
+
+                            SelectAttackEffect selectAttackEffect = GManager.instance.GetComponent<SelectAttackEffect>();
+
+                            selectAttackEffect.SetUp(
+                                attacker: permanent,
+                                canAttackPlayerCondition: () => true,
+                                defenderCondition: _ => true,
+                                cardEffect: activateClass);
+
+                            yield return ContinuousController.instance.StartCoroutine(selectAttackEffect.Activate());
+                        }
+                    }
+                }
+            }
+            #endregion
+
+            #region DigiXros
+            if (timing == EffectTiming.None)
+            {
+                AddDigiXrosConditionClass addDigiXrosConditionClass = new AddDigiXrosConditionClass();
+                addDigiXrosConditionClass.SetUpICardEffect($"DigiXros -2", CanUseCondition, card);
+                addDigiXrosConditionClass.SetUpAddDigiXrosConditionClass(getDigiXrosCondition: GetDigiXros);
+                addDigiXrosConditionClass.SetNotShowUI(true);
+                cardEffects.Add(addDigiXrosConditionClass);
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return true;
+                }
+
+                DigiXrosCondition GetDigiXros(CardSource cardSource)
+                {
+                    if (cardSource == card)
+                    {
+                        DigiXrosConditionElement element = new DigiXrosConditionElement(CanSelectCardCondition,
+                            "1 Lv.5 or lower Digimon card w/[Gokuumon] in text or w/[SW] trait");
+
+                        bool CanSelectCardCondition(CardSource xrosCardSource)
+                        {
+                            return xrosCardSource != null
+                                && xrosCardSource.Owner == card.Owner
+                                && xrosCardSource.IsDigimon
+                                && xrosCardSource.HasLevel
+                                && xrosCardSource.Level <= 5
+                                && (xrosCardSource.HasText("Gokuumon")
+                                    || xrosCardSource.EqualsTraits("SW"));
+                        }
+
+                        List<DigiXrosConditionElement> elements = new List<DigiXrosConditionElement>() { element };
+
+                        DigiXrosCondition digiXrosCondition = new DigiXrosCondition(elements, null, 2);
+
+                        return digiXrosCondition;
+                    }
+
+                    return null;
+                }
+            }
+            #endregion
+
+            #region Inherited
+            if (timing == EffectTiming.OnAllyAttack)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Trash bot 2 sources of 1 enemy Digimon, 1 of their sourceless Digimon can't suspend until their turn ends", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDescription());
+                activateClass.SetHashString("EX12_029_Inherited");
+                activateClass.SetIsInheritedEffect(true);
+                cardEffects.Add(activateClass);
+
+                string EffectDescription()
+                {
+                    return "[When Attacking] [Once Per Turn] Trash the bottom 2 digivolution cards of 1 of your opponent's Digimon. Then, 1 of their Digimon with no digivolution cards can't suspend until their turn ends.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimonTrigger(card, activateClass)
+                        && CardEffectCommons.CanTriggerOnAttack(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimonActivate(card, activateClass);
+                }
+
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                }
+
+                bool OpponentsDigimonWithoutSources(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card)
+                        && permanent.DigivolutionCards.Count == 0;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    {
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: 1,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to trash digivolution cards from.",
+                            "The opponent is selecting 1 Digimon to trash digivolution cards from.");
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.TrashDigivolutionCardsFromTopOrBottom(
+                                targetPermanent: permanent,
+                                trashCount: 2,
+                                isFromTop: false,
+                                activateClass: activateClass));
+                        }
+                    }
+
+                    if (CardEffectCommons.HasMatchConditionPermanent(OpponentsDigimonWithoutSources))
+                    {
+                        SelectPermanentEffect selectPermanentEffect1 = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect1.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: OpponentsDigimonWithoutSources,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: 1,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: null,
+                            afterSelectPermanentCoroutine: AfterSelectPermanentCoroutine,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect1.SetUpCustomMessage("Select 1 Digimon to gain can't suspend until end of opponent's turn.", "The opponent is selecting 1 Digimon that will gain can't suspend until end of opponent's turn.");
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect1.Activate());
+
+                        IEnumerator AfterSelectPermanentCoroutine(List<Permanent> permanents)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotSuspendPlayerEffect(
+                                permanentCondition: (permanent) => permanent == permanents[0],
+                                effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                                activateClass: activateClass,
+                                isOnlyActivePhase: false,
+                                effectName: "Can't Suspend"));
+                        }
+                    }
+
+                }
+            }
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/Scripts/CardEffect/EX12/Blue/EX12_029.cs.meta

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

Assets/Scripts/CardEffect/EX12/Red/EX12_012.cs

@@ -0,0 +1,107 @@
+using System.Collections;
+using System.Collections.Generic;
+
+// Apemon
+namespace DCGO.CardEffects.EX12
+{
+    public class EX12_012 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Alternate Digivolution Condition
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.EqualsTraits("Shambala");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 2, ignoreDigivolutionRequirement: false, card: card, condition: null, level: 3));
+            }
+            #endregion
+
+            #region Raid
+            if (timing == EffectTiming.OnAllyAttack)
+            {
+                cardEffects.Add(CardEffectFactory.RaidSelfEffect(isInheritedEffect: false, card: card, condition: null));
+            }
+            #endregion
+
+            #region Start of Your Main Phase
+            string SharedEffectName = "Trash 1 [SW] card to <Draw 2>";
+
+            CardEffectFactory.ActivateClassesForSharedEffects
+                (ref cardEffects, timing, card,
+                    SharedEffectName,
+                    SharedActivateCoroutine,
+                    SharedEffectDescription,
+                    additionalActivateCondition: AdditionalActivateCondition,
+                    optional: false,
+                    onPlay: true,
+                    whenDigivolving: true);
+
+            string SharedEffectDescription(string tag) => $"[{tag}] By trashing 1 card with the [SW] trait from your hand, <Draw 2>.";
+
+            bool AdditionalActivateCondition(Hashtable hashtable, ActivateClass activateClass)
+            {
+                return CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition);
+            }
+
+            bool CanSelectCardCondition(CardSource cardSource)
+            {
+                return cardSource.EqualsTraits("SW");
+            }
+
+            IEnumerator SharedActivateCoroutine(Hashtable hashtable, ActivateClass activateClass)
+            {
+                SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                selectHandEffect.SetUp(
+                    selectPlayer: card.Owner,
+                    canTargetCondition: CanSelectCardCondition,
+                    canTargetCondition_ByPreSelecetedList: null,
+                    canEndSelectCondition: null,
+                    maxCount: 1,
+                    canNoSelect: true,
+                    canEndNotMax: false,
+                    isShowOpponent: true,
+                    selectCardCoroutine: null,
+                    afterSelectCardCoroutine: AfterSelectCardCoroutine,
+                    mode: SelectHandEffect.Mode.Discard,
+                    cardEffect: activateClass);
+
+                yield return StartCoroutine(selectHandEffect.Activate());
+
+                IEnumerator AfterSelectCardCoroutine(List<CardSource> cardSources)
+                {
+                    if (cardSources.Count >= 1)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 2, activateClass).Draw());
+                    }
+                }
+            }
+            #endregion
+
+            #region Inherit
+            if (timing == EffectTiming.None)
+            {
+                bool Condition()
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && CardEffectCommons.IsOwnerTurn(card);
+                }
+
+                cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect(
+                    changeValue: 2000,
+                    isInheritedEffect: true,
+                    card: card,
+                    condition: Condition));
+            }
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/Scripts/CardEffect/EX12/Red/EX12_012.cs.meta

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

Assets/Scripts/CardEffect/EX12/Red/EX12_018.cs

@@ -0,0 +1,332 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+// Siriusmon / Planet Punch
+namespace DCGO.CardEffects.EX12
+{
+    public class EX12_018 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Digimon Effects
+
+            #region Alt Digivolution
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return permanent.TopCard.HasVBTraits
+                            || permanent.TopCard.HasText("Gammamon");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(PermanentCondition, 3, true, card, null, level: 5));
+            }
+            #endregion
+
+            #region Progress
+            if (timing == EffectTiming.None)
+            {
+                cardEffects.Add(CardEffectFactory.ProgressSelfStaticEffect(false, card, null));
+            }
+            #endregion
+
+            #region Piercing
+            if (timing == EffectTiming.OnDetermineDoSecurityCheck)
+            {
+                cardEffects.Add(CardEffectFactory.PierceSelfEffect(isInheritedEffect: false, card: card, condition: null));
+            }
+            #endregion
+
+            #region Security Attack +1
+            if (timing == EffectTiming.None)
+            {
+                cardEffects.Add(CardEffectFactory.ChangeSelfSAttackStaticEffect(changeValue: 1, isInheritedEffect: false, card: card, condition: null));
+            }
+            #endregion
+
+            #region Shared WD / WA
+
+            string SharedEffectName = "May place up to 2 [Gammamon] in text/[VB] trait digimon from hand or trash as top/bottom digivolution card, if placed -2000 DP for each digivolution card to 1 opponent digimon";
+
+            string SharedEffectDescription(string tag) => $"[{tag}] [Once Per Turn] You may place up to 2 Digimon cards with [Gammamon] in its text or the [VB] trait from your hand or trash as this Digimon's top or bottom digivolution cards. If this effect placed, to 1 of your opponent's Digimon, give -2000 DP until their turn ends for each of this Digimon's digivolution cards.";
+
+            string SharedHashValue = "EX12_018_WDWA";
+
+            CardEffectFactory.ActivateClassesForSharedEffects
+                (ref cardEffects, timing, card,
+                    SharedEffectName,
+                    SharedActivateCoroutine,
+                    SharedEffectDescription,
+                    hashValue: SharedHashValue,
+                    maxCountPerTurn: 1,
+                    optional: false,
+                    isSkippable: true,
+                    whenDigivolving: true,
+                    whenAttacking: true);
+
+            bool CanSelectCardCondition(CardSource cardSource)
+                => cardSource.IsDigimon &&
+                (cardSource.HasVBTraits || cardSource.HasText("Gammamon"));
+
+            bool CanSelectPermamentCondition(Permanent permanent) => CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+
+            IEnumerator SharedActivateCoroutine(Hashtable hashtable, ActivateClass activateClass)
+            {
+                bool isUsed = false;
+                bool canSelectHand = CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition);
+                bool canSelectTrash = CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition);
+
+                if (canSelectHand || canSelectTrash)
+                {
+                    List<CardSource> cardSources = new List<CardSource>();
+
+                    while (cardSources.Count < 2)
+                    {
+                        #region Setup Location Selection
+                        List<SelectionElement<int>> selectionElements = new List<SelectionElement<int>>();
+
+                        if (canSelectHand) selectionElements.Add(new(message: $"From Hand", value: 1, spriteIndex: 0));
+                        if (canSelectTrash) selectionElements.Add(new(message: $"From Trash", value: 2, spriteIndex: 0));
+                        selectionElements.Add(new(message: $"Don't place any", value: 3, spriteIndex: 1));
+
+                        string selectPlayerMessage = "Where will you select cards from to place under this Digimon as digivolution sources?";
+                        string notSelectPlayerMessage = "The opponent is choosing to up to 2 digimon cards inside this cards digivolution source.";
+
+                        GManager.instance.userSelectionManager.SetIntSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+                        #endregion
+
+                        if (GManager.instance.userSelectionManager.SelectedIntValue == 3)
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            int maxCount = Math.Max(2, 2-cardSources.Count);
+
+                            IEnumerator SelectCardCoroutine(CardSource cardSource)
+                            {
+                                cardSources.Add(cardSource);
+                                yield return null;
+                            }
+
+                            if (GManager.instance.userSelectionManager.SelectedIntValue == 1)
+                            {
+                                SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+                                selectHandEffect.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: CanSelectCardCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: maxCount,
+                                    canNoSelect: true,
+                                    canEndNotMax: true,
+                                    isShowOpponent: true,
+                                    selectCardCoroutine: SelectCardCoroutine,
+                                    afterSelectCardCoroutine: null,
+                                    mode: SelectHandEffect.Mode.Custom,
+                                    cardEffect: activateClass);
+
+                                selectHandEffect.SetUpCustomMessage("Select up to 2 digimon cards to add to source.", "The opponent is selecting 2 digimon cards to add to source.");
+                                selectHandEffect.SetUpCustomMessage_ShowCard("Selected cards");
+                                yield return ContinuousController.instance.StartCoroutine(selectHandEffect.Activate());
+                            }
+                            else
+                            {
+                                SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+                                selectCardEffect.SetUp(
+                                    canTargetCondition: CanSelectCardCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    canNoSelect: () => true,
+                                    selectCardCoroutine: SelectCardCoroutine,
+                                    afterSelectCardCoroutine: null,
+                                    message: "Select up to 2 digimon cards",
+                                    maxCount: maxCount,
+                                    canEndNotMax: true,
+                                    isShowOpponent: true,
+                                    mode: SelectCardEffect.Mode.Custom,
+                                    root: SelectCardEffect.Root.Trash,
+                                    customRootCardList: null,
+                                    canLookReverseCard: true,
+                                    selectPlayer: card.Owner,
+                                    cardEffect: activateClass);
+
+                                selectCardEffect.SetUpCustomMessage("Select up to 2 digimon cards to add to source.", "The opponent is selecting 2 digimon cards to add to source.");
+                                selectCardEffect.SetUpCustomMessage_ShowCard("Selected cards");
+                                yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+                            }
+                        }
+                    }
+
+                    if (cardSources.Any())
+                    {
+                        isUsed = true;
+                        #region Setup Location Selection
+                        List<SelectionElement<bool>> selectionElements1 = new List<SelectionElement<bool>>();
+
+                        if (canSelectHand) selectionElements1.Add(new(message: $"Top of digivolution sources", value: true, spriteIndex: 0));
+                        if (canSelectTrash) selectionElements1.Add(new(message: $"Bottom of digivolution sources", value: false, spriteIndex: 0));
+
+                        string selectPlayerMessage1 = "Will you place up to 2 digimon cards inside this cards digivolution source?";
+                        string notSelectPlayerMessage1 = "The opponent is choosing to up to 2 digimon cards inside this cards digivolution source.";
+
+                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements1, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage1, notSelectPlayerMessage: notSelectPlayerMessage1);
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+                        #endregion
+
+                        bool isTop = GManager.instance.userSelectionManager.SelectedBoolValue;
+                        if (isTop)
+                        {
+                            List<CardSource> fixedCards = new List<CardSource>();
+                            fixedCards = cardSources.Clone();
+                            fixedCards.Reverse();
+
+                            yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsTop(
+                            addedDigivolutionCards: fixedCards,
+                            cardEffect: activateClass));
+                        }
+                        else yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(
+                            addedDigivolutionCards: cardSources,
+                            cardEffect: activateClass));
+
+                        if (card.PermanentOfThisCard().DigivolutionCards.Intersect(cardSources).Any() && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectPermamentCondition))
+                        {
+                            int dpMinus = 2000 * card.PermanentOfThisCard().DigivolutionCards.Count;
+
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectPermamentCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: 1,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: SelectPermanentCoroutine,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+
+                            selectPermanentEffect.SetUpCustomMessage($"Select 1 Digimon that will get DP -{dpMinus}.", $"The opponent is selecting 1 Digimon that will get DP -{dpMinus}.");
+
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                            IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: permanent, changeValue: -dpMinus, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
+                            }
+                        }
+                    }
+                }
+
+                if (!isUsed) activateClass.RemoveUse();
+            }
+
+            #endregion
+
+            #endregion
+
+            #region Option Effects
+
+            #region Ignore Colour Requirement
+            if (timing == EffectTiming.None)
+            {
+                cardEffects.Add(CardEffectFactory.UseRequirements(card, CardCondition));
+
+                bool CardCondition(CardSource cardSource)
+                {
+                    return cardSource.HasVBTraits;
+                }
+            }
+            #endregion
+
+            #region Main
+            if (timing == EffectTiming.OptionSkill)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Delete 1 enemy digimon with highest DP, then 1 digimon may attack", CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDescription());
+                cardEffects.Add(activateClass);
+
+                string EffectDescription()
+                    => "[Main] Delete 1 of your opponent's highest DP Digimon. Then, 1 of your Digimon may attack.";
+
+                bool CanUseCondition(Hashtable hashtable)
+                    => CardEffectCommons.CanTriggerOptionMainEffect(hashtable, card);
+
+                bool CanSelectOpponentPermanentCondition(Permanent permanent)
+                    => CardEffectCommons.IsMaxDP(permanent, card.Owner.Enemy, null);
+
+                bool CanSelectOwnerPermamentCondition(Permanent permanent)
+                    => CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
+                    && permanent.CanAttack(activateClass);
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectOpponentPermanentCondition))
+                    {
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectOpponentPermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: 1,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: null,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Destroy,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to delete", "The opponent is selecting 1 Digimon to delete.");
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                    }
+
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectOwnerPermamentCondition))
+                    {
+                        SelectPermanentEffect selectPermanentEffect =
+                        GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectOwnerPermamentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: 1,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: null,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Attack,
+                            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());
+                    }
+                }
+            }
+            #endregion
+
+            #region Arts Digivolution
+            if (timing == EffectTiming.None)
+            {
+                cardEffects.Add(CardEffectFactory.ArtsDigivolveEffect(card));
+            }
+            #endregion
+
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/Scripts/CardEffect/EX12/Red/EX12_018.cs.meta

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

Assets/Scripts/CardEffect/EX12/Red/EX12_019.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+// Nezhamon
+namespace DCGO.CardEffects.EX12
+{
+    public class EX12_019 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Alternative Digivolve Condition
+            if (timing == EffectTiming.None)
+            {
+                static bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.EqualsTraits("Shambala");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(PermanentCondition, 3, false, card, null, level: 5));
+            }
+            #endregion
+
+            #region Rush
+            if (timing == EffectTiming.None)
+            {
+                cardEffects.Add(CardEffectFactory.RushSelfStaticEffect(isInheritedEffect: false, card: card, condition: null));
+            }
+            #endregion
+
+            #region Collision
+            if (timing == EffectTiming.OnCounterTiming)
+            {
+                cardEffects.Add(CardEffectFactory.CollisionSelfStaticEffect(false, card, null));
+            }
+            #endregion
+
+            #region Piercing
+            if (timing == EffectTiming.OnDetermineDoSecurityCheck)
+            {
+                cardEffects.Add(CardEffectFactory.PierceSelfEffect(isInheritedEffect: false, card: card, condition: null));
+            }
+            #endregion
+
+            #region Blocker
+            if (timing == EffectTiming.None)
+            {
+                cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(isInheritedEffect: false, card: card, condition: null));
+            }
+            #endregion
+
+            #region Engage
+            if (timing == EffectTiming.OnEndTurn)
+            {
+                cardEffects.Add(CardEffectFactory.EngageSelfStaticEffect(isInheritedEffect: false, card: card, condition: null));
+            }
+            #endregion
+
+            #region AT Attack Change
+            if (timing == EffectTiming.OnAttackTargetChanged)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Become Digimon effect immune and gain 4K DP until enemy turn ends", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDescription());
+                activateClass.SetHashString("EX12_019_AT_1");
+                cardEffects.Add(activateClass);
+
+                string EffectDescription()
+                {
+                    return "[All Turns] [Once Per Turn] When attack targets change, until your opponent's turn ends, their Digimon effects don't affect this Digimon and it gets +4000 DP.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimonTrigger(card, activateClass)
+                        && CardEffectCommons.CanTriggerOnPermanentAttackTargetSwitch(hashtable, permanent => true);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimonActivate(card, activateClass);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    card.PermanentOfThisCard().UntilOpponentTurnEndEffects.Add((_timing) => PermanentEffectFactory.DigimonEffectImmunity(card.PermanentOfThisCard()));
+
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP
+                    (
+                        card.PermanentOfThisCard(),
+                        +4000,
+                        EffectDuration.UntilOpponentTurnEnd,
+                        activateClass
+                    ));
+
+                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateBuffEffect(card.PermanentOfThisCard()));
+                }
+            }
+            #endregion
+
+            #region AT Security Removed
+            if (timing == EffectTiming.OnLoseSecurity)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("This Digimon may unsuspend", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDescription());
+                activateClass.SetHashString("EX12_019_AT_2");
+                cardEffects.Add(activateClass);
+
+                string EffectDescription() => "[All Turns] [Once Per Turn] When security stacks are removed from, this Digimon may unsuspend.";
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimonTrigger(card, activateClass)
+                        && CardEffectCommons.CanTriggerWhenLoseSecurity(hashtable, _ => true);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimonActivate(card, activateClass)
+                        && card.PermanentOfThisCard().CanUnsuspend;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(new IUnsuspendPermanents(
+                        permanents: new List<Permanent>() { card.PermanentOfThisCard() },
+                        cardEffect: activateClass).Unsuspend());
+                }
+            }
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/Scripts/CardEffect/EX12/Red/EX12_019.cs.meta

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

Assets/Scripts/CardEffect/EX12/Yellow/EX12_001.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+// Nyaromon
+namespace DCGO.CardEffects.EX12
+{
+    public class EX12_001 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Inherit
+            if (timing == EffectTiming.OnEndTurn)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("May DNA this [VB] Digimon and 1 other into a [VB] in hand", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDescription());
+                activateClass.SetIsSkippable(true);
+                activateClass.SetIsInheritedEffect(true);
+                cardEffects.Add(activateClass);
+
+                string EffectDescription()
+                {
+                    return "[End of Your Turn] This [VB] trait Digimon and any of your other Digimon may DNA digivolve into a [VB] trait Digimon card in the hand. Then, that DNA digivolved Digimon may attack.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimonTrigger(card, activateClass);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimonActivate(card, activateClass)
+                        && CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectDNACondition)
+                        && CardEffectCommons.HasMatchConditionOwnersPermanent(card, (permanent) => permanent.IsDigimon && permanent != card.PermanentOfThisCard())
+                        && card.PermanentOfThisCard().TopCard.EqualsTraits("VB");
+                }
+
+                bool CanSelectDNACondition(CardSource cardSource)
+                {
+                    return cardSource.EqualsTraits("VB")
+                        && cardSource.jogressCondition.Count > 0;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    Func<Permanent, bool>[] permanentConditions = new Func<Permanent, bool>[] { permanent => permanent == card.PermanentOfThisCard() };
+
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DNADigivolvePermanentsIntoHandOrTrashCard(
+                        canSelectDNACardCondition: CanSelectDNACondition,
+                        payCost: true,
+                        isHand: true,
+                        activateClass,
+                        permanentConditions
+                    ));
+                }
+            }
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/Scripts/CardEffect/EX12/Yellow/EX12_001.cs.meta

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

Assets/Scripts/CardEffect/EX12/Yellow/EX12_046.cs

@@ -0,0 +1,254 @@
+using System.Collections;
+using System.Collections.Generic;
+
+// Shishimamon
+namespace DCGO.CardEffects.EX12
+{
+    public class EX12_046 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Alternative Digivolve Condition
+            if (timing == EffectTiming.None)
+            {
+                static bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.EqualsTraits("Shambala");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(PermanentCondition, 3, false, card, null, level: 4));
+            }
+            #endregion
+
+            #region Shared OP / WD
+            string SharedEffectName = "Give 1 enemy Digimon <Security A. -1> and -3K DP until their turn ends";
+
+            CardEffectFactory.ActivateClassesForSharedEffects
+                (ref cardEffects, timing, card,
+                    SharedEffectName,
+                    SharedActivateCoroutine,
+                    SharedEffectDescription,
+                    optional: false,
+                    onPlay: true,
+                    whenDigivolving: true);
+
+            string SharedEffectDescription(string tag) => $"[{tag}] Give 1 of your opponent's Digimon <Security A. -1> and -3000 DP until their turn ends.";
+
+            bool CanSelectPermanentCondition(Permanent permanent)
+            {
+                return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+            }
+
+            IEnumerator SharedActivateCoroutine(Hashtable hashtable, ActivateClass activateClass)
+            {
+                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                {
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectPermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: SelectPermanentCoroutine,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Custom,
+                        cardEffect: activateClass);
+
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will get <Security A. -1> and -3K DP.", "The opponent is selecting 1 Digimon that will get <Security A. -1> and -3K DP.");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonSAttack(
+                            targetPermanent: permanent,
+                            changeValue: -1,
+                            effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                            activateClass: activateClass));
+
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
+                            targetPermanent: permanent,
+                            changeValue: -3000,
+                            effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                            activateClass: activateClass));
+                    }
+                }
+            }
+            #endregion
+
+            #region Your Turn
+            if (timing == EffectTiming.OnLoseSecurity)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("May digivolve this Digimon into [TB] trait in hand for 2 less", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDescription());
+                activateClass.SetIsSkippable(true);
+                cardEffects.Add(activateClass);
+
+                string EffectDescription()
+                {
+                    return "[Your Turn] When your opponent's security stack is removed from, this Digimon may digivolve into a [TB] trait Digimon card in the hand with the cost reduced by 2.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaTrigger(card, activateClass)
+                        && CardEffectCommons.IsOwnerTurn(card)
+                        && CardEffectCommons.CanTriggerWhenLoseSecurity(hashtable, player => player == card.Owner.Enemy);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaActivate(card, activateClass)
+                        && CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition);
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    return cardSource.EqualsTraits("TB");
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DigivolveIntoHandOrTrashCard(
+                        targetPermanent: card.PermanentOfThisCard(),
+                        cardCondition: CanSelectCardCondition,
+                        payCost: true,
+                        reduceCostTuple: (reduceCost: 2, reduceCostCardCondition: null),
+                        fixedCostTuple: null,
+                        ignoreDigivolutionRequirementFixedCost: -1,
+                        isHand: true,
+                        activateClass: activateClass,
+                        successProcess: null));
+                }
+            }
+            #endregion
+
+            #region DigiXros
+            if (timing == EffectTiming.None)
+            {
+                AddDigiXrosConditionClass addDigiXrosConditionClass = new AddDigiXrosConditionClass();
+                addDigiXrosConditionClass.SetUpICardEffect($"DigiXros -2", CanUseCondition, card);
+                addDigiXrosConditionClass.SetUpAddDigiXrosConditionClass(getDigiXrosCondition: GetDigiXros);
+                addDigiXrosConditionClass.SetNotShowUI(true);
+                cardEffects.Add(addDigiXrosConditionClass);
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return true;
+                }
+
+                DigiXrosCondition GetDigiXros(CardSource cardSource)
+                {
+                    if (cardSource == card)
+                    {
+                        DigiXrosConditionElement element = new DigiXrosConditionElement(CanSelectCardCondition,
+                            "1 Lv.4 or lower [TB] trait card");
+
+                        bool CanSelectCardCondition(CardSource xrosCardSource)
+                        {
+                            return xrosCardSource != null
+                                && xrosCardSource.Owner == card.Owner
+                                && xrosCardSource.HasLevel
+                                && xrosCardSource.Level <= 4
+                                && xrosCardSource.EqualsTraits("TB");
+                        }
+
+                        List<DigiXrosConditionElement> elements = new List<DigiXrosConditionElement>() { element };
+
+                        DigiXrosCondition digiXrosCondition = new DigiXrosCondition(elements, null, 2);
+
+                        return digiXrosCondition;
+                    }
+
+                    return null;
+                }
+            }
+            #endregion
+
+            #region Inherited
+            if (timing == EffectTiming.OnEndAttack)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("May play 1 [TB] Digimon with 5K DP or less from hand for free", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDescription());
+                activateClass.SetIsInheritedEffect(true);
+                activateClass.SetIsSkippable(true);
+                activateClass.SetHashString("EX12_046_Inherited");
+                cardEffects.Add(activateClass);
+
+                string EffectDescription()
+                {
+                    return "[End of Attack] [Once Per Turn] You may play 1 [TB] trait Digimon card with 5000 DP or less from your hand without paying the cost.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimonTrigger(card, activateClass)
+                        && CardEffectCommons.CanTriggerOnAttack(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimonActivate(card, activateClass)
+                        && CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition);
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    return cardSource.IsDigimon
+                        && cardSource.HasDP
+                        && cardSource.CardDP <= 5000
+                        && cardSource.EqualsTraits("TB")
+                        && CardEffectCommons.CanPlayAsNewPermanent(cardSource, false, activateClass);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    bool Used = false;
+                    SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                    selectHandEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectCardCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: true,
+                        canEndNotMax: false,
+                        isShowOpponent: true,
+                        selectCardCoroutine: null,
+                        afterSelectCardCoroutine: AfterSelectCardCoroutine,
+                        mode: SelectHandEffect.Mode.PlayForFree,
+                        cardEffect: activateClass);
+
+                    IEnumerator AfterSelectCardCoroutine(List<CardSource> cardSources)
+                    {
+                        if (cardSources.Count > 0)
+                        {
+                            Used = true;
+
+                            yield return null;
+                        }
+                    }
+
+                    yield return StartCoroutine(selectHandEffect.Activate());
+
+                    if (!Used)
+                    {
+                        activateClass.RemoveUse();
+                    }
+                }
+            }
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/Scripts/CardEffect/EX12/Yellow/EX12_046.cs.meta

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

Assets/Scripts/CardEffect/EX12/Yellow/EX12_047.cs

@@ -0,0 +1,275 @@
+using System.Collections;
+using System.Collections.Generic;
+
+// Amaterasumon
+namespace DCGO.CardEffects.EX12
+{
+    public class EX12_047 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Alternate Digivolution Requirement
+            if (timing == EffectTiming.None)
+            {
+                static bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.EqualsTraits("Shambala");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 3, ignoreDigivolutionRequirement: false, card: card, condition: null, level: 5));
+            }
+            #endregion
+
+            #region Static Keywords
+            #region Piercing
+            if (timing == EffectTiming.OnDetermineDoSecurityCheck)
+            {
+                cardEffects.Add(CardEffectFactory.PierceSelfEffect(isInheritedEffect: false, card: card, condition: null));
+            }
+            #endregion
+
+            #region Security A. +1
+            if (timing == EffectTiming.None)
+            {
+                cardEffects.Add(CardEffectFactory.ChangeSelfSAttackStaticEffect(changeValue: 1, isInheritedEffect: false, card: card, condition: null));
+            }
+            #endregion
+
+            #region Ascension
+            if (timing == EffectTiming.OnDestroyedAnyone)
+            {
+                cardEffects.Add(CardEffectFactory.AscensionSelfEffect(isInheritedEffect: false, card: card, condition: null));
+            }
+            #endregion
+            #endregion
+
+            #region Shared OP/WD
+            string SharedEffectName = "Delete enemy lowest DP, by returning 2 of their trash cards to bottom of deck, this gets 6K DP and they get -5K DP";
+
+            CardEffectFactory.ActivateClassesForSharedEffects
+            (ref cardEffects, timing, card,
+                SharedEffectName,
+                SharedActivateCoroutine,
+                SharedEffectDescription,
+                optional: false,
+                onPlay: true,
+                whenDigivolving: true);
+
+            string SharedEffectDescription(string tag)
+            {
+                return $"[{tag}] Delete 1 of your opponent's lowest DP Digimon. Then, by returning 2 cards from their trash to the bottom of the deck, for the turn, this Digimon gets +6000 DP and, to 1 of their Digimon, give -5000 DP for each of those returned cards' colors.";
+            }
+
+            bool CanSelectDeletePermanentCondition(Permanent permanent)
+            {
+                return CardEffectCommons.IsMinDP(permanent, card.Owner.Enemy);
+            }
+
+            bool CanSelectDPMinusPermanentCondition(Permanent permanent)
+            {
+                return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+            }
+
+            IEnumerator SharedActivateCoroutine(Hashtable hashtable, ActivateClass activateClass)
+            {
+                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectDeletePermanentCondition))
+                {
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectDeletePermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: null,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Destroy,
+                        cardEffect: activateClass);
+
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to delete.", "The opponent is selecting 1 Digimon to delete.");
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                }
+
+                if (card.Owner.Enemy.TrashCards.Count >= 2)
+                {
+                    List<CardSource> selectedCards = new List<CardSource>();
+
+                    SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                    selectCardEffect.SetUp(
+                        canTargetCondition: (card) => true,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        canNoSelect: () => true,
+                        selectCardCoroutine: SelectCardCoroutine,
+                        afterSelectCardCoroutine: null,
+                        message: "Select 2 cards to bottom deck",
+                        maxCount: 2,
+                        canEndNotMax: false,
+                        isShowOpponent: true,
+                        mode: SelectCardEffect.Mode.Custom,
+                        root: SelectCardEffect.Root.Custom,
+                        customRootCardList: card.Owner.Enemy.TrashCards,
+                        canLookReverseCard: true,
+                        selectPlayer: card.Owner,
+                        cardEffect: activateClass);
+
+                    IEnumerator SelectCardCoroutine(CardSource cardSource)
+                    {
+                        selectedCards.Add(cardSource);
+                        yield return null;
+                    }
+
+                    selectCardEffect.SetUpCustomMessage("Select 2 cards to bottom deck", "Your opponent is selecting 2 cards to bottom deck");
+                    selectCardEffect.SetUpCustomMessage_ShowCard("Selected Cards");
+                    yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                    if (selectedCards.Count == 2)
+                    {
+                        int DPMinus = Combinations.GetUniqueColorCardCount(selectedCards) * -5000;
+
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ReturnRevealedCardsToLibraryBottom(
+                            remainingCards: selectedCards,
+                            activateClass: activateClass));
+
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
+                            targetPermanent: card.PermanentOfThisCard(),
+                            changeValue: 6000,
+                            effectDuration: EffectDuration.UntilEachTurnEnd,
+                            activateClass: activateClass));
+
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectDPMinusPermanentCondition))
+                        {
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectDPMinusPermanentCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: 1,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: SelectPermanentCoroutine2,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+
+                            selectPermanentEffect.SetUpCustomMessage($"Select 1 Digimon that will get {DPMinus} DP.", $"The opponent is selecting 1 Digimon that will get {DPMinus} DP.");
+
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                            IEnumerator SelectPermanentCoroutine2(Permanent permanent)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
+                                    targetPermanent: permanent,
+                                    changeValue: DPMinus,
+                                    effectDuration: EffectDuration.UntilEachTurnEnd,
+                                    activateClass: activateClass));
+                            }
+                        }
+                    }
+                }
+            }
+            #endregion
+
+            #region On Deletion
+            if (timing == EffectTiming.OnDestroyedAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("May return 1 [TB] card from trash to hand, then may play 1 lvl 5- [TB] Digimon from hand for free", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDescription());
+                activateClass.SetIsSkippable(true);
+                cardEffects.Add(activateClass);
+
+                string EffectDescription()
+                {
+                    return "[On Deletion] You may return 1 [TB] trait card from your trash to the hand. Then, you may play 1 level 5 or lower [TB] trait Digimon card from your hand without paying the cost.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnDeletion(hashtable, card, activateClass);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanActivateOnDeletion(card, activateClass)
+                        && (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectReturnCardCondition)
+                            || CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectPlayCardCondition));
+                }
+
+                bool CanSelectReturnCardCondition(CardSource cardSource)
+                {
+                    return cardSource.EqualsTraits("TB");
+                }
+
+                bool CanSelectPlayCardCondition(CardSource cardSource)
+                {
+                    return cardSource.IsDigimon
+                        && cardSource.HasLevel
+                        && cardSource.Level <= 5
+                        && cardSource.EqualsTraits("TB")
+                        && CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectReturnCardCondition))
+                    {
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                        selectCardEffect.SetUp(
+                            canTargetCondition: CanSelectReturnCardCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            canNoSelect: () => true,
+                            selectCardCoroutine: null,
+                            afterSelectCardCoroutine: null,
+                            message: "Select 1 [TS] trait Option card to return to hand",
+                            maxCount: 1,
+                            canEndNotMax: false,
+                            isShowOpponent: true,
+                            mode: SelectCardEffect.Mode.AddHand,
+                            root: SelectCardEffect.Root.Trash,
+                            customRootCardList: null,
+                            canLookReverseCard: true,
+                            selectPlayer: card.Owner,
+                            cardEffect: activateClass);
+
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+                    }
+
+                    if (CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectPlayCardCondition))
+                    {
+                        SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                        selectHandEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPlayCardCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: 1,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            isShowOpponent: true,
+                            selectCardCoroutine: null,
+                            afterSelectCardCoroutine: null,
+                            mode: SelectHandEffect.Mode.PlayForFree,
+                            cardEffect: activateClass);
+
+                        yield return StartCoroutine(selectHandEffect.Activate());
+                    }
+                }
+            }
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/Scripts/CardEffect/EX12/Yellow/EX12_047.cs.meta

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

Assets/Scripts/CardEffect/EX4/White/EX4_072.cs

@@ -1,8 +1,8 @@
-using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
+// Digital Translator
 namespace DCGO.CardEffects.EX4
 {
     public class EX4_072 : CEntity_Effect
@@ -11,6 +11,7 @@ namespace DCGO.CardEffects.EX4
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
+            #region Rule
             if (timing == EffectTiming.None)
             {
                 ChangeCardNamesClass changeCardNamesClass = new ChangeCardNamesClass();
@@ -24,8 +25,6 @@ namespace DCGO.CardEffects.EX4
                     return true;
                 }
 
-
-
                 List<string> changeCardNames(CardSource cardSource, List<string> CardNames)
                 {
                     if (cardSource == card)
@@ -36,7 +35,9 @@ namespace DCGO.CardEffects.EX4
                     return CardNames;
                 }
             }
+            #endregion
 
+            #region Ignore Color Requirement
             if (timing == EffectTiming.None)
             {
                 IgnoreColorConditionClass ignoreColorConditionClass = new IgnoreColorConditionClass();
@@ -47,55 +48,40 @@ namespace DCGO.CardEffects.EX4
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, (permanent) => permanent.IsTamer))
-                    {
-                        return true;
-                    }
-
-                    return false;
+                    return CardEffectCommons.HasMatchConditionOwnersPermanent(card, (permanent) => permanent.IsTamer);
                 }
 
-
-
                 bool CardCondition(CardSource cardSource)
                 {
-                    if (cardSource == card)
-                    {
-                        return true;
-                    }
-
-                    return false;
+                    return cardSource == card;
                 }
             }
+            #endregion
 
+            #region Main
             if (timing == EffectTiming.OptionSkill)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect(card.BaseENGCardNameFromEntity, CanUseCondition, card);
-                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDescription());
                 cardEffects.Add(activateClass);
 
-                string EffectDiscription()
+                string EffectDescription()
                 {
-                    return "[Main] Choose 1 of your level 6 Digimon. Ignoring digivolution requirements and without paying the cost, it may digivolve into a level 6 Digimon card in your hand with a different name that includes the chosen Digimon's name.";
+                    return "[Main] Choose 1 of your [Gallantmon], [Sakuyamon] or [MegaGargomon].From your hand, ignoring digivolution requirements and without paying the cost, it may digivolve into a level 6 Digimon card with a different name that includes the chosen Digimon's name.";
                 }
 
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
+                    && (permanent.TopCard.EqualsCardName("Gallantmon")
+                        || permanent.TopCard.EqualsCardName("Sakuyamon")
+                        || permanent.TopCard.EqualsCardName("MegaGargomon")))
                     {
-                        if (permanent.TopCard.HasLevel && permanent.Level == 6)
+                        foreach (CardSource cardSource in card.Owner.HandCards)
                         {
-                            foreach (CardSource cardSource in card.Owner.HandCards)
-                            {
-                                if (CanSelectCardCondition(cardSource, permanent))
-                                {
-                                    if (!cardSource.CanNotEvolve(permanent))
-                                    {
-                                        return true;
-                                    }
-                                }
-                            }
+                            if (CanSelectCardCondition(cardSource, permanent)
+                            && !cardSource.CanNotEvolve(permanent)) return true;
                         }
                     }
 
@@ -104,18 +90,9 @@ namespace DCGO.CardEffects.EX4
 
                 bool CanSelectCardCondition(CardSource cardSource, Permanent permanent)
                 {
-                    if (permanent.TopCard.CardNames.Count((cardName) => cardSource.ContainsCardName(cardName)) >= 1)
-                    {
-                        if (permanent.TopCard.CardNames.Count((cardName) => cardSource.CardNames.Contains(cardName)) == 0)
-                        {
-                            if (cardSource.HasLevel && cardSource.Level == 6)
-                            {
-                                return true;
-                            }
-                        }
-                    }
-
-                    return false;
+                    return permanent.TopCard.CardNames.Any((cardName) => cardSource.ContainsCardName(cardName) && !cardSource.EqualsCardName(cardName))
+                        && cardSource.HasLevel
+                        && cardSource.Level == 6;
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -129,8 +106,6 @@ namespace DCGO.CardEffects.EX4
                     {
                         Permanent selectedPermanent = null;
 
-                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
                         SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
 
                         selectPermanentEffect.SetUp(
@@ -138,7 +113,7 @@ namespace DCGO.CardEffects.EX4
                             canTargetCondition: CanSelectPermanentCondition,
                             canTargetCondition_ByPreSelecetedList: null,
                             canEndSelectCondition: null,
-                            maxCount: maxCount,
+                            maxCount: 1,
                             canNoSelect: true,
                             canEndNotMax: false,
                             selectPermanentCoroutine: SelectPermanentCoroutine,
@@ -173,35 +148,27 @@ namespace DCGO.CardEffects.EX4
                     }
                 }
             }
+            #endregion
 
-
+            #region Security
             if (timing == EffectTiming.SecuritySkill)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect($"Return 1 card from trash to hand and add this card to hand", CanUseCondition, card);
-                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetUpICardEffect("Return 1 card from trash to hand and add this card to hand", CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDescription());
                 activateClass.SetIsSecurityEffect(true);
                 cardEffects.Add(activateClass);
 
-                string EffectDiscription()
+                string EffectDescription()
                 {
                     return "[Security] Return 1 Digimon card from your trash to your hand, and add this card to your hand.";
                 }
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    if (cardSource != null)
-                    {
-                        if (cardSource.IsDigimon)
-                        {
-                            if (cardSource.Owner == card.Owner)
-                            {
-                                return true;
-                            }
-                        }
-                    }
-
-                    return false;
+                    return cardSource != null
+                        && cardSource.IsDigimon
+                        && cardSource.Owner == card.Owner;
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -213,8 +180,6 @@ namespace DCGO.CardEffects.EX4
                 {
                     if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                     {
-                        int maxCount = Math.Min(1, card.Owner.TrashCards.Count(CanSelectCardCondition));
-
                         SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
 
                         selectCardEffect.SetUp(
@@ -225,7 +190,7 @@ namespace DCGO.CardEffects.EX4
                             selectCardCoroutine: null,
                             afterSelectCardCoroutine: null,
                             message: "Select 1 card to add to your hand.",
-                            maxCount: maxCount,
+                            maxCount: 1,
                             canEndNotMax: false,
                             isShowOpponent: true,
                             mode: SelectCardEffect.Mode.AddHand,
@@ -241,8 +206,9 @@ namespace DCGO.CardEffects.EX4
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.AddThisCardToHand(card, activateClass));
                 }
             }
+            #endregion
 
             return cardEffects;
         }
     }
-}
+}

Assets/Scripts/CardEffect/P/Black/P_244.cs

@@ -0,0 +1,278 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+//Unique Emblem: Ragnarok Attainer
+namespace DCGO.CardEffects.P
+{
+    public class P_244 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Main
+            if (timing == EffectTiming.OptionSkill)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Play 1 [Vemmon]/[Zenith] from hand or trash for free, then place in battle area", CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDescription());
+                cardEffects.Add(activateClass);
+
+                string EffectDescription()
+                {
+                    return "[Main] You may play 1 [Vemmon] or [Zenith] from your hand or trash without paying the cost. Then, place this card in the battle area.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOptionMainEffect(hashtable, card);
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    return (cardSource.EqualsCardName("Vemmon")
+                            || cardSource.EqualsCardName("Zenith"))
+                        && CardEffectCommons.CanPlayAsNewPermanent(cardSource, false, activateClass);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition)
+                    || CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
+                    {
+                        bool canSelectHand = CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition);
+                        bool canSelectTrash = CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition);
+
+                        if (canSelectHand || canSelectTrash)
+                        {
+                            #region Setup Location Selection
+                            if (canSelectHand && canSelectTrash)
+                            {
+                                List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                                {
+                                    new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
+                                    new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
+                                };
+
+                                string selectPlayerMessage = "From which area do you select a card?";
+                                string notSelectPlayerMessage = "The opponent is choosing from which area to select a card.";
+
+                                GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                            }
+                            else
+                            {
+                                GManager.instance.userSelectionManager.SetBool(canSelectHand);
+                            }
+
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+                            #endregion
+
+                            bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+                            #region Hand/Trash Card Selection & Play
+                            if (fromHand)
+                            {
+                                SelectHandEffect selectHandEffect2 = GManager.instance.GetComponent<SelectHandEffect>();
+
+                                selectHandEffect2.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: CanSelectCardCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: 1,
+                                    canNoSelect: true,
+                                    canEndNotMax: false,
+                                    isShowOpponent: true,
+                                    selectCardCoroutine: null,
+                                    afterSelectCardCoroutine: null,
+                                    mode: SelectHandEffect.Mode.PlayForFree,
+                                    cardEffect: activateClass);
+
+                                yield return StartCoroutine(selectHandEffect2.Activate());
+                            }
+                            else
+                            {
+                                SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                                selectCardEffect.SetUp(
+                                    canTargetCondition: CanSelectCardCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    canNoSelect: () => true,
+                                    selectCardCoroutine: null,
+                                    afterSelectCardCoroutine: null,
+                                    message: "Select 1 card to play.",
+                                    maxCount: 1,
+                                    canEndNotMax: false,
+                                    isShowOpponent: true,
+                                    mode: SelectCardEffect.Mode.PlayForFree,
+                                    root: SelectCardEffect.Root.Trash,
+                                    customRootCardList: null,
+                                    canLookReverseCard: true,
+                                    selectPlayer: card.Owner,
+                                    cardEffect: activateClass);
+
+                                yield return StartCoroutine(selectCardEffect.Activate());
+                            }
+                            #endregion
+                        }
+                    }
+
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlaceDelayOptionCards(card: card, cardEffect: activateClass));
+                }
+            }
+            #endregion
+
+            #region Your turn - Delay
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Digivolve into a Digimon w/[Vemmon] in text for 3 less.", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDescription());
+                cardEffects.Add(activateClass);
+
+                string EffectDescription()
+                {
+                    return "[Your Turn] When effects place [Vemmon] as any of your Digimon's digivolution cards, <Delay>.\r\n 1 of your Digimon with [Vemmon] in its text may digivolve into a Digimon card with [Vemmon] in its text in the hand or trash with the cost reduced by 3.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(card)
+                        && CardEffectCommons.CanDeclareOptionDelayEffect(card)
+                        && CardEffectCommons.CanTriggerOnAddDigivolutionCard(
+                            hashtable: hashtable,
+                            permanentCondition: TriggerPermanentCondition,
+                            cardEffectCondition: _ => true,
+                            cardCondition: TriggerCardCondition);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(card);
+                }
+
+                bool TriggerPermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
+                }
+
+                bool TriggerCardCondition(CardSource cardSource)
+                {
+                    return cardSource.EqualsCardName("Vemmon");
+                }
+
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
+                        && permanent.TopCard.HasText("Vemmon");
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    return cardSource.IsDigimon
+                        && cardSource.HasText("Vemmon");
+                }
+
+                bool ValidTarget(CardSource cardSource, SelectCardEffect.Root root, Permanent permanent)
+                {
+                    return CanSelectCardCondition(cardSource)
+                        && cardSource.CanPlayCardTargetFrame(permanent.PermanentFrame, false, activateClass, root);
+                }
+
+                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.HasMatchConditionOwnersPermanent(card, CanSelectPermanentCondition))
+                        {
+                            Permanent selectedPermanent = null;
+
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectPermanentCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: 1,
+                                canNoSelect: true,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: SelectPermanentCoroutine,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+
+                            selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to digivolve.", "The opponent is selecting 1 Digimon to return to digivolve.");
+
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                            IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                            {
+                                selectedPermanent = permanent;
+
+                                yield return null;
+                            }
+
+                            if (selectedPermanent != null)
+                            {
+                                bool ValidCardInHand = card.Owner.HandCards.Any(cardSource => ValidTarget(cardSource, SelectCardEffect.Root.Hand, selectedPermanent));
+                                bool ValidCardInTrash = card.Owner.TrashCards.Any(cardSource => ValidTarget(cardSource, SelectCardEffect.Root.Trash, selectedPermanent));
+
+                                if (ValidCardInHand && ValidCardInTrash)
+                                {
+                                    List<SelectionElement<bool>> selectionElements1 = new List<SelectionElement<bool>>()
+                                    {
+                                        new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
+                                        new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
+                                    };
+
+                                    string selectPlayerMessage1 = "From which area do you select a card?";
+                                    string notSelectPlayerMessage1 = "The opponent is choosing from which area to select a card.";
+
+                                    GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements1, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage1, notSelectPlayerMessage: notSelectPlayerMessage1);
+                                }
+                                else
+                                {
+                                    GManager.instance.userSelectionManager.SetBool(ValidCardInHand);
+                                }
+
+                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                                var fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DigivolveIntoHandOrTrashCard(
+                                    selectedPermanent,
+                                    CanSelectCardCondition,
+                                    payCost: true,
+                                    reduceCostTuple: (3, null),
+                                    fixedCostTuple: null,
+                                    ignoreDigivolutionRequirementFixedCost: -1,
+                                    isHand: fromHand,
+                                    activateClass,
+                                    successProcess: null
+                                ));
+                            }
+                        }
+                    }
+                }
+            }
+            #endregion
+
+            #region Security Effect
+            if (timing == EffectTiming.SecuritySkill)
+            {
+                CardEffectCommons.AddActivateMainOptionSecurityEffect(
+                    card: card,
+                    cardEffects: ref cardEffects,
+                    effectName: "Play 1 [Vemmon]/[Zenith] from hand or trash for free, then place in battle area");
+            }
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/Scripts/CardEffect/P/Black/P_244.cs.meta

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

Assets/Scripts/CardEffect/RB1/Blue/RB1_015.cs

@@ -155,113 +155,12 @@ public class RB1_015 : CEntity_Effect
             }
         }
 
-        if (timing == EffectTiming.None)
-        {
-            AddSkillClass addSkillClass = new AddSkillClass();
-            addSkillClass.SetUpICardEffect("This Digimon gains all effects of [Gammamon] in digivolution cards", CanUseCondition, card);
-            addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
-
-            cardEffects.Add(addSkillClass);
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.IsExistOnBattleArea(card);
-            }
-
-            bool PermanentCondition(Permanent permanent)
-            {
-                return permanent == card.PermanentOfThisCard();
-            }
-
-            bool CardSourceCondition(CardSource cardSource)
-            {
-                if (PermanentCondition(cardSource.PermanentOfThisCard()))
-                {
-                    if (cardSource == cardSource.PermanentOfThisCard().TopCard)
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
-            {
-                if (CardSourceCondition(cardSource))
-                {
-                    foreach (CardSource cardSource1 in cardSource.PermanentOfThisCard().DigivolutionCards)
-                    {
-                        if (cardSource1.ContainsCardName("Gammamon"))
-                        {
-                            foreach (ICardEffect cardEffect in cardSource1.cEntity_EffectController.GetCardEffects_ExceptAddedEffects(_timing, card))
-                            {
-                                if (!cardEffect.IsSecurityEffect && !cardEffect.IsInheritedEffect)
-                                {
-                                    cardEffects.Add(cardEffect);
-                                }
-                            }
-                        }
-                    }
-                }
-
-                return cardEffects;
-            }
-        }
+        #region All Turns Copy effects of Gammamon in digivolution cards
+        bool CopyCardCondition(CardSource cardSource) => cardSource.ContainsCardName("Gammamon");
 
-        if (timing == EffectTiming.None)
-        {
-            AddSkillClass addSkillClass = new AddSkillClass();
-            addSkillClass.SetUpICardEffect("This Digimon gains all effects of [Gammamon] in digivolution cards", CanUseCondition, card);
-            addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
-            addSkillClass.SetIsInheritedEffect(true);
-            cardEffects.Add(addSkillClass);
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.IsExistOnBattleArea(card);
-            }
-
-            bool PermanentCondition(Permanent permanent)
-            {
-                return permanent == card.PermanentOfThisCard();
-            }
-
-            bool CardSourceCondition(CardSource cardSource)
-            {
-                if (PermanentCondition(cardSource.PermanentOfThisCard()))
-                {
-                    if (cardSource == cardSource.PermanentOfThisCard().TopCard)
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
-            {
-                if (CardSourceCondition(cardSource))
-                {
-                    foreach (CardSource cardSource1 in cardSource.PermanentOfThisCard().DigivolutionCards)
-                    {
-                        if (cardSource1.ContainsCardName("Gammamon"))
-                        {
-                            foreach (ICardEffect cardEffect in cardSource1.cEntity_EffectController.GetCardEffects_ExceptAddedEffects(_timing, card))
-                            {
-                                if (!cardEffect.IsSecurityEffect && !cardEffect.IsInheritedEffect)
-                                {
-                                    cardEffects.Add(cardEffect);
-                                }
-                            }
-                        }
-                    }
-                }
-
-                return cardEffects;
-            }
-        }
+        CardEffectFactory.CopyDigivolutionCardEffects(ref cardEffects, timing, card, cardCondition: CopyCardCondition);
+        CardEffectFactory.CopyDigivolutionCardEffects(ref cardEffects, timing, card, isInheritedEffect: true, cardCondition: CopyCardCondition);
+        #endregion
 
         return cardEffects;
     }

Assets/Scripts/CardEffect/RB1/Green/RB1_023.cs

@@ -125,113 +125,12 @@ public class RB1_023 : CEntity_Effect
             }
         }
 
-        if (timing == EffectTiming.None)
-        {
-            AddSkillClass addSkillClass = new AddSkillClass();
-            addSkillClass.SetUpICardEffect("This Digimon gains all effects of [Gammamon] in digivolution cards", CanUseCondition, card);
-            addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
-
-            cardEffects.Add(addSkillClass);
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.IsExistOnBattleArea(card);
-            }
-
-            bool PermanentCondition(Permanent permanent)
-            {
-                return permanent == card.PermanentOfThisCard();
-            }
-
-            bool CardSourceCondition(CardSource cardSource)
-            {
-                if (PermanentCondition(cardSource.PermanentOfThisCard()))
-                {
-                    if (cardSource == cardSource.PermanentOfThisCard().TopCard)
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
-            {
-                if (CardSourceCondition(cardSource))
-                {
-                    foreach (CardSource cardSource1 in cardSource.PermanentOfThisCard().DigivolutionCards)
-                    {
-                        if (cardSource1.ContainsCardName("Gammamon"))
-                        {
-                            foreach (ICardEffect cardEffect in cardSource1.cEntity_EffectController.GetCardEffects_ExceptAddedEffects(_timing, card))
-                            {
-                                if (!cardEffect.IsSecurityEffect && !cardEffect.IsInheritedEffect)
-                                {
-                                    cardEffects.Add(cardEffect);
-                                }
-                            }
-                        }
-                    }
-                }
-
-                return cardEffects;
-            }
-        }
+        #region All Turns Copy effects of Gammamon in digivolution cards
+        bool CopyCardCondition(CardSource cardSource) => cardSource.ContainsCardName("Gammamon");
 
-        if (timing == EffectTiming.None)
-        {
-            AddSkillClass addSkillClass = new AddSkillClass();
-            addSkillClass.SetUpICardEffect("This Digimon gains all effects of [Gammamon] in digivolution cards", CanUseCondition, card);
-            addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
-            addSkillClass.SetIsInheritedEffect(true);
-            cardEffects.Add(addSkillClass);
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.IsExistOnBattleArea(card);
-            }
-
-            bool PermanentCondition(Permanent permanent)
-            {
-                return permanent == card.PermanentOfThisCard();
-            }
-
-            bool CardSourceCondition(CardSource cardSource)
-            {
-                if (PermanentCondition(cardSource.PermanentOfThisCard()))
-                {
-                    if (cardSource == cardSource.PermanentOfThisCard().TopCard)
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
-            {
-                if (CardSourceCondition(cardSource))
-                {
-                    foreach (CardSource cardSource1 in cardSource.PermanentOfThisCard().DigivolutionCards)
-                    {
-                        if (cardSource1.ContainsCardName("Gammamon"))
-                        {
-                            foreach (ICardEffect cardEffect in cardSource1.cEntity_EffectController.GetCardEffects_ExceptAddedEffects(_timing, card))
-                            {
-                                if (!cardEffect.IsSecurityEffect && !cardEffect.IsInheritedEffect)
-                                {
-                                    cardEffects.Add(cardEffect);
-                                }
-                            }
-                        }
-                    }
-                }
-
-                return cardEffects;
-            }
-        }
+        CardEffectFactory.CopyDigivolutionCardEffects(ref cardEffects, timing, card, cardCondition: CopyCardCondition);
+        CardEffectFactory.CopyDigivolutionCardEffects(ref cardEffects, timing, card, isInheritedEffect: true, cardCondition: CopyCardCondition);
+        #endregion
 
         return cardEffects;
     }

Assets/Scripts/CardEffect/RB1/Purple/RB1_030.cs

@@ -231,113 +231,12 @@ public class RB1_030 : CEntity_Effect
             }
         }
 
-        if (timing == EffectTiming.None)
-        {
-            AddSkillClass addSkillClass = new AddSkillClass();
-            addSkillClass.SetUpICardEffect("This Digimon gains all effects of [Gammamon] in digivolution cards", CanUseCondition, card);
-            addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
-
-            cardEffects.Add(addSkillClass);
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.IsExistOnBattleArea(card);
-            }
-
-            bool PermanentCondition(Permanent permanent)
-            {
-                return permanent == card.PermanentOfThisCard();
-            }
-
-            bool CardSourceCondition(CardSource cardSource)
-            {
-                if (PermanentCondition(cardSource.PermanentOfThisCard()))
-                {
-                    if (cardSource == cardSource.PermanentOfThisCard().TopCard)
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
-            {
-                if (CardSourceCondition(cardSource))
-                {
-                    foreach (CardSource cardSource1 in cardSource.PermanentOfThisCard().DigivolutionCards)
-                    {
-                        if (cardSource1.ContainsCardName("Gammamon"))
-                        {
-                            foreach (ICardEffect cardEffect in cardSource1.cEntity_EffectController.GetCardEffects_ExceptAddedEffects(_timing, card))
-                            {
-                                if (!cardEffect.IsSecurityEffect && !cardEffect.IsInheritedEffect)
-                                {
-                                    cardEffects.Add(cardEffect);
-                                }
-                            }
-                        }
-                    }
-                }
-
-                return cardEffects;
-            }
-        }
+        #region All Turns Copy effects of Gammamon in digivolution cards
+        bool CopyCardCondition(CardSource cardSource) => cardSource.ContainsCardName("Gammamon");
 
-        if (timing == EffectTiming.None)
-        {
-            AddSkillClass addSkillClass = new AddSkillClass();
-            addSkillClass.SetUpICardEffect("This Digimon gains all effects of [Gammamon] in digivolution cards", CanUseCondition, card);
-            addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
-            addSkillClass.SetIsInheritedEffect(true);
-            cardEffects.Add(addSkillClass);
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.IsExistOnBattleArea(card);
-            }
-
-            bool PermanentCondition(Permanent permanent)
-            {
-                return permanent == card.PermanentOfThisCard();
-            }
-
-            bool CardSourceCondition(CardSource cardSource)
-            {
-                if (PermanentCondition(cardSource.PermanentOfThisCard()))
-                {
-                    if (cardSource == cardSource.PermanentOfThisCard().TopCard)
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
-            {
-                if (CardSourceCondition(cardSource))
-                {
-                    foreach (CardSource cardSource1 in cardSource.PermanentOfThisCard().DigivolutionCards)
-                    {
-                        if (cardSource1.ContainsCardName("Gammamon"))
-                        {
-                            foreach (ICardEffect cardEffect in cardSource1.cEntity_EffectController.GetCardEffects_ExceptAddedEffects(_timing, card))
-                            {
-                                if (!cardEffect.IsSecurityEffect && !cardEffect.IsInheritedEffect)
-                                {
-                                    cardEffects.Add(cardEffect);
-                                }
-                            }
-                        }
-                    }
-                }
-
-                return cardEffects;
-            }
-        }
+        CardEffectFactory.CopyDigivolutionCardEffects(ref cardEffects, timing, card, cardCondition: CopyCardCondition);
+        CardEffectFactory.CopyDigivolutionCardEffects(ref cardEffects, timing, card, isInheritedEffect: true, cardCondition: CopyCardCondition);
+        #endregion
 
         return cardEffects;
     }

Assets/Scripts/CardEffect/RB1/Red/RB1_009.cs

@@ -46,113 +46,12 @@ namespace DCGO.CardEffects.RB1
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 3, ignoreDigivolutionRequirement: true, card: card, condition: Condition));
             }
 
-            if (timing == EffectTiming.None)
-            {
-                AddSkillClass addSkillClass = new AddSkillClass();
-                addSkillClass.SetUpICardEffect("This Digimon gains all effects of [Gammamon] in digivolution cards", CanUseCondition, card);
-                addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
-
-                cardEffects.Add(addSkillClass);
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
-                }
-
-                bool PermanentCondition(Permanent permanent)
-                {
-                    return permanent == card.PermanentOfThisCard();
-                }
-
-                bool CardSourceCondition(CardSource cardSource)
-                {
-                    if (PermanentCondition(cardSource.PermanentOfThisCard()))
-                    {
-                        if (cardSource == cardSource.PermanentOfThisCard().TopCard)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-
-                List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
-                {
-                    if (CardSourceCondition(cardSource))
-                    {
-                        foreach (CardSource cardSource1 in cardSource.PermanentOfThisCard().DigivolutionCards)
-                        {
-                            if (cardSource1.ContainsCardName("Gammamon"))
-                            {
-                                foreach (ICardEffect cardEffect in cardSource1.cEntity_EffectController.GetCardEffects_ExceptAddedEffects(_timing, card))
-                                {
-                                    if (!cardEffect.IsSecurityEffect && !cardEffect.IsInheritedEffect)
-                                    {
-                                        cardEffects.Add(cardEffect);
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    return cardEffects;
-                }
-            }
+            #region All Turns Copy effects of Gammamon in digivolution cards
+            bool CopyCardCondition(CardSource cardSource) => cardSource.ContainsCardName("Gammamon");
 
-            if (timing == EffectTiming.None)
-            {
-                AddSkillClass addSkillClass = new AddSkillClass();
-                addSkillClass.SetUpICardEffect("This Digimon gains all effects of [Gammamon] in digivolution cards", CanUseCondition, card);
-                addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
-                addSkillClass.SetIsInheritedEffect(true);
-                cardEffects.Add(addSkillClass);
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
-                }
-
-                bool PermanentCondition(Permanent permanent)
-                {
-                    return permanent == card.PermanentOfThisCard();
-                }
-
-                bool CardSourceCondition(CardSource cardSource)
-                {
-                    if (PermanentCondition(cardSource.PermanentOfThisCard()))
-                    {
-                        if (cardSource == cardSource.PermanentOfThisCard().TopCard)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-
-                List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
-                {
-                    if (CardSourceCondition(cardSource))
-                    {
-                        foreach (CardSource cardSource1 in cardSource.PermanentOfThisCard().DigivolutionCards)
-                        {
-                            if (cardSource1.ContainsCardName("Gammamon"))
-                            {
-                                foreach (ICardEffect cardEffect in cardSource1.cEntity_EffectController.GetCardEffects_ExceptAddedEffects(_timing, card))
-                                {
-                                    if (!cardEffect.IsSecurityEffect && !cardEffect.IsInheritedEffect)
-                                    {
-                                        cardEffects.Add(cardEffect);
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    return cardEffects;
-                }
-            }
+            CardEffectFactory.CopyDigivolutionCardEffects(ref cardEffects, timing, card, cardCondition: CopyCardCondition);
+            CardEffectFactory.CopyDigivolutionCardEffects(ref cardEffects, timing, card, isInheritedEffect: true, cardCondition: CopyCardCondition);
+            #endregion
 
             return cardEffects;
         }

Assets/Scripts/Script/CardEffectFactory/CopiedEffects.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+
+public partial class CardEffectFactory
+{
+    /// <summary>
+    /// Effect to copy through the effects of digivolution cards as effect of the top card. Done directly in CEntity_Effect.CardEffects for efficiency
+    /// </summary>
+    /// <param name="cardEffects">Reference to the list of effects for this card to add effects to</param>
+    /// <param name="timing">timing being queried</param>
+    /// <param name="card">Card with the copy effect</param>
+    /// <param name="canUseCondition">Condition to use this effect (Current turn, This digimon with X trait, etc.)</param>
+    /// <param name="cardCondition">Condition of the cards to copy from (gammamon in name, MachineDramon or Chaosdramon, etc.)</param>
+    /// <param name="effectCondition">Conditions on the effects to copy (Only On Plays, only activate effects, etc.)</param>
+    public static void CopyDigivolutionCardEffects(ref List<ICardEffect> cardEffects,
+                                                   EffectTiming timing, 
+                                                   CardSource card,
+                                                   bool isInheritedEffect = false,
+                                                   bool isLinkedEffect = false,
+                                                   Func<bool> canUseCondition = null,
+                                                   Func<CardSource, bool> cardCondition = null,
+                                                   Func<ICardEffect, bool> effectCondition = null
+                                                   )
+    {
+        if (card.PermanentOfThisCard() == null) return;
+        if (canUseCondition != null && !canUseCondition()) return;
+
+        Permanent thisPermanent = card.PermanentOfThisCard();
+
+        //If it is an inherited effect it should be in digivolution cards, if link effect should be linked, if neither it should not be in either (leaving only topcard)
+        if (isInheritedEffect != thisPermanent.DigivolutionCards.Contains(card)) return;
+        if (isLinkedEffect != thisPermanent.LinkedCards.Contains(card)) return;
+
+        List<CardSource> validSources = thisPermanent.DigivolutionCards.Filter(cardSource => cardSource != card && (cardCondition == null || cardCondition(cardSource)));
+
+        foreach (CardSource cardSource in validSources)
+        {
+            List<ICardEffect> toCopyEffects = cardSource.EffectList(timing);
+            int i = 0;
+            foreach (ICardEffect cardEffect in toCopyEffects)
+            {
+                if (cardEffect.IsInheritedEffect || cardEffect.IsLinkedEffect) continue;
+
+                if (cardEffect is ActivateClass)
+                {
+                    ActivateClass activateClass = (ActivateClass)cardEffect;
+                    activateClass.SetHashString(GenerateHashString(card, cardSource, i));//Set unique hashstring so OPTs work correctly
+                    cardEffects.Add(activateClass);
+                    cardEffects.Add(PermanentEffectFactory.AddDetailClass(thisPermanent, activateClass.EffectDiscription, true, activateClass));
+                }
+                else//If any other effect types need their can use condition changed to work correctly those can be handled here, otherwise just copied through
+                {
+                    cardEffects.Add(cardEffect);
+                }
+            }
+        }
+    }
+
+    private static string GenerateHashString(CardSource card, CardSource cardSource, int i) => $"Card-{card.CardIndex}-Copying-Card-{cardSource.CardIndex}-effect-{i}";
+}

Assets/Scripts/Script/CardEffectFactory/CopiedEffects.cs.meta

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

Assets/Scripts/Script/CardSource.cs

@@ -4177,6 +4177,18 @@ public class CardSource : MonoBehaviour
     }
 
     #endregion
+
+    #region whether this card has VB trait
+
+    public bool HasVBTraits
+    {
+        get
+        {
+            return EqualsTraits("VB");
+        }
+    }
+
+    #endregion
 }
 
 public class JogressCondition

Assets/Scripts/Script/SelectDigiXrosClass.cs

@@ -2,13 +2,14 @@ using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 using System.Linq;
-using Photon;
 using Photon.Pun;
 using System;
-using UnityEngine.Events;
 
 public class SelectDigiXrosClass : MonoBehaviourPunCallbacks
 {
+    private static WaitForSeconds _waitForSeconds0_4 = new WaitForSeconds(0.4f);
+    private static WaitForSeconds _waitForSeconds0_3 = new WaitForSeconds(0.3f);
+
     public List<CardSource> selectedDigicrossCards { get; private set; } = new List<CardSource>();
     public List<AddDigivolutionCardsInfo> addDigivolutionCardInfos { get; private set; } = new List<AddDigivolutionCardsInfo>();
     public List<CardSource> excludedCards { get; private set; } = new List<CardSource>();
@@ -387,8 +388,7 @@ public class SelectDigiXrosClass : MonoBehaviourPunCallbacks
 
                     if (_endSelectDigiXros)
                     {
-                        _endSelectDigiXros = false;
-                        //break; TODO: Removed for not triggering digixros in all situations
+                        _endSelectDigiXros = false;//Reset here in case of leftover from previous digixros
                     }
 
                     bool canSelectHand = false;
@@ -425,11 +425,11 @@ public class SelectDigiXrosClass : MonoBehaviourPunCallbacks
                         }
                     }
 
-                    Func<IEnumerator> _SelectHandCard = () => SelectHandCard(digiXrosCondition, element, card);
-                    Func<IEnumerator> _SelectBattleAreaDigimon = () => SelectBattleAreaPermanent(digiXrosCondition, element, card);
-                    Func<IEnumerator> _SelectTrashCard = () => SelectTrashCard(digiXrosCondition, element, card);
-                    Func<IEnumerator> _SelectTamerDigivolutionCard = () => SelectTamerDigivolutionCard(digiXrosCondition, element, card);
-                    Func<IEnumerator> _EndSelectDigiXros = () => EndSelectDigiXros();
+                    IEnumerator _SelectHandCard() => SelectHandCard(digiXrosCondition, element, card);
+                    IEnumerator _SelectBattleAreaDigimon() => SelectBattleAreaPermanent(digiXrosCondition, element, card);
+                    IEnumerator _SelectTrashCard() => SelectTrashCard(digiXrosCondition, element, card);
+                    IEnumerator _SelectTamerDigivolutionCard() => SelectTamerDigivolutionCard(digiXrosCondition, element, card);
+                    IEnumerator _EndSelectDigiXros() => EndSelectDigiXros();
 
                     List<Func<IEnumerator>> actions = new List<Func<IEnumerator>>() { _SelectHandCard, _SelectBattleAreaDigimon, _SelectTrashCard, _SelectTamerDigivolutionCard, _EndSelectDigiXros };
 
@@ -470,7 +470,7 @@ public class SelectDigiXrosClass : MonoBehaviourPunCallbacks
                         }
                     }
 
-                    else if (canSelectActions.Count == 2 && digiXrosCondition.CanTargetCondition_ByPreSelecetedList == null && !element.skipAllIfNoSelect)
+                    else if (canSelectActions.Count == 2 && !element.skipAllIfNoSelect)
                     {
                         SetTargetDigiXrossIndex(card.Owner.PlayerID, actions.IndexOf(canSelectActions[0]));
                     }
@@ -554,9 +554,14 @@ public class SelectDigiXrosClass : MonoBehaviourPunCallbacks
                     {
                         yield return ContinuousController.instance.StartCoroutine(actions[_targetIndex]());
 
+                        if (_endSelectDigiXros)
+                        {
+                            break;//Perform here where the value will only just have been set by the above routine
+                        }
+
                         if (!card.Owner.isYou && GManager.instance.IsAI)
                         {
-                            yield return new WaitForSeconds(0.3f);
+                            yield return _waitForSeconds0_3;
                         }
                     }
                 }
@@ -565,7 +570,7 @@ public class SelectDigiXrosClass : MonoBehaviourPunCallbacks
 
         if (selectedDigicrossCards.Count >= 1)
         {
-            yield return new WaitForSeconds(0.4f);
+            yield return _waitForSeconds0_4;
         }
 
         GManager.instance.GetComponent<Effects>().OffShowCard2();
@@ -619,7 +624,7 @@ public class SelectDigiXrosClass : MonoBehaviourPunCallbacks
                     {
                         if (digiXrosCondition.CanTargetCondition_ByPreSelecetedList != null || element.skipAllIfNoSelect)
                         {
-                            EndSelectDigiXros();
+                            StartCoroutine(EndSelectDigiXros());
                         }
                     }
                 }
@@ -677,7 +682,7 @@ public class SelectDigiXrosClass : MonoBehaviourPunCallbacks
                     {
                         if (digiXrosCondition.CanTargetCondition_ByPreSelecetedList != null || element.skipAllIfNoSelect)
                         {
-                            EndSelectDigiXros();
+                            StartCoroutine(EndSelectDigiXros());
                         }
                     }
                 }
@@ -739,7 +744,7 @@ public class SelectDigiXrosClass : MonoBehaviourPunCallbacks
                     {
                         if (digiXrosCondition.CanTargetCondition_ByPreSelecetedList != null || element.skipAllIfNoSelect)
                         {
-                            EndSelectDigiXros();
+                            StartCoroutine(EndSelectDigiXros());
                         }
                     }
                 }
@@ -794,7 +799,7 @@ public class SelectDigiXrosClass : MonoBehaviourPunCallbacks
                             {
                                 if (digiXrosCondition.CanTargetCondition_ByPreSelecetedList != null || element.skipAllIfNoSelect)
                                 {
-                                    EndSelectDigiXros();
+                                    StartCoroutine(EndSelectDigiXros());
                                 }
                             }
                         }
@@ -859,7 +864,7 @@ public class SelectDigiXrosClass : MonoBehaviourPunCallbacks
                     {
                         if (digiXrosCondition.CanTargetCondition_ByPreSelecetedList != null || element.skipAllIfNoSelect)
                         {
-                            EndSelectDigiXros();
+                            StartCoroutine(EndSelectDigiXros());
                         }
                     }
                 }