BT16 card updates

Assets/CardBaseEntity/BT16/Yellow/Digimon/Agumon-BT16-029.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:26fe88bf524cdfdbca21e0994e31b47556ed9612cd2ae968050a1c4e21793407
-size 1707
+oid sha256:34a6ace2f0e9727fb94b3f8f7640589b29fe4617a8e2dac457e9404fe209ee27
+size 1708

Assets/CardEffect/BT16/Black/DoruGreymon_BT16_061.cs

@@ -188,8 +188,8 @@ namespace DCGO.CardEffects.BT16
                             canEndSelectCondition: null,
                             canNoSelect: () => false,
                             selectCardCoroutine: null,
-                            afterSelectCardCoroutine: null,
-                            message: "",
+                            afterSelectCardCoroutine: AfterSelectCardCoroutine,
+                            message: "Select 1 card to play",
                             maxCount: 1,
                             canEndNotMax: false,
                             isShowOpponent:false,
@@ -203,7 +203,20 @@ namespace DCGO.CardEffects.BT16
 
                         yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
                     }
-                    yield return null;
+
+                    IEnumerator AfterSelectCardCoroutine(List<CardSource> selectedCardSources)
+                    {
+                        if (selectedCardSources.Count >= 1)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
+                                cardSources:selectedCardSources,
+                                activateClass: activateClass,
+                                payCost: false,
+                                isTapped: false,
+                                root: SelectCardEffect.Root.Trash,
+                                activateETB:false));
+                        }
+                    }
                 }
             }
             #endregion

Assets/CardEffect/BT16/Black/Dorugoramon_BT16_064.cs

@@ -41,10 +41,9 @@ namespace DCGO.CardEffects.BT16
             #endregion
 
             #region Collision - Blocker
-            if(timing == EffectTiming.None)
+            if(timing == EffectTiming.OnAllyAttack)
             {
                 cardEffects.Add(CardEffectFactory.CollisionSelfStaticEffect(false, card, null));
-                cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(false, card, null));
             }
             #endregion
 
@@ -110,6 +109,9 @@ namespace DCGO.CardEffects.BT16
                             afterSelectPermanentCoroutine: null,
                             mode: SelectPermanentEffect.Mode.Destroy,
                             cardEffect: activateClass);
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
                     }
 
                     yield return null;

Assets/CardEffect/BT16/Black/KosukeKisakata_BT16_087.cs

@@ -97,7 +97,7 @@ namespace DCGO.CardEffects.BT16
                     return false;
                 }
 
-                cardEffects.Add(CardEffectFactory.RebootSelfStaticEffect(isInheritedEffect: true, card: card, condition: Condition));
+                cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(isInheritedEffect: true, card: card, condition: Condition));
                 cardEffects.Add(CardEffectFactory.PierceSelfEffect(isInheritedEffect: true, card: card, condition: Condition));
             }
 

Assets/CardEffect/BT16/Black/Mekanorimon_BT16_057.cs

@@ -152,7 +152,7 @@ namespace DCGO.CardEffects.BT16
                 {
                     if (CardEffectCommons.IsOwnerTurn(card))
                     {
-                        if(card.PermanentOfThisCard().DigivolutionCards.Count > 0)
+                        if(card.PermanentOfThisCard().DigivolutionCards.Count == 0)
                         {
                             return true;
                         }

Assets/CardEffect/BT16/Green/Pulsemon_BT16_039.cs

@@ -31,7 +31,7 @@ namespace DCGO.CardEffects.BT16
 
                 string EffectDiscription()
                 {
-                    return "[On Play] Reveal the top 4 cards of your deck. Add 1 card with [Pulsemon] in its text and 1 card with the [Abaddin Electronics] trait among them to your hand. Place the rest at the bottom of your deck in any order.";
+                    return "[On Play] Reveal the top 4 cards of your deck. Add 1 card with [Pulsemon] in its text and 1 card with the [Abadin Electronics] trait among them to your hand. Place the rest at the bottom of your deck in any order.";
                 }
 
                 bool CanSelectCardCondition(CardSource cardSource)
@@ -45,11 +45,11 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanSelectSecondCardCondition(CardSource cardSource)
                 {
-                    if (cardSource.CardTraits.Contains("Abaddin Electronics"))
+                    if (cardSource.CardTraits.Contains("Abadin Electronics"))
                     {
                         return true;
                     }
-                    if (cardSource.CardTraits.Contains("AbaddinElectronics"))
+                    if (cardSource.CardTraits.Contains("AbadinElectronics"))
                     {
                         return true;
                     }
@@ -89,7 +89,7 @@ namespace DCGO.CardEffects.BT16
                             selectCardCoroutine: null),
                         new SimplifiedSelectCardConditionClass(
                             canTargetCondition:CanSelectSecondCardCondition,
-                            message:"Select 1 card with [Abaddin Electronics] in its traits.",
+                            message:"Select 1 card with [Abadin Electronics] in its traits.",
                             mode: SelectCardEffect.Mode.AddHand,
                             maxCount: 1,
                             selectCardCoroutine: null),

Assets/CardEffect/BT16/Green/Runnermon_BT16_043.cs

@@ -19,7 +19,7 @@ namespace DCGO.CardEffects.BT16
             {
                 bool PermanentCondition(Permanent targetPermanent)
                 {
-                    return targetPermanent.TopCard.CardNames.Contains("Pulsemon") && targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.Level == 4;
+                    return targetPermanent.TopCard.ContainsCardName("Pulsemon");
                 }
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 2, ignoreDigivolutionRequirement: false, card: card, condition: null));

Assets/CardEffect/BT16/Green/TerriermonXAntibody_BT16_038.cs

@@ -38,7 +38,16 @@ namespace DCGO.CardEffects.BT16
 
                 bool PermanentCondition(Permanent permanent)
                 {
-                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card);
+
+                    if(CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card))
+                    {
+                        if(permanent == card.PermanentOfThisCard())
+                        {
+                            return true;
+                        }
+                    }
+
+                    return true;
                 }
 
                 bool CardCondition(CardSource cardSource)

Assets/CardEffect/BT16/Green/TyrantKabuterimon_BT16_048.cs

@@ -16,7 +16,7 @@ namespace DCGO.CardEffects.BT16
             {
                 bool PermanentCondition(Permanent targetPermanent)
                 {
-                    return targetPermanent.TopCard.GetCostItself >= 13 && targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.Level == 6 && targetPermanent.TopCard.CardTraits.Contains("Insectoid");
+                    return targetPermanent.TopCard.GetCostItself <= 13 && targetPermanent.TopCard.HasLevel && targetPermanent.TopCard.Level == 6 && targetPermanent.TopCard.CardTraits.Contains("Insectoid");
                 }
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 2, ignoreDigivolutionRequirement: true, card: card, condition: null));

Assets/CardEffect/BT16/Purple/ArukenimonAndMummymon_BT16_089.cs

@@ -353,6 +353,13 @@ namespace DCGO.CardEffects.BT16
 
             #endregion
 
+            #region Security Skill
+            if (timing == EffectTiming.SecuritySkill)
+            {
+                cardEffects.Add(CardEffectFactory.PlaySelfTamerSecurityEffect(card));
+            }
+            #endregion
+
             return cardEffects;
         }
     }

Assets/CardEffect/BT16/Purple/CherubimonXAntibody_BT16_079.cs

@@ -33,13 +33,192 @@ namespace DCGO.CardEffects.BT16
             }
             #endregion
 
+            #region When Attacking
+            if (timing == EffectTiming.OnAllyAttack)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Play a level 4 or lower Digimon from your hand or trash.", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
+                activateClass.SetHashString("AttackingDigimon_BT16_079");
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Attacking] [Once Per Turn] You may play 1 level 4 or lower yellow or green Digimon from your hand or trash without paying the cost.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnAttack(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        return true;
+                    }
+
+                    return false;
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+
+                    if (CardEffectCommons.IsExistOnHand(cardSource))
+                    {
+                        if (cardSource.Level <= 4 && cardSource.CardColors.Contains(CardColor.Yellow) && cardSource.IsDigimon)
+                        {
+                            return true;
+                        }
+
+                        if (cardSource.Level <= 4 && cardSource.CardColors.Contains(CardColor.Green) && cardSource.IsDigimon)
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanSelectCardCondition1(CardSource cardSource)
+                {
+                    if (CardEffectCommons.IsExistOnTrash(cardSource))
+                    {
+                        if (cardSource.Level <= 4 && cardSource.CardColors.Contains(CardColor.Yellow) && cardSource.IsDigimon)
+                        {
+                            return true;
+                        }
+
+                        if (cardSource.Level <= 4 && cardSource.CardColors.Contains(CardColor.Green) && cardSource.IsDigimon)
+                        {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    bool canSelectHand = card.Owner.HandCards.Count(CanSelectCardCondition) >= 1;
+                    bool canSelectTrash = card.Owner.TrashCards.Count(CanSelectCardCondition1) >= 1;
+
+                    if (canSelectHand || canSelectTrash)
+                    {
+                        if (canSelectHand && canSelectTrash)
+                        {
+                            List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                        {
+                            new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
+                        };
+
+                            string selectPlayerMessage = "From which area do you play a card?";
+                            string notSelectPlayerMessage = "The opponent is choosing from which area to play a card.";
+
+                            GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                        }
+
+                        else
+                        {
+                            GManager.instance.userSelectionManager.SetBool(canSelectHand);
+                        }
+
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                        bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+                        List<CardSource> selectedCards = new List<CardSource>();
+
+                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        {
+                            selectedCards.Add(cardSource);
+
+                            yield return null;
+                        }
+
+                        if (fromHand)
+                        {
+                            int maxCount1 = 1;
+
+                            SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                            selectHandEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectCardCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount1,
+                                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());
+                        }
+
+                        else
+                        {
+                            int maxCount1 = 1;
+
+                            SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                            selectCardEffect.SetUp(
+                                        canTargetCondition: CanSelectCardCondition1,
+                                        canTargetCondition_ByPreSelecetedList: null,
+                                        canEndSelectCondition: null,
+                                        canNoSelect: () => true,
+                                        selectCardCoroutine: SelectCardCoroutine,
+                                        afterSelectCardCoroutine: null,
+                                        message: "Select 1 card to play.",
+                                        maxCount: maxCount1,
+                                        canEndNotMax: false,
+                                        isShowOpponent: true,
+                                        mode: SelectCardEffect.Mode.Custom,
+                                        root: SelectCardEffect.Root.Custom,
+                                        customRootCardList: card.Owner.TrashCards,
+                                        canLookReverseCard: true,
+                                        selectPlayer: card.Owner,
+                                        cardEffect: activateClass);
+
+                            selectCardEffect.SetUpCustomMessage("Select 1 trash card to play.", "The opponent is selecting 1 trash card to play.");
+                            selectCardEffect.SetUpCustomMessage_ShowCard("Played Card");
+
+                            yield return StartCoroutine(selectCardEffect.Activate());
+                        }
+
+                        SelectCardEffect.Root root = SelectCardEffect.Root.Hand;
+
+                        if (!fromHand)
+                        {
+                            root = SelectCardEffect.Root.Trash;
+                        }
+
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
+                            cardSources: selectedCards,
+                            activateClass: activateClass,
+                            payCost: false,
+                            isTapped: false,
+                            root: root,
+                            activateETB: true));
+                    }
+                }
+            }
+            #endregion
+
             #region When Digivolving
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Play a level 4 or lower Digimon from your hand or trash.", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
-                activateClass.SetHashString("PlayDigimon_BT16_079");
+                activateClass.SetHashString("DigivovleDigimon_BT16_079");
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -49,7 +228,7 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable,card) || CardEffectCommons.CanTriggerOnAttack(hashtable,card);
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable,card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)

Assets/CardEffect/BT16/Purple/Dinobeemon_BT16_077.cs

@@ -114,7 +114,7 @@ namespace DCGO.CardEffects.BT16
 
             #region Partition & Partition Inherit
 
-            if(timing == EffectTiming.OnDestroyedAnyone)
+            if(timing == EffectTiming.WhenPermanentWouldBeDeleted)
             {
 
                 bool CanSelectFirstSource(CardSource cardSource)
@@ -139,7 +139,7 @@ namespace DCGO.CardEffects.BT16
             
             }
 
-            if (timing == EffectTiming.OnDestroyedAnyone)
+            if (timing == EffectTiming.WhenPermanentWouldBeDeleted)
             {
 
                 bool CanSelectFirstSource(CardSource cardSource)

Assets/CardEffect/BT16/Yellow/Agumon_BT16_029.cs

@@ -139,19 +139,12 @@ namespace DCGO.CardEffects.BT16
             #region Inherit
             if (timing == EffectTiming.None)
             {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Opponent's Security Digimon get DP -3000", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
-                activateClass.SetIsInheritedEffect(true);
-                activateClass.SetHashString("DP-3000_BT16_029_inhetited");
-                cardEffects.Add(activateClass);
-
-                string EffectDiscription()
+                bool CardCondition(CardSource cardSource)
                 {
-                    return "[Your Turn] All of your opponent's Security Digimon get -3000 DP.";
+                    return cardSource.Owner == card.Owner.Enemy;
                 }
 
-                bool CanUseCondition(Hashtable hashtable)
+                bool Condition()
                 {
                     if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
@@ -160,23 +153,16 @@ namespace DCGO.CardEffects.BT16
                             return true;
                         }
                     }
-
                     return false;
                 }
 
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
-                }
-
-                IEnumerator ActivateCoroutine(Hashtable hashtable)
-                {
-                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeSecurityDigimonCardDPPlayerEffect(
-                        cardCondition: cardSource => cardSource.Owner == card.Owner.Enemy,
-                        changeValue: -3000,
-                        effectDuration: EffectDuration.UntilOwnerTurnEnd,
-                        activateClass: activateClass));
-                }
+                cardEffects.Add(CardEffectFactory.ChangeSecurityDigimonCardDPStaticEffect(
+                    cardCondition: CardCondition,
+                    changeValue: -3000,
+                    isInheritedEffect: true,
+                    card: card,
+                    condition: Condition,
+                    effectName: "Opponent's Security Digimon gains DP -3000"));
             }
             #endregion
 

Assets/CardEffect/BT16/Yellow/DragonBreath_BT16_094.cs

@@ -173,6 +173,7 @@ namespace DCGO.CardEffects.BT16
                             bool decision = GManager.instance.userSelectionManager.SelectedBoolValue;
 
                             List<CardSource> selectedCards = new List<CardSource>();
+                            bool discarded = false;
 
                             IEnumerator SelectCardCoroutine(CardSource cardSource)
                             {
@@ -216,8 +217,6 @@ namespace DCGO.CardEffects.BT16
                             {
                                 int discardCount = 1;
 
-                                bool discarded = false;
-
                                 SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
 
                                 selectHandEffect.SetUp(
@@ -245,43 +244,43 @@ namespace DCGO.CardEffects.BT16
                                         yield return null;
                                     }
                                 }
+                            }
 
-                                if (discarded)
+                            if (discarded || selectedCards.Count > 0)
+                            {
+                                if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                                 {
-                                    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: true,
+                                        canEndNotMax: false,
+                                        selectPermanentCoroutine: SelectPermanentCoroutine,
+                                        afterSelectPermanentCoroutine: null,
+                                        mode: SelectPermanentEffect.Mode.Custom,
+                                        cardEffect: activateClass);
+
+                                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to give -7000 DP.", "The opponent is selecting 1 Digimon to give -7000 DP.");
+
+                                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
                                     {
-                                        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: true,
-                                            canEndNotMax: false,
-                                            selectPermanentCoroutine: SelectPermanentCoroutine,
-                                            afterSelectPermanentCoroutine: null,
-                                            mode: SelectPermanentEffect.Mode.Custom,
-                                            cardEffect: activateClass);
-
-                                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to give -7000 DP.", "The opponent is selecting 1 Digimon to give -7000 DP.");
-
-                                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                                        {
-                                            Permanent selectedPermanent = permanent;
-
-                                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
-                                                selectedPermanent,
-                                                -7000,
-                                                EffectDuration.UntilEachTurnEnd,
-                                                activateClass)
-                                                );
-                                        }
+                                        Permanent selectedPermanent = permanent;
+
+                                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(
+                                            selectedPermanent,
+                                            -7000,
+                                            EffectDuration.UntilEachTurnEnd,
+                                            activateClass)
+                                            );
                                     }
                                 }
                             }

Assets/CardEffect/BT16/Yellow/Gatomon_BT16_031.cs

@@ -283,19 +283,12 @@ namespace DCGO.CardEffects.BT16
             #region Inherit
             if (timing == EffectTiming.None)
             {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Opponent's Security Digimon get DP -3000", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
-                activateClass.SetIsInheritedEffect(true);
-                activateClass.SetHashString("DP-3000_BT16_031_inhetited");
-                cardEffects.Add(activateClass);
-
-                string EffectDiscription()
+                bool CardCondition(CardSource cardSource)
                 {
-                    return "[Your Turn] All of your opponent's Security Digimon get -3000 DP.";
+                    return cardSource.Owner == card.Owner.Enemy;
                 }
 
-                bool CanUseCondition(Hashtable hashtable)
+                bool Condition()
                 {
                     if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
@@ -304,23 +297,16 @@ namespace DCGO.CardEffects.BT16
                             return true;
                         }
                     }
-
                     return false;
                 }
 
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
-                }
-
-                IEnumerator ActivateCoroutine(Hashtable hashtable)
-                {
-                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeSecurityDigimonCardDPPlayerEffect(
-                        cardCondition: cardSource => cardSource.Owner == card.Owner.Enemy,
-                        changeValue: -3000,
-                        effectDuration: EffectDuration.UntilOwnerTurnEnd,
-                        activateClass: activateClass));
-                }
+                cardEffects.Add(CardEffectFactory.ChangeSecurityDigimonCardDPStaticEffect(
+                    cardCondition: CardCondition,
+                    changeValue: -3000,
+                    isInheritedEffect: true,
+                    card: card,
+                    condition: Condition,
+                    effectName: "Opponent's Security Digimon gains DP -3000"));
             }
             #endregion
 

Assets/CardEffect/BT16/Yellow/RapidmonXAntibody_BT16_101.cs

@@ -135,22 +135,19 @@ namespace DCGO.CardEffects.BT16
                 {
                     if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
-                        if (CardEffectCommons.IsOwnerTurn(card))
+                        if (CardEffectCommons.CanTriggerOnPermanentDeleted(hashtable, PermanentCondition))
                         {
-                            if (CardEffectCommons.CanTriggerOnPermanentDeleted(hashtable, PermanentCondition))
+                            if (CardEffectCommons.IsDPZeroDelete(hashtable))
                             {
-                                if (CardEffectCommons.IsDPZeroDelete(hashtable))
-                                {
-                                    return true;
-                                }
+                                return true;
+                            }
 
-                                bool WinnerCondition(Permanent permanent) => CardEffectCommons.IsOwnerPermanent(permanent, card);
-                                bool LoserCondition(Permanent permanent) => CardEffectCommons.IsOpponentPermanent(permanent, card);
+                            bool WinnerCondition(Permanent permanent) => CardEffectCommons.IsOwnerPermanent(permanent, card);
+                            bool LoserCondition(Permanent permanent) => CardEffectCommons.IsOpponentPermanent(permanent, card);
 
-                                if (CardEffectCommons.CanTriggerWhenDeleteOpponentDigimonByBattle(hashtable: hashtable, winnerCondition: WinnerCondition, loserCondition: LoserCondition, isOnlyWinnerSurvive: true))
-                                {
-                                    return true;
-                                }
+                            if (CardEffectCommons.CanTriggerWhenDeleteOpponentDigimonByBattle(hashtable: hashtable, winnerCondition: WinnerCondition, loserCondition: LoserCondition, isOnlyWinnerSurvive: true))
+                            {
+                                return true;
                             }
                         }
                     }

Assets/CardEffect/BT16/Yellow/Salamon_BT16_030.cs

@@ -33,19 +33,12 @@ namespace DCGO.CardEffects.BT16
             #region Inherit
             if (timing == EffectTiming.None)
             {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Opponent's Security Digimon get DP -3000", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
-                activateClass.SetIsInheritedEffect(true);
-                activateClass.SetHashString("DP-3000_BT16_030_inhetited");
-                cardEffects.Add(activateClass);
-
-                string EffectDiscription()
+                bool CardCondition(CardSource cardSource)
                 {
-                    return "[Your Turn] All of your opponent's Security Digimon get -3000 DP.";
+                    return cardSource.Owner == card.Owner.Enemy;
                 }
 
-                bool CanUseCondition(Hashtable hashtable)
+                bool Condition()
                 {
                     if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
@@ -54,28 +47,21 @@ namespace DCGO.CardEffects.BT16
                             return true;
                         }
                     }
-
                     return false;
                 }
 
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
-                }
-
-                IEnumerator ActivateCoroutine(Hashtable hashtable)
-                {
-                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeSecurityDigimonCardDPPlayerEffect(
-                        cardCondition: cardSource => cardSource.Owner == card.Owner.Enemy,
-                        changeValue: -3000,
-                        effectDuration: EffectDuration.UntilOwnerTurnEnd,
-                        activateClass: activateClass));
-                }
+                cardEffects.Add(CardEffectFactory.ChangeSecurityDigimonCardDPStaticEffect(
+                    cardCondition: CardCondition,
+                    changeValue: -3000,
+                    isInheritedEffect: true,
+                    card: card,
+                    condition: Condition,
+                    effectName: "Opponent's Security Digimon gains DP -3000"));
             }
             #endregion
 
             #region Start of Main
-            if(timing == EffectTiming.OnStartMainPhase)
+            if (timing == EffectTiming.OnStartMainPhase)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("1 of your Digimon may Digivolve", CanUseCondition, card);

Assets/CardEffect/BT16/Yellow/Tempomon_BT16_034.cs

@@ -80,7 +80,7 @@ namespace DCGO.CardEffects.BT16
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if(card.Owner.SecurityCards.Count >=3)
+                    if(card.Owner.SecurityCards.Count >= 3)
                     {
                         int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(PermanentCondition));
 
@@ -134,7 +134,7 @@ namespace DCGO.CardEffects.BT16
 
                         IEnumerator SelectPermanentCoroutine(Permanent permanent)
                         {
-                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: permanent, changeValue: -4000, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonSAttack(targetPermanent: permanent, changeValue: -2, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
                         }
                     }
                 }
@@ -249,7 +249,7 @@ namespace DCGO.CardEffects.BT16
 
                         IEnumerator SelectPermanentCoroutine(Permanent permanent)
                         {
-                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: permanent, changeValue: -4000, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonSAttack(targetPermanent: permanent, changeValue: -2, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
                         }
                     }
                 }

Assets/Scripts/CardEffectCommons/KeyWordEffects/Collision.cs

@@ -67,7 +67,7 @@ public partial class CardEffectCommons
             {
                 if (CardEffectCommons.IsPermanentExistsOnBattleArea(permanent))
                 {
-                    if (permanent.TopCard.Owner.isYou)
+                    if (!permanent.TopCard.Owner.isYou)
                     {
                         if (permanent.HasBlocker && permanent.CanBlock(cardSource.PermanentOfThisCard()))
                         {

Assets/Scripts/CardSource.cs

@@ -1457,6 +1457,26 @@ public class CardSource : MonoBehaviour
     }
     #endregion
 
+    #region whether this card has at least 1 trait that contains "Light Fang/Night Claw"
+    public bool HasLightFangOrNightClawTraits
+    {
+        get
+        {
+            if (ContainsTraits("Light Fang"))
+            {
+                return true;
+            }
+
+            if (ContainsTraits("Night Claw"))
+            {
+                return true;
+            }
+
+            return false;
+        }
+    }
+    #endregion
+
     #region whether this card has the string in text
     public bool HasText(string text)
     {