updates for 1.8.2.8

Assets/CardBaseEntity/P/Green/Digimon/P_185.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7862d947d5019c3033efecf4d6d1670a83889c8cddf1327cbd48ea0635771f15
-size 1560
+oid sha256:c6021812c5402ba27e59fe70ad81d15d36868c192581b7478e9b7b4ae8d6dbc0
+size 1562

Assets/CardEffect/BT20/Purple/BT20_098.cs

@@ -137,6 +137,11 @@ namespace DCGO.CardEffects.BT20
                                                cardEffect: activateClass);
                                 }
 
+                                bool CanNoSelect()
+                                {
+                                    return selectedCardsToPlay.Count == 0;
+                                }
+
                                 bool RemoveOptionsAlreadySelected(List<CardSource> cardSources, CardSource cardSource)
                                 {
                                     if (cardSources.Contains(cardSource))
@@ -149,7 +154,7 @@ namespace DCGO.CardEffects.BT20
                                     canTargetCondition: CanSelectPlayCardCondition,
                                     canTargetCondition_ByPreSelecetedList: RemoveOptionsAlreadySelected,
                                     canEndSelectCondition: null,
-                                    canNoSelect: () => true,
+                                    canNoSelect: CanNoSelect,
                                     selectCardCoroutine: SelectCardCoroutine2,
                                     afterSelectCardCoroutine: null,
                                     message: "Select 1 card to play.",

Assets/CardEffect/BT21/Black/BT21_058.cs

@@ -299,12 +299,7 @@ namespace DCGO.CardEffects.BT21
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
                     if (CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card))
-                    {
-                        if (permanent.TopCard.HasPlayCost & permanent.TopCard.GetCostItself <= 4)
-                        {
-                            return true;
-                        }
-                    }
+                        return permanent.TopCard.HasPlayCost && permanent.TopCard.GetCostItself <= 4;
 
                     return false;
                 }

Assets/CardEffect/BT21/Black/BT21_060.cs

@@ -250,6 +250,8 @@ namespace DCGO.CardEffects.BT21
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
+                    List<CardSource> selectedCards = new List<CardSource>();
+
                     SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
 
                     selectCardEffect.SetUp(
@@ -277,9 +279,16 @@ namespace DCGO.CardEffects.BT21
 
                     IEnumerator AfterSelectCardCoroutine(List<CardSource> cardSources)
                     {
-                        yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddLibraryBottomCards(cardSources));
+                        selectedCards = cardSources;
+
+                        yield return null;
+                    }
+
+                    if(selectedCards.Count > 0)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(new ReturnToLibraryBottomDigivolutionCardsClass(card.PermanentOfThisCard(), selectedCards, CardEffectCommons.CardEffectHashtable(activateClass)).ReturnToLibraryBottomDigivolutionCards());
 
-                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect2(cardSources, "Deck Bottom Cards", true, true));
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect2(selectedCards, "Deck Bottom Cards", true, true));
 
                         GManager.instance.attackProcess.IsEndAttack = true;
                     }

Assets/CardEffect/BT21/Purple/BT21_074.cs

@@ -38,6 +38,30 @@ namespace DCGO.CardEffects.BT21
             }
             #endregion
 
+            #region Ability to link
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return permanent.TopCard.HasAppmonTraits;
+                }
+                cardEffects.Add(CardEffectFactory.AddSelfLinkConditionStaticEffect(permanentCondition: PermanentCondition, linkCost: 3, card: card));
+
+            }
+
+            if (timing == EffectTiming.OnDeclaration)
+            {
+                cardEffects.Add(CardEffectFactory.LinkEffect(card));
+            }
+            #endregion
+
+            #region Shared Conditions
+            bool CanTuckOrTrash(CardSource cardSource)
+            {
+                return cardSource.EqualsTraits("Appmon") || cardSource.HasThreeMusketeersTraits;
+            }
+            #endregion
+
             #region On Play/When Digivolving shared
             bool CanActivateConditionSharedOP(Hashtable hashtable)
             {
@@ -71,15 +95,8 @@ namespace DCGO.CardEffects.BT21
             }
             #endregion
 
-            #region OnPlay/WhenDigivolving/WhenAttacking shared
-            bool CanTuckOrTrash(CardSource cardSource)
-            {
-                return cardSource.EqualsTraits("Appmon") || cardSource.HasThreeMusketeersTraits;
-            }
-            #endregion
-
             #region On Play
-            if(timing == EffectTiming.OnEnterFieldAnyone)
+            if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Tuck to get protections", CanUseCondition, card);
@@ -214,38 +231,42 @@ namespace DCGO.CardEffects.BT21
 
                             yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
+                            Permanent selectedPermanent = null;
+
                             IEnumerator SelectPermanentCoroutine(Permanent permanent)
                             {
-                                Permanent selectedPermanent = permanent;
+                                selectedPermanent = permanent;
 
-                                if (selectedPermanent != null)
+                                yield return null;
+                            }
+
+                            if (selectedPermanent != null)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(selectedPermanent.AddDigivolutionCardsBottom(new List<CardSource>() { selectedCards[0] }, activateClass));
+
+                                #region Immunities
+
+                                bool CardEffectCondition(ICardEffect cardEffect)
                                 {
-                                    yield return ContinuousController.instance.StartCoroutine(selectedPermanent.AddDigivolutionCardsBottom(new List<CardSource>() { selectedCards[0] }, activateClass));
-
-                                    #region Immunities
-
-                                    bool CardEffectCondition(ICardEffect cardEffect)
-                                    {
-                                        return CardEffectCommons.IsOpponentEffect(cardEffect, card);
-                                    }
-
-                                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotReturnToHand(
-                                        targetPermanent: card.PermanentOfThisCard(),
-                                        cardEffectCondition: CardEffectCondition,
-                                        effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                                        activateClass: activateClass,
-                                        effectName: "Can't return to hand by opponent's effects"));
-
-                                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotReturnToDeck(
-                                        targetPermanent: card.PermanentOfThisCard(),
-                                        cardEffectCondition: CardEffectCondition,
-                                        effectDuration: EffectDuration.UntilOpponentTurnEnd,
-                                        activateClass: activateClass,
-                                        effectName: "Can't return to deck by opponent's effects"));
-
-                                    ActivateDeDigivolveProtection();
-                                    #endregion
+                                    return CardEffectCommons.IsOpponentEffect(cardEffect, card);
                                 }
+
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotReturnToHand(
+                                    targetPermanent: selectedPermanent,
+                                    cardEffectCondition: CardEffectCondition,
+                                    effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                                    activateClass: activateClass,
+                                    effectName: "Can't return to hand by opponent's effects"));
+
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCanNotReturnToDeck(
+                                    targetPermanent: selectedPermanent,
+                                    cardEffectCondition: CardEffectCondition,
+                                    effectDuration: EffectDuration.UntilOpponentTurnEnd,
+                                    activateClass: activateClass,
+                                    effectName: "Can't return to deck by opponent's effects"));
+
+                                ActivateDeDigivolveProtection();
+                                #endregion
                             }
                         }
                     }
@@ -458,7 +479,7 @@ namespace DCGO.CardEffects.BT21
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Trash source to de-digivolve", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateConditionAtkShared, ActivateCoroutine, 1, false, EffectDescription());
+                activateClass.SetUpActivateClass(CanActivateConditionAtkShared, ActivateCoroutine, 1, true, EffectDescription());
                 activateClass.SetHashString("BT21_074De-digivolve");
                 cardEffects.Add(activateClass);
                     
@@ -532,7 +553,7 @@ namespace DCGO.CardEffects.BT21
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Trash source to de-digivolve", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateConditionAtkShared, ActivateCoroutine, 1, false, EffectDescription());
+                activateClass.SetUpActivateClass(CanActivateConditionAtkShared, ActivateCoroutine, 1, true, EffectDescription());
                 activateClass.SetHashString("BT21_074De-digivolve");
                 cardEffects.Add(activateClass);
 
@@ -601,23 +622,6 @@ namespace DCGO.CardEffects.BT21
             }
             #endregion
 
-            #region Ability to link
-            if (timing == EffectTiming.None)
-            {
-                bool PermanentCondition(Permanent permanent)
-                {
-                    return permanent.TopCard.HasAppmonTraits;
-                }
-                cardEffects.Add(CardEffectFactory.AddSelfLinkConditionStaticEffect(permanentCondition: PermanentCondition, linkCost: 3, card: card));
-
-            }
-
-            if(timing == EffectTiming.OnDeclaration)
-            {
-                cardEffects.Add(CardEffectFactory.LinkEffect(card));
-            }
-            #endregion
-
             #region When Linking
             if (timing == EffectTiming.WhenLinked)
             {

Assets/CardEffect/BT21/Purple/BT21_077.cs

@@ -128,6 +128,7 @@ namespace DCGO.CardEffects.BT21
 
                                 if (selectedPermanent != null)
                                 {
+                                    /*
                                     #region Give Collision
                                     AddSkillClass addSkillClass = new AddSkillClass();
                                     addSkillClass.SetUpICardEffect("Gain Collision", CanUseCondition1, card);
@@ -137,17 +138,20 @@ namespace DCGO.CardEffects.BT21
 
                                     bool CanUseCondition1(Hashtable hashtable)
                                     {
+                                        UnityEngine.Debug.Log($"GIVE COLLISION: Can Use");
                                         return true;
                                     }
 
                                     bool CardSourceCondition(CardSource cardSource)
                                     {
+                                        UnityEngine.Debug.Log($"GIVE COLLISION: CardSourceCondition - {PermanentCondition(selectedPermanent)}");
                                         return PermanentCondition(selectedPermanent);
                                     }
 
                                     bool PermanentCondition(Permanent permanent)
                                     {
-                                        if (CardEffectCommons.IsPermanentExistsOnBattleAreaDigimon(permanent))
+                                        UnityEngine.Debug.Log($"GIVE COLLISION: PermanentCondition - {CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)}, {permanent.TopCard.CanNotBeAffected(activateClass)}, {(permanent == selectedPermanent)}");
+                                        if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
                                         {
                                             if (!permanent.TopCard.CanNotBeAffected(activateClass))
                                             {
@@ -159,16 +163,19 @@ namespace DCGO.CardEffects.BT21
                                         return false;
                                     }
 
-                                    List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
+                                    List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> gainEffects, EffectTiming _timing)
                                     {
                                         if (_timing == EffectTiming.OnCounterTiming)
                                         {
                                             bool CardSourceCondition(CardSource cardSource)
                                             {
+                                                UnityEngine.Debug.Log($"GAIN COLLISION: {CardEffectCommons.IsExistOnBattleAreaDigimon(cardSource)}");
                                                 if (CardEffectCommons.IsExistOnBattleAreaDigimon(cardSource))
                                                 {
+                                                    UnityEngine.Debug.Log($"GAIN COLLISION: {(cardSource == selectedPermanent.TopCard)}");
                                                     if (cardSource == selectedPermanent.TopCard)
                                                     {
+                                                        UnityEngine.Debug.Log($"GAIN COLLISION: {PermanentCondition(selectedPermanent)}");
                                                         if (PermanentCondition(selectedPermanent))
                                                         {
                                                             return true;
@@ -181,15 +188,22 @@ namespace DCGO.CardEffects.BT21
 
                                             bool Condition()
                                             {
+                                                UnityEngine.Debug.Log($"GAIN COLLISION: Condition - {CardSourceCondition(cardSource)}");
                                                 return CardSourceCondition(cardSource);
                                             }
 
-                                            cardEffects.Add(CardEffectFactory.CollisionSelfStaticEffect(false, cardSource, Condition));
+                                            gainEffects.Add(CardEffectFactory.CollisionSelfStaticEffect(false, cardSource, Condition));
                                         }
 
-                                        return cardEffects;
+                                        return gainEffects;
                                     }
                                     #endregion
+                                    */
+
+                                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCollision(
+                                            selectedPermanent,
+                                            EffectDuration.UntilOpponentTurnEnd,
+                                            activateClass));
 
                                     ActivateClass activateClassDebuff = new ActivateClass();
                                     activateClassDebuff.SetUpICardEffect("Attack with this Digimon", CanUseConditionDebuff,
@@ -353,17 +367,20 @@ namespace DCGO.CardEffects.BT21
 
                                     bool CanUseCondition1(Hashtable hashtable)
                                     {
+                                        UnityEngine.Debug.Log($"GIVE COLLISION: Can Use");
                                         return true;
                                     }
 
                                     bool CardSourceCondition(CardSource cardSource)
                                     {
+                                        UnityEngine.Debug.Log($"GIVE COLLISION: CardSourceCondition - {PermanentCondition(selectedPermanent)}");
                                         return PermanentCondition(selectedPermanent);
                                     }
 
                                     bool PermanentCondition(Permanent permanent)
                                     {
-                                        if (CardEffectCommons.IsPermanentExistsOnBattleAreaDigimon(permanent))
+                                        UnityEngine.Debug.Log($"GIVE COLLISION: PermanentCondition - {CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)}, {permanent.TopCard.CanNotBeAffected(activateClass)}, {(permanent == selectedPermanent)}");
+                                        if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
                                         {
                                             if (!permanent.TopCard.CanNotBeAffected(activateClass))
                                             {
@@ -375,16 +392,19 @@ namespace DCGO.CardEffects.BT21
                                         return false;
                                     }
 
-                                    List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> cardEffects, EffectTiming _timing)
+                                    List<ICardEffect> GetEffects(CardSource cardSource, List<ICardEffect> gainEffects, EffectTiming _timing)
                                     {
                                         if (_timing == EffectTiming.OnCounterTiming)
                                         {
                                             bool CardSourceCondition(CardSource cardSource)
                                             {
+                                                UnityEngine.Debug.Log($"GAIN COLLISION: {CardEffectCommons.IsExistOnBattleAreaDigimon(cardSource)}");
                                                 if (CardEffectCommons.IsExistOnBattleAreaDigimon(cardSource))
                                                 {
+                                                    UnityEngine.Debug.Log($"GAIN COLLISION: {(cardSource == selectedPermanent.TopCard)}");
                                                     if (cardSource == selectedPermanent.TopCard)
                                                     {
+                                                        UnityEngine.Debug.Log($"GAIN COLLISION: {PermanentCondition(selectedPermanent)}");
                                                         if (PermanentCondition(selectedPermanent))
                                                         {
                                                             return true;
@@ -397,21 +417,20 @@ namespace DCGO.CardEffects.BT21
 
                                             bool Condition()
                                             {
+                                                UnityEngine.Debug.Log($"GAIN COLLISION: Condition - {CardSourceCondition(cardSource)}");
                                                 return CardSourceCondition(cardSource);
                                             }
 
-                                            cardEffects.Add(CardEffectFactory.CollisionSelfStaticEffect(false, cardSource, Condition));
+                                            gainEffects.Add(CardEffectFactory.CollisionSelfStaticEffect(false, cardSource, Condition));
                                         }
 
-                                        return cardEffects;
+                                        return gainEffects;
                                     }
                                     #endregion
 
                                     ActivateClass activateClassDebuff = new ActivateClass();
-                                    activateClassDebuff.SetUpICardEffect("Attack with this Digimon", CanUseConditionDebuff,
-                                        selectedPermanent.TopCard);
-                                    activateClassDebuff.SetUpActivateClass(CanActivateConditionDebuff, ActivateCoroutineDebuff, -1, false,
-                                        EffectDescriptionDebuff());
+                                    activateClassDebuff.SetUpICardEffect("Attack with this Digimon", CanUseConditionDebuff, selectedPermanent.TopCard);
+                                    activateClassDebuff.SetUpActivateClass(CanActivateConditionDebuff, ActivateCoroutineDebuff, -1, false, EffectDescriptionDebuff());
                                     activateClassDebuff.SetEffectSourcePermanent(selectedPermanent);
                                     selectedPermanent.UntilOwnerTurnEndEffects.Add(GetCardEffect);
 

Assets/CardEffect/BT21/Red/BT21_001.cs

@@ -30,9 +30,12 @@ namespace DCGO.CardEffects.BT21
                 {
                     if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
                     {
-                        if (CardEffectCommons.CanTriggerWhenLoseSecurity(hashtable, player => player == card.Owner.Enemy))
+                        if (CardEffectCommons.IsOwnerTurn(card))
                         {
-                            return true;
+                            if (CardEffectCommons.CanTriggerWhenLoseSecurity(hashtable, player => player == card.Owner.Enemy))
+                            {
+                                return true;
+                            }
                         }
                     }
                     return false;

Assets/CardEffect/BT21/Red/BT21_009.cs

@@ -24,6 +24,19 @@ namespace DCGO.CardEffects.BT21
 
             #endregion
 
+            #region Link
+            if (timing == EffectTiming.OnDeclaration)
+            {
+                /// <summary>
+                /// Used to link a card
+                /// </summary>
+                /// <param name="card">Reference to this card</param>
+                /// <param name="condition">OPTIONAL - Function to check for effect conditions</param>
+                /// <author>Mike Bunch</author>
+                cardEffects.Add(CardEffectFactory.LinkEffect(card));
+            }
+            #endregion
+
             #region Alternative Digivolution Condition
 
             if (timing == EffectTiming.None)
@@ -64,11 +77,16 @@ namespace DCGO.CardEffects.BT21
                 string EffectDiscription()
                     => "[Your Turn] [Once Per Turn] When this Digimon gets linked, if you have 1 or fewer Tamers, you may play 1 [Haru Shinkai] from your hand without paying the cost.";
 
+                bool LinkPermanentCondition(Permanent permanent)
+                {
+                    return permanent == card.PermanentOfThisCard();
+                }
+
                 bool CanUseCondition(Hashtable hashtable)
                 {
                     if (isExistOnField(card))
                     {
-                        if (CardEffectCommons.CanTriggerWhenLinking(hashtable, null, card))
+                        if (CardEffectCommons.CanTriggerWhenLinked(hashtable, LinkPermanentCondition, null))
                         {
                             return true;
                         }
@@ -158,15 +176,6 @@ namespace DCGO.CardEffects.BT21
 
             #endregion
 
-            #region +2k DP
-
-            if (timing == EffectTiming.None)
-            {
-                cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect(changeValue: 2000, isInheritedEffect: false, card: card, condition: null, isLinkedEffect: true));
-            }
-
-            #endregion
-
             #endregion
 
             return cardEffects;

Assets/CardEffect/BT21/Red/BT21_012.cs

@@ -70,6 +70,8 @@ namespace DCGO.CardEffects.BT21
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
+                    yield return ContinuousController.instance.StartCoroutine(new SuspendPermanentsClass(new List<Permanent>() { card.PermanentOfThisCard() }, CardEffectCommons.CardEffectHashtable(activateClass)).Tap());
+
                     CardSource selectedCard = null;
                     bool tamerPlayed = false;
 

Assets/CardEffect/BT21/Red/BT21_013.cs

@@ -11,7 +11,31 @@ namespace DCGO.CardEffects.BT21
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
-            #region Alternative Digivolution Condition
+            #region Alternative Digivolution Condition - Tamer
+
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    if (targetPermanent.TopCard.IsTamer)
+                    {
+                        return targetPermanent.TopCard.CardColors.Contains(CardColor.Red);
+                    }
+                    return false;
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 2,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null)
+                );
+            }
+
+            #endregion
+
+            #region Alternative Digivolution Condition - BurningGreymon
 
             if (timing == EffectTiming.None)
             {
@@ -93,7 +117,7 @@ namespace DCGO.CardEffects.BT21
                         return true;
                     }
 
-                    if (permanent.TopCard.CardColors.Contains(CardColor.Red) && permanent.IsTamer)
+                    if (permanent.TopCard.CardColors.Contains(CardColor.Red) && permanent.IsTamer && permanent.TopCard.HasInheritedEffect)
                     {
                         return true;
                     }

Assets/CardEffect/BT21/Red/BT21_014.cs

@@ -10,6 +10,30 @@ namespace DCGO.CardEffects.BT21
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
+            #region Alternative Digivolution Condition - Tamer
+
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    if (targetPermanent.TopCard.IsTamer)
+                    {
+                        return targetPermanent.TopCard.CardColors.Contains(CardColor.Red);
+                    }
+                    return false;
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 3,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null)
+                );
+            }
+
+            #endregion
+
             #region Alternative Digivolution Condition
 
             if (timing == EffectTiming.None)

Assets/CardEffect/BT21/Red/BT21_016.cs

@@ -11,6 +11,56 @@ namespace DCGO.CardEffects.BT21
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
+            #region Alternative Digivolution Condition
+
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    if (targetPermanent.TopCard.IsLevel3)
+                    {
+                        return targetPermanent.TopCard.HasHeroTraits || targetPermanent.TopCard.EqualsTraits("Xros Heart");
+                    }
+                    return false;
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    digivolutionCost: 2,
+                    ignoreDigivolutionRequirement: false,
+                    card: card,
+                    condition: null)
+                );
+            }
+
+            #endregion
+
+            #region Also treated as [Shoutmon]
+            if (timing == EffectTiming.None)
+            {
+                ChangeCardNamesClass changeCardNamesClass = new ChangeCardNamesClass();
+                changeCardNamesClass.SetUpICardEffect("Also treated as [Shoutmon]", CanUseCondition, card);
+                changeCardNamesClass.SetUpChangeCardNamesClass(changeCardNames: changeCardNames);
+
+                cardEffects.Add(changeCardNamesClass);
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return true;
+                }
+
+                List<string> changeCardNames(CardSource cardSource, List<string> CardNames)
+                {
+                    if (cardSource == card)
+                    {
+                        CardNames.Add("Shoutmon");
+                    }
+
+                    return CardNames;
+                }
+            }
+            #endregion
+
             #region Raid
 
             if (timing == EffectTiming.OnAllyAttack)
@@ -101,19 +151,12 @@ namespace DCGO.CardEffects.BT21
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
-                    {
-                        if (CardEffectCommons.CanTriggerOnDeletion(hashtable, card))
-                        {
-                            return true;
-                        }
-                    }
-                    return false;
+                    return CardEffectCommons.CanTriggerOnDeletion(hashtable, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                    return CardEffectCommons.CanActivateOnDeletion(card);
                 }
 
                 bool CanSelectTamerCondition(Permanent permanent)

Assets/CardEffect/BT21/Red/BT21_018.cs

@@ -143,6 +143,19 @@ namespace DCGO.CardEffects.BT21
 
             #endregion
 
+            #region Link
+            if (timing == EffectTiming.OnDeclaration)
+            {
+                /// <summary>
+                /// Used to link a card
+                /// </summary>
+                /// <param name="card">Reference to this card</param>
+                /// <param name="condition">OPTIONAL - Function to check for effect conditions</param>
+                /// <author>Mike Bunch</author>
+                cardEffects.Add(CardEffectFactory.LinkEffect(card));
+            }
+            #endregion
+
             #endregion
 
             #region Your Turn
@@ -162,7 +175,7 @@ namespace DCGO.CardEffects.BT21
                 {
                     if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
                     {
-                        if (CardEffectCommons.CanTriggerWhenLinking(hashtable, PermanentCondition, card))
+                        if (CardEffectCommons.CanTriggerWhenLinked(hashtable, LinkPermanentCondition, null))
                         {
                             return true;
                         }
@@ -185,35 +198,27 @@ namespace DCGO.CardEffects.BT21
                     return false;
                 }
 
-                bool PermanentCondition(Permanent permanent)
+                bool LinkPermanentCondition(Permanent permanent)
                 {
                     return permanent == card.PermanentOfThisCard();
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if (card.PermanentOfThisCard().CanAttack(activateClass))
-                        {
-                            SelectAttackEffect selectAttackEffect = GManager.instance.GetComponent<SelectAttackEffect>();
+                    SelectAttackEffect selectAttackEffect = GManager.instance.GetComponent<SelectAttackEffect>();
 
-                            selectAttackEffect.SetUp(
-                                attacker: card.PermanentOfThisCard(),
-                                canAttackPlayerCondition: () => true,
-                                defenderCondition: (permanent) => true,
-                                cardEffect: activateClass);
+                    selectAttackEffect.SetUp(
+                        attacker: card.PermanentOfThisCard(),
+                        canAttackPlayerCondition: () => true,
+                        defenderCondition: (permanent) => true,
+                        cardEffect: activateClass);
 
-                            yield return ContinuousController.instance.StartCoroutine(selectAttackEffect.Activate());
-                        }
-                    }
+                    yield return ContinuousController.instance.StartCoroutine(selectAttackEffect.Activate());
                 }
             }
 
             #endregion
 
-            #region Link ESS
-
             #region When Linked
 
             if (timing == EffectTiming.WhenLinked)
@@ -278,17 +283,6 @@ namespace DCGO.CardEffects.BT21
 
             #endregion
 
-            #region +3k DP
-
-            if (timing == EffectTiming.None)
-            {
-                cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect(changeValue: 3000, isInheritedEffect: false, card: card, condition: null, isLinkedEffect: true));
-            }
-
-            #endregion
-
-            #endregion
-
             return cardEffects;
         }
     }

Assets/CardEffect/BT21/Red/BT21_021.cs

@@ -147,19 +147,12 @@ namespace DCGO.CardEffects.BT21
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
-                    {
-                        if (CardEffectCommons.CanTriggerOnDeletion(hashtable, card))
-                        {
-                            return true;
-                        }
-                    }
-                    return false;
+                    return CardEffectCommons.CanTriggerOnDeletion(hashtable, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                    return CardEffectCommons.CanActivateOnDeletion(card);
                 }
 
                 bool CanSelectTamerCondition(Permanent permanent)
@@ -295,7 +288,7 @@ namespace DCGO.CardEffects.BT21
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Play 1 [Xros Heart]/[Blue Flare]/[Hero] Digimon", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -329,7 +322,7 @@ namespace DCGO.CardEffects.BT21
 
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    if (cardSource.IsDigimon)
+                    if (cardSource.IsDigimon || cardSource.IsTamer)
                     {
                         if (cardSource.EqualsTraits("Xros Heart") || cardSource.EqualsTraits("Blue Flare") || cardSource.EqualsTraits("Hero"))
                         {
@@ -371,10 +364,21 @@ namespace DCGO.CardEffects.BT21
                     {
                         bool isPlayed = false;
                         var reducdedCost = selectedCard.BasePlayCostFromEntity - 5;
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: new List<CardSource>() { selectedCard }, activateClass: activateClass, payCost: true, isTapped: false, root: SelectCardEffect.Root.Hand, activateETB: true, fixedCost: reducdedCost));
+
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
+                                     cardSources: new List<CardSource>() { selectedCard }, 
+                                     activateClass: activateClass, 
+                                     payCost: true, 
+                                     isTapped: false, 
+                                     root: SelectCardEffect.Root.Hand,
+                                     activateETB: true, 
+                                     fixedCost: reducdedCost));
+
                         if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedCard.PermanentOfThisCard())) isPlayed = true;
+
                         if (isPlayed)
                         {
+
                             SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
 
                             selectPermanentEffect.SetUp(

Assets/CardEffect/BT21/Red/BT21_023.cs

@@ -120,6 +120,19 @@ namespace DCGO.CardEffects.BT21
 
             #endregion
 
+            #region Link
+            if (timing == EffectTiming.OnDeclaration)
+            {
+                /// <summary>
+                /// Used to link a card
+                /// </summary>
+                /// <param name="card">Reference to this card</param>
+                /// <param name="condition">OPTIONAL - Function to check for effect conditions</param>
+                /// <author>Mike Bunch</author>
+                cardEffects.Add(CardEffectFactory.LinkEffect(card));
+            }
+            #endregion
+
             #endregion
 
             #region On Play / When digivolving Shared
@@ -134,7 +147,6 @@ namespace DCGO.CardEffects.BT21
                         {
                             return true;
                         }
-                        return true;
                     }
                 }
                 return false;
@@ -230,7 +242,7 @@ namespace DCGO.CardEffects.BT21
 
                     if (selectedCard != null)
                     {
-                        yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddLinkCard(card, activateClass));
+                        yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddLinkCard(selectedCard, activateClass));
                     }
                 }
             }
@@ -243,7 +255,7 @@ namespace DCGO.CardEffects.BT21
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("You may Link 1 level 4 or lower digimon", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, hashtable => SharedActivateCoroutine(hashtable, activateClass), -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, hashtable => SharedActivateCoroutine(hashtable, activateClass), -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -284,7 +296,7 @@ namespace DCGO.CardEffects.BT21
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("You may Link 1 level 4 or lower digimon", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, hashtable => SharedActivateCoroutine(hashtable, activateClass), -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, hashtable => SharedActivateCoroutine(hashtable, activateClass), -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -475,14 +487,6 @@ namespace DCGO.CardEffects.BT21
 
             #endregion
 
-            #region ESS - +4k DP
-
-            if (timing == EffectTiming.None)
-            {
-                cardEffects.Add(CardEffectFactory.ChangeSelfDPStaticEffect(changeValue: 2000, isInheritedEffect: false, card: card, condition: null, isLinkedEffect: true));
-            }
-
-            #endregion
 
             return cardEffects;
         }

Assets/CardEffect/BT21/Red/BT21_024.cs

@@ -24,6 +24,11 @@ namespace DCGO.CardEffects.BT21
                     return "[On Play] If your opponent has 5 or fewer security cards, they place 1 card from their hand as the bottom security card. Then, trash their top security card.";
                 }
 
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    return true;
+                }
+
                 bool CanUseCondition(Hashtable hashtable)
                 {
                     return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
@@ -36,23 +41,22 @@ namespace DCGO.CardEffects.BT21
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
+                    CardSource selectedCard = null;
                     if (card.Owner.Enemy.SecurityCards.Count <= 5 && card.Owner.Enemy.HandCards.Count() >= 1)
                     {
-                        List<CardSource> selectedCard = new List<CardSource>();
-
                         int maxCount = 1;
 
                         SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
 
                         selectHandEffect.SetUp(
                             selectPlayer: card.Owner.Enemy,
-                            canTargetCondition: null,
+                            canTargetCondition: CanSelectCardCondition,
                             canTargetCondition_ByPreSelecetedList: null,
                             canEndSelectCondition: null,
                             maxCount: maxCount,
                             canNoSelect: false,
                             canEndNotMax: false,
-                            isShowOpponent: true,
+                            isShowOpponent: false,
                             selectCardCoroutine: SelectCardCoroutine,
                             afterSelectCardCoroutine: null,
                             mode: SelectHandEffect.Mode.Custom,
@@ -62,22 +66,24 @@ namespace DCGO.CardEffects.BT21
                             "Select 1 card to place at the bottom of security.",
                             "The opponent is selecting 1 card to place at the bottom of security.");
 
-                        selectHandEffect.SetUpCustomMessage_ShowCard("Security Bottom Card");
-
-                        yield return StartCoroutine(selectHandEffect.Activate());
+                        yield return ContinuousController.instance.StartCoroutine(selectHandEffect.Activate());
 
                         IEnumerator SelectCardCoroutine(CardSource cardSource)
                         {
-                            if (selectedCard != null)
-                            {
-                                yield return ContinuousController.instance.StartCoroutine(new IPutSecurityPermanent(
-                                    cardSource.PermanentOfThisCard(),
-                                    CardEffectCommons.CardEffectHashtable(activateClass),
-                                    false).PutSecurity());
-                            }
+                            selectedCard = cardSource;
+                            yield return null;
                         }
                     }
 
+                    if (selectedCard != null)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(selectedCard, toTop: false));
+
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(selectedCard.Owner));
+
+                        yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(selectedCard.Owner).AddSecurity());
+                    }
+
                     yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
                         player: card.Owner.Enemy,
                         destroySecurityCount: 1,

Assets/CardEffect/BT21/Red/BT21_025.cs

@@ -41,10 +41,11 @@ namespace DCGO.CardEffects.BT21
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("trash top security", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+                activateClass.SetHashString("YT_BT21-025");
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
-                    => "Your Turn] [Once Per Turn] When any of your [Reptile]/[Dragonkin] trait Digimon's attack targets change, trash your opponent's top security card.";
+                    => "[Your Turn] [Once Per Turn] When any of your [Reptile]/[Dragonkin] trait Digimon's attack targets change, trash your opponent's top security card.";
 
                 bool CanUseCondition(Hashtable hashtable)
                 {

Assets/CardEffect/BT21/Red/BT21_027.cs

@@ -62,7 +62,7 @@ namespace DCGO.CardEffects.BT21
             if (timing == EffectTiming.None)
             {
                 AddDigiXrosConditionClass addDigiXrosConditionClass = new AddDigiXrosConditionClass();
-                addDigiXrosConditionClass.SetUpICardEffect($"DigiXros", CanUseCondition, card);
+                addDigiXrosConditionClass.SetUpICardEffect($"DigiXros -3", CanUseCondition, card);
                 addDigiXrosConditionClass.SetUpAddDigiXrosConditionClass(getDigiXrosCondition: GetDigiXros);
                 addDigiXrosConditionClass.SetNotShowUI(true);
                 cardEffects.Add(addDigiXrosConditionClass);
@@ -76,9 +76,9 @@ namespace DCGO.CardEffects.BT21
                 {
                     if (cardSource == card)
                     {
-                        DigiXrosConditionElement element = new DigiXrosConditionElement(CanSelectCardCondition, "[OmniShoutmon]/[ZeigGreymon]");
+                        DigiXrosConditionElement element = new DigiXrosConditionElement(CanSelectCardCondition1, "[OmniShoutmon]");
 
-                        bool CanSelectCardCondition(CardSource cardSource)
+                        bool CanSelectCardCondition1(CardSource cardSource)
                         {
                             if (cardSource != null)
                             {
@@ -90,7 +90,23 @@ namespace DCGO.CardEffects.BT21
                                         {
                                             return true;
                                         }
+                                    }
+                                }
+                            }
+
+                            return false;
+                        }
+
+                        DigiXrosConditionElement element2 = new DigiXrosConditionElement(CanSelectCardCondition2, "[ZeigGreymon]");
 
+                        bool CanSelectCardCondition2(CardSource cardSource)
+                        {
+                            if (cardSource != null)
+                            {
+                                if (cardSource.Owner == card.Owner)
+                                {
+                                    if (cardSource.IsDigimon)
+                                    {
                                         if (cardSource.EqualsCardName("ZeigGreymon"))
                                         {
                                             return true;
@@ -102,7 +118,7 @@ namespace DCGO.CardEffects.BT21
                             return false;
                         }
 
-                        List<DigiXrosConditionElement> elements = new List<DigiXrosConditionElement>() { element };
+                        List<DigiXrosConditionElement> elements = new List<DigiXrosConditionElement>() { element, element2 };
 
                         DigiXrosCondition digiXrosCondition = new DigiXrosCondition(elements, null, 3);
 

Assets/CardEffect/BT21/Red/BT21_029.cs

@@ -3,7 +3,7 @@ using System.Collections;
 using System.Collections.Generic;
 
 // Medusamon
-namespace DCGO.CardEffects
+namespace DCGO.CardEffects.BT21
 {
     public class BT21_029 : CEntity_Effect
     {
@@ -15,7 +15,7 @@ namespace DCGO.CardEffects
 
             #region Progress
 
-            if (timing == EffectTiming.OnAllyAttack)
+            if (timing == EffectTiming.OnAllyAttack || timing == EffectTiming.OnEnterFieldAnyone)
             {
                 bool Condition()
                 {

Assets/CardEffect/BT21/Red/BT21_081.cs

@@ -75,7 +75,8 @@ namespace DCGO.CardEffects.BT21
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
+                    return CardEffectCommons.IsOwnerTurn(card) &&
+                           CardEffectCommons.IsExistOnBattleArea(card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
@@ -105,7 +106,7 @@ namespace DCGO.CardEffects.BT21
                             canTargetCondition_ByPreSelecetedList: null,
                             canEndSelectCondition: null,
                             maxCount: 1,
-                            canNoSelect: true,
+                            canNoSelect: false,
                             canEndNotMax: false,
                             selectPermanentCoroutine: SelectPermanentCoroutine,
                             afterSelectPermanentCoroutine: null,
@@ -136,8 +137,6 @@ namespace DCGO.CardEffects.BT21
                                     defenderCondition: (permanent) => true,
                                     cardEffect: activateClass);
 
-                                selectAttackEffect.SetCanNotSelectNotAttack();
-
                                 yield return ContinuousController.instance.StartCoroutine(selectAttackEffect.Activate());
                             }
                         }

Assets/CardEffect/BT21/Red/BT21_082.cs

@@ -25,31 +25,42 @@ namespace DCGO.CardEffects.BT21
                     return "[Start of Your Main Phase] 1 of your Digimon or Tamers may digivolve into a Digimon card with the [Hybrid] or [Hero] trait in the hand. For each of your red Tamers with different names, reduce this effect's digivolution cost by 1.";
                 }
 
-                bool CanUseCondition(Hashtable hashtable)
+                bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card))
+                    {
+                        if(permanent.IsDigimon || permanent.IsTamer)
+                        {
+                            foreach (CardSource cardSource in card.Owner.HandCards)
+                            {
+                                if (CanSelectCardCondition(cardSource))
+                                {
+                                    if (cardSource.CanPlayCardTargetFrame(permanent.PermanentFrame, true, activateClass))
+                                    {
+                                        return true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    return false;
                 }
 
-                bool CanActivateCondition(Hashtable hashtable)
+                bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
+                    return cardSource.EqualsTraits("Hybrid") || cardSource.EqualsTraits("Hero");
                 }
 
-                bool CanSelectDigivolvePermanent(Permanent permanent)
+                bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card) && (permanent.IsTamer || permanent.IsDigimon);
+                    return CardEffectCommons.IsOwnerTurn(card) &&
+                           CardEffectCommons.IsExistOnBattleArea(card);
                 }
 
-                bool CanSelectCardCondition(CardSource digivolveTarget, Permanent digivolvingTarget)
+                bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (digivolveTarget.EqualsTraits("Hybrid") || digivolveTarget.EqualsTraits("Hero"))
-                    {
-                        if (digivolveTarget.CanPlayCardTargetFrame(digivolvingTarget.PermanentFrame, true, activateClass))
-                        {
-                            return true;
-                        }
-                    }
-                    return false;
+                    return CardEffectCommons.IsExistOnBattleArea(card);
                 }
 
                 int costReduction()
@@ -67,45 +78,48 @@ namespace DCGO.CardEffects.BT21
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    Permanent selectedPermanent = null;
-                    int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectDigivolvePermanent));
-                    SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                    selectPermanentEffect.SetUp(
-                        selectPlayer: card.Owner,
-                        canTargetCondition: CanSelectDigivolvePermanent,
-                        canTargetCondition_ByPreSelecetedList: null,
-                        canEndSelectCondition: null,
-                        maxCount: maxCount,
-                        canNoSelect: true,
-                        canEndNotMax: false,
-                        selectPermanentCoroutine: SelectPermanentCoroutine,
-                        afterSelectPermanentCoroutine: null,
-                        mode: SelectPermanentEffect.Mode.Custom,
-                        cardEffect: activateClass);
-
-                    selectPermanentEffect.SetUpCustomMessage("Select 1 digimon to digivolve", "The opponent is selecting 1 digimon to digivolve");
-                    yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                     {
-                        selectedPermanent = permanent;
-                        yield return null;
-                    }
+                        Permanent selectedPermanent = null;
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectPermanentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 digimon to digivolve", "The opponent is selecting 1 digimon to digivolve");
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            selectedPermanent = permanent;
+                            yield return null;
+                        }
 
-                    if (selectedPermanent != null)
-                    {
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DigivolveIntoHandOrTrashCard(
-                                targetPermanent: selectedPermanent,
-                                cardCondition: (cardSource) => CanSelectCardCondition(cardSource, selectedPermanent),
-                                payCost: true,
-                                reduceCostTuple: (reduceCost: costReduction(), reduceCostCardCondition: null),
-                                fixedCostTuple: null,
-                                ignoreDigivolutionRequirementFixedCost: -1,
-                                isHand: true,
-                                activateClass: activateClass,
-                                successProcess: null));
-                    }
+                        if (selectedPermanent != null)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DigivolveIntoHandOrTrashCard(
+                                    targetPermanent: selectedPermanent,
+                                    cardCondition: CanSelectCardCondition,
+                                    payCost: true,
+                                    reduceCostTuple: (reduceCost: costReduction(), reduceCostCardCondition: null),
+                                    fixedCostTuple: null,
+                                    ignoreDigivolutionRequirementFixedCost: -1,
+                                    isHand: true,
+                                    activateClass: activateClass,
+                                    successProcess: null));
+                        }
+                    } 
                 }
             }
             #endregion
@@ -117,7 +131,6 @@ namespace DCGO.CardEffects.BT21
             }
             #endregion
 
-
             #region Inherit
             if(timing == EffectTiming.OnLoseSecurity)
             {
@@ -187,6 +200,7 @@ namespace DCGO.CardEffects.BT21
                 }
             }
             #endregion
+
             return cardEffects;
         }
     }

Assets/CardEffect/BT21/Red/BT21_083.cs

@@ -113,6 +113,8 @@ namespace DCGO.CardEffects.BT21
 
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
+                List<Permanent> playedPermanents = new List<Permanent>();
+
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Suspend this tamer, Attack with a [Xros Heart]/[Hero] Digimon", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
@@ -157,16 +159,20 @@ namespace DCGO.CardEffects.BT21
 
                 bool AttackingPermanentCondition(Permanent permanent)
                 {
-                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
+                    if (playedPermanents.Contains(permanent))
                     {
-                        if (permanent.TopCard.EqualsTraits("Xros Heart") || permanent.TopCard.EqualsTraits("Hero"))
+                        if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
                         {
-                            if (permanent.CanAttack(activateClass))
+                            if (permanent.TopCard.EqualsTraits("Xros Heart") || permanent.TopCard.EqualsTraits("Hero"))
                             {
-                                return true;
+                                if (permanent.CanAttack(activateClass))
+                                {
+                                    return true;
+                                }
                             }
                         }
                     }
+                    
                     return false;
                 }
 
@@ -174,6 +180,8 @@ namespace DCGO.CardEffects.BT21
                 {
                     yield return ContinuousController.instance.StartCoroutine(new SuspendPermanentsClass(new List<Permanent>() { card.PermanentOfThisCard() }, CardEffectCommons.CardEffectHashtable(activateClass)).Tap());
 
+                    playedPermanents = CardEffectCommons.GetPermanentsFromHashtable(hashtable);
+
                     if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, AttackingPermanentCondition))
                     {
                         Permanent selectedPermanent = null;

Assets/CardEffect/BT21/Red/BT21_084.cs

@@ -3,7 +3,8 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
-namespace DCGO.CardEffects
+//Haru Shinkai
+namespace DCGO.CardEffects.BT21
 {
     public class BT21_084 : CEntity_Effect
     {

Assets/CardEffect/BT21/Red/BT21_090.cs

@@ -84,7 +84,7 @@ namespace DCGO.CardEffects.BT21
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Your 1 Digimon digivolves", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()

Assets/CardEffect/BT21/Red/BT21_092.cs

@@ -196,7 +196,7 @@ namespace DCGO.CardEffects.BT21
             if (timing == EffectTiming.SecuritySkill)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Play 1 Tamer with inherited effects", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Play 1 [Xros Heart] trait card with a play cost of 5 or less", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
                 cardEffects.Add(activateClass);
 

Assets/CardEffect/BT21/Red/BT21_093.cs

@@ -18,7 +18,7 @@ namespace DCGO.CardEffects.BT21
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Reduce Play Cost -4", CanUseCondition, card);
-                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
                 activateClass.SetHashString("PlayCost-4_BT21_093");
                 cardEffects.Add(activateClass);
 
@@ -30,9 +30,7 @@ namespace DCGO.CardEffects.BT21
                 bool CanUseCondition(Hashtable hashtable)
                 {
                     if (CardEffectCommons.CanTriggerWhenPermanentWouldPlay(hashtable, cardSource => cardSource == card))
-                    {
-                        return true;
-                    }
+                        return (card.Owner.Enemy.SecurityCards.Count <= 3);
 
                     return false;
                 }
@@ -281,7 +279,7 @@ namespace DCGO.CardEffects.BT21
                 {
                     if (CardEffectCommons.IsExistOnBattleArea(card))
                     {
-                        if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, CanSelectPermanent) && CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCard))
+                        if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, CanSelectPermanent))
                         {
                             return true;
                         }
@@ -295,66 +293,81 @@ namespace DCGO.CardEffects.BT21
                     {
                         if (permanent.TopCard.EqualsTraits("Reptile") || permanent.TopCard.EqualsTraits("Dragonkin"))
                         {
-                            return true;
+                            foreach (CardSource cardSource in card.Owner.HandCards)
+                            {
+                                if (CanSelectCardCondition(cardSource))
+                                {
+                                    if (cardSource.CanPlayCardTargetFrame(permanent.PermanentFrame, true, activateClass))
+                                    {
+                                        return true;
+                                    }
+                                }
+                            }
                         }
                     }
                     return false;
                 }
 
-                bool CanSelectCard(CardSource cardSource)
+                bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    if (CardEffectCommons.IsExistOnHand(cardSource))
-                    {
-                        if (cardSource.EqualsTraits("Reptile") || cardSource.EqualsTraits("Dragonkin"))
-                        {
-                            return true;
-                        }
-                    }
-                    return false;
+                    return cardSource.EqualsTraits("Reptile") || cardSource.EqualsTraits("Dragonkin");
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, CanSelectPermanent) && CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCard))
+                    bool delaySuccessful = false;
+
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: new List<Permanent>() { card.PermanentOfThisCard() }, activateClass: activateClass, successProcess: permanents => SuccessProcess(), failureProcess: null));
+
+                    IEnumerator SuccessProcess()
                     {
-                        Permanent selectedDigimon = null;
-                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOwnersPermanentCount(card, CanSelectPermanent));
-                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-                        selectPermanentEffect.SetUp(
-                            selectPlayer: card.Owner,
-                            canTargetCondition: CanSelectPermanent,
-                            canTargetCondition_ByPreSelecetedList: null,
-                            canEndSelectCondition: null,
-                            maxCount: maxCount,
-                            canNoSelect: true,
-                            canEndNotMax: false,
-                            selectPermanentCoroutine: SelectPermanentCoroutine,
-                            afterSelectPermanentCoroutine: null,
-                            mode: SelectPermanentEffect.Mode.Custom,
-                            cardEffect: activateClass);
-                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to digivolve", "The opponent is selecting 1 Digimon to digivolve");
-
-                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
-                        {
-                            selectedDigimon = permanent;
-                            yield return null;
-                        }
+                        delaySuccessful = true;
+                        yield return null;
+                    }
 
-                        if (selectedDigimon != null)
+                    if (delaySuccessful)
+                    {
+                        if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, CanSelectPermanent))
                         {
-                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DigivolveIntoHandOrTrashCard(
-                                targetPermanent: selectedDigimon,
-                                cardCondition: CanSelectCard,
-                                payCost: false,
-                                reduceCostTuple: null,
-                                fixedCostTuple: null,
-                                ignoreDigivolutionRequirementFixedCost: -1,
-                                isHand: true,
-                                activateClass: activateClass,
-                                successProcess: null));
+                            Permanent selectedDigimon = null;
+                            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOwnersPermanentCount(card, CanSelectPermanent));
+                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                            selectPermanentEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectPermanent,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                maxCount: maxCount,
+                                canNoSelect: true,
+                                canEndNotMax: false,
+                                selectPermanentCoroutine: SelectPermanentCoroutine,
+                                afterSelectPermanentCoroutine: null,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+                            selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to digivolve", "The opponent is selecting 1 Digimon to digivolve");
+
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                            IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                            {
+                                selectedDigimon = permanent;
+                                yield return null;
+                            }
+
+                            if (selectedDigimon != null)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DigivolveIntoHandOrTrashCard(
+                                    targetPermanent: selectedDigimon,
+                                    cardCondition: CanSelectCardCondition,
+                                    payCost: false,
+                                    reduceCostTuple: null,
+                                    fixedCostTuple: null,
+                                    ignoreDigivolutionRequirementFixedCost: -1,
+                                    isHand: true,
+                                    activateClass: activateClass,
+                                    successProcess: null));
+                            }
                         }
-                    }
+                    }                    
                 }
             }
 

Assets/CardEffect/BT6/Red/BT6_087.cs

@@ -79,9 +79,9 @@ public class BT6_087 : CEntity_Effect
 
             IEnumerator ActivateCoroutine(Hashtable _hashtable)
             {
-                yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(1, activateClass));
-
                 yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
+
+                yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(1, activateClass));
             }
         }
 

Assets/CardEffect/LM/Blue/LM_041.cs

@@ -74,15 +74,9 @@ namespace DCGO.CardEffects.LM
                 {
                     if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
                     {
-                        if (permanent.IsSuspended)
+                        if (permanent.TopCard.EqualsTraits("DS"))
                         {
-                            if (CardEffectCommons.CanUnsuspend(permanent))
-                            {
-                                if (permanent.TopCard.EqualsTraits("DS"))
-                                {
-                                    return true;
-                                }
-                            }
+                            return true;
                         }
                     }
                     return false;
@@ -106,7 +100,7 @@ namespace DCGO.CardEffects.LM
                         mode: SelectPermanentEffect.Mode.UnTap,
                         cardEffect: activateClass);
 
-                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will be returned to bottom of the deck", "The opponent is selecting 1 Digimon that will be returned to bottom of the deck");
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will be returned to unsuspend", "The opponent is selecting 1 Digimon that will be returned to unsuspend");
 
                     yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
                 }
@@ -156,15 +150,9 @@ namespace DCGO.CardEffects.LM
                 {
                     if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
                     {
-                        if (permanent.IsSuspended)
+                        if (permanent.TopCard.EqualsTraits("DS"))
                         {
-                            if (CardEffectCommons.CanUnsuspend(permanent))
-                            {
-                                if (permanent.TopCard.EqualsTraits("DS"))
-                                {
-                                    return true;
-                                }
-                            }
+                            return true;
                         }
                     }
                     return false;
@@ -188,7 +176,7 @@ namespace DCGO.CardEffects.LM
                         mode: SelectPermanentEffect.Mode.UnTap,
                         cardEffect: activateClass);
 
-                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will be returned to bottom of the deck", "The opponent is selecting 1 Digimon that will be returned to bottom of the deck");
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will be returned to unsuspend", "The opponent is selecting 1 Digimon that will be returned to unsuspend");
 
                     yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
                 }
@@ -238,10 +226,7 @@ namespace DCGO.CardEffects.LM
                     {
                         if (permanent.IsDigimon && permanent.IsTamer)
                         {
-                            if (!permanent.TopCard.CanNotBeAffected(activateClass))
-                            {
-                                return true;
-                            }
+                            return true;
                         }
                     }
                     return false;
@@ -257,6 +242,7 @@ namespace DCGO.CardEffects.LM
                             player: card.Owner.Enemy,
                             refSkillInfos: ref ContinuousController.instance.nullSkillInfos).ReduceSecurity());
                     }
+
                     if (card.Owner.MemoryForPlayer <= 1 && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectPermanentCondition))
                     {
                         Permanent selectedPermanent = null;
@@ -339,10 +325,7 @@ namespace DCGO.CardEffects.LM
                     {
                         if (permanent.IsDigimon && permanent.IsTamer)
                         {
-                            if (!permanent.TopCard.CanNotBeAffected(activateClass))
-                            {
-                                return true;
-                            }
+                            return true;
                         }
                     }
                     return false;
@@ -358,6 +341,7 @@ namespace DCGO.CardEffects.LM
                             player: card.Owner.Enemy,
                             refSkillInfos: ref ContinuousController.instance.nullSkillInfos).ReduceSecurity());
                     }
+
                     if (card.Owner.MemoryForPlayer <= 1 && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectPermanentCondition))
                     {
                         Permanent selectedPermanent = null;

Assets/CardEffect/LM/Green/LM_042.cs

@@ -92,13 +92,7 @@ namespace DCGO.CardEffects.LM
                     {
                         if (permanent.IsTamer || permanent.IsDigimon)
                         {
-                            if (!permanent.IsSuspended)
-                            {
-                                if (!permanent.TopCard.CanNotBeAffected(activateClass))
-                                {
-                                    return true;
-                                }
-                            }
+                            return true;
                         }
                     }
                     return false;
@@ -137,7 +131,7 @@ namespace DCGO.CardEffects.LM
                         mode: SelectPermanentEffect.Mode.Tap,
                         cardEffect: activateClass);
 
-                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimom or Tamer to suspend", "The opponent is selecting 1 Digimom or tamer to suspend");
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon or Tamer to suspend", "The opponent is selecting 1 Digimon or tamer to suspend");
                     yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
                     Permanent selectedPermanent = null;
@@ -157,7 +151,7 @@ namespace DCGO.CardEffects.LM
                         mode: SelectPermanentEffect.Mode.Custom,
                         cardEffect: activateClass);
 
-                    selectPermanentEffect1.SetUpCustomMessage("Select 1 Digimom or Tamer to disable WD effects", "The opponent is selecting 1 Digimom or tamer to disable WD effects");
+                    selectPermanentEffect1.SetUpCustomMessage("Select 1 Digimon or Tamer to disable WD effects", "The opponent is selecting 1 Digimon or tamer to disable WD effects");
                     yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect1.Activate());
 
                     IEnumerator SelectPermanentCoroutine(Permanent permanent)
@@ -250,13 +244,7 @@ namespace DCGO.CardEffects.LM
                     {
                         if (permanent.IsTamer || permanent.IsDigimon)
                         {
-                            if (!permanent.IsSuspended)
-                            {
-                                if (!permanent.TopCard.CanNotBeAffected(activateClass))
-                                {
-                                    return true;
-                                }
-                            }
+                            return true;
                         }
                     }
                     return false;
@@ -295,7 +283,7 @@ namespace DCGO.CardEffects.LM
                         mode: SelectPermanentEffect.Mode.Tap,
                         cardEffect: activateClass);
 
-                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimom or Tamer to suspend", "The opponent is selecting 1 Digimom or tamer to suspend");
+                    selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon or Tamer to suspend", "The opponent is selecting 1 Digimon or tamer to suspend");
                     yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
                     Permanent selectedPermanent = null;
@@ -315,7 +303,7 @@ namespace DCGO.CardEffects.LM
                         mode: SelectPermanentEffect.Mode.Custom,
                         cardEffect: activateClass);
 
-                    selectPermanentEffect1.SetUpCustomMessage("Select 1 Digimom or Tamer to disable WD effects", "The opponent is selecting 1 Digimom or tamer to disable WD effects");
+                    selectPermanentEffect1.SetUpCustomMessage("Select 1 Digimon or Tamer to disable WD effects", "The opponent is selecting 1 Digimon or tamer to disable WD effects");
                     yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect1.Activate());
 
                     IEnumerator SelectPermanentCoroutine(Permanent permanent)
@@ -377,19 +365,12 @@ namespace DCGO.CardEffects.LM
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
-                    {
-                        if (CardEffectCommons.CanTriggerOnDeletion(hashtable, card))
-                        {
-                            return true;
-                        }
-                    }
-                    return false;
+                    return CardEffectCommons.CanTriggerOnDeletion(hashtable, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                    if (CardEffectCommons.CanActivateOnDeletion(card))
                     {
                         if (card.Owner.CanAddSecurity(activateClass))
                         {

Assets/CardEffect/LM/Purple/LM_044.cs

@@ -57,19 +57,12 @@ namespace DCGO.CardEffects.LM
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
-                    {
-                        if (CardEffectCommons.CanTriggerOnDeletion(hashtable, card))
-                        {
-                            return true;
-                        }
-                    }
-                    return false;
+                    return CardEffectCommons.CanTriggerOnDeletion(hashtable, card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                    return CardEffectCommons.CanActivateOnDeletion(card);
                 }
 
                 bool CanSelectPermanentCondition(Permanent permanent)

Assets/CardEffect/LM/Red/LM_039.cs

@@ -148,17 +148,20 @@ namespace DCGO.CardEffects.LM
                             yield return null;
                         }
 
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.BouncePeremanentAndProcessAccordingToResult(new List<Permanent> { selectedPermanent }, activateClass, SuccessProcess(), null));
-                        IEnumerator SuccessProcess()
+                        if(selectedPermanent != null)
                         {
-                            bottomdecked = true;
-                            yield return null;
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeckBouncePeremanentAndProcessAccordingToResult(new List<Permanent> { selectedPermanent }, activateClass, SuccessProcess(), null));
+                            IEnumerator SuccessProcess()
+                            {
+                                bottomdecked = true;
+                                yield return null;
+                            }
                         }
-                    }
 
-                    if (!bottomdecked)
-                    {
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonSAttack(targetPermanent: card.PermanentOfThisCard(), changeValue: 1, effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
+                        if (!bottomdecked)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonSAttack(targetPermanent: card.PermanentOfThisCard(), changeValue: 1, effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
+                        }
                     }
                 }
             }
@@ -242,17 +245,21 @@ namespace DCGO.CardEffects.LM
                             yield return null;
                         }
 
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.BouncePeremanentAndProcessAccordingToResult(new List<Permanent> { selectedPermanent }, activateClass, SuccessProcess(), null));
-                        IEnumerator SuccessProcess()
+                        if (selectedPermanent != null)
                         {
-                            bottomdecked = true;
-                            yield return null;
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeckBouncePeremanentAndProcessAccordingToResult(new List<Permanent> { selectedPermanent }, activateClass, SuccessProcess(), null));
+                            
+                            IEnumerator SuccessProcess()
+                            {
+                                bottomdecked = true;
+                                yield return null;
+                            }
                         }
-                    }
 
-                    if (!bottomdecked)
-                    {
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonSAttack(targetPermanent: card.PermanentOfThisCard(), changeValue: 1, effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
+                        if (!bottomdecked)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonSAttack(targetPermanent: card.PermanentOfThisCard(), changeValue: 1, effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
+                        }
                     }
                 }
             }

Assets/CardEffect/P/Black/P_184.cs

@@ -112,13 +112,12 @@ namespace DCGO.CardEffects.P
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: card.PermanentOfThisCard(), changeValue: 3000, effectDuration: EffectDuration.UntilOpponentTurnEnd, activateClass: activateClass));
-                    if (card.PermanentOfThisCard().cardSources.Find(x => x.EqualsCardName("Kosuke Kisakata")) != null)
+                    
+                    if (card.PermanentOfThisCard().DigivolutionCards.Any(x => x.EqualsCardName("Kosuke Kisakata")))
                     {
                         var permanents = card.Owner.GetBattleAreaDigimons().Filter(x => CanTargetPermanentCondition(x)).ToList();
-                        if (permanents.Any())
-                        {
-                            yield return ContinuousController.instance.StartCoroutine(new IUnsuspendPermanents(permanents, activateClass).Unsuspend());
-                        }
+
+                        yield return ContinuousController.instance.StartCoroutine(new IUnsuspendPermanents(permanents, activateClass).Unsuspend());
                     }
                 }
             }

Assets/CardEffect/P/Green/P_185.cs

@@ -139,18 +139,28 @@ namespace DCGO.CardEffects.P
 
             if (timing == EffectTiming.None)
             {
-                List<CardSource> cards = card.PermanentOfThisCard().cardSources;
-                var colourCount = Combinations.GetDifferenetColorCardCount(cards);
-                var newDP = colourCount * 1000;
+                int count()
+                {
+                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                    {
+                        List<CardSource> cards = card.PermanentOfThisCard().cardSources;
+                        var colourCount = Combinations.GetDifferenetColorCardCount(cards);
+                        var newDP = colourCount * 1000;
+
+                        return newDP;
+                    }
+
+                    return 0;
+                }
 
                 bool Condition()
                 {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
                 }
 
                 bool PermanentCondition(Permanent permanent)
                 {
-                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card))
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
                     {
                         if (permanent == card.PermanentOfThisCard())
                         {
@@ -163,7 +173,7 @@ namespace DCGO.CardEffects.P
 
                 cardEffects.Add(CardEffectFactory.ChangeDPStaticEffect(
                 permanentCondition: PermanentCondition,
-                changeValue: newDP,
+                changeValue: count(),
                 isInheritedEffect: false,
                 card: card,
                 condition: Condition,

Assets/CardEffect/P/Purple/P_187.cs

@@ -132,7 +132,7 @@ namespace DCGO.CardEffects.P
                 {
                     if (CardEffectCommons.IsPermanentExistsOnBattleArea(permanent))
                     {
-                        if (permanent.IsTamer || permanent.IsTamer)
+                        if (permanent.IsDigimon || permanent.IsTamer)
                         {
                             return true;
                         }
@@ -170,6 +170,8 @@ namespace DCGO.CardEffects.P
 
                             selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to place in security", "The opponent is selecting 1 Digimon place in security.");
 
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
                             IEnumerator SelectPermanentCoroutine(Permanent permanent)
                             {
                                 Permanent selectedPermanent = permanent;

Assets/CardEffect/P/Red/P_182.cs

@@ -148,15 +148,27 @@ namespace DCGO.CardEffects.P
 
             if (timing == EffectTiming.None)
             {
-                List<CardSource> cards = card.Owner.FieldPermanents
-                        .Where(x => x.IsDigimon && x.IsTamer)
+                int count()
+                {
+                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                    {
+
+                        List<CardSource> cards = card.Owner.FieldPermanents
+                        .Where(x => x.IsDigimon || x.IsTamer)
                         .Select(x => x.TopCard)
                         .Concat(card.Owner.Enemy.FieldPermanents
-                            .Where(x => x.IsDigimon && x.IsTamer)
+                            .Where(x => x.IsDigimon || x.IsTamer)
                             .Select(x => x.TopCard))
                         .ToList();
-                var colourCount = Combinations.GetDifferenetColorCardCount(cards);
-                var newDP = colourCount * 1000;
+                        var colourCount = Combinations.GetDifferenetColorCardCount(cards);
+                        var newDP = colourCount * 1000;
+
+
+                        return newDP;
+                    }
+
+                    return 0;
+                }
 
                 bool Condition()
                 {
@@ -178,7 +190,7 @@ namespace DCGO.CardEffects.P
 
                 cardEffects.Add(CardEffectFactory.ChangeDPStaticEffect(
                 permanentCondition: PermanentCondition,
-                changeValue: newDP,
+                changeValue: count(),
                 isInheritedEffect: false,
                 card: card,
                 condition: Condition,

Assets/CardEffect/P/Red/P_186.cs

@@ -164,7 +164,7 @@ namespace DCGO.CardEffects.P
                     return false;
                 }
 
-                Permanent permanent = null;
+                Permanent selectedPermanent = null;
                 bool permanentDeleted = false;
 
                 int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(PermanentCondition));
@@ -190,13 +190,13 @@ namespace DCGO.CardEffects.P
 
                 IEnumerator SelectPermanentCoroutine(Permanent permanent)
                 {
-                    Permanent selectedPermanent = permanent;
-                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.TrashDigivolutionCardsFromTopOrBottom(targetPermanent: selectedPermanent, trashCount: 4, isFromTop: false, activateClass: activateClass));
+                    selectedPermanent = permanent;
+                    yield return null;
                 }
 
-                if (permanent != null)
+                if (selectedPermanent != null)
                 {
-                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: new List<Permanent>() { permanent }, activateClass: activateClass, successProcess: permanents => SuccessProcess(), failureProcess: null));
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: new List<Permanent>() { selectedPermanent }, activateClass: activateClass, successProcess: permanents => SuccessProcess(), failureProcess: null));
 
                     IEnumerator SuccessProcess()
                     {
@@ -205,7 +205,7 @@ namespace DCGO.CardEffects.P
                     }
                 }
 
-                if (permanent == null || !permanentDeleted)
+                if (!permanentDeleted)
                 {
                     if (card.Owner.CanAddSecurity(activateClass))
                     {

Assets/Scripts/AutoProcessing.cs

@@ -193,8 +193,8 @@ public class AutoProcessing : MonoBehaviourPunCallbacks
             if (!GManager.instance.attackProcess.AttackingPermanent.IsDigimon)
                 return true;
 
-            if (GManager.instance.attackProcess.DefendingPermanent == null && GManager.instance.attackProcess.HasDefender)
-                return true;
+            //if (GManager.instance.attackProcess.HasDefender && GManager.instance.attackProcess.DefendingPermanent == null)
+            //    return true;
         }
 
         return false;
@@ -206,7 +206,7 @@ public class AutoProcessing : MonoBehaviourPunCallbacks
         {
             if (permanent.TopCard != null)
             {
-                if (!permanent.LinkedCards.Any(source => source.CanLinkToTargetPermanent(permanent, false)))
+                if (permanent.LinkedCards.Any(source => !source.CanLinkToTargetPermanent(permanent, false)))
                 {
                     return true;
                 }
@@ -236,6 +236,9 @@ public class AutoProcessing : MonoBehaviourPunCallbacks
             //Battle as Tamer
             yield return ContinuousController.instance.StartCoroutine(BattleWithoutDigimon());
 
+            //Link Lacking condition
+            yield return ContinuousController.instance.StartCoroutine(DigimonLackLinkConditionProcess());
+
             IsRuleProcessing = false;
         }
     }
@@ -269,7 +272,7 @@ public class AutoProcessing : MonoBehaviourPunCallbacks
         #region Is it necessary to deal with Battle Without Digimon?
         if (IsAttackerNotADigimon())
         {
-            return true;
+            //return true;
         }
         #endregion
 
@@ -383,7 +386,7 @@ public class AutoProcessing : MonoBehaviourPunCallbacks
         {
             foreach(Permanent permanent in LackLinkConditionPermanents)
             {
-                List<CardSource> selectedCards = permanent.LinkedCards.FindAll(source => source.CanLinkToTargetPermanent(permanent, false));
+                List<CardSource> selectedCards = permanent.LinkedCards.FindAll(source => !source.CanLinkToTargetPermanent(permanent, false));
 
                 yield return ContinuousController.instance.StartCoroutine(new ITrashLinkCards(
                                permanent,

Assets/Scripts/CardController.cs

@@ -1856,7 +1856,7 @@ public class IDigiBurst
         {
             if (_permanent.TopCard != null)
             {
-                if (_permanent.ImmuneFromStackTrashing()) return false;
+                if (_permanent.ImmuneFromStackTrashing(_cardEffect)) return false;
 
                 if (_upToMaxCount)
                 {
@@ -3773,7 +3773,7 @@ public class IDegeneration
         if (_permanent == null) yield break;
         if (_permanent.TopCard == null) yield break;
         if (_permanent.ImmuneFromDeDigivolve()) yield break;
-        if (_permanent.ImmuneFromStackTrashing()) yield break;
+        if (_permanent.ImmuneFromStackTrashing(_cardEffect)) yield break;
         if (_permanent.TopCard.CanNotBeAffected(_cardEffect)) yield break;
 
         int maxCount = Math.Min(_permanent.DigivolutionCards.Count, _degenerationCount);
@@ -3926,7 +3926,7 @@ public class ITrashDigivolutionCards
         if (_cardEffect == null) yield break;
         if (_permanent == null) yield break;
         if (_permanent.TopCard == null) yield break;
-        if (_permanent.ImmuneFromStackTrashing()) yield break;
+        if (_permanent.ImmuneFromStackTrashing(_cardEffect)) yield break;
         if (_permanent.TopCard.CanNotBeAffected(_cardEffect)) yield break;
         if (_permanent.HasNoDigivolutionCards) yield break;
 
@@ -4025,15 +4025,13 @@ public class ITrashLinkCards
     public IEnumerator TrashLinkCards()
     {
         if (_trashTargetCards == null) yield break;
-        if (_cardEffect == null) yield break;
         if (_permanent == null) yield break;
         if (_permanent.TopCard == null) yield break;
-        if (_permanent.TopCard.CanNotBeAffected(_cardEffect)) yield break;
-        if (_permanent.HasNoDigivolutionCards) yield break;
+        if (_cardEffect != null && _permanent.TopCard.CanNotBeAffected(_cardEffect)) yield break;
+        if (_permanent.HasNoLinkCards) yield break;
 
         _trashTargetCards = _trashTargetCards.Filter((cardSource) =>
-            _permanent.DigivolutionCards.Contains(cardSource) &&
-            !cardSource.CanNotTrashFromDigivolutionCards(_cardEffect));
+            _permanent.LinkedCards.Contains(cardSource));
 
         if (_trashTargetCards.Count == 0) yield break;
 
@@ -4543,7 +4541,7 @@ public class ITrashStack
         if (_cardEffect.EffectSourceCard == null) yield break;
         if (_permanent == null) yield break;
         if (_permanent.TopCard == null) yield break;
-        if (_permanent.ImmuneFromStackTrashing()) yield break;
+        if (_permanent.ImmuneFromStackTrashing(_cardEffect)) yield break;
         if (_permanent.TopCard.CanNotBeAffected(_cardEffect)) yield break;
 
         _trashCount = Math.Min(_permanent.StackCards.Count, _trashCount);

Assets/Scripts/CardSource.cs

@@ -2569,28 +2569,25 @@ public class CardSource : MonoBehaviour
         {
             if (targetPermanent.TopCard != null)
             {
-                if (targetPermanent.TopCard.Owner.GetFieldPermanents().Contains(targetPermanent))
+                if (this.CanLink(PayCost))
                 {
-                    if (this.CanLink(PayCost))
+                    if (linkCondition != null)
                     {
-                        if (linkCondition != null)
+                        if (linkCondition.digimonCondition(targetPermanent))
                         {
-                            if (linkCondition.digimonCondition(targetPermanent))
+                            if (PayCost)
                             {
-                                if (PayCost)
-                                {
-                                    int cost = linkCondition.cost;
+                                int cost = linkCondition.cost;
 
-                                    cost = GetChangedCostItselef(cost, SelectCardEffect.Root.Hand, new List<Permanent>() { targetPermanent }, checkAvailability: true);
+                                cost = GetChangedCostItselef(cost, SelectCardEffect.Root.Hand, new List<Permanent>() { targetPermanent }, checkAvailability: true);
 
-                                    if (Owner.MaxMemoryCost < cost)
-                                    {
-                                        return false;
-                                    }
+                                if (Owner.MaxMemoryCost < cost)
+                                {
+                                    return false;
                                 }
-
-                                return true;
                             }
+
+                            return true;
                         }
                     }
                 }

Assets/Scripts/Permanent.cs

@@ -627,7 +627,7 @@ public class Permanent
     #endregion
 
     #region Immune From Trashing Stack
-    public bool ImmuneFromStackTrashing()
+    public bool ImmuneFromStackTrashing(ICardEffect effect)
     {
         foreach (Player player in GManager.instance.turnStateMachine.gameContext.Players)
         {
@@ -639,7 +639,7 @@ public class Permanent
                     {
                         if (cardEffect1.CanUse(null))
                         {
-                            if (((IImmuneFromStackTrashingEffect)cardEffect1).ImmuneStackTrashing(this, cardEffect1))
+                            if (((IImmuneFromStackTrashingEffect)cardEffect1).ImmuneStackTrashing(this, effect))
                             {
                                 return true;
                             }
@@ -1233,8 +1233,10 @@ public class Permanent
                                     continue;
                                 }
 
-                                if(isTopCard && !cardSource.IsLinked)
+                                if(isTopCard && !cardEffect.IsInheritedEffect && !cardSource.IsLinked)
+                                {
                                     _EffectList.Add(cardEffect);
+                                }
                             }
                         }
                     }

ProjectSettings/ProjectSettings.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4666baedd607ecd324f22e75a6a0b0b0241baa85c949dc6f6337e2a1f8522d1f
+oid sha256:9b46f518780e5f04ee8448c7cb066b9091b78b22cfdbbda5b9c56c36cb663a43
 size 20168

lfs/objects/9b/46/9b46f518780e5f04ee8448c7cb066b9091b78b22cfdbbda5b9c56c36cb663a43

@@ -0,0 +1,668 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!129 &1
+PlayerSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 23
+  productGUID: 8fbfd141f045ffc4bbe9d3347b8eb87d
+  AndroidProfiler: 0
+  AndroidFilterTouchesWhenObscured: 0
+  AndroidEnableSustainedPerformanceMode: 0
+  defaultScreenOrientation: 4
+  targetDevice: 2
+  useOnDemandResources: 0
+  accelerometerFrequency: 60
+  companyName: DCGO
+  productName: DCGO
+  defaultCursor: {fileID: 2800000, guid: b086a093dbd45b24e80e13a51af2e5f8, type: 3}
+  cursorHotspot: {x: 0, y: 0}
+  m_SplashScreenBackgroundColor: {r: 0.12156863, g: 0.12156863, b: 0.1254902, a: 1}
+  m_ShowUnitySplashScreen: 1
+  m_ShowUnitySplashLogo: 0
+  m_SplashScreenOverlayOpacity: 0
+  m_SplashScreenAnimation: 0
+  m_SplashScreenLogoStyle: 1
+  m_SplashScreenDrawMode: 0
+  m_SplashScreenBackgroundAnimationZoom: 1
+  m_SplashScreenLogoAnimationZoom: 1
+  m_SplashScreenBackgroundLandscapeAspect: 1
+  m_SplashScreenBackgroundPortraitAspect: 1
+  m_SplashScreenBackgroundLandscapeUvs:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 0.9999999
+  m_SplashScreenBackgroundPortraitUvs:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  m_SplashScreenLogos:
+  - logo: {fileID: 0}
+    duration: 8
+  m_VirtualRealitySplashScreen: {fileID: 0}
+  m_HolographicTrackingLossScreen: {fileID: 0}
+  defaultScreenWidth: 1920
+  defaultScreenHeight: 1080
+  defaultScreenWidthWeb: 960
+  defaultScreenHeightWeb: 600
+  m_StereoRenderingPath: 0
+  m_ActiveColorSpace: 0
+  m_MTRendering: 1
+  mipStripping: 0
+  numberOfMipsStripped: 0
+  m_StackTraceTypes: 010000000100000001000000010000000100000001000000
+  iosShowActivityIndicatorOnLoading: -1
+  androidShowActivityIndicatorOnLoading: -1
+  iosUseCustomAppBackgroundBehavior: 0
+  iosAllowHTTPDownload: 1
+  allowedAutorotateToPortrait: 1
+  allowedAutorotateToPortraitUpsideDown: 1
+  allowedAutorotateToLandscapeRight: 1
+  allowedAutorotateToLandscapeLeft: 1
+  useOSAutorotation: 1
+  use32BitDisplayBuffer: 1
+  preserveFramebufferAlpha: 0
+  disableDepthAndStencilBuffers: 0
+  androidStartInFullscreen: 1
+  androidRenderOutsideSafeArea: 1
+  androidUseSwappy: 1
+  androidBlitType: 0
+  androidResizableWindow: 0
+  androidDefaultWindowWidth: 1920
+  androidDefaultWindowHeight: 1080
+  androidMinimumWindowWidth: 400
+  androidMinimumWindowHeight: 300
+  androidFullscreenMode: 1
+  defaultIsNativeResolution: 1
+  macRetinaSupport: 1
+  runInBackground: 0
+  captureSingleScreen: 0
+  muteOtherAudioSources: 0
+  Prepare IOS For Recording: 0
+  Force IOS Speakers When Recording: 0
+  deferSystemGesturesMode: 0
+  hideHomeButton: 0
+  submitAnalytics: 1
+  usePlayerLog: 1
+  bakeCollisionMeshes: 0
+  forceSingleInstance: 0
+  useFlipModelSwapchain: 1
+  resizableWindow: 0
+  useMacAppStoreValidation: 0
+  macAppStoreCategory: public.app-category.games
+  gpuSkinning: 0
+  xboxPIXTextureCapture: 0
+  xboxEnableAvatar: 0
+  xboxEnableKinect: 0
+  xboxEnableKinectAutoTracking: 0
+  xboxEnableFitness: 0
+  visibleInBackground: 1
+  allowFullscreenSwitch: 1
+  fullscreenMode: 1
+  xboxSpeechDB: 0
+  xboxEnableHeadOrientation: 0
+  xboxEnableGuest: 0
+  xboxEnablePIXSampling: 0
+  metalFramebufferOnly: 0
+  xboxOneResolution: 0
+  xboxOneSResolution: 0
+  xboxOneXResolution: 3
+  xboxOneMonoLoggingLevel: 0
+  xboxOneLoggingLevel: 1
+  xboxOneDisableEsram: 0
+  xboxOneEnableTypeOptimization: 0
+  xboxOnePresentImmediateThreshold: 0
+  switchQueueCommandMemory: 1048576
+  switchQueueControlMemory: 16384
+  switchQueueComputeMemory: 262144
+  switchNVNShaderPoolsGranularity: 33554432
+  switchNVNDefaultPoolsGranularity: 16777216
+  switchNVNOtherPoolsGranularity: 16777216
+  switchNVNMaxPublicTextureIDCount: 0
+  switchNVNMaxPublicSamplerIDCount: 0
+  stadiaPresentMode: 0
+  stadiaTargetFramerate: 0
+  vulkanNumSwapchainBuffers: 3
+  vulkanEnableSetSRGBWrite: 0
+  vulkanEnablePreTransform: 0
+  vulkanEnableLateAcquireNextImage: 0
+  vulkanEnableCommandBufferRecycling: 1
+  m_SupportedAspectRatios:
+    4:3: 1
+    5:4: 1
+    16:10: 1
+    16:9: 1
+    Others: 1
+  bundleVersion: 1.8.2.7
+  preloadedAssets: []
+  metroInputSource: 0
+  wsaTransparentSwapchain: 0
+  m_HolographicPauseOnTrackingLoss: 1
+  xboxOneDisableKinectGpuReservation: 1
+  xboxOneEnable7thCore: 1
+  vrSettings:
+    enable360StereoCapture: 0
+  isWsaHolographicRemotingEnabled: 0
+  enableFrameTimingStats: 0
+  enableOpenGLProfilerGPURecorders: 1
+  useHDRDisplay: 0
+  D3DHDRBitDepth: 0
+  m_ColorGamuts: 00000000
+  targetPixelDensity: 30
+  resolutionScalingMode: 0
+  resetResolutionOnWindowResize: 0
+  androidSupportedAspectRatio: 1
+  androidMaxAspectRatio: 2.1
+  applicationIdentifier:
+    Standalone: com.DCGO.DCGO
+  buildNumber:
+    Standalone: 0
+    iPhone: 0
+    tvOS: 0
+  overrideDefaultApplicationIdentifier: 0
+  AndroidBundleVersionCode: 1
+  AndroidMinSdkVersion: 22
+  AndroidTargetSdkVersion: 0
+  AndroidPreferredInstallLocation: 1
+  aotOptions: 
+  stripEngineCode: 1
+  iPhoneStrippingLevel: 0
+  iPhoneScriptCallOptimization: 0
+  ForceInternetPermission: 0
+  ForceSDCardPermission: 0
+  CreateWallpaper: 0
+  APKExpansionFiles: 0
+  keepLoadedShadersAlive: 0
+  StripUnusedMeshComponents: 0
+  VertexChannelCompressionMask: 4054
+  iPhoneSdkVersion: 988
+  iOSTargetOSVersionString: 11.0
+  tvOSSdkVersion: 0
+  tvOSRequireExtendedGameController: 0
+  tvOSTargetOSVersionString: 11.0
+  uIPrerenderedIcon: 0
+  uIRequiresPersistentWiFi: 0
+  uIRequiresFullScreen: 1
+  uIStatusBarHidden: 1
+  uIExitOnSuspend: 0
+  uIStatusBarStyle: 0
+  appleTVSplashScreen: {fileID: 0}
+  appleTVSplashScreen2x: {fileID: 0}
+  tvOSSmallIconLayers: []
+  tvOSSmallIconLayers2x: []
+  tvOSLargeIconLayers: []
+  tvOSLargeIconLayers2x: []
+  tvOSTopShelfImageLayers: []
+  tvOSTopShelfImageLayers2x: []
+  tvOSTopShelfImageWideLayers: []
+  tvOSTopShelfImageWideLayers2x: []
+  iOSLaunchScreenType: 0
+  iOSLaunchScreenPortrait: {fileID: 0}
+  iOSLaunchScreenLandscape: {fileID: 0}
+  iOSLaunchScreenBackgroundColor:
+    serializedVersion: 2
+    rgba: 0
+  iOSLaunchScreenFillPct: 100
+  iOSLaunchScreenSize: 100
+  iOSLaunchScreenCustomXibPath: 
+  iOSLaunchScreeniPadType: 0
+  iOSLaunchScreeniPadImage: {fileID: 0}
+  iOSLaunchScreeniPadBackgroundColor:
+    serializedVersion: 2
+    rgba: 0
+  iOSLaunchScreeniPadFillPct: 100
+  iOSLaunchScreeniPadSize: 100
+  iOSLaunchScreeniPadCustomXibPath: 
+  iOSLaunchScreenCustomStoryboardPath: 
+  iOSLaunchScreeniPadCustomStoryboardPath: 
+  iOSDeviceRequirements: []
+  iOSURLSchemes: []
+  macOSURLSchemes: []
+  iOSBackgroundModes: 0
+  iOSMetalForceHardShadows: 0
+  metalEditorSupport: 1
+  metalAPIValidation: 1
+  iOSRenderExtraFrameOnPause: 0
+  iosCopyPluginsCodeInsteadOfSymlink: 0
+  appleDeveloperTeamID: 
+  iOSManualSigningProvisioningProfileID: 
+  tvOSManualSigningProvisioningProfileID: 
+  iOSManualSigningProvisioningProfileType: 0
+  tvOSManualSigningProvisioningProfileType: 0
+  appleEnableAutomaticSigning: 0
+  iOSRequireARKit: 0
+  iOSAutomaticallyDetectAndAddCapabilities: 1
+  appleEnableProMotion: 0
+  shaderPrecisionModel: 0
+  clonedFromGUID: 00000000000000000000000000000000
+  templatePackageId: 
+  templateDefaultScene: 
+  useCustomMainManifest: 0
+  useCustomLauncherManifest: 0
+  useCustomMainGradleTemplate: 0
+  useCustomLauncherGradleManifest: 0
+  useCustomBaseGradleTemplate: 0
+  useCustomGradlePropertiesTemplate: 0
+  useCustomProguardFile: 0
+  AndroidTargetArchitectures: 1
+  AndroidTargetDevices: 0
+  AndroidSplashScreenScale: 0
+  androidSplashScreen: {fileID: 0}
+  AndroidKeystoreName: 
+  AndroidKeyaliasName: 
+  AndroidBuildApkPerCpuArchitecture: 0
+  AndroidTVCompatibility: 0
+  AndroidIsGame: 1
+  AndroidEnableTango: 0
+  androidEnableBanner: 1
+  androidUseLowAccuracyLocation: 0
+  androidUseCustomKeystore: 0
+  m_AndroidBanners:
+  - width: 320
+    height: 180
+    banner: {fileID: 0}
+  androidGamepadSupportLevel: 0
+  chromeosInputEmulation: 1
+  AndroidMinifyWithR8: 0
+  AndroidMinifyRelease: 0
+  AndroidMinifyDebug: 0
+  AndroidValidateAppBundleSize: 1
+  AndroidAppBundleSizeToValidate: 150
+  m_BuildTargetIcons:
+  - m_BuildTarget: 
+    m_Icons:
+    - serializedVersion: 2
+      m_Icon: {fileID: 2800000, guid: 388af3b42075feb47ae156f0a332faa9, type: 3}
+      m_Width: 128
+      m_Height: 128
+      m_Kind: 0
+  m_BuildTargetPlatformIcons: []
+  m_BuildTargetBatching: []
+  m_BuildTargetShaderSettings: []
+  m_BuildTargetGraphicsJobs: []
+  m_BuildTargetGraphicsJobMode: []
+  m_BuildTargetGraphicsAPIs: []
+  m_BuildTargetVRSettings: []
+  m_DefaultShaderChunkSizeInMB: 16
+  m_DefaultShaderChunkCount: 0
+  openGLRequireES31: 0
+  openGLRequireES31AEP: 0
+  openGLRequireES32: 0
+  m_TemplateCustomTags: {}
+  mobileMTRendering:
+    Android: 1
+    iPhone: 1
+    tvOS: 1
+  m_BuildTargetGroupLightmapEncodingQuality: []
+  m_BuildTargetGroupLightmapSettings: []
+  m_BuildTargetNormalMapEncoding: []
+  m_BuildTargetDefaultTextureCompressionFormat: []
+  playModeTestRunnerEnabled: 0
+  runPlayModeTestAsEditModeTest: 0
+  actionOnDotNetUnhandledException: 1
+  enableInternalProfiler: 0
+  logObjCUncaughtExceptions: 1
+  enableCrashReportAPI: 0
+  cameraUsageDescription: 
+  locationUsageDescription: 
+  microphoneUsageDescription: 
+  bluetoothUsageDescription: 
+  switchNMETAOverride: 
+  switchNetLibKey: 
+  switchSocketMemoryPoolSize: 6144
+  switchSocketAllocatorPoolSize: 128
+  switchSocketConcurrencyLimit: 14
+  switchScreenResolutionBehavior: 2
+  switchUseCPUProfiler: 0
+  switchUseGOLDLinker: 0
+  switchLTOSetting: 0
+  switchApplicationID: 0x01004b9000490000
+  switchNSODependencies: 
+  switchTitleNames_0: 
+  switchTitleNames_1: 
+  switchTitleNames_2: 
+  switchTitleNames_3: 
+  switchTitleNames_4: 
+  switchTitleNames_5: 
+  switchTitleNames_6: 
+  switchTitleNames_7: 
+  switchTitleNames_8: 
+  switchTitleNames_9: 
+  switchTitleNames_10: 
+  switchTitleNames_11: 
+  switchTitleNames_12: 
+  switchTitleNames_13: 
+  switchTitleNames_14: 
+  switchTitleNames_15: 
+  switchPublisherNames_0: 
+  switchPublisherNames_1: 
+  switchPublisherNames_2: 
+  switchPublisherNames_3: 
+  switchPublisherNames_4: 
+  switchPublisherNames_5: 
+  switchPublisherNames_6: 
+  switchPublisherNames_7: 
+  switchPublisherNames_8: 
+  switchPublisherNames_9: 
+  switchPublisherNames_10: 
+  switchPublisherNames_11: 
+  switchPublisherNames_12: 
+  switchPublisherNames_13: 
+  switchPublisherNames_14: 
+  switchPublisherNames_15: 
+  switchIcons_0: {fileID: 0}
+  switchIcons_1: {fileID: 0}
+  switchIcons_2: {fileID: 0}
+  switchIcons_3: {fileID: 0}
+  switchIcons_4: {fileID: 0}
+  switchIcons_5: {fileID: 0}
+  switchIcons_6: {fileID: 0}
+  switchIcons_7: {fileID: 0}
+  switchIcons_8: {fileID: 0}
+  switchIcons_9: {fileID: 0}
+  switchIcons_10: {fileID: 0}
+  switchIcons_11: {fileID: 0}
+  switchIcons_12: {fileID: 0}
+  switchIcons_13: {fileID: 0}
+  switchIcons_14: {fileID: 0}
+  switchIcons_15: {fileID: 0}
+  switchSmallIcons_0: {fileID: 0}
+  switchSmallIcons_1: {fileID: 0}
+  switchSmallIcons_2: {fileID: 0}
+  switchSmallIcons_3: {fileID: 0}
+  switchSmallIcons_4: {fileID: 0}
+  switchSmallIcons_5: {fileID: 0}
+  switchSmallIcons_6: {fileID: 0}
+  switchSmallIcons_7: {fileID: 0}
+  switchSmallIcons_8: {fileID: 0}
+  switchSmallIcons_9: {fileID: 0}
+  switchSmallIcons_10: {fileID: 0}
+  switchSmallIcons_11: {fileID: 0}
+  switchSmallIcons_12: {fileID: 0}
+  switchSmallIcons_13: {fileID: 0}
+  switchSmallIcons_14: {fileID: 0}
+  switchSmallIcons_15: {fileID: 0}
+  switchManualHTML: 
+  switchAccessibleURLs: 
+  switchLegalInformation: 
+  switchMainThreadStackSize: 1048576
+  switchPresenceGroupId: 
+  switchLogoHandling: 0
+  switchReleaseVersion: 0
+  switchDisplayVersion: 1.0.0
+  switchStartupUserAccount: 0
+  switchTouchScreenUsage: 0
+  switchSupportedLanguagesMask: 0
+  switchLogoType: 0
+  switchApplicationErrorCodeCategory: 
+  switchUserAccountSaveDataSize: 0
+  switchUserAccountSaveDataJournalSize: 0
+  switchApplicationAttribute: 0
+  switchCardSpecSize: -1
+  switchCardSpecClock: -1
+  switchRatingsMask: 0
+  switchRatingsInt_0: 0
+  switchRatingsInt_1: 0
+  switchRatingsInt_2: 0
+  switchRatingsInt_3: 0
+  switchRatingsInt_4: 0
+  switchRatingsInt_5: 0
+  switchRatingsInt_6: 0
+  switchRatingsInt_7: 0
+  switchRatingsInt_8: 0
+  switchRatingsInt_9: 0
+  switchRatingsInt_10: 0
+  switchRatingsInt_11: 0
+  switchRatingsInt_12: 0
+  switchLocalCommunicationIds_0: 
+  switchLocalCommunicationIds_1: 
+  switchLocalCommunicationIds_2: 
+  switchLocalCommunicationIds_3: 
+  switchLocalCommunicationIds_4: 
+  switchLocalCommunicationIds_5: 
+  switchLocalCommunicationIds_6: 
+  switchLocalCommunicationIds_7: 
+  switchParentalControl: 0
+  switchAllowsScreenshot: 1
+  switchAllowsVideoCapturing: 1
+  switchAllowsRuntimeAddOnContentInstall: 0
+  switchDataLossConfirmation: 0
+  switchUserAccountLockEnabled: 0
+  switchSystemResourceMemory: 16777216
+  switchSupportedNpadStyles: 22
+  switchNativeFsCacheSize: 32
+  switchIsHoldTypeHorizontal: 0
+  switchSupportedNpadCount: 8
+  switchSocketConfigEnabled: 0
+  switchTcpInitialSendBufferSize: 32
+  switchTcpInitialReceiveBufferSize: 64
+  switchTcpAutoSendBufferSizeMax: 256
+  switchTcpAutoReceiveBufferSizeMax: 256
+  switchUdpSendBufferSize: 9
+  switchUdpReceiveBufferSize: 42
+  switchSocketBufferEfficiency: 4
+  switchSocketInitializeEnabled: 1
+  switchNetworkInterfaceManagerInitializeEnabled: 1
+  switchPlayerConnectionEnabled: 1
+  switchUseNewStyleFilepaths: 0
+  switchUseLegacyFmodPriorities: 1
+  switchUseMicroSleepForYield: 1
+  switchEnableRamDiskSupport: 0
+  switchMicroSleepForYieldTime: 25
+  switchRamDiskSpaceSize: 12
+  ps4NPAgeRating: 12
+  ps4NPTitleSecret: 
+  ps4NPTrophyPackPath: 
+  ps4ParentalLevel: 11
+  ps4ContentID: ED1633-NPXX51362_00-0000000000000000
+  ps4Category: 0
+  ps4MasterVersion: 01.00
+  ps4AppVersion: 01.00
+  ps4AppType: 0
+  ps4ParamSfxPath: 
+  ps4VideoOutPixelFormat: 0
+  ps4VideoOutInitialWidth: 1920
+  ps4VideoOutBaseModeInitialWidth: 1920
+  ps4VideoOutReprojectionRate: 60
+  ps4PronunciationXMLPath: 
+  ps4PronunciationSIGPath: 
+  ps4BackgroundImagePath: 
+  ps4StartupImagePath: 
+  ps4StartupImagesFolder: 
+  ps4IconImagesFolder: 
+  ps4SaveDataImagePath: 
+  ps4SdkOverride: 
+  ps4BGMPath: 
+  ps4ShareFilePath: 
+  ps4ShareOverlayImagePath: 
+  ps4PrivacyGuardImagePath: 
+  ps4ExtraSceSysFile: 
+  ps4NPtitleDatPath: 
+  ps4RemotePlayKeyAssignment: -1
+  ps4RemotePlayKeyMappingDir: 
+  ps4PlayTogetherPlayerCount: 0
+  ps4EnterButtonAssignment: 2
+  ps4ApplicationParam1: 0
+  ps4ApplicationParam2: 0
+  ps4ApplicationParam3: 0
+  ps4ApplicationParam4: 0
+  ps4DownloadDataSize: 0
+  ps4GarlicHeapSize: 2048
+  ps4ProGarlicHeapSize: 2560
+  playerPrefsMaxSize: 32768
+  ps4Passcode: frAQBc8Wsa1xVPfvJcrgRYwTiizs2trQ
+  ps4pnSessions: 1
+  ps4pnPresence: 1
+  ps4pnFriends: 1
+  ps4pnGameCustomData: 1
+  playerPrefsSupport: 0
+  enableApplicationExit: 0
+  resetTempFolder: 1
+  restrictedAudioUsageRights: 0
+  ps4UseResolutionFallback: 0
+  ps4ReprojectionSupport: 0
+  ps4UseAudio3dBackend: 0
+  ps4UseLowGarlicFragmentationMode: 1
+  ps4SocialScreenEnabled: 0
+  ps4ScriptOptimizationLevel: 2
+  ps4Audio3dVirtualSpeakerCount: 14
+  ps4attribCpuUsage: 0
+  ps4PatchPkgPath: 
+  ps4PatchLatestPkgPath: 
+  ps4PatchChangeinfoPath: 
+  ps4PatchDayOne: 0
+  ps4attribUserManagement: 0
+  ps4attribMoveSupport: 0
+  ps4attrib3DSupport: 0
+  ps4attribShareSupport: 0
+  ps4attribExclusiveVR: 0
+  ps4disableAutoHideSplash: 0
+  ps4videoRecordingFeaturesUsed: 0
+  ps4contentSearchFeaturesUsed: 0
+  ps4CompatibilityPS5: 0
+  ps4AllowPS5Detection: 0
+  ps4GPU800MHz: 1
+  ps4attribEyeToEyeDistanceSettingVR: 0
+  ps4IncludedModules: []
+  ps4attribVROutputEnabled: 0
+  monoEnv: 
+  splashScreenBackgroundSourceLandscape: {fileID: 21300000, guid: 516ed7e95df0bfc478e34188a82d224c, type: 3}
+  splashScreenBackgroundSourcePortrait: {fileID: 0}
+  blurSplashScreenBackground: 0
+  spritePackerPolicy: 
+  webGLMemorySize: 32
+  webGLExceptionSupport: 1
+  webGLNameFilesAsHashes: 0
+  webGLDataCaching: 1
+  webGLDebugSymbols: 0
+  webGLEmscriptenArgs: 
+  webGLModulesDirectory: 
+  webGLTemplate: APPLICATION:Default
+  webGLAnalyzeBuildSize: 0
+  webGLUseEmbeddedResources: 0
+  webGLCompressionFormat: 0
+  webGLWasmArithmeticExceptions: 0
+  webGLLinkerTarget: 1
+  webGLThreadsSupport: 0
+  webGLDecompressionFallback: 0
+  webGLPowerPreference: 2
+  scriptingDefineSymbols:
+    Android: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+    EmbeddedLinux: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+    GameCoreScarlett: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+    GameCoreXboxOne: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+    LinuxHeadlessSimulation: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+    Lumin: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+    Nintendo Switch: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+    PS4: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+    PS5: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+    Stadia: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+    Standalone: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+    WebGL: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+    Windows Store Apps: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+    XboxOne: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+    iPhone: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+    tvOS: PHOTON_UNITY_NETWORKING;PUN_2_0_OR_NEWER;PUN_2_OR_NEWER;PUN_2_19_OR_NEWER
+  additionalCompilerArguments: {}
+  platformArchitecture: {}
+  scriptingBackend:
+    Standalone: 1
+  il2cppCompilerConfiguration: {}
+  managedStrippingLevel: {}
+  incrementalIl2cppBuild: {}
+  suppressCommonWarnings: 1
+  allowUnsafeCode: 0
+  useDeterministicCompilation: 1
+  enableRoslynAnalyzers: 1
+  selectedPlatform: 0
+  additionalIl2CppArgs: 
+  scriptingRuntimeVersion: 1
+  gcIncremental: 1
+  assemblyVersionValidation: 1
+  gcWBarrierValidation: 0
+  apiCompatibilityLevelPerPlatform: {}
+  m_RenderingPath: 1
+  m_MobileRenderingPath: 1
+  metroPackageName: DCGO
+  metroPackageVersion: 
+  metroCertificatePath: 
+  metroCertificatePassword: 
+  metroCertificateSubject: 
+  metroCertificateIssuer: 
+  metroCertificateNotAfter: 0000000000000000
+  metroApplicationDescription: DCGO
+  wsaImages: {}
+  metroTileShortName: 
+  metroTileShowName: 0
+  metroMediumTileShowName: 0
+  metroLargeTileShowName: 0
+  metroWideTileShowName: 0
+  metroSupportStreamingInstall: 0
+  metroLastRequiredScene: 0
+  metroDefaultTileSize: 1
+  metroTileForegroundText: 2
+  metroTileBackgroundColor: {r: 0.13333334, g: 0.17254902, b: 0.21568628, a: 0}
+  metroSplashScreenBackgroundColor: {r: 0.12941177, g: 0.17254902, b: 0.21568628, a: 1}
+  metroSplashScreenUseBackgroundColor: 0
+  platformCapabilities: {}
+  metroTargetDeviceFamilies: {}
+  metroFTAName: 
+  metroFTAFileTypes: []
+  metroProtocolName: 
+  vcxProjDefaultLanguage: 
+  XboxOneProductId: 
+  XboxOneUpdateKey: 
+  XboxOneSandboxId: 
+  XboxOneContentId: 
+  XboxOneTitleId: 
+  XboxOneSCId: 
+  XboxOneGameOsOverridePath: 
+  XboxOnePackagingOverridePath: 
+  XboxOneAppManifestOverridePath: 
+  XboxOneVersion: 1.0.0.0
+  XboxOnePackageEncryption: 0
+  XboxOnePackageUpdateGranularity: 2
+  XboxOneDescription: 
+  XboxOneLanguage:
+  - enus
+  XboxOneCapability: []
+  XboxOneGameRating: {}
+  XboxOneIsContentPackage: 0
+  XboxOneEnhancedXboxCompatibilityMode: 0
+  XboxOneEnableGPUVariability: 1
+  XboxOneSockets: {}
+  XboxOneSplashScreen: {fileID: 0}
+  XboxOneAllowedProductIds: []
+  XboxOnePersistentLocalStorageSize: 0
+  XboxOneXTitleMemory: 8
+  XboxOneOverrideIdentityName: 
+  XboxOneOverrideIdentityPublisher: 
+  vrEditorSettings: {}
+  cloudServicesEnabled: {}
+  luminIcon:
+    m_Name: 
+    m_ModelFolderPath: 
+    m_PortalFolderPath: 
+  luminCert:
+    m_CertPath: 
+    m_SignPackage: 1
+  luminIsChannelApp: 0
+  luminVersion:
+    m_VersionCode: 1
+    m_VersionName: 
+  apiCompatibilityLevel: 6
+  activeInputHandler: 0
+  windowsGamepadBackendHint: 0
+  cloudProjectId: 
+  framebufferDepthMemorylessMode: 0
+  qualitySettingsNames: []
+  projectName: 
+  organizationId: 
+  cloudEnabled: 0
+  legacyClampBlendShapeWeights: 0
+  playerDataPath: 
+  forceSRGBBlit: 1
+  virtualTexturingSupportEnabled: 0