Add more Blue cards

Assets/CardEffect/BT16/Blue/Angemon_BT16_019.cs

@@ -12,7 +12,7 @@ namespace DCGO.CardEffects.BT16
         {
             var cardEffects = new List<ICardEffect>();
 
-            #region Alternate Digivolution Requirement
+            #region Alternate Digivolution Requirement, Blocker
             if(timing == EffectTiming.None)
             {
                 bool PermanentCondition(Permanent targetPermanent)
@@ -27,119 +27,62 @@ namespace DCGO.CardEffects.BT16
                     card: card,
                     condition: null)
                 );
+                
+                cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(isInheritedEffect: false, card: card, condition: null));
             }
             #endregion
 
-            #region Raid
-            if(timing == EffectTiming.OnAllyAttack)
-            {
-                cardEffects.Add(CardEffectFactory.RaidSelfEffect(
-                        isInheritedEffect: false,
-                        card: card,
-                        condition: null)
-                    );
-            }
-            #endregion
-
-            #region On Play
-            if(timing == EffectTiming.OnEnterFieldAnyone)
+            #region On Play/When Digivolving
+            if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Select 1 of your Digimon to gain effects", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpICardEffect("Unsuspend 1 level 4 or lower Digimon", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
                 {
-                    return "[On Play] 1 of your Digimon can't be deleted in battle until the end of your opponent's turn.";
-                }
-
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
-                }
-
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
+                    return "[On Play] [When Digivolving] Unsuspend 1 of your level 4 or lower Digimon.";
                 }
 
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
-                }
-
-                IEnumerator ActivateCoroutine(Hashtable hashtable)
-                {
-                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                    selectPermanentEffect.SetUp(
-                        selectPlayer: card.Owner,
-                        canTargetCondition: CanSelectPermanentCondition,
-                        canTargetCondition_ByPreSelecetedList: null,
-                        canEndSelectCondition: null,
-                        maxCount: 1,
-                        canNoSelect: false,
-                        canEndNotMax: false,
-                        selectPermanentCoroutine: SelectPermanentCoroutine,
-                        afterSelectPermanentCoroutine: null,
-                        mode: SelectPermanentEffect.Mode.Custom,
-                        cardEffect: activateClass);
-
-                    selectPermanentEffect.SetUpCustomMessage(
-                        "Select 1 Digimon that will get effects.",
-                        "The opponent is selecting 1 Digimon that will get effects.");
-
-                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
                     {
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotBeDeletedByBattle(
-                            targetPermanent: permanent,
-                            canNotBeDestroyedByBattleCondition: CanNotBeDestroyedByBattleCondition,
-                            effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                            activateClass: activateClass,
-                            effectName: "Can't be deleted in battle"));
-
-                        bool CanNotBeDestroyedByBattleCondition(Permanent permanent1, Permanent attackingPermanent, Permanent defendingPermanent, CardSource defendingCard)
+                        if (permanent.Level <= 4)
                         {
-                            return permanent == attackingPermanent || permanent == defendingPermanent;
+                            if (permanent.TopCard.HasLevel)
+                            {
+                                return true;
+                            }
                         }
                     }
-                }
-            }
-            #endregion
 
-            #region When Digivolving
-            if (timing == EffectTiming.OnEnterFieldAnyone)
-            {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Select 1 of your Digimon to gain effects", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
-                cardEffects.Add(activateClass);
-
-                string EffectDiscription()
-                {
-                    return "[When Digivolving] 1 of your Digimon can't be deleted in battle until the end of your opponent's turn.";
+                    return false;
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card) || CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
-                }
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                        {
+                            return true;
+                        }
+                    }
 
-                bool CanSelectPermanentCondition(Permanent permanent)
-                {
-                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
+                    return false;
                 }
 
-                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
+                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+
                     SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
 
                     selectPermanentEffect.SetUp(
@@ -147,38 +90,18 @@ namespace DCGO.CardEffects.BT16
                         canTargetCondition: CanSelectPermanentCondition,
                         canTargetCondition_ByPreSelecetedList: null,
                         canEndSelectCondition: null,
-                        maxCount: 1,
+                        maxCount: maxCount,
                         canNoSelect: false,
                         canEndNotMax: false,
-                        selectPermanentCoroutine: SelectPermanentCoroutine,
+                        selectPermanentCoroutine: null,
                         afterSelectPermanentCoroutine: null,
-                        mode: SelectPermanentEffect.Mode.Custom,
+                        mode: SelectPermanentEffect.Mode.UnTap,
                         cardEffect: activateClass);
-
-                    selectPermanentEffect.SetUpCustomMessage(
-                        "Select 1 Digimon that will get effects.",
-                        "The opponent is selecting 1 Digimon that will get effects.");
-
                     yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                    {
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotBeDeletedByBattle(
-                            targetPermanent: permanent,
-                            canNotBeDestroyedByBattleCondition: CanNotBeDestroyedByBattleCondition,
-                            effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                            activateClass: activateClass,
-                            effectName: "Can't be deleted in battle"));
-
-                        bool CanNotBeDestroyedByBattleCondition(Permanent permanent1, Permanent attackingPermanent, Permanent defendingPermanent, CardSource defendingCard)
-                        {
-                            return permanent == attackingPermanent || permanent == defendingPermanent;
-                        }
-                    }
                 }
             }
             #endregion
-
+            
             #region Inherited Effect
             if (timing == EffectTiming.OnAllyAttack)
             {

Assets/CardEffect/BT16/Blue/Divemon_BT16_023.cs

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

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

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

Assets/CardEffect/BT16/Blue/GaoGamon_BT16_020.cs

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

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

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

Assets/CardEffect/BT16/Blue/MagnaAngemon_BT16_024.cs

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

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

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

Assets/CardEffect/BT16/Blue/Mantaraymon_BT16_022.cs

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

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

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

Assets/CardEffect/BT16/Blue/Togemogumon_BT16_021.cs

@@ -0,0 +1,143 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System;
+
+namespace DCGO.CardEffects.BT16
+{
+    public class Togemogumon_BT16_021 : CEntity_Effect
+    {
+        
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            var cardEffects = new List<ICardEffect>();
+
+            #region Alternate Digivolution Requirement, Blocker
+            if(timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.CardNames.Contains("Wormmon");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 2,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null)
+                );
+                
+                cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(isInheritedEffect: false, card: card, condition: null));
+            }
+            #endregion
+            
+            #region Armor Purge
+            if (timing == EffectTiming.WhenPermanentWouldBeDeleted)
+            {
+                cardEffects.Add(CardEffectFactory.ArmorPurgeEffect(card: card));
+            }
+            #endregion
+            
+            #region All Turns
+            
+            if (timing == EffectTiming.OnTappedAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Trash digivolution cards & stun 1 Digimon", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+                
+                string EffectDiscription()
+                {
+                    return "[All Turns] [Once Per Turn] When an opponent's Digimon becomes suspended, trash the top digivolution card of 1 of " +
+                           "their Digimon. Then, 1 of their Digimon with no digivolution cards can't attack or block until the end of their turn.";
+                }
+                
+                bool CanSelectPermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
+                    {
+                        if (permanent.HasNoDigivolutionCards)
+                        {
+                            return true;
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                }
+                
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.CanTriggerWhenPermanentSuspends(hashtable, PermanentCondition))
+                        {
+                            return true;
+                        }
+                    }
+                    
+                    return false;
+                }
+                
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(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 effects.", "The opponent is selecting 1 Digimon that will get effects.");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotAttack(
+                            targetPermanent: permanent,
+                            defenderCondition: null,
+                            effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                            activateClass: activateClass,
+                            effectName: "Can't Attack"));
+
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotBlock(
+                            targetPermanent: permanent,
+                            attackerCondition: null,
+                            effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                            activateClass: activateClass,
+                            effectName: "Can't Block"));
+                    }
+                }
+            }
+            }
+            
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/BT16/Blue/Togemogumon_BT16_021.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c922f62f0e4f4577b85ffb144d72ec73
+timeCreated: 1717032693

Assets/Scripts/CardSource.cs

@@ -1307,7 +1307,7 @@ public class CardSource : MonoBehaviour
         }
     }
     #endregion
-
+    
     #region whether this card has at least 1 trait that contains "Angel"
     public bool HasAngelTraits
     {
@@ -1317,32 +1317,61 @@ public class CardSource : MonoBehaviour
             {
                 return true;
             }
-
+            
             if (ContainsTraits("Cherub"))
             {
                 return true;
             }
-
+            
             if (ContainsTraits("Throne"))
             {
                 return true;
             }
-
+            
             if (ContainsTraits("Authority"))
             {
                 return true;
             }
-
+            
             if (ContainsTraits("Seraph"))
             {
                 return true;
             }
-
+            
             if (ContainsTraits("Virtue"))
             {
                 return true;
             }
-
+            
+            return false;
+        }
+    }
+    #endregion
+    
+    #region whether this card has 1 of the "Angel", "Archangel" or "Three Great Angels" trait
+    public bool HasAngelTraitRestrictive
+    {
+        get
+        {
+            if (ContainsTraits("Three Great Angels") || ContainsTraits("ThreeGreatAngels"))
+            {
+                return true;
+            }
+            
+            if (ContainsTraits("Archangel"))
+            {
+                return true;
+            }
+            
+            if (CardTraits.Count(trait => 
+                    (trait.Contains("Angel") || trait.Contains("angel"))
+                    && trait != "Archangel"
+                    && trait != "Fallen Angel" && trait != "FallenAngel"
+                    && trait != "Three Great Angels" && trait != "ThreeGreatAngels") >= 1)
+            {
+                return true;
+            }
+            
             return false;
         }
     }
@@ -1406,7 +1435,7 @@ public class CardSource : MonoBehaviour
         }
     }
     #endregion
-
+    
     #region whether this card has at least 1 trait that contains "DigiPolice"
     public bool HasDigiPoliceTraits
     {
@@ -1416,11 +1445,16 @@ public class CardSource : MonoBehaviour
             {
                 return true;
             }
-
+            
             return false;
         }
     }
     #endregion
+    
+    #region whether this card has at least 1 trait that contains "Light Fang" or "Night Claw"
+    public bool HasLightFangNightClawTraits => ContainsTraits("Light Fang") || ContainsTraits("Night Claw");
+    
+    #endregion
 
     #region whether this card has the string in text
     public bool HasText(string text)
@@ -1463,10 +1497,14 @@ public class CardSource : MonoBehaviour
         return false;
     }
     #endregion
-
+    
     #region whether this card has <Save> in text
     public bool HasSaveText => HasText("<Save>");
     #endregion
+    
+    #region whether this card has "Pulsemon" in text
+    public bool HasPulsemonText => HasText("Pulsemon");
+    #endregion
 
     #region card names checked when digixros
     public List<string> CardNames_DigiXros
@@ -1986,6 +2024,30 @@ public class CardSource : MonoBehaviour
     #region whether this card has level
     public bool HasLevel => _cEntity_Base == null || _cEntity_Base.HasLevel;
     #endregion
+    
+    #region whether this card is level 3
+    
+    public bool IsLevel3 => (_cEntity_Base == null || _cEntity_Base.HasLevel) && _cEntity_Base.Level == 3;
+    
+    #endregion
+    
+    #region whether this card is level 4
+    
+    public bool IsLevel4 => (_cEntity_Base == null || _cEntity_Base.HasLevel) && _cEntity_Base.Level == 4;
+    
+    #endregion
+    
+    #region whether this card is level 5
+    
+    public bool IsLevel5 => (_cEntity_Base == null || _cEntity_Base.HasLevel) && _cEntity_Base.Level == 5;
+    
+    #endregion
+    
+    #region whether this card is level 6
+    
+    public bool IsLevel6 => (_cEntity_Base == null || _cEntity_Base.HasLevel) && _cEntity_Base.Level == 6;
+    
+    #endregion
 
     #region DigiXros requirement
     public DigiXrosCondition digiXrosCondition