fixes for 1.9.0.6

Assets/CardBaseEntity/P/Blue/Digimon/P_190.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:370419d77a297e909df1f2819bf53015cb713b4aa6b566b681553f6479d82222
-size 1249
+oid sha256:2f8da3e758225b889427d7fd51c86797c9aa1956cdd382ef1fc56c27eae03dd5
+size 1238

Assets/CardBaseEntity/P/Blue/Digimon/P_190_P1.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7586257a709cf95ca48afa56a2ab7cd2e8b51c34a6195d10c9e561801d45f144
-size 1255
+oid sha256:88a47707a9bead317d6103b2c7c88c165835bb337330174320b1330ef5a29ddc
+size 1244

Assets/CardEffect/BT16/White/BT16_090.cs

@@ -54,7 +54,7 @@ namespace DCGO.CardEffects.BT16
                     {
                         if (permanent.IsDigimon)
                         {
-                            return true;
+                            return !permanent.ImmuneFromStackTrashing(activateClass);
                         }
                     }
 

Assets/CardEffect/BT20/Black/BT20_058.cs

@@ -14,7 +14,7 @@ namespace DCGO.CardEffects.BT20
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Delete 1 Digimon", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
@@ -68,7 +68,7 @@ namespace DCGO.CardEffects.BT20
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Delete 1 Digimon", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 

Assets/CardEffect/BT20/Yellow/BT20_035.cs

@@ -125,7 +125,7 @@ namespace DCGO.CardEffects.BT20
             if (timing == EffectTiming.OnAddDigivolutionCards)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Activate [When Digiolving] effect, Then may attack", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 

Assets/CardEffect/EX9/Black/EX9_053.cs

@@ -196,7 +196,7 @@ namespace DCGO.CardEffects.EX9
             if (timing == EffectTiming.OnAllyAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("", CanUseCondition, card);
+                activateClass.SetUpICardEffect("De-Digivolve 1", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
                 activateClass.SetHashString("WA_EX9-053");
                 activateClass.SetIsInheritedEffect(true);

Assets/CardEffect/EX9/Black/EX9_054.cs

@@ -134,7 +134,7 @@ namespace DCGO.CardEffects.EX9
             if (timing == EffectTiming.OnDestroyedAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Play 1 Digimon", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
                 cardEffects.Add(activateClass);
 

Assets/CardEffect/EX9/Black/EX9_055.cs

@@ -483,7 +483,7 @@ namespace DCGO.CardEffects.EX9
                         bool CanSelectOpponentsDigimon(Permanent permanent)
                         {
                             return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) &&
-                                   permanent.TopCard.HasLevel && permanent.TopCard.Level <= selectedCards[0].Level;
+                                   permanent.TopCard.HasLevel && permanent.TopCard.Level == selectedCards[0].Level;
                         }
 
                         if (CardEffectCommons.HasMatchConditionPermanent(CanSelectOpponentsDigimon))

Assets/CardEffect/EX9/Black/EX9_056.cs

@@ -100,11 +100,13 @@ namespace DCGO.CardEffects.EX9
 
                     if (selectedPermanent != null)
                     {
+                        Player cardOwner = selectedPermanent.TopCard.Owner;
+
                         yield return ContinuousController.instance.StartCoroutine(new IPutSecurityPermanent(
                         selectedPermanent,
                         CardEffectCommons.CardEffectHashtable(activateClass), toTop: false).PutSecurity());
 
-                        if (selectedPermanent.TopCard.Owner.SecurityCards.Contains(selectedPermanent.TopCard))
+                        if (cardOwner.SecurityCards.Contains(selectedPermanent.TopCard))
                         {
                             yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
                                 player: card.Owner.Enemy,
@@ -180,11 +182,13 @@ namespace DCGO.CardEffects.EX9
 
                     if (selectedPermanent != null)
                     {
+                        Player cardOwner = selectedPermanent.TopCard.Owner;
+
                         yield return ContinuousController.instance.StartCoroutine(new IPutSecurityPermanent(
                         selectedPermanent,
                         CardEffectCommons.CardEffectHashtable(activateClass), toTop: false).PutSecurity());
 
-                        if (selectedPermanent.TopCard.Owner.SecurityCards.Contains(selectedPermanent.TopCard))
+                        if (cardOwner.SecurityCards.Contains(selectedPermanent.TopCard))
                         {
                             yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
                                 player: card.Owner.Enemy,

Assets/CardEffect/EX9/Black/EX9_057.cs

@@ -128,14 +128,32 @@ namespace DCGO.CardEffects.EX9
 
                     if (negamonCards.Count >= 4)
                     {
-                        yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddLibraryBottomCards(negamonCards));
+                        List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                        {
+                            new SelectionElement<bool>(message: $"Yes", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"No", value : false, spriteIndex: 1),
+                        };
 
-                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect(negamonCards, "Digi-Egg deck Bottom Cards", true, true));
-                    }
+                        string selectPlayerMessage = "Will you return 4 [Negamon] back to Digi-Egg deck?";
+                        string notSelectPlayerMessage = "The opponent is choosing whether or not to return 4 [Negamon].";
 
-                    if (card.Owner.CanMove)
-                    {
-                        yield return ContinuousController.instance.StartCoroutine(CardObjectController.MovePermanent(card.Owner.GetBreedingAreaPermanents()[0].PermanentFrame));
+                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                        bool willReturn = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+                        if (willReturn)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddLibraryBottomCards(negamonCards));
+
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect(negamonCards, "Digi-Egg deck Bottom Cards", true, true));
+
+                            if (card.Owner.CanMove)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(CardObjectController.MovePermanent(card.Owner.GetBreedingAreaPermanents()[0].PermanentFrame));
+                            }
+                        }
                     }
                 }
             }

Assets/CardEffect/EX9/Purple/EX9_059.cs

@@ -147,7 +147,6 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    UnityEngine.Debug.Log($"CAN USE: {CardEffectCommons.CanTriggerOnAttack(hashtable, card)}");
                     return CardEffectCommons.CanTriggerOnAttack(hashtable, card);
                 }
 

Assets/CardEffect/EX9/Purple/EX9_062.cs

@@ -30,7 +30,26 @@ namespace DCGO.CardEffects.EX9
 
             if (timing == EffectTiming.None)
             {
-                // To be implemented
+                ChangeCardLevelForAssemblyClass changeCardLevelForAssemblyClass = new ChangeCardLevelForAssemblyClass();
+                changeCardLevelForAssemblyClass.SetUpICardEffect("This card is also treated as level 4 for [Kimeramon]'s assembly.", CanUseCondition, card);
+                changeCardLevelForAssemblyClass.SetUpChangeCardLevelForAssemblyClass(changeCardLevel: changeCardLevel);
+
+                cardEffects.Add(changeCardLevelForAssemblyClass);
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return true;
+                }
+
+                List<int> changeCardLevel(CardSource cardSource, List<int> Level)
+                {
+                    if (cardSource == card)
+                    {
+                        Level.Add(4);
+                    }
+
+                    return Level;
+                }
             }
 
             #endregion

Assets/CardEffect/EX9/Purple/EX9_063.cs

@@ -219,43 +219,60 @@ namespace DCGO.CardEffects.EX9
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.TrashDigivolutionCardsFromTopOrBottom(targetPermanent: card.PermanentOfThisCard(), trashCount: 1, isFromTop: false, activateClass: activateClass));
-
-                    if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
+                    bool CanSelectBottomCardCondition(CardSource cardSource)
                     {
-                        CardSource selectedCard = null;
-                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOwnersCardCountInTrash(card, CanSelectCardCondition));
-                        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+                        return cardSource.IsFlipped;
+                    }
 
-                        selectCardEffect.SetUp(
-                                    canTargetCondition: CanSelectCardCondition,
-                                    canTargetCondition_ByPreSelecetedList: null,
-                                    canEndSelectCondition: null,
-                                    canNoSelect: () => true,
-                                    selectCardCoroutine: SelectCardCoroutine,
-                                    afterSelectCardCoroutine: null,
-                                    message: "Select 1 [DM] digimon to play",
-                                    maxCount: maxCount,
-                                    canEndNotMax: true,
-                                    isShowOpponent: true,
-                                    mode: SelectCardEffect.Mode.Custom,
-                                    root: SelectCardEffect.Root.Trash,
-                                    customRootCardList: null,
-                                    canLookReverseCard: true,
-                                    selectPlayer: card.Owner,
-                                    cardEffect: activateClass);
+                    int cardEvoSources = card.PermanentOfThisCard().DigivolutionCards.Count;
 
-                        selectCardEffect.SetUpCustomMessage("Select 1 [DM] digimon to play", "The opponent is selecting 1 digimon to play.");
-                        yield return StartCoroutine(selectCardEffect.Activate());
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.TrashDigivolutionCardsFromTopOrBottom(
+                        targetPermanent: card.PermanentOfThisCard(),
+                        trashCount: 1,
+                        isFromTop: false,
+                        activateClass: activateClass,
+                        cardCondition: CanSelectBottomCardCondition
+                    ));
 
-                        IEnumerator SelectCardCoroutine(CardSource cardSource)
+                    if (card.PermanentOfThisCard().DigivolutionCards.Count < cardEvoSources)
+                    {
+                        if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                         {
-                            selectedCard = cardSource;
-                            yield return null;
-                        }
+                            CardSource selectedCard = null;
+                            int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOwnersCardCountInTrash(card, CanSelectCardCondition));
+                            SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                            selectCardEffect.SetUp(
+                                        canTargetCondition: CanSelectCardCondition,
+                                        canTargetCondition_ByPreSelecetedList: null,
+                                        canEndSelectCondition: null,
+                                        canNoSelect: () => true,
+                                        selectCardCoroutine: SelectCardCoroutine,
+                                        afterSelectCardCoroutine: null,
+                                        message: "Select 1 [DM] digimon to play",
+                                        maxCount: maxCount,
+                                        canEndNotMax: true,
+                                        isShowOpponent: true,
+                                        mode: SelectCardEffect.Mode.Custom,
+                                        root: SelectCardEffect.Root.Trash,
+                                        customRootCardList: null,
+                                        canLookReverseCard: true,
+                                        selectPlayer: card.Owner,
+                                        cardEffect: activateClass);
+
+                            selectCardEffect.SetUpCustomMessage("Select 1 [DM] digimon to play", "The opponent is selecting 1 digimon to play.");
+                            yield return StartCoroutine(selectCardEffect.Activate());
+
+                            IEnumerator SelectCardCoroutine(CardSource cardSource)
+                            {
+                                selectedCard = cardSource;
+                                yield return null;
+                            }
 
-                        if (selectedCard != null) yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: new List<CardSource> { selectedCard }, activateClass: activateClass, payCost: false, isTapped: false, root: SelectCardEffect.Root.Trash, activateETB: true));
+                            if (selectedCard != null) yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: new List<CardSource> { selectedCard }, activateClass: activateClass, payCost: false, isTapped: false, root: SelectCardEffect.Root.Trash, activateETB: true));
+                        }
                     }
+                    
                 }
             }
 

Assets/CardEffect/EX9/Purple/EX9_064.cs

@@ -184,7 +184,7 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    var playCost = 2 + card.PermanentOfThisCard().DigivolutionCards.Filter(x => x.IsFlipped).Count;
+                    var playCost = 4 + card.PermanentOfThisCard().DigivolutionCards.Filter(x => x.IsFlipped).Count;
                     return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) && permanent.TopCard.BasePlayCostFromEntity <= playCost;
                 }
 
@@ -288,7 +288,7 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    var playCost = 2 + card.PermanentOfThisCard().DigivolutionCards.Filter(x => x.IsFlipped).Count;
+                    var playCost = 4 + card.PermanentOfThisCard().DigivolutionCards.Filter(x => x.IsFlipped).Count;
                     return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) && permanent.TopCard.BasePlayCostFromEntity <= playCost;
                 }
 

Assets/CardEffect/EX9/Purple/EX9_065.cs

@@ -43,7 +43,7 @@ namespace DCGO.CardEffects.EX9
 
             #endregion
 
-            #region Give Ver.4 Digimon Blocker
+            #region Give Ver.4 Digimon Blocker/Retaliation
 
             if (timing == EffectTiming.None)
             {
@@ -54,7 +54,8 @@ namespace DCGO.CardEffects.EX9
 
                 bool PermanentCondition(Permanent permanent)
                 {
-                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card) && permanent.TopCard.EqualsTraits("Ver.4");
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card) && 
+                           permanent.TopCard.EqualsTraits("Ver.4");
                 }
 
                 cardEffects.Add(CardEffectFactory.BlockerStaticEffect(
@@ -62,35 +63,22 @@ namespace DCGO.CardEffects.EX9
                     isInheritedEffect: false,
                     card: card,
                     condition: CanUseCondition));
-            }
-
-            #endregion
 
-            #region Give Ver.4 Digimon Retaliation
-
-            if (timing == EffectTiming.None)
-            {
                 AddSkillClass addSkillClass = new AddSkillClass();
-                addSkillClass.SetUpICardEffect("Your Digimon gain <Retaliation>", CanUseCondition, card);
+                addSkillClass.SetUpICardEffect("Your Digimon gain <Retaliation>", CanUseRetaliationCondition, card);
                 addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
                 cardEffects.Add(addSkillClass);
 
-                bool CanUseCondition(Hashtable hashtable)
+                bool CanUseRetaliationCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
-                }
-
-                bool PermanentCondition(Permanent permanent)
-                {
-                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card) && 
-                           permanent.TopCard.EqualsTraits("Ver.4");
+                    return CanUseCondition();
                 }
 
                 bool CardSourceCondition(CardSource cardSource)
                 {
                     if (CardEffectCommons.IsExistOnBattleAreaDigimon(cardSource))
                     {
-                        if (cardSource.Owner == card.Owner)
+                        if (cardSource == cardSource.PermanentOfThisCard().TopCard)
                         {
                             if (PermanentCondition(cardSource.PermanentOfThisCard()))
                             {
@@ -106,12 +94,13 @@ namespace DCGO.CardEffects.EX9
                 {
                     if (_timing == EffectTiming.OnDestroyedAnyone)
                     {
-                        cardEffects.Add(CardEffectFactory.RetaliationSelfEffect(isInheritedEffect: false, card: card, condition: null));
+                        cardEffects.Add(CardEffectFactory.RetaliationSelfEffect(isInheritedEffect: false, card: cardSource, condition: null));
                     }
 
                     return cardEffects;
                 }
             }
+
             #endregion
 
             #region On Play

Assets/CardEffect/EX9/Red/EX9_066.cs

@@ -72,7 +72,9 @@ namespace DCGO.CardEffects.EX9
 
                         IEnumerator SelectCardCoroutine(CardSource source)
                         {
-                            if(source != null)
+                            cardAdded = false;
+
+                            if (source != null)
                                 cardAdded = true;
 
                             yield return null;

Assets/CardEffect/EX9/White/EX9_072.cs

@@ -49,19 +49,12 @@ namespace DCGO.CardEffects.EX9
                            permanent.TopCard.EqualsTraits("DM") && permanent.DigivolutionCards.Exists(x => x.IsFlipped);
                 }
 
-                int changeDP(Permanent permanent) => permanent.DigivolutionCards.Filter(x => x.IsFlipped).Count * 1000;
-
-                foreach (Permanent permanent in card.Owner.GetBattleAreaPermanents())
+                foreach (Permanent permanent in card.Owner.GetBattleAreaPermanents().Filter(PermanentCondition))
                 {
-                    cardEffects.Add(CardEffectFactory.ChangeDPStaticEffect(
-                        permanentCondition: PermanentCondition,
-                        changeValue: changeDP(permanent),
-                        isInheritedEffect: false,
-                        card: card,
-                        condition: CanUseCondition,
-                        effectName: () => "Change DP",
-                        isLinkedEffect: false
-                    ));
+                    int dpValue = permanent.DigivolutionCards.Filter(x => x.IsFlipped).Count * 1000;
+
+                    Permanent.DPBoost dpBoost = new Permanent.DPBoost("EX9_072", dpValue, CanUseCondition);
+                    permanent.AddBoost(dpBoost);
                 }
             }
 

Assets/CardEffect/EX9/White/EX9_074.cs

@@ -40,7 +40,7 @@ namespace DCGO.CardEffects.EX9
                                 {
                                     if (cardSource.IsDigimon)
                                     {
-                                        if (cardSource.IsLevel4)
+                                        if (cardSource.IsLevel4 || cardSource.Level_Assembly.Contains(4))
                                         {
                                             if (cardSource.HasDMTraits)
                                             {

Assets/CardEffect/EX9/Yellow/EX9_024.cs

@@ -146,7 +146,7 @@ namespace DCGO.CardEffects.EX9
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Delete 1 other of your digimon, to end a attack", CanUseCondition, card);
-                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
                 activateClass.SetHashString("EX9_024_EndAttack");
                 activateClass.SetIsInheritedEffect(true);
                 cardEffects.Add(activateClass);

Assets/CardEffect/EX9/Yellow/EX9_031.cs

@@ -202,7 +202,7 @@ namespace DCGO.CardEffects.EX9
             {
                 bool CanSelectCardCondition(CardSource cardSource)
                 {
-                    return card.IsFlipped;
+                    return cardSource.IsFlipped;
                 }
 
                 int cardEvoSources = card.PermanentOfThisCard().DigivolutionCards.Count;

Assets/CardEffect/EX9/Yellow/EX9_033.cs

@@ -57,7 +57,7 @@ namespace DCGO.CardEffects.EX9
 
             if (timing == EffectTiming.None)
             {
-                bool CanUseCondition()
+                bool CanUseAllTurnsCondition()
                 {
                     return CardEffectCommons.IsExistOnBattleArea(card);
                 }
@@ -66,11 +66,8 @@ namespace DCGO.CardEffects.EX9
                     permanentCondition: SharedPermanentCondition,
                     isInheritedEffect: false,
                     card: card,
-                    condition: CanUseCondition));
-            }
+                    condition: CanUseAllTurnsCondition));
 
-            if (timing == EffectTiming.None)
-            {
                 AddSkillClass addSkillClass = new AddSkillClass();
                 addSkillClass.SetUpICardEffect("Your Digimons gain Alliance", CanUseCondition, card);
                 addSkillClass.SetUpAddSkillClass(cardSourceCondition: CardSourceCondition, getEffects: GetEffects);
@@ -78,22 +75,20 @@ namespace DCGO.CardEffects.EX9
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleArea(card);
+                    return CanUseAllTurnsCondition();
                 }
 
                 bool CardSourceCondition(CardSource cardSource)
                 {
                     if (CardEffectCommons.IsExistOnBattleAreaDigimon(cardSource))
                     {
-                        if (card.Owner == cardSource.Owner)
+                        if (cardSource == cardSource.PermanentOfThisCard().TopCard)
                         {
-                            if (cardSource.PermanentOfThisCard().IsToken || cardSource.EqualsTraits("Puppet"))
+                            if (SharedPermanentCondition(cardSource.PermanentOfThisCard()))
                             {
                                 return true;
                             }
                         }
-
-                        return false;
                     }
 
                     return false;

Assets/CardEffect/P/Green/P_185.cs

@@ -172,7 +172,7 @@ namespace DCGO.CardEffects.P
             if (timing == EffectTiming.OnEndTurn)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Unsuspend", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
                 activateClass.SetHashString("Unsuspend_P_185");
                 cardEffects.Add(activateClass);

Assets/CardEffect/P/Purple/P_193.cs

@@ -110,126 +110,136 @@ namespace DCGO.CardEffects.P
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, CanSelectPermanentCondition))
-                    {
-                        bool destroyed = false;
-                        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: null,
-                            afterSelectPermanentCoroutine: AfterSelectPermanentCoroutine,
-                            mode: SelectPermanentEffect.Mode.Destroy,
-                            cardEffect: activateClass);
-
-                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to delete.",
-                            "The opponent is selecting 1 Digimon to delete.");
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: new List<Permanent>() { card.PermanentOfThisCard() }, activateClass: activateClass, successProcess: permanents => SuccessProcess(), failureProcess: null));
 
-                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                        IEnumerator AfterSelectPermanentCoroutine(List<Permanent> selectedPermanents)
+                    IEnumerator SuccessProcess()
+                    {
+                        if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, CanSelectPermanentCondition))
                         {
-                            if (selectedPermanents.Count > 0) destroyed = true;
-                            yield return null;
+                            bool destroyed = false;
+                            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: null,
+                                afterSelectPermanentCoroutine: AfterSelectPermanentCoroutine,
+                                mode: SelectPermanentEffect.Mode.Custom,
+                                cardEffect: activateClass);
+
+                            selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to delete.",
+                                "The opponent is selecting 1 Digimon to delete.");
+
+                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                            IEnumerator AfterSelectPermanentCoroutine(List<Permanent> selectedPermanents)
+                            {
+                                if (selectedPermanents.Count > 0) destroyed = true;
+                                yield return null;
+                            }
+
+                            if (destroyed)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(targetPermanents: new List<Permanent>() { card.PermanentOfThisCard() }, activateClass: activateClass, successProcess: permanents => DeleteSuccessProcess(), failureProcess: null));
+                            }
                         }
+                    }
 
-                        if (destroyed)
-                        {
-                            bool canSelectHand = CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition);
-                            bool canSelectTrash = CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition);
+                    IEnumerator DeleteSuccessProcess()
+                    {
+                        bool canSelectHand = CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition);
+                        bool canSelectTrash = CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition);
 
-                            if (canSelectHand || canSelectTrash)
+                        if (canSelectHand || canSelectTrash)
+                        {
+                            if (canSelectHand && canSelectTrash)
                             {
-                                if (canSelectHand && canSelectTrash)
-                                {
-                                    List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                                List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                                         {
                                             new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
                                             new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
                                         };
 
-                                    string selectPlayerMessage = "From which area do you select a card?";
-                                    string notSelectPlayerMessage = "The opponent is choosing from which area to select a card.";
-
-                                    GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
-                                }
-                                else
-                                {
-                                    GManager.instance.userSelectionManager.SetBool(canSelectHand);
-                                }
-
-                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
-                                bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
-
-                                List<CardSource> selectedCards = new List<CardSource>();
-
-                                IEnumerator SelectCardCoroutine(CardSource cardSource)
-                                {
-                                    selectedCards.Add(cardSource);
-
-                                    yield return null;
-                                }
-
-                                SelectCardEffect.Root root = SelectCardEffect.Root.Hand;
-                                if (fromHand)
-                                {
-                                    SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
-
-                                    selectHandEffect.SetUp(
-                                        selectPlayer: card.Owner,
-                                        canTargetCondition: CanSelectCardCondition,
-                                        canTargetCondition_ByPreSelecetedList: null,
-                                        canEndSelectCondition: null,
-                                        maxCount: 1,
-                                        canNoSelect: true,
-                                        canEndNotMax: false,
-                                        isShowOpponent: true,
-                                        selectCardCoroutine: SelectCardCoroutine,
-                                        afterSelectCardCoroutine: null,
-                                        mode: SelectHandEffect.Mode.Custom,
-                                        cardEffect: activateClass);
-
-                                    selectHandEffect.SetUpCustomMessage("Select 1 digimon to play", "The opponent is selecting 1 digimon to play");
-
-                                    yield return StartCoroutine(selectHandEffect.Activate());
-                                }
-                                else
-                                {
-                                    root = SelectCardEffect.Root.Trash;
-                                    SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
-
-                                    selectCardEffect.SetUp(
-                                        canTargetCondition: CanSelectCardCondition,
-                                        canTargetCondition_ByPreSelecetedList: null,
-                                        canEndSelectCondition: null,
-                                        canNoSelect: () => true,
-                                        selectCardCoroutine: SelectCardCoroutine,
-                                        afterSelectCardCoroutine: null,
-                                        message: "Select 1 digimon to play",
-                                        maxCount: 1,
-                                        canEndNotMax: false,
-                                        isShowOpponent: true,
-                                        mode: SelectCardEffect.Mode.Custom,
-                                        root: SelectCardEffect.Root.Trash,
-                                        customRootCardList: null,
-                                        canLookReverseCard: true,
-                                        selectPlayer: card.Owner,
-                                        cardEffect: activateClass);
-
-                                    selectCardEffect.SetUpCustomMessage("Select 1 1 digimon to play", "The opponent is selecting 1 digimon to play");
-
-                                    yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
-                                }
-
-                                if (selectedCards.Count > 0) yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: selectedCards, activateClass: activateClass, payCost: false, isTapped: false, root: root, activateETB: true));
+                                string selectPlayerMessage = "From which area do you select a card?";
+                                string notSelectPlayerMessage = "The opponent is choosing from which area to select a card.";
+
+                                GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                            }
+                            else
+                            {
+                                GManager.instance.userSelectionManager.SetBool(canSelectHand);
+                            }
+
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+                            bool fromHand = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+                            List<CardSource> selectedCards = new List<CardSource>();
+
+                            IEnumerator SelectCardCoroutine(CardSource cardSource)
+                            {
+                                selectedCards.Add(cardSource);
+
+                                yield return null;
                             }
+
+                            SelectCardEffect.Root root = SelectCardEffect.Root.Hand;
+                            if (fromHand)
+                            {
+                                SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                                selectHandEffect.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: CanSelectCardCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: 1,
+                                    canNoSelect: true,
+                                    canEndNotMax: false,
+                                    isShowOpponent: true,
+                                    selectCardCoroutine: SelectCardCoroutine,
+                                    afterSelectCardCoroutine: null,
+                                    mode: SelectHandEffect.Mode.Custom,
+                                    cardEffect: activateClass);
+
+                                selectHandEffect.SetUpCustomMessage("Select 1 digimon to play", "The opponent is selecting 1 digimon to play");
+
+                                yield return StartCoroutine(selectHandEffect.Activate());
+                            }
+                            else
+                            {
+                                root = SelectCardEffect.Root.Trash;
+                                SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                                selectCardEffect.SetUp(
+                                    canTargetCondition: CanSelectCardCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    canNoSelect: () => true,
+                                    selectCardCoroutine: SelectCardCoroutine,
+                                    afterSelectCardCoroutine: null,
+                                    message: "Select 1 digimon to play",
+                                    maxCount: 1,
+                                    canEndNotMax: false,
+                                    isShowOpponent: true,
+                                    mode: SelectCardEffect.Mode.Custom,
+                                    root: SelectCardEffect.Root.Trash,
+                                    customRootCardList: null,
+                                    canLookReverseCard: true,
+                                    selectPlayer: card.Owner,
+                                    cardEffect: activateClass);
+
+                                selectCardEffect.SetUpCustomMessage("Select 1 1 digimon to play", "The opponent is selecting 1 digimon to play");
+
+                                yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+                            }
+
+                            if (selectedCards.Count > 0) yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(cardSources: selectedCards, activateClass: activateClass, payCost: false, isTapped: false, root: root, activateETB: true));
                         }
                     }
                 }

Assets/CardEffect/P/Yellow/P_191.cs

@@ -20,7 +20,8 @@ namespace DCGO.CardEffects.P
             {
                 bool PermanentCondition(Permanent targetPermanent)
                 {
-                    return targetPermanent.TopCard.HasLightFangOrNightClawTraits;
+                    return targetPermanent.TopCard.IsLevel5 &&
+                           targetPermanent.TopCard.HasLightFangOrNightClawTraits;
                 }
 
                 cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 3, ignoreDigivolutionRequirement: false, card: card, condition: null));
@@ -102,7 +103,7 @@ namespace DCGO.CardEffects.P
                             mode: SelectPermanentEffect.Mode.Custom,
                             cardEffect: activateClass);
 
-                        selectPermanentEffect.SetUpCustomMessage(customMessageArray: CardEffectCommons.customPermanentMessageArray_ChangeDP(changeValue: DPChangeValue(), maxCount: maxCount));
+                        selectPermanentEffect.SetUpCustomMessage(customMessageArray: CardEffectCommons.customPermanentMessageArray_ChangeDP(changeValue: -DPChangeValue(), maxCount: maxCount));
 
                         yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
@@ -114,7 +115,7 @@ namespace DCGO.CardEffects.P
 
                         if (selectedPermanent != null)
                         {
-                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: selectedPermanent, changeValue: DPChangeValue(), effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: selectedPermanent, changeValue: -DPChangeValue(), effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
 
                             if (CardEffectCommons.HasMatchConditionPermanent(CanSelectDeletePermanentCondition))
                             {
@@ -252,7 +253,7 @@ namespace DCGO.CardEffects.P
                             mode: SelectPermanentEffect.Mode.Custom,
                             cardEffect: activateClass);
 
-                        selectPermanentEffect.SetUpCustomMessage(customMessageArray: CardEffectCommons.customPermanentMessageArray_ChangeDP(changeValue: DPChangeValue(), maxCount: maxCount));
+                        selectPermanentEffect.SetUpCustomMessage(customMessageArray: CardEffectCommons.customPermanentMessageArray_ChangeDP(changeValue: -DPChangeValue(), maxCount: maxCount));
 
                         yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
@@ -264,7 +265,7 @@ namespace DCGO.CardEffects.P
 
                         if (selectedPermanent != null)
                         {
-                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: selectedPermanent, changeValue: DPChangeValue(), effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: selectedPermanent, changeValue: -DPChangeValue(), effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
 
                             if (CardEffectCommons.HasMatchConditionPermanent(CanSelectDeletePermanentCondition))
                             {

Assets/Scripts/CEntity_EffectController.cs

@@ -69,13 +69,16 @@ public class CEntity_EffectController : MonoBehaviour
                                     {
                                         if (cardEffect is IAddSkillEffect)
                                         {
-                                            if (cardEffect.IsInheritedEffect == (cardSource == permanent.TopCard) || cardEffect.IsInheritedEffect == cardSource.IsFlipped)
+                                            UnityEngine.Debug.Log($"ADD SKILL CHECK {cardSource.BaseENGCardNameFromEntity}: {cardEffect.IsInheritedEffect}== {(cardSource == permanent.TopCard)} || {cardSource.IsFlipped}");
+                                            if (cardEffect.IsInheritedEffect == (cardSource == permanent.TopCard) || (cardEffect.IsInheritedEffect && cardSource.IsFlipped))
                                             {
                                                 continue;
                                             }
 
+                                            UnityEngine.Debug.Log($"ADD SKILL CHECK {cardEffect.CanUse(null)}");
                                             if (cardEffect.CanUse(null))
                                             {
+                                                UnityEngine.Debug.Log($"ADD SKILL CHECK {!card.CanNotBeAffected(cardEffect)}");
                                                 if (!card.CanNotBeAffected(cardEffect))
                                                     GetCardEffects = ((IAddSkillEffect)cardEffect).GetCardEffect(card, GetCardEffects, timing);
                                             }

Assets/Scripts/CardEffectInterfaces.cs

@@ -154,6 +154,13 @@ public interface IChangeCardNamesForDigiXrosEffect
 }
 #endregion
 
+#region "Change target card's card level for Assembly" effect
+public interface IChangeCardLevelForAssemblyEffect
+{
+    List<int> ChangeCardLevelForAssembly(List<int> levels, CardSource cardSource);
+}
+#endregion
+
 #region "Change target card's traits" effect
 public interface IChangeTraitsEffect
 {

Assets/Scripts/CardEffects/AddSkillClass.cs

@@ -14,7 +14,7 @@ public class AddSkillClass : ICardEffect, IAddSkillEffect
     }
     public List<ICardEffect> GetCardEffect(CardSource card, List<ICardEffect> getCardEffect, EffectTiming timing)
     {
-        //if (_cardSourceCondition(card))
+        if (_cardSourceCondition(card))
         {
             getCardEffect = _getEffects(card, getCardEffect, timing);
         }

Assets/Scripts/CardEffects/ChangeCardLevelForAssemblyClass.cs

@@ -0,0 +1,24 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System;
+
+public class ChangeCardLevelForAssemblyClass : ICardEffect, IChangeCardLevelForAssemblyEffect
+{
+    public void SetUpChangeCardLevelForAssemblyClass(Func<CardSource, List<int>, List<int>> changeCardLevel)
+    {
+        this.changeCardLevel = changeCardLevel;
+    }
+
+    Func<CardSource, List<int>, List<int>> changeCardLevel { get; set; }
+
+    public List<int> ChangeCardLevelForAssembly(List<int> Level, CardSource cardSource)
+    {
+        if (changeCardLevel != null)
+        {
+            Level = changeCardLevel(cardSource, Level);
+        }
+
+        return Level;
+    }
+}

Assets/Scripts/CardEffects/ChangeCardLevelForAssemblyClass.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b66bed69e9bf47b41b1a035c8c3918a7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/CardSource.cs

@@ -800,8 +800,6 @@ public class CardSource : MonoBehaviour
     }
     #endregion
 
-
-
     #region whether this card can declare skill
     public bool CanDeclareSkill => CanDeclareSkillList.Count > 0;
     #endregion
@@ -1561,7 +1559,6 @@ public class CardSource : MonoBehaviour
     }
     #endregion
 
-
     #region whether this card has "XAntibody" trait
     public bool HasXAntibodyTraits => CardTraits.Some(DataBase.IsXAntibodyString);
     #endregion
@@ -1754,6 +1751,25 @@ public class CardSource : MonoBehaviour
     }
     #endregion
 
+    #region card level checked when Assembly
+    public List<int> Level_Assembly
+    {
+        get
+        {
+            List<int> cardLevel_Assembly = new List<int>();
+            cardLevel_Assembly.Add(TreatedLevel);
+
+            #region the effects of itself
+            EffectList(EffectTiming.None)
+                .Filter(cardEffect => cardEffect is IChangeCardLevelForAssemblyEffect && cardEffect.CanUse(null))
+                .ForEach(cardEffect => cardLevel_Assembly = ((IChangeCardLevelForAssemblyEffect)cardEffect).ChangeCardLevelForAssembly(cardLevel_Assembly, this));
+            #endregion
+
+            return cardLevel_Assembly;
+        }
+    }
+    #endregion
+
     #region whether this card has at least 1 card name checked when digixros that equals the string
     /// <summary>
     /// Used to check if specified name is exactly in cards name values ("dra" is not "Commandramon") 

Assets/Scripts/FieldPermanentCard.cs

@@ -444,6 +444,16 @@ public class FieldPermanentCard : MonoBehaviour
         {
             SetCardSuspended(updateIsTapped);
 
+
+            if (ThisPermanent.TopCard.IsFlipped)
+            {
+                DPText.transform.parent.gameObject.SetActive(false);
+                LevelText.transform.parent.gameObject.SetActive(false);
+                EvoRootCountText.transform.parent.gameObject.SetActive(false);
+                LinkedObject.SetActive(false);
+                return;
+            }
+
             //DP
             if (ThisPermanent.IsDigimon)
             {

Assets/Scripts/SelectAssemblyClass.cs

@@ -291,7 +291,7 @@ public class SelectAssemblyClass : MonoBehaviourPunCallbacks
 
             selectCardEffect.SetUp(
                         canTargetCondition: CanSelectCardCondition,
-                        canTargetCondition_ByPreSelecetedList: null,
+                        canTargetCondition_ByPreSelecetedList: AssemblyCondition.CanTargetCondition_ByPreSelecetedList,
                         canEndSelectCondition: null,
                         canNoSelect: () => true,
                         selectCardCoroutine: SelectCardCoroutine,