Round 1 of sweeping updates for BT21 cards

Assets/CardBaseEntity/BT21/Black/Digimon/BT21_055.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0d12063ec0d9cbd7fbf7d828921ec85ae654b8465c5dc5029169a7e070aec70e
-size 1386
+oid sha256:2f0cac4a1c33280e3a4485a0c5b2c6fc58cc6db6d204702e9b7c656200b019d6
+size 1417

Assets/CardBaseEntity/BT21/Yellow/Tamer/BT21_086.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:57052404d4cd1206549bcebb56cf28f82ca21029d71e55551e697a96ebdce852
-size 1443
+oid sha256:c1579fc914d9c4eab037ff854287952e5e14c14e0825f924cf18c7d0b81a8211
+size 1429

Assets/CardBaseEntity/BT21/Yellow/Tamer/BT21_086_P1.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:972552ab2f307a0104ebec164f64416ba35da2111c0006457097e909f6b32102
-size 1449
+oid sha256:8034bbcbb591bddfe43952d35a9747f35f0f000a7c60a778883928e43e2464e3
+size 1435

Assets/CardEffect/BT21/Black/BT21_053.cs

@@ -20,7 +20,7 @@ namespace DCGO.CardEffects.BT21
                     return targetPermanent.TopCard.HasAppmonTraits;
                 }
 
-                cardEffects.Add(CardEffectFactory.AddSelfLinkConditionStaticEffect(permanentCondition: PermanentCondition, linkCost: 0, card: card));
+                cardEffects.Add(CardEffectFactory.AddSelfLinkConditionStaticEffect(permanentCondition: PermanentCondition, linkCost: 1, card: card));
             }
 
             #endregion
@@ -150,14 +150,13 @@ namespace DCGO.CardEffects.BT21
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
-                        CardEffectCommons.CanTriggerWhenLinking(hashtable, null, card) &&
-                        CardEffectCommons.HasMatchConditionOpponentsPermanent(card, IsOpponentsDigimon);
+                    return CardEffectCommons.CanTriggerWhenLinking(hashtable, null, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
+                           CardEffectCommons.HasMatchConditionOpponentsPermanent(card, IsOpponentsDigimon);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)

Assets/CardEffect/BT21/Black/BT21_054.cs

@@ -23,7 +23,7 @@ namespace DCGO.CardEffects.BT21
                     return targetPermanent.TopCard.HasAppmonTraits;
                 }
 
-                cardEffects.Add(CardEffectFactory.AddSelfLinkConditionStaticEffect(permanentCondition: PermanentCondition, linkCost: 0, card: card));
+                cardEffects.Add(CardEffectFactory.AddSelfLinkConditionStaticEffect(permanentCondition: PermanentCondition, linkCost: 1, card: card));
             }
 
             #endregion
@@ -206,8 +206,8 @@ namespace DCGO.CardEffects.BT21
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
-                        CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition);
+                    return CardEffectCommons.IsExistOnBattleArea(card) &&
+                           CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)

Assets/CardEffect/BT21/Black/BT21_056.cs

@@ -18,7 +18,7 @@ namespace DCGO.CardEffects.BT21
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Trash 1 card with [Vemmon] in text from hand to return 1 non-Digi-Egg card with [Vemmon] in text from trash to hand", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -112,7 +112,7 @@ namespace DCGO.CardEffects.BT21
                                             canTargetCondition: CanSelectCardCondition,
                                             canTargetCondition_ByPreSelecetedList: null,
                                             canEndSelectCondition: null,
-                                            canNoSelect: () => false,
+                                            canNoSelect: () => true,
                                             selectCardCoroutine: null,
                                             afterSelectCardCoroutine: null,
                                             message: "Select 1 card to add to your hand.",
@@ -137,111 +137,144 @@ namespace DCGO.CardEffects.BT21
 
             #endregion
 
-            #region Your Turn Inherited
+            #region Your Turn - ESS
 
-            if (timing == EffectTiming.BeforePayCost)
-            {
-                ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Digivolution Cost -1", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
-                activateClass.SetIsInheritedEffect(true);
-                activateClass.SetHashString("DigivolutionCost-1_BT21_056");
-                cardEffects.Add(activateClass);
+            ActivateClass activateClass2 = new ActivateClass();
+            activateClass2.SetUpICardEffect("Digivolution Cost -1", CanUseCondition2, card);
+            activateClass2.SetUpActivateClass(CanActivateCondition2, ActivateCoroutine2, 1, false, EffectDiscription2());
+            activateClass2.SetIsInheritedEffect(true);
+            activateClass2.SetNotShowUI(true);
+            activateClass2.SetIsBackgroundProcess(true);
+            activateClass2.SetHashString("DigivolutionCost-1_BT11_061");
 
-                string EffectDiscription()
-                {
-                    return "[Your Turn] [Once Per Turn] When this Digimon would digivolve into a Digimon card with [Vemmon] in its text, reduce the digivolution cost by 1.";
-                }
-
-                bool PermanentCondition(Permanent permanent)
-                {
-                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card) &&
-                        permanent == card.PermanentOfThisCard();
-                }
+            string EffectDiscription2()
+            {
+                return "";
+            }
 
-                bool CardCondition(CardSource cardSource)
+            bool CanUseCondition2(Hashtable hashtable)
+            {
+                if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
                 {
-                    return cardSource.IsDigimon &&
-                        cardSource.HasText("Vemmon");
-                }
+                    if (CardEffectCommons.IsOwnerTurn(card))
+                    {
+                        if (CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card))
+                        {
+                            List<CardSource> evoRootTops = CardEffectCommons.GetEvoRootTopsFromEnterFieldHashtable(
+                                hashtable,
+                                permanent => permanent.cardSources.Contains(card));
 
-                bool CanUseCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
-                        CardEffectCommons.IsOwnerTurn(card) &&
-                        CardEffectCommons.CanTriggerWhenPermanentWouldDigivolve(hashtable, PermanentCondition, CardCondition);
+                            if (evoRootTops != null)
+                            {
+                                if (!evoRootTops.Contains(card))
+                                {
+                                    if (card.PermanentOfThisCard().TopCard.HasText("Vemmon"))
+                                    {
+                                        return true;
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
 
-                bool CanActivateCondition(Hashtable hashtable)
-                {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
-                }
+                return false;
+            }
 
-                IEnumerator ActivateCoroutine(Hashtable _hashtable)
-                {
-                    if (isExistOnField(card))
-                    {
-                        Hashtable hashtable = new Hashtable();
-                        hashtable.Add("CardEffect", activateClass);
+            bool CanActivateCondition2(Hashtable hashtable)
+            {
+                return CardEffectCommons.IsExistOnBattleArea(card);
+            }
 
-                        ContinuousController.instance.PlaySE(GManager.instance.GetComponent<Effects>().BuffSE);
+            IEnumerator ActivateCoroutine2(Hashtable _hashtable)
+            {
+                yield return null;
+            }
 
-                        ChangeCostClass changeCostClass = new ChangeCostClass();
-                        changeCostClass.SetUpICardEffect("Digivolution Cost -1", CanUseCondition1, card);
-                        changeCostClass.SetUpChangeCostClass(changeCostFunc: ChangeCost, cardSourceCondition: CardSourceCondition, rootCondition: RootCondition, isUpDown: isUpDown, isCheckAvailability: () => false, isChangePayingCost: () => true);
-                        card.Owner.UntilCalculateFixedCostEffect.Add((_timing) => changeCostClass);
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                cardEffects.Add(activateClass2);
+            }
 
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ShowReducedCost(_hashtable));
+            if (timing == EffectTiming.None)
+            {
+                ChangeCostClass changeCostClass = new ChangeCostClass();
+                changeCostClass.SetUpICardEffect($"Digivolution Cost -1", CanUseCondition, card);
+                changeCostClass.SetUpChangeCostClass(changeCostFunc: ChangeCost, cardSourceCondition: CardSourceCondition, rootCondition: RootCondition, isUpDown: isUpDown, isCheckAvailability: () => false, isChangePayingCost: () => true);
 
-                        bool CanUseCondition1(Hashtable hashtable)
-                        {
-                            return true;
-                        }
+                changeCostClass.SetIsInheritedEffect(true);
+                cardEffects.Add(changeCostClass);
 
-                        int ChangeCost(CardSource cardSource, int Cost, SelectCardEffect.Root root, List<Permanent> targetPermanents)
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (CardEffectCommons.IsOwnerTurn(card))
                         {
-                            if (CardSourceCondition(cardSource) && RootCondition(root) && PermanentsCondition(targetPermanents))
+                            if (!card.cEntity_EffectController.isOverMaxCountPerTurn(activateClass2, activateClass2.MaxCountPerTurn))
                             {
-                                Cost -= 1;
+                                return true;
                             }
-
-                            return Cost;
                         }
+                    }
 
-                        bool PermanentsCondition(List<Permanent> targetPermanents)
-                        {
-                            return targetPermanents != null &&
-                                targetPermanents.Count(PermanentCondition) >= 1;
-                        }
+                    return false;
+                }
 
-                        bool PermanentCondition(Permanent targetPermanent)
+                int ChangeCost(CardSource cardSource, int Cost, SelectCardEffect.Root root, List<Permanent> targetPermanents)
+                {
+                    if (CardSourceCondition(cardSource))
+                    {
+                        if (RootCondition(root))
                         {
-                            return targetPermanent.TopCard != null &&
-                                targetPermanent.TopCard.Owner == card.Owner &&
-                                targetPermanent.TopCard.Owner.GetBattleAreaPermanents().Contains(targetPermanent);
+                            if (PermanentsCondition(targetPermanents))
+                            {
+                                Cost -= 1;
+                            }
                         }
+                    }
 
-                        bool CardSourceCondition(CardSource cardSource)
-                        {
-                            return cardSource != null &&
-                                cardSource.Owner == card.Owner &&
-                                cardSource.HasText("Vemmon");
-                        }
+                    return Cost;
+                }
 
-                        bool RootCondition(SelectCardEffect.Root root)
+                bool PermanentsCondition(List<Permanent> targetPermanents)
+                {
+                    if (targetPermanents != null)
+                    {
+                        if (targetPermanents.Count(PermanentCondition) >= 1)
                         {
                             return true;
                         }
+                    }
 
-                        bool isUpDown()
-                        {
-                            return true;
-                        }
+                    return false;
+                }
 
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent == card.PermanentOfThisCard();
+                }
+
+                bool CardSourceCondition(CardSource cardSource)
+                {
+                    if (cardSource.HasText("Vemmon"))
+                    {
+                        return true;
                     }
+
+                    return false;
+                }
+
+                bool RootCondition(SelectCardEffect.Root root)
+                {
+                    return true;
                 }
-            }
 
+                bool isUpDown()
+                {
+                    return true;
+                }
+            }
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT21/Black/BT21_059.cs

@@ -11,6 +11,18 @@ namespace DCGO.CardEffects.BT21
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
+            #region Alternative Digivolution Condition
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.EqualsTraits("Stnd.");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 2, ignoreDigivolutionRequirement: false, card: card, condition: null));
+            }
+            #endregion
+
             #region Link Condition
 
             if (timing == EffectTiming.None)
@@ -20,7 +32,7 @@ namespace DCGO.CardEffects.BT21
                     return targetPermanent.TopCard.HasAppmonTraits;
                 }
 
-                cardEffects.Add(CardEffectFactory.AddSelfLinkConditionStaticEffect(permanentCondition: PermanentCondition, linkCost: 0, card: card));
+                cardEffects.Add(CardEffectFactory.AddSelfLinkConditionStaticEffect(permanentCondition: PermanentCondition, linkCost: 2, card: card));
             }
 
             #endregion
@@ -193,14 +205,13 @@ namespace DCGO.CardEffects.BT21
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
-                        CardEffectCommons.CanTriggerWhenLinking(hashtable, null, card) &&
-                        CardEffectCommons.HasMatchConditionOpponentsPermanent(card, IsOpponentsDigimon);
+                    return CardEffectCommons.CanTriggerWhenLinking(hashtable, null, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                    return CardEffectCommons.IsExistOnBattleArea(card) &&
+                           CardEffectCommons.HasMatchConditionOpponentsPermanent(card, IsOpponentsDigimon);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)

Assets/CardEffect/BT21/Black/BT21_062.cs

@@ -145,34 +145,34 @@ namespace DCGO.CardEffects.BT21
 
                         if (added)
                         {
-                            List<CardSource> selectedCards = new List<CardSource>();
+                            bool canSelectHand = card.Owner.HandCards.Count(CanSelectCardCondition1) >= 1;
+                            bool canSelectTrash = CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition1);
 
-                            if (card.Owner.HandCards.Count(CanSelectCardCondition1) >= 1)
+                            if (canSelectHand || canSelectTrash)
                             {
-                                int maxCount = 1;
-
-                                SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
-
-                                selectHandEffect.SetUp(
-                                    selectPlayer: card.Owner,
-                                    canTargetCondition: CanSelectCardCondition1,
-                                    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 option card to use.",
-                                    "The opponent is selecting 1 option card to use.");
-                                selectHandEffect.SetUpCustomMessage_ShowCard("Used Card");
-
-                                yield return StartCoroutine(selectHandEffect.Activate());
+                                if (canSelectHand && canSelectTrash)
+                                {
+                                    List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                                    {
+                                        new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
+                                        new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
+                                    };
+
+                                    string selectPlayerMessage = "From which area do you play a card?";
+                                    string notSelectPlayerMessage = "The opponent is choosing from which area to play a card.";
+
+                                    GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                                }
+                                else
+                                {
+                                    GManager.instance.userSelectionManager.SetBool(canSelectHand);
+                                }
+
+                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                                bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+                                List<CardSource> selectedCards = new List<CardSource>();
 
                                 IEnumerator SelectCardCoroutine(CardSource cardSource)
                                 {
@@ -180,18 +180,70 @@ namespace DCGO.CardEffects.BT21
 
                                     yield return null;
                                 }
-                            }
 
-                            if (selectedCards.Count >= 1)
-                            {
-                                yield return ContinuousController.instance.StartCoroutine(
-                                    CardEffectCommons.PlayOptionCards(
-                                        cardSources: selectedCards,
-                                        activateClass: activateClass,
-                                        payCost: false,
-                                        root: SelectCardEffect.Root.Hand
-                                    )
-                                );
+                                if (fromHand)
+                                {
+                                    int maxCount = 1;
+
+                                    SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                                    selectHandEffect.SetUp(
+                                        selectPlayer: card.Owner,
+                                        canTargetCondition: CanSelectCardCondition1,
+                                        canTargetCondition_ByPreSelecetedList: null,
+                                        canEndSelectCondition: null,
+                                        maxCount: maxCount,
+                                        canNoSelect: true,
+                                        canEndNotMax: false,
+                                        isShowOpponent: true,
+                                        selectCardCoroutine: SelectCardCoroutine,
+                                        afterSelectCardCoroutine: null,
+                                        mode: SelectHandEffect.Mode.Custom,
+                                        cardEffect: activateClass);
+
+                                    selectHandEffect.SetUpCustomMessage("Select 1 card to play.", "The opponent is selecting 1 card to play.");
+                                    selectHandEffect.SetUpCustomMessage_ShowCard("Played Card");
+
+                                    yield return StartCoroutine(selectHandEffect.Activate());
+                                }
+                                else
+                                {
+                                    int maxCount = 1;
+
+                                    SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                                    selectCardEffect.SetUp(
+                                        canTargetCondition: CanSelectCardCondition1,
+                                        canTargetCondition_ByPreSelecetedList: null,
+                                        canEndSelectCondition: null,
+                                        canNoSelect: () => true,
+                                        selectCardCoroutine: SelectCardCoroutine,
+                                        afterSelectCardCoroutine: null,
+                                        message: "Select 1 card to play.",
+                                        maxCount: maxCount,
+                                        canEndNotMax: false,
+                                        isShowOpponent: true,
+                                        mode: SelectCardEffect.Mode.Custom,
+                                        root: SelectCardEffect.Root.Trash,
+                                        customRootCardList: null,
+                                        canLookReverseCard: true,
+                                        selectPlayer: card.Owner,
+                                        cardEffect: activateClass);
+
+                                    selectCardEffect.SetUpCustomMessage("Select 1 card to play.", "The opponent is selecting 1 card to play.");
+                                    selectCardEffect.SetUpCustomMessage_ShowCard("Played Card");
+
+                                    yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+                                }
+
+                                SelectCardEffect.Root root = SelectCardEffect.Root.Hand;
+
+                                if (!fromHand)
+                                {
+                                    root = SelectCardEffect.Root.Trash;
+                                }
+
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: selectedCards, activateClass: activateClass, payCost: false, isTapped: false, root: root, activateETB: true));
                             }
                         }
                     }
@@ -331,7 +383,7 @@ namespace DCGO.CardEffects.BT21
                         selectCardCoroutine: null,
                         afterSelectCardCoroutine: AfterSelectCardCoroutine,
                         message: "Select 4 [Vemmon] to place at the bottom of the deck.",
-                        maxCount: 1,
+                        maxCount: 4,
                         canEndNotMax: false,
                         isShowOpponent: false,
                         mode: SelectCardEffect.Mode.Custom,

Assets/CardEffect/BT21/Black/BT21_098.cs

@@ -55,16 +55,16 @@ namespace DCGO.CardEffects.BT21
                             cardEffect: activateClass);
 
                         yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlaceDelayOptionCards(card: card, cardEffect: activateClass));
                     }
+
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlaceDelayOptionCards(card: card, cardEffect: activateClass));
                 }
             }
 
             #endregion
 
             #region Your Turn Delay
-            if (timing == EffectTiming.OnDeclaration)
+            if (timing == EffectTiming.OnAllyAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Delete 1 opponent's Digimon with lowest play cost, trash security until 1 left if didn't delete", CanUseCondition, card);
@@ -123,60 +123,77 @@ namespace DCGO.CardEffects.BT21
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
+                    bool activateDelay = false;
+
                     List<Permanent> deleteTargetPermanents = new List<Permanent>();
 
-                    bool attemptedToDelete = false;
+                    bool failedToDelete = false;
 
-                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(
+                                    targetPermanents: new List<Permanent>() { card.PermanentOfThisCard() }, 
+                                    activateClass: activateClass, 
+                                    successProcess: permanents => SuccessProcess(), 
+                                    failureProcess: null));
+
+                    IEnumerator SuccessProcess()
                     {
-                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                        activateDelay = true;
+                        yield return null;
+                    }
 
-                        selectPermanentEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: CanSelectPermanentCondition,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: 1,
-                            canNoSelect: false,
-                            canEndNotMax: false,
-                            selectPermanentCoroutine: null,
-                            afterSelectPermanentCoroutine: AfterSelectPermanentCoroutine,
-                            mode: SelectPermanentEffect.Mode.Destroy,
-                            cardEffect: activateClass);
+                    if (activateDelay)
+                    {
+                        if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
+                        {
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
 
-                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectPermanentCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: 1,
+                                canNoSelect: false,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: null,
+                                afterSelectPermanentCoroutine: AfterSelectPermanentCoroutine,
+                                mode: SelectPermanentEffect.Mode.Destroy,
+                                cardEffect: activateClass);
 
-                        IEnumerator AfterSelectPermanentCoroutine(List<Permanent> permanents)
-                        {
-                            deleteTargetPermanents = permanents.Clone();
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
-                            attemptedToDelete = true;
+                            IEnumerator AfterSelectPermanentCoroutine(List<Permanent> permanents)
+                            {
+                                deleteTargetPermanents = permanents.Clone();
 
-                            yield return null;
+                                yield return null;
+                            }
                         }
-                    }
 
-                    if (attemptedToDelete)
-                    {
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: deleteTargetPermanents, activateClass: activateClass, successProcess: null, failureProcess: FailureProcess));
+                        if (deleteTargetPermanents.Count > 0)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: deleteTargetPermanents, activateClass: activateClass, successProcess: null, failureProcess: FailureProcess));
 
-                        IEnumerator FailureProcess()
+                            IEnumerator FailureProcess()
+                            {
+                                failedToDelete = true;
+                                yield return null;
+                            }
+                        }
+                        else
+                        {
+                            failedToDelete = true;
+                        }
+
+                        if (!failedToDelete)
                         {
                             yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
-                                player: card.Owner.Enemy,
-                                destroySecurityCount: card.Owner.Enemy.SecurityCards.Count - 1,
-                                cardEffect: activateClass,
-                                fromTop: true).DestroySecurity());
+                                    player: card.Owner.Enemy,
+                                    destroySecurityCount: card.Owner.Enemy.SecurityCards.Count - 1,
+                                    cardEffect: activateClass,
+                                    fromTop: true).DestroySecurity());
                         }
                     }
-                    else
-                    {
-                        yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
-                            player: card.Owner.Enemy,
-                            destroySecurityCount: card.Owner.Enemy.SecurityCards.Count - 1,
-                            cardEffect: activateClass,
-                            fromTop: true).DestroySecurity());
-                    }
                 }
             }
             #endregion
@@ -187,7 +204,7 @@ namespace DCGO.CardEffects.BT21
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect($"Play 1 card with [VEMMON] in text from hand or trash and add this card to hand", CanUseCondition, card);
-                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDescription());
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDescription());
                 activateClass.SetIsSecurityEffect(true);
                 cardEffects.Add(activateClass);
 

Assets/CardEffect/BT21/Blue/BT21_038.cs

@@ -20,7 +20,7 @@ namespace DCGO.CardEffects.BT21
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
                     permanentCondition: PermanentCondition,
-                    digivolutionCost: 2,
+                    digivolutionCost: 3,
                     ignoreDigivolutionRequirement: false,
                     card: card,
                     condition: null));

Assets/CardEffect/BT21/Green/BT21_047.cs

@@ -109,11 +109,12 @@ namespace DCGO.CardEffects.BT21
             }
             #endregion
 
-            #region Inherit
+            #region Link Effect
             if (timing == EffectTiming.OnDetermineDoSecurityCheck)
             {
                 cardEffects.Add(CardEffectFactory.PierceSelfEffect(
-                    isInheritedEffect: true,
+                    isInheritedEffect: false,
+                    isLinkedEffect: true,
                     card: card,
                     condition: null));
             }

Assets/CardEffect/BT21/Green/BT21_050.cs

@@ -18,10 +18,128 @@ namespace DCGO.CardEffects.BT21
                     return (targetPermanent.TopCard.EqualsTraits("WG") && targetPermanent.TopCard.IsLevel4);
                 }
 
-                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 2, ignoreDigivolutionRequirement: false, card: card, condition: null));
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 3, ignoreDigivolutionRequirement: false, card: card, condition: null));
             }
             #endregion
 
+            #region On Play
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Suspend", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[On Play] You may suspend 1 Digimon.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnBattleAreaDigimon(permanent);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(PermanentCondition))
+                    {
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(PermanentCondition));
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: PermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: null,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Tap,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to suspend.", "The opponent is selecting 1 Digimon to suspend.");
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                    }
+                }
+            }
+
+            #endregion
+
+            #region When Digivolving
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Suspend", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] You may suspend 1 Digimon.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnBattleAreaDigimon(permanent);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(PermanentCondition))
+                    {
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(PermanentCondition));
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: PermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: null,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Tap,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to suspend.", "The opponent is selecting 1 Digimon to suspend.");
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                    }
+                }
+            }
+
+            #endregion
+
             #region Opponents Turn
             if (timing == EffectTiming.OnAllyAttack)
             {

Assets/CardEffect/BT21/Green/BT21_51.cs → Assets/CardEffect/BT21/Green/BT21_051.cs

@@ -4,7 +4,7 @@ using System.Collections.Generic;
 
 namespace DCGO.CardEffects.BT21
 {
-    public class BT21_51 : CEntity_Effect
+    public class BT21_051 : CEntity_Effect
     {
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {

Assets/CardEffect/BT21/Green/BT21_097.cs

@@ -20,11 +20,14 @@ namespace DCGO.CardEffects.BT21
 
                 bool HasAppmonTrait(Permanent permanent)
                 {
-                    if (permanent.TopCard.EqualsTraits("Appmon"))
+                    if(CardEffectCommons.IsOwnerPermanent(permanent, card))
                     {
-                        if (permanent.IsDigimon || permanent.IsTamer)
+                        if (permanent.TopCard.EqualsTraits("Appmon"))
                         {
-                            return true;
+                            if (permanent.IsDigimon || permanent.IsTamer)
+                            {
+                                return true;
+                            }
                         }
                     }
 
@@ -33,7 +36,7 @@ namespace DCGO.CardEffects.BT21
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.HasMatchConditionOwnersPermanent(card, HasAppmonTrait);
+                    return CardEffectCommons.HasMatchConditionPermanent(HasAppmonTrait, true);
                 }
 
                 bool CardCondition(CardSource cardSource)
@@ -136,7 +139,7 @@ namespace DCGO.CardEffects.BT21
 
                             selectHandEffect.SetUp(
                                 selectPlayer: card.Owner,
-                                canTargetCondition: (cardSource) => true,
+                                canTargetCondition: CanSelectLinkTarget,
                                 canTargetCondition_ByPreSelecetedList: null,
                                 canEndSelectCondition: null,
                                 maxCount: 1,

Assets/CardEffect/BT21/Purple/BT21_064.cs

@@ -16,7 +16,7 @@ namespace DCGO.CardEffects.BT21
             {
                 bool PermanentCondition(Permanent targetPermanent)
                 {
-                    return targetPermanent.TopCard.EqualsCardName("Guilmon") || (targetPermanent.Level == 2 && targetPermanent.TopCard.EqualsTraits("Hero"));
+                    return targetPermanent.TopCard.EqualsCardName("Gigimon") || (targetPermanent.Level == 2 && targetPermanent.TopCard.EqualsTraits("Hero"));
                 }
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(

Assets/CardEffect/BT21/Purple/BT21_065.cs

@@ -174,12 +174,12 @@ namespace DCGO.CardEffects.BT21
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanActivateOnDeletionInherited(hashtable, card);
+                    return CardEffectCommons.CanTriggerOnDeletion(hashtable, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.CanActivateOnDeletion(card))
+                    if (CardEffectCommons.CanActivateOnDeletionInherited(hashtable,card))
                     {
                         if (card.Owner.CanAddMemory(activateClass))
                         {

Assets/CardEffect/BT21/Purple/BT21_070.cs

@@ -10,6 +10,18 @@ namespace DCGO.CardEffects.BT21
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
+            #region Alternative Digivolution Condition
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.EqualsTraits("Stnd.");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 2, ignoreDigivolutionRequirement: false, card: card, condition: null));
+            }
+            #endregion
+
             #region Security
             if (timing == EffectTiming.SecuritySkill)
             {

Assets/CardEffect/BT21/Purple/BT21_071.cs

@@ -12,8 +12,20 @@ namespace DCGO.CardEffects.BT21
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
-            #region Digivolution Condition
-            if(timing == EffectTiming.None)
+            #region Alternative Digivolution Condition - Stnd.
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.EqualsTraits("Stnd.");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 2, ignoreDigivolutionRequirement: false, card: card, condition: null));
+            }
+            #endregion
+
+            #region Alternative Digivolution Condition - Three Musketeers
+            if (timing == EffectTiming.None)
             {
                 bool Condition(Permanent permanent)
                 {
@@ -389,7 +401,7 @@ namespace DCGO.CardEffects.BT21
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return isExistOnField(card) && (card.Owner.HandCards.Count >= 1 || card.Owner.LibraryCards.Count >= 1);
+                    return isExistOnField(card);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)

Assets/CardEffect/BT21/Purple/BT21_075.cs

@@ -88,12 +88,12 @@ namespace DCGO.CardEffects.BT21
 
                             yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainRaid(
                                 targetPermanent: selectedPermanent,
-                                effectDuration: EffectDuration.UntilEachTurnEnd,
+                                effectDuration: EffectDuration.UntilOpponentTurnEnd,
                                 activateClass: activateClass));
 
                             yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainRetaliation(
                                 targetPermanent: selectedPermanent,
-                                effectDuration: EffectDuration.UntilEachTurnEnd,
+                                effectDuration: EffectDuration.UntilOpponentTurnEnd,
                                 activateClass: activateClass));
                         }
                     }

Assets/CardEffect/BT21/Purple/BT21_076.cs

@@ -70,7 +70,7 @@ namespace DCGO.CardEffects.BT21
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
@@ -183,6 +183,7 @@ namespace DCGO.CardEffects.BT21
                 }
             }
             #endregion
+
             return cardEffects;
         }
     }

Assets/CardEffect/BT21/Purple/BT21_079.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using UnityEngine;
 
 namespace DCGO.CardEffects.BT21
 {
@@ -103,7 +104,7 @@ namespace DCGO.CardEffects.BT21
 
                 int Count()
                 {
-                    return (card.Owner.TrashCards.Count + card.Owner.Enemy.TrashCards.Count) / 10;
+                    return Mathf.FloorToInt((card.Owner.TrashCards.Count + card.Owner.Enemy.TrashCards.Count) / 10);
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -120,7 +121,7 @@ namespace DCGO.CardEffects.BT21
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition);
+                    return CardEffectCommons.CanActivateOnDeletion(card) && CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
@@ -174,6 +175,7 @@ namespace DCGO.CardEffects.BT21
                 }
             }
             #endregion
+
             return cardEffects;
         }
     }

Assets/CardEffect/BT21/Purple/BT21_100.cs

@@ -36,7 +36,6 @@ namespace DCGO.CardEffects.BT21
             }
             #endregion
 
-
             #region Main
             if (timing == EffectTiming.OptionSkill)
             {
@@ -108,7 +107,8 @@ namespace DCGO.CardEffects.BT21
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanDeclareOptionDelayEffect(card) &&
+                    return CardEffectCommons.IsOwnerTurn(card) &&
+                           CardEffectCommons.CanDeclareOptionDelayEffect(card) &&
                            CardEffectCommons.CanTriggerOnPermanentDeleted(hashtable, TriggerPermanentCondition) &&
                            CardEffectCommons.IsByEffect(hashtable, null);
                 }

Assets/CardEffect/BT21/White/BT21_101.cs

@@ -104,7 +104,7 @@ namespace DCGO.CardEffects.BT21
 
             #region Link +1
 
-            if (timing == EffectTiming.None) cardEffects.Add(CardEffectFactory.ChangeSelfLinkMaxStaticEffect(card.PermanentOfThisCard().LinkedMax + 1, false, card, null));
+            if (timing == EffectTiming.None) cardEffects.Add(CardEffectFactory.ChangeSelfLinkMaxStaticEffect(1, false, card, null));
 
             #endregion
 
@@ -138,36 +138,19 @@ namespace DCGO.CardEffects.BT21
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    bool unsuspended = false;
-                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-                    selectPermanentEffect.SetUp
-                        (
-                        card.Owner,
-                        permanent => CardEffectCommons.IsPermanentExistsOnBattleAreaDigimon(permanent) && permanent == card.PermanentOfThisCard(),
-                        null,
-                        null,
-                        1,
-                        true,
-                        false,
-                        SelectPermanentCoroutine,
-                        null,
-                        SelectPermanentEffect.Mode.UnTap,
-                        activateClass
-                        );
-                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                    {
-                        if (permanent.IsSuspended) unsuspended = true;
-                        yield return null;
-                    }
-                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                    Permanent thisPermanent = card.PermanentOfThisCard();
 
-                    if (unsuspended)
+                    if(thisPermanent.CanUnsuspend && thisPermanent.IsSuspended)
                     {
+                        yield return ContinuousController.instance.StartCoroutine(new IUnsuspendPermanents(
+                            new List<Permanent>() { card.PermanentOfThisCard() }, 
+                            activateClass).Unsuspend());
+
                         yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
-                        player: card.Owner.Enemy,
-                        destroySecurityCount: 1,
-                        cardEffect: activateClass,
-                        fromTop: true).DestroySecurity());
+                            player: card.Owner.Enemy,
+                            destroySecurityCount: 1,
+                            cardEffect: activateClass,
+                            fromTop: true).DestroySecurity());
                     }
                 }
             }

Assets/CardEffect/BT21/White/BT21_102.cs

@@ -70,14 +70,13 @@ namespace DCGO.CardEffects.BT21
                 bool CanUseCondition(Hashtable hashtable)
                     => CardEffectCommons.IsExistOnBattleArea(card)
                     && CardEffectCommons.IsOwnerTurn(card)
-                    && CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectDigimon);
+                    && CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCard);
 
                 bool CanActivateCondition(Hashtable hashtable)
                     => CardEffectCommons.IsExistOnBattleArea(card);
 
-                bool CanSelectDigimon(CardSource source)
-                    => source.IsDigimon
-                    && source.BasePlayCostFromEntity <= AdjustedPlayCostMax(source)
+                bool CanSelectCard(CardSource source)
+                    => source.BasePlayCostFromEntity <= AdjustedPlayCostMax(source)
                     && (source.HasAdventureTraits || source.HasHeroTraits);
 
                 int AdjustedPlayCostMax(CardSource cardSource)
@@ -91,7 +90,7 @@ namespace DCGO.CardEffects.BT21
                     SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
                     selectHandEffect.SetUp(
                         selectPlayer: card.Owner,
-                        canTargetCondition: CanSelectDigimon,
+                        canTargetCondition: CanSelectCard,
                         canTargetCondition_ByPreSelecetedList: null,
                         canEndSelectCondition: null,
                         maxCount: 1,

Assets/CardEffect/BT21/Yellow/BT21_041.cs

@@ -63,7 +63,8 @@ namespace DCGO.CardEffects.BT21
                 cardEffects.Add(CardEffectFactory.ChangeSecurityDigimonCardDPStaticEffect(
                     cardCondition: CardCondition,
                     changeValue: -3000,
-                    isInheritedEffect: true,
+                    isInheritedEffect: false,
+                    islinkedEffect: true,
                     card: card,
                     condition: Condition,
                     effectName: "Opponent's Security Digimon gains DP -3000"));

Assets/CardEffect/BT21/Yellow/BT21_042.cs

@@ -43,13 +43,14 @@ namespace DCGO.CardEffects.BT21
 
                 bool PlayedPermanentCondition(Permanent permanent)
                 {
-                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card) && permanent.IsTamer && permanent.TopCard.EqualsCardName("Marcus Damon");
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card) && 
+                           permanent.TopCard.EqualsCardName("Marcus Damon");
                 }
 
                 bool CanSelectCardToDigivolveInto(CardSource cardSource)
                 {
                     return cardSource.CardColors.Contains(CardColor.Yellow) && 
-                           cardSource.EqualsCardName("RizeGreymon") &&
+                           cardSource.ContainsCardName("RizeGreymon") &&
                            cardSource.CanPlayCardTargetFrame(card.PermanentOfThisCard().PermanentFrame, false, activateClass);
                 }
 

Assets/CardEffect/BT21/Yellow/BT21_043.cs

@@ -10,6 +10,18 @@ namespace DCGO.CardEffects.BT21
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
+            #region Alternative Digivolution Condition
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.EqualsTraits("Stnd.");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 2, ignoreDigivolutionRequirement: false, card: card, condition: null));
+            }
+            #endregion
+
             #region Link Condition
             if (timing == EffectTiming.None)
             {
@@ -204,7 +216,7 @@ namespace DCGO.CardEffects.BT21
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                    if (isExistOnField(card))
                     {
                         if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                         {

Assets/CardEffect/BT21/Yellow/BT21_044.cs

@@ -286,7 +286,7 @@ namespace DCGO.CardEffects.BT21
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Place 1 [Marcus Damon] on the top of security from trash", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
                 activateClass.SetHashString("AddSecurity_BT21_044");
                 cardEffects.Add(activateClass);
 

Assets/CardEffect/BT21/Yellow/BT21_045.cs

@@ -22,6 +22,13 @@ namespace DCGO.CardEffects.BT21
             }
             #endregion
 
+            #region Raid
+            if (timing == EffectTiming.OnAllyAttack)
+            {
+                cardEffects.Add(CardEffectFactory.RaidSelfEffect(isInheritedEffect: false, card: card, condition: null));
+            }
+            #endregion
+
             #region When Digivolving
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {

Assets/CardEffect/BT21/Yellow/BT21_086.cs

@@ -66,6 +66,59 @@ namespace DCGO.CardEffects.BT21
             }
             #endregion
 
+            #region On Play
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Suspend this Tamer", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[On Play] 1 of your [Marcus Damon] may suspend.";
+                }
+
+                bool CanSelectMarcus(Permanent permanent)
+                {
+                    return permanent.TopCard.EqualsCardName("Marcus Damon");
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleArea(card);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectMarcus))
+                    {
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectMarcus,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: 1,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: null,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Tap,
+                            cardEffect: activateClass);
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                    }
+                }
+            }
+            #endregion
+
             #region All Turns
             if (timing == EffectTiming.OnTappedAnyone)
             {

Assets/CardEffect/BT21/Yellow/BT21_096.cs

@@ -87,29 +87,42 @@ namespace DCGO.CardEffects.BT21
                         {
                             if (selectedPermanent1.CanAttack(activateClass) && CardEffectCommons.HasMatchConditionPermanent(CanSelectOpponentPermanentCondition))
                             {
-                                bool DefenderCondition(Permanent permanent)
+                                #region Attack unsuspended Digimon
+
+                                CanAttackTargetDefendingPermanentClass canAttackTargetDefendingPermanentClass = new CanAttackTargetDefendingPermanentClass();
+                                canAttackTargetDefendingPermanentClass.SetUpICardEffect("Can attack unsuspended Digimon", CanUseCondition, selectedPermanent1.TopCard);
+                                canAttackTargetDefendingPermanentClass.SetUpCanAttackTargetDefendingPermanentClass(
+                                    attackerCondition: AttackerCondition,
+                                    defenderCondition: DefenderCondition,
+                                    cardEffectCondition: CardEffectCondition);
+                                selectedPermanent1.UntilEndAttackEffects.Add(_ => canAttackTargetDefendingPermanentClass);
+
+                                bool CanUseCondition(Hashtable hashtable)
+                                {
+                                    return true;
+                                }
+
+                                bool AttackerCondition(Permanent attacker)
+                                {
+                                    return attacker == selectedPermanent1;
+                                }
+
+                                bool DefenderCondition(Permanent defender)
                                 {
-                                    if (permanent != null)
-                                    {
-                                        if (permanent.TopCard != null)
-                                        {
-                                            if (permanent.TopCard.Owner == card.Owner.Enemy)
-                                            {
-                                                if (permanent.IsDigimon)
-                                                {
-                                                    if (!permanent.IsSuspended)
-                                                    {
-                                                        if (permanent.TopCard.Owner.GetBattleAreaPermanents().Contains(permanent))
-                                                        {
-                                                            return true;
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-
-                                    return false;
+                                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(defender, card) &&
+                                           !defender.IsSuspended;
+                                }
+
+                                bool CardEffectCondition(ICardEffect cardEffect)
+                                {
+                                    return true;
+                                }
+
+                                #endregion
+
+                                bool AttackDefenderCondition(Permanent permanent)
+                                {
+                                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
                                 }
 
                                 SelectAttackEffect selectAttackEffect = GManager.instance.GetComponent<SelectAttackEffect>();
@@ -117,7 +130,7 @@ namespace DCGO.CardEffects.BT21
                                 selectAttackEffect.SetUp(
                                     attacker: selectedPermanent1,
                                     canAttackPlayerCondition: () => false,
-                                    defenderCondition: DefenderCondition,
+                                    defenderCondition: AttackDefenderCondition,
                                     cardEffect: activateClass);
 
                                 yield return ContinuousController.instance.StartCoroutine(selectAttackEffect.Activate());