BT15 Yellow Cards added

Assets/AddOn/GlitchFx-master/GlitchFx.unitypackage.meta

@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: d80f995af690a474e841364c1e88ee1b
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/CardEffect/BT15/Yellow/AngewomonAce_BT15_038.cs → Assets/CardEffect/BT15/Yellow/Angewomon_ACE_BT15_038.cs

@@ -5,7 +5,7 @@ using System.Linq;
 using Photon;
 using System;
 using Photon.Pun;
-public class AngewomonAce_BT15_038 : CEntity_Effect
+public class Angewomon_ACE_BT15_038 : CEntity_Effect
 {
   public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
   {
@@ -25,7 +25,7 @@ public class AngewomonAce_BT15_038 : CEntity_Effect
 
       string EffectDiscription()
       {
-        return "[On Play] You may trash the top card of your security stack to unsuspend this Digimon.";
+        return "[On Play] By trashing the top or bottom card of your security stack, 1 of your opponent's Digimon gets -6000 DP until the end of your opponent's turn.";
       }
 
       bool CanSelectPermanentCondition(Permanent permanent)
@@ -69,7 +69,7 @@ public class AngewomonAce_BT15_038 : CEntity_Effect
           yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
           bool fromTop = GManager.instance.userSelectionManager.SelectedBoolValue;
-
+  
           yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
                   card.Owner,
                   1,
@@ -123,7 +123,7 @@ public class AngewomonAce_BT15_038 : CEntity_Effect
 
       string EffectDiscription()
       {
-        return "[When Digivolving] You may trash the top card of your security stack to unsuspend this Digimon.";
+        return "[On Play] By trashing the top or bottom card of your security stack, 1 of your opponent's Digimon gets -6000 DP until the end of your opponent's turn.";
       }
 
       bool CanSelectPermanentCondition(Permanent permanent)

Assets/CardEffect/BT15/Yellow/Bombermon_BT15_039.cs

@@ -30,7 +30,7 @@ public class Bombermon_BT15_039 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[On Play] Delete 1 of your opponent's Digimon with <Blocker>.";
+                return "[On Play] 1 of your opponent's Digimon gets -3000 DP and [On Deletion] Lose 1 memory, until the end of your opponent's turn.";
             }
 
             bool CanSelectPermanentCondition(Permanent permanent)
@@ -157,7 +157,7 @@ public class Bombermon_BT15_039 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[On Play] Delete 1 of your opponent's Digimon with <Blocker>.";
+                return "[When Digivolving] 1 of your opponent's Digimon gets -3000 DP and [On Deletion] Lose 1 memory, until the end of your opponent's turn.";
             }
 
             bool CanSelectPermanentCondition(Permanent permanent)

Assets/CardEffect/BT15/Yellow/Tailmon_BT15_037.cs → Assets/CardEffect/BT15/Yellow/Gatomon_BT15_037.cs

@@ -1,35 +1,43 @@
 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
-
-public class Tailmon_BT15_037 : CEntity_Effect
+using System.Linq;
+using Photon;
+using System;
+using Photon.Pun;
+public class Gatomon_BT15_037 : CEntity_Effect
 {
     public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
     {
         List<ICardEffect> cardEffects = new List<ICardEffect>();
 
-        if (timing == EffectTiming.OnDiscardSecurity)
+        if (timing == EffectTiming.WhenPermanentWouldBeDeleted)
+        {
+            cardEffects.Add(CardEffectFactory.BarrierSelfEffect(isInheritedEffect: false, card: card, condition: null));
+        }
+
+        if(timing == EffectTiming.WhenPermanentWouldBeDeleted)
+        {
+            cardEffects.Add(CardEffectFactory.BarrierSelfEffect(isInheritedEffect: true, card: card, condition: null));
+        }
+
+        if(timing == EffectTiming.OnLoseSecurity)
         {
             ActivateClass activateClass = new ActivateClass();
-            activateClass.SetUpICardEffect("Play this card", CanUseCondition, card);
-            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+            activateClass.SetUpICardEffect("Gain 1 memory.", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
             cardEffects.Add(activateClass);
 
             string EffectDiscription()
             {
-                return "When an effect trashes this card from the security stack, you may play this card without paying the cost.";
+                return "[All Turns][Once per turn] When a card is removed from your security stack, gain 1 memory.";
             }
 
             bool CanUseCondition(Hashtable hashtable)
             {
-                return CardEffectCommons.CanTriggerOnTrashSelfSecurity(hashtable, cardEffect => cardEffect != null, card);
-            }
-
-            bool CanActivateCondition(Hashtable hashtable)
-            {
-                if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: card, payCost: false, cardEffect: activateClass))
+                if (CardEffectCommons.IsExistOnBattleArea(card))
                 {
-                    if (CardEffectCommons.IsExistOnTrash(card))
+                    if (CardEffectCommons.CanTriggerWhenLoseSecurity(hashtable, player => player == card.Owner))
                     {
                         return true;
                     }
@@ -38,64 +46,52 @@ public class Tailmon_BT15_037 : CEntity_Effect
                 return false;
             }
 
-            IEnumerator ActivateCoroutine(Hashtable _hashtable)
+            bool CanActivateCondition(Hashtable hashtable)
             {
-                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: new List<CardSource>() { card }, activateClass: activateClass, payCost: false, isTapped: false, root: SelectCardEffect.Root.Trash, activateETB: true));
+                if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                {
+                    return true;
+                }
+                return false;
             }
-        }
 
-        if (timing == EffectTiming.WhenPermanentWouldBeDeleted)
-        {
-            cardEffects.Add(CardEffectFactory.BarrierSelfEffect(isInheritedEffect: false, card: card, condition: null));
+            IEnumerator ActivateCoroutine(Hashtable _hashtable)
+            { 
+                yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(1, activateClass));
+            }
         }
 
-        if (timing == EffectTiming.OnLoseSecurity)
+        if (timing == EffectTiming.OnDiscardSecurity)
         {
             ActivateClass activateClass = new ActivateClass();
-            activateClass.SetUpICardEffect("Memory +1", CanUseCondition, card);
-            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
-            activateClass.SetHashString("Memory+1_BT15_037");
+            activateClass.SetUpICardEffect("Play this card without paying the cost", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
             cardEffects.Add(activateClass);
 
             string EffectDiscription()
             {
-                return "[Your Turn][Once Per Turn] When a card is removed from your security stack, gain 1 memory.";
+                return "When an effect trashes this card from your security stack, you may play this card without paying the cost.";
             }
 
             bool CanUseCondition(Hashtable hashtable)
             {
-                if (CardEffectCommons.IsExistOnBattleArea(card))
-                {
-                    if (CardEffectCommons.CanTriggerWhenLoseSecurity(hashtable, player => player == card.Owner))
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
+                return CardEffectCommons.CanTriggerOnTrashSelfSecurity(hashtable, cardEffect => cardEffect != null, card);
             }
 
             bool CanActivateCondition(Hashtable hashtable)
             {
-                if (CardEffectCommons.IsExistOnBattleArea(card))
-                {
-                    return true;
-                }
-
-                return false;
+                return CardEffectCommons.IsExistOnTrash(card);
             }
 
             IEnumerator ActivateCoroutine(Hashtable _hashtable)
             {
-                yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(1, activateClass));
+                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: new List<CardSource>() { card }, activateClass: activateClass, payCost: false, isTapped: false, root: SelectCardEffect.Root.Execution, activateETB: true));
             }
-        }
 
-        if (timing == EffectTiming.WhenPermanentWouldBeDeleted)
-        {
-            cardEffects.Add(CardEffectFactory.BarrierSelfEffect(isInheritedEffect: true, card: card, condition: null));
-        }
+        }    
 
         return cardEffects;
     }
+
+
 }

Assets/CardEffect/BT15/Yellow/Wizzarmon_BT15_036.cs.meta → Assets/CardEffect/BT15/Yellow/Gatomon_BT15_037.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: b5d902ff124cd8843b40d39a01d6eb8a
+guid: 5677908846a375245acf37e46137cb5f
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/CardEffect/BT15/Yellow/Geremon_BT15_035.cs

@@ -44,7 +44,7 @@ public class Geremon_BT15_035 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[On Play] You may trash 1 Digimon card with [Machine] or [Cyborg] in its traits in your hand to ?¿½?¿½Draw 2?¿½?¿½. (Draw 2 cards from your deck.)";
+                return "[On Play] By trashing 1 card with [Numemon] or [Sukamon] in its name in your hand, 1 of your opponent's Digimon gains [Security A. -1] until the end of your opponent's turn.";
             }
 
             bool CanSelectCardCondition(CardSource cardSource)
@@ -171,7 +171,7 @@ public class Geremon_BT15_035 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[On Play] You may trash 1 Digimon card with [Machine] or [Cyborg] in its traits in your hand to ?¿½?¿½Draw 2?¿½?¿½. (Draw 2 cards from your deck.)";
+                return "[On Deletion] By trashing 1 card with [Numemon] or [Sukamon] in its name in your hand, 1 of your opponent's Digimon gains [Security A. -1] until the end of your opponent's turn.";
             }
 
             bool CanSelectCardCondition(CardSource cardSource)
@@ -289,7 +289,7 @@ public class Geremon_BT15_035 : CEntity_Effect
             }
         }
 
-        if (timing == EffectTiming.OnDestroyedAnyone)
+        if (timing == EffectTiming.OnAllyAttack)
         {
             ActivateClass activateClass = new ActivateClass();
             activateClass.SetUpICardEffect("Security Attack -1", CanUseCondition, card);
@@ -299,7 +299,7 @@ public class Geremon_BT15_035 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[On Deletion] Gain 1 memory.";
+                return "[When Attacking] 1 of your opponent's Digimon gains [Security A. -1] until the end of your opponent's turn.";
             }
 
             bool CanSelectPermanentCondition(Permanent permanent)
@@ -309,7 +309,7 @@ public class Geremon_BT15_035 : CEntity_Effect
 
             bool CanUseCondition(Hashtable hashtable)
             {
-                return CardEffectCommons.CanTriggerOnDeletion(hashtable, card);
+                return CardEffectCommons.CanTriggerOnAttack(hashtable, card);
             }
 
             bool CanActivateCondition(Hashtable hashtable)

Assets/CardEffect/BT15/Yellow/Monzaemon_X_Antibody_BT15_040.cs

@@ -0,0 +1,146 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.Linq;
+using Photon;
+using System;
+using Photon.Pun;
+
+public class Monzaemon_X_Antibody_BT15_040 : CEntity_Effect
+{
+    public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+    {
+        List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+        if (timing == EffectTiming.OnEnterFieldAnyone)
+        {
+            ActivateClass activateClass = new ActivateClass();
+            activateClass.SetUpICardEffect("Play 1 Numemon or level 3 from your hand.", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+            cardEffects.Add(activateClass);
+
+            string EffectDiscription()
+            {
+                return "[When Digivolving] If this Digimon has a card with [Monzaemon] in it's name or [X-Antibody] in it's digivolution cards, you may play 1 level 3 Digimon card from your hand without paying the cost.";
+            }
+
+            bool CanSelectCardCondition(CardSource cardSource)
+            {
+                if (cardSource.CardNames.Contains("Numemon") || cardSource.HasLevel && cardSource.Level <=3)
+                {
+                    if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass))
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            bool CanUseCondition(Hashtable hashtable)
+            {
+                return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+            }
+
+            bool CanActivateCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (card.Owner.HandCards.Count >= 1)
+                    {
+                        if (card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) => cardSource.CardNames.Contains("Monzaemon") || cardSource.CardNames.Contains("X Antibody") || cardSource.CardNames.Contains("XAntibody")) >= 1)
+                        {
+                            return true;
+                        }
+                    }
+                }
+
+                return false;
+            }
+
+            IEnumerator ActivateCoroutine(Hashtable _hashtable)
+            {
+                if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
+                {
+                    List<CardSource> selectedCards = new List<CardSource>();
+
+                    int maxCount = 1;
+
+                    SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                    selectHandEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectCardCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: maxCount,
+                        canNoSelect: true,
+                        canEndNotMax: false,
+                        isShowOpponent: true,
+                        selectCardCoroutine: SelectCardCoroutine,
+                        afterSelectCardCoroutine: null,
+                        mode: SelectHandEffect.Mode.Custom,
+                        cardEffect: activateClass);
+
+                    selectHandEffect.SetUpCustomMessage("Select 1 card to play.", "The opponent is selecting 1 card to play.");
+                    selectHandEffect.SetUpCustomMessage_ShowCard("Played Card");
+
+                    yield return StartCoroutine(selectHandEffect.Activate());
+
+                    IEnumerator SelectCardCoroutine(CardSource cardSource)
+                    {
+                        selectedCards.Add(cardSource);
+
+                        yield return null;
+                    }
+
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: selectedCards, activateClass: activateClass, payCost: false, isTapped: false, root: SelectCardEffect.Root.Hand, activateETB: true));
+                }
+            }
+        }
+        /*
+        if(timing == EffectTiming.OnEnterFieldAnyone)
+        {
+            ActivateClass activateClass = new ActivateClass();
+            activateClass.SetUpICardEffect("Give opponent's Digimon -2000 DP for each Digimon", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
+            cardEffects.Add(activateClass);
+
+            string EffectDiscription()
+            {
+                return "[All Turns][Once per turn] When another of your Digimon is played, for each of your Digimon, 1 of your opponent's Digimon gets -2000 DP unti the end of your opponent's turn";
+            }
+
+            bool PermanentCondition(Permanent permanent)
+            {
+                if (CardEffectCommons.IsPermanentExistsOnBattleArea(permanent))
+                {
+                    if (permanent.IsDigimon)
+                    {
+                        if (permanent != card.PermanentOfThisCard())
+                        {
+                            return true;
+                        }
+                    }
+                }
+
+                return false;
+            }
+
+            bool CanSelectPermanentCondition(Permanent permanent)
+            {
+                if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
+                {
+                    return true;
+                }
+
+                return false;
+            }
+
+        }
+        */
+
+        return cardEffects;
+    }
+
+}

Assets/CardEffect/BT15/Yellow/Tailmon_BT15_037.cs.meta → Assets/CardEffect/BT15/Yellow/Monzaemon_X_Antibody_BT15_040.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: f2f58a6750997504ab0ba828c8f6b57d
+guid: 693f1d75cce5caa4eafc8d166ff71aad
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/CardEffect/BT15/Yellow/Nyaromon_BT15_003.cs

@@ -22,7 +22,7 @@ public class Nyaromon_BT15_003 : CEntity_Effect
 
             string EffectDiscription()
             {
-                return "[When Attacking][Once Per Turn] If this Digimon has [Unidentified] in its type, trigger <Draw 1>. (Draw 1 card from your deck.)";
+                return "[When Attacking][Once Per Turn] By trashing the top or bottom card of your security stack, gain 1 memory.";
             }
 
             bool CanUseCondition(Hashtable hashtable)

Assets/CardEffect/BT15/Yellow/Salamon_BT15_034.cs

@@ -0,0 +1,265 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.Linq;
+using Photon;
+using System;
+using Photon.Pun;
+
+public class Salamon_BT15_034 : CEntity_Effect
+{
+    public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+    {
+        List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+        if(timing == EffectTiming.OnLoseSecurity)
+        {
+            ActivateClass activateClass = new ActivateClass();
+            activateClass.SetUpICardEffect("Give an opponent's Digimon card -2000 DP.", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+            activateClass.SetIsInheritedEffect(true);
+            cardEffects.Add(activateClass);
+
+            string EffectDiscription()
+            {
+                return "[All Turns][Once per turn] When a card is removed from your security stack, 1 of your opponents Digimon gets -2000 DP for the turn.";
+            }
+
+            bool CanActivateCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    return true;
+                }
+                return false;
+            }
+
+            bool CanUseCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (CardEffectCommons.CanTriggerWhenLoseSecurity(hashtable, player => player == card.Owner))
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            bool CanSelectPermanentCondition(Permanent permanent)
+            {
+                return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+            }
+
+
+            IEnumerator ActivateCoroutine(Hashtable _hashtable)
+            {
+                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                {
+                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
+                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectPermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectPermanentCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: maxCount,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: SelectPermanentCoroutine,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Custom,
+                        cardEffect: activateClass);
+
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will get DP -2000.", "The opponent is selecting 1 Digimon that will get DP -2000.");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: permanent, changeValue: -2000, effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
+                    }
+                }
+            }
+
+        }
+
+        if (timing == EffectTiming.OnStartMainPhase)
+        {
+            ActivateClass activateClass = new ActivateClass();
+            activateClass.SetUpICardEffect("Add top card of security to hand or place a yellow Digimon with the [Vaccine] trait at the top or bottom of security.", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+            cardEffects.Add(activateClass);
+
+            string EffectDiscription()
+            {
+                return "[Start of Your Main Phase] If you have 3 or more security cards you may add the top card of your security stack to the hand. If you have 2 or fewer security cards, you may place 1 yellow card with the [Vaccine] trait from your hand at the top or bottom of your security stack.";
+            }
+
+            bool CanSelectCardCondition(CardSource cardSource)
+            {
+                if (cardSource.IsDigimon)
+                {
+                    if (cardSource.ContainsTraits("Vaccine"))
+                    {
+                        if (cardSource.CardColors.Contains(CardColor.Yellow))
+                        {
+                            return true;
+                        }
+                    }
+                }
+
+                return false;
+            }
+
+            bool CanActivateCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (card.Owner.SecurityCards.Count >= 3)
+                    {
+                        return true;
+                    }
+                }
+
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (card.Owner.SecurityCards.Count <= 2)
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            bool CanUseCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleArea(card))
+                {
+                    if (CardEffectCommons.IsOwnerTurn(card))
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            IEnumerator ActivateCoroutine(Hashtable _hashtable)
+            {
+                if (card.Owner.SecurityCards.Count >= 3)
+                {
+                    CardSource topCard = card.Owner.SecurityCards[0];
+
+                    yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddHandCards(new List<CardSource>() { topCard }, false, activateClass));
+
+                    yield return ContinuousController.instance.StartCoroutine(new IReduceSecurity(
+                        player: card.Owner,
+                        refSkillInfos: ref ContinuousController.instance.nullSkillInfos).ReduceSecurity());
+                }
+
+                if (card.Owner.SecurityCards.Count <= 2)
+                {
+                    if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
+                    {
+                        List<CardSource> selectedCard = new List<CardSource>();
+
+                        int maxCount = 1;
+
+                        SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                        selectHandEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectCardCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            isShowOpponent: true,
+                            selectCardCoroutine: SelectCardCoroutine,
+                            afterSelectCardCoroutine: null,
+                            mode: SelectHandEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        selectHandEffect.SetUpCustomMessage(
+                            "Select 1 card to place at the top or bottom of security.",
+                            "The opponent is selecting 1 card to place at the bottom of security.");
+                        selectHandEffect.SetUpCustomMessage_ShowCard("Security Bottom Card");
+
+                        yield return StartCoroutine(selectHandEffect.Activate());
+
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            if (selectedCard != null)
+                            {
+                                List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                                {
+                                    new SelectionElement<bool>(message: $"Security Top", value : true, spriteIndex: 0),
+                                    new SelectionElement<bool>(message: $"Security Bottom", value : false, spriteIndex: 1),
+                                };
+
+                                string selectPlayerMessage = "Will you place the card on the top or bottom of the security?";
+                                string notSelectPlayerMessage = "The opponent is selecting whether to place the card on the top or bottom of security.";
+
+                                GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+
+                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                                bool toTop = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+                                if (toTop)
+                                {
+                                    GManager.instance.commandText.OpenCommandText("\"Place to the top of security\" was selected.");
+
+                                    GManager.instance.playLog.AddLogString($"\n{card.BaseENGCardNameFromEntity}({card.CardID}):Place the Digimon to the top of security\n");
+                                }
+
+                                else
+                                {
+                                    GManager.instance.commandText.OpenCommandText("\"Place to the bottom of security\" was selected.");
+
+                                    GManager.instance.playLog.AddLogString($"\n{card.BaseENGCardNameFromEntity}({card.CardID}):Place the Digimon to the bottom of security\n");
+                                }
+
+                                yield return new WaitForSeconds(0.4f);
+                                GManager.instance.commandText.CloseCommandText();
+                                yield return new WaitWhile(() => GManager.instance.commandText.gameObject.activeSelf);
+
+                                selectedCard.Add(cardSource);
+
+                                yield return null;
+
+                                foreach (CardSource card in selectedCard)
+                                {
+                                    if (toTop)
+                                    {
+                                        yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(card, toTop: true));
+                                    }
+                                    
+                                    if(!toTop)
+                                    {
+                                        yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(card, toTop: false));
+                                    }
+                                    
+                                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(card.Owner));
+
+                                    yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(card.Owner).AddSecurity());
+                                }
+                            }
+
+                        }
+
+                    }
+
+                }
+            }
+
+        }
+
+            return cardEffects;
+    }
+}

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

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

Assets/CardEffect/BT15/Yellow/Tapirmon_BT15_033.cs

@@ -0,0 +1,21 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.Linq;
+using Photon;
+using System;
+using Photon.Pun;
+public class Tapirmon_BT15_033 : CEntity_Effect
+{
+    public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+    {
+        List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+        if (timing == EffectTiming.WhenPermanentWouldBeDeleted)
+        {
+            cardEffects.Add(CardEffectFactory.BarrierSelfEffect(isInheritedEffect: false, card: card, condition: null));
+        }
+
+        return cardEffects; 
+    }
+}

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

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

Assets/CardEffect/BT15/Yellow/Wizardmon_BT15_036.cs

@@ -0,0 +1,228 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.Linq;
+using Photon;
+using System;
+using Photon.Pun;
+
+
+public class Wizardmon_BT15_036 : CEntity_Effect
+{
+    public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+    {
+        List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+        if (timing == EffectTiming.None)
+        {
+            cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(isInheritedEffect: false, card: card, condition: null));
+        }
+
+        if (timing == EffectTiming.OnDestroyedAnyone)
+        {
+            ActivateClass activateClass = new ActivateClass();
+            activateClass.SetUpICardEffect("Trash a security to give opponent's Digimon -6000 DP.", CanUseCondition, card);
+            activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+            cardEffects.Add(activateClass);
+
+            string EffectDiscription()
+            {
+                return "[On Deletion] By trashing the top or bottom card of your security stack, 1 of your opponent's Digimon gets -6000 DP until the end of the opponent's turn.";
+            }
+
+            bool CanActivateCondition(Hashtable hashtable)
+            {
+                if (CardEffectCommons.CanActivateOnDeletion(card))
+                {
+                    if (card.Owner.SecurityCards.Count >= 1)
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            bool CanUseCondition(Hashtable hashtable)
+            {
+                return CardEffectCommons.CanTriggerOnDeletion(hashtable, card);
+            }
+
+            bool CanSelectPermanent(Permanent permanent)
+            {
+                if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
+                {
+                    return true;
+                }
+                return false;
+            }
+
+            IEnumerator ActivateCoroutine(Hashtable _hashtable)
+            {
+                if (card.Owner.SecurityCards.Count >= 1)
+                {
+                    List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                    {
+                        new SelectionElement<bool>(message: $"Security Top", value : true, spriteIndex: 0),
+                        new SelectionElement<bool>(message: $"Security Bottom", value : false, spriteIndex: 1),
+                    };
+
+                    string selectPlayerMessage = "Which will you trash the top or bottom card of the security?";
+                    string notSelectPlayerMessage = "The opponent is selecting whether to trash the top or bottom card of security.";
+
+                    GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+
+                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                    bool fromTop = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+                    yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
+                            card.Owner,
+                            1,
+                            activateClass,
+                            fromTop).DestroySecurity());
+
+
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanent))
+                    {
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanent));
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermanent,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will get DP -6000.", "The opponent is selecting 1 Digimon that will get DP -6000.");
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
+                                targetPermanent: permanent,
+                                changeValue: -6000,
+                                effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                                activateClass: activateClass));
+                        }
+                    }
+                }
+            }
+        }
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Trash a security to give opponent's Digimon -6000 DP.", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[On Play] By trashing the top or bottom card of your security stack, 1 of your opponent's Digimon gets -6000 DP until the end of the opponent's turn.";
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (card.Owner.SecurityCards.Count > 0)
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+
+                bool CanSelectPermanent(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
+                    {
+                        return true;
+                    }
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    if (card.Owner.SecurityCards.Count >= 1)
+                    {
+                        List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                    {
+                        new SelectionElement<bool>(message: $"Security Top", value : true, spriteIndex: 0),
+                        new SelectionElement<bool>(message: $"Security Bottom", value : false, spriteIndex: 1),
+                    };
+
+                        string selectPlayerMessage = "Which will you trash the top or bottom card of the security?";
+                        string notSelectPlayerMessage = "The opponent is selecting whether to trash the top or bottom card of security.";
+
+                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                        bool fromTop = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+                        yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
+                                card.Owner,
+                                1,
+                                activateClass,
+                                fromTop).DestroySecurity());
+
+
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanent))
+                        {
+                            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanent));
+
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectPermanent,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: SelectPermanentCoroutine,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+
+                            selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will get DP -6000.", "The opponent is selecting 1 Digimon that will get DP -6000.");
+
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                            IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
+                                    targetPermanent: permanent,
+                                    changeValue: -6000,
+                                    effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                                    activateClass: activateClass));
+                            }
+                        }
+                    }
+                }
+            
+        
+        }
+
+        return cardEffects;
+    }
+
+}

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

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

Assets/CardEffect/BT15/Yellow/Wizzarmon_BT15_036.cs

@@ -1,218 +0,0 @@
-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
-using System.Linq;
-using Photon;
-using System;
-using Photon.Pun;
-
-public class Wizzarmon_BT15_036 : CEntity_Effect
-{
-  public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
-  {
-    List<ICardEffect> cardEffects = new List<ICardEffect>();
-
-    if (timing == EffectTiming.None)
-    {
-      cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(isInheritedEffect: false, card: card, condition: null));
-    }
-
-    if (timing == EffectTiming.OnEnterFieldAnyone)
-    {
-      ActivateClass activateClass = new ActivateClass();
-      activateClass.SetUpICardEffect("Trash the top card of your security so that opponent's 1 Digimon gains DP -6000", CanUseCondition, card);
-      activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
-      cardEffects.Add(activateClass);
-
-      string EffectDiscription()
-      {
-        return "[On Play] You may trash the top card of your security stack to unsuspend this Digimon.";
-      }
-
-      bool CanSelectPermanentCondition(Permanent permanent)
-      {
-        return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
-      }
-
-      bool CanUseCondition(Hashtable hashtable)
-      {
-        return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
-      }
-
-      bool CanActivateCondition(Hashtable hashtable)
-      {
-        if (CardEffectCommons.IsExistOnBattleArea(card))
-        {
-          if (card.Owner.SecurityCards.Count >= 1)
-          {
-            return true;
-          }
-        }
-
-        return false;
-      }
-
-      IEnumerator ActivateCoroutine(Hashtable _hashtable)
-      {
-        if (card.Owner.SecurityCards.Count >= 1)
-        {
-          List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
-                    {
-                        new SelectionElement<bool>(message: $"Security Top", value : true, spriteIndex: 0),
-                        new SelectionElement<bool>(message: $"Security Bottom", value : false, spriteIndex: 1),
-                    };
-
-          string selectPlayerMessage = "Which will you trash the top or bottom card of the security?";
-          string notSelectPlayerMessage = "The opponent is selecting whether to trash the top or bottom card of security.";
-
-          GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
-
-          yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
-
-          bool fromTop = GManager.instance.userSelectionManager.SelectedBoolValue;
-
-          yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
-                  card.Owner,
-                  1,
-                  activateClass,
-                  fromTop).DestroySecurity());
-
-          if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-          {
-            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-            selectPermanentEffect.SetUp(
-                selectPlayer: card.Owner,
-                canTargetCondition: CanSelectPermanentCondition,
-                canTargetCondition_ByPreSelecetedList: null,
-                canEndSelectCondition: null,
-                maxCount: maxCount,
-                canNoSelect: false,
-                canEndNotMax: false,
-                selectPermanentCoroutine: SelectPermanentCoroutine,
-                afterSelectPermanentCoroutine: null,
-                mode: SelectPermanentEffect.Mode.Custom,
-                cardEffect: activateClass);
-
-            selectPermanentEffect.SetUpCustomMessage(
-                "Select 1 Digimon that will get DP -6000.",
-                "The opponent is selecting 1 Digimon that will get DP -6000.");
-
-            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-            IEnumerator SelectPermanentCoroutine(Permanent permanent)
-            {
-              yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
-                targetPermanent: permanent,
-                changeValue: -6000,
-                effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                activateClass: activateClass));
-            }
-          }
-        }
-      }
-    }
-
-    if (timing == EffectTiming.OnDestroyedAnyone)
-    {
-      ActivateClass activateClass = new ActivateClass();
-      activateClass.SetUpICardEffect("Trash the top card of your security so that opponent's 1 Digimon gains DP -6000", CanUseCondition, card);
-      activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
-      cardEffects.Add(activateClass);
-
-      string EffectDiscription()
-      {
-        return "[On Deletion] Gain 2 memory.";
-      }
-
-      bool CanSelectPermanentCondition(Permanent permanent)
-      {
-        return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
-      }
-
-      bool CanUseCondition(Hashtable hashtable)
-      {
-        return CardEffectCommons.CanTriggerOnDeletion(hashtable, card);
-      }
-
-      bool CanActivateCondition(Hashtable hashtable)
-      {
-        if (CardEffectCommons.CanActivateOnDeletion(card))
-        {
-          if (card.Owner.SecurityCards.Count >= 1)
-          {
-            return true;
-          }
-        }
-
-        return false;
-      }
-
-      IEnumerator ActivateCoroutine(Hashtable _hashtable)
-      {
-        if (card.Owner.SecurityCards.Count >= 1)
-        {
-          List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
-                    {
-                        new SelectionElement<bool>(message: $"Security Top", value : true, spriteIndex: 0),
-                        new SelectionElement<bool>(message: $"Security Bottom", value : false, spriteIndex: 1),
-                    };
-
-          string selectPlayerMessage = "Which will you trash the top or bottom card of the security?";
-          string notSelectPlayerMessage = "The opponent is selecting whether to trash the top or bottom card of security.";
-
-          GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
-
-          yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
-
-          bool fromTop = GManager.instance.userSelectionManager.SelectedBoolValue;
-
-          yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
-                  card.Owner,
-                  1,
-                  activateClass,
-                  fromTop).DestroySecurity());
-
-          if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
-          {
-            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
-
-            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-            selectPermanentEffect.SetUp(
-                selectPlayer: card.Owner,
-                canTargetCondition: CanSelectPermanentCondition,
-                canTargetCondition_ByPreSelecetedList: null,
-                canEndSelectCondition: null,
-                maxCount: maxCount,
-                canNoSelect: false,
-                canEndNotMax: false,
-                selectPermanentCoroutine: SelectPermanentCoroutine,
-                afterSelectPermanentCoroutine: null,
-                mode: SelectPermanentEffect.Mode.Custom,
-                cardEffect: activateClass);
-
-            selectPermanentEffect.SetUpCustomMessage(
-                "Select 1 Digimon that will get DP -6000.",
-                "The opponent is selecting 1 Digimon that will get DP -6000.");
-
-            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-            IEnumerator SelectPermanentCoroutine(Permanent permanent)
-            {
-              yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
-                targetPermanent: permanent,
-                changeValue: -6000,
-                effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                activateClass: activateClass));
-            }
-          }
-        }
-      }
-    }
-
-    return cardEffects;
-  }
-}