Merge branch 'Convert-ALL-Card-Classes' of https://github.com/DCGO2/DCGO into Convert-ALL-Card-Classes

Assets/CardEffect/BT15/Yellow/Angewomon_ACE_BT15_038.cs

@@ -1,272 +0,0 @@
-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
-using System.Linq;
-using Photon;
-using System;
-using Photon.Pun;
-public class Angewomon_ACE_BT15_038 : CEntity_Effect
-{
-  public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
-  {
-    List<ICardEffect> cardEffects = new List<ICardEffect>();
-
-    if (timing == EffectTiming.OnCounterTiming)
-    {
-      cardEffects.Add(CardEffectFactory.BlastDigivolveEffect(card: card, condition: null));
-    }
-
-        #region On Play
-
-        if (timing == EffectTiming.OnEnterFieldAnyone)
-    {
-      ActivateClass activateClass = new ActivateClass();
-      activateClass.SetUpICardEffect("Trash the top card of your security so that opponent's 1 Digimon gains DP -6000", CanUseCondition, card);
-      activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
-      cardEffects.Add(activateClass);
-
-      string EffectDiscription()
-      {
-        return "[On Play] By trashing the top or bottom card of your security stack, 1 of your opponent's Digimon gets -6000 DP until the end of your opponent's turn.";
-      }
-
-      bool CanSelectPermanentCondition(Permanent permanent)
-      {
-        return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
-      }
-
-      bool CanUseCondition(Hashtable hashtable)
-      {
-        return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
-      }
-
-      bool CanActivateCondition(Hashtable hashtable)
-      {
-        if (CardEffectCommons.IsExistOnBattleArea(card))
-        {
-          if (card.Owner.SecurityCards.Count >= 1)
-          {
-            return true;
-          }
-        }
-
-        return false;
-      }
-
-      IEnumerator ActivateCoroutine(Hashtable _hashtable)
-      {
-        if (card.Owner.SecurityCards.Count >= 1)
-        {
-          List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
-                    {
-                        new SelectionElement<bool>(message: $"Security Top", value : true, spriteIndex: 0),
-                        new SelectionElement<bool>(message: $"Security Bottom", value : false, spriteIndex: 1),
-                    };
-
-          string selectPlayerMessage = "Which will you trash the top or bottom card of the security?";
-          string notSelectPlayerMessage = "The opponent is selecting whether to trash the top or bottom card of security.";
-
-          GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
-
-          yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
-
-          bool fromTop = GManager.instance.userSelectionManager.SelectedBoolValue;
-  
-          yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
-                  card.Owner,
-                  1,
-                  activateClass,
-                  fromTop).DestroySecurity());
-
-          if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-          {
-            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-            selectPermanentEffect.SetUp(
-                selectPlayer: card.Owner,
-                canTargetCondition: CanSelectPermanentCondition,
-                canTargetCondition_ByPreSelecetedList: null,
-                canEndSelectCondition: null,
-                maxCount: maxCount,
-                canNoSelect: false,
-                canEndNotMax: false,
-                selectPermanentCoroutine: SelectPermanentCoroutine,
-                afterSelectPermanentCoroutine: null,
-                mode: SelectPermanentEffect.Mode.Custom,
-                cardEffect: activateClass);
-
-            selectPermanentEffect.SetUpCustomMessage(
-                "Select 1 Digimon that will get DP -6000.",
-                "The opponent is selecting 1 Digimon that will get DP -6000.");
-
-            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-            IEnumerator SelectPermanentCoroutine(Permanent permanent)
-            {
-              yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
-                targetPermanent: permanent,
-                changeValue: -6000,
-                effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                activateClass: activateClass));
-            }
-          }
-        }
-      }
-    }
-#endregion
-
-        #region When Digivolving 
-
-        if (timing == EffectTiming.OnEnterFieldAnyone)
-    {
-      ActivateClass activateClass = new ActivateClass();
-      activateClass.SetUpICardEffect("Trash the top card of your security so that opponent's 1 Digimon gains DP -6000", CanUseCondition, card);
-      activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
-      cardEffects.Add(activateClass);
-
-      string EffectDiscription()
-      {
-        return "[On Play] By trashing the top or bottom card of your security stack, 1 of your opponent's Digimon gets -6000 DP until the end of your opponent's turn.";
-      }
-
-      bool CanSelectPermanentCondition(Permanent permanent)
-      {
-        return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
-      }
-
-      bool CanUseCondition(Hashtable hashtable)
-      {
-        return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
-      }
-
-      bool CanActivateCondition(Hashtable hashtable)
-      {
-        if (CardEffectCommons.IsExistOnBattleArea(card))
-        {
-          if (card.Owner.SecurityCards.Count >= 1)
-          {
-            return true;
-          }
-        }
-
-        return false;
-      }
-
-      IEnumerator ActivateCoroutine(Hashtable _hashtable)
-      {
-        if (card.Owner.SecurityCards.Count >= 1)
-        {
-          List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
-                    {
-                        new SelectionElement<bool>(message: $"Security Top", value : true, spriteIndex: 0),
-                        new SelectionElement<bool>(message: $"Security Bottom", value : false, spriteIndex: 1),
-                    };
-
-          string selectPlayerMessage = "Which will you trash the top or bottom card of the security?";
-          string notSelectPlayerMessage = "The opponent is selecting whether to trash the top or bottom card of security.";
-
-          GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
-
-          yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
-
-          bool fromTop = GManager.instance.userSelectionManager.SelectedBoolValue;
-
-          yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
-                  card.Owner,
-                  1,
-                  activateClass,
-                  fromTop).DestroySecurity());
-
-          if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-          {
-            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-            selectPermanentEffect.SetUp(
-                selectPlayer: card.Owner,
-                canTargetCondition: CanSelectPermanentCondition,
-                canTargetCondition_ByPreSelecetedList: null,
-                canEndSelectCondition: null,
-                maxCount: maxCount,
-                canNoSelect: false,
-                canEndNotMax: false,
-                selectPermanentCoroutine: SelectPermanentCoroutine,
-                afterSelectPermanentCoroutine: null,
-                mode: SelectPermanentEffect.Mode.Custom,
-                cardEffect: activateClass);
-
-            selectPermanentEffect.SetUpCustomMessage(
-                "Select 1 Digimon that will get DP -6000.",
-                "The opponent is selecting 1 Digimon that will get DP -6000.");
-
-            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-            IEnumerator SelectPermanentCoroutine(Permanent permanent)
-            {
-              yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
-                targetPermanent: permanent,
-                changeValue: -6000,
-                effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                activateClass: activateClass));
-            }
-          }
-        }
-      }
-    }
-        #endregion
-
-        #region All Turns
-
-        if (timing == EffectTiming.OnLoseSecurity)
-    {
-      ActivateClass activateClass = new ActivateClass();
-      activateClass.SetUpICardEffect("Recovery +1 (Deck)", CanUseCondition, card);
-      activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
-      activateClass.SetHashString("Recovery1_BT15_038");
-      cardEffects.Add(activateClass);
-
-      string EffectDiscription()
-      {
-        return "[All Turns][Once Per Turn] When a card is removed from your security stack, if you have 3 or fewer security cards, trigger <Recovery +1 (Deck)>. (Place the top card of your deck on top of your security stack.)";
-      }
-
-      bool CanUseCondition(Hashtable hashtable)
-      {
-        if (CardEffectCommons.IsExistOnBattleArea(card))
-        {
-          if (CardEffectCommons.CanTriggerWhenLoseSecurity(hashtable, player => player == card.Owner))
-          {
-            return true;
-          }
-        }
-
-        return false;
-      }
-
-      bool CanActivateCondition(Hashtable hashtable)
-      {
-        if (CardEffectCommons.IsExistOnBattleArea(card))
-        {
-          if (card.Owner.SecurityCards.Count <= 3)
-          {
-            return true;
-          }
-        }
-
-        return false;
-      }
-
-      IEnumerator ActivateCoroutine(Hashtable _hashtable)
-      {
-        yield return ContinuousController.instance.StartCoroutine(new IRecovery(card.Owner, 1, activateClass).Recovery());
-      }
-    }
-        #endregion
-
-
-        return cardEffects;
-  }
-}

Assets/CardEffect/BT15/Yellow/Holydramon_BT15_042.cs → Assets/CardEffect/BT15/Yellow/BT15_038.cs

@@ -1,26 +1,32 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace DCGO.CardEffects.BT15
 {
-    public class Holydramon_BT15_042 : CEntity_Effect
+    public class BT15_038 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
+            if (timing == EffectTiming.OnCounterTiming)
+            {
+                cardEffects.Add(CardEffectFactory.BlastDigivolveEffect(card: card, condition: null));
+            }
+
+            #region On Play
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Trash the top card of your security so that opponent's 1 Digimon gains DP -9000 until the end of their turn", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Trash the top card of your security so that opponent's 1 Digimon gains DP -6000", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
                 {
-                    return "[On Play] You may trash the top card of your security stack to unsuspend this Digimon.";
+                    return "[On Play] By trashing the top or bottom card of your security stack, 1 of your opponent's Digimon gets -6000 DP until the end of your opponent's turn.";
                 }
 
                 bool CanSelectPermanentCondition(Permanent permanent)
@@ -91,8 +97,8 @@ namespace DCGO.CardEffects.BT15
                                 cardEffect: activateClass);
 
                             selectPermanentEffect.SetUpCustomMessage(
-                                "Select 1 Digimon that will get DP -9000.",
-                                "The opponent is selecting 1 Digimon that will get DP -9000.");
+                                "Select 1 Digimon that will get DP -6000.",
+                                "The opponent is selecting 1 Digimon that will get DP -6000.");
 
                             yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
@@ -100,7 +106,7 @@ namespace DCGO.CardEffects.BT15
                             {
                                 yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
                                   targetPermanent: permanent,
-                                  changeValue: -9000,
+                                  changeValue: -6000,
                                   effectDuration: EffectDuration.UntilOpponentTurnEnd,
                                   activateClass: activateClass));
                             }
@@ -109,16 +115,20 @@ namespace DCGO.CardEffects.BT15
                 }
             }
 
+            #endregion
+
+            #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Trash the top card of your security so that opponent's 1 Digimon gains DP -9000", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Trash the top card of your security so that opponent's 1 Digimon gains DP -6000", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
                 {
-                    return "[When Digivolving] You may trash the top card of your security stack to unsuspend this Digimon.";
+                    return "[On Play] By trashing the top or bottom card of your security stack, 1 of your opponent's Digimon gets -6000 DP until the end of your opponent's turn.";
                 }
 
                 bool CanSelectPermanentCondition(Permanent permanent)
@@ -189,8 +199,8 @@ namespace DCGO.CardEffects.BT15
                                 cardEffect: activateClass);
 
                             selectPermanentEffect.SetUpCustomMessage(
-                                "Select 1 Digimon that will get DP -9000.",
-                                "The opponent is selecting 1 Digimon that will get DP -9000.");
+                                "Select 1 Digimon that will get DP -6000.",
+                                "The opponent is selecting 1 Digimon that will get DP -6000.");
 
                             yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
@@ -198,7 +208,7 @@ namespace DCGO.CardEffects.BT15
                             {
                                 yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
                                   targetPermanent: permanent,
-                                  changeValue: -9000,
+                                  changeValue: -6000,
                                   effectDuration: EffectDuration.UntilOpponentTurnEnd,
                                   activateClass: activateClass));
                             }
@@ -207,12 +217,16 @@ namespace DCGO.CardEffects.BT15
                 }
             }
 
+            #endregion
+
+            #region All Turns
+
             if (timing == EffectTiming.OnLoseSecurity)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Place 1 card from hand to the top or bottom of the security", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
-                activateClass.SetHashString("Place1CardFromHandToSecurity_BT15_042");
+                activateClass.SetUpICardEffect("Recovery +1 (Deck)", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+                activateClass.SetHashString("Recovery1_BT15_038");
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -220,11 +234,6 @@ namespace DCGO.CardEffects.BT15
                     return "[All Turns][Once Per Turn] When a card is removed from your security stack, if you have 3 or fewer security cards, trigger <Recovery +1 (Deck)>. (Place the top card of your deck on top of your security stack.)";
                 }
 
-                bool CanSelectCardCondition(CardSource cardSource)
-                {
-                    return cardSource.CardColors.Contains(CardColor.Yellow);
-                }
-
                 bool CanUseCondition(Hashtable hashtable)
                 {
                     if (CardEffectCommons.IsExistOnBattleArea(card))
@@ -244,13 +253,7 @@ namespace DCGO.CardEffects.BT15
                     {
                         if (card.Owner.SecurityCards.Count <= 3)
                         {
-                            if (card.Owner.HandCards.Count >= 1)
-                            {
-                                if (card.Owner.CanAddSecurity(activateClass))
-                                {
-                                    return true;
-                                }
-                            }
+                            return true;
                         }
                     }
 
@@ -259,77 +262,12 @@ namespace DCGO.CardEffects.BT15
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
-                    {
-                        if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
-                        {
-                            List<CardSource> selectedCards = new List<CardSource>();
-
-                            int maxCount = 1;
-
-                            SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
-
-                            selectHandEffect.SetUp(
-                                selectPlayer: card.Owner,
-                                canTargetCondition: CanSelectCardCondition,
-                                canTargetCondition_ByPreSelecetedList: null,
-                                canEndSelectCondition: null,
-                                maxCount: maxCount,
-                                canNoSelect: true,
-                                canEndNotMax: false,
-                                isShowOpponent: true,
-                                selectCardCoroutine: SelectCardCoroutine,
-                                afterSelectCardCoroutine: null,
-                                mode: SelectHandEffect.Mode.Custom,
-                                cardEffect: activateClass);
-
-                            selectHandEffect.SetUpCustomMessage(
-                                "Select 1 card to place on the security.",
-                                "The opponent is selecting 1 card to place on the security.");
-
-                            yield return StartCoroutine(selectHandEffect.Activate());
-
-                            IEnumerator SelectCardCoroutine(CardSource cardSource)
-                            {
-                                selectedCards.Add(cardSource);
-
-                                yield return null;
-                            }
-
-                            foreach (CardSource cardSource in selectedCards)
-                            {
-                                List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
-                    {
-                        new SelectionElement<bool>(message: $"Security Top", value : true, spriteIndex: 0),
-                        new SelectionElement<bool>(message: $"Security Bottom", value : false, spriteIndex: 1),
-                    };
-
-                                string selectPlayerMessage = "Which will you place the card on the top or bottom card of the security?";
-                                string notSelectPlayerMessage = "The opponent is selecting whether to place the card on the top or bottom card of security.";
-
-                                GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
-
-                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
-
-                                bool toTop = GManager.instance.userSelectionManager.SelectedBoolValue;
-
-                                yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(cardSource));
-
-                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(cardSource.Owner));
-
-                                yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(cardSource.Owner).AddSecurity());
-
-                                if (!toTop)
-                                {
-                                    cardSource.Owner.SecurityCards.Remove(cardSource);
-                                    cardSource.Owner.SecurityCards.Add(cardSource);
-                                }
-                            }
-                        }
-                    }
+                    yield return ContinuousController.instance.StartCoroutine(new IRecovery(card.Owner, 1, activateClass).Recovery());
                 }
             }
 
+            #endregion
+
             return cardEffects;
         }
     }

Assets/CardEffect/BT15/Yellow/BT15_040.cs

@@ -0,0 +1,218 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DCGO.CardEffects.BT15
+{
+    public class BT15_040 : 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)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    if (targetPermanent.TopCard.ContainsCardName("Monzaemon") && targetPermanent.Level == 5 && !targetPermanent.TopCard.HasXAntibodyTraits)
+                    {
+                        return true;
+                    }
+                    return false;
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 0,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null));
+            }
+
+            #endregion
+
+            #region When Digivolving
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Play 1 Numemon or level 3 from your hand.", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] If a card with [Monzaemon] in its name or [X Antibody] is in this Digimon's digivolution cards, you may play 1 [Numemon] or 1 level 3 Digimon card from your hand without paying the cost.";
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    if (cardSource.CardNames.Contains("Numemon") || (cardSource.HasLevel && cardSource.Level <= 3))
+                    {
+                        if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass))
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (card.Owner.HandCards.Count >= 1)
+                        {
+                            if (card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) => cardSource.ContainsCardName("Monzaemon") || cardSource.CardNames.Contains("X Antibody") || cardSource.CardNames.Contains("XAntibody")) >= 1)
+                            {
+                                return true;
+                            }
+                        }
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
+                    {
+                        List<CardSource> selectedCards = new List<CardSource>();
+
+                        int maxCount = 1;
+
+                        SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                        selectHandEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectCardCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            isShowOpponent: true,
+                            selectCardCoroutine: SelectCardCoroutine,
+                            afterSelectCardCoroutine: null,
+                            mode: SelectHandEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        selectHandEffect.SetUpCustomMessage("Select 1 card to play.", "The opponent is selecting 1 card to play.");
+                        selectHandEffect.SetUpCustomMessage_ShowCard("Played Card");
+
+                        yield return StartCoroutine(selectHandEffect.Activate());
+
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            selectedCards.Add(cardSource);
+
+                            yield return null;
+                        }
+
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: selectedCards, activateClass: activateClass, payCost: false, isTapped: false, root: SelectCardEffect.Root.Hand, activateETB: true));
+                    }
+                }
+            }
+
+            #endregion
+
+            #region All Turns
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Give opponent's Digimon -2000 DP for each Digimon", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+                activateClass.SetHashString("ReduceDP_BT15_040");
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[All Turns][Once per turn] When another of your Digimon is played, for each of your Digimon, 1 of your opponent's Digimon gets -2000 DP unti the end of your opponent's turn";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.CanTriggerOnPermanentPlay(hashtable, (permanent) =>
+                            CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card) && permanent.TopCard != card))
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
+                    {
+                        return true;
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
+                    int maxDP = 0;
+                    maxDP += 2000 * card.Owner.GetBattleAreaDigimons().Count();
+
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectPermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: maxCount,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: SelectPermanentCoroutine,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Custom,
+                        cardEffect: activateClass);
+
+                    selectPermanentEffect.SetUpCustomMessage("Selcect 1 Digimon that will get DP " + maxDP + ".", "The opponent is selecting 1 Digimon that will get DP " + maxDP + ".");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: permanent, changeValue: -maxDP, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
+                    }
+                }
+            }
+
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/BT15/Yellow/Magnadramon_BT15_042.cs → Assets/CardEffect/BT15/Yellow/BT15_042.cs

@@ -1,15 +1,12 @@
+using System;
 using System.Collections;
 using System.Collections.Generic;
-using UnityEngine;
 using System.Linq;
-using Photon;
-using System;
-using Photon.Pun;
-using System.Runtime.InteropServices.WindowsRuntime;
+using UnityEngine;
 
 namespace DCGO.CardEffects.BT15
 {
-    public class Magnadramon_BT15_042 : CEntity_Effect
+    public class BT15_042 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {

Assets/CardEffect/BT15/Yellow/BT15_084.cs

@@ -0,0 +1,206 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace DCGO.CardEffects.BT15
+{
+    public class BT15_084 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region When trashed from security
+
+            if (timing == EffectTiming.OnDiscardSecurity)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Opponent's 1 Digimon gains Security Attack -1", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "When an effect trashes this card from the security stack, 1 of your opponent's Digimon gains [Security A -1] until the end of your opponent's turn.";
+                }
+
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnTrashSelfSecurity(hashtable, cardEffect => cardEffect != null, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    {
+                        if (CardEffectCommons.IsExistOnTrash(card))
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    {
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect.SetUpCustomMessage(
+                            "Selcect 1 Digimon that will get Security Attack -1.",
+                            "The opponent is selecting 1 Digimon that will get Security Attack -1.");
+
+                        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));
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            #region Start of Turn
+
+            if (timing == EffectTiming.OnStartTurn)
+            {
+                cardEffects.Add(CardEffectFactory.SetMemoryTo3TamerEffect(card));
+            }
+
+            #endregion
+
+            #region All turns
+
+            if (timing == EffectTiming.OnLoseSecurity)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Opponent's 1 Digimon gains Security Attack -1", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
+                activateClass.SetHashString("AllTurns_BT15_084");
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[All Turns] When an effect removes a card from your security stack, by suspending this Tamer, 1 of your opponent's Digimon gains [Security A-1] until the end of your opponent's turn.";
+                }
+
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.CanTriggerWhenLoseSecurity(hashtable, player => player == card.Owner))
+                        {
+                            ICardEffect effect = CardEffectCommons.GetCardEffectFromHashtable(hashtable);
+                            if (effect != null)
+                            {
+                                return true;
+                            }
+                            //if (!GManager.instance.attackProcess.DoSecurityCheck)
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.CanActivateSuspendCostEffect(card))
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(new SuspendPermanentsClass(new List<Permanent>() { card.PermanentOfThisCard() }, CardEffectCommons.CardEffectHashtable(activateClass)).Tap());
+
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    {
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect.SetUpCustomMessage(
+                            "Selcect 1 Digimon that will get Security Attack -1.",
+                            "The opponent is selecting 1 Digimon that will get Security Attack -1.");
+
+                        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));
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            #region Security effect
+
+            if (timing == EffectTiming.SecuritySkill)
+            {
+                cardEffects.Add(CardEffectFactory.PlaySelfTamerSecurityEffect(card));
+            }
+
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/BT15/Yellow/BT15_092.cs

@@ -0,0 +1,223 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DCGO.CardEffects.BT15
+{
+    public class BT15_092 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region When trashed from security
+
+            if (timing == EffectTiming.OnDiscardSecurity)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Activate security effect", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "When an effect trashes this card from the security stack, activate this card's [Security] effect.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnTrashSelfSecurity(hashtable, cardEffect => cardEffect != null, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnTrash(card);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    ActivateClass mainActivateClass = CardEffectCommons.OptionSecurityEffect(card);
+
+                    if (mainActivateClass != null)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(mainActivateClass.Activate(CardEffectCommons.OptionMainCheckHashtable(card)));
+                    }
+                }
+            }
+
+            #endregion
+
+            #region Main
+
+            if (timing == EffectTiming.OptionSkill)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Play 1 Digimon from security", CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[Main] Search your security stack. You may play 1 level 4 or lower yellow Digimon card among it without paying the cost. Then, shuffle your security stack. If you have a Tamer with [Kari Kamiya] in its name, place this card on top of your security stack.";
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    if (cardSource.IsDigimon)
+                    {
+                        if (cardSource.CardColors.Contains(CardColor.Yellow) && cardSource.Level <= 4)
+                        {
+                            if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOptionMainEffect(hashtable, card);
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card))
+                    {
+                        if (card.Owner.CanAddSecurity(activateClass))
+                        {
+                            if (permanent.IsTamer)
+                            {
+                                if (permanent.TopCard.ContainsCardName("Kari Kamiya"))
+                                {
+                                    return true;
+                                }
+
+                                if (permanent.TopCard.ContainsCardName("KariKamiya"))
+                                {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    if (card.Owner.SecurityCards.Count >= 1)
+                    {
+                        bool played = false;
+
+                        int maxCount = Math.Min(1, card.Owner.SecurityCards.Count(CanSelectCardCondition));
+
+                        List<CardSource> selectedCards = new List<CardSource>();
+
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                        selectCardEffect.SetUp(
+                            canTargetCondition: CanSelectCardCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            canNoSelect: () => true,
+                            selectCardCoroutine: SelectCardCoroutine,
+                            afterSelectCardCoroutine: AfterSelectCardCoroutine,
+                            message: "Select 1 Digimon to play.",
+                            maxCount: maxCount,
+                            canEndNotMax: false,
+                            isShowOpponent: true,
+                            mode: SelectCardEffect.Mode.Custom,
+                            root: SelectCardEffect.Root.Security,
+                            customRootCardList: null,
+                            canLookReverseCard: true,
+                            selectPlayer: card.Owner,
+                            cardEffect: activateClass);
+
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            selectedCards.Add(cardSource);
+
+                            yield return null;
+                        }
+
+                        IEnumerator AfterSelectCardCoroutine(List<CardSource> cardSources)
+                        {
+                            if (cardSources.Count >= 1)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(new IReduceSecurity(
+                                    player: card.Owner,
+                                    refSkillInfos: ref ContinuousController.instance.nullSkillInfos).ReduceSecurity());
+                            }
+
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: selectedCards, activateClass: activateClass, payCost: false, isTapped: false, root: SelectCardEffect.Root.Security, activateETB: true));
+                        }
+                    }
+
+                    card.Owner.SecurityCards = RandomUtility.ShuffledDeckCards(card.Owner.SecurityCards);
+
+                    if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, PermanentCondition))
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(card, toTop: true));
+
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(card.Owner));
+
+                        yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(card.Owner).AddSecurity());
+                    }
+                }
+            }
+
+            #endregion
+
+            #region Security effect
+
+            if (timing == EffectTiming.SecuritySkill)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect($"Security Attack -1", CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetIsSecurityEffect(true);
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[Security] All of your opponent's Digimon and all of your opponent's Security Digimon get -5000 DP until the end of your turn.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerSecurityEffect(hashtable, card);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    bool PermanentCondition(Permanent permanent)
+                    {
+                        return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                    }
+
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDPPlayerEffect(
+                        permanentCondition: PermanentCondition,
+                        changeValue: -5000,
+                        effectDuration: EffectDuration.UntilOwnerTurnEnd,
+                        activateClass: activateClass));
+
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeSecurityDigimonCardDPPlayerEffect(
+                            cardCondition: cardSource => cardSource.Owner == card.Owner.Enemy,
+                            changeValue: -5000,
+                            effectDuration: EffectDuration.UntilOwnerTurnEnd,
+                            activateClass: activateClass));
+                }
+            }
+
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/BT15/Yellow/BT15_093.cs

@@ -0,0 +1,146 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace DCGO.CardEffects.BT15
+{
+    public class BT15_093 : 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(card.BaseENGCardNameFromEntity, CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[Main] 1 of your opponent's Digimon gets -6000 DP for the turn. Then, by trashing the top or bottom card of your security stack, 1 of your opponent's Digimon gets -6000 DP for the turn.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOptionMainEffect(hashtable, card);
+                }
+
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    {
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will get DP -6000.", "The opponent is selecting 1 Digimon that will get DP -6000.");
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: permanent, changeValue: -6000, effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
+                        }
+                    }
+
+                    if (card.Owner.SecurityCards.Count >= 1)
+                    {
+                        List<SelectionElement<int>> selectionElements = new List<SelectionElement<int>>()
+                    {
+                        new SelectionElement<int>(message: $"Security Top", value : 0, spriteIndex: 0),
+                        new SelectionElement<int>(message: $"Security Bottom", value : 1, spriteIndex: 0),
+                        new SelectionElement<int>(message: $"No Selection", value : 2, spriteIndex: 1),
+                    };
+
+                        string selectPlayerMessage = "Which will you trash the top or bottom card of the security?";
+                        string notSelectPlayerMessage = "The opponent is selecting whether to trash the top or bottom card of security.";
+
+                        GManager.instance.userSelectionManager.SetIntSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                        int selectionValue = GManager.instance.userSelectionManager.SelectedIntValue;
+
+                        if (selectionValue != 2)
+                        {
+                            bool fromTop = selectionValue.Equals(0);
+
+                            yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
+                                player: card.Owner,
+                                destroySecurityCount: 1,
+                                cardEffect: activateClass,
+                                fromTop: fromTop).DestroySecurity());
+
+                            if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                            {
+                                int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
+                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                                selectPermanentEffect.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: CanSelectPermanentCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: maxCount,
+                                    canNoSelect: false,
+                                    canEndNotMax: false,
+                                    selectPermanentCoroutine: SelectPermanentCoroutine,
+                                    afterSelectPermanentCoroutine: null,
+                                    mode: SelectPermanentEffect.Mode.Custom,
+                                    cardEffect: activateClass);
+
+                                selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will get DP -6000.", "The opponent is selecting 1 Digimon that will get DP -6000.");
+
+                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                                IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                                {
+                                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: permanent, changeValue: -6000, effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            #region Security effect
+
+            if (timing == EffectTiming.SecuritySkill)
+            {
+                CardEffectCommons.AddActivateMainOptionSecurityEffect(
+                    card: card,
+                    cardEffects: ref cardEffects,
+                    effectName: $"Minus DP");
+            }
+
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/BT15/Yellow/Holy_Arrow_BT15_093.cs

@@ -1,147 +0,0 @@
-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
-using System.Linq;
-using Photon;
-using System;
-using Photon.Pun;
-
-public class Holy_Arrow_BT15_093 : 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(card.BaseENGCardNameFromEntity, CanUseCondition, card);
-            activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
-            cardEffects.Add(activateClass);
-
-            string EffectDiscription()
-            {
-                return "[Main] 1 of your opponent's Digimon gets -6000 DP for the turn. Then, by trashing the top or bottom card of your security stack, 1 of your opponent's Digimon gets -6000 DP for the turn.";
-            }
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.CanTriggerOptionMainEffect(hashtable, card);
-            }
-
-            bool CanSelectPermanentCondition(Permanent permanent)
-            {
-                return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
-            }
-
-            IEnumerator ActivateCoroutine(Hashtable _hashtable)
-            {
-                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-                {
-                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                    selectPermanentEffect.SetUp(
-                        selectPlayer: card.Owner,
-                        canTargetCondition: CanSelectPermanentCondition,
-                        canTargetCondition_ByPreSelecetedList: null,
-                        canEndSelectCondition: null,
-                        maxCount: maxCount,
-                        canNoSelect: false,
-                        canEndNotMax: false,
-                        selectPermanentCoroutine: SelectPermanentCoroutine,
-                        afterSelectPermanentCoroutine: null,
-                        mode: SelectPermanentEffect.Mode.Custom,
-                        cardEffect: activateClass);
-
-                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will get DP -6000.", "The opponent is selecting 1 Digimon that will get DP -6000.");
-
-                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                    {
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: permanent, changeValue: -6000, effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
-                    }
-                }
-
-                if (card.Owner.SecurityCards.Count >= 1)
-                {
-                    List<SelectionElement<int>> selectionElements = new List<SelectionElement<int>>()
-                    {
-                        new SelectionElement<int>(message: $"Security Top", value : 0, spriteIndex: 0),
-                        new SelectionElement<int>(message: $"Security Bottom", value : 1, spriteIndex: 0),
-                        new SelectionElement<int>(message: $"No Selection", value : 2, spriteIndex: 1),
-                    };
-
-                    string selectPlayerMessage = "Which will you trash the top or bottom card of the security?";
-                    string notSelectPlayerMessage = "The opponent is selecting whether to trash the top or bottom card of security.";
-
-                    GManager.instance.userSelectionManager.SetIntSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
-
-                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
-
-                    int selectionValue = GManager.instance.userSelectionManager.SelectedIntValue;
-
-                    if(selectionValue != 2)
-                    {
-                        bool fromTop = selectionValue.Equals(0);
-
-                        yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
-                            player: card.Owner,
-                            destroySecurityCount: 1,
-                            cardEffect: activateClass,
-                            fromTop: fromTop).DestroySecurity());
-
-                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-                        {
-                            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                            selectPermanentEffect.SetUp(
-                                selectPlayer: card.Owner,
-                                canTargetCondition: CanSelectPermanentCondition,
-                                canTargetCondition_ByPreSelecetedList: null,
-                                canEndSelectCondition: null,
-                                maxCount: maxCount,
-                                canNoSelect: false,
-                                canEndNotMax: false,
-                                selectPermanentCoroutine: SelectPermanentCoroutine,
-                                afterSelectPermanentCoroutine: null,
-                                mode: SelectPermanentEffect.Mode.Custom,
-                                cardEffect: activateClass);
-
-                            selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will get DP -6000.", "The opponent is selecting 1 Digimon that will get DP -6000.");
-
-                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                            IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                            {
-                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: permanent, changeValue: -6000, effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
-                            }
-                        }
-                    }                 
-                }
-            }
-        }
-
-        #endregion
-
-        #region Security effect
-        if (timing == EffectTiming.SecuritySkill)
-        {
-            CardEffectCommons.AddActivateMainOptionSecurityEffect(
-                card: card,
-                cardEffects: ref cardEffects,
-                effectName: $"Minus DP");
-        }
-        #endregion
-
-        return cardEffects;
-    }
-
-}

Assets/CardEffect/BT15/Yellow/Holydramon_BT15_042.cs.meta

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

Assets/CardEffect/BT15/Yellow/Kari_Kamiya_BT15_084.cs

@@ -1,202 +0,0 @@
-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
-using System.Linq;
-using Photon;
-using System;
-using Photon.Pun;
-
-public class Kari_Kamiya_BT15_084 : CEntity_Effect
-{
-    public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
-    {
-        List<ICardEffect> cardEffects = new List<ICardEffect>();
-
-        #region When trashed from security
-
-        if (timing == EffectTiming.OnDiscardSecurity)
-        {
-            ActivateClass activateClass = new ActivateClass();
-            activateClass.SetUpICardEffect("Opponent's 1 Digimon gains Security Attack -1", CanUseCondition, card);
-            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-            cardEffects.Add(activateClass);
-
-            string EffectDiscription()
-            {
-                return "When an effect trashes this card from the security stack, 1 of your opponent's Digimon gains [Security A -1] until the end of your opponent's turn.";
-            }
-
-            bool CanSelectPermanentCondition(Permanent permanent)
-            {
-                return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
-            }
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.CanTriggerOnTrashSelfSecurity(hashtable, cardEffect => cardEffect != null, card);
-            }
-
-            bool CanActivateCondition(Hashtable hashtable)
-            {
-                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-                {
-                    if (CardEffectCommons.IsExistOnTrash(card))
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            IEnumerator ActivateCoroutine(Hashtable _hashtable)
-            {
-                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-                {
-                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                    selectPermanentEffect.SetUp(
-                        selectPlayer: card.Owner,
-                        canTargetCondition: CanSelectPermanentCondition,
-                        canTargetCondition_ByPreSelecetedList: null,
-                        canEndSelectCondition: null,
-                        maxCount: maxCount,
-                        canNoSelect: false,
-                        canEndNotMax: false,
-                        selectPermanentCoroutine: SelectPermanentCoroutine,
-                        afterSelectPermanentCoroutine: null,
-                        mode: SelectPermanentEffect.Mode.Custom,
-                        cardEffect: activateClass);
-
-                    selectPermanentEffect.SetUpCustomMessage(
-                        "Selcect 1 Digimon that will get Security Attack -1.",
-                        "The opponent is selecting 1 Digimon that will get Security Attack -1.");
-
-                    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));
-                    }
-                }
-            }
-        }
-        #endregion
-
-        #region Start of Turn
-        if (timing == EffectTiming.OnStartTurn)
-        {
-            cardEffects.Add(CardEffectFactory.SetMemoryTo3TamerEffect(card));
-        }
-        #endregion
-
-        #region All turns
-
-        if (timing == EffectTiming.OnLoseSecurity)
-        {
-            ActivateClass activateClass = new ActivateClass();
-            activateClass.SetUpICardEffect("Opponent's 1 Digimon gains Security Attack -1", CanUseCondition, card);
-            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
-            activateClass.SetHashString("AllTurns_BT15_084");
-            cardEffects.Add(activateClass);
-
-            string EffectDiscription()
-            {
-                return "[All Turns] When an effect removes a card from your security stack, by suspending this Tamer, 1 of your opponent's Digimon gains [Security A-1] until the end of your opponent's turn.";
-            }
-
-            bool CanSelectPermanentCondition(Permanent permanent)
-            {
-                return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
-            }
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                if (CardEffectCommons.IsExistOnBattleArea(card))
-                {
-                    if (CardEffectCommons.CanTriggerWhenLoseSecurity(hashtable, player => player == card.Owner))
-                    {
-                        ICardEffect effect = CardEffectCommons.GetCardEffectFromHashtable(hashtable);
-                        if (effect != null)
-                        {
-                            return true;
-                        }
-                        //if (!GManager.instance.attackProcess.DoSecurityCheck)
-                    }
-                }
-
-                return false;
-            }
-
-            bool CanActivateCondition(Hashtable hashtable)
-            {
-                if (CardEffectCommons.IsExistOnBattleArea(card))
-                {
-                    if (CardEffectCommons.CanActivateSuspendCostEffect(card))
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            IEnumerator ActivateCoroutine(Hashtable _hashtable)
-            {
-                yield return ContinuousController.instance.StartCoroutine(new SuspendPermanentsClass(new List<Permanent>() { card.PermanentOfThisCard() }, CardEffectCommons.CardEffectHashtable(activateClass)).Tap());
-
-                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-                {
-                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                    selectPermanentEffect.SetUp(
-                        selectPlayer: card.Owner,
-                        canTargetCondition: CanSelectPermanentCondition,
-                        canTargetCondition_ByPreSelecetedList: null,
-                        canEndSelectCondition: null,
-                        maxCount: maxCount,
-                        canNoSelect: false,
-                        canEndNotMax: false,
-                        selectPermanentCoroutine: SelectPermanentCoroutine,
-                        afterSelectPermanentCoroutine: null,
-                        mode: SelectPermanentEffect.Mode.Custom,
-                        cardEffect: activateClass);
-
-                    selectPermanentEffect.SetUpCustomMessage(
-                        "Selcect 1 Digimon that will get Security Attack -1.",
-                        "The opponent is selecting 1 Digimon that will get Security Attack -1.");
-
-                    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));
-                    }
-                }
-            }
-        }
-
-        #endregion
-
-        #region Security effect
-        if (timing == EffectTiming.SecuritySkill)
-        {
-            cardEffects.Add(CardEffectFactory.PlaySelfTamerSecurityEffect(card));
-        }
-        #endregion
-
-        return cardEffects;
-    }
-}

Assets/CardEffect/BT15/Yellow/Monzaemon_X_Antibody_BT15_040.cs

@@ -1,211 +0,0 @@
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System;
-
-public class Monzaemon_X_Antibody_BT15_040 : 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)
-        {
-            bool PermanentCondition(Permanent targetPermanent)
-            {
-                if (targetPermanent.TopCard.ContainsCardName("Monzaemon") && targetPermanent.Level == 5 && !targetPermanent.TopCard.HasXAntibodyTraits)
-                {
-                    return true;
-                }
-                return false;
-            }
-
-            cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
-                permanentCondition: PermanentCondition,
-                digivolutionCost: 0,
-                ignoreDigivolutionRequirement: false,
-                card: card,
-                condition: null));
-        }
-        #endregion
-
-        #region When Digivolving
-        if (timing == EffectTiming.OnEnterFieldAnyone)
-        {
-            ActivateClass activateClass = new ActivateClass();
-            activateClass.SetUpICardEffect("Play 1 Numemon or level 3 from your hand.", CanUseCondition, card);
-            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
-            cardEffects.Add(activateClass);
-
-            string EffectDiscription()
-            {
-                return "[When Digivolving] If a card with [Monzaemon] in its name or [X Antibody] is in this Digimon's digivolution cards, you may play 1 [Numemon] or 1 level 3 Digimon card from your hand without paying the cost.";
-            }
-
-            bool CanSelectCardCondition(CardSource cardSource)
-            {
-                if (cardSource.CardNames.Contains("Numemon") || (cardSource.HasLevel && cardSource.Level <=3))
-                {
-                    if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass))
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
-            }
-
-            bool CanActivateCondition(Hashtable hashtable)
-            {
-                if (CardEffectCommons.IsExistOnBattleArea(card))
-                {
-                    if (card.Owner.HandCards.Count >= 1)
-                    {
-                        if (card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) => cardSource.ContainsCardName("Monzaemon") || cardSource.CardNames.Contains("X Antibody") || cardSource.CardNames.Contains("XAntibody")) >= 1)
-                        {
-                            return true;
-                        }
-                    }
-                }
-
-                return false;
-            }
-
-            IEnumerator ActivateCoroutine(Hashtable _hashtable)
-            {
-                if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
-                {
-                    List<CardSource> selectedCards = new List<CardSource>();
-
-                    int maxCount = 1;
-
-                    SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
-
-                    selectHandEffect.SetUp(
-                        selectPlayer: card.Owner,
-                        canTargetCondition: CanSelectCardCondition,
-                        canTargetCondition_ByPreSelecetedList: null,
-                        canEndSelectCondition: null,
-                        maxCount: maxCount,
-                        canNoSelect: true,
-                        canEndNotMax: false,
-                        isShowOpponent: true,
-                        selectCardCoroutine: SelectCardCoroutine,
-                        afterSelectCardCoroutine: null,
-                        mode: SelectHandEffect.Mode.Custom,
-                        cardEffect: activateClass);
-
-                    selectHandEffect.SetUpCustomMessage("Select 1 card to play.", "The opponent is selecting 1 card to play.");
-                    selectHandEffect.SetUpCustomMessage_ShowCard("Played Card");
-
-                    yield return StartCoroutine(selectHandEffect.Activate());
-
-                    IEnumerator SelectCardCoroutine(CardSource cardSource)
-                    {
-                        selectedCards.Add(cardSource);
-
-                        yield return null;
-                    }
-
-                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: selectedCards, activateClass: activateClass, payCost: false, isTapped: false, root: SelectCardEffect.Root.Hand, activateETB: true));
-                }
-            }
-        }
-        #endregion
-
-        #region All Turns
-        if (timing == EffectTiming.OnEnterFieldAnyone)
-        {
-            ActivateClass activateClass = new ActivateClass();
-            activateClass.SetUpICardEffect("Give opponent's Digimon -2000 DP for each Digimon", CanUseCondition, card);
-            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
-            activateClass.SetHashString("ReduceDP_BT15_040");
-            cardEffects.Add(activateClass);
-           
-
-            string EffectDiscription()
-            {
-                return "[All Turns][Once per turn] When another of your Digimon is played, for each of your Digimon, 1 of your opponent's Digimon gets -2000 DP unti the end of your opponent's turn";
-            }
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                if (CardEffectCommons.IsExistOnBattleArea(card))
-                {
-                    if (CardEffectCommons.CanTriggerOnPermanentPlay(hashtable, (permanent) => 
-                        CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card) && permanent.TopCard != card))
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            bool CanActivateCondition(Hashtable hashtable)
-            {
-                if (CardEffectCommons.IsExistOnBattleArea(card))
-                {
-                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            bool CanSelectPermanentCondition(Permanent permanent)
-            {
-                if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
-                {
-                    return true;
-                }
-
-                return false;
-            }
-
-            IEnumerator ActivateCoroutine(Hashtable _hashtable)
-            {
-                int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-                int maxDP = 0;
-                maxDP += 2000 * card.Owner.GetBattleAreaDigimons().Count();
-
-                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                selectPermanentEffect.SetUp(
-                    selectPlayer: card.Owner,
-                    canTargetCondition: CanSelectPermanentCondition,
-                    canTargetCondition_ByPreSelecetedList: null,
-                    canEndSelectCondition: null,
-                    maxCount: maxCount,
-                    canNoSelect: false,
-                    canEndNotMax: false,
-                    selectPermanentCoroutine: SelectPermanentCoroutine,
-                    afterSelectPermanentCoroutine: null,
-                    mode: SelectPermanentEffect.Mode.Custom,
-                    cardEffect: activateClass);
-
-                selectPermanentEffect.SetUpCustomMessage("Selcect 1 Digimon that will get DP " + maxDP + ".", "The opponent is selecting 1 Digimon that will get DP " + maxDP + ".");
-
-                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                {
-                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: permanent, changeValue: -maxDP, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
-
-                }
-            }
-        }
-        #endregion
-
-        return cardEffects;
-    }
-}

Assets/CardEffect/BT15/Yellow/Revelation_of_Light_BT15_092.cs

@@ -1,224 +0,0 @@
-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
-using System.Linq;
-using Photon;
-using System;
-using Photon.Pun;
-
-public class Revelation_of_Light_BT15_092 : CEntity_Effect
-{
-    public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
-    {
-        List<ICardEffect> cardEffects = new List<ICardEffect>();
-
-        #region When trashed from security
-
-        if (timing == EffectTiming.OnDiscardSecurity)
-        {
-            ActivateClass activateClass = new ActivateClass();
-            activateClass.SetUpICardEffect("Activate security effect", CanUseCondition, card);
-            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-            cardEffects.Add(activateClass);
-
-            string EffectDiscription()
-            {
-                return "When an effect trashes this card from the security stack, activate this card's [Security] effect.";
-            }
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.CanTriggerOnTrashSelfSecurity(hashtable, cardEffect => cardEffect != null, card);
-            }
-
-            bool CanActivateCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.IsExistOnTrash(card);
-            }
-
-            IEnumerator ActivateCoroutine(Hashtable _hashtable)
-            {
-                ActivateClass mainActivateClass = CardEffectCommons.OptionSecurityEffect(card);
-
-                if (mainActivateClass != null)
-                {
-                    yield return ContinuousController.instance.StartCoroutine(mainActivateClass.Activate(CardEffectCommons.OptionMainCheckHashtable(card)));
-                }
-            }
-        }
-
-        #endregion
-
-        #region Main
-
-        if (timing == EffectTiming.OptionSkill)
-        {
-            ActivateClass activateClass = new ActivateClass();
-            activateClass.SetUpICardEffect("Play 1 Digimon from security", CanUseCondition, card);
-            activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
-            cardEffects.Add(activateClass);
-
-            string EffectDiscription()
-            {
-                return "[Main] Search your security stack. You may play 1 level 4 or lower yellow Digimon card among it without paying the cost. Then, shuffle your security stack. If you have a Tamer with [Kari Kamiya] in its name, place this card on top of your security stack.";
-            }
-
-            bool CanSelectCardCondition(CardSource cardSource)
-            {
-                if (cardSource.IsDigimon)
-                {
-                    if (cardSource.CardColors.Contains(CardColor.Yellow) && cardSource.Level <= 4)
-                    {
-                        if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass))
-                        {
-                            return true;
-                        }
-                    }
-                }
-
-                return false;
-            }
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.CanTriggerOptionMainEffect(hashtable, card);
-            }
-
-            bool PermanentCondition(Permanent permanent)
-            {
-                if (CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card))
-                {
-                    if (card.Owner.CanAddSecurity(activateClass))
-                    {
-                        if (permanent.IsTamer)
-                        {
-                            if (permanent.TopCard.ContainsCardName("Kari Kamiya"))
-                            {
-                                return true;
-                            }
-
-                            if (permanent.TopCard.ContainsCardName("KariKamiya"))
-                            {
-                                return true;
-                            }
-                        }
-                    }
-                }
-
-                return false;
-            }
-
-            IEnumerator ActivateCoroutine(Hashtable _hashtable)
-            {
-                if (card.Owner.SecurityCards.Count >= 1)
-                {
-                    bool played = false;
-
-                    int maxCount = Math.Min(1, card.Owner.SecurityCards.Count(CanSelectCardCondition));
-
-                    List<CardSource> selectedCards = new List<CardSource>();
-
-                    SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
-
-                    selectCardEffect.SetUp(
-                        canTargetCondition: CanSelectCardCondition,
-                        canTargetCondition_ByPreSelecetedList: null,
-                        canEndSelectCondition: null,
-                        canNoSelect: () => true,
-                        selectCardCoroutine: SelectCardCoroutine,
-                        afterSelectCardCoroutine: AfterSelectCardCoroutine,
-                        message: "Select 1 Digimon to play.",
-                        maxCount: maxCount,
-                        canEndNotMax: false,
-                        isShowOpponent: true,
-                        mode: SelectCardEffect.Mode.Custom,
-                        root: SelectCardEffect.Root.Security,
-                        customRootCardList: null,
-                        canLookReverseCard: true,
-                        selectPlayer: card.Owner,
-                        cardEffect: activateClass);
-
-                    yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
-
-                    IEnumerator SelectCardCoroutine(CardSource cardSource)
-                    {
-                        selectedCards.Add(cardSource);
-
-                        yield return null;
-                    }
-
-                    IEnumerator AfterSelectCardCoroutine(List<CardSource> cardSources)
-                    {
-                        if (cardSources.Count >= 1)
-                        {
-                            yield return ContinuousController.instance.StartCoroutine(new IReduceSecurity(
-                                player: card.Owner,
-                                refSkillInfos: ref ContinuousController.instance.nullSkillInfos).ReduceSecurity());
-                        }
-
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: selectedCards, activateClass: activateClass, payCost: false, isTapped: false, root: SelectCardEffect.Root.Security, activateETB: true));
-                    }
-                }
-
-                card.Owner.SecurityCards = RandomUtility.ShuffledDeckCards(card.Owner.SecurityCards);
-
-                if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, PermanentCondition))
-                {
-                    yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(card, toTop: true));
-
-                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(card.Owner));
-
-                    yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(card.Owner).AddSecurity());
-
-                }
-            }
-        }
-        #endregion
-
-        #region Security effect
-
-        if (timing == EffectTiming.SecuritySkill)
-        {
-            ActivateClass activateClass = new ActivateClass();
-            activateClass.SetUpICardEffect($"Security Attack -1", CanUseCondition, card);
-            activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
-            activateClass.SetIsSecurityEffect(true);
-            cardEffects.Add(activateClass);
-
-            string EffectDiscription()
-            {
-                return "[Security] All of your opponent's Digimon and all of your opponent's Security Digimon get -5000 DP until the end of your turn.";
-            }
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.CanTriggerSecurityEffect(hashtable, card);
-            }
-
-            IEnumerator ActivateCoroutine(Hashtable _hashtable)
-            {
-                bool PermanentCondition(Permanent permanent)
-                {
-                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
-                }
-
-                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDPPlayerEffect(
-                    permanentCondition: PermanentCondition,
-                    changeValue: -5000,
-                    effectDuration: EffectDuration.UntilOwnerTurnEnd,
-                    activateClass: activateClass));
-
-                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeSecurityDigimonCardDPPlayerEffect(
-                        cardCondition: cardSource => cardSource.Owner == card.Owner.Enemy,
-                        changeValue: -5000,
-                        effectDuration: EffectDuration.UntilOwnerTurnEnd,
-                        activateClass: activateClass));
-
-            }
-        }
-
-        #endregion
-
-        return cardEffects;
-    }
-}

Assets/CardEffect/BT16/Black/Dorimon_BT16_005.cs → Assets/CardEffect/BT16/Black/BT16_005.cs

@@ -1,11 +1,9 @@
 using System.Collections;
 using System.Collections.Generic;
-using System;
-using UnityEngine;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Dorimon_BT16_005 : CEntity_Effect
+    public class BT16_005 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
@@ -31,7 +29,7 @@ namespace DCGO.CardEffects.BT16
                     {
                         if (permanent.IsDigimon)
                         {
-                            if (permanent.HasBlocker) 
+                            if (permanent.HasBlocker)
                             {
                                 if (permanent != card.PermanentOfThisCard())
                                 {
@@ -83,14 +81,13 @@ namespace DCGO.CardEffects.BT16
                     List<Hashtable> hashtables = CardEffectCommons.GetHashtablesFromHashtable(hashtable);
 
                     if (hashtables != null)
-                    {   
-                        if(hashtables.Count > 0)
+                    {
+                        if (hashtables.Count > 0)
                             yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(1, activateClass));
                     }
                 }
             }
 
-
             return cardEffects;
         }
     }

Assets/CardEffect/BT16/Black/Armadillomon_BT16_049.cs → Assets/CardEffect/BT16/Black/BT16_049.cs

@@ -4,7 +4,7 @@ using System.Collections.Generic;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Armadillomon_BT16_049 : CEntity_Effect
+    public class BT16_049 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {

Assets/CardEffect/BT16/Black/Commandramon_BT16_050.cs → Assets/CardEffect/BT16/Black/BT16_050.cs

@@ -1,16 +1,15 @@
-using System;
-using System.Collections;
 using System.Collections.Generic;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Commandramon_BT16_050 : CEntity_Effect
+    public class BT16_050 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Shared Effect
+
             string EffectDiscription()
             {
                 return "[All Turns] All of your other Digimon with the [D-Brigade] or [DigiPolice] trait get +1000 DP.";
@@ -41,9 +40,11 @@ namespace DCGO.CardEffects.BT16
 
                 return false;
             }
+
             #endregion
 
             #region All Turns
+
             if (timing == EffectTiming.None)
             {
                 cardEffects.Add(CardEffectFactory.ChangeDPStaticEffect(
@@ -54,9 +55,11 @@ namespace DCGO.CardEffects.BT16
                 condition: Condition,
                 effectName: EffectDiscription));
             }
+
             #endregion
 
             #region Inherited Effect
+
             if (timing == EffectTiming.None)
             {
                 cardEffects.Add(CardEffectFactory.ChangeDPStaticEffect(
@@ -67,6 +70,7 @@ namespace DCGO.CardEffects.BT16
                 condition: Condition,
                 effectName: EffectDiscription));
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Black/Dorumon_BT16_051.cs → Assets/CardEffect/BT16/Black/BT16_051.cs

@@ -5,13 +5,14 @@ using System.Linq;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Dorumon_BT16_051 : CEntity_Effect
+    public class BT16_051 : 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)
@@ -21,9 +22,11 @@ namespace DCGO.CardEffects.BT16
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 0, ignoreDigivolutionRequirement: false, card: card, condition: null));
             }
+
             #endregion
 
             #region Start of Main Phase
+
             if (timing == EffectTiming.OnStartMainPhase)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -60,7 +63,7 @@ namespace DCGO.CardEffects.BT16
                             return true;
                         }
                     }
-                    
+
                     return false;
                 }
 
@@ -73,7 +76,6 @@ namespace DCGO.CardEffects.BT16
                         {
                             return true;
                         }
-
                     }
 
                     return false;
@@ -163,9 +165,11 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             #region Inherited Effect
+
             if (timing == EffectTiming.None)
             {
                 cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect<Func<int>>(
@@ -174,6 +178,7 @@ namespace DCGO.CardEffects.BT16
                     card: card,
                     condition: null));
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Black/HagurumonXAntibody_BT16_052.cs → Assets/CardEffect/BT16/Black/BT16_052.cs

@@ -4,13 +4,14 @@ using System.Linq;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class HagurumonXAntibody_BT16_052 : CEntity_Effect
+    public class BT16_052 : 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)
@@ -20,9 +21,11 @@ namespace DCGO.CardEffects.BT16
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 0, ignoreDigivolutionRequirement: false, card: card, condition: null));
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -58,10 +61,13 @@ namespace DCGO.CardEffects.BT16
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayKoHagurumonToken(activateClass));
                 }
             }
+
             #endregion
 
             #region Inherited Effect
+
             cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(true, card, null));
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Black/KoHagurumon_BT16_052_token.cs → Assets/CardEffect/BT16/Black/BT16_052_token.cs

@@ -1,15 +1,15 @@
-using System.Collections;
 using System.Collections.Generic;
 
 namespace DCGO.CardEffects.Tokens
 {
-    public class KoHagurumon_BT16_052_token : CEntity_Effect
+    public class BT16_052_token : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Decoy
+
             if (timing == EffectTiming.WhenPermanentWouldBeDeleted)
             {
                 string DecoyDiscription()
@@ -38,6 +38,7 @@ namespace DCGO.CardEffects.Tokens
 
                 cardEffects.Add(CardEffectFactory.DecoySelfEffect(isInheritedEffect: false, card: card, condition: null, permanentCondition: CanSelectDecoyPermanentCondition, effectName: "Decoy ([Black])", effectDiscription: DecoyDiscription()));
             }
+
             #endregion
 
             if (timing == EffectTiming.None)

Assets/CardEffect/BT16/Black/Ankylomon_BT16_053.cs → Assets/CardEffect/BT16/Black/BT16_053.cs

@@ -4,13 +4,14 @@ using System.Collections.Generic;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Ankylomon_BT16_053 : CEntity_Effect
+    public class BT16_053 : 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)
@@ -20,16 +21,20 @@ namespace DCGO.CardEffects.BT16
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 2, ignoreDigivolutionRequirement: false, card: card, condition: null));
             }
+
             #endregion
 
             #region Barrier
-            if(timing == EffectTiming.WhenPermanentWouldBeDeleted)
+
+            if (timing == EffectTiming.WhenPermanentWouldBeDeleted)
             {
                 cardEffects.Add(CardEffectFactory.BarrierSelfEffect(false, card, null));
             }
+
             #endregion
 
             #region On Play
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -104,9 +109,11 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -181,9 +188,11 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             #region Inherited Effect
+
             if (timing == EffectTiming.None)
             {
                 cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect<Func<int>>(
@@ -192,6 +201,7 @@ namespace DCGO.CardEffects.BT16
                     card: card,
                     condition: null));
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Black/Sealsdramon_BT16_054.cs → Assets/CardEffect/BT16/Black/BT16_054.cs

@@ -4,7 +4,7 @@ using System.Linq;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Sealsdramon_BT16_054 : CEntity_Effect
+    public class BT16_054 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
@@ -12,7 +12,6 @@ namespace DCGO.CardEffects.BT16
 
             #region On Play/When Digivolving Shared
 
-            
             bool CanSelectCardCondition(CardSource cardSource)
             {
                 if (cardSource.CardTraits.Contains("D-Brigade"))
@@ -41,10 +40,10 @@ namespace DCGO.CardEffects.BT16
                 return false;
             }
 
-            
             #endregion
 
             #region On Play
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -106,7 +105,7 @@ namespace DCGO.CardEffects.BT16
                         if (CardEffectCommons.IsExistOnBattleArea(card))
                         {
                             yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainRush(
-                                targetPermanent: card.PermanentOfThisCard(), 
+                                targetPermanent: card.PermanentOfThisCard(),
                                 effectDuration: EffectDuration.UntilEachTurnEnd,
                                 activateClass: activateClass));
 
@@ -120,9 +119,11 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -198,12 +199,13 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             #region Inherited Effect
+
             if (timing == EffectTiming.None)
             {
-
                 string InheritedEffectDiscription()
                 {
                     return "[All Turns] All of your other Digimon with the [D-Brigade] or [DigiPolice] trait get +1000 DP.";
@@ -242,6 +244,7 @@ namespace DCGO.CardEffects.BT16
                 condition: Condition,
                 effectName: InheritedEffectDiscription));
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Black/Namakemon_BT16_055.cs → Assets/CardEffect/BT16/Black/BT16_055.cs

@@ -4,7 +4,7 @@ using System.Collections.Generic;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Namakemon_BT16_055 : CEntity_Effect
+    public class BT16_055 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
@@ -47,7 +47,7 @@ namespace DCGO.CardEffects.BT16
 
             IEnumerator AfterSelectPermanent(List<Permanent> permanents)
             {
-                if(permanents.Count >= 1)
+                if (permanents.Count >= 1)
                     selectedPermanent = permanents[0];
 
                 yield return null;
@@ -67,7 +67,6 @@ namespace DCGO.CardEffects.BT16
                 immuneFromDeDigivolveClass.SetUpImmuneFromDeDigivolveClass(PermanentCondition: PermanentDeDigivolveCondition);
                 selectedPermanent.UntilOpponentTurnEndEffects.Add((_timing) => immuneFromDeDigivolveClass);
             }
-            
 
             bool CanUseDeDigivolveCondition(Hashtable hashtable1)
             {
@@ -112,7 +111,6 @@ namespace DCGO.CardEffects.BT16
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    
                     SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
 
                     selectPermanentEffect.SetUp(
@@ -136,7 +134,7 @@ namespace DCGO.CardEffects.BT16
                     {
                         yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
-                        if(selectedPermanent != null)
+                        if (selectedPermanent != null)
                         {
                             ActivateDeDigivolveProtection();
 
@@ -149,11 +147,11 @@ namespace DCGO.CardEffects.BT16
                         }
                     }
 
-                    if(card.Owner.SecurityCards.Count <= 3)
+                    if (card.Owner.SecurityCards.Count <= 3)
                     {
                         yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
-                        if(selectedPermanent != null)
+                        if (selectedPermanent != null)
                         {
                             yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainReboot(
                                 targetPermanent: selectedPermanent,
@@ -190,7 +188,6 @@ namespace DCGO.CardEffects.BT16
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-
                     SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
 
                     selectPermanentEffect.SetUp(
@@ -248,7 +245,6 @@ namespace DCGO.CardEffects.BT16
             }
             #endregion
 
-
             #region Inherited Effect
             if (timing == EffectTiming.None)
             {

Assets/CardEffect/BT16/Black/Publimon_BT16_056.cs → Assets/CardEffect/BT16/Black/BT16_056.cs

@@ -1,17 +1,17 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using UnityEngine;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Publimon_BT16_056 : CEntity_Effect
+    public class BT16_056 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region On Play
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -87,9 +87,8 @@ namespace DCGO.CardEffects.BT16
                                     Permanent securityPermanent = selectedPermanent;
                                     CardSource securityCard = securityPermanent.TopCard;
 
-                                    if(securityPermanent.DigivolutionCards.Count >= 1)
+                                    if (securityPermanent.DigivolutionCards.Count >= 1)
                                     {
-
                                         yield return ContinuousController.instance.StartCoroutine(CardObjectController.RemoveFromAllArea(securityCard));
 
                                         permanent.ShowingPermanentCard.ShowPermanentData(true);
@@ -115,16 +114,18 @@ namespace DCGO.CardEffects.BT16
                                                 }
                                             }
                                         }
-                                    }                                    
+                                    }
                                 }
                             }
                         }
                     }
                 }
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -202,7 +203,6 @@ namespace DCGO.CardEffects.BT16
 
                                     if (securityPermanent.DigivolutionCards.Count >= 1)
                                     {
-
                                         yield return ContinuousController.instance.StartCoroutine(CardObjectController.RemoveFromAllArea(securityCard));
 
                                         permanent.ShowingPermanentCard.ShowPermanentData(true);
@@ -235,9 +235,11 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             #region All Turns
+
             if (timing == EffectTiming.OnAddSecurity)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -255,7 +257,7 @@ namespace DCGO.CardEffects.BT16
                 {
                     if (CardEffectCommons.CanTriggerWhenAddSecurity(hashtable, player => player == card.Owner.Enemy))
                     {
-                        if(card.Owner.Enemy.SecurityCards.Count >= 3)
+                        if (card.Owner.Enemy.SecurityCards.Count >= 3)
                             return true;
                     }
 
@@ -269,7 +271,7 @@ namespace DCGO.CardEffects.BT16
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if(card.Owner.Enemy.SecurityCards.Count < 3)
+                    if (card.Owner.Enemy.SecurityCards.Count < 3)
                         yield break;
 
                     yield return GManager.instance.photonWaitController.StartWait("Publimon_Select_ETB");
@@ -296,6 +298,7 @@ namespace DCGO.CardEffects.BT16
                         fromTop: toTop).DestroySecurity());
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Black/Mekanorimon_BT16_057.cs → Assets/CardEffect/BT16/Black/BT16_057.cs

@@ -1,17 +1,17 @@
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Mekanorimon_BT16_057 : CEntity_Effect
+    public class BT16_057 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Blocker/Armor Purge
-            if(timing == EffectTiming.None)
+
+            if (timing == EffectTiming.None)
             {
                 cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(isInheritedEffect: false, card: card, condition: null));
             }
@@ -20,10 +20,12 @@ namespace DCGO.CardEffects.BT16
             {
                 cardEffects.Add(CardEffectFactory.ArmorPurgeEffect(card: card));
             }
+
             #endregion
 
             #region On Play
-            if(timing == EffectTiming.OnEnterFieldAnyone)
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("<De-Digivolve 1>", CanUseCondition, card);
@@ -143,16 +145,18 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             #region Your Turn
+
             if (timing == EffectTiming.None)
             {
                 bool Condition()
                 {
                     if (CardEffectCommons.IsOwnerTurn(card))
                     {
-                        if(card.PermanentOfThisCard().DigivolutionCards.Count == 0)
+                        if (card.PermanentOfThisCard().DigivolutionCards.Count == 0)
                         {
                             return true;
                         }
@@ -169,6 +173,7 @@ namespace DCGO.CardEffects.BT16
                     effectName: "Can't Attack"
                     ));
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Black/Dorugamon_BT16_058.cs → Assets/CardEffect/BT16/Black/BT16_058.cs

@@ -1,18 +1,18 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using UnityEngine;
 using System.Linq;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Dorugamon_BT16_058 : CEntity_Effect
+    public class BT16_058 : 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)
             {
                 bool PermanentCondition(Permanent targetPermanent)
@@ -37,16 +37,20 @@ namespace DCGO.CardEffects.BT16
                     card: card,
                     condition: null));
             }
+
             #endregion
 
             #region Collision
+
             if (timing == EffectTiming.OnCounterTiming)
             {
                 cardEffects.Add(CardEffectFactory.CollisionSelfStaticEffect(false, card, null));
             }
+
             #endregion
 
             #region On Play
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -59,7 +63,6 @@ namespace DCGO.CardEffects.BT16
                     return "[On Play] By trashing 1 card in your hand, <Draw 1>. Then, if this Digimon has a Tamer with the [SoC] trait in its digivolution cards, 1 of your opponent's Digimon gains \"[Start of Your Main Phase] This Digimon attacks.\" until the end of their turn.";
                 }
 
-
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
                     return true;
@@ -136,6 +139,7 @@ namespace DCGO.CardEffects.BT16
                         yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
 
                         #region Has Tamer with [SoC] Trait - grant Start of Your Main Phase Effect
+
                         if (card.PermanentOfThisCard().DigivolutionCards.Count(HasTamerCardCondition) >= 1)
                         {
                             if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
@@ -250,13 +254,16 @@ namespace DCGO.CardEffects.BT16
                                 }
                             }
                         }
+
                         #endregion
                     }
                 }
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -345,6 +352,7 @@ namespace DCGO.CardEffects.BT16
                         yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
 
                         #region Has Tamer with [SoC] Trait - grant Start of Your Main Phase Effect
+
                         if (card.PermanentOfThisCard().DigivolutionCards.Count(HasTamerCardCondition) >= 1)
                         {
                             if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
@@ -459,13 +467,16 @@ namespace DCGO.CardEffects.BT16
                                 }
                             }
                         }
+
                         #endregion
                     }
                 }
             }
+
             #endregion
 
             #region Inherited Effect
+
             if (timing == EffectTiming.None)
             {
                 cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect<Func<int>>(
@@ -474,6 +485,7 @@ namespace DCGO.CardEffects.BT16
                     card: card,
                     condition: null));
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Black/Shootmon_BT16_059.cs → Assets/CardEffect/BT16/Black/BT16_059.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Shootmon_BT16_059 : CEntity_Effect
+    public class BT16_059 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
@@ -14,7 +14,7 @@ namespace DCGO.CardEffects.BT16
             {
                 bool PermanentCondition(Permanent targetPermanent)
                 {
-                    if(targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.Level == 4)
+                    if (targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.Level == 4)
                     {
                         if (targetPermanent.TopCard.HasText("Pulsemon"))
                         {
@@ -50,9 +50,9 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanSelectDeletePermanentCondition(Permanent permanent)
                 {
-                    if(CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
                     {
-                        if(permanent.TopCard.HasPlayCost && permanent.TopCard.GetCostItself <= 6)
+                        if (permanent.TopCard.HasPlayCost && permanent.TopCard.GetCostItself <= 6)
                         {
                             return true;
                         }
@@ -80,7 +80,7 @@ namespace DCGO.CardEffects.BT16
                 {
                     SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
 
-                    if(card.Owner.SecurityCards.Count >= 3)
+                    if (card.Owner.SecurityCards.Count >= 3)
                     {
                         selectPermanentEffect.SetUp(
                             selectPlayer: card.Owner,
@@ -106,7 +106,7 @@ namespace DCGO.CardEffects.BT16
                         }
                     }
 
-                    if(card.Owner.SecurityCards.Count <= 3)
+                    if (card.Owner.SecurityCards.Count <= 3)
                     {
                         if (CardEffectCommons.HasMatchConditionPermanent(CanSelectDeletePermanentCondition))
                         {

Assets/CardEffect/BT16/Black/Tankdramon_BT16_060.cs → Assets/CardEffect/BT16/Black/BT16_060.cs

@@ -1,17 +1,17 @@
 using System.Collections;
 using System.Collections.Generic;
-using UnityEngine;
 using System.Linq;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Tankdramon_BT16_060 : CEntity_Effect
+    public class BT16_060 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region On Play
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -120,9 +120,11 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -231,9 +233,11 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             #region All Turns - ESS
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -297,11 +301,10 @@ namespace DCGO.CardEffects.BT16
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if(CardEffectCommons.MatchConditionOpponentsPermanentCount(card, permanent => permanent.IsDigimon) > 0)
+                    if (CardEffectCommons.MatchConditionOpponentsPermanentCount(card, permanent => permanent.IsDigimon) > 0)
                     {
                         SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
 
-
                         selectPermanentEffect.SetUp(
                             selectPlayer: card.Owner,
                             canTargetCondition: OpponentPermanentCondition,
@@ -329,6 +332,7 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Black/DoruGreymon_BT16_061.cs → Assets/CardEffect/BT16/Black/BT16_061.cs

@@ -1,11 +1,10 @@
 using System.Collections;
 using System.Collections.Generic;
-using UnityEngine;
 using System.Linq;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class DoruGreymon_BT16_061 : CEntity_Effect
+    public class BT16_061 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
@@ -211,7 +210,7 @@ namespace DCGO.CardEffects.BT16
                                 if (CardEffectCommons.CanTriggerOnPermanentDeleted(hashtable, DeletedPermanentCondition))
                                     return true;
                             }
-                        }                        
+                        }
                     }
 
                     return false;
@@ -268,7 +267,6 @@ namespace DCGO.CardEffects.BT16
 
             #endregion
 
-
             return cardEffects;
         }
     }

Assets/CardEffect/BT16/Black/Zanmetsumon_BT16_062.cs → Assets/CardEffect/BT16/Black/BT16_062.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Zanmetsumon_BT16_062 : CEntity_Effect
+    public class BT16_062 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
@@ -51,7 +51,7 @@ namespace DCGO.CardEffects.BT16
                 {
                     if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
                     {
-                        if(permanent.HasDP && permanent.DP <= card.PermanentOfThisCard().DP)
+                        if (permanent.HasDP && permanent.DP <= card.PermanentOfThisCard().DP)
                         {
                             return true;
                         }
@@ -65,7 +65,7 @@ namespace DCGO.CardEffects.BT16
                     if (CardEffectCommons.IsPermanentExistsOnBattleArea(permanent))
                     {
                         if (permanent.IsDigimon &&
-                            permanent.TopCard.HasPlayCost && 
+                            permanent.TopCard.HasPlayCost &&
                             permanent.TopCard.GetCostItself <= 3)
                         {
                             return true;
@@ -174,7 +174,7 @@ namespace DCGO.CardEffects.BT16
                     if (CardEffectCommons.IsPermanentExistsOnBattleArea(permanent))
                     {
                         if (permanent.IsDigimon &&
-                            permanent.TopCard.HasPlayCost && 
+                            permanent.TopCard.HasPlayCost &&
                             permanent.TopCard.GetCostItself <= 3)
                         {
                             return true;
@@ -220,7 +220,6 @@ namespace DCGO.CardEffects.BT16
                             yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
                         }
 
-
                         if (CardEffectCommons.HasMatchConditionPermanent(CanSelectDeletePermanentCondition))
                         {
                             selectPermanentEffect.SetUp(
@@ -238,7 +237,6 @@ namespace DCGO.CardEffects.BT16
 
                             yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
                         }
-                        
                     }
 
                     yield return null;

Assets/CardEffect/BT16/Black/Shakkoumon_BT16_063.cs → Assets/CardEffect/BT16/Black/BT16_063.cs

@@ -1,10 +1,9 @@
 using System.Collections;
 using System.Collections.Generic;
-using UnityEngine;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Shakkoumon_BT16_063 : CEntity_Effect
+    public class BT16_063 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
@@ -15,6 +14,7 @@ namespace DCGO.CardEffects.BT16
             partitionConditions.Add(new PartitionCondition(4, CardColor.Yellow));
 
             #region DNA Digivolution - Black Lv.4 + Yellow Lv.4: Cost 0
+
             if (timing == EffectTiming.None)
             {
                 AddJogressConditionClass addJogressConditionClass = new AddJogressConditionClass();
@@ -79,9 +79,11 @@ namespace DCGO.CardEffects.BT16
                     return null;
                 }
             }
+
             #endregion
 
             #region When Digivolved
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 int SelectedCardCount = card.Owner.Enemy.SecurityCards.Count;
@@ -102,7 +104,7 @@ namespace DCGO.CardEffects.BT16
                     {
                         if (permanent.TopCard.HasLevel)
                         {
-                            if(permanent.Level <= SelectedCardCount)
+                            if (permanent.Level <= SelectedCardCount)
                             {
                                 return true;
                             }
@@ -114,18 +116,19 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable,card);
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);                }
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
                     Permanent selectedPermanent = card.PermanentOfThisCard();
 
-                    if(selectedPermanent != null)
+                    if (selectedPermanent != null)
                     {
                         CanNotAffectedClass canNotAffectedClass = new CanNotAffectedClass();
                         canNotAffectedClass.SetUpICardEffect("Isn't affected by opponent's Digimon's effect", CanUseUnaffectedCondition, card);
@@ -138,7 +141,7 @@ namespace DCGO.CardEffects.BT16
                         {
                             return CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent);
                         }
-                        
+
                         bool CardUnaffectedCondition(CardSource cardSource)
                         {
                             if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent))
@@ -186,10 +189,10 @@ namespace DCGO.CardEffects.BT16
                         string notSelectPlayerMessage = "The opponent is choosing which security to use.";
 
                         GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
-                        
+
                         yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                        if(GManager.instance.userSelectionManager.SelectedBoolValue)
+                        if (GManager.instance.userSelectionManager.SelectedBoolValue)
                             SelectedCardCount = card.Owner.SecurityCards.Count;
 
                         selectPermanentEffect.SetUp(
@@ -208,7 +211,6 @@ namespace DCGO.CardEffects.BT16
                         selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to place to security.", "The opponent is selecting 1 Digimon to place to security.");
 
                         yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
                     }
 
                     IEnumerator SelectPermanentCoroutine(Permanent permanent)
@@ -226,9 +228,11 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             #region Partition
+
             if (timing == EffectTiming.WhenRemoveField)
             {
                 cardEffects.Add(CardEffectFactory.PartitionSelfEffect(
@@ -238,9 +242,11 @@ namespace DCGO.CardEffects.BT16
                     cardSourceConditions: partitionConditions)
                 );
             }
+
             #endregion
 
             #region Partition - Inherited
+
             if (timing == EffectTiming.WhenRemoveField)
             {
                 cardEffects.Add(CardEffectFactory.PartitionSelfEffect(
@@ -250,6 +256,7 @@ namespace DCGO.CardEffects.BT16
                     cardSourceConditions: partitionConditions)
                 );
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Black/Dorugoramon_BT16_064.cs → Assets/CardEffect/BT16/Black/BT16_064.cs

@@ -1,17 +1,17 @@
 using System.Collections;
 using System.Collections.Generic;
-using UnityEngine;
 using System.Linq;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Dorugoramon_BT16_064 : CEntity_Effect
+    public class BT16_064 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Alternate Digivolution - [DoruGreymon] in name or Lv.5 w/[SoC] trait: Cost 3
+
             if (timing == EffectTiming.None)
             {
                 bool PermanentCondition(Permanent targetPermanent)
@@ -39,16 +39,20 @@ namespace DCGO.CardEffects.BT16
                     card: card,
                     condition: null));
             }
+
             #endregion
 
             #region Collision
+
             if (timing == EffectTiming.OnCounterTiming)
             {
                 cardEffects.Add(CardEffectFactory.CollisionSelfStaticEffect(false, card, null));
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -70,7 +74,7 @@ namespace DCGO.CardEffects.BT16
                 {
                     if (CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card))
                     {
-                        if(permanent.IsDigimon || permanent.IsTamer)
+                        if (permanent.IsDigimon || permanent.IsTamer)
                         {
                             if (!permanent.IsSuspended)
                             {
@@ -84,7 +88,7 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if(CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card))
+                    if (CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card))
                     {
                         if (card.PermanentOfThisCard().DigivolutionCards.Count(HasTamerWithTrait) >= 1)
                         {
@@ -125,10 +129,12 @@ namespace DCGO.CardEffects.BT16
                     yield return null;
                 }
             }
+
             #endregion
 
             #region All Turns - Unsuspend
-            if(timing == EffectTiming.OnDestroyedAnyone)
+
+            if (timing == EffectTiming.OnDestroyedAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Unsuspend this Digimon", CanUseCondition, card);
@@ -196,6 +202,7 @@ namespace DCGO.CardEffects.BT16
                     yield return ContinuousController.instance.StartCoroutine(new IUnsuspendPermanents(new List<Permanent>() { card.PermanentOfThisCard() }, activateClass).Unsuspend());
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Black/Darkdramon_BT16_065.cs → Assets/CardEffect/BT16/Black/BT16_065.cs

@@ -3,11 +3,10 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEngine;
-using System;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Darkdramon_BT16_065 : CEntity_Effect
+    public class BT16_065 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
@@ -35,6 +34,7 @@ namespace DCGO.CardEffects.BT16
             }
 
             #region Before Pay Cost - Condition Effect
+
             if (timing == EffectTiming.BeforePayCost)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -187,7 +187,6 @@ namespace DCGO.CardEffects.BT16
                         {
                             return true;
                         }
-
                         else
                         {
                             if (targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0)
@@ -217,9 +216,11 @@ namespace DCGO.CardEffects.BT16
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ShowReducedCost(_hashtable));
                 }
             }
+
             #endregion
 
             #region Reduce Play Cost - Not Shown
+
             if (timing == EffectTiming.None)
             {
                 ChangeCostClass changeCostClass = new ChangeCostClass();
@@ -228,7 +229,6 @@ namespace DCGO.CardEffects.BT16
                 changeCostClass.SetNotShowUI(true);
                 cardEffects.Add(changeCostClass);
 
-
                 bool CanUseCondition(Hashtable hashtable)
                 {
                     if (card.Owner.HandCards.Contains(card))
@@ -283,7 +283,6 @@ namespace DCGO.CardEffects.BT16
                     {
                         return true;
                     }
-
                     else
                     {
                         if (targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0)
@@ -318,9 +317,11 @@ namespace DCGO.CardEffects.BT16
                     return true;
                 }
             }
+
             #endregion
 
             #region On Play
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -337,7 +338,7 @@ namespace DCGO.CardEffects.BT16
                 {
                     if (cardSource.IsDigimon)
                     {
-                        if(cardSource.HasPlayCost)
+                        if (cardSource.HasPlayCost)
                         {
                             return true;
                         }
@@ -355,7 +356,7 @@ namespace DCGO.CardEffects.BT16
                 {
                     if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
                     {
-                        if(card.Owner.LibraryCards.Count >= 1)
+                        if (card.Owner.LibraryCards.Count >= 1)
                         {
                             return true;
                         }
@@ -409,7 +410,7 @@ namespace DCGO.CardEffects.BT16
                             cardEffect: activateClass);
 
                         yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                    }                
+                    }
 
                     bool CanSelectPermanentCondition(Permanent permanent)
                     {
@@ -417,7 +418,7 @@ namespace DCGO.CardEffects.BT16
                         {
                             if (permanent.TopCard.HasPlayCost)
                             {
-                                if(permanent.TopCard.GetCostItself <= costDeletion)
+                                if (permanent.TopCard.GetCostItself <= costDeletion)
                                 {
                                     return true;
                                 }
@@ -430,9 +431,11 @@ namespace DCGO.CardEffects.BT16
                     yield return null;
                 }
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -542,9 +545,11 @@ namespace DCGO.CardEffects.BT16
                     yield return null;
                 }
             }
+
             #endregion
 
             #region End of Turn
+
             if (timing == EffectTiming.OnEndTurn)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -661,7 +666,6 @@ namespace DCGO.CardEffects.BT16
 
                                     photonView.RPC("SetJogressEvoRootsFrameIDs", RpcTarget.All, _jogressEvoRootsFrameIDs);
                                 }
-
                                 else
                                 {
                                     GManager.instance.commandText.OpenCommandText("The opponent is choosing a card to DNA digivolve.");
@@ -695,6 +699,7 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Black/KosukeKisakata_BT16_087.cs → Assets/CardEffect/BT16/Black/BT16_087.cs

@@ -1,11 +1,10 @@
 using System.Collections;
 using System.Collections.Generic;
-using UnityEngine;
 using System.Linq;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class KosukeKisakata_BT16_087 : CEntity_Effect
+    public class BT16_087 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
@@ -37,7 +36,6 @@ namespace DCGO.CardEffects.BT16
                 {
                     if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
                     {
-
                         if (permanent.TopCard.HasXAntibodyTraits)
                         {
                             return true;
@@ -98,7 +96,6 @@ namespace DCGO.CardEffects.BT16
                 }
 
                 cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(isInheritedEffect: true, card: card, condition: Condition));
-              
             }
 
             if (timing == EffectTiming.OnDetermineDoSecurityCheck)
@@ -122,7 +119,6 @@ namespace DCGO.CardEffects.BT16
                 }
 
                 cardEffects.Add(CardEffectFactory.PierceSelfEffect(isInheritedEffect: true, card: card, condition: Condition));
-
             }
 
             if (timing == EffectTiming.OnEndTurn)

Assets/CardEffect/BT16/Black/CodyHidaAndTKTakaishi_BT16_088.cs → Assets/CardEffect/BT16/Black/BT16_088.cs

@@ -4,7 +4,7 @@ using System.Linq;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class CodyHidaAndTKTakaishi_BT16_088 : CEntity_Effect
+    public class BT16_088 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
@@ -16,6 +16,7 @@ namespace DCGO.CardEffects.BT16
             }
 
             #region Start of Main Phase
+
             if (timing == EffectTiming.OnStartMainPhase)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -171,9 +172,11 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             #region Your Turn - When you Digivolve
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -269,7 +272,6 @@ namespace DCGO.CardEffects.BT16
                         selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to De-Digivolve.", "The opponent is selecting 1 Digimon to De-Digivolve.");
 
                         yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
                     }
 
                     IEnumerator SelectPermanentCoroutine(Permanent permanent)
@@ -287,6 +289,7 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Black/MetropolitanPoliceDepartmentCommunitySafetyBureauCyberCrimeDivisionInvestigationUnitElevenDigimonCrimeResponeTeam_BT16_096.cs → Assets/CardEffect/BT16/Black/BT16_096.cs

@@ -1,18 +1,17 @@
-using Photon.Pun;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
 using UnityEngine;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class MetropolitanPoliceDepartmentCommunitySafetyBureauCyberCrimeDivisionInvestigationUnitElevenDigimonCrimeResponeTeam_BT16_096 : CEntity_Effect
+    public class BT16_096 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Option Skill
+
             if (timing == EffectTiming.OptionSkill)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -56,9 +55,11 @@ namespace DCGO.CardEffects.BT16
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlaceDelayOptionCards(card: card, cardEffect: activateClass));
                 }
             }
+
             #endregion
 
             #region On Declaration
+
             if (timing == EffectTiming.OnDeclaration)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -131,9 +132,11 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             #region Security Skill
+
             if (timing == EffectTiming.SecuritySkill)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -178,6 +181,7 @@ namespace DCGO.CardEffects.BT16
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlaceDelayOptionCards(card: card, cardEffect: activateClass));
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Black/AncientAngelOfSteel_BT16_097.cs → Assets/CardEffect/BT16/Black/BT16_097.cs

@@ -6,7 +6,7 @@ using UnityEngine;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class AncientAngelOfSteel_BT16_097 : CEntity_Effect
+    public class BT16_097 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
@@ -170,7 +170,6 @@ namespace DCGO.CardEffects.BT16
 
                                             photonView.RPC("SetJogressEvoRootsFrameIDs", RpcTarget.All, _jogressEvoRootsFrameIDs);
                                         }
-
                                         else
                                         {
                                             GManager.instance.commandText.OpenCommandText(
@@ -273,7 +272,6 @@ namespace DCGO.CardEffects.BT16
                     GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner,
                         selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
-
                     yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
                     bool playDigimon = GManager.instance.userSelectionManager.SelectedBoolValue;
@@ -300,7 +298,6 @@ namespace DCGO.CardEffects.BT16
                                     selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage1,
                                     notSelectPlayerMessage: notSelectPlayerMessage1);
                             }
-
                             else
                             {
                                 GManager.instance.userSelectionManager.SetBool(canSelectHand);
@@ -345,7 +342,6 @@ namespace DCGO.CardEffects.BT16
 
                                 yield return StartCoroutine(selectHandEffect.Activate());
                             }
-
                             else
                             {
                                 int maxCount1 = 1;

Assets/CardEffect/BT16/Black/DoruDjinn_BT16_098.cs → Assets/CardEffect/BT16/Black/BT16_098.cs

@@ -3,13 +3,14 @@ using System.Collections.Generic;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class DoruDjinn_BT16_098 : CEntity_Effect
+    public class BT16_098 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Main - Option Skill
+
             if (timing == EffectTiming.OptionSkill)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -26,7 +27,7 @@ namespace DCGO.CardEffects.BT16
                 {
                     if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
                     {
-                        if(permanent.TopCard.ContainsCardName("Dorugoramon"))
+                        if (permanent.TopCard.ContainsCardName("Dorugoramon"))
                         {
                             return true;
                         }
@@ -37,11 +38,11 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanSelectDeleteTarget(Permanent permanent)
                 {
-                    if(CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card))
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card))
                     {
-                        if(permanent.IsDigimon || permanent.IsTamer)
+                        if (permanent.IsDigimon || permanent.IsTamer)
                         {
-                            if(permanent.TopCard.HasPlayCost && permanent.TopCard.GetCostItself <= 4)
+                            if (permanent.TopCard.HasPlayCost && permanent.TopCard.GetCostItself <= 4)
                             {
                                 return true;
                             }
@@ -71,10 +72,9 @@ namespace DCGO.CardEffects.BT16
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if(CardEffectCommons.HasMatchConditionOwnersPermanent(card, HasDorugoramonInPlay))
+                    if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, HasDorugoramonInPlay))
                     {
-
-                        if(CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectDeleteTarget))
+                        if (CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectDeleteTarget))
                         {
                             SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
 
@@ -99,6 +99,7 @@ namespace DCGO.CardEffects.BT16
                     yield return ContinuousController.instance.StartCoroutine(new DestroyPermanentsClass(destroyTargetPermanents, CardEffectCommons.CardEffectHashtable(activateClass)).Destroy());
                 }
             }
+
             #endregion
 
             if (timing == EffectTiming.SecuritySkill)

Assets/CardEffect/BT16/Blue/DemiVeemon_BT16_002.cs → Assets/CardEffect/BT16/Blue/BT16_002.cs

@@ -1,21 +1,20 @@
-using System.Collections;
 using System.Collections.Generic;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class DemiVeemon_BT16_002 : CEntity_Effect
+    public class BT16_002 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
-            if(timing == EffectTiming.None)
+            if (timing == EffectTiming.None)
             {
                 bool PermanentCondition()
                 {
                     if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
-                        if(card.PermanentOfThisCard().TopCard.CardColors.Count >= 2)
+                        if (card.PermanentOfThisCard().TopCard.CardColors.Count >= 2)
                         {
                             return true;
                         }
@@ -25,7 +24,7 @@ namespace DCGO.CardEffects.BT16
 
                 cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect(1000, true, card, PermanentCondition));
             }
-            
+
             return cardEffects;
         }
     }

Assets/CardEffect/BT16/Blue/Veemon_BT16_017.cs → Assets/CardEffect/BT16/Blue/BT16_017.cs

@@ -3,14 +3,15 @@ using System.Collections.Generic;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Veemon_BT16_017 : CEntity_Effect
+    public class BT16_017 : 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)
+
+            if (timing == EffectTiming.None)
             {
                 bool PermanentCondition(Permanent targetPermanent)
                 {
@@ -24,10 +25,12 @@ namespace DCGO.CardEffects.BT16
                     card: card,
                     condition: null));
             }
+
             #endregion
 
             #region Your turn - When enter field
-            if(timing == EffectTiming.OnEnterFieldAnyone)
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Memory +1", CanUseCondition, card);
@@ -69,9 +72,11 @@ namespace DCGO.CardEffects.BT16
                         card.Owner.AddMemory(1, activateClass));
                 }
             }
+
             #endregion
 
             #region Inherited Effect
+
             if (timing == EffectTiming.None)
             {
                 bool InheritedEffectCondition()
@@ -85,8 +90,9 @@ namespace DCGO.CardEffects.BT16
                     card: card,
                     condition: InheritedEffectCondition));
             }
+
             #endregion
-            
+
             return cardEffects;
         }
     }

Assets/CardEffect/BT16/Blue/ExVeemon_BT16_018.cs → Assets/CardEffect/BT16/Blue/BT16_018.cs

@@ -3,13 +3,14 @@ using System.Collections.Generic;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class ExVeemon_BT16_018 : CEntity_Effect
+    public class BT16_018 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             var cardEffects = new List<ICardEffect>();
 
             #region Alternate Digivolution Requirement
+
             if (timing == EffectTiming.None)
             {
                 bool PermanentCondition(Permanent targetPermanent)
@@ -25,10 +26,12 @@ namespace DCGO.CardEffects.BT16
                     condition: null)
                 );
             }
+
             #endregion
 
             #region Inherited Effect
-            if(timing == EffectTiming.None)
+
+            if (timing == EffectTiming.None)
             {
                 bool InheritedEffectCondition()
                 {
@@ -41,10 +44,12 @@ namespace DCGO.CardEffects.BT16
                     card: card,
                     condition: InheritedEffectCondition));
             }
+
             #endregion
 
             #region Raid
-            if(timing == EffectTiming.OnAllyAttack)
+
+            if (timing == EffectTiming.OnAllyAttack)
             {
                 cardEffects.Add(CardEffectFactory.RaidSelfEffect(
                         isInheritedEffect: false,
@@ -52,10 +57,12 @@ namespace DCGO.CardEffects.BT16
                         condition: null)
                     );
             }
+
             #endregion
 
             #region On Play
-            if(timing == EffectTiming.OnEnterFieldAnyone)
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activatePlayClass = new ActivateClass();
                 activatePlayClass.SetUpICardEffect("Select 1 of your Digimon to gain battle protection", CanUsePlayCondition, card);
@@ -126,9 +133,11 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateDigivolveClass = new ActivateClass();
@@ -148,7 +157,7 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanUseDigivolveCondition(Hashtable hashtable)
                 {
-                    if(CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
                         return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
 
                     return false;
@@ -200,6 +209,7 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Blue/Angemon_BT16_019.cs → Assets/CardEffect/BT16/Blue/BT16_019.cs

@@ -1,246 +1,253 @@
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System;
-
-namespace DCGO.CardEffects.BT16
-{
-    public class Angemon_BT16_019 : CEntity_Effect
-    {
-        
-        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
-        {
-            var cardEffects = new List<ICardEffect>();
-
-            #region Alternate Digivolution Requirement, Blocker
-            if(timing == EffectTiming.None)
-            {
-                bool PermanentCondition(Permanent targetPermanent)
-                {
-                    return targetPermanent.TopCard.CardNames.Contains("Patamon");
-                }
-
-                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
-                    permanentCondition: PermanentCondition,
-                    digivolutionCost: 2,
-                    ignoreDigivolutionRequirement: false,
-                    card: card,
-                    condition: null)
-                );
-                
-                cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(isInheritedEffect: false, card: card, condition: null));
-            }
-            #endregion
-
-            #region On Play
-            if (timing == EffectTiming.OnEnterFieldAnyone)
-            {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Unsuspend 1 level 4 or lower Digimon", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-                cardEffects.Add(activateClass);
-
-                string EffectDiscription()
-                {
-                    return "[On Play] Unsuspend 1 of your level 4 or lower Digimon.";
-                }
-
-                bool CanSelectPermanentCondition(Permanent permanent)
-                {
-                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
-                    {
-                        if (permanent.Level <= 4)
-                        {
-                            if (permanent.TopCard.HasLevel)
-                            {
-                                return true;
-                            }
-                        }
-                    }
-
-                    return false;
-                }
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
-                }
-
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-
-                IEnumerator ActivateCoroutine(Hashtable _hashtable)
-                {
-                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                    selectPermanentEffect.SetUp(
-                        selectPlayer: card.Owner,
-                        canTargetCondition: CanSelectPermanentCondition,
-                        canTargetCondition_ByPreSelecetedList: null,
-                        canEndSelectCondition: null,
-                        maxCount: maxCount,
-                        canNoSelect: false,
-                        canEndNotMax: false,
-                        selectPermanentCoroutine: null,
-                        afterSelectPermanentCoroutine: null,
-                        mode: SelectPermanentEffect.Mode.UnTap,
-                        cardEffect: activateClass);
-                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                }
-            }
-            #endregion
-
-            #region When Digivolving
-            if (timing == EffectTiming.OnEnterFieldAnyone)
-            {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Unsuspend 1 level 4 or lower Digimon", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-                cardEffects.Add(activateClass);
-
-                string EffectDiscription()
-                {
-                    return "[When Digivolving] Unsuspend 1 of your level 4 or lower Digimon.";
-                }
-
-                bool CanSelectPermanentCondition(Permanent permanent)
-                {
-                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
-                    {
-                        if (permanent.Level <= 4)
-                        {
-                            if (permanent.TopCard.HasLevel)
-                            {
-                                return true;
-                            }
-                        }
-                    }
-
-                    return false;
-                }
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
-                }
-
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-
-                IEnumerator ActivateCoroutine(Hashtable _hashtable)
-                {
-                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                    selectPermanentEffect.SetUp(
-                        selectPlayer: card.Owner,
-                        canTargetCondition: CanSelectPermanentCondition,
-                        canTargetCondition_ByPreSelecetedList: null,
-                        canEndSelectCondition: null,
-                        maxCount: maxCount,
-                        canNoSelect: false,
-                        canEndNotMax: false,
-                        selectPermanentCoroutine: null,
-                        afterSelectPermanentCoroutine: null,
-                        mode: SelectPermanentEffect.Mode.UnTap,
-                        cardEffect: activateClass);
-                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                }
-            }
-            #endregion
-
-            #region Inherited Effect
-            if (timing == EffectTiming.OnAllyAttack)
-            {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Trash 1 digivolution card", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false,
-                    EffectDiscription());
-                activateClass.SetIsInheritedEffect(true);
-                cardEffects.Add(activateClass);
-
-                string EffectDiscription()
-                {
-                    return "[When Attacking] Trash the top digivolution card of 1 of your opponent's Digimon.";
-                }
-
-                bool CanSelectPermanentCondition(Permanent permanent)
-                {
-                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card)
-                           && permanent.DigivolutionCards.Count(cardSource =>
-                               !cardSource.CanNotTrashFromDigivolutionCards(activateClass)) >= 1;
-                }
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.CanTriggerOnAttack(hashtable, card);
-                }
-
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleArea(card) &&
-                           CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition);
-                }
-
-                IEnumerator ActivateCoroutine(Hashtable hashtable)
-                {
-                    var maxCount = Math.Min(1,
-                        CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-                    var selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                    selectPermanentEffect.SetUp(
-                        selectPlayer: card.Owner,
-                        canTargetCondition: CanSelectPermanentCondition,
-                        canTargetCondition_ByPreSelecetedList: null,
-                        canEndSelectCondition: null,
-                        maxCount: maxCount,
-                        canNoSelect: false,
-                        canEndNotMax: false,
-                        selectPermanentCoroutine: SelectPermanentCoroutine,
-                        afterSelectPermanentCoroutine: null,
-                        mode: SelectPermanentEffect.Mode.Custom,
-                        cardEffect: activateClass);
-
-                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will trash digivolution cards.",
-                        "The opponent is selecting 1 Digimon that will trash digivolution cards.");
-
-                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                    yield break;
-
-                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                    {
-                        yield return ContinuousController.instance.StartCoroutine(
-                            CardEffectCommons.TrashDigivolutionCardsFromTopOrBottom(targetPermanent: permanent,
-                                trashCount: 1, isFromTop: true, activateClass: activateClass));
-                    }
-                }
-            }
-            #endregion
-
-            return cardEffects;
-        }
-    }
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DCGO.CardEffects.BT16
+{
+    public class BT16_019 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            var cardEffects = new List<ICardEffect>();
+
+            #region Alternate Digivolution Requirement, Blocker
+
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.CardNames.Contains("Patamon");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 2,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null)
+                );
+
+                cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(isInheritedEffect: false, card: card, condition: null));
+            }
+
+            #endregion
+
+            #region On Play
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Unsuspend 1 level 4 or lower Digimon", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[On Play] Unsuspend 1 of your level 4 or lower Digimon.";
+                }
+
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                    {
+                        if (permanent.Level <= 4)
+                        {
+                            if (permanent.TopCard.HasLevel)
+                            {
+                                return true;
+                            }
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectPermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: maxCount,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: null,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.UnTap,
+                        cardEffect: activateClass);
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                }
+            }
+
+            #endregion
+
+            #region When Digivolving
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Unsuspend 1 level 4 or lower Digimon", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] Unsuspend 1 of your level 4 or lower Digimon.";
+                }
+
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                    {
+                        if (permanent.Level <= 4)
+                        {
+                            if (permanent.TopCard.HasLevel)
+                            {
+                                return true;
+                            }
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectPermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: maxCount,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: null,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.UnTap,
+                        cardEffect: activateClass);
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                }
+            }
+
+            #endregion
+
+            #region Inherited Effect
+
+            if (timing == EffectTiming.OnAllyAttack)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Trash 1 digivolution card", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false,
+                    EffectDiscription());
+                activateClass.SetIsInheritedEffect(true);
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Attacking] Trash the top digivolution card of 1 of your opponent's Digimon.";
+                }
+
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card)
+                           && permanent.DigivolutionCards.Count(cardSource =>
+                               !cardSource.CanNotTrashFromDigivolutionCards(activateClass)) >= 1;
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnAttack(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(card) &&
+                           CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    var maxCount = Math.Min(1,
+                        CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+                    var selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectPermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: maxCount,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: SelectPermanentCoroutine,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Custom,
+                        cardEffect: activateClass);
+
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will trash digivolution cards.",
+                        "The opponent is selecting 1 Digimon that will trash digivolution cards.");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                    yield break;
+
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(
+                            CardEffectCommons.TrashDigivolutionCardsFromTopOrBottom(targetPermanent: permanent,
+                                trashCount: 1, isFromTop: true, activateClass: activateClass));
+                    }
+                }
+            }
+
+            #endregion
+
+            return cardEffects;
+        }
+    }
 }

Assets/CardEffect/BT16/Blue/GaoGamon_BT16_020.cs → Assets/CardEffect/BT16/Blue/BT16_020.cs

@@ -1,83 +1,84 @@
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System;
-
-namespace DCGO.CardEffects.BT16
-{
-    public class Gaogamon_BT16_020 : CEntity_Effect
-    {
-        
-        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
-        {
-            List<ICardEffect> cardEffects = new List<ICardEffect>();
-
-            #region Alternate Digivolution Requirement, Inherited Effect
-            if(timing == EffectTiming.None)
-            {
-                bool PermanentCondition(Permanent targetPermanent)
-                {
-                    if(targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.Level == 3)
-                        return targetPermanent.TopCard.HasLightFangNightClawTraits;
-
-                    return false;
-                }
-
-                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
-                    permanentCondition: PermanentCondition,
-                    digivolutionCost: 2,
-                    ignoreDigivolutionRequirement: false,
-                    card: card,
-                    condition: null)
-                );
-                
-                cardEffects.Add(CardEffectFactory.JammingSelfStaticEffect(isInheritedEffect: true, card: card, condition: null));
-            }
-            #endregion
-
-            #region When Digivolving
-            if (timing == EffectTiming.OnEnterFieldAnyone)
-            {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Draw 1 card, then Memory +1", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-                activateClass.SetHashString("GaoGamon_BT16_020_When_Digivolving");
-                cardEffects.Add(activateClass);
-
-                string EffectDiscription()
-                {
-                    return "[When Digivolving] Both players draw 1 card from their decks. Then, if your opponent has 8 or more cards in their hand or this Digimon has 3 or more digivolution cards, gain 1 memory.";
-                }
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
-                }
-
-                bool CanActivateCondition(Hashtable hashtable)
-                {                   
-                    return CardEffectCommons.IsExistOnBattleArea(card);
-                }
-                
-                IEnumerator ActivateCoroutine(Hashtable _hashtable)
-                {
-                    foreach (Player player in GManager.instance.turnStateMachine.gameContext.Players_ForTurnPlayer)
-                    {
-                        if (player.LibraryCards.Count >= 1)
-                        {
-                            yield return ContinuousController.instance.StartCoroutine(new DrawClass(player, 1, activateClass).Draw());
-                        }
-                    }
-                    
-                    if (card.Owner.Enemy.HandCards.Count >= 8 || card.PermanentOfThisCard().DigivolutionCards.Count >= 3)
-                    {
-                        yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(1, activateClass));
-                    }
-                }
-            }
-            #endregion
-
-            return cardEffects;
-        }
-    }
+using System.Collections;
+using System.Collections.Generic;
+
+namespace DCGO.CardEffects.BT16
+{
+    public class BT16_020 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Alternate Digivolution Requirement, Inherited Effect
+
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    if (targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.Level == 3)
+                        return targetPermanent.TopCard.HasLightFangNightClawTraits;
+
+                    return false;
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 2,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null)
+                );
+
+                cardEffects.Add(CardEffectFactory.JammingSelfStaticEffect(isInheritedEffect: true, card: card, condition: null));
+            }
+
+            #endregion
+
+            #region When Digivolving
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Draw 1 card, then Memory +1", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetHashString("GaoGamon_BT16_020_When_Digivolving");
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] Both players draw 1 card from their decks. Then, if your opponent has 8 or more cards in their hand or this Digimon has 3 or more digivolution cards, gain 1 memory.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(card);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    foreach (Player player in GManager.instance.turnStateMachine.gameContext.Players_ForTurnPlayer)
+                    {
+                        if (player.LibraryCards.Count >= 1)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(new DrawClass(player, 1, activateClass).Draw());
+                        }
+                    }
+
+                    if (card.Owner.Enemy.HandCards.Count >= 8 || card.PermanentOfThisCard().DigivolutionCards.Count >= 3)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(1, activateClass));
+                    }
+                }
+            }
+
+            #endregion
+
+            return cardEffects;
+        }
+    }
 }

Assets/CardEffect/BT16/Blue/GaoGamon_BT16_020.cs.meta → Assets/CardEffect/BT16/Blue/BT16_020.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 1f84bea6b2eb461eb8cc9a3b885ec9d8
+fileFormatVersion: 2
+guid: 1f84bea6b2eb461eb8cc9a3b885ec9d8
 timeCreated: 1717031914

Assets/CardEffect/BT16/Blue/Togemoqumon_BT16_021.cs → Assets/CardEffect/BT16/Blue/BT16_021.cs

@@ -1,18 +1,16 @@
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
-using System;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Togemoqumon_BT16_021 : CEntity_Effect
+    public class BT16_021 : CEntity_Effect
     {
-        
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Alternate Digivolution Requirement, Blocker
+
             if (timing == EffectTiming.None)
             {
                 bool PermanentCondition(Permanent targetPermanent)
@@ -27,37 +25,40 @@ namespace DCGO.CardEffects.BT16
                     card: card,
                     condition: null)
                 );
-                
+
                 cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(isInheritedEffect: false, card: card, condition: null));
             }
+
             #endregion
-            
+
             #region Armor Purge
+
             if (timing == EffectTiming.WhenPermanentWouldBeDeleted)
             {
                 cardEffects.Add(CardEffectFactory.ArmorPurgeEffect(card: card));
             }
+
             #endregion
-            
+
             #region All Turns
-            
+
             if (timing == EffectTiming.OnTappedAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Trash 1 digivolution card & stun 1 Digimon", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
-                
+
                 string EffectDiscription()
                 {
                     return "[All Turns] [Once Per Turn] When an opponent's Digimon becomes suspended, trash the top digivolution card of 1 of their Digimon. Then, 1 of their Digimon with no digivolution cards can't attack or block until the end of their turn.";
                 }
-                
+
                 bool CanSelectPermanentSourceStripCondition(Permanent permanent)
                 {
                     return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
                 }
-                
+
                 bool CanSelectPermanentStunCondition(Permanent permanent)
                 {
                     if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
@@ -67,15 +68,15 @@ namespace DCGO.CardEffects.BT16
                             return true;
                         }
                     }
-                    
+
                     return false;
                 }
-                
+
                 bool PermanentCondition(Permanent permanent)
                 {
                     return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
                 }
-                
+
                 bool CanUseCondition(Hashtable hashtable)
                 {
                     if (CardEffectCommons.IsExistOnBattleArea(card))
@@ -85,10 +86,10 @@ namespace DCGO.CardEffects.BT16
                             return true;
                         }
                     }
-                    
+
                     return false;
                 }
-                
+
                 bool CanActivateCondition(Hashtable hashtable)
                 {
                     return CardEffectCommons.IsExistOnBattleArea(card);
@@ -96,9 +97,8 @@ namespace DCGO.CardEffects.BT16
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                
                     SelectPermanentEffect selectPermanentSourceStripEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-                
+
                     selectPermanentSourceStripEffect.SetUp(
                         selectPlayer: card.Owner,
                         canTargetCondition: CanSelectPermanentSourceStripCondition,
@@ -111,23 +111,23 @@ namespace DCGO.CardEffects.BT16
                         afterSelectPermanentCoroutine: null,
                         mode: SelectPermanentEffect.Mode.Custom,
                         cardEffect: activateClass);
-                
+
                     selectPermanentSourceStripEffect.SetUpCustomMessage("Select 1 Digimon that will trash digivolution cards.",
                         "The opponent is selecting 1 Digimon that will trash digivolution cards.");
-                
+
                     yield return ContinuousController.instance.StartCoroutine(selectPermanentSourceStripEffect.Activate());
-                
+
                     IEnumerator SelectPermanentSourceStripCoroutine(Permanent permanent)
                     {
                         yield return ContinuousController.instance.StartCoroutine(
                             CardEffectCommons.TrashDigivolutionCardsFromTopOrBottom(targetPermanent: permanent,
                                 trashCount: 1, isFromTop: true, activateClass: activateClass));
                     }
-                
+
                     if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentStunCondition))
                     {
                         SelectPermanentEffect selectPermanentStunEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-                    
+
                         selectPermanentStunEffect.SetUp(
                             selectPlayer: card.Owner,
                             canTargetCondition: CanSelectPermanentStunCondition,
@@ -140,7 +140,7 @@ namespace DCGO.CardEffects.BT16
                             afterSelectPermanentCoroutine: null,
                             mode: SelectPermanentEffect.Mode.Custom,
                             cardEffect: activateClass);
-                    
+
                         selectPermanentStunEffect.SetUpCustomMessage("Select 1 Digimon that will get effects.", "The opponent is selecting 1 Digimon that will get effects.");
 
                         yield return ContinuousController.instance.StartCoroutine(selectPermanentStunEffect.Activate());
@@ -164,7 +164,7 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
-            
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Blue/Mantaraymon_BT16_022.cs → Assets/CardEffect/BT16/Blue/BT16_022.cs

@@ -1,143 +1,141 @@
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System;
-
-namespace DCGO.CardEffects.BT16
-{
-    public class Mantaraymon_BT16_022 : CEntity_Effect
-    {
-        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
-        {
-            var cardEffects = new List<ICardEffect>();
-
-            #region Alternate Digivolution Requirement
-
-            if (timing == EffectTiming.None)
-            {
-                bool PermanentCondition(Permanent targetPermanent)
-                {
-                    return targetPermanent.TopCard.CardNames.Contains("Patamon");
-                }
-
-                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
-                    permanentCondition: PermanentCondition,
-                    digivolutionCost: 2,
-                    ignoreDigivolutionRequirement: false,
-                    card: card,
-                    condition: null)
-                );
-            }
-
-            #endregion
-
-            #region Armor Purge
-
-            if (timing == EffectTiming.WhenPermanentWouldBeDeleted)
-            {
-                cardEffects.Add(CardEffectFactory.ArmorPurgeEffect(card: card));
-            }
-
-            #endregion
-
-            #region When Attacking
-
-            if (timing == EffectTiming.OnAllyAttack)
-            {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Trash digivolution cards & Security Attack -1", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-                cardEffects.Add(activateClass);
-
-                string EffectDiscription()
-                {
-                    return
-                        "[When Attacking] Trash any 1 digivolution card of 1 of your opponent's Digimon. Then, 1 of their Digimon with no " +
-                        "digivolution cards gains <Security Attack -1> until the end of their turn.";
-                }
-
-                bool CanSelectPermanentTrashCondition(Permanent permanent)
-                {
-                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
-                }
-
-                bool CanSelectPermanentDebuffCondition(Permanent permanent)
-                {
-                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) &&
-                           permanent.DigivolutionCards.Count == 0;
-                }
-
-                bool CanSelectCardCondition(CardSource cardSource)
-                {
-                    return !cardSource.CanNotTrashFromDigivolutionCards(activateClass);
-                }
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.CanTriggerOnAttack(hashtable, card);
-                }
-
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentTrashCondition))
-                        {
-                            return true;
-                        }
-
-                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentDebuffCondition))
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-
-                IEnumerator ActivateCoroutine(Hashtable _hashtable)
-                {
-                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.SelectTrashDigivolutionCards(
-                        permanentCondition: CanSelectPermanentTrashCondition,
-                        cardCondition: CanSelectCardCondition,
-                        maxCount: 1,
-                        canNoTrash: false,
-                        isFromOnly1Permanent: true,
-                        activateClass: activateClass
-                    ));
-
-                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentDebuffCondition))
-                    {
-                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                        selectPermanentEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: CanSelectPermanentDebuffCondition,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: 1,
-                            canNoSelect: false,
-                            canEndNotMax: false,
-                            selectPermanentCoroutine: SelectPermanentCoroutine,
-                            afterSelectPermanentCoroutine: null,
-                            mode: SelectPermanentEffect.Mode.Custom,
-                            cardEffect: activateClass);
-
-                        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));
-                        }
-                    }
-                }
-            }
-
-            #endregion
-
-            return cardEffects;
-        }
-    }
+using System.Collections;
+using System.Collections.Generic;
+
+namespace DCGO.CardEffects.BT16
+{
+    public class BT16_022 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            var cardEffects = new List<ICardEffect>();
+
+            #region Alternate Digivolution Requirement
+
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.CardNames.Contains("Patamon");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 2,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null)
+                );
+            }
+
+            #endregion
+
+            #region Armor Purge
+
+            if (timing == EffectTiming.WhenPermanentWouldBeDeleted)
+            {
+                cardEffects.Add(CardEffectFactory.ArmorPurgeEffect(card: card));
+            }
+
+            #endregion
+
+            #region When Attacking
+
+            if (timing == EffectTiming.OnAllyAttack)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Trash digivolution cards & Security Attack -1", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return
+                        "[When Attacking] Trash any 1 digivolution card of 1 of your opponent's Digimon. Then, 1 of their Digimon with no " +
+                        "digivolution cards gains <Security Attack -1> until the end of their turn.";
+                }
+
+                bool CanSelectPermanentTrashCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                }
+
+                bool CanSelectPermanentDebuffCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) &&
+                           permanent.DigivolutionCards.Count == 0;
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    return !cardSource.CanNotTrashFromDigivolutionCards(activateClass);
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnAttack(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentTrashCondition))
+                        {
+                            return true;
+                        }
+
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentDebuffCondition))
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.SelectTrashDigivolutionCards(
+                        permanentCondition: CanSelectPermanentTrashCondition,
+                        cardCondition: CanSelectCardCondition,
+                        maxCount: 1,
+                        canNoTrash: false,
+                        isFromOnly1Permanent: true,
+                        activateClass: activateClass
+                    ));
+
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentDebuffCondition))
+                    {
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermanentDebuffCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: 1,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        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));
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            return cardEffects;
+        }
+    }
 }

Assets/CardEffect/BT16/Blue/Mantaraymon_BT16_022.cs.meta → Assets/CardEffect/BT16/Blue/BT16_022.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 4f40534ba1df4f86a291be7d367a6099
+fileFormatVersion: 2
+guid: 4f40534ba1df4f86a291be7d367a6099
 timeCreated: 1717033192

Assets/CardEffect/BT16/Blue/Divemon_BT16_023.cs → Assets/CardEffect/BT16/Blue/BT16_023.cs

@@ -1,318 +1,323 @@
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System;
-
-namespace DCGO.CardEffects.BT16
-{
-    public class Divemon_BT16_023 : CEntity_Effect
-    {
-        
-        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
-        {
-            var cardEffects = new List<ICardEffect>();
-
-            #region Alternate Digivolution Requirement
-            if(timing == EffectTiming.None)
-            {
-                bool PermanentCondition(Permanent targetPermanent)
-                {
-                    return targetPermanent.TopCard.HasPulsemonText && targetPermanent.TopCard.IsLevel4;
-                }
-
-                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
-                    permanentCondition: PermanentCondition,
-                    digivolutionCost: 3,
-                    ignoreDigivolutionRequirement: false,
-                    card: card,
-                    condition: null)
-                );
-            }
-            #endregion
-
-            #region On Play
-            if (timing == EffectTiming.OnEnterFieldAnyone)
-            {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Unsuspend 1 Digimon and/or bottom deck an opponent's Level 4 or lower Digimon", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-                cardEffects.Add(activateClass);
-
-                string EffectDiscription()
-                {
-                    return "[On Play] If you have 3 or more security cards, unsuspend 1 of your Digimon. If " +
-                           "you have 3 or fewer, return 1 of your opponent's level 4 or lower Digimon to the bottom of the deck.";
-                }
-
-                bool CanSelectPermanentUnsuspendCondition(Permanent permanent)
-                {
-                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
-                    {
-                        if (permanent.TopCard.HasLevel)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-                
-                bool CanSelectPermanentBounceCondition(Permanent permanent)
-                {
-                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
-                    {
-                        if (permanent.Level <= 4)
-                        {
-                            return true;
-                        }
-                    }
-                    
-                    return false;
-                }
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
-                }
-
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        return true;
-                    }
-
-                    return false;
-                }
-
-                IEnumerator ActivateCoroutine(Hashtable _hashtable)
-                {
-                    if (isExistOnField(card))
-                    {
-                        if (card.Owner.GetBattleAreaDigimons().Contains(card.PermanentOfThisCard()))
-                        {
-                            if (card.Owner.SecurityCards.Count >= 3)
-                            {
-                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-                                
-                                selectPermanentEffect.SetUp(
-                                    selectPlayer: card.Owner,
-                                    canTargetCondition: CanSelectPermanentUnsuspendCondition,
-                                    canTargetCondition_ByPreSelecetedList: null,
-                                    canEndSelectCondition: null,
-                                    maxCount: 1,
-                                    canNoSelect: false,
-                                    canEndNotMax: false,
-                                    selectPermanentCoroutine: null,
-                                    afterSelectPermanentCoroutine: null,
-                                    mode: SelectPermanentEffect.Mode.UnTap,
-                                    cardEffect: activateClass);
-                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                            }
-                            
-                            if (card.Owner.SecurityCards.Count <= 3)
-                            {
-                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-                                
-                                selectPermanentEffect.SetUp(
-                                    selectPlayer: card.Owner,
-                                    canTargetCondition: CanSelectPermanentBounceCondition,
-                                    canTargetCondition_ByPreSelecetedList: null,
-                                    canEndSelectCondition: null,
-                                    maxCount: 1,
-                                    canNoSelect: false,
-                                    canEndNotMax: false,
-                                    selectPermanentCoroutine: null,
-                                    afterSelectPermanentCoroutine: null,
-                                    mode: SelectPermanentEffect.Mode.PutLibraryBottom,
-                                    cardEffect: activateClass);
-                                
-                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                            }
-                        }
-                    }
-                }
-            }
-            #endregion
-
-            #region When Digivolving
-            if (timing == EffectTiming.OnEnterFieldAnyone)
-            {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Unsuspend 1 Digimon and/or bottom deck an opponent's Level 4 or lower Digimon", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-                cardEffects.Add(activateClass);
-
-                string EffectDiscription()
-                {
-                    return "[When Digivolving] If you have 3 or more security cards, unsuspend 1 of your Digimon. If " +
-                           "you have 3 or fewer, return 1 of your opponent's level 4 or lower Digimon to the bottom of the deck.";
-                }
-
-                bool CanSelectPermanentUnsuspendCondition(Permanent permanent)
-                {
-                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
-                    {
-                        if (permanent.TopCard.HasLevel)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-
-                bool CanSelectPermanentBounceCondition(Permanent permanent)
-                {
-                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
-                    {
-                        if (permanent.Level <= 4)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
-                }
-
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        return true;
-                    }
-
-                    return false;
-                }
-
-                IEnumerator ActivateCoroutine(Hashtable _hashtable)
-                {
-                    if (isExistOnField(card))
-                    {
-                        if (card.Owner.GetBattleAreaDigimons().Contains(card.PermanentOfThisCard()))
-                        {
-                            if (card.Owner.SecurityCards.Count >= 3)
-                            {
-                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                                selectPermanentEffect.SetUp(
-                                    selectPlayer: card.Owner,
-                                    canTargetCondition: CanSelectPermanentUnsuspendCondition,
-                                    canTargetCondition_ByPreSelecetedList: null,
-                                    canEndSelectCondition: null,
-                                    maxCount: 1,
-                                    canNoSelect: false,
-                                    canEndNotMax: false,
-                                    selectPermanentCoroutine: null,
-                                    afterSelectPermanentCoroutine: null,
-                                    mode: SelectPermanentEffect.Mode.UnTap,
-                                    cardEffect: activateClass);
-                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                            }
-
-                            if (card.Owner.SecurityCards.Count <= 3)
-                            {
-                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                                selectPermanentEffect.SetUp(
-                                    selectPlayer: card.Owner,
-                                    canTargetCondition: CanSelectPermanentBounceCondition,
-                                    canTargetCondition_ByPreSelecetedList: null,
-                                    canEndSelectCondition: null,
-                                    maxCount: 1,
-                                    canNoSelect: false,
-                                    canEndNotMax: false,
-                                    selectPermanentCoroutine: null,
-                                    afterSelectPermanentCoroutine: null,
-                                    mode: SelectPermanentEffect.Mode.PutLibraryBottom,
-                                    cardEffect: activateClass);
-
-                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                            }
-                        }
-                    }
-                }
-            }
-            #endregion
-
-            #region Inherit
-            if (timing == EffectTiming.OnEndAttack)
-            {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Unsuspend this Digimon.", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
-                activateClass.SetIsInheritedEffect(true);
-                activateClass.SetHashString("Unsuspend_BT16_023");
-                cardEffects.Add(activateClass);
-
-                string EffectDiscription()
-                {
-                    return "[End of Attack][Once per turn] If this Digimon has [Pulsemon] in its text, by trashing the top card of your security stack, unsuspend this Digimon.";
-                }
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.CanTriggerOnEndAttack(hashtable, card);
-                }
-
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if (card.PermanentOfThisCard().TopCard.HasText("Pulsemon"))
-                        {
-                            if (card.Owner.SecurityCards.Count >= 1)
-                            {
-                                if (CardEffectCommons.CanUnsuspend(card.PermanentOfThisCard()))
-                                {
-                                    return true;
-                                }
-                            }
-                        }
-                    }
-
-                    return false;
-                }
-
-                bool PermanentCondition(Permanent permanent)
-                {
-                    if (permanent == card.PermanentOfThisCard())
-                    {
-                        if (card.PermanentOfThisCard().TopCard.HasText("Pulsemon"))
-                        {
-                            if (CardEffectCommons.CanUnsuspend(card.PermanentOfThisCard()))
-                            {
-                                return true;
-                            }
-                        }
-                    }
-                    return false;
-                }
-
-                IEnumerator ActivateCoroutine(Hashtable _hashtable)
-                {
-                    yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
-                    player: card.Owner,
-                    destroySecurityCount: 1,
-                    cardEffect: activateClass,
-                    fromTop: true).DestroySecurity());
-
-                    if (CardEffectCommons.HasMatchConditionPermanent(PermanentCondition))
-                    {
-                        Permanent selectedPermanent = card.PermanentOfThisCard();
-
-                        yield return ContinuousController.instance.StartCoroutine(new IUnsuspendPermanents(new List<Permanent>() { selectedPermanent }, activateClass).Unsuspend());
-                    }
-                }
-            }
-            #endregion
-
-            return cardEffects;
-        }
-    }
+using System.Collections;
+using System.Collections.Generic;
+
+namespace DCGO.CardEffects.BT16
+{
+    public class BT16_023 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            var cardEffects = new List<ICardEffect>();
+
+            #region Alternate Digivolution Requirement
+
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.HasPulsemonText && targetPermanent.TopCard.IsLevel4;
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 3,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null)
+                );
+            }
+
+            #endregion
+
+            #region On Play
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Unsuspend 1 Digimon and/or bottom deck an opponent's Level 4 or lower Digimon", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[On Play] If you have 3 or more security cards, unsuspend 1 of your Digimon. If " +
+                           "you have 3 or fewer, return 1 of your opponent's level 4 or lower Digimon to the bottom of the deck.";
+                }
+
+                bool CanSelectPermanentUnsuspendCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                    {
+                        if (permanent.TopCard.HasLevel)
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanSelectPermanentBounceCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
+                    {
+                        if (permanent.Level <= 4)
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        return true;
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    if (isExistOnField(card))
+                    {
+                        if (card.Owner.GetBattleAreaDigimons().Contains(card.PermanentOfThisCard()))
+                        {
+                            if (card.Owner.SecurityCards.Count >= 3)
+                            {
+                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                                selectPermanentEffect.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: CanSelectPermanentUnsuspendCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: 1,
+                                    canNoSelect: false,
+                                    canEndNotMax: false,
+                                    selectPermanentCoroutine: null,
+                                    afterSelectPermanentCoroutine: null,
+                                    mode: SelectPermanentEffect.Mode.UnTap,
+                                    cardEffect: activateClass);
+                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                            }
+
+                            if (card.Owner.SecurityCards.Count <= 3)
+                            {
+                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                                selectPermanentEffect.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: CanSelectPermanentBounceCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: 1,
+                                    canNoSelect: false,
+                                    canEndNotMax: false,
+                                    selectPermanentCoroutine: null,
+                                    afterSelectPermanentCoroutine: null,
+                                    mode: SelectPermanentEffect.Mode.PutLibraryBottom,
+                                    cardEffect: activateClass);
+
+                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                            }
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            #region When Digivolving
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Unsuspend 1 Digimon and/or bottom deck an opponent's Level 4 or lower Digimon", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] If you have 3 or more security cards, unsuspend 1 of your Digimon. If " +
+                           "you have 3 or fewer, return 1 of your opponent's level 4 or lower Digimon to the bottom of the deck.";
+                }
+
+                bool CanSelectPermanentUnsuspendCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                    {
+                        if (permanent.TopCard.HasLevel)
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanSelectPermanentBounceCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
+                    {
+                        if (permanent.Level <= 4)
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        return true;
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    if (isExistOnField(card))
+                    {
+                        if (card.Owner.GetBattleAreaDigimons().Contains(card.PermanentOfThisCard()))
+                        {
+                            if (card.Owner.SecurityCards.Count >= 3)
+                            {
+                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                                selectPermanentEffect.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: CanSelectPermanentUnsuspendCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: 1,
+                                    canNoSelect: false,
+                                    canEndNotMax: false,
+                                    selectPermanentCoroutine: null,
+                                    afterSelectPermanentCoroutine: null,
+                                    mode: SelectPermanentEffect.Mode.UnTap,
+                                    cardEffect: activateClass);
+                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                            }
+
+                            if (card.Owner.SecurityCards.Count <= 3)
+                            {
+                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                                selectPermanentEffect.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: CanSelectPermanentBounceCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: 1,
+                                    canNoSelect: false,
+                                    canEndNotMax: false,
+                                    selectPermanentCoroutine: null,
+                                    afterSelectPermanentCoroutine: null,
+                                    mode: SelectPermanentEffect.Mode.PutLibraryBottom,
+                                    cardEffect: activateClass);
+
+                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                            }
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            #region Inherit
+
+            if (timing == EffectTiming.OnEndAttack)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Unsuspend this Digimon.", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
+                activateClass.SetIsInheritedEffect(true);
+                activateClass.SetHashString("Unsuspend_BT16_023");
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[End of Attack][Once per turn] If this Digimon has [Pulsemon] in its text, by trashing the top card of your security stack, unsuspend this Digimon.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnEndAttack(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (card.PermanentOfThisCard().TopCard.HasText("Pulsemon"))
+                        {
+                            if (card.Owner.SecurityCards.Count >= 1)
+                            {
+                                if (CardEffectCommons.CanUnsuspend(card.PermanentOfThisCard()))
+                                {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    if (permanent == card.PermanentOfThisCard())
+                    {
+                        if (card.PermanentOfThisCard().TopCard.HasText("Pulsemon"))
+                        {
+                            if (CardEffectCommons.CanUnsuspend(card.PermanentOfThisCard()))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
+                    player: card.Owner,
+                    destroySecurityCount: 1,
+                    cardEffect: activateClass,
+                    fromTop: true).DestroySecurity());
+
+                    if (CardEffectCommons.HasMatchConditionPermanent(PermanentCondition))
+                    {
+                        Permanent selectedPermanent = card.PermanentOfThisCard();
+
+                        yield return ContinuousController.instance.StartCoroutine(new IUnsuspendPermanents(new List<Permanent>() { selectedPermanent }, activateClass).Unsuspend());
+                    }
+                }
+            }
+
+            #endregion
+
+            return cardEffects;
+        }
+    }
 }

Assets/CardEffect/BT16/Blue/Divemon_BT16_023.cs.meta → Assets/CardEffect/BT16/Blue/BT16_023.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 934ee3414f964febb134f7145e81b910
+fileFormatVersion: 2
+guid: 934ee3414f964febb134f7145e81b910
 timeCreated: 1717037640

Assets/CardEffect/BT16/Blue/MagnaAngemon_BT16_024.cs → Assets/CardEffect/BT16/Blue/BT16_024.cs

@@ -1,464 +1,467 @@
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System;
-
-namespace DCGO.CardEffects.BT16
-{
-    public class MagnaAngemon_BT16_024 : CEntity_Effect
-    {
-        
-        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
-        {
-            var cardEffects = new List<ICardEffect>();
-
-            #region Alternate Digivolution Requirement
-            if(timing == EffectTiming.None)
-            {
-                bool PermanentCondition(Permanent targetPermanent)
-                {
-                    return targetPermanent.TopCard.CardNames.Contains("Angemon");
-                }
-
-                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
-                    permanentCondition: PermanentCondition,
-                    digivolutionCost: 3,
-                    ignoreDigivolutionRequirement: false,
-                    card: card,
-                    condition: null)
-                );
-            }
-            #endregion
-
-            #region On Play
-            
-            if (timing == EffectTiming.OnEnterFieldAnyone)
-            {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("This Digimon digivolves into a Digimon card from security", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-                activateClass.SetHashString("MagnaAngemon_BT16_024_OnPlay_WhenDigivolving");
-                cardEffects.Add(activateClass);
-                
-                string EffectDiscription()
-                {
-                    return
-                        "[On Play] If it's your turn, search your security stack. This Digimon may digivolve into a Digimon card with the [Angel] " +
-                        "or [Three Great Angels] trait among them with the digivolution cost reduced by 2. Then, shuffle your security stack. If this effect digivolved, " +
-                        "you may place 1 Digimon card with the [Angel], [Archangel] or [Three Great Angels] trait from your hand at the bottom of your security stack.";
-                }
-                
-                bool CanSelectCardDigivolutionCondition(CardSource cardSource)
-                {
-                    if (cardSource.CardTraits.Contains("Angel") || cardSource.CardTraits.Contains("Three Great Angels") || cardSource.CardTraits.Contains("ThreeGreatAngels"))
-                    {
-                        if (cardSource.IsDigimon)
-                        {
-                            if (CardEffectCommons.IsExistOnBattleArea(card))
-                            {
-                                if (cardSource.CanPlayCardTargetFrame(card.PermanentOfThisCard().PermanentFrame, false, activateClass))
-                                {
-                                    return true;
-                                }
-                            }
-                        }
-                    }
-                    
-                    return false;
-                }
-                
-                bool CanSelectCardRecoverCondition(CardSource cardSource)
-                {
-                    if (cardSource.IsDigimon)
-                    {
-                        if (cardSource.HasAngelTraitRestrictive)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-                
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsOwnerTurn(card) && CardEffectCommons.CanTriggerOnPlay(hashtable, card);
-                }
-                
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if (card.Owner.SecurityCards.Count >= 1)
-                        {
-                            return true;
-                        }
-                    }
-                    
-                    return false;
-                }
-                
-                IEnumerator ActivateCoroutine(Hashtable _hashtable)
-                {
-                    if (card.Owner.SecurityCards.Count >= 1)
-                    {
-                        int maxCount = Math.Min(1, card.Owner.SecurityCards.Count);
-                        
-                        CardSource selectedCard = null;
-                        
-                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
-                        
-                        selectCardEffect.SetUp(
-                            canTargetCondition: CanSelectCardDigivolutionCondition,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            canNoSelect: () => true,
-                            selectCardCoroutine: SelectCardCoroutine,
-                            afterSelectCardCoroutine: null,
-                            message: "Select 1 card to digivolve.",
-                            maxCount: maxCount,
-                            canEndNotMax: false,
-                            isShowOpponent: true,
-                            mode: SelectCardEffect.Mode.Custom,
-                            root: SelectCardEffect.Root.Security,
-                            customRootCardList: null,
-                            canLookReverseCard: true,
-                            selectPlayer: card.Owner,
-                            cardEffect: activateClass);
-                        
-                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
-                        
-                        IEnumerator SelectCardCoroutine(CardSource cardSource)
-                        {
-                            selectedCard = cardSource;
-                            
-                            yield return null;
-                        }
-                        
-                        ContinuousController.instance.PlaySE(GManager.instance.ShuffleSE);
-                        
-                        card.Owner.SecurityCards = RandomUtility.ShuffledDeckCards(card.Owner.SecurityCards);
-                        
-                        if (selectedCard != null)
-                        {
-                            if (CardEffectCommons.IsExistOnBattleArea(card))
-                            {
-                                GManager.instance.turnStateMachine.gameContext.IsSecurityLooking = true;
-                                
-                                if (selectedCard.CanPlayCardTargetFrame(card.PermanentOfThisCard().PermanentFrame,
-                                        PayCost: false, activateClass, root: SelectCardEffect.Root.Security))
-                                {
-                                    PlayCardClass playCardClass = new PlayCardClass(
-                                        cardSources: new List<CardSource>() { selectedCard },
-                                        hashtable: CardEffectCommons.CardEffectHashtable(activateClass),
-                                        payCost: true,
-                                        targetPermanent: card.PermanentOfThisCard(),
-                                        isTapped: false,
-                                        root: SelectCardEffect.Root.Security,
-                                        activateETB: true);
-
-                                    playCardClass.SetReducedCost(2);
-
-                                    yield return ContinuousController.instance.StartCoroutine(playCardClass.PlayCard());
-                                }
-                                
-                                GManager.instance.turnStateMachine.gameContext.IsSecurityLooking = false;
-                                
-                                if (CardEffectCommons.IsDigivolvedByTheEffect(card.PermanentOfThisCard(), selectedCard,
-                                        activateClass))
-                                {
-                                    if (card.Owner.CanAddSecurity(activateClass))
-                                    {
-                                        if (card.Owner.HandCards.Count(CanSelectCardRecoverCondition) >= 1)
-                                        {
-                                            List<CardSource> selectedCards = new List<CardSource>();
-                                            
-                                            maxCount = 1;
-                                            
-                                            SelectHandEffect selectHandEffect =
-                                                GManager.instance.GetComponent<SelectHandEffect>();
-                                            
-                                            selectHandEffect.SetUp(
-                                                selectPlayer: card.Owner,
-                                                canTargetCondition: CanSelectCardRecoverCondition,
-                                                canTargetCondition_ByPreSelecetedList: null,
-                                                canEndSelectCondition: null,
-                                                maxCount: maxCount,
-                                                canNoSelect: true,
-                                                canEndNotMax: false,
-                                                isShowOpponent: true,
-                                                selectCardCoroutine: SelectCardCoroutine1,
-                                                afterSelectCardCoroutine: null,
-                                                mode: SelectHandEffect.Mode.Custom,
-                                                cardEffect: activateClass);
-                                            
-                                            selectHandEffect.SetUpCustomMessage(
-                                                "Select 1 card to place at the bottom of security.",
-                                                "The opponent is selecting 1 card to place at the bottom of security.");
-                                            selectHandEffect.SetUpCustomMessage_ShowCard("Security Bottom Card");
-                                            
-                                            yield return StartCoroutine(selectHandEffect.Activate());
-                                            
-                                            IEnumerator SelectCardCoroutine1(CardSource cardSource)
-                                            {
-                                                selectedCards.Add(cardSource);
-                                                
-                                                yield return null;
-                                            }
-                                            
-                                            foreach (CardSource cardSource in selectedCards)
-                                            {
-                                                yield return ContinuousController.instance.StartCoroutine(
-                                                    CardObjectController.AddSecurityCard(cardSource, toTop: false));
-                                                
-                                                yield return ContinuousController.instance.StartCoroutine(GManager
-                                                    .instance.GetComponent<Effects>()
-                                                    .CreateRecoveryEffect(cardSource.Owner));
-                                                
-                                                yield return ContinuousController.instance.StartCoroutine(
-                                                    new IAddSecurity(cardSource.Owner).AddSecurity());
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            
-            #endregion
-
-            #region When Digivolving
-            
-            if (timing == EffectTiming.OnEnterFieldAnyone)
-            {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("This Digimon digivolves into a Digimon card from security", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-                activateClass.SetHashString("MagnaAngemon_BT16_024_OnPlay_WhenDigivolving");
-                cardEffects.Add(activateClass);
-                
-                string EffectDiscription()
-                {
-                    return
-                        "[When Digivolving] If it's your turn, search your security stack. This Digimon may digivolve into a Digimon card with the [Angel] " +
-                        "or [Three Great Angels] trait among them with the digivolution cost reduced by 2. Then, shuffle your security stack. If this effect digivolved, " +
-                        "you may place 1 Digimon card with the [Angel], [Archangel] or [Three Great Angels] trait from your hand at the bottom of your security stack.";
-                }
-                
-                bool CanSelectCardDigivolutionCondition(CardSource cardSource)
-                {
-                    if (cardSource.CardTraits.Contains("Angel") || cardSource.CardTraits.Contains("Three Great Angels") || cardSource.CardTraits.Contains("ThreeGreatAngels"))
-                    {
-                        if (cardSource.IsDigimon)
-                        {
-                            if (CardEffectCommons.IsExistOnBattleArea(card))
-                            {
-                                if (cardSource.CanPlayCardTargetFrame(card.PermanentOfThisCard().PermanentFrame, false, activateClass))
-                                {
-                                    return true;
-                                }
-                            }
-                        }
-                    }
-                    
-                    return false;
-                }
-
-                bool CanSelectCardRecoverCondition(CardSource cardSource)
-                {
-                    if (cardSource.IsDigimon)
-                    {
-                        if (cardSource.HasAngelTraitRestrictive)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
-                }
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsOwnerTurn(card) && CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
-                }
-                
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if (card.Owner.SecurityCards.Count >= 1)
-                        {
-                            return true;
-                        }
-                    }
-                    
-                    return false;
-                }
-                
-                IEnumerator ActivateCoroutine(Hashtable _hashtable)
-                {
-                    if (card.Owner.SecurityCards.Count >= 1)
-                    {
-                        int maxCount = Math.Min(1, card.Owner.SecurityCards.Count);
-                        
-                        CardSource selectedCard = null;
-                        
-                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
-                        
-                        selectCardEffect.SetUp(
-                            canTargetCondition: CanSelectCardDigivolutionCondition,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            canNoSelect: () => true,
-                            selectCardCoroutine: SelectCardCoroutine,
-                            afterSelectCardCoroutine: null,
-                            message: "Select 1 card to digivolve.",
-                            maxCount: maxCount,
-                            canEndNotMax: false,
-                            isShowOpponent: true,
-                            mode: SelectCardEffect.Mode.Custom,
-                            root: SelectCardEffect.Root.Security,
-                            customRootCardList: null,
-                            canLookReverseCard: true,
-                            selectPlayer: card.Owner,
-                            cardEffect: activateClass);
-                        
-                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
-                        
-                        IEnumerator SelectCardCoroutine(CardSource cardSource)
-                        {
-                            selectedCard = cardSource;
-                            
-                            yield return null;
-                        }
-                        
-                        ContinuousController.instance.PlaySE(GManager.instance.ShuffleSE);
-                        
-                        card.Owner.SecurityCards = RandomUtility.ShuffledDeckCards(card.Owner.SecurityCards);
-                        
-                        if (selectedCard != null)
-                        {
-                            if (CardEffectCommons.IsExistOnBattleArea(card))
-                            {
-                                GManager.instance.turnStateMachine.gameContext.IsSecurityLooking = true;
-                                
-                                if (selectedCard.CanPlayCardTargetFrame(card.PermanentOfThisCard().PermanentFrame,
-                                        PayCost: false, activateClass, root: SelectCardEffect.Root.Security))
-                                {
-                                    PlayCardClass playCardClass = new PlayCardClass(
-                                        cardSources: new List<CardSource>() { selectedCard },
-                                        hashtable: CardEffectCommons.CardEffectHashtable(activateClass),
-                                        payCost: true,
-                                        targetPermanent: card.PermanentOfThisCard(),
-                                        isTapped: false,
-                                        root: SelectCardEffect.Root.Security,
-                                        activateETB: true);
-
-                                    playCardClass.SetReducedCost(2);
-
-                                    yield return ContinuousController.instance.StartCoroutine(playCardClass.PlayCard());
-                                }
-                                
-                                GManager.instance.turnStateMachine.gameContext.IsSecurityLooking = false;
-                                
-                                if (CardEffectCommons.IsDigivolvedByTheEffect(card.PermanentOfThisCard(), selectedCard,
-                                        activateClass))
-                                {
-                                    if (card.Owner.CanAddSecurity(activateClass))
-                                    {
-                                        if (card.Owner.HandCards.Count(CanSelectCardRecoverCondition) >= 1)
-                                        {
-                                            List<CardSource> selectedCards = new List<CardSource>();
-                                            
-                                            maxCount = 1;
-                                            
-                                            SelectHandEffect selectHandEffect =
-                                                GManager.instance.GetComponent<SelectHandEffect>();
-                                            
-                                            selectHandEffect.SetUp(
-                                                selectPlayer: card.Owner,
-                                                canTargetCondition: CanSelectCardRecoverCondition,
-                                                canTargetCondition_ByPreSelecetedList: null,
-                                                canEndSelectCondition: null,
-                                                maxCount: maxCount,
-                                                canNoSelect: true,
-                                                canEndNotMax: false,
-                                                isShowOpponent: true,
-                                                selectCardCoroutine: SelectCardCoroutine1,
-                                                afterSelectCardCoroutine: null,
-                                                mode: SelectHandEffect.Mode.Custom,
-                                                cardEffect: activateClass);
-                                            
-                                            selectHandEffect.SetUpCustomMessage(
-                                                "Select 1 card to place at the bottom of security.",
-                                                "The opponent is selecting 1 card to place at the bottom of security.");
-                                            selectHandEffect.SetUpCustomMessage_ShowCard("Security Bottom Card");
-                                            
-                                            yield return StartCoroutine(selectHandEffect.Activate());
-                                            
-                                            IEnumerator SelectCardCoroutine1(CardSource cardSource)
-                                            {
-                                                selectedCards.Add(cardSource);
-                                                
-                                                yield return null;
-                                            }
-                                            
-                                            foreach (CardSource cardSource in selectedCards)
-                                            {
-                                                yield return ContinuousController.instance.StartCoroutine(
-                                                    CardObjectController.AddSecurityCard(cardSource, toTop: false));
-                                                
-                                                yield return ContinuousController.instance.StartCoroutine(GManager
-                                                    .instance.GetComponent<Effects>()
-                                                    .CreateRecoveryEffect(cardSource.Owner));
-                                                
-                                                yield return ContinuousController.instance.StartCoroutine(
-                                                    new IAddSecurity(cardSource.Owner).AddSecurity());
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            
-            #endregion
-            
-            #region Inherited Effect
-            if (timing == EffectTiming.None)
-            {
-                bool CanUseCondition()
-                {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if (CardEffectCommons.IsOpponentTurn(card))
-                        {
-                            return true;
-                        }
-                    }
-                    
-                    return false;
-                }
-                
-                bool PermanentCondition(Permanent permanent)
-                {
-                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
-                    {
-                        return permanent.TopCard.HasAngelTraitRestrictive;
-                    }
-                    
-                    return false;
-                }
-                
-                cardEffects.Add(CardEffectFactory.BlockerStaticEffect(permanentCondition: PermanentCondition, isInheritedEffect: true, card: card, condition: CanUseCondition));
-            }
-            #endregion
-
-            return cardEffects;
-        }
-    }
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DCGO.CardEffects.BT16
+{
+    public class BT16_024 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            var cardEffects = new List<ICardEffect>();
+
+            #region Alternate Digivolution Requirement
+
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.CardNames.Contains("Angemon");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 3,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null)
+                );
+            }
+
+            #endregion
+
+            #region On Play
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("This Digimon digivolves into a Digimon card from security", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetHashString("MagnaAngemon_BT16_024_OnPlay_WhenDigivolving");
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return
+                        "[On Play] If it's your turn, search your security stack. This Digimon may digivolve into a Digimon card with the [Angel] " +
+                        "or [Three Great Angels] trait among them with the digivolution cost reduced by 2. Then, shuffle your security stack. If this effect digivolved, " +
+                        "you may place 1 Digimon card with the [Angel], [Archangel] or [Three Great Angels] trait from your hand at the bottom of your security stack.";
+                }
+
+                bool CanSelectCardDigivolutionCondition(CardSource cardSource)
+                {
+                    if (cardSource.CardTraits.Contains("Angel") || cardSource.CardTraits.Contains("Three Great Angels") || cardSource.CardTraits.Contains("ThreeGreatAngels"))
+                    {
+                        if (cardSource.IsDigimon)
+                        {
+                            if (CardEffectCommons.IsExistOnBattleArea(card))
+                            {
+                                if (cardSource.CanPlayCardTargetFrame(card.PermanentOfThisCard().PermanentFrame, false, activateClass))
+                                {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanSelectCardRecoverCondition(CardSource cardSource)
+                {
+                    if (cardSource.IsDigimon)
+                    {
+                        if (cardSource.HasAngelTraitRestrictive)
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsOwnerTurn(card) && CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (card.Owner.SecurityCards.Count >= 1)
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    if (card.Owner.SecurityCards.Count >= 1)
+                    {
+                        int maxCount = Math.Min(1, card.Owner.SecurityCards.Count);
+
+                        CardSource selectedCard = null;
+
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                        selectCardEffect.SetUp(
+                            canTargetCondition: CanSelectCardDigivolutionCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            canNoSelect: () => true,
+                            selectCardCoroutine: SelectCardCoroutine,
+                            afterSelectCardCoroutine: null,
+                            message: "Select 1 card to digivolve.",
+                            maxCount: maxCount,
+                            canEndNotMax: false,
+                            isShowOpponent: true,
+                            mode: SelectCardEffect.Mode.Custom,
+                            root: SelectCardEffect.Root.Security,
+                            customRootCardList: null,
+                            canLookReverseCard: true,
+                            selectPlayer: card.Owner,
+                            cardEffect: activateClass);
+
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            selectedCard = cardSource;
+
+                            yield return null;
+                        }
+
+                        ContinuousController.instance.PlaySE(GManager.instance.ShuffleSE);
+
+                        card.Owner.SecurityCards = RandomUtility.ShuffledDeckCards(card.Owner.SecurityCards);
+
+                        if (selectedCard != null)
+                        {
+                            if (CardEffectCommons.IsExistOnBattleArea(card))
+                            {
+                                GManager.instance.turnStateMachine.gameContext.IsSecurityLooking = true;
+
+                                if (selectedCard.CanPlayCardTargetFrame(card.PermanentOfThisCard().PermanentFrame,
+                                        PayCost: false, activateClass, root: SelectCardEffect.Root.Security))
+                                {
+                                    PlayCardClass playCardClass = new PlayCardClass(
+                                        cardSources: new List<CardSource>() { selectedCard },
+                                        hashtable: CardEffectCommons.CardEffectHashtable(activateClass),
+                                        payCost: true,
+                                        targetPermanent: card.PermanentOfThisCard(),
+                                        isTapped: false,
+                                        root: SelectCardEffect.Root.Security,
+                                        activateETB: true);
+
+                                    playCardClass.SetReducedCost(2);
+
+                                    yield return ContinuousController.instance.StartCoroutine(playCardClass.PlayCard());
+                                }
+
+                                GManager.instance.turnStateMachine.gameContext.IsSecurityLooking = false;
+
+                                if (CardEffectCommons.IsDigivolvedByTheEffect(card.PermanentOfThisCard(), selectedCard,
+                                        activateClass))
+                                {
+                                    if (card.Owner.CanAddSecurity(activateClass))
+                                    {
+                                        if (card.Owner.HandCards.Count(CanSelectCardRecoverCondition) >= 1)
+                                        {
+                                            List<CardSource> selectedCards = new List<CardSource>();
+
+                                            maxCount = 1;
+
+                                            SelectHandEffect selectHandEffect =
+                                                GManager.instance.GetComponent<SelectHandEffect>();
+
+                                            selectHandEffect.SetUp(
+                                                selectPlayer: card.Owner,
+                                                canTargetCondition: CanSelectCardRecoverCondition,
+                                                canTargetCondition_ByPreSelecetedList: null,
+                                                canEndSelectCondition: null,
+                                                maxCount: maxCount,
+                                                canNoSelect: true,
+                                                canEndNotMax: false,
+                                                isShowOpponent: true,
+                                                selectCardCoroutine: SelectCardCoroutine1,
+                                                afterSelectCardCoroutine: null,
+                                                mode: SelectHandEffect.Mode.Custom,
+                                                cardEffect: activateClass);
+
+                                            selectHandEffect.SetUpCustomMessage(
+                                                "Select 1 card to place at the bottom of security.",
+                                                "The opponent is selecting 1 card to place at the bottom of security.");
+                                            selectHandEffect.SetUpCustomMessage_ShowCard("Security Bottom Card");
+
+                                            yield return StartCoroutine(selectHandEffect.Activate());
+
+                                            IEnumerator SelectCardCoroutine1(CardSource cardSource)
+                                            {
+                                                selectedCards.Add(cardSource);
+
+                                                yield return null;
+                                            }
+
+                                            foreach (CardSource cardSource in selectedCards)
+                                            {
+                                                yield return ContinuousController.instance.StartCoroutine(
+                                                    CardObjectController.AddSecurityCard(cardSource, toTop: false));
+
+                                                yield return ContinuousController.instance.StartCoroutine(GManager
+                                                    .instance.GetComponent<Effects>()
+                                                    .CreateRecoveryEffect(cardSource.Owner));
+
+                                                yield return ContinuousController.instance.StartCoroutine(
+                                                    new IAddSecurity(cardSource.Owner).AddSecurity());
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            #region When Digivolving
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("This Digimon digivolves into a Digimon card from security", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetHashString("MagnaAngemon_BT16_024_OnPlay_WhenDigivolving");
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return
+                        "[When Digivolving] If it's your turn, search your security stack. This Digimon may digivolve into a Digimon card with the [Angel] " +
+                        "or [Three Great Angels] trait among them with the digivolution cost reduced by 2. Then, shuffle your security stack. If this effect digivolved, " +
+                        "you may place 1 Digimon card with the [Angel], [Archangel] or [Three Great Angels] trait from your hand at the bottom of your security stack.";
+                }
+
+                bool CanSelectCardDigivolutionCondition(CardSource cardSource)
+                {
+                    if (cardSource.CardTraits.Contains("Angel") || cardSource.CardTraits.Contains("Three Great Angels") || cardSource.CardTraits.Contains("ThreeGreatAngels"))
+                    {
+                        if (cardSource.IsDigimon)
+                        {
+                            if (CardEffectCommons.IsExistOnBattleArea(card))
+                            {
+                                if (cardSource.CanPlayCardTargetFrame(card.PermanentOfThisCard().PermanentFrame, false, activateClass))
+                                {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanSelectCardRecoverCondition(CardSource cardSource)
+                {
+                    if (cardSource.IsDigimon)
+                    {
+                        if (cardSource.HasAngelTraitRestrictive)
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsOwnerTurn(card) && CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (card.Owner.SecurityCards.Count >= 1)
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    if (card.Owner.SecurityCards.Count >= 1)
+                    {
+                        int maxCount = Math.Min(1, card.Owner.SecurityCards.Count);
+
+                        CardSource selectedCard = null;
+
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                        selectCardEffect.SetUp(
+                            canTargetCondition: CanSelectCardDigivolutionCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            canNoSelect: () => true,
+                            selectCardCoroutine: SelectCardCoroutine,
+                            afterSelectCardCoroutine: null,
+                            message: "Select 1 card to digivolve.",
+                            maxCount: maxCount,
+                            canEndNotMax: false,
+                            isShowOpponent: true,
+                            mode: SelectCardEffect.Mode.Custom,
+                            root: SelectCardEffect.Root.Security,
+                            customRootCardList: null,
+                            canLookReverseCard: true,
+                            selectPlayer: card.Owner,
+                            cardEffect: activateClass);
+
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            selectedCard = cardSource;
+
+                            yield return null;
+                        }
+
+                        ContinuousController.instance.PlaySE(GManager.instance.ShuffleSE);
+
+                        card.Owner.SecurityCards = RandomUtility.ShuffledDeckCards(card.Owner.SecurityCards);
+
+                        if (selectedCard != null)
+                        {
+                            if (CardEffectCommons.IsExistOnBattleArea(card))
+                            {
+                                GManager.instance.turnStateMachine.gameContext.IsSecurityLooking = true;
+
+                                if (selectedCard.CanPlayCardTargetFrame(card.PermanentOfThisCard().PermanentFrame,
+                                        PayCost: false, activateClass, root: SelectCardEffect.Root.Security))
+                                {
+                                    PlayCardClass playCardClass = new PlayCardClass(
+                                        cardSources: new List<CardSource>() { selectedCard },
+                                        hashtable: CardEffectCommons.CardEffectHashtable(activateClass),
+                                        payCost: true,
+                                        targetPermanent: card.PermanentOfThisCard(),
+                                        isTapped: false,
+                                        root: SelectCardEffect.Root.Security,
+                                        activateETB: true);
+
+                                    playCardClass.SetReducedCost(2);
+
+                                    yield return ContinuousController.instance.StartCoroutine(playCardClass.PlayCard());
+                                }
+
+                                GManager.instance.turnStateMachine.gameContext.IsSecurityLooking = false;
+
+                                if (CardEffectCommons.IsDigivolvedByTheEffect(card.PermanentOfThisCard(), selectedCard,
+                                        activateClass))
+                                {
+                                    if (card.Owner.CanAddSecurity(activateClass))
+                                    {
+                                        if (card.Owner.HandCards.Count(CanSelectCardRecoverCondition) >= 1)
+                                        {
+                                            List<CardSource> selectedCards = new List<CardSource>();
+
+                                            maxCount = 1;
+
+                                            SelectHandEffect selectHandEffect =
+                                                GManager.instance.GetComponent<SelectHandEffect>();
+
+                                            selectHandEffect.SetUp(
+                                                selectPlayer: card.Owner,
+                                                canTargetCondition: CanSelectCardRecoverCondition,
+                                                canTargetCondition_ByPreSelecetedList: null,
+                                                canEndSelectCondition: null,
+                                                maxCount: maxCount,
+                                                canNoSelect: true,
+                                                canEndNotMax: false,
+                                                isShowOpponent: true,
+                                                selectCardCoroutine: SelectCardCoroutine1,
+                                                afterSelectCardCoroutine: null,
+                                                mode: SelectHandEffect.Mode.Custom,
+                                                cardEffect: activateClass);
+
+                                            selectHandEffect.SetUpCustomMessage(
+                                                "Select 1 card to place at the bottom of security.",
+                                                "The opponent is selecting 1 card to place at the bottom of security.");
+                                            selectHandEffect.SetUpCustomMessage_ShowCard("Security Bottom Card");
+
+                                            yield return StartCoroutine(selectHandEffect.Activate());
+
+                                            IEnumerator SelectCardCoroutine1(CardSource cardSource)
+                                            {
+                                                selectedCards.Add(cardSource);
+
+                                                yield return null;
+                                            }
+
+                                            foreach (CardSource cardSource in selectedCards)
+                                            {
+                                                yield return ContinuousController.instance.StartCoroutine(
+                                                    CardObjectController.AddSecurityCard(cardSource, toTop: false));
+
+                                                yield return ContinuousController.instance.StartCoroutine(GManager
+                                                    .instance.GetComponent<Effects>()
+                                                    .CreateRecoveryEffect(cardSource.Owner));
+
+                                                yield return ContinuousController.instance.StartCoroutine(
+                                                    new IAddSecurity(cardSource.Owner).AddSecurity());
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            #region Inherited Effect
+
+            if (timing == EffectTiming.None)
+            {
+                bool CanUseCondition()
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.IsOpponentTurn(card))
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                    {
+                        return permanent.TopCard.HasAngelTraitRestrictive;
+                    }
+
+                    return false;
+                }
+
+                cardEffects.Add(CardEffectFactory.BlockerStaticEffect(permanentCondition: PermanentCondition, isInheritedEffect: true, card: card, condition: CanUseCondition));
+            }
+
+            #endregion
+
+            return cardEffects;
+        }
+    }
 }

Assets/CardEffect/BT16/Blue/MagnaAngemon_BT16_024.cs.meta → Assets/CardEffect/BT16/Blue/BT16_024.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: bacc1535a302407d9d956a4c957b868a
+fileFormatVersion: 2
+guid: bacc1535a302407d9d956a4c957b868a
 timeCreated: 1717038941

Assets/CardEffect/BT16/Blue/Paildramon_BT16_025.cs → Assets/CardEffect/BT16/Blue/BT16_025.cs

@@ -4,7 +4,7 @@ using System.Linq;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Paildramon_BT16_025 : CEntity_Effect
+    public class BT16_025 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
@@ -15,6 +15,7 @@ namespace DCGO.CardEffects.BT16
             partitionConditions.Add(new PartitionCondition(4, CardColor.Green));
 
             #region Partition - Inherited
+
             if (timing == EffectTiming.WhenRemoveField)
             {
                 cardEffects.Add(CardEffectFactory.PartitionSelfEffect
@@ -29,9 +30,11 @@ namespace DCGO.CardEffects.BT16
                     condition: null,
                     cardSourceConditions: partitionConditions));
             }
+
             #endregion
 
             #region DNA
+
             if (timing == EffectTiming.None)
             {
                 AddJogressConditionClass addJogressConditionClass = new AddJogressConditionClass();
@@ -45,8 +48,6 @@ namespace DCGO.CardEffects.BT16
                     return true;
                 }
 
-
-
                 JogressCondition GetJogress(CardSource cardSource)
                 {
                     if (cardSource == card)
@@ -122,9 +123,11 @@ namespace DCGO.CardEffects.BT16
                     return null;
                 }
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -163,7 +166,7 @@ namespace DCGO.CardEffects.BT16
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
                     List<Permanent> oppenentDigimon = card.Owner.Enemy.GetBattleAreaDigimons();
-                    List<Permanent> opponentSuspendable = oppenentDigimon.Where(permanent => 
+                    List<Permanent> opponentSuspendable = oppenentDigimon.Where(permanent =>
                         permanent.DigivolutionCards.Count <= card.PermanentOfThisCard().DigivolutionCards.Count &&
                         PermanentCondition(permanent)).ToList();
 
@@ -181,9 +184,11 @@ namespace DCGO.CardEffects.BT16
                     yield return null;
                 }
             }
+
             #endregion
 
             #region When Attacking
+
             if (timing == EffectTiming.OnAllyAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -248,7 +253,7 @@ namespace DCGO.CardEffects.BT16
                         selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to suspend.", "The opponent is selecting 1 Digimon to suspend.");
 
                         yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                    }                    
+                    }
 
                     IEnumerator SelectPermanentCoroutine(Permanent permanent)
                     {
@@ -264,6 +269,7 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Blue/VikemonAce_BT16_026.cs → Assets/CardEffect/BT16/Blue/BT16_026.cs

@@ -3,13 +3,14 @@ using System.Collections.Generic;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class VikemonAce_BT16_026 : CEntity_Effect
+    public class BT16_026 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Alternate Digivolution, Blast Digivolve
+
             if (timing == EffectTiming.None)
             {
                 bool PermanentCondition(Permanent targetPermanent)
@@ -30,9 +31,11 @@ namespace DCGO.CardEffects.BT16
             {
                 cardEffects.Add(CardEffectFactory.BlastDigivolveEffect(card: card, condition: null));
             }
+
             #endregion
 
             #region On Play
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -52,7 +55,7 @@ namespace DCGO.CardEffects.BT16
 
                 bool CantSuspendCondition(Permanent permanent)
                 {
-                    if(CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
                     {
                         return permanent.DigivolutionCards.Count <= 1;
                     }
@@ -99,7 +102,6 @@ namespace DCGO.CardEffects.BT16
 
                             yield return null;
                         }
-
                     }
 
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotSuspendPlayerEffect(
@@ -110,9 +112,11 @@ namespace DCGO.CardEffects.BT16
                         effectName: "Can't Suspend"));
                 }
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -179,7 +183,6 @@ namespace DCGO.CardEffects.BT16
 
                             yield return null;
                         }
-
                     }
 
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotSuspendPlayerEffect(
@@ -190,9 +193,11 @@ namespace DCGO.CardEffects.BT16
                         effectName: "Can't Suspend"));
                 }
             }
+
             #endregion
 
             #region When Attacking
+
             if (timing == EffectTiming.OnAllyAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -207,7 +212,7 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanSelectPermanentCondition(Permanent targetPermanent)
                 {
-                    if(CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(targetPermanent, card))
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(targetPermanent, card))
                         return (targetPermanent.DigivolutionCards.Count <= 1);
 
                     return false;
@@ -249,6 +254,7 @@ namespace DCGO.CardEffects.BT16
                     yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Blue/ImperialdramonFighterModeAce_BT16_027.cs → Assets/CardEffect/BT16/Blue/BT16_027.cs

@@ -4,13 +4,14 @@ using System.Linq;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class ImperialdramonFighterModeAce_BT16_027 : CEntity_Effect
+    public class BT16_027 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Alternate Digivolution, Blast Digivolve
+
             if (timing == EffectTiming.None)
             {
                 bool PermanentCondition(Permanent targetPermanent)
@@ -31,9 +32,11 @@ namespace DCGO.CardEffects.BT16
             {
                 cardEffects.Add(CardEffectFactory.BlastDigivolveEffect(card: card, condition: null));
             }
+
             #endregion
 
             #region On Play
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -93,9 +96,11 @@ namespace DCGO.CardEffects.BT16
                     yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
                 }
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -155,9 +160,11 @@ namespace DCGO.CardEffects.BT16
                     yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
                 }
             }
+
             #endregion
 
             #region End of Attack
+
             if (timing == EffectTiming.OnEndAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -178,7 +185,7 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    if(CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
                     {
                         return permanent.IsSuspended;
                     }
@@ -223,6 +230,7 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Blue/ImperialdramonDragonMode_BT16_028.cs → Assets/CardEffect/BT16/Blue/BT16_028.cs

@@ -4,13 +4,14 @@ using System.Linq;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class ImperialdramonDragonMode_BT16_028 : CEntity_Effect
+    public class BT16_028 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Alternate Digivolution
+
             if (timing == EffectTiming.None)
             {
                 bool PermanentCondition(Permanent targetPermanent)
@@ -26,9 +27,11 @@ namespace DCGO.CardEffects.BT16
                     condition: null)
                 );
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -43,7 +46,7 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanSelectOpponentsDigimon(Permanent permanent)
                 {
-                    if(CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card))
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card))
                     {
                         return permanent.IsDigimon || permanent.IsTamer;
                     }
@@ -55,9 +58,9 @@ namespace DCGO.CardEffects.BT16
                 {
                     if (CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card))
                     {
-                        if(permanent.IsDigimon || permanent.IsTamer)
+                        if (permanent.IsDigimon || permanent.IsTamer)
                         {
-                            if(!permanent.IsSuspended)
+                            if (!permanent.IsSuspended)
                             {
                                 return true;
                             }
@@ -69,9 +72,9 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanSelectYourSuspendedDigimon(Permanent permanent)
                 {
-                    if(CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent,card))
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
                     {
-                        if(permanent.IsDigimon && permanent.IsSuspended)
+                        if (permanent.IsDigimon && permanent.IsSuspended)
                         {
                             return true;
                         }
@@ -79,10 +82,9 @@ namespace DCGO.CardEffects.BT16
                     return false;
                 }
 
-
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if(CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card))
+                    if (CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card))
                     {
                         return true;
                     }
@@ -136,7 +138,6 @@ namespace DCGO.CardEffects.BT16
                         }
                     }
 
-
                     if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
                         if (CardEffectCommons.HasMatchConditionPermanent(CanSelectOpponentsDigimonToSuspend))
@@ -191,11 +192,12 @@ namespace DCGO.CardEffects.BT16
                         }
                     }
                 }
-
             }
+
             #endregion
 
             #region All Turns - When an effect plays/digivolves
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -215,7 +217,7 @@ namespace DCGO.CardEffects.BT16
 
                 bool HasTamer(Permanent permanent)
                 {
-                    if(permanent.IsTamer)
+                    if (permanent.IsTamer)
                         return CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card);
 
                     return false;
@@ -228,11 +230,11 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if(CardEffectCommons.CanTriggerOnPermanentPlay(hashtable, IsOpponentDigimon) || CardEffectCommons.CanTriggerWhenPermanentDigivolving(hashtable, IsOpponentDigimon))
+                    if (CardEffectCommons.CanTriggerOnPermanentPlay(hashtable, IsOpponentDigimon) || CardEffectCommons.CanTriggerWhenPermanentDigivolving(hashtable, IsOpponentDigimon))
                     {
                         if (CardEffectCommons.IsByEffect(hashtable, null))
                         {
-                            if(CardEffectCommons.HasMatchConditionOwnersPermanent(card, HasTamer))
+                            if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, HasTamer))
                             {
                                 if (card.Owner.HandCards.Count(HasFighterMode) >= 1)
                                 {
@@ -265,6 +267,7 @@ namespace DCGO.CardEffects.BT16
                             ignoreSelection: true));
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Blue/DavisMotomiyaAndKenIchijoji_BT16_085.cs → Assets/CardEffect/BT16/Blue/BT16_085.cs

@@ -1,12 +1,10 @@
-using Photon.Pun;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using UnityEngine;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class DavisMotomiyaAndKenIchijoji_BT16_085 : CEntity_Effect
+    public class BT16_085 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
@@ -18,6 +16,7 @@ namespace DCGO.CardEffects.BT16
             }
 
             #region Start of Main Phase
+
             if (timing == EffectTiming.OnStartMainPhase)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -176,9 +175,11 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             #region Your Turn - When you Digivolve
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -285,10 +286,10 @@ namespace DCGO.CardEffects.BT16
                                 activateClass: activateClass
                             ));
                         }
-
                     }
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Blue/InvincibleDragonInsectFusion_BT16_092.cs → Assets/CardEffect/BT16/Blue/BT16_092.cs

@@ -6,7 +6,7 @@ using UnityEngine;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class InvincibleDragonInsectFusion_BT16_092 : CEntity_Effect
+    public class BT16_092 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
@@ -170,7 +170,6 @@ namespace DCGO.CardEffects.BT16
 
                                             photonView.RPC("SetJogressEvoRootsFrameIDs", RpcTarget.All, _jogressEvoRootsFrameIDs);
                                         }
-
                                         else
                                         {
                                             GManager.instance.commandText.OpenCommandText(
@@ -282,7 +281,6 @@ namespace DCGO.CardEffects.BT16
                     GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner,
                         selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
-
                     yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
                     bool playDigimon = GManager.instance.userSelectionManager.SelectedBoolValue;
@@ -309,7 +307,6 @@ namespace DCGO.CardEffects.BT16
                                     selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage1,
                                     notSelectPlayerMessage: notSelectPlayerMessage1);
                             }
-
                             else
                             {
                                 GManager.instance.userSelectionManager.SetBool(canSelectHand);
@@ -354,7 +351,6 @@ namespace DCGO.CardEffects.BT16
 
                                 yield return StartCoroutine(selectHandEffect.Activate());
                             }
-
                             else
                             {
                                 int maxCount1 = 1;

Assets/CardEffect/BT16/Blue/Patamon_BT16-016.cs

@@ -1,24 +1,25 @@
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using System;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Patamon_BT16_016 : CEntity_Effect
+    public class BT16_016 : 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)
             {
                 bool PermanentCondition(Permanent targetPermanent)
                 {
                     return targetPermanent.TopCard.CardNames.Contains("Tokomon");
                 }
-                
+
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
                     permanentCondition: PermanentCondition,
                     digivolutionCost: 0,
@@ -26,9 +27,11 @@ namespace DCGO.CardEffects.BT16
                     card: card,
                     condition: null));
             }
+
             #endregion
 
             #region Start of Main Phase
+
             if (timing == EffectTiming.OnStartMainPhase)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -42,7 +45,6 @@ namespace DCGO.CardEffects.BT16
                     return "[Start of your Main Phase] If it's your turn, 1 of your Digimon may digivolve into a level 4 Digimon card with the [Angel] or [Free] trait from your hand with the digivolution cost reduced by 1.";
                 }
 
-
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
                     return (cardSource.CardTraits.Contains("Angel") || cardSource.CardTraits.Contains("Free"))
@@ -142,9 +144,11 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
-            
+
             #region On Play Effect
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -158,7 +162,6 @@ namespace DCGO.CardEffects.BT16
                     return "[On Play] If it's your turn, 1 of your Digimon may digivolve into a level 4 Digimon card with the [Angel] or [Free] trait from your hand with the digivolution cost reduced by 1.";
                 }
 
-
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
                     return (cardSource.CardTraits.Contains("Angel") || cardSource.CardTraits.Contains("Free"))
@@ -193,7 +196,7 @@ namespace DCGO.CardEffects.BT16
                 {
                     if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
-                        if (card.Owner.HandCards.Count(CanSelectCardCondition) >=1)
+                        if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
                         {
                             return true;
                         }
@@ -250,9 +253,11 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
-            
+
             #region Inherited Effect
+
             if (timing == EffectTiming.OnAllyAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -284,7 +289,7 @@ namespace DCGO.CardEffects.BT16
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    var maxCount = Math.Min(1,CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+                    var maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
                     var selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
 
                     selectPermanentEffect.SetUp(
@@ -314,6 +319,7 @@ namespace DCGO.CardEffects.BT16
                     }
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Green/Minomon_BT16_004.cs → Assets/CardEffect/BT16/Green/BT16_004.cs

@@ -1,16 +1,16 @@
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class Minomon_BT16_004 : CEntity_Effect
+    public class BT16_004 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Inherit
+
             if (timing == EffectTiming.OnDestroyedAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -34,24 +34,24 @@ namespace DCGO.CardEffects.BT16
                 {
                     if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
-                            if (CardEffectCommons.CanTriggerOnPermanentDeleted(hashtable, PermanentCondition))
-                            {
+                        if (CardEffectCommons.CanTriggerOnPermanentDeleted(hashtable, PermanentCondition))
+                        {
                             bool WinnerCondition(Permanent permanent) => permanent.cardSources.Contains(card);
                             bool WinnerRealCondition(Permanent permanent)
                             {
                                 if (permanent.TopCard.CardColors.Count >= 2)
                                 {
                                     return true;
-                                }      
+                                }
                                 return false;
                             }
                             bool LoserCondition(Permanent permanent) => CardEffectCommons.IsOpponentPermanent(permanent, card);
 
-                                if (CardEffectCommons.CanTriggerWhenDeleteOpponentDigimonByBattle(hashtable: hashtable, winnerCondition: WinnerCondition, winnerRealCondition: WinnerRealCondition, loserCondition: LoserCondition, isOnlyWinnerSurvive: false))
-                                {
-                                    return true;
-                                }
+                            if (CardEffectCommons.CanTriggerWhenDeleteOpponentDigimonByBattle(hashtable: hashtable, winnerCondition: WinnerCondition, winnerRealCondition: WinnerRealCondition, loserCondition: LoserCondition, isOnlyWinnerSurvive: false))
+                            {
+                                return true;
                             }
+                        }
                     }
                     return false;
                 }
@@ -71,6 +71,7 @@ namespace DCGO.CardEffects.BT16
                     yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(1, activateClass));
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT16/Green/KoKabuterimon_BT16_037.cs → Assets/CardEffect/BT16/Green/BT16_037.cs

@@ -3,13 +3,14 @@ using System.Collections.Generic;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class KoKabuterimon_BT16_037 : CEntity_Effect
+    public class BT16_037 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region On Play
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -68,9 +69,11 @@ namespace DCGO.CardEffects.BT16
                     ));
                 }
             }
+
             #endregion
 
             #region Inherit
+
             if (timing == EffectTiming.None)
             {
                 bool Condition()
@@ -88,6 +91,7 @@ namespace DCGO.CardEffects.BT16
 
                 cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect(changeValue: 1000, isInheritedEffect: true, card: card, condition: Condition));
             }
+
             #endregion
 
             return cardEffects;