BT15-Green and Apocolymon Effects

Assets/CardEffect/BT15/Green/Jureimon_BT15_050.cs → Assets/CardEffect/BT15/Green/Cherrymon_BT15_050.cs

@@ -6,12 +6,13 @@ using Photon;
 using System;
 using Photon.Pun;
 
-public class Jureimon_BT15_050 : CEntity_Effect
+public class Cherrymon_BT15_050 : 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();
@@ -21,7 +22,7 @@ public class Jureimon_BT15_050 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[On Play] Reveal the top 4 cards of your deck. Add 2 cards that are either black with [Knightmon] or [DeadlyAxemon] in their names or with [Twilight] in their traits among them to your hand. Place the rest at the bottom of your deck in any order.";
+                return "[On Play] Reveal the top 4 cards of your deck. Add 2 level 6 or higher cards among them to the hand. Return the rest to the bottom of the deck.";
             }
 
             bool CanSelectCardCondition(CardSource cardSource)
@@ -74,7 +75,9 @@ public class Jureimon_BT15_050 : CEntity_Effect
                 ));
             }
         }
+        #endregion
 
+        #region On End Your Turn
         if (timing == EffectTiming.OnEndTurn)
         {
             ActivateClass activateClass = new ActivateClass();
@@ -84,7 +87,7 @@ public class Jureimon_BT15_050 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[Start of Your Main Phase] If you have a Tamer with [Tai Kamiya] in its name, this Digimon may digivolve into [Greymon] in your hand without paying the cost.";
+                return "[End of Your Turn] By deleting 1 of your Digimon, you may play 1 Digimon card with the [Dark Masters] trait from your hand to an empty space in your breeding area without paying the cost.";
             }
 
             bool CanSelectPermanentCondition(Permanent permanent)
@@ -96,7 +99,7 @@ public class Jureimon_BT15_050 : CEntity_Effect
             {
                 if (card.Owner.GetBreedingAreaPermanents().Count == 0)
                 {
-                    if (cardSource.CardTraits.Contains("Dark Masters") || cardSource.CardTraits.Contains("Dark Masters"))
+                    if (cardSource.CardTraits.Contains("Dark Masters") || cardSource.CardTraits.Contains("DarkMasters"))
                     {
                         if (cardSource.IsDigimon)
                         {
@@ -224,7 +227,9 @@ public class Jureimon_BT15_050 : CEntity_Effect
                 }
             }
         }
+        #endregion
 
+        //Inherited Effect
         if (timing == EffectTiming.OnDetermineDoSecurityCheck)
         {
             cardEffects.Add(CardEffectFactory.PierceSelfEffect(isInheritedEffect: true, card: card, condition: null));

Assets/CardEffect/BT15/Green/HerakuruKabuterimon_BT15_053.cs

@@ -1,284 +0,0 @@
-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
-using System.Linq;
-using Photon;
-using System;
-using Photon.Pun;
-public class HerakuruKabuterimon_BT15_053 : CEntity_Effect
-{
-  public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
-  {
-    List<ICardEffect> cardEffects = new List<ICardEffect>();
-
-    if (timing == EffectTiming.OnStartMainPhase)
-    {
-      ActivateClass activateClass = new ActivateClass();
-      activateClass.SetUpICardEffect("Suspend 1 Digimon and your 1 Digimon gains Pierce", CanUseCondition, card);
-      activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-      cardEffects.Add(activateClass);
-
-      string EffectDiscription()
-      {
-        return "[Start of Your Main Phase] If you have a Tamer with [Tai Kamiya] in its name, this Digimon may digivolve into [Greymon] in your hand without paying the cost.";
-      }
-
-      bool CanSelectPermanentCondition(Permanent permanent)
-      {
-        return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
-      }
-
-      bool CanSelectPermanentCondition1(Permanent permanent)
-      {
-        return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
-      }
-
-      bool CanUseCondition(Hashtable hashtable)
-      {
-        if (CardEffectCommons.IsExistOnBattleArea(card))
-        {
-          if (CardEffectCommons.IsOwnerTurn(card))
-          {
-            return true;
-          }
-        }
-
-        return false;
-      }
-
-      bool CanActivateCondition(Hashtable hashtable)
-      {
-        if (CardEffectCommons.IsExistOnBattleArea(card))
-        {
-          if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-          {
-            return true;
-          }
-
-          if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition1))
-          {
-            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: null,
-              afterSelectPermanentCoroutine: null,
-              mode: SelectPermanentEffect.Mode.Tap,
-              cardEffect: activateClass);
-
-          yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-        }
-
-        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition1))
-        {
-          int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition1));
-
-          SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-          selectPermanentEffect.SetUp(
-              selectPlayer: card.Owner,
-              canTargetCondition: CanSelectPermanentCondition1,
-              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 gain Pierce.",
-              "The opponent is selecting 1 Digimon that will gain Pierce.");
-
-          yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-          IEnumerator SelectPermanentCoroutine(Permanent permanent)
-          {
-            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainPierce(
-                targetPermanent: permanent,
-                effectDuration: EffectDuration.UntilEachTurnEnd,
-                activateClass: activateClass));
-          }
-        }
-      }
-    }
-
-    if (timing == EffectTiming.OnEnterFieldAnyone)
-    {
-      ActivateClass activateClass = new ActivateClass();
-      activateClass.SetUpICardEffect("Suspend 1 Digimon and your 1 Digimon gains Pierce", CanUseCondition, card);
-      activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-      cardEffects.Add(activateClass);
-
-      string EffectDiscription()
-      {
-        return "[When Digivolving] Suspend 1 of your opponent's Digimon. That Digimon doesn't unsuspend during their next unsuspend phase.";
-      }
-
-      bool CanSelectPermanentCondition(Permanent permanent)
-      {
-        return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
-      }
-
-      bool CanSelectPermanentCondition1(Permanent permanent)
-      {
-        return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
-      }
-
-      bool CanUseCondition(Hashtable hashtable)
-      {
-        return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
-      }
-
-      bool CanActivateCondition(Hashtable hashtable)
-      {
-        if (CardEffectCommons.IsExistOnBattleArea(card))
-        {
-          if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-          {
-            return true;
-          }
-
-          if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition1))
-          {
-            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: null,
-              afterSelectPermanentCoroutine: null,
-              mode: SelectPermanentEffect.Mode.Tap,
-              cardEffect: activateClass);
-
-          yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-        }
-
-        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition1))
-        {
-          int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition1));
-
-          SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-          selectPermanentEffect.SetUp(
-              selectPlayer: card.Owner,
-              canTargetCondition: CanSelectPermanentCondition1,
-              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 gain Pierce.",
-              "The opponent is selecting 1 Digimon that will gain Pierce.");
-
-          yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-          IEnumerator SelectPermanentCoroutine(Permanent permanent)
-          {
-            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainPierce(
-                targetPermanent: permanent,
-                effectDuration: EffectDuration.UntilEachTurnEnd,
-                activateClass: activateClass));
-          }
-        }
-      }
-    }
-
-    if (timing == EffectTiming.None)
-    {
-      CanNotAffectedClass canNotAffectedClass = new CanNotAffectedClass();
-      canNotAffectedClass.SetUpICardEffect("Isn't affected by opponent's Digimon's effects", CanUseCondition, card);
-      canNotAffectedClass.SetUpCanNotAffectedClass(CardCondition: CardCondition, SkillCondition: SkillCondition);
-      cardEffects.Add(canNotAffectedClass);
-
-      bool CanUseCondition(Hashtable hashtable)
-      {
-        if (CardEffectCommons.IsExistOnBattleArea(card))
-        {
-          if (card.PermanentOfThisCard().IsSuspended)
-          {
-            return true;
-          }
-        }
-
-        return false;
-      }
-
-      bool CardCondition(CardSource cardSource)
-      {
-        if (cardSource == card)
-        {
-          if (CardEffectCommons.IsExistOnBattleArea(card))
-          {
-            if (cardSource == card.PermanentOfThisCard().TopCard)
-            {
-              return true;
-            }
-          }
-        }
-
-        return false;
-      }
-
-      bool SkillCondition(ICardEffect cardEffect)
-      {
-        if (CardEffectCommons.IsOpponentEffect(cardEffect, card))
-        {
-          if (cardEffect.IsDigimonEffect)
-          {
-            return true;
-          }
-        }
-
-        return false;
-      }
-    }
-
-    return cardEffects;
-  }
-}

Assets/CardEffect/BT15/Green/HerculesKabuterimon_BT15_053.cs

@@ -0,0 +1,183 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.Linq;
+using Photon;
+using System;
+using Photon.Pun;
+public class HerculesKabuterimon_BT15_053 : CEntity_Effect
+{
+  public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+  {
+        List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+        #region Start of Your Main Phase/ When Digivolving
+        if (timing == EffectTiming.OnStartMainPhase || timing == EffectTiming.OnEnterFieldAnyone)
+        {
+            ActivateClass activateClass = new ActivateClass();
+            activateClass.SetUpICardEffect("Suspend 1 Digimon and your 1 Digimon gains Pierce", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+            cardEffects.Add(activateClass);
+
+            string EffectDiscription()
+            {
+                return "[Start of Your Main Phase] [When Digivolving] Suspend 1 of your opponent's Digimon. 1 of your Digimon gains <Piercing> for the turn.";
+            }
+
+            bool CanSelectPermanentCondition(Permanent permanent)
+            {
+                return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+            }
+
+            bool CanSelectPermanentCondition1(Permanent permanent)
+            {
+                return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
+            }
+
+            bool CanUseCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (CardEffectCommons.IsOwnerTurn(card))
+                    {
+                        return true;
+                    }
+                }
+
+                return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+            }
+
+            bool CanActivateCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    {
+                        return true;
+                    }
+
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition1))
+                    {
+                        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: null,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Tap,
+                        cardEffect: activateClass);
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                }
+
+                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition1))
+                {
+                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition1));
+
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectPermanentCondition1,
+                        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 gain Pierce.",
+                        "The opponent is selecting 1 Digimon that will gain Pierce.");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainPierce(
+                            targetPermanent: permanent,
+                            effectDuration: EffectDuration.UntilEachTurnEnd,
+                            activateClass: activateClass));
+                    }
+                }
+            }
+        }
+        #endregion
+
+        #region All Turns
+        if (timing == EffectTiming.None)
+        {
+            CanNotAffectedClass canNotAffectedClass = new CanNotAffectedClass();
+            canNotAffectedClass.SetUpICardEffect("Isn't affected by opponent's Digimon's effects", CanUseCondition, card);
+            canNotAffectedClass.SetUpCanNotAffectedClass(CardCondition: CardCondition, SkillCondition: SkillCondition);
+            cardEffects.Add(canNotAffectedClass);
+
+            bool CanUseCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (card.PermanentOfThisCard().IsSuspended)
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            bool CardCondition(CardSource cardSource)
+            {
+                if (cardSource == card)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (cardSource == card.PermanentOfThisCard().TopCard)
+                        {
+                            return true;
+                        }
+                    }
+                }
+
+                return false;
+            }
+
+            bool SkillCondition(ICardEffect cardEffect)
+            {
+                if (CardEffectCommons.IsOpponentEffect(cardEffect, card))
+                {
+                    if (cardEffect.IsDigimonEffect)
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+        }
+        #endregion
+
+        return cardEffects;
+  }
+}

Assets/CardEffect/BT15/Green/ClashOfKnowledge_BT15_095.cs → Assets/CardEffect/BT15/Green/Impact_of_Knowledge_BT15_095.cs

@@ -5,12 +5,13 @@ using System.Linq;
 using Photon;
 using System;
 using Photon.Pun;
-public class ClashOfKnowledge_BT15_095 : CEntity_Effect
+public class Impact_of_Knowledge_BT15_095 : CEntity_Effect
 {
     public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
     {
         List<ICardEffect> cardEffects = new List<ICardEffect>();
 
+        #region Use Option
         if (timing == EffectTiming.OptionSkill)
         {
             ActivateClass activateClass = new ActivateClass();
@@ -20,7 +21,7 @@ public class ClashOfKnowledge_BT15_095 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[Main] Until the end of your opponent's turn, 1 of your opponent's Digimon gains \"[On Deletion] Trash the top card of your security stack.\" Then, if you have a blue Digimon in play, you may play 1 green level 4 or lower Digimon card with a [Free] trait from your hand without paying its cost.";
+                return "[Main] Suspend 1 of your opponent's Digimon. Then, if you have a Tamer with [Izzy Izumi] in its name, until end of your opponent's turn, 1 of their Digimon gains \"[On Deletion] Trash the top card of your security stack.\"";
             }
 
             bool CanSelectPermanentCondition(Permanent permanent)
@@ -149,6 +150,7 @@ public class ClashOfKnowledge_BT15_095 : CEntity_Effect
                 }
             }
         }
+        #endregion
 
         if (timing == EffectTiming.SecuritySkill)
         {

Assets/CardEffect/BT15/Green/Izzy_Izumi_BT15_085.cs

@@ -0,0 +1,129 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.Linq;
+using Photon;
+using System;
+using Photon.Pun;
+
+public class Izzy_Izumi_BT15_085 : CEntity_Effect
+{
+    public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+    {
+        List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+        //Start of Your Turn
+        if (timing == EffectTiming.OnStartTurn)
+        {
+            cardEffects.Add(CardEffectFactory.SetMemoryTo3TamerEffect(card));
+        }
+
+        #region Opponent's Turn
+        if (timing == EffectTiming.OnCounterTiming)
+        {
+            ActivateClass activateClass = new ActivateClass();
+            activateClass.SetUpICardEffect("Switch Attack Target to your Digimon", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+            cardEffects.Add(activateClass);
+
+            string EffectDiscription()
+            {
+                return "[Opponent's Turn] When an opponent's Digimon attacks, by suspending this Tamer, switch the target of attack to 1 of your suspended Digimon with the [Insectoid] trait.";
+            }
+
+            bool CanSelectPermanentCondition(Permanent permanent)
+            {
+                if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                {
+                    if (permanent.TopCard.CardTraits.Contains("Insectoid"))
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            bool PermanentCondition(Permanent permanent)
+            {
+                return CardEffectCommons.IsOpponentPermanent(permanent, card);
+            }
+
+            bool CanUseCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (CardEffectCommons.IsOpponentTurn(card))
+                    {
+                        if (CardEffectCommons.CanTriggerOnPermanentAttack(hashtable, PermanentCondition))
+                        {
+                            return true;
+
+                        }
+                    }
+                }
+
+                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("Select 1 Digimon that opponent's Digimon attacks to.", "The opponent is selecting 1 Digimon that your Digimon attacks to.");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.attackProcess.SwitchDefender(
+                            activateClass,
+                            false,
+                            permanent));
+                    }
+                }
+            }
+        }
+        #endregion
+
+        //Security Effect
+        if (timing == EffectTiming.SecuritySkill)
+            cardEffects.Add(CardEffectFactory.PlaySelfTamerSecurityEffect(card));
+
+        return cardEffects;
+    }
+}

Assets/CardEffect/BT15/Green/Izzy_Izumi_BT15_085.cs.meta

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

Assets/CardEffect/BT15/Green/Kabuterimon_BT15_047.cs

@@ -11,105 +11,104 @@ public class Kabuterimon_BT15_047 : CEntity_Effect
   {
     List<ICardEffect> cardEffects = new List<ICardEffect>();
 
-    if (timing == EffectTiming.None)
-    {
-      CanNotAffectedClass canNotAffectedClass = new CanNotAffectedClass();
-      canNotAffectedClass.SetUpICardEffect("Isn't affected by opponent's Digimon's effects", CanUseCondition, card);
-      canNotAffectedClass.SetUpCanNotAffectedClass(CardCondition: CardCondition, SkillCondition: SkillCondition);
-      cardEffects.Add(canNotAffectedClass);
-
-      bool CanUseCondition(Hashtable hashtable)
-      {
-        if (CardEffectCommons.IsExistOnBattleArea(card))
+        #region All Turns
+        if (timing == EffectTiming.None)
         {
-          if (card.PermanentOfThisCard().IsSuspended)
-          {
-            return true;
-          }
-        }
-
-        return false;
-      }
+            CanNotAffectedClass canNotAffectedClass = new CanNotAffectedClass();
+            canNotAffectedClass.SetUpICardEffect("Isn't affected by opponent's Digimon's effects", CanUseCondition, card);
+            canNotAffectedClass.SetUpCanNotAffectedClass(CardCondition: CardCondition, SkillCondition: SkillCondition);
+            cardEffects.Add(canNotAffectedClass);
 
-      bool CardCondition(CardSource cardSource)
-      {
-        if (cardSource == card)
-        {
-          if (CardEffectCommons.IsExistOnBattleArea(card))
-          {
-            if (cardSource == card.PermanentOfThisCard().TopCard)
+            bool CanUseCondition(Hashtable hashtable)
             {
-              return true;
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (card.PermanentOfThisCard().IsSuspended)
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
             }
-          }
-        }
 
-        return false;
-      }
+            bool CardCondition(CardSource cardSource)
+            {
+                if (cardSource == card)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (cardSource == card.PermanentOfThisCard().TopCard)
+                        {
+                            return true;
+                        }
+                    }
+                }
+
+                return false;
+            }
 
-      bool SkillCondition(ICardEffect cardEffect)
-      {
-        if (CardEffectCommons.IsOpponentEffect(cardEffect, card))
-        {
-          if (cardEffect.IsDigimonEffect)
-          {
-            return true;
-          }
+            bool SkillCondition(ICardEffect cardEffect)
+            {
+                if (CardEffectCommons.IsOpponentEffect(cardEffect, card))
+                {
+                    if (cardEffect.IsDigimonEffect)
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
         }
+        #endregion
 
-        return false;
-      }
-    }
-
-    if (timing == EffectTiming.OnEndBattle)
-    {
-      ActivateClass activateClass = new ActivateClass();
-      activateClass.SetUpICardEffect("Memory +1", CanUseCondition, card);
-      activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
-      activateClass.SetIsInheritedEffect(true);
-      activateClass.SetHashString("Memory+1_BT15_047");
-      cardEffects.Add(activateClass);
-
-      string EffectDiscription()
-      {
-        return "[Your Turn][Once Per Turn] When this Digimon deletes an opponent's Digimon in battle, gain 1 memory.";
-      }
-
-      bool CanUseCondition(Hashtable hashtable)
-      {
-        if (CardEffectCommons.IsExistOnBattleArea(card))
+        #region Inherited Effect
+        if (timing == EffectTiming.OnEndBattle)
         {
-          if (CardEffectCommons.IsOwnerTurn(card))
-          {
-            bool WinnerCondition(Permanent permanent) => permanent.cardSources.Contains(card);
-            bool LoserCondition(Permanent permanent) => CardEffectCommons.IsOpponentPermanent(permanent, card);
-
-            if (CardEffectCommons.CanTriggerWhenDeleteOpponentDigimonByBattle(hashtable: hashtable, winnerCondition: WinnerCondition, loserCondition: LoserCondition, isOnlyWinnerSurvive: false))
+            ActivateClass activateClass = new ActivateClass();
+            activateClass.SetUpICardEffect("Memory +1", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+            activateClass.SetIsInheritedEffect(true);
+            activateClass.SetHashString("Memory+1_BT15_047");
+            cardEffects.Add(activateClass);
+
+            string EffectDiscription()
             {
-              return true;
+                return "[All Turns] [Once Per Turn] When this Digimon deletes an opponent's Digimon in battle, gain 1 memory.";
             }
-          }
-        }
 
-        return false;
-      }
+            bool CanUseCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    bool WinnerCondition(Permanent permanent) => permanent.cardSources.Contains(card);
+                    bool LoserCondition(Permanent permanent) => CardEffectCommons.IsOpponentPermanent(permanent, card);
 
-      bool CanActivateCondition(Hashtable hashtable)
-      {
-        if (CardEffectCommons.IsExistOnBattleArea(card))
-        {
-          return true;
-        }
+                    if (CardEffectCommons.CanTriggerWhenDeleteOpponentDigimonByBattle(hashtable: hashtable, winnerCondition: WinnerCondition, loserCondition: LoserCondition, isOnlyWinnerSurvive: false))
+                        return true;
+                }
 
-        return false;
-      }
+                return false;
+            }
+
+            bool CanActivateCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    return true;
+                }
 
-      IEnumerator ActivateCoroutine(Hashtable _hashtable)
-      {
-        yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(1, activateClass));
-      }
-    }
+                return false;
+            }
+
+            IEnumerator ActivateCoroutine(Hashtable _hashtable)
+            {
+                yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(1, activateClass));
+            }
+        }
+        #endregion
 
-    return cardEffects;
+        return cardEffects;
   }
 }

Assets/CardEffect/BT15/Green/LilimonXAntibody_BT15_051.cs → Assets/CardEffect/BT15/Green/Lillymon_X_Antibody_BT15_051.cs

@@ -6,12 +6,13 @@ using Photon;
 using System;
 using Photon.Pun;
 
-public class LilimonXAntibody_BT15_051 : CEntity_Effect
+public class Lillymon_X_Antibody_BT15_051 : CEntity_Effect
 {
     public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
     {
         List<ICardEffect> cardEffects = new List<ICardEffect>();
 
+        //Alternate Digivolution Requirement
         if (timing == EffectTiming.None)
         {
             bool PermanentCondition(Permanent targetPermanent)
@@ -27,6 +28,7 @@ public class LilimonXAntibody_BT15_051 : CEntity_Effect
                 condition: null));
         }
 
+        #region When Digivolving
         if (timing == EffectTiming.OnEnterFieldAnyone)
         {
             ActivateClass activateClass = new ActivateClass();
@@ -36,7 +38,7 @@ public class LilimonXAntibody_BT15_051 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[When Digivolving] 1 of your opponent's Digimon cannot unsuspend until the end of your opponent's turn.";
+                return "[When Digivolving] If there's a suspended Digimon, gain 1 memory. If [Lillymon] or [X Antibody] in this Digimon's digivolution cards, <Draw 1> for each of your opponent's suspended Digimon.";
             }
 
             bool CanUseCondition(Hashtable hashtable)
@@ -60,7 +62,7 @@ public class LilimonXAntibody_BT15_051 : CEntity_Effect
                 return false;
             }
 
-            bool PermanentCondition1(Permanent permanent)
+            bool IsSuspendedCondition(Permanent permanent)
             {
                 if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
                 {
@@ -87,7 +89,7 @@ public class LilimonXAntibody_BT15_051 : CEntity_Effect
 
                     if (card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) => cardSource.CardNames.Contains("Lillymon") || cardSource.CardNames.Contains("X Antibody") || cardSource.CardNames.Contains("XAntibody")) >= 1)
                     {
-                        if (CardEffectCommons.HasMatchConditionPermanent(PermanentCondition1))
+                        if (CardEffectCommons.HasMatchConditionPermanent(IsSuspendedCondition))
                         {
                             if (card.Owner.LibraryCards.Count >= 1)
                             {
@@ -111,18 +113,20 @@ public class LilimonXAntibody_BT15_051 : CEntity_Effect
                 {
                     if (card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) => cardSource.CardNames.Contains("Lillymon") || cardSource.CardNames.Contains("X Antibody") || cardSource.CardNames.Contains("XAntibody")) >= 1)
                     {
-                        if (CardEffectCommons.HasMatchConditionPermanent(PermanentCondition1))
+                        if (CardEffectCommons.HasMatchConditionPermanent(IsSuspendedCondition))
                         {
                             yield return ContinuousController.instance.StartCoroutine(new DrawClass(
                                 card.Owner,
-                                CardEffectCommons.MatchConditionPermanentCount(PermanentCondition1),
+                                CardEffectCommons.MatchConditionPermanentCount(IsSuspendedCondition),
                                 activateClass).Draw());
                         }
                     }
                 }
             }
         }
+        #endregion
 
+        #region Inherited Effect
         if (timing == EffectTiming.None)
         {
             int count()
@@ -152,6 +156,7 @@ public class LilimonXAntibody_BT15_051 : CEntity_Effect
                 card: card,
                 condition: Condition));
         }
+        #endregion
 
         return cardEffects;
     }

Assets/CardEffect/BT15/Green/AtolerkabuterimonAce_BT15_049.cs → Assets/CardEffect/BT15/Green/MegaKabuterimon_ACE_BT15_049.cs

@@ -5,17 +5,19 @@ using System.Linq;
 using Photon;
 using System;
 using Photon.Pun;
-public class AtolerkabuterimonAce_BT15_049 : CEntity_Effect
+public class MegaKabuterimon_ACE_BT15_049 : CEntity_Effect
 {
     public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
     {
         List<ICardEffect> cardEffects = new List<ICardEffect>();
 
+        //Blast Digivolve
         if (timing == EffectTiming.OnCounterTiming)
         {
             cardEffects.Add(CardEffectFactory.BlastDigivolveEffect(card: card, condition: null));
         }
 
+        #region On Play/When Digivolving
         if (timing == EffectTiming.OnEnterFieldAnyone)
         {
             ActivateClass activateClass = new ActivateClass();
@@ -25,7 +27,7 @@ public class AtolerkabuterimonAce_BT15_049 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[On Play] 1 of your Digimon gets +3000 DP for the turn.";
+                return "[On Play] [When Digivolving] 1 of your Digimon gets +3000 DP until the end of your opponent's turn. Then, if one of their Digimon is attacking, you may switch the target of attack to this Digimon.";
             }
 
             bool CanSelectPermanentCondition(Permanent permanent)
@@ -35,127 +37,7 @@ public class AtolerkabuterimonAce_BT15_049 : CEntity_Effect
 
             bool CanUseCondition(Hashtable hashtable)
             {
-                return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
-            }
-
-            bool CanActivateCondition(Hashtable hashtable)
-            {
-                if (CardEffectCommons.IsExistOnBattleArea(card))
-                {
-                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-                    {
-                        return true;
-                    }
-
-                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(GManager.instance.attackProcess.AttackingPermanent, card))
-                    {
-                        if (GManager.instance.attackProcess.IsAttacking)
-                        {
-                            if (GManager.instance.attackProcess.AttackingPermanent.CanSwitchAttackTarget)
-                            {
-                                return true;
-                            }
-                        }
-                    }
-                }
-
-                return false;
-            }
-
-            IEnumerator ActivateCoroutine(Hashtable _hashtable)
-            {
-                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-                {
-                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                    selectPermanentEffect.SetUp(
-                        selectPlayer: card.Owner,
-                        canTargetCondition: CanSelectPermanentCondition,
-                        canTargetCondition_ByPreSelecetedList: null,
-                        canEndSelectCondition: null,
-                        maxCount: maxCount,
-                        canNoSelect: false,
-                        canEndNotMax: false,
-                        selectPermanentCoroutine: SelectPermanentCoroutine,
-                        afterSelectPermanentCoroutine: null,
-                        mode: SelectPermanentEffect.Mode.Custom,
-                        cardEffect: activateClass);
-
-                    selectPermanentEffect.SetUpCustomMessage(
-                        "Select 1 Digimon that will get DP +3000.",
-                        "The opponent is selecting 1 Digimon that will get DP +3000.");
-
-                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                    {
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
-                            targetPermanent: permanent,
-                            changeValue: 3000,
-                            effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                            activateClass: activateClass));
-                    }
-                }
-
-                if (CardEffectCommons.IsExistOnBattleArea(card))
-                {
-                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(GManager.instance.attackProcess.AttackingPermanent, card))
-                    {
-                        if (GManager.instance.attackProcess.IsAttacking)
-                        {
-                            if (GManager.instance.attackProcess.AttackingPermanent.CanSwitchAttackTarget)
-                            {
-                                List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
-                        {
-                            new SelectionElement<bool>(message: $"Switch", value : true, spriteIndex: 0),
-                            new SelectionElement<bool>(message: $"Not switch", value : false, spriteIndex: 1),
-                        };
-
-                                string selectPlayerMessage = "Will you switch the attack target?";
-                                string notSelectPlayerMessage = "The opponent is selecting whether to switch the attack target.";
-
-                                GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
-
-                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
-
-                                bool doSwitch = GManager.instance.userSelectionManager.SelectedBoolValue;
-
-                                if (doSwitch)
-                                {
-                                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.attackProcess.SwitchDefender(
-                                        activateClass,
-                                        false,
-                                        card.PermanentOfThisCard()));
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        if (timing == EffectTiming.OnEnterFieldAnyone)
-        {
-            ActivateClass activateClass = new ActivateClass();
-            activateClass.SetUpICardEffect("Your 1 Digimon gains DP +3000 and switch attack target", CanUseCondition, card);
-            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-            cardEffects.Add(activateClass);
-
-            string EffectDiscription()
-            {
-                return "[When Digivolving] 1 of your Digimon gets +3000 DP for the turn.";
-            }
-
-            bool CanSelectPermanentCondition(Permanent permanent)
-            {
-                return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
-            }
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                return CardEffectCommons.CanTriggerOnPlay(hashtable, card) || CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
             }
 
             bool CanActivateCondition(Hashtable hashtable)
@@ -255,7 +137,9 @@ public class AtolerkabuterimonAce_BT15_049 : CEntity_Effect
                 }
             }
         }
+        #endregion
 
+        #region All Turns
         if (timing == EffectTiming.None)
         {
             CanNotAffectedClass canNotAffectedClass = new CanNotAffectedClass();
@@ -305,6 +189,7 @@ public class AtolerkabuterimonAce_BT15_049 : CEntity_Effect
                 return false;
             }
         }
+        #endregion
 
         return cardEffects;
     }

Assets/CardEffect/BT15/Green/Mochimon_BT15_004.cs → Assets/CardEffect/BT15/Green/Motimon_BT15_004.cs

@@ -6,7 +6,7 @@ using Photon;
 using System;
 using Photon.Pun;
 
-public class Mochimon_BT15_004 : CEntity_Effect
+public class Motimon_BT15_004 : CEntity_Effect
 {
     public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
     {
@@ -22,7 +22,7 @@ public class Mochimon_BT15_004 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[End of Your Turn] This Digimon may attack an opponent's Digimon.";
+                return "[End of Your Turn] If this Digimon has the [Insectoid] trait, it may attack an opponent's Digimon.";
             }
 
             bool CanUseCondition(Hashtable hashtable)

Assets/CardEffect/BT15/Green/Mashmon_BT15_044.cs → Assets/CardEffect/BT15/Green/Mushroomon_BT15_044.cs

@@ -6,7 +6,7 @@ using Photon;
 using System;
 using Photon.Pun;
 
-public class Mashmon_BT15_044 : CEntity_Effect
+public class Mushroomon_BT15_044 : CEntity_Effect
 {
     public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
     {
@@ -21,7 +21,7 @@ public class Mashmon_BT15_044 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[On Deletion] Gain 2 memory.";
+                return "[On Deletion] 1 of your opponent's Digimon can't unsuspend until the end of their turn.";
             }
 
             bool CanSelectPermanentCondition(Permanent permanent)

Assets/CardEffect/BT15/Green/ParumonXAntibody_BT15_045.cs → Assets/CardEffect/BT15/Green/Palmon_X_Antibody_BT15_045.cs

@@ -6,17 +6,18 @@ using Photon;
 using System;
 using Photon.Pun;
 
-public class ParumonXAntibody_BT15_045 : CEntity_Effect
+public class Palmon_X_Antibody_BT15_045 : CEntity_Effect
 {
     public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
     {
         List<ICardEffect> cardEffects = new List<ICardEffect>();
 
+        //Alternate Digivolution Requirement
         if (timing == EffectTiming.None)
         {
             bool PermanentCondition(Permanent targetPermanent)
             {
-                return targetPermanent.TopCard.CardNames.Contains("Parumon");
+                return targetPermanent.TopCard.CardNames.Contains("Palmon");
             }
 
             cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
@@ -27,6 +28,7 @@ public class ParumonXAntibody_BT15_045 : CEntity_Effect
                 condition: null));
         }
 
+        #region On Play/When Digivolving
         if (timing == EffectTiming.OnEnterFieldAnyone)
         {
             ActivateClass activateClass = new ActivateClass();
@@ -36,7 +38,7 @@ public class ParumonXAntibody_BT15_045 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[When Digivolving] Suspend 1 of your opponent's Digimon. That Digimon doesn't unsuspend during their next unsuspend phase.";
+                return "[On Play] [When Digivolving] Suspend 1 of your opponent's Digimon.";
             }
 
             bool CanSelectPermanentCondition(Permanent permanent)
@@ -46,68 +48,7 @@ public class ParumonXAntibody_BT15_045 : CEntity_Effect
 
             bool CanUseCondition(Hashtable hashtable)
             {
-                return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
-            }
-
-            bool CanActivateCondition(Hashtable hashtable)
-            {
-                if (CardEffectCommons.IsExistOnBattleArea(card))
-                {
-                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            IEnumerator ActivateCoroutine(Hashtable _hashtable)
-            {
-                if (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: null,
-                        afterSelectPermanentCoroutine: null,
-                        mode: SelectPermanentEffect.Mode.Tap,
-                        cardEffect: activateClass);
-
-                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                }
-            }
-        }
-
-        if (timing == EffectTiming.OnEnterFieldAnyone)
-        {
-            ActivateClass activateClass = new ActivateClass();
-            activateClass.SetUpICardEffect("Suspend 1 Digimon", CanUseCondition, card);
-            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-            cardEffects.Add(activateClass);
-
-            string EffectDiscription()
-            {
-                return "[When Digivolving] Suspend 1 of your opponent's Digimon. That Digimon doesn't unsuspend during their next unsuspend phase.";
-            }
-
-            bool CanSelectPermanentCondition(Permanent permanent)
-            {
-                return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
-            }
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                return CardEffectCommons.CanTriggerOnPlay(hashtable, card) || CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
             }
 
             bool CanActivateCondition(Hashtable hashtable)
@@ -148,7 +89,9 @@ public class ParumonXAntibody_BT15_045 : CEntity_Effect
                 }
             }
         }
+        #endregion
 
+        #region Inherited Effect
         if (timing == EffectTiming.OnEnterFieldAnyone)
         {
             ActivateClass activateClass = new ActivateClass();
@@ -160,7 +103,7 @@ public class ParumonXAntibody_BT15_045 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[Your Turn][Once Per Turn] When you play a green Tamer, gain 1 memory.";
+                return "[Your Turn] [Once Per Turn] When one of your green Tamers is played, gain 1 memory.";
             }
 
             bool PermanentCondition(Permanent permanent)
@@ -210,6 +153,7 @@ public class ParumonXAntibody_BT15_045 : CEntity_Effect
                 yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(1, activateClass));
             }
         }
+        #endregion
 
         return cardEffects;
     }

Assets/CardEffect/BT15/Green/Pinokkimon_BT15_052.cs → Assets/CardEffect/BT15/Green/Puppetmon_BT15_052.cs

@@ -6,46 +6,20 @@ using Photon;
 using System;
 using Photon.Pun;
 
-public class Pinokkimon_BT15_052 : CEntity_Effect
+public class Puppetmon_BT15_052 : CEntity_Effect
 {
     public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
     {
         List<ICardEffect> cardEffects = new List<ICardEffect>();
 
-        if (timing == EffectTiming.OnEnterFieldAnyone)
+        //Can't evo on white
+        if (timing == EffectTiming.None)
         {
-            ActivateClass activateClass = new ActivateClass();
-            activateClass.SetUpICardEffect("Return 1 suspended Digimon to the bottom of deck", CanUseCondition, card);
-            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-            cardEffects.Add(activateClass);
-
-            string EffectDiscription()
-            {
-                return "[When Digivolving] Trigger <De-Digivolve 1> on 1 of your opponent's Digimon. (Trash up to 1 card from the top of one of your opponent's Digimon. If it has no digivolution cards, or becomes a level 3 Digimon, you can't trash any more cards.)";
-            }
-
-            bool CanSelectPermanentCondition(Permanent permanent)
-            {
-                if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
-                {
-                    if (permanent.IsSuspended)
-                    {
-                        return true;
-                    }
-                }
-                return false;
-            }
-
-            bool CanUseCondition(Hashtable hashtable)
-            {
-                return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
-            }
-
-            bool CanActivateCondition(Hashtable hashtable)
+            bool Condition()
             {
                 if (CardEffectCommons.IsExistOnBattleArea(card))
                 {
-                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    if (CardEffectCommons.IsOwnerTurn(card))
                     {
                         return true;
                     }
@@ -54,33 +28,22 @@ public class Pinokkimon_BT15_052 : CEntity_Effect
                 return false;
             }
 
-            IEnumerator ActivateCoroutine(Hashtable _hashtable)
+            bool CardCondition(CardSource cardSource)
             {
-                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: null,
-                        afterSelectPermanentCoroutine: null,
-                        mode: SelectPermanentEffect.Mode.PutLibraryBottom,
-                        cardEffect: activateClass);
-
-                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                }
+                return !cardSource.CardColors.Contains(CardColor.White);
             }
+
+            cardEffects.Add(CardEffectFactory.CanNotDigivolveStaticSelfEffect(
+            cardCondition: CardCondition,
+            isInheritedEffect: false,
+            card: card,
+            condition: Condition,
+            effectName: "This Digimon can digivolve only to white Digimon")
+            );
         }
 
-        if (timing == EffectTiming.OnAllyAttack)
+        #region On Play/When Attacking
+        if (timing == EffectTiming.OnEnterFieldAnyone || timing == EffectTiming.OnAllyAttack)
         {
             ActivateClass activateClass = new ActivateClass();
             activateClass.SetUpICardEffect("Return 1 suspended Digimon to the bottom of deck", CanUseCondition, card);
@@ -89,7 +52,7 @@ public class Pinokkimon_BT15_052 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[When Digivolving] Trigger <De-Digivolve 1> on 1 of your opponent's Digimon. (Trash up to 1 card from the top of one of your opponent's Digimon. If it has no digivolution cards, or becomes a level 3 Digimon, you can't trash any more cards.)";
+                return "[On Play] [When Attacking] Return 1 of your opponent's suspended Digimon to the bottom of the deck.";
             }
 
             bool CanSelectPermanentCondition(Permanent permanent)
@@ -106,7 +69,7 @@ public class Pinokkimon_BT15_052 : CEntity_Effect
 
             bool CanUseCondition(Hashtable hashtable)
             {
-                return CardEffectCommons.CanTriggerOnAttack(hashtable, card);
+                return CardEffectCommons.CanTriggerOnPlay(hashtable, card) || CardEffectCommons.CanTriggerOnAttack(hashtable, card);
             }
 
             bool CanActivateCondition(Hashtable hashtable)
@@ -114,9 +77,7 @@ public class Pinokkimon_BT15_052 : CEntity_Effect
                 if (CardEffectCommons.IsExistOnBattleArea(card))
                 {
                     if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-                    {
                         return true;
-                    }
                 }
 
                 return false;
@@ -147,36 +108,9 @@ public class Pinokkimon_BT15_052 : CEntity_Effect
                 }
             }
         }
+        #endregion
 
-        if (timing == EffectTiming.None)
-        {
-            bool Condition()
-            {
-                if (CardEffectCommons.IsExistOnBattleArea(card))
-                {
-                    if (CardEffectCommons.IsOwnerTurn(card))
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            bool CardCondition(CardSource cardSource)
-            {
-                return !cardSource.CardColors.Contains(CardColor.White);
-            }
-
-            cardEffects.Add(CardEffectFactory.CanNotDigivolveStaticSelfEffect(
-            cardCondition: CardCondition,
-            isInheritedEffect: false,
-            card: card,
-            condition: Condition,
-            effectName: "This Digimon can digivolve only to white Digimon")
-            );
-        }
-
+        #region End of Opponent's Turn
         if (timing == EffectTiming.OnEndTurn)
         {
             ActivateClass activateClass = new ActivateClass();
@@ -186,26 +120,19 @@ public class Pinokkimon_BT15_052 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[End of Your Turn] Trash the top card of your security stack.";
+                return "[End of Opponent's Turn] Delete this Digimon. Then, you may play 1 Digimon card with the [Dark Masters] trait, other than [Puppetmon] from your hand without paying the cost.";
             }
 
             bool CanSelectCardCondition(CardSource cardSource)
             {
-                if (!cardSource.CardNames.Contains("Pinokkimon"))
+                if (!cardSource.CardNames.Contains("Puppetmon"))
                 {
                     if (cardSource.IsDigimon)
                     {
                         if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass))
                         {
-                            if (cardSource.CardTraits.Contains("Dark Masters"))
-                            {
-                                return true;
-                            }
-
-                            if (cardSource.CardTraits.Contains("DarkMasters"))
-                            {
+                            if (cardSource.CardTraits.Contains("Dark Masters") || cardSource.CardTraits.Contains("DarkMasters"))
                                 return true;
-                            }
                         }
                     }
                 }
@@ -284,11 +211,11 @@ public class Pinokkimon_BT15_052 : CEntity_Effect
                 }
             }
         }
+        #endregion
 
+        //Inhereted Effect
         if (timing == EffectTiming.OnDetermineDoSecurityCheck)
-        {
             cardEffects.Add(CardEffectFactory.PierceSelfEffect(isInheritedEffect: true, card: card, condition: null));
-        }
 
         return cardEffects;
     }

Assets/CardEffect/BT15/Green/Rosemon_X_Antibody_BT15_054.cs

@@ -0,0 +1,285 @@
+using System.Collections;
+using System.Collections.Generic;
+using System;
+using UnityEditor.Experimental.GraphView;
+using System.Linq;
+
+public class Rosemon_X_Antibody_BT15_054 : CEntity_Effect
+{
+    public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+    {
+        List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+        #region When Digivolving
+        if (timing == EffectTiming.OnEnterFieldAnyone)
+        {
+            ActivateClass activateClass = new ActivateClass();
+            activateClass.SetUpICardEffect("Opponent's 1 Digimon can't unsuspend", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+            cardEffects.Add(activateClass);
+
+            string EffectDiscription()
+            {
+                return "[When Digivolving] Suspend 1 of your opponent's Digimon and 1 of their Tamers. They can't unsuspend until the end of their turn.";
+            }
+
+            bool CanSelectDigimonCard(Permanent permanent)
+            {
+                return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+            }
+
+            bool CanSelectTamerCard(Permanent permanent)
+            {
+                if(CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card))
+                {
+                    if (permanent.TopCard.CardKind == CardKind.Tamer)
+                        return true;
+                }
+
+                return false;
+            }
+
+            bool CanUseCondition(Hashtable hashtable)
+            {
+                return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+            }
+
+            bool CanActivateCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card))
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectDigimonCard))
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            IEnumerator ActivateCoroutine(Hashtable _hashtable)
+            {
+                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectDigimonCard))
+                {
+                    List<CardSource> selectedCards = new List<CardSource>();
+                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectDigimonCard));
+
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectDigimonCard,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: maxCount,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: SelectDigimonCoroutine,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Custom,
+                        cardEffect: activateClass);
+
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will get unable to unsuspend.", "The opponent is selecting 1 Digimon that will get unable to unsuspend.");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                    IEnumerator SelectDigimonCoroutine(Permanent permanent)
+                    {
+                        selectedCards.Add(permanent.TopCard);
+
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCantUnsuspendUntilOpponentTurnEnd(
+                            targetPermanent: permanent,
+                            activateClass: activateClass
+                        ));
+                    }
+
+                    if (selectedCards.Count >= 1)
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectTamerCard))
+                        {
+                            maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectTamerCard));
+
+                            SelectPermanentEffect selectTamerEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectTamerCard,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: SelectTamerCoroutine,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+
+                            selectPermanentEffect.SetUpCustomMessage(
+                                "Select 1 Tamer that will get unable to unsuspend.",
+                                "The opponent is selecting 1 Tamer that will get unable to unsuspend.");
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                            IEnumerator SelectTamerCoroutine(Permanent permanent)
+                            {
+                                selectedCards.Add(permanent.TopCard);
+
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCantUnsuspendUntilOpponentTurnEnd(
+                                    targetPermanent: permanent,
+                                    activateClass: activateClass
+                                ));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        #endregion
+
+        #region Opponent's Turn Digimon Played
+        if (timing == EffectTiming.OnEnterFieldAnyone)
+        {
+            ActivateClass activateClass = new ActivateClass();
+            activateClass.SetUpICardEffect("Suspend 1 of your Opponent's Digimon", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
+            cardEffects.Add(activateClass);
+
+            string EffectDiscription()
+            {
+                return "[Opponent's Turn] [Once Per Turn] When an opponent's Digimon is played, you may suspend 1 of their Digimon.";
+            }
+
+            bool CanSelectPermanentCondition(Permanent permanent)
+            {
+                return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
+            }
+
+            bool PermanentCondition(Permanent permanent)
+            {
+                return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+            }
+
+            bool CanUseCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (CardEffectCommons.CanTriggerOnPermanentPlay(hashtable, PermanentCondition))
+                        return true;
+                }
+
+                return false;
+            }
+
+            bool CanActivateCondition(Hashtable hashtable)
+            {
+                return CardEffectCommons.IsExistOnBattleArea(card);
+            }
+
+            IEnumerator ActivateCoroutine(Hashtable _hashtable)
+            {
+                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                {
+                    List<CardSource> selectedCards = new List<CardSource>();
+                    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.Custom,
+                        cardEffect: activateClass);
+
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to unsuspend.", "The opponent is selecting 1 Digimon to unsuspend.");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                }
+            }
+        }
+        #endregion
+
+        #region Opponent's Turn Digimon Enters From Raising Area
+        if (timing == EffectTiming.OnEnterFieldAnyone)
+        {
+            ActivateClass activateClass = new ActivateClass();
+            activateClass.SetUpICardEffect("Suspend 1 of your Opponent's Digimon", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
+            cardEffects.Add(activateClass);
+
+            string EffectDiscription()
+            {
+                return "[Opponent's Turn] [Once Per Turn] When an opponent's Digimon moves from the breeding area to the battle area, if [Rosemon] or [X Antibody] in this Digimon's digivolution cards, you may suspend 1 of their Digimon.";
+            }
+
+            bool PermanentCondition(Permanent permanent)
+            {
+                return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+
+            }
+
+            bool CanUseCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (CardEffectCommons.IsOpponentTurn(card))
+                    {
+                        if (CardEffectCommons.CanTriggerOnMove(hashtable, PermanentCondition))
+                        {
+                            return true;
+                        }
+                    }
+                }
+
+                return false;
+            }
+
+            bool CanActivateCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    return true;
+                }
+
+                return false;
+            }
+
+            IEnumerator ActivateCoroutine(Hashtable _hashtable)
+            {
+                if (CardEffectCommons.HasMatchConditionPermanent(PermanentCondition))
+                {
+                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(PermanentCondition));
+
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: PermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: maxCount,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: null,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Tap,
+                        cardEffect: activateClass);
+
+                    if (card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) => cardSource.CardNames.Contains("Rosemon") || cardSource.CardNames.Contains("X Antibody") || cardSource.CardNames.Contains("XAntibody")) >= 1)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                    }
+                        
+                }
+            }
+        }
+        #endregion
+        
+        return cardEffects;
+    }
+}

Assets/CardEffect/BT15/Green/Rosemon_X_Antibody_BT15_054.cs.meta

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

Assets/CardEffect/BT15/Green/PuchiThunder_BT15_094.cs → Assets/CardEffect/BT15/Green/Super_Shocker_BT15_094.cs

@@ -6,12 +6,13 @@ using Photon;
 using System;
 using Photon.Pun;
 
-public class PuchiThunder_BT15_094 : CEntity_Effect
+public class Super_Shocker_BT15_094 : CEntity_Effect
 {
     public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
     {
         List<ICardEffect> cardEffects = new List<ICardEffect>();
 
+        #region Use Option
         if (timing == EffectTiming.OptionSkill)
         {
             ActivateClass activateClass = new ActivateClass();
@@ -21,12 +22,12 @@ public class PuchiThunder_BT15_094 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[Main] Suspend 1 of your opponent's Digimon.";
+                return "[Main] Suspend 1 level 6 or lower Digimon. 1 of your Digimon with the [Insectoid] trait gets +3000 DP until the end of your opponent's turn.";
             }
 
             bool CanSelectPermanentCondition(Permanent permanent)
             {
-                if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
+                if (CardEffectCommons.IsPermanentExistsOnBattleArea(permanent))
                 {
                     if (permanent.Level <= 6)
                     {
@@ -116,6 +117,7 @@ public class PuchiThunder_BT15_094 : CEntity_Effect
                 }
             }
         }
+        #endregion
 
         if (timing == EffectTiming.SecuritySkill)
         {

Assets/CardEffect/BT15/Green/Tentomon_BT15_043.cs

@@ -12,6 +12,7 @@ public class Tentomon_BT15_043 : CEntity_Effect
     {
         List<ICardEffect> cardEffects = new List<ICardEffect>();
 
+        #region Start of Main Phase
         if (timing == EffectTiming.OnStartMainPhase)
         {
             ActivateClass activateClass = new ActivateClass();
@@ -21,7 +22,7 @@ public class Tentomon_BT15_043 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[Start of Your Main Phase] If you have a Tamer with [Tai Kamiya] in its name, this Digimon may digivolve into [Greymon] in your hand without paying the cost.";
+                return "[Start of Your Main Phase] By suspending 1 Digimon, 1 of your Digimon with the [Insectoid] trait gets +3000 DP until the end of your opponent's turn.";
             }
 
             bool CanSelectPermanentCondition(Permanent permanent)
@@ -168,7 +169,9 @@ public class Tentomon_BT15_043 : CEntity_Effect
                 }
             }
         }
+        #endregion
 
+        #region Inherited Effect
         if (timing == EffectTiming.OnEndBattle)
         {
             ActivateClass activateClass = new ActivateClass();
@@ -180,22 +183,19 @@ public class Tentomon_BT15_043 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[Your Turn][Once Per Turn] When this Digimon deletes an opponent's Digimon in battle, gain 1 memory.";
+                return "[All Turns] [Once Per Turn] When this Digimon deletes an opponent's Digimon in battle, gain 1 memory.";
             }
 
             bool CanUseCondition(Hashtable hashtable)
             {
                 if (CardEffectCommons.IsExistOnBattleArea(card))
                 {
-                    if (CardEffectCommons.IsOwnerTurn(card))
-                    {
-                        bool WinnerCondition(Permanent permanent) => permanent.cardSources.Contains(card);
-                        bool LoserCondition(Permanent permanent) => CardEffectCommons.IsOpponentPermanent(permanent, card);
+                    bool WinnerCondition(Permanent permanent) => permanent.cardSources.Contains(card);
+                    bool LoserCondition(Permanent permanent) => CardEffectCommons.IsOpponentPermanent(permanent, card);
 
-                        if (CardEffectCommons.CanTriggerWhenDeleteOpponentDigimonByBattle(hashtable: hashtable, winnerCondition: WinnerCondition, loserCondition: LoserCondition, isOnlyWinnerSurvive: false))
-                        {
-                            return true;
-                        }
+                    if (CardEffectCommons.CanTriggerWhenDeleteOpponentDigimonByBattle(hashtable: hashtable, winnerCondition: WinnerCondition, loserCondition: LoserCondition, isOnlyWinnerSurvive: false))
+                    {
+                        return true;
                     }
                 }
 
@@ -218,6 +218,7 @@ public class Tentomon_BT15_043 : CEntity_Effect
                 yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(1, activateClass));
             }
         }
+        #endregion
 
         return cardEffects;
     }

Assets/CardEffect/BT15/Green/TogemonXAntibody_BT15_048.cs

@@ -1,165 +0,0 @@
-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
-using System.Linq;
-using Photon;
-using System;
-using Photon.Pun;
-
-public class TogemonXAntibody_BT15_048 : CEntity_Effect
-{
-  public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
-  {
-    List<ICardEffect> cardEffects = new List<ICardEffect>();
-
-    if (timing == EffectTiming.None)
-    {
-      bool PermanentCondition(Permanent targetPermanent)
-      {
-        return targetPermanent.TopCard.CardNames.Contains("Togemon");
-      }
-
-      cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
-        permanentCondition: PermanentCondition,
-        digivolutionCost: 0,
-        ignoreDigivolutionRequirement: false,
-        card: card,
-        condition: null));
-    }
-
-    if (timing == EffectTiming.OnEnterFieldAnyone)
-    {
-      ActivateClass activateClass = new ActivateClass();
-      activateClass.SetUpICardEffect("Opponent's 1 Digimon can't unsuspend and suspend 1 Digimon", CanUseCondition, card);
-      activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-      cardEffects.Add(activateClass);
-
-      string EffectDiscription()
-      {
-        return "[When Digivolving] 1 of your opponent's Digimon cannot unsuspend 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 (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-          {
-            return true;
-          }
-        }
-
-        return false;
-      }
-
-      IEnumerator ActivateCoroutine(Hashtable _hashtable)
-      {
-        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-        {
-          int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-          SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-          selectPermanentEffect.SetUp(
-              selectPlayer: card.Owner,
-              canTargetCondition: CanSelectPermanentCondition,
-              canTargetCondition_ByPreSelecetedList: null,
-              canEndSelectCondition: null,
-              maxCount: maxCount,
-              canNoSelect: false,
-              canEndNotMax: false,
-              selectPermanentCoroutine: SelectPermanentCoroutine,
-              afterSelectPermanentCoroutine: null,
-              mode: SelectPermanentEffect.Mode.Custom,
-              cardEffect: activateClass);
-
-          selectPermanentEffect.SetUpCustomMessage(
-            "Select 1 Digimon that will get unable to unsuspend.",
-            "The opponent is selecting 1 Digimon that will get unable to unsuspend.");
-
-          yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-          IEnumerator SelectPermanentCoroutine(Permanent permanent)
-          {
-            Permanent selectedPermanent = permanent;
-
-            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCantUnsuspendUntilOpponentTurnEnd(
-                targetPermanent: selectedPermanent,
-                activateClass: activateClass
-            ));
-          }
-        }
-
-        if (CardEffectCommons.IsExistOnBattleArea(card))
-        {
-          if (card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) => cardSource.CardNames.Contains("Togemon") || cardSource.CardNames.Contains("X Antibody") || cardSource.CardNames.Contains("XAntibody")) >= 1)
-          {
-            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: null,
-                  afterSelectPermanentCoroutine: null,
-                  mode: SelectPermanentEffect.Mode.Tap,
-                  cardEffect: activateClass);
-
-              yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-            }
-          }
-        }
-      }
-    }
-
-    if (timing == EffectTiming.None)
-    {
-      int count()
-      {
-        return card.Owner.Enemy.GetBattleAreaDigimons().Count(permanent => permanent.IsSuspended);
-      }
-
-      bool Condition()
-      {
-        if (CardEffectCommons.IsExistOnBattleArea(card))
-        {
-          if (CardEffectCommons.IsOwnerTurn(card))
-          {
-            if (count() >= 1)
-            {
-              return true;
-            }
-          }
-        }
-
-        return false;
-      }
-
-      cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect<Func<int>>(
-          changeValue: () => 1000 * count(),
-          isInheritedEffect: true,
-          card: card,
-          condition: Condition));
-    }
-
-    return cardEffects;
-  }
-}

Assets/CardEffect/BT15/Green/Togemon_X_Antibody_BT15_048.cs

@@ -0,0 +1,170 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.Linq;
+using Photon;
+using System;
+using Photon.Pun;
+
+public class Togemon_X_Antibody_BT15_048 : CEntity_Effect
+{
+  public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+  {
+        List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+        //Alternate Digivolution Requirement
+        if (timing == EffectTiming.None)
+        {
+            bool PermanentCondition(Permanent targetPermanent)
+            {
+                return targetPermanent.TopCard.CardNames.Contains("Togemon");
+            }
+
+            cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+              permanentCondition: PermanentCondition,
+              digivolutionCost: 0,
+              ignoreDigivolutionRequirement: false,
+              card: card,
+              condition: null));
+        }
+
+        #region When Digivolving
+        if (timing == EffectTiming.OnEnterFieldAnyone)
+        {
+            ActivateClass activateClass = new ActivateClass();
+            activateClass.SetUpICardEffect("Opponent's 1 Digimon can't unsuspend and suspend 1 Digimon", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+            cardEffects.Add(activateClass);
+
+            string EffectDiscription()
+            {
+                return "[When Digivolving] 1 of your opponent's Digimon can't unsuspend until the end of their turn. If [Togemon] or [X Antibody] is in this Digimon's digivolution cards, suspend 1 of your opponent's Digimon.";
+            }
+
+            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 (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            IEnumerator ActivateCoroutine(Hashtable _hashtable)
+            {
+                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                {
+                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectPermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: maxCount,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: SelectPermanentCoroutine,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Custom,
+                        cardEffect: activateClass);
+
+                    selectPermanentEffect.SetUpCustomMessage(
+                      "Select 1 Digimon that will get unable to unsuspend.",
+                      "The opponent is selecting 1 Digimon that will get unable to unsuspend.");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    {
+                        Permanent selectedPermanent = permanent;
+
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCantUnsuspendUntilOpponentTurnEnd(
+                            targetPermanent: selectedPermanent,
+                            activateClass: activateClass
+                        ));
+                    }
+                }
+
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) => cardSource.CardNames.Contains("Togemon") || cardSource.CardNames.Contains("X Antibody") || cardSource.CardNames.Contains("XAntibody")) >= 1)
+                    {
+                        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: null,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Tap,
+                                cardEffect: activateClass);
+
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                        }
+                    }
+                }
+            }
+        }
+        #endregion
+
+        #region Inherited Effect
+        if (timing == EffectTiming.None)
+        {
+            int count()
+            {
+                return card.Owner.Enemy.GetBattleAreaDigimons().Count(permanent => permanent.IsSuspended);
+            }
+
+            bool Condition()
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (CardEffectCommons.IsOwnerTurn(card))
+                    {
+                        if (count() >= 1)
+                        {
+                            return true;
+                        }
+                    }
+                }
+
+                return false;
+            }
+
+            cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect<Func<int>>(
+                changeValue: () => 1000 * count(),
+                isInheritedEffect: true,
+                card: card,
+                condition: Condition));
+        }
+        #endregion
+
+        return cardEffects;
+  }
+}

Assets/CardEffect/BT15/Green/Woodmon_BT15_046.cs

@@ -22,7 +22,7 @@ public class Woodmon_BT15_046 : CEntity_Effect
 
       string EffectDiscription()
       {
-        return "[Opponent's Turn][Once Per Turn] When one of your Digimon becomes suspended, trash the top card of your opponent's security stack.";
+        return "[Your Turn] [Once Per Turn] When one of your Digimon becomes suspended, <Draw 1>.";
       }
 
       bool PermanentCondition(Permanent permanent)

Assets/CardEffect/BT15/White.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: fa23aaa59a1ea764397e976ec230c45d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CardEffect/BT15/White/Apocalymon_BT15_102.cs

@@ -0,0 +1,520 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.Linq;
+using Photon;
+using System;
+using Photon.Pun;
+
+public class Apocalymon_BT15_102 : CEntity_Effect
+{
+    public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+    {
+        List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+        #region Before Pay Cost
+        if (timing == EffectTiming.BeforePayCost)
+        {
+            ActivateClass activateClass = new ActivateClass();
+            activateClass.SetUpICardEffect("Placing 1 [Dark Masters] to get Play Cost -4", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+            activateClass.SetHashString("PlayCost-12_BT15_102");
+            cardEffects.Add(activateClass);
+
+            string EffectDiscription()
+            {
+                return "When this card would be played, by placing up to 3 [Dark Masters] trait cards with different names from your battle area or trash under it, reduce the play cost by 4 for each one.";
+            }
+
+            bool CanSelectCardCondition(CardSource cardSource)
+            {
+                if (cardSource.IsDigimon)
+                {
+                    if (cardSource.CardTraits.Contains("Dark Masters") || cardSource.CardTraits.Contains("DarkMasters"))
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            bool CardCondition(CardSource cardSource)
+            {
+                if (cardSource == card)
+                {
+                    if (CardEffectCommons.IsExistOnHand(cardSource))
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            bool CanUseCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.CanTriggerWhenPermanentWouldPlay(hashtable, CardCondition))
+                {
+                    return true;
+                }
+
+                return false;
+            }
+
+            bool CanActivateCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            IEnumerator ActivateCoroutine(Hashtable _hashtable)
+            {
+                    int digivolutionCardsCount = 0;
+
+                    List<CardSource> digivolutionCards = new List<CardSource>();
+
+                    bool CanSelectCardCondition1(CardSource cardSource)
+                    {
+                        if (CanSelectCardCondition(cardSource))
+                        {
+                            if (digivolutionCards.Count((cardSource1) => cardSource1.CardID == cardSource.CardID) == 0)
+                            {
+                                return true;
+                            }
+                        }
+
+                        return false;
+                    }
+
+                if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, (cardSource) => CanSelectCardCondition1(cardSource)))
+                {
+                    List<CardSource> selectedCards = new List<CardSource>();
+
+                    int maxCount = Math.Min(3 - digivolutionCards.Count, card.Owner.TrashCards.Count((cardSource) => CanSelectCardCondition1(cardSource)));
+
+                    if (maxCount >= 1)
+                    {
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                        selectCardEffect.SetUp(
+                            canTargetCondition: CanSelectCardCondition1,
+                            canTargetCondition_ByPreSelecetedList: CanTargetCondition_ByPreSelecetedList,
+                            canEndSelectCondition: CanEndSelectCondition,
+                            canNoSelect: () => true,
+                            selectCardCoroutine: SelectCardCoroutine,
+                            afterSelectCardCoroutine: null,
+                            message: "Select cards to place in Digivolution cards.",
+                            maxCount: maxCount,
+                            canEndNotMax: true,
+                            isShowOpponent: true,
+                            mode: SelectCardEffect.Mode.Custom,
+                            root: SelectCardEffect.Root.Trash,
+                            customRootCardList: null,
+                            canLookReverseCard: true,
+                            selectPlayer: card.Owner,
+                            cardEffect: activateClass);
+
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                        bool CanTargetCondition_ByPreSelecetedList(List<CardSource> cardSources, CardSource cardSource)
+                        {
+                            List<string> cardIDs = new List<string>();
+
+                            foreach (CardSource cardSource1 in cardSources)
+                            {
+                                if (!cardIDs.Contains(cardSource1.CardID))
+                                {
+                                    cardIDs.Add(cardSource1.CardID);
+                                }
+                            }
+
+                            foreach (CardSource cardSource1 in digivolutionCards)
+                            {
+                                if (!cardIDs.Contains(cardSource1.CardID))
+                                {
+                                    cardIDs.Add(cardSource1.CardID);
+                                }
+                            }
+
+                            if (cardIDs.Contains(cardSource.CardID))
+                            {
+                                return false;
+                            }
+
+                            return true;
+                        }
+
+                        bool CanEndSelectCondition(List<CardSource> cardSources)
+                        {
+                            List<string> cardIDs = new List<string>();
+
+                            foreach (CardSource cardSource1 in cardSources)
+                            {
+                                if (!cardIDs.Contains(cardSource1.CardID))
+                                {
+                                    cardIDs.Add(cardSource1.CardID);
+                                }
+                            }
+
+                            foreach (CardSource cardSource1 in digivolutionCards)
+                            {
+                                if (!cardIDs.Contains(cardSource1.CardID))
+                                {
+                                    cardIDs.Add(cardSource1.CardID);
+                                }
+                            }
+
+                            if (cardIDs.Count != cardSources.Count + digivolutionCards.Count)
+                            {
+                                return false;
+                            }
+
+                            return true;
+                        }
+
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            selectedCards.Add(cardSource);
+                            digivolutionCards.Add(cardSource);
+                            yield return null;
+                        }
+
+                        if (selectedCards.Count >= 1)
+                        {
+                            foreach (CardSource selectedCard in selectedCards)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(CardObjectController.RemoveFromAllArea(selectedCard));
+                            }
+
+                            yield return StartCoroutine(AfterSelectCardCoroutine(selectedCards));
+                        }
+                    }
+                }
+
+                IEnumerator AfterSelectCardCoroutine(List<CardSource> cardSources)
+                {
+                    if (card.Owner.CanReduceCost(null, card))
+                    {
+                        ContinuousController.instance.PlaySE(GManager.instance.GetComponent<Effects>().BuffSE);
+                    }
+
+                    ChangeCostClass changeCostClass = new ChangeCostClass();
+                    changeCostClass.SetUpICardEffect("Play Cost -4", CanUseCondition1, card);
+                    changeCostClass.SetUpChangeCostClass(changeCostFunc: ChangeCost, cardSourceCondition: CardSourceCondition, rootCondition: RootCondition, isUpDown: isUpDown, isCheckAvailability: () => false, isChangePayingCost: () => true);
+                    card.Owner.UntilCalculateFixedCostEffect.Add((_timing) => changeCostClass);
+
+                    bool CanUseCondition1(Hashtable hashtable)
+                    {
+                        return true;
+                    }
+
+                    int ChangeCost(CardSource cardSource, int Cost, SelectCardEffect.Root root, List<Permanent> targetPermanents)
+                    {
+                        if (CardSourceCondition(cardSource))
+                        {
+                            if (RootCondition(root))
+                            {
+                                if (PermanentsCondition(targetPermanents))
+                                {
+                                    Cost -= cardSources.Count * 4;
+                                }
+                            }
+                        }
+
+                        return Cost;
+                    }
+
+                    bool PermanentsCondition(List<Permanent> targetPermanents)
+                    {
+                        if (targetPermanents == null)
+                        {
+                            return true;
+                        }
+
+                        else
+                        {
+                            if (targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0)
+                            {
+                                return true;
+                            }
+                        }
+
+                        return false;
+                    }
+
+                    bool CardSourceCondition(CardSource cardSource)
+                    {
+                        return cardSource == card;
+                    }
+
+                    bool RootCondition(SelectCardEffect.Root root)
+                    {
+                        return true;
+                    }
+
+                    bool isUpDown()
+                    {
+                        return true;
+                    }
+
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ShowReducedCost(_hashtable));
+
+                    yield return null;
+                }
+            }
+        }
+        #endregion
+
+        #region End of Your Turn
+        if (timing == EffectTiming.OnEndTurn)
+        {
+            ActivateClass activateClass = new ActivateClass();
+            activateClass.SetUpICardEffect("Place 1 digimon from trash under this Digimon's digivolution cards", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+            cardEffects.Add(activateClass);
+
+            string EffectDiscription()
+            {
+                return "[End of Your Turn] [Once Per Turn] By placing 1 level 6 or lower card from your trash as this Digimon's bottom digivolution card, activate 1 [On Play] effect on that card as an effect. Then, trash the top 2 cards of your opponent's deck for each of this Digimon's level 6 digivolution cards.";
+            }
+
+            bool CanSelectCardCondition(CardSource cardSource)
+            {
+                if (cardSource.IsDigimon)
+                {
+                    if (cardSource.HasLevel)
+                    {
+                        if(cardSource.Level == 6)
+                        {
+                            return true;
+                        }
+                    }
+                }
+
+                return false;
+            }
+
+            bool CanUseCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (CardEffectCommons.IsOwnerTurn(card))
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            bool CanActivateCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            IEnumerator ActivateCoroutine(Hashtable _hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    bool canSelectTrash = CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition);
+
+                    if (canSelectTrash)
+                    {
+                        List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                        {
+                            new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
+                        };
+
+                        string selectPlayerMessage = "From which area do you select a card?";
+                        string notSelectPlayerMessage = "The opponent is choosing from which area to select a card.";
+
+                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                    }
+
+                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                    bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+                    List<CardSource> selectedCards = new List<CardSource>();
+
+                    IEnumerator SelectCardCoroutine(CardSource cardSource)
+                    {
+                        selectedCards.Add(cardSource);
+
+                        yield return null;
+                    }
+
+                    if (fromHand)
+                    {
+                        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 bottom of digivolution cards.",
+                            "The opponent is selecting 1 card to place on bottom of digivolution cards.");
+                        selectHandEffect.SetUpCustomMessage_ShowCard("Digivolution Card");
+
+                        yield return StartCoroutine(selectHandEffect.Activate());
+                    }
+
+                    else
+                    {
+                        int maxCount = 1;
+
+                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                        selectCardEffect.SetUp(
+                            canTargetCondition: CanSelectCardCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            canNoSelect: () => true,
+                            selectCardCoroutine: SelectCardCoroutine,
+                            afterSelectCardCoroutine: null,
+                            message: "Select 1 card to place on bottom of digivolution cards.",
+                            maxCount: maxCount,
+                            canEndNotMax: false,
+                            isShowOpponent: true,
+                            mode: SelectCardEffect.Mode.Custom,
+                            root: SelectCardEffect.Root.Trash,
+                            customRootCardList: null,
+                            canLookReverseCard: true,
+                            selectPlayer: card.Owner,
+                            cardEffect: activateClass);
+
+                        selectCardEffect.SetUpCustomMessage(
+                            "Select 1 card to place on bottom of digivolution cards.",
+                            "The opponent is selecting 1 card to place on bottom of digivolution cards.");
+                        selectCardEffect.SetUpCustomMessage_ShowCard("Digivolution Card");
+
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+                    }
+
+                    CardSource selectedCard = null;
+
+                    if (selectedCards.Count >= 1)
+                    {
+                        if (CardEffectCommons.IsExistOnBattleArea(card))
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(
+                                selectedCards,
+                                activateClass));
+
+                            selectedCard = selectedCards[0];
+                        }
+                    }
+
+                    if (selectedCard != null)
+                    {
+                        List<ICardEffect> candidateEffects = selectedCard.EffectList_ForCard(EffectTiming.OnEnterFieldAnyone, card)
+                            .Clone()
+                            .Filter(cardEffect => cardEffect != null && cardEffect is ActivateICardEffect && !cardEffect.IsSecurityEffect && cardEffect.IsOnPlay);
+
+                        if (candidateEffects.Count >= 1)
+                        {
+                            ICardEffect selectedEffect = null;
+
+                            if (candidateEffects.Count == 1)
+                            {
+                                selectedEffect = candidateEffects[0];
+                            }
+
+                            else
+                            {
+                                List<SkillInfo> skillInfos = candidateEffects
+                                    .Map(cardEffect => new SkillInfo(cardEffect, null, EffectTiming.None));
+
+                                List<CardSource> cardSources = candidateEffects
+                                    .Map(cardEffect => cardEffect.EffectSourceCard);
+
+                                SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                                selectCardEffect.SetUp(
+                                    canTargetCondition: (cardSource) => true,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    canNoSelect: () => false,
+                                    selectCardCoroutine: null,
+                                    afterSelectCardCoroutine: null,
+                                    message: "Select 1 effect to activate.",
+                                    maxCount: 1,
+                                    canEndNotMax: false,
+                                    isShowOpponent: false,
+                                    mode: SelectCardEffect.Mode.Custom,
+                                    root: SelectCardEffect.Root.Custom,
+                                    customRootCardList: cardSources,
+                                    canLookReverseCard: true,
+                                    selectPlayer: card.Owner,
+                                    cardEffect: activateClass);
+
+                                selectCardEffect.SetNotShowCard();
+                                selectCardEffect.SetUpSkillInfos(skillInfos);
+                                selectCardEffect.SetUpAfterSelectIndexCoroutine(AfterSelectIndexCoroutine);
+
+                                yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                                IEnumerator AfterSelectIndexCoroutine(List<int> selectedIndexes)
+                                {
+                                    if (selectedIndexes.Count == 1)
+                                    {
+                                        selectedEffect = candidateEffects[selectedIndexes[0]];
+                                        yield return null;
+                                    }
+                                }
+                            }
+
+                            if (selectedEffect != null)
+                            {
+                                Hashtable effectHashtable = CardEffectCommons.OnPlayCheckHashtableOfCard(card);
+
+                                if (selectedEffect.CanUse(effectHashtable))
+                                {
+                                    yield return ContinuousController.instance.StartCoroutine(
+                                        ((ActivateICardEffect)selectedEffect).Activate_Optional_Effect_Execute(effectHashtable));
+                                }
+                            }
+                        }
+                    }
+                }
+
+                int trashCount = 2 * card.PermanentOfThisCard().cardSources.Count;
+
+                yield return ContinuousController.instance.StartCoroutine(new IAddTrashCardsFromLibraryTop(trashCount, card.Owner.Enemy, activateClass).AddTrashCardsFromLibraryTop());
+            }
+        }
+        #endregion
+
+        return cardEffects;
+    }
+}

Assets/CardEffect/BT15/White/Apocalymon_BT15_102.cs.meta

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