Merge pull request #18 from DCGO2/BT16

Bt16

Assets/CardBaseEntity/BT16/Red/Digimon/Silphymon-BT16-012_P1.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:771b143edd268e8a967ce15ffaa1d1a6997529e04e1faca62555f04f736765b4
+oid sha256:e1296db4ef005a472ca36c11a57c88e59830ef9826c9e35212cbfb909367eb36
 size 2408

Assets/CardEffect/BT16/Black/Darkdramon_BT16_065.cs

@@ -382,48 +382,46 @@ namespace DCGO.CardEffects.BT16
                     int costDeletion = 0;
 
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.RevealDeckTopCardsAndProcessForAll(
-                        revealCount: 3,
-                        simplifiedSelectCardCondition:
-                        new SimplifiedSelectCardConditionClass(
-                            canTargetCondition: RevealSelectCardCondition,
-                            message: "Select play cost to use",
-                            mode: SelectCardEffect.Mode.Custom,
-                            maxCount: -1,
-                            selectCardCoroutine: SelectCardCoroutine),
-                        remainingCardsPlace: RemainingCardsPlace.Trash,
-                        activateClass: activateClass,
-                        revealedCardsCoroutine: null
-                    ));
+                            revealCount: 3,
+                            simplifiedSelectCardCondition:
+                            new SimplifiedSelectCardConditionClass(
+                                canTargetCondition: RevealSelectCardCondition,
+                                message: "Select play cost to use",
+                                mode: SelectCardEffect.Mode.Discard,
+                                maxCount: -1,
+                                selectCardCoroutine: SelectCardCoroutine),
+                            remainingCardsPlace: RemainingCardsPlace.Trash,
+                            activateClass: activateClass,
+                            revealedCardsCoroutine: null
+                        ));
 
                     IEnumerator SelectCardCoroutine(CardSource cardSource)
                     {
                         costDeletion = cardSource.GetCostItself;
 
-                        if(CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectPermanentCondition))
-                        {
-                            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: null,
-                                afterSelectPermanentCoroutine: null,
-                                mode: SelectPermanentEffect.Mode.Destroy,
-                                cardEffect: activateClass);
-
-                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                        }
-                        
-
-
                         yield return null;
                     }
 
+                    if (CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectPermanentCondition))
+                    {
+                        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: null,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Destroy,
+                            cardEffect: activateClass);
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                    }                
+
                     bool CanSelectPermanentCondition(Permanent permanent)
                     {
                         if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
@@ -494,48 +492,46 @@ namespace DCGO.CardEffects.BT16
                     int costDeletion = 0;
 
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.RevealDeckTopCardsAndProcessForAll(
-                        revealCount: 3,
-                        simplifiedSelectCardCondition:
-                        new SimplifiedSelectCardConditionClass(
-                            canTargetCondition: RevealSelectCardCondition,
-                            message: "Select play cost to use",
-                            mode: SelectCardEffect.Mode.Custom,
-                            maxCount: -1,
-                            selectCardCoroutine: SelectCardCoroutine),
-                        remainingCardsPlace: RemainingCardsPlace.Trash,
-                        activateClass: activateClass,
-                        revealedCardsCoroutine: null
-                    ));
+                            revealCount: 3,
+                            simplifiedSelectCardCondition:
+                            new SimplifiedSelectCardConditionClass(
+                                canTargetCondition: RevealSelectCardCondition,
+                                message: "Select play cost to use",
+                                mode: SelectCardEffect.Mode.Discard,
+                                maxCount: -1,
+                                selectCardCoroutine: SelectCardCoroutine),
+                            remainingCardsPlace: RemainingCardsPlace.Trash,
+                            activateClass: activateClass,
+                            revealedCardsCoroutine: null
+                        ));
 
                     IEnumerator SelectCardCoroutine(CardSource cardSource)
                     {
                         costDeletion = cardSource.GetCostItself;
 
-                        if (CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectPermanentCondition))
-                        {
-                            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: null,
-                                afterSelectPermanentCoroutine: null,
-                                mode: SelectPermanentEffect.Mode.Destroy,
-                                cardEffect: activateClass);
-
-                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                        }
-
-
-
                         yield return null;
                     }
 
+                    if (CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectPermanentCondition))
+                    {
+                        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: null,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Destroy,
+                            cardEffect: activateClass);
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                    }
+
                     bool CanSelectPermanentCondition(Permanent permanent)
                     {
                         if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))

Assets/CardEffect/BT16/Black/KosukeKisakata_BT16_087.cs

@@ -98,7 +98,31 @@ namespace DCGO.CardEffects.BT16
                 }
 
                 cardEffects.Add(CardEffectFactory.BlockerSelfStaticEffect(isInheritedEffect: true, card: card, condition: Condition));
+              
+            }
+
+            if (timing == EffectTiming.OnDetermineDoSecurityCheck)
+            {
+                bool Condition()
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (card.PermanentOfThisCard().TopCard.HasXAntibodyTraits)
+                        {
+                            return true;
+                        }
+
+                        if (card.PermanentOfThisCard().TopCard.HasSocTraits)
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
                 cardEffects.Add(CardEffectFactory.PierceSelfEffect(isInheritedEffect: true, card: card, condition: Condition));
+
             }
 
             if (timing == EffectTiming.OnEndTurn)

Assets/CardEffect/BT16/Black/MetropolitanPoliceDepartmentCommunitySafetyBureauCyberCrimeDivisionInvestigationUnitElevenDigimonCrimeResponeTeam_BT16_096.cs

@@ -73,11 +73,13 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    if (card.HasDBrigadeorDigiPoliceTraits)
+                    if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass))
                     {
-                        if(card.HasPlayCost && card.GetCostItself <= 4)
+                        Debug.Log($"SelectCondion ({cardSource.BaseENGCardNameFromEntity}): Can Play as new permanent - {cardSource.HasDBrigadeorDigiPoliceTraits}");
+                        if (cardSource.HasDBrigadeorDigiPoliceTraits)
                         {
-                            if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass))
+                            Debug.Log($"SelectCondion ({cardSource.BaseENGCardNameFromEntity}): has right traits");
+                            if (cardSource.HasPlayCost && cardSource.GetCostItself <= 4)
                             {
                                 return true;
                             }
@@ -114,7 +116,7 @@ namespace DCGO.CardEffects.BT16
                             maxCount: 1,
                             selectCardCoroutine: SelectCardCoroutine),
                             },
-                            remainingCardsPlace: RemainingCardsPlace.DeckTop,
+                            remainingCardsPlace: RemainingCardsPlace.Trash,
                             activateClass: activateClass));
                         }
 

Assets/CardEffect/BT16/Black/Shakkoumon_BT16_063.cs

@@ -275,7 +275,7 @@ namespace DCGO.CardEffects.BT16
             #endregion
 
             #region Partition - Inherited
-            if (timing == EffectTiming.WhenPermanentWouldBeDeleted)
+            if (timing == EffectTiming.WhenRemoveField)
             {
                 bool CanSelectFirstSourceCondition(CardSource cardSource)
                 {

Assets/CardEffect/BT16/Black/Shootmon_BT16_059.cs

@@ -230,46 +230,69 @@ namespace DCGO.CardEffects.BT16
             if (timing == EffectTiming.OnEndAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Unsuspend this digimon", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Unsuspend this Digimon by trashing the top card of your security.", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
                 activateClass.SetIsInheritedEffect(true);
-
+                activateClass.SetHashString("Inherit_BT16_059");
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
                 {
-                    return "[End of Attack] [Once Per Turn] If this Digimon has [Pulsemon] in its text, by trashing the top card of your security stack, unsuspend this Digimon.";
+                    return "[End of Attack] [Once per turn] If this Digimon has [Pulsemon] in its text, by trashing the top card of your security stack, unsuspend this Digimon.";
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if(CardEffectCommons.CanTriggerOnEndAttack(hashtable, card))
+                    return CardEffectCommons.CanTriggerOnEndAttack(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
-                        return card.HasText("Pulsemon");
+                        if (card.PermanentOfThisCard().TopCard.HasText("Pulsemon"))
+                        {
+                            if (card.Owner.SecurityCards.Count >= 1)
+                            {
+                                if (CardEffectCommons.CanUnsuspend(card.PermanentOfThisCard()))
+                                {
+                                    return true;
+                                }
+                            }
+                        }
                     }
 
                     return false;
                 }
 
-                bool CanActivateCondition(Hashtable hashtable)
+                bool PermanentCondition(Permanent permanent)
                 {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
+                    if (permanent == card.PermanentOfThisCard())
+                    {
+                        if (card.PermanentOfThisCard().TopCard.HasText("Pulsemon"))
+                        {
+                            if (CardEffectCommons.CanUnsuspend(card.PermanentOfThisCard()))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
                 }
 
-                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    if(CardEffectCommons.IsExistOnBattleArea(card))
+                    yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
+                    player: card.Owner,
+                    destroySecurityCount: 1,
+                    cardEffect: activateClass,
+                    fromTop: true).DestroySecurity());
+
+                    if (CardEffectCommons.HasMatchConditionPermanent(PermanentCondition))
                     {
-                        if(card.Owner.SecurityCards.Count > 0)
-                        {
-                            yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
-                                    player: card.Owner,
-                                    destroySecurityCount: 1,
-                                    cardEffect: activateClass,
-                                    fromTop: true).DestroySecurity());
+                        Permanent selectedPermanent = card.PermanentOfThisCard();
 
-                            yield return ContinuousController.instance.StartCoroutine(new IUnsuspendPermanents(new List<Permanent>() { card.PermanentOfThisCard() }, activateClass).Unsuspend());
-                        }
+                        yield return ContinuousController.instance.StartCoroutine(new IUnsuspendPermanents(new List<Permanent>() { selectedPermanent }, activateClass).Unsuspend());
                     }
                 }
             }

Assets/CardEffect/BT16/Black/Tankdramon_BT16_060.cs

@@ -283,10 +283,7 @@ namespace DCGO.CardEffects.BT16
                     {
                         if (CardEffectCommons.CanTriggerOnPermanentPlay(hashtable, PermanentCondition))
                         {
-                            if (CardEffectCommons.IsByEffect(hashtable, null))
-                            {
-                                return true;
-                            }
+                            return true;
                         }
                     }
 

Assets/CardEffect/BT16/Black/Zanmetsumon_BT16_062.cs

@@ -219,26 +219,25 @@ namespace DCGO.CardEffects.BT16
                             yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
                         }
 
-                        if (card.PermanentOfThisCard().cardSources.Count > 1)
+
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectDeletePermanentCondition))
                         {
-                            if (CardEffectCommons.HasMatchConditionPermanent(CanSelectDeletePermanentCondition))
-                            {
-                                selectPermanentEffect.SetUp(
-                                    selectPlayer: card.Owner,
-                                    canTargetCondition: CanSelectDeletePermanentCondition,
-                                    canTargetCondition_ByPreSelecetedList: null,
-                                    canEndSelectCondition: null,
-                                    maxCount: maxCount,
-                                    canNoSelect: false,
-                                    canEndNotMax: false,
-                                    selectPermanentCoroutine: null,
-                                    afterSelectPermanentCoroutine: null,
-                                    mode: SelectPermanentEffect.Mode.Destroy,
-                                    cardEffect: activateClass);
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectDeletePermanentCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: null,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Destroy,
+                                cardEffect: activateClass);
 
-                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                            }
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
                         }
+                        
                     }
 
                     yield return null;

Assets/CardEffect/BT16/Blue/DavisMotomiyaAndKenIchijoji_BT16_085.cs

@@ -182,7 +182,7 @@ namespace DCGO.CardEffects.BT16
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Memory +1", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
                 cardEffects.Add(activateClass);
 

Assets/CardEffect/BT16/Blue/Divemon_BT16_023.cs

@@ -134,70 +134,74 @@ namespace DCGO.CardEffects.BT16
                 }
             }
             #endregion
-            
-            #region Inherited Effect
-            if (timing == EffectTiming.OnAllyAttack)
+
+            #region Inherit
+            if (timing == EffectTiming.OnEndAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Trash 1 digivolution card", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false,
-                    EffectDiscription());
+                activateClass.SetUpICardEffect("Unsuspend this Digimon.", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
                 activateClass.SetIsInheritedEffect(true);
+                activateClass.SetHashString("Unsuspend_BT16_023");
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
                 {
-                    return "[When Attacking] Trash the top digivolution card of 1 of your opponent's Digimon.";
+                    return "[End of Attack][Once per turn] If this Digimon has [Pulsemon] in its text, by trashing the top card of your security stack, unsuspend this Digimon.";
                 }
 
-                bool CanSelectPermanentCondition(Permanent permanent)
+                bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card)
-                           && permanent.DigivolutionCards.Count(cardSource =>
-                               !cardSource.CanNotTrashFromDigivolutionCards(activateClass)) >= 1;
+                    return CardEffectCommons.CanTriggerOnEndAttack(hashtable, card);
                 }
 
-                bool CanUseCondition(Hashtable hashtable)
+                bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerOnAttack(hashtable, card);
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (card.PermanentOfThisCard().TopCard.HasText("Pulsemon"))
+                        {
+                            if (card.Owner.SecurityCards.Count >= 1)
+                            {
+                                if (CardEffectCommons.CanUnsuspend(card.PermanentOfThisCard()))
+                                {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+
+                    return false;
                 }
 
-                bool CanActivateCondition(Hashtable hashtable)
+                bool PermanentCondition(Permanent permanent)
                 {
-                    return CardEffectCommons.IsExistOnBattleArea(card) &&
-                           CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition);
+                    if (permanent == card.PermanentOfThisCard())
+                    {
+                        if (card.PermanentOfThisCard().TopCard.HasText("Pulsemon"))
+                        {
+                            if (CardEffectCommons.CanUnsuspend(card.PermanentOfThisCard()))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
                 }
 
-                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                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(new IDestroySecurity(
+                    player: card.Owner,
+                    destroySecurityCount: 1,
+                    cardEffect: activateClass,
+                    fromTop: true).DestroySecurity());
+
+                    if (CardEffectCommons.HasMatchConditionPermanent(PermanentCondition))
                     {
-                        yield return ContinuousController.instance.StartCoroutine(
-                            CardEffectCommons.TrashDigivolutionCardsFromTopOrBottom(targetPermanent: permanent,
-                                trashCount: 1, isFromTop: true, activateClass: activateClass));
+                        Permanent selectedPermanent = card.PermanentOfThisCard();
+
+                        yield return ContinuousController.instance.StartCoroutine(new IUnsuspendPermanents(new List<Permanent>() { selectedPermanent }, activateClass).Unsuspend());
                     }
                 }
             }

Assets/CardEffect/BT16/Blue/GaoGamon_BT16_020.cs

@@ -5,12 +5,12 @@ using System;
 
 namespace DCGO.CardEffects.BT16
 {
-    public class GaoGamon_BT16_020 : CEntity_Effect
+    public class Gaogamon_BT16_020 : CEntity_Effect
     {
         
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
-            var cardEffects = new List<ICardEffect>();
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Alternate Digivolution Requirement, Inherited Effect
             if(timing == EffectTiming.None)

Assets/CardEffect/BT16/Blue/ImperialdramonDragonMode_BT16_028.cs

@@ -2,7 +2,7 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
-namespace DCGO.CardEffects
+namespace DCGO.CardEffects.BT16
 {
     public class ImperialdramonDragonMode_BT16_028 : CEntity_Effect
     {
@@ -29,7 +29,7 @@ namespace DCGO.CardEffects
             #endregion
 
             #region When Digivolving
-            if (timing == EffectTiming.None)
+            if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("1 of your opponent's Digimon/Tamer can't unsuspend.", CanUseCondition, card);

Assets/CardEffect/BT16/Blue/ImperialdramonFighterModeAce_BT16_027.cs

@@ -2,7 +2,7 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
-namespace DCGO.CardEffects
+namespace DCGO.CardEffects.BT16
 {
     public class ImperialdramonFighterModeAce_BT16_027 : CEntity_Effect
     {

Assets/CardEffect/BT16/Blue/InvincibleDragonInsectFusion_BT16_092.cs

@@ -4,7 +4,7 @@ using System.Collections.Generic;
 using System.Linq;
 using UnityEngine;
 
-namespace DCGO.CardEffects
+namespace DCGO.CardEffects.BT16
 {
     public class InvincibleDragonInsectFusion_BT16_092 : CEntity_Effect
     {

Assets/CardEffect/BT16/Blue/MagnaAngemon_BT16_024.cs

@@ -148,12 +148,14 @@ namespace DCGO.CardEffects.BT16
                                     PlayCardClass playCardClass = new PlayCardClass(
                                         cardSources: new List<CardSource>() { selectedCard },
                                         hashtable: CardEffectCommons.CardEffectHashtable(activateClass),
-                                        payCost: false,
+                                        payCost: true,
                                         targetPermanent: card.PermanentOfThisCard(),
                                         isTapped: false,
                                         root: SelectCardEffect.Root.Security,
                                         activateETB: true);
-                                    
+
+                                    playCardClass.SetReducedCost(2);
+
                                     yield return ContinuousController.instance.StartCoroutine(playCardClass.PlayCard());
                                 }
                                 

Assets/CardEffect/BT16/Blue/Paildramon_BT16_025.cs

@@ -2,7 +2,7 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
-namespace DCGO.CardEffects
+namespace DCGO.CardEffects.BT16
 {
     public class Paildramon_BT16_025 : CEntity_Effect
     {
@@ -11,7 +11,7 @@ namespace DCGO.CardEffects
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Partition - Inherited
-            if(timing == EffectTiming.WhenPermanentWouldBeDeleted)
+            if(timing == EffectTiming.WhenRemoveField)
             {
                 bool CanSelectFirstSourceCondition(CardSource cardSource)
                 {

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

@@ -109,7 +109,7 @@ namespace DCGO.CardEffects.BT16
                                 reduceCostTuple: (reduceCost: 1, reduceCostCardCondition: null),
                                 fixedCostTuple: null,
                                 ignoreDigivolutionRequirementFixedCost: -1,
-                                isHand: false,
+                                isHand: true,
                                 activateClass: activateClass,
                                 successProcess: null));
                         }
@@ -200,7 +200,7 @@ namespace DCGO.CardEffects.BT16
                                 reduceCostTuple: (reduceCost: 1, reduceCostCardCondition: null),
                                 fixedCostTuple: null,
                                 ignoreDigivolutionRequirementFixedCost: -1,
-                                isHand: false,
+                                isHand: true,
                                 activateClass: activateClass,
                                 successProcess: null));
                         }

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

@@ -1,173 +1,173 @@
-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 1 digivolution card & stun 1 Digimon", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
-                cardEffects.Add(activateClass);
-                
-                string EffectDiscription()
-                {
-                    return "[All Turns] [Once Per Turn] When an opponent's Digimon becomes suspended, trash the top digivolution card of 1 of their Digimon. Then, 1 of their Digimon with no digivolution cards can't attack or block until the end of their turn.";
-                }
-                
-                bool CanSelectPermanentSourceStripCondition(Permanent permanent)
-                {
-                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
-                }
-                
-                bool CanSelectPermanentStunCondition(Permanent permanent)
-                {
-                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
-                    {
-                        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)
-                {
-                
-                    var selectPermanentSourceStripEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-                
-                    selectPermanentSourceStripEffect.SetUp(
-                        selectPlayer: card.Owner,
-                        canTargetCondition: CanSelectPermanentSourceStripCondition,
-                        canTargetCondition_ByPreSelecetedList: null,
-                        canEndSelectCondition: null,
-                        maxCount: 1,
-                        canNoSelect: false,
-                        canEndNotMax: false,
-                        selectPermanentCoroutine: SelectPermanentSourceStripCoroutine,
-                        afterSelectPermanentCoroutine: null,
-                        mode: SelectPermanentEffect.Mode.Custom,
-                        cardEffect: activateClass);
-                
-                    selectPermanentSourceStripEffect.SetUpCustomMessage("Select 1 Digimon that will trash digivolution cards.",
-                        "The opponent is selecting 1 Digimon that will trash digivolution cards.");
-                
-                    yield return ContinuousController.instance.StartCoroutine(selectPermanentSourceStripEffect.Activate());
-                
-                    IEnumerator SelectPermanentSourceStripCoroutine(Permanent permanent)
-                    {
-                        yield return ContinuousController.instance.StartCoroutine(
-                            CardEffectCommons.TrashDigivolutionCardsFromTopOrBottom(targetPermanent: permanent,
-                                trashCount: 1, isFromTop: true, activateClass: activateClass));
-                    }
-                
-                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentStunCondition))
-                    {
-                        SelectPermanentEffect selectPermanentStunEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-                    
-                        selectPermanentStunEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: CanSelectPermanentStunCondition,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: 1,
-                            canNoSelect: false,
-                            canEndNotMax: false,
-                            selectPermanentCoroutine: SelectPermanentStunCoroutine,
-                            afterSelectPermanentCoroutine: null,
-                            mode: SelectPermanentEffect.Mode.Custom,
-                            cardEffect: activateClass);
-                    
-                        selectPermanentStunEffect.SetUpCustomMessage("Select 1 Digimon that will get effects.", "The opponent is selecting 1 Digimon that will get effects.");
-
-                        yield return ContinuousController.instance.StartCoroutine(selectPermanentStunEffect.Activate());
-
-                        IEnumerator SelectPermanentStunCoroutine(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;
-        }
-    }
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System;
+
+namespace DCGO.CardEffects.BT16
+{
+    public class Togemoqumon_BT16_021 : CEntity_Effect
+    {
+        
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Alternate Digivolution Requirement, Blocker
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    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 1 digivolution card & stun 1 Digimon", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+                
+                string EffectDiscription()
+                {
+                    return "[All Turns] [Once Per Turn] When an opponent's Digimon becomes suspended, trash the top digivolution card of 1 of their Digimon. Then, 1 of their Digimon with no digivolution cards can't attack or block until the end of their turn.";
+                }
+                
+                bool CanSelectPermanentSourceStripCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                }
+                
+                bool CanSelectPermanentStunCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
+                    {
+                        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)
+                {
+                
+                    SelectPermanentEffect selectPermanentSourceStripEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                
+                    selectPermanentSourceStripEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: CanSelectPermanentSourceStripCondition,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: SelectPermanentSourceStripCoroutine,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Custom,
+                        cardEffect: activateClass);
+                
+                    selectPermanentSourceStripEffect.SetUpCustomMessage("Select 1 Digimon that will trash digivolution cards.",
+                        "The opponent is selecting 1 Digimon that will trash digivolution cards.");
+                
+                    yield return ContinuousController.instance.StartCoroutine(selectPermanentSourceStripEffect.Activate());
+                
+                    IEnumerator SelectPermanentSourceStripCoroutine(Permanent permanent)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(
+                            CardEffectCommons.TrashDigivolutionCardsFromTopOrBottom(targetPermanent: permanent,
+                                trashCount: 1, isFromTop: true, activateClass: activateClass));
+                    }
+                
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentStunCondition))
+                    {
+                        SelectPermanentEffect selectPermanentStunEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                    
+                        selectPermanentStunEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermanentStunCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: 1,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentStunCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+                    
+                        selectPermanentStunEffect.SetUpCustomMessage("Select 1 Digimon that will get effects.", "The opponent is selecting 1 Digimon that will get effects.");
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentStunEffect.Activate());
+
+                        IEnumerator SelectPermanentStunCoroutine(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 → Assets/CardEffect/BT16/Blue/Togemoqumon_BT16_021.cs.meta

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

Assets/CardEffect/BT16/Blue/Veemon_BT16_017.cs

@@ -31,8 +31,7 @@ namespace DCGO.CardEffects.BT16
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Memory +1", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false,
-                    EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -44,6 +43,7 @@ namespace DCGO.CardEffects.BT16
                 {
                     return CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card)
                            && permanent != card.PermanentOfThisCard()
+                           && permanent.IsDigimon
                            && (permanent.TopCard.CardColors.Contains(CardColor.Green)
                                || permanent.TopCard.ContainsTraits("Free"));
                 }

Assets/CardEffect/BT16/Blue/VikemonAce_BT16_026.cs

@@ -1,7 +1,7 @@
 using System.Collections;
 using System.Collections.Generic;
 
-namespace DCGO.CardEffects
+namespace DCGO.CardEffects.BT16
 {
     public class VikemonAce_BT16_026 : CEntity_Effect
     {

Assets/CardEffect/BT16/Green/GranKuwagamonAce_BT16_046.cs

@@ -130,7 +130,7 @@ namespace DCGO.CardEffects.BT16
                                     {
                                         if (!selectedPermanent.oldIsTapped_playCard)
                                         {
-                                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCantUnsuspendUntilOpponentTurnEnd(
+                                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCantUnsuspendNextActivePhase(
                                                 targetPermanent: selectedPermanent,
                                                 activateClass: activateClass
                                             ));

Assets/CardEffect/BT16/Green/MetallifeKuwagamon_BT16_045.cs

@@ -19,7 +19,7 @@ namespace DCGO.CardEffects.BT16
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Suspend and gain DP", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription()) ;
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -63,30 +63,50 @@ namespace DCGO.CardEffects.BT16
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.HasMatchConditionPermanent(PermanentCondition))
+                    List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                        {
+                            new SelectionElement<bool>(message: $"Yes", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"No", value : false, spriteIndex: 1),
+                        };
+
+                    string selectPlayerMessage = "Will you suspend 1 Digimon?";
+                    string notSelectPlayerMessage = "The opponent is choosing whether or not to suspend a Digimon.";
+
+                    GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+
+                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                    bool willSuspend = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+                    if (willSuspend)
                     {
-                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(PermanentCondition));
+                        if (CardEffectCommons.HasMatchConditionPermanent(PermanentCondition))
+                        {
 
-                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(PermanentCondition));
 
-                        selectPermanentEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: PermanentCondition,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: maxCount,
-                            canNoSelect: false,
-                            canEndNotMax: false,
-                            selectPermanentCoroutine: null,
-                            afterSelectPermanentCoroutine: null,
-                            mode: SelectPermanentEffect.Mode.Tap,
-                            cardEffect: activateClass);
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
 
-                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to suspend.", "The opponent is selecting 1 Digimon to suspend.");
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: PermanentCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: null,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Tap,
+                                cardEffect: activateClass);
 
-                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                            selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to suspend.", "The opponent is selecting 1 Digimon to suspend.");
+
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
+                        }
                     }
+
                     if (CardEffectCommons.HasMatchConditionPermanent(PermanentConditionForSecondEffect))
                     {
                         int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(PermanentConditionForSecondEffect));

Assets/CardEffect/BT16/Green/TerriermonXAntibody_BT16_038.cs

@@ -47,7 +47,7 @@ namespace DCGO.CardEffects.BT16
                         }
                     }
 
-                    return true;
+                    return false;
                 }
 
                 bool CardCondition(CardSource cardSource)

Assets/CardEffect/BT16/Purple/CherubimonXAntibody_BT16_079.cs

@@ -39,7 +39,7 @@ namespace DCGO.CardEffects.BT16
                 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");
+                activateClass.SetHashString("PlayDigimon_BT16_079");
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -218,7 +218,7 @@ namespace DCGO.CardEffects.BT16
                 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("DigivovleDigimon_BT16_079");
+                activateClass.SetHashString("PlayDigimon_BT16_079");
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()

Assets/CardEffect/BT16/Purple/DemonWoldOfTheCastleOfNineWolves_BT16_099.cs

@@ -126,149 +126,146 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if (card.Owner.TrashCards.Count(CanSelectCardCondition) >= 1)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
+                    return CardEffectCommons.CanDeclareOptionDelayEffect(card);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    #region reduce play cost
-                    ChangeCostClass changeCostClass = new ChangeCostClass();
-                    changeCostClass.SetUpICardEffect($"Play Cost -2", CanUseCondition1, card);
-                    changeCostClass.SetUpChangeCostClass(changeCostFunc: ChangeCost, cardSourceCondition: CardSourceCondition, rootCondition: RootCondition, isUpDown: isUpDown, isCheckAvailability: () => false, isChangePayingCost: () => true);
-                    Func<EffectTiming, ICardEffect> getCardEffect = GetCardEffect;
-                    card.Owner.UntilCalculateFixedCostEffect.Add(getCardEffect);
-
-                    ICardEffect GetCardEffect(EffectTiming _timing)
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: new List<Permanent>() { card.PermanentOfThisCard() }, activateClass: activateClass, successProcess: permanents => SuccessProcess(), failureProcess: null));
+
+                    IEnumerator SuccessProcess()
                     {
-                        if (_timing == EffectTiming.None)
+                        #region reduce play cost
+                        ChangeCostClass changeCostClass = new ChangeCostClass();
+                        changeCostClass.SetUpICardEffect($"Play Cost -2", CanUseCondition1, card);
+                        changeCostClass.SetUpChangeCostClass(changeCostFunc: ChangeCost, cardSourceCondition: CardSourceCondition, rootCondition: RootCondition, isUpDown: isUpDown, isCheckAvailability: () => false, isChangePayingCost: () => true);
+                        Func<EffectTiming, ICardEffect> getCardEffect = GetCardEffect;
+                        card.Owner.UntilCalculateFixedCostEffect.Add(getCardEffect);
+
+                        ICardEffect GetCardEffect(EffectTiming _timing)
                         {
-                            return changeCostClass;
-                        }
+                            if (_timing == EffectTiming.None)
+                            {
+                                return changeCostClass;
+                            }
 
-                        return null;
-                    }
+                            return null;
+                        }
 
-                    bool CanUseCondition1(Hashtable hashtable)
-                    {
-                        return true;
-                    }
+                        bool CanUseCondition1(Hashtable hashtable)
+                        {
+                            return true;
+                        }
 
-                    int ChangeCost(CardSource cardSource, int Cost, SelectCardEffect.Root root, List<Permanent> targetPermanents)
-                    {
-                        if (CardSourceCondition(cardSource))
+                        int ChangeCost(CardSource cardSource, int Cost, SelectCardEffect.Root root, List<Permanent> targetPermanents)
                         {
-                            if (RootCondition(root))
+                            if (CardSourceCondition(cardSource))
                             {
-                                if (PermanentsCondition(targetPermanents))
+                                if (RootCondition(root))
                                 {
-                                    Cost -= 2;
+                                    if (PermanentsCondition(targetPermanents))
+                                    {
+                                        Cost -= 2;
+                                    }
                                 }
                             }
-                        }
-
-                        return Cost;
-                    }
 
-                    bool PermanentsCondition(List<Permanent> targetPermanents)
-                    {
-                        if (targetPermanents == null)
-                        {
-                            return true;
+                            return Cost;
                         }
 
-                        else
+                        bool PermanentsCondition(List<Permanent> targetPermanents)
                         {
-                            if (targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0)
+                            if (targetPermanents == null)
                             {
                                 return true;
                             }
-                        }
 
-                        return false;
-                    }
+                            else
+                            {
+                                if (targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0)
+                                {
+                                    return true;
+                                }
+                            }
 
-                    bool CardSourceCondition(CardSource cardSource)
-                    {
-                        if (cardSource.HasPlayCost)
+                            return false;
+                        }
+
+                        bool CardSourceCondition(CardSource cardSource)
                         {
-                            if (cardSource.ContainsTraits("SoC"))
+                            if (cardSource.HasPlayCost)
                             {
-                                return true;
+                                if (cardSource.ContainsTraits("SoC"))
+                                {
+                                    return true;
+                                }
                             }
-                        }
 
-                        return false;
-                    }
+                            return false;
+                        }
 
-                    bool RootCondition(SelectCardEffect.Root root)
-                    {
-                        return true;
-                    }
+                        bool RootCondition(SelectCardEffect.Root root)
+                        {
+                            return true;
+                        }
 
-                    bool isUpDown()
-                    {
-                        return true;
-                    }
-                    #endregion
+                        bool isUpDown()
+                        {
+                            return true;
+                        }
+                        #endregion
 
-                    if (card.Owner.TrashCards.Count(CanSelectCardCondition) >= 1)
-                    {
-                        List<CardSource> selectedCards = new List<CardSource>();
-
-                        int maxCount = 1;
-
-                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
-
-                        selectCardEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: CanSelectCardCondition,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: maxCount,
-                            message: "Select 1 card to play.",
-                            canNoSelect: () => true,
-                            canEndNotMax: false,
-                            isShowOpponent: true,
-                            selectCardCoroutine: SelectCardCoroutine,
-                            afterSelectCardCoroutine: null,
-                            mode: SelectCardEffect.Mode.Custom,
-                            root: SelectCardEffect.Root.Trash,
-                            customRootCardList: null,
-                            canLookReverseCard: false,
-                            cardEffect: activateClass);
-
-                        selectCardEffect.SetUpCustomMessage("Select 1 card to play.", "The opponent is selecting 1 card to play.");
-                        selectCardEffect.SetUpCustomMessage_ShowCard("Played Card");
-
-                        yield return StartCoroutine(selectCardEffect.Activate());
-
-                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        if (card.Owner.TrashCards.Count(CanSelectCardCondition) >= 1)
                         {
-                            selectedCards.Add(cardSource);
+                            List<CardSource> selectedCards = new List<CardSource>();
+
+                            int maxCount = 1;
+
+                            SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                            selectCardEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectCardCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount,
+                                message: "Select 1 card to play.",
+                                canNoSelect: () => true,
+                                canEndNotMax: false,
+                                isShowOpponent: true,
+                                selectCardCoroutine: SelectCardCoroutine,
+                                afterSelectCardCoroutine: null,
+                                mode: SelectCardEffect.Mode.Custom,
+                                root: SelectCardEffect.Root.Trash,
+                                customRootCardList: null,
+                                canLookReverseCard: false,
+                                cardEffect: activateClass);
+
+                            selectCardEffect.SetUpCustomMessage("Select 1 card to play.", "The opponent is selecting 1 card to play.");
+                            selectCardEffect.SetUpCustomMessage_ShowCard("Played Card");
 
-                            yield return null;
+                            yield return StartCoroutine(selectCardEffect.Activate());
+
+                            IEnumerator SelectCardCoroutine(CardSource cardSource)
+                            {
+                                selectedCards.Add(cardSource);
+
+                                yield return null;
+                            }
+
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
+                                cardSources: selectedCards,
+                                activateClass: activateClass,
+                                payCost: true,
+                                isTapped: false,
+                                root: SelectCardEffect.Root.Trash,
+                                activateETB: true));
                         }
 
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
-                            cardSources: selectedCards,
-                            activateClass: activateClass,
-                            payCost: true,
-                            isTapped: false,
-                            root: SelectCardEffect.Root.Trash,
-                            activateETB: true));
+                        #region Remove Cost effect after use
+                        card.Owner.UntilCalculateFixedCostEffect.Remove(getCardEffect);
+                        #endregion
                     }
-
-                    #region Remove Cost effect after use
-                    card.Owner.UntilCalculateFixedCostEffect.Remove(getCardEffect);
-                    #endregion
                 }
             }
             #endregion

Assets/CardEffect/BT16/Purple/Dinobeemon_BT16_077.cs

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

Assets/CardEffect/BT16/Purple/GesomonXAntibody_BT16_069.cs

@@ -27,7 +27,7 @@ namespace DCGO.CardEffects.BT16
             #endregion
 
             #region On Play / When Digivolving
-            if (timing == EffectTiming.None)
+            if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Trash sources and give effects.", CanUseCondition, card);
@@ -87,10 +87,7 @@ namespace DCGO.CardEffects.BT16
                     {
                         if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                         {
-                            if (card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) => cardSource.CardNames.Contains("Gesomon") || cardSource.CardNames.Contains("X Antibody") || cardSource.CardNames.Contains("XAntibody")) >= 1)
-                            {
-                                return true;
-                            }
+                            return true;
                         }
                     }
 
@@ -99,7 +96,7 @@ namespace DCGO.CardEffects.BT16
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition) && card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) => cardSource.CardNames.Contains("Gesomon") || cardSource.CardNames.Contains("X Antibody") || cardSource.CardNames.Contains("XAntibody")) >= 1)
                     {
                         int maxCountToTrash = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
 

Assets/CardEffect/BT16/Purple/MaloMyotismon_BT16_081.cs

@@ -123,8 +123,11 @@ namespace DCGO.CardEffects.BT16
 
                     IEnumerator SuccessProcess()
                     {
-                        if(CardEffectCommons.IsExistOnBattleArea(card))
+                        bool attemptedToDeletedUnsuspended = false;
+
+                        if (CardEffectCommons.IsExistOnBattleArea(card))
                         {
+
                             if (CardEffectCommons.HasMatchConditionPermanent(CanSelectOpponentUnsuspendedDigimon))
                             {
                                 int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectOpponentUnsuspendedDigimon));
@@ -157,10 +160,12 @@ namespace DCGO.CardEffects.BT16
 
                                     yield return null;
                                 }
-                                
-                                
+
+
                                 yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: deleteTargetPermanents, activateClass: activateClass, successProcess: null, failureProcess: FailureProcess));
 
+                                attemptedToDeletedUnsuspended = true;
+
                                 IEnumerator FailureProcess()
                                 {
                                     if (CardEffectCommons.IsExistOnBattleArea(card))
@@ -195,16 +200,52 @@ namespace DCGO.CardEffects.BT16
                                                     deleteTargetPermanents.Add(permanent);
                                                 }
 
-                                                yield return null;
+                                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: deleteTargetPermanents, activateClass: activateClass, successProcess: null, failureProcess: null));
                                             }
+                                        }
+                                    }
+                                }
+                            }
 
+                            if (!CardEffectCommons.HasMatchConditionPermanent(CanSelectOpponentUnsuspendedDigimon) && CardEffectCommons.HasMatchConditionPermanent(CanSelectOpponentTamer) && attemptedToDeletedUnsuspended == false)
+                            {
 
-                                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: deleteTargetPermanents, activateClass: activateClass, successProcess: null, failureProcess: null));
-                                        }
+                                int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectOpponentTamer));
+
+                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                                selectPermanentEffect.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: CanSelectOpponentTamer,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: maxCount,
+                                    canNoSelect: false,
+                                    canEndNotMax: false,
+                                    selectPermanentCoroutine: null,
+                                    afterSelectPermanentCoroutine: AfterSelectPermanentCoroutine,
+                                    mode: SelectPermanentEffect.Mode.Custom,
+                                    cardEffect: activateClass);
+
+                                selectPermanentEffect.SetUpCustomMessage("Select 1 Tamer to delete.", "The opponent is selecting 1 Tamer to delete.");
+
+                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                                IEnumerator AfterSelectPermanentCoroutine(List<Permanent> permanents)
+                                {
+                                    foreach (Permanent permanent in permanents)
+                                    {
+                                        deleteTargetPermanents.Add(permanent);
                                     }
+
+                                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: deleteTargetPermanents, activateClass: activateClass, successProcess: null, failureProcess: null));
                                 }
+
                             }
                         }
+
+                        
+                        
                     }
 
                     

Assets/CardEffect/BT16/Purple/Mummymon_BT16_073.cs

@@ -15,7 +15,7 @@ namespace DCGO.CardEffects.BT16
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Retaliation
-            if (timing == EffectTiming.None)
+            if (timing == EffectTiming.OnDestroyedAnyone)
             {
                 cardEffects.Add(CardEffectFactory.RetaliationSelfEffect(isInheritedEffect: false, card: card, condition: null));
             }

Assets/CardEffect/BT16/Purple/Soloogarmon_BT16_076.cs

@@ -260,6 +260,89 @@ namespace DCGO.CardEffects.BT16
             }
             #endregion
 
+            #region All Turns
+            if (timing == EffectTiming.OnDestroyedAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Digivolve into [FenriLoogamon] from your trash.", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[All Turns] When one of your other Digimon with the [SoC] trait is deleted, this Digimon with a Tamer with the [SoC] trait in its digivolution cardsmay digivolve into [FenriLoogamon] from your trash without paying the cost.";
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card))
+                    {
+                        if (permanent != card.PermanentOfThisCard())
+                        {
+                            if (permanent.TopCard.CardTraits.Contains("SoC"))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.IsOwnerTurn(card))
+                        {
+                            if (CardEffectCommons.CanTriggerOnPermanentDeleted(hashtable, PermanentCondition))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanSelectFenriInTrash(CardSource cardSource)
+                {
+                    if (cardSource.CardNames.Contains("FenriLoogamon"))
+                    {
+                        return true;
+                    }
+                    return false;
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (card.PermanentOfThisCard().DigivolutionCards.Count((cardSource) => (cardSource.CardTraits.Contains("SoC") && cardSource.IsTamer)) >= 1)
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DigivolveIntoHandOrTrashCard(
+                    targetPermanent: card.PermanentOfThisCard(),
+                    cardCondition: cardSource => CanSelectFenriInTrash(cardSource),
+                    payCost: false,
+                    reduceCostTuple: null,
+                    fixedCostTuple: null,
+                    ignoreDigivolutionRequirementFixedCost: -1,
+                    isHand: false,
+                    activateClass: activateClass,
+                    successProcess: null));
+                }
+            }
+            #endregion
+
             return cardEffects;
         }
     }

Assets/CardEffect/BT16/Purple/SyakomonXAntibody_BT16_066.cs

@@ -21,8 +21,8 @@ namespace DCGO.CardEffects.BT16
             }
             #endregion
 
-            #region Start of Main / When Digivolving
-            if (timing == EffectTiming.OnStartMainPhase || timing == EffectTiming.OnEnterFieldAnyone)
+            #region Start of Main
+            if (timing == EffectTiming.OnStartMainPhase)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Your opponent trashes a card or else you gain a memory.", CanUseCondition, card);
@@ -31,7 +31,7 @@ namespace DCGO.CardEffects.BT16
 
                 string EffectDiscription()
                 {
-                    return "[Start of Your Main Phase] [When Digivolving] Your opponent may trash 1 Digimon card in their hand. If they don't, gain 1 memory.";
+                    return "[Start of Your Main Phase] Your opponent may trash 1 Digimon card in their hand. If they don't, gain 1 memory.";
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -44,27 +44,85 @@ namespace DCGO.CardEffects.BT16
                         }
                     }
 
-                    if(CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if(CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card))
-                        {
-                            return true;
-                        }
-                    }
-
                     return false;
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if(CardEffectCommons.IsExistOnBattleArea(card))
+                    return CardEffectCommons.IsExistOnBattleArea(card);
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    return cardSource.IsDigimon;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    bool discarded = false;
+
+                    if (card.Owner.Enemy.HandCards.Count >= 1)
                     {
-                        if (card.Owner.Enemy.HandCards.Count >= 1)
+                        int discardCount = 1;
+
+                        SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                        selectHandEffect.SetUp(
+                            selectPlayer: card.Owner.Enemy,
+                            canTargetCondition: CanSelectCardCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: discardCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            isShowOpponent: true,
+                            selectCardCoroutine: null,
+                            afterSelectCardCoroutine: AfterSelectCardCoroutine,
+                            mode: SelectHandEffect.Mode.Discard,
+                            cardEffect: activateClass);
+
+                        yield return StartCoroutine(selectHandEffect.Activate());
+
+                        IEnumerator AfterSelectCardCoroutine(List<CardSource> cardSources)
                         {
-                            return true;
+                            if (cardSources.Count >= 1)
+                            {
+                                discarded = true;
+
+                                yield return null;
+                            }
                         }
                     }
-                    return false;
+
+                    if (!discarded)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(1, activateClass));
+                    }
+                }
+            }
+            #endregion
+
+            #region When Digivolving
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Your opponent trashes a card or else you gain a memory.", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] Your opponent may trash 1 Digimon card in their hand. If they don't, gain 1 memory.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(card);
                 }
 
                 bool CanSelectCardCondition(CardSource cardSource)
@@ -122,7 +180,7 @@ namespace DCGO.CardEffects.BT16
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Draw 1 and trash 1 card from hand", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
                 activateClass.SetIsInheritedEffect(true);
                 activateClass.SetHashString("DrawTrashBT16_066");
                 cardEffects.Add(activateClass);
@@ -139,25 +197,13 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.CanActivateOnDeletionInherited(hashtable, card))
-                    {
-                        if (card.Owner.LibraryCards.Count >= 1)
-                        {
-                            return true;
-                        }
-
-                        if (card.Owner.HandCards.Count >= 1)
-                        {
-                            return true;
-                        }
-                    }
-
-                    return false;
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
+                    if (card.Owner.LibraryCards.Count >= 1)
+                        yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
 
                     if (card.Owner.HandCards.Count >= 1)
                     {

Assets/CardEffect/BT16/Red/Aquilamon_BT16_008.cs

@@ -101,7 +101,7 @@ namespace DCGO.CardEffects.BT16
             #endregion
 
             #region Inherit
-            if (timing == EffectTiming.OnUseAttack)
+            if (timing == EffectTiming.OnAllyAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Suspend 1 of your opponent's Digimon.", CanUseCondition, card);

Assets/CardEffect/BT16/Red/BeastlyStormDanceofAffection_BT16_091.cs

@@ -249,18 +249,18 @@ namespace DCGO.CardEffects.BT16
             if (timing == EffectTiming.SecuritySkill)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Play 1 [Aquilamon] or [Gatomon]", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Play 1 [Hawkmon] or [Salamon]", CanUseCondition, card);
                 activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
                 {
-                    return "[Security] You may play 1 [Aquilamon] or [Gatomon] from your hand without paying the cost. Then, add this card to the hand.";
+                    return "[Security] You may play 1 [Hawkmon] or [Salamon] from your hand or trash without paying the cost. Then, add this card to the hand.";
                 }
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    if (cardSource.CardNames.Contains("Aquilamon") || cardSource.CardNames.Contains("Gatomon"))
+                    if (cardSource.CardNames.Contains("Hawkmon") || cardSource.CardNames.Contains("Salamon"))
                     {
                         if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass))
                         {
@@ -278,41 +278,116 @@ namespace DCGO.CardEffects.BT16
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
+                    bool canSelectHand = card.Owner.HandCards.Count(CanSelectCardCondition) >= 1;
+                    bool canSelectTrash = CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition);
+
+                    if (canSelectHand || canSelectTrash)
                     {
-                        List<CardSource> selectedCards = new List<CardSource>();
+                        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),
+                        };
 
-                        int maxCount = 1;
+                            string selectPlayerMessage = "From which area do you select a card?";
+                            string notSelectPlayerMessage = "The opponent is choosing from which area to select a card.";
 
-                        SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+                            GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                        }
 
-                        selectHandEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: CanSelectCardCondition,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: maxCount,
-                            canNoSelect: true,
-                            canEndNotMax: false,
-                            isShowOpponent: true,
-                            selectCardCoroutine: SelectCardCoroutine,
-                            afterSelectCardCoroutine: null,
-                            mode: SelectHandEffect.Mode.Custom,
-                            cardEffect: activateClass);
+                        else
+                        {
+                            GManager.instance.userSelectionManager.SetBool(canSelectHand);
+                        }
 
-                        selectHandEffect.SetUpCustomMessage("Select 1 Digimon to play.", "The opponent is selecting 1 Digimon to play.");
-                        selectHandEffect.SetUpCustomMessage_ShowCard("Played Card");
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                        yield return StartCoroutine(selectHandEffect.Activate());
+                        bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
 
-                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                        if(fromHand)
                         {
-                            selectedCards.Add(cardSource);
+                            if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
+                            {
+                                List<CardSource> selectedCards = new List<CardSource>();
 
-                            yield return null;
+                                int maxCount = 1;
+
+                                SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                                selectHandEffect.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: CanSelectCardCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: maxCount,
+                                    canNoSelect: true,
+                                    canEndNotMax: false,
+                                    isShowOpponent: true,
+                                    selectCardCoroutine: SelectCardCoroutine,
+                                    afterSelectCardCoroutine: null,
+                                    mode: SelectHandEffect.Mode.Custom,
+                                    cardEffect: activateClass);
+
+                                selectHandEffect.SetUpCustomMessage("Select 1 Digimon to play.", "The opponent is selecting 1 Digimon to play.");
+                                selectHandEffect.SetUpCustomMessage_ShowCard("Played Card");
+
+                                yield return StartCoroutine(selectHandEffect.Activate());
+
+                                IEnumerator SelectCardCoroutine(CardSource cardSource)
+                                {
+                                    selectedCards.Add(cardSource);
+
+                                    yield return null;
+                                }
+
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: selectedCards, activateClass: activateClass, payCost: false, isTapped: false, root: SelectCardEffect.Root.Hand, activateETB: true));
+                            }
                         }
+                        else
+                        {
+                            if (card.Owner.TrashCards.Count(CanSelectCardCondition) >= 1)
+                            {
+                                int maxCount = 1;
 
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: selectedCards, activateClass: activateClass, payCost: false, isTapped: false, root: SelectCardEffect.Root.Hand, activateETB: true));
+                                List<CardSource> selectedCards = new List<CardSource>();
+
+                                SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                                selectCardEffect.SetUp(
+                                    canTargetCondition: CanSelectCardCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    canNoSelect: () => true,
+                                    selectCardCoroutine: SelectCardCoroutine,
+                                    afterSelectCardCoroutine: null,
+                                    message: "Select 1 Digimon to play.",
+                                    maxCount: maxCount,
+                                    canEndNotMax: false,
+                                    isShowOpponent: true,
+                                    mode: SelectCardEffect.Mode.Custom,
+                                    root: SelectCardEffect.Root.Trash,
+                                    customRootCardList: null,
+                                    canLookReverseCard: true,
+                                    selectPlayer: card.Owner,
+                                    cardEffect: activateClass);
+
+                                selectCardEffect.SetUpCustomMessage_ShowCard("Played Card");
+                                selectCardEffect.SetUpCustomMessage("Select 1 Digimon to play.", "The opponent is selecting 1 Digimon to play.");
+
+                                yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                                IEnumerator SelectCardCoroutine(CardSource cardSource)
+                                {
+                                    selectedCards.Add(cardSource);
+
+                                    yield return null;
+                                }
+
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: selectedCards, activateClass: activateClass, payCost: false, isTapped: false, root: SelectCardEffect.Root.Trash, activateETB: true));
+                            }
+                        }
                     }
 
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.AddThisCardToHand(card, activateClass));

Assets/CardEffect/BT16/Red/GarudamonXAntibody_BT16_011.cs

@@ -206,7 +206,8 @@ namespace DCGO.CardEffects.BT16
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("1 of your Digimon gains <Rush>.", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+                activateClass.SetHashString("GainRush_BT16_011");
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()

Assets/CardEffect/BT16/Red/Hawkmon_BT16_007.cs

@@ -68,7 +68,7 @@ namespace DCGO.CardEffects.BT16
                 {
                     if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
-                        if (CardEffectCommons.CanTriggerOnPermanentPlay(hashtable, PermanentCondition))
+                        if (CardEffectCommons.CanTriggerOnPermanentPlay(hashtable, PermanentCondition) || CardEffectCommons.CanTriggerWhenPermanentDigivolving(hashtable, PermanentCondition))
                         {
                             if (CardEffectCommons.IsOwnerTurn(card))
                             {
@@ -101,10 +101,10 @@ namespace DCGO.CardEffects.BT16
             #endregion
             
             #region inherited effect
-            if (timing == EffectTiming.OnUseAttack)
+            if (timing == EffectTiming.OnAllyAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Suspend 1", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Suspend 1 of your opponent's Digimon", CanUseCondition, card);
                 activateClass.SetIsInheritedEffect(true);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);

Assets/CardEffect/BT16/Red/Helloogarmon_BT16_010.cs

@@ -37,6 +37,13 @@ namespace DCGO.CardEffects.BT16
             }
             #endregion
 
+            #region Retaliation
+            if (timing == EffectTiming.OnDestroyedAnyone)
+            {
+                cardEffects.Add(CardEffectFactory.RetaliationSelfEffect(isInheritedEffect: false, card: card, condition: null));
+            }
+            #endregion
+
             #region End of Opponent's Turn
             if (timing == EffectTiming.OnEndTurn)
             {
@@ -159,12 +166,7 @@ namespace DCGO.CardEffects.BT16
                 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        return true;
-                    }
-
-                    return false;
+                    return CardEffectCommons.CanTriggerOnDeletion(hashtable, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
@@ -174,9 +176,9 @@ namespace DCGO.CardEffects.BT16
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, (cardSource) => CanSelectCardCondition(cardSource)))
+                    if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                     {
-                        int maxCount = Math.Min(1, card.Owner.TrashCards.Count((cardSource) => CanSelectCardCondition(cardSource)));
+                        int maxCount = Math.Min(1, card.Owner.TrashCards.Count(CanSelectCardCondition));
 
                         List<CardSource> selectedCards = new List<CardSource>();
 

Assets/CardEffect/BT16/Red/Lynxmon_BT16_009.cs

@@ -60,7 +60,7 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card))
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
                     {
                         return true;
                     }

Assets/CardEffect/BT16/Red/Poromon_BT16_001.cs

@@ -10,7 +10,7 @@ namespace DCGO.CardEffects.BT16
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Inherit
-            if (timing == EffectTiming.OnUseAttack)
+            if (timing == EffectTiming.OnAllyAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Delete opponent's Digimon with 2000 DP or less.", CanUseCondition, card);
@@ -42,7 +42,7 @@ namespace DCGO.CardEffects.BT16
 
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card))
+                    if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
                     {
                         if (permanent.DP <= 2000)
                         {

Assets/CardEffect/BT16/Red/Silphymon_BT16_012.cs

@@ -246,13 +246,13 @@ namespace DCGO.CardEffects.BT16
                                         mode: SelectPermanentEffect.Mode.Custom,
                                         cardEffect: activateClass);
 
-                                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will get DP -7000.", "The opponent is selecting 1 Digimon that will get DP -5000.");
+                                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will get DP -7000.", "The opponent is selecting 1 Digimon that will get DP -7000.");
 
                                     yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
                                     IEnumerator SelectPermanentCoroutine(Permanent permanent)
                                     {
-                                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: permanent, changeValue: -5000, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
+                                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: permanent, changeValue: -7000, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
                                     }
                                 }
                             }

Assets/CardEffect/BT16/Red/ValkyrimonAce_BT16_013.cs

@@ -47,7 +47,7 @@ namespace DCGO.CardEffects.BT16
 
                 string EffectDiscription()
                 {
-                    return "[On Play] [When Digivolving] Until the end of your opponent's next turn, all of your opponent's Digimon get -5000DP.";
+                    return "[On Play] [When Digivolving] All of your opponent's Digimon get -5000DP for the turn.";
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -75,7 +75,7 @@ namespace DCGO.CardEffects.BT16
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDPPlayerEffect(
                         permanentCondition: PermanentCondition,
                         changeValue: -5000,
-                        effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                        effectDuration: EffectDuration.UntilEachTurnEnd,
                         activateClass: activateClass));
                 }
             }

Assets/CardEffect/BT16/White/BigUkkomon_BT16_083.cs

@@ -18,8 +18,8 @@ namespace DCGO.CardEffects.BT16
             if (timing == EffectTiming.OnDestroyedAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpICardEffect("Return all Tamers, then play a Tamer and [Ukkomon] from your trash.", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -190,7 +190,7 @@ namespace DCGO.CardEffects.BT16
             {
                 
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Attack with this Digimon without suspending", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Return 1 Digi-Egg to delete 1 opponent Digimon with the lowest level and play a level 4 Digimon.", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
                 activateClass.SetHashString("Effect_BT16_083");
                 cardEffects.Add(activateClass);
@@ -198,7 +198,7 @@ namespace DCGO.CardEffects.BT16
 
                 string EffectDiscription()
                 {
-                    return "[End of Your Turn][Once Per Turn] By returning 1 Digi-Egg card from your trash to the bottom of your Digi-Egg deck, delete 1 of your opponent's Digimon with the lowest level. Then you may play 1 level 4 or lower Digimon card from your hand to the breeding area without paying the cost.";
+                    return "[End of Your Turn] [Once Per Turn] By returning 1 Digi-Egg card from your trash to the bottom of your Digi-Egg deck, delete 1 of your opponent's Digimon with the lowest level. Then you may play 1 level 4 or lower Digimon card from your hand to the breeding area without paying the cost.";
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -226,32 +226,24 @@ namespace DCGO.CardEffects.BT16
                     return false;
                 }
 
-                bool CanSelectCardCondition(CardSource card)
+                bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    if(card.IsDigiEgg)
+                    if(cardSource.IsDigiEgg)
                     {
                         return true;
                     }
                     return false;
                 }
 
-                bool CanSelectLevel4InHand(CardSource card)
+                bool CanSelectLevel4InHand(CardSource cardSource)
                 {
-                    if (card.IsDigimon)
+                    if (cardSource.IsDigimon)
                     {
-                        if(card.HasLevel)
+                        if(cardSource.HasLevel)
                         {
-                            if(card.Level <= 4)
+                            if(cardSource.Level <= 4)
                             {
-                                if (CardEffectCommons.CanPlayAsNewPermanent(
-                                    cardSource: card,
-                                    payCost: false,
-                                    cardEffect: activateClass,
-                                    isBreedingArea: true))
-                                {
-                                    return true;
-                                }
-                                
+                                return true;
                             }
                         }
                     }
@@ -317,24 +309,15 @@ namespace DCGO.CardEffects.BT16
                                     maxCount: maxCount,
                                     canNoSelect: true,
                                     canEndNotMax: false,
-                                    selectPermanentCoroutine: SelectPermanentCoroutine,
+                                    selectPermanentCoroutine: null,
                                     afterSelectPermanentCoroutine: null,
-                                    mode: SelectPermanentEffect.Mode.Custom,
+                                    mode: SelectPermanentEffect.Mode.Destroy,
                                     cardEffect: activateClass);
 
                                 selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to delete.", "The opponent is selecting 1 Digimon to delete.");
 
                                 yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
-                                IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                                {
-                                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: new List<Permanent>() { permanent }, activateClass: activateClass, successProcess: permanents => SuccessProcess(), failureProcess: null));
-
-                                    IEnumerator SuccessProcess()
-                                    {
-                                        yield return null;
-                                    }
-                                }
                             }
                         }
                     }
@@ -349,7 +332,7 @@ namespace DCGO.CardEffects.BT16
 
                         selectHandEffect.SetUp(
                             selectPlayer: card.Owner,
-                            canTargetCondition: CanSelectCardCondition,
+                            canTargetCondition: CanSelectLevel4InHand,
                             canTargetCondition_ByPreSelecetedList: null,
                             canEndSelectCondition: null,
                             maxCount: maxCount,
@@ -383,7 +366,6 @@ namespace DCGO.CardEffects.BT16
                             isBreedingArea: true));
                     }
 
-                    yield return null;
                 }
                 
             }

Assets/CardEffect/BT16/White/LuiOhwada_BT16_090.cs

@@ -40,10 +40,7 @@ namespace DCGO.CardEffects.BT16
                     {
                         if (permanent.TopCard.CardNames.Contains("Ukkomon"))
                         {
-                            if (!permanent.IsToken)
-                            {
-                                return true;
-                            }
+                            return true;
                         }
                     }
 
@@ -59,7 +56,6 @@ namespace DCGO.CardEffects.BT16
                             return true;
                         }
                     }
-                    
 
                     return false;
                 }
@@ -68,14 +64,7 @@ namespace DCGO.CardEffects.BT16
                 {
                     if (cardSource.CardNames.Contains("BigUkkomon"))
                     {
-                        if (CardEffectCommons.CanPlayAsNewPermanent(
-                            cardSource: card,
-                            payCost: false,
-                            cardEffect: activateClass,
-                            isBreedingArea: true))
-                        {
-                            return true;
-                        }
+                        return true;
                     }
                     return false;
                 }
@@ -93,7 +82,13 @@ namespace DCGO.CardEffects.BT16
                 {
                     if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
-                        return true;
+                        if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, CanSelectPermanentCondition) && card.Owner.GetBreedingAreaPermanents().Count(CanSelectBreedingAreaDigimon) >= 1)
+                        {
+                            if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
+                            {
+                                return true;
+                            }
+                        }
                     }
                     return false;
                 }
@@ -132,113 +127,113 @@ namespace DCGO.CardEffects.BT16
                             {
                                 ukkomonDeleted = true;
 
-                                yield return null;
-                            }
-                        }
-                    }
-
-                    if (card.Owner.GetBreedingAreaPermanents().Count(CanSelectBreedingAreaDigimon) >= 1)
-                    {
+                                if (card.Owner.GetBreedingAreaPermanents().Count(CanSelectBreedingAreaDigimon) >= 1)
+                                {
 
-                        List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                                    List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                         {
                             new SelectionElement<bool>(message: $"Yes", value : true, spriteIndex: 0),
                             new SelectionElement<bool>(message: $"No", value : false, spriteIndex: 1),
                         };
 
-                        string selectPlayerMessage = "Will you trash breeding area Digimon to play [BigUkkomon] from your hand?";
-                        string notSelectPlayerMessage = "The opponent is choosing whether or not to trash cards.";
+                                    string selectPlayerMessage = "Will you trash breeding area Digimon to play [BigUkkomon] from your hand?";
+                                    string notSelectPlayerMessage = "The opponent is choosing whether or not to trash cards.";
 
-                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                                    GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
 
-                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+                                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
 
-                        bool trashBreedingAreaDigimon = GManager.instance.userSelectionManager.SelectedBoolValue; 
+                                    bool trashBreedingAreaDigimon = GManager.instance.userSelectionManager.SelectedBoolValue;
 
-                        if (trashBreedingAreaDigimon)
-                        {
-                            List<Permanent> DigitamaPermanents = card.Owner.GetBreedingAreaPermanents()
-                                            .Filter(permanent => permanent.IsDigimon)
-                                            .Filter(permanent => !permanent.TopCard.CanNotBeAffected(activateClass))
-                                            .Clone();
+                                    if (trashBreedingAreaDigimon)
+                                    {
+                                        List<Permanent> DigitamaPermanents = card.Owner.GetBreedingAreaPermanents()
+                                                        .Filter(permanent => permanent.IsDigimon)
+                                                        .Clone();
 
-                            if (DigitamaPermanents.Count >= 1)
-                            {
-                                foreach (Permanent permanent in DigitamaPermanents)
-                                {
-                                    yield return ContinuousController.instance.StartCoroutine(permanent.DiscardEvoRoots());
+                                        if (DigitamaPermanents.Count >= 1)
+                                        {
+                                            foreach (Permanent permanent in DigitamaPermanents)
+                                            {
+                                                yield return ContinuousController.instance.StartCoroutine(permanent.DiscardEvoRoots());
 
-                                    CardSource cardSource = permanent.TopCard;
+                                                CardSource cardSource = permanent.TopCard;
 
-                                    ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect(new List<CardSource>() { cardSource }, "Cards put to trash", true, true));
+                                                ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect(new List<CardSource>() { cardSource }, "Cards put to trash", true, true));
 
-                                    yield return ContinuousController.instance.StartCoroutine(CardObjectController.RemoveField(permanent));
-                                    yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddTrashCard(cardSource));
-                                    breedingAreaPermanentDeleted = true;
-                                }
-                            }
-                        }
-                    }
 
-                    if(ukkomonDeleted && breedingAreaPermanentDeleted)
-                    {
-                        if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
-                        {
-                            List<CardSource> selectedCards = new List<CardSource>();
+                                                yield return ContinuousController.instance.StartCoroutine(CardObjectController.RemoveField(permanent));
+                                                yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddTrashCard(cardSource));
+                                                breedingAreaPermanentDeleted = true;
+                                            }
+                                        }
+                                    }
 
-                            int maxCount = 1;
+                                    if (ukkomonDeleted && breedingAreaPermanentDeleted)
+                                    {
+                                        if (card.Owner.HandCards.Count(CanSelectCardCondition) >= 1)
+                                        {
+                                            List<CardSource> selectedCards = new List<CardSource>();
 
-                            SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+                                            int maxCount = 1;
 
-                            selectHandEffect.SetUp(
-                                selectPlayer: card.Owner,
-                                canTargetCondition: CanSelectCardCondition,
-                                canTargetCondition_ByPreSelecetedList: null,
-                                canEndSelectCondition: null,
-                                maxCount: maxCount,
-                                canNoSelect: true,
-                                canEndNotMax: false,
-                                isShowOpponent: true,
-                                selectCardCoroutine: SelectCardCoroutine,
-                                afterSelectCardCoroutine: null,
-                                mode: SelectHandEffect.Mode.Custom,
-                                cardEffect: activateClass);
+                                            SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
 
-                            selectHandEffect.SetUpCustomMessage("Select 1 card to play.", "The opponent is selecting 1 card to play.");
-                            selectHandEffect.SetUpCustomMessage_ShowCard("Played Card");
+                                            selectHandEffect.SetUp(
+                                                selectPlayer: card.Owner,
+                                                canTargetCondition: CanSelectCardCondition,
+                                                canTargetCondition_ByPreSelecetedList: null,
+                                                canEndSelectCondition: null,
+                                                maxCount: maxCount,
+                                                canNoSelect: true,
+                                                canEndNotMax: false,
+                                                isShowOpponent: true,
+                                                selectCardCoroutine: SelectCardCoroutine,
+                                                afterSelectCardCoroutine: null,
+                                                mode: SelectHandEffect.Mode.Custom,
+                                                cardEffect: activateClass);
 
-                            yield return StartCoroutine(selectHandEffect.Activate());
+                                            selectHandEffect.SetUpCustomMessage("Select 1 card to play.", "The opponent is selecting 1 card to play.");
+                                            selectHandEffect.SetUpCustomMessage_ShowCard("Played Card");
 
-                            IEnumerator SelectCardCoroutine(CardSource cardSource)
-                            {
-                                selectedCards.Add(cardSource);
+                                            yield return StartCoroutine(selectHandEffect.Activate());
+
+                                            IEnumerator SelectCardCoroutine(CardSource cardSource)
+                                            {
+                                                selectedCards.Add(cardSource);
+
+                                                yield return null;
+                                            }
 
-                                yield return null;
-                            }
 
+                                            PlayCardClass playCard = new PlayCardClass(
+                                                                cardSources: new List<CardSource>() { selectedCards[0] },
+                                                                hashtable: CardEffectCommons.CardEffectHashtable(activateClass),
+                                                                payCost: true,
+                                                                targetPermanent: null,
+                                                                isTapped: false,
+                                                                root: SelectCardEffect.Root.Hand,
+                                                                activateETB: true
+                                                                );
 
-                            PlayCardClass playCard = new PlayCardClass(
-                                                cardSources: new List<CardSource>() { selectedCards[0] },
-                                                hashtable: CardEffectCommons.CardEffectHashtable(activateClass),
+
+                                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
+                                                cardSources: playCard.CardSources,
+                                                activateClass: activateClass,
                                                 payCost: true,
-                                                targetPermanent: null,
                                                 isTapped: false,
                                                 root: SelectCardEffect.Root.Hand,
-                                                activateETB: true
-                                                );
-
-
-                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
-                                cardSources: playCard.CardSources,
-                                activateClass: activateClass,
-                                payCost: true,
-                                isTapped: false,
-                                root: SelectCardEffect.Root.Hand,
-                                activateETB: true,
-                                isBreedingArea: true,
-                                fixedCost: 3));
+                                                activateETB: true,
+                                                isBreedingArea: true,
+                                                fixedCost: 3));
+                                        }
+                                    }
+                                }
+                            }
                         }
                     }
+
+                   
                 }
             }
             #endregion

Assets/CardEffect/BT16/Yellow/RapidmonXAntibody_BT16_101.cs

@@ -141,7 +141,48 @@ namespace DCGO.CardEffects.BT16
                             {
                                 return true;
                             }
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        return true;
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(2, activateClass));
+                }
+            }
+
+            if (timing == EffectTiming.OnEndBattle)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Memory +2", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+                activateClass.SetIsInheritedEffect(false);
+                activateClass.SetHashString("Memory+2_BT16_101");
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[All Turns][Once Per Turn] When an opponent's Digimon is deleted in battle or by dropping to 0 DP, gain 2 memory.";
+                }
 
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.IsOwnerTurn(card))
+                        {
                             bool WinnerCondition(Permanent permanent) => CardEffectCommons.IsOwnerPermanent(permanent, card);
                             bool LoserCondition(Permanent permanent) => CardEffectCommons.IsOpponentPermanent(permanent, card);
 
@@ -167,10 +208,12 @@ namespace DCGO.CardEffects.BT16
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(2, activateClass));
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(2, activateClass));
+                    }
                 }
             }
-
             #endregion
 
             #region All Turns

Assets/CardEffect/BT16/Yellow/Sheepmon_BT16_032.cs

@@ -1,5 +1,6 @@
 using System.Collections;
 using System.Collections.Generic;
+using UnityEngine;
 using System.Linq;
 
 namespace DCGO.CardEffects.BT16
@@ -62,6 +63,7 @@ namespace DCGO.CardEffects.BT16
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
+                    Debug.Log("SHEEPMON: END ATTACK");
                     GManager.instance.attackProcess.IsEndAttack = true;
 
                     yield return null;

Assets/CardEffect/BT16/Yellow/Tempomon_BT16_034.cs

@@ -260,7 +260,7 @@ namespace DCGO.CardEffects.BT16
             if(timing == EffectTiming.OnEndAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Unsuspend this Digimon.", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Unsuspend this Digimon by trashing the top card of your security.", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
                 activateClass.SetIsInheritedEffect(true);
                 activateClass.SetHashString("Inherit_BT16_034");
@@ -268,7 +268,7 @@ namespace DCGO.CardEffects.BT16
 
                 string EffectDiscription()
                 {
-                    return "[End of Attack][Once per turn] If this Digimon has [Pulsemon] in its text, by trashing the top card of your security stack, unsuspend this Digimon.";
+                    return "[End of Attack] [Once per turn] If this Digimon has [Pulsemon] in its text, by trashing the top card of your security stack, unsuspend this Digimon.";
                 }
 
                 bool CanUseCondition(Hashtable hashtable)

Assets/Scripts/AttackProcess.cs

@@ -295,7 +295,7 @@ public class AttackProcess : MonoBehaviourPunCallbacks
                     canTargetCondition_ByPreSelecetedList: null,
                     canEndSelectCondition: null,
                     maxCount: maxCount,
-                    canNoSelect: true,
+                    canNoSelect: (!IsBlocking),
                     canEndNotMax: false,
                     selectPermanentCoroutine: SelectPermanentCoroutine,
                     afterSelectPermanentCoroutine: null,
@@ -303,7 +303,9 @@ public class AttackProcess : MonoBehaviourPunCallbacks
                     cardEffect: null);
 
                 selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will block.", "The opponent is selecting 1 Digimon that will block.");
-                selectPermanentEffect.SetUpCustomBackButtonMessage("Not Block");
+                
+                if(!IsBlocking)
+                    selectPermanentEffect.SetUpCustomBackButtonMessage("Not Block");
 
                 yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
@@ -394,19 +396,12 @@ public class AttackProcess : MonoBehaviourPunCallbacks
                     GManager.instance.autoProcessing.PutStackedSkill(skillInfos_Pierce[0]);
                 }
                 #endregion
-
+                
                 yield return ContinuousController.instance.StartCoroutine(GManager.instance.autoProcessing.TriggeredSkillProcess(true, null));
-
                 GManager.instance.turnStateMachine.IsSelecting = true;
             }
             #endregion
 
-            //end attack
-            if (IsEndAttack)
-            {
-                goto EndAttack;
-            }
-
             if (AttackingPermanent.TopCard == null)
             {
                 goto EndAttack;

Assets/Scripts/CardController.cs

@@ -155,6 +155,11 @@ public class PlayCardClass
         _fixedCost = FixedCost;
     }
 
+    public void SetReducedCost(int ReducedCost)
+    {
+        _reducedCost = ReducedCost;
+    }
+
     public void SetAddSecurityEndOption()
     {
         _addSecurityEndOption = true;
@@ -175,6 +180,7 @@ public class PlayCardClass
     bool _showEffect = false;
     bool _ignoreLevel = false;
     int _fixedCost = -1;
+    int _reducedCost = 0;
     int[] _jogressEvoRootsFrameIDs = null;
     int _burstTamerFrameID = -1;
     bool _addSecurityEndOption = false;
@@ -379,9 +385,14 @@ public class PlayCardClass
                                     {
                                         if (cost <= card.Owner.MaxMemoryCost)
                                         {
-                                            CostList.Add(cost);
+                                            int evoCost = cost;
+
+                                            if(_reducedCost > 0)
+                                                evoCost -= _reducedCost;
+
+                                            CostList.Add(evoCost);
                                         }
-                                    }
+                                    } 
                                 }
 
                                 else
@@ -3421,6 +3432,11 @@ public class IBattle
 
                 GManager.instance.turnStateMachine.IsSelecting = true;
 
+                //Preemptive end battle if the attack process is ended
+                if(GManager.instance.attackProcess.IsEndAttack)
+                    yield break;
+                
+
                 #region battle with permanent
                 if (DefendingPermanent != null)
                 {

Assets/Scripts/CardEffectCommons/KeyWordEffects/Collision.cs

@@ -27,6 +27,8 @@ public partial class CardEffectCommons
     #region Effect process of [Collision]
     public static IEnumerator CollisionProcess(CardSource cardSource, ICardEffect activateClass, Func<IEnumerator> beforeOnAttackCoroutine = null)
     {
+        List<Permanent> enemyDigimons = new List<Permanent>();
+
         if (CanActivateCollision(cardSource))
         {
             foreach (Permanent enemyDigimon in cardSource.Owner.Enemy.GetBattleAreaDigimons())
@@ -38,9 +40,13 @@ public partial class CardEffectCommons
                         targetPermanent: enemyDigimon,
                         effectDuration: EffectDuration.UntilEndAttack,
                         activateClass: activateClass));
+
+                GManager.instance.attackProcess.IsBlocking = true;
             }
 
-            int maxCount = 1;
+
+
+            /*int maxCount = 1;
 
             Permanent selectedPermanent = null;
 
@@ -57,7 +63,7 @@ public partial class CardEffectCommons
                 selectPermanentCoroutine: SelectPermanentCoroutine,
                 afterSelectPermanentCoroutine: null,
                 mode: SelectPermanentEffect.Mode.Custom,
-                cardEffect: null);
+                cardEffect: activateClass);
 
             selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will block.", "The opponent is selecting 1 Digimon that will block.");
 
@@ -84,7 +90,7 @@ public partial class CardEffectCommons
                 selectedPermanent = permanent;
 
                 yield return ContinuousController.instance.StartCoroutine(GManager.instance.attackProcess.SwitchDefender(null, true, selectedPermanent));
-            }
+            }*/
         }
     }
     #endregion