pre 1.4.16 update

Assets/CardBaseEntity/BT16/Yellow/Digimon/Chaosmon-BT16-036.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:72a998200e941cb0ec712c3ef7b49727f7b12d83996ea621347d71fa5dd2014e
+oid sha256:cf43110c2e49e388de3d11814c4a43a56d2b9cae9461fe722dfd3743154e0c16
 size 1917

Assets/CardBaseEntity/BT16/Yellow/Digimon/Chaosmon-BT16-036_P1.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:37d69125b68fb5600fa540545786d05368dc8f60d0ac5be6fec78c472ed7da68
-size 1900
+oid sha256:66dd33ba7a79265c81ba3ca20dc6e2cf99b1b3ccabde3180fc6eccf70deb7a40
+size 1923

Assets/CardEffect/BT12/Red/MatsudaTakato_BT12_089.cs

@@ -259,7 +259,7 @@ public class MatsudaTakato_BT12_089 : CEntity_Effect
                             isHand: true,
                             activateClass: activateClass,
                             successProcess: SuccessProcess(),
-                            ignoreLevel: true));
+                            ignoreRequirements: CardEffectCommons.IgnoreRequirement.Level));
 
                         IEnumerator SuccessProcess()
                         {

Assets/CardEffect/BT13/Yellow/SatsumaRentaro_BT13_098.cs

@@ -198,7 +198,7 @@ public class SatsumaRentaro_BT13_098 : CEntity_Effect
                             isHand: true,
                             activateClass: activateClass,
                             successProcess: null,
-                            ignoreLevel: true));
+                            ignoreRequirements: CardEffectCommons.IgnoreRequirement.Level));
                     }
                 }
             }

Assets/CardEffect/BT14/Purple/Solgarumon_BT14_079.cs

@@ -36,15 +36,18 @@ public class Solgarumon_BT14_079 : CEntity_Effect
                     }
                 }
 
-                if (cardSource.Level <= maxLevel && cardSource.Level != 2)
+                if (cardSource.Level <= maxLevel && !cardSource.IsLevel2)
                 {
-                    if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass))
+                    if (!cardSource.IsDigiEgg)
                     {
-                        if (cardSource.HasLevel)
+                        if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass))
                         {
-                            if (cardSource.CardTraits.Contains("Dark Animal") || cardSource.CardTraits.Contains("DarkAnimal") || cardSource.CardTraits.Contains("SoC"))
+                            if (cardSource.HasLevel)
                             {
-                                return true;
+                                if (cardSource.CardTraits.Contains("Dark Animal") || cardSource.CardTraits.Contains("DarkAnimal") || cardSource.CardTraits.Contains("SoC"))
+                                {
+                                    return true;
+                                }
                             }
                         }
                     }

Assets/CardEffect/BT15/Purple/Leviamon_X_Antibody_BT15_081.cs

@@ -170,9 +170,7 @@ public class Leviamon_X_Antibody_BT15_081 : CEntity_Effect
                     }
 
                     if (selectedPermanent != null)
-                    {
-                        Debug.Log("Selected Permanent: " + selectedPermanent.TopCard.CardNames[0]);
-     
+                    {     
                         yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DigivolveIntoHandOrTrashCard(
                             targetPermanent: selectedPermanent,
                             cardCondition: null,
@@ -183,9 +181,7 @@ public class Leviamon_X_Antibody_BT15_081 : CEntity_Effect
                             isHand: false,
                             activateClass: activateClass,
                             successProcess: null,
-                            ignoreLevel: false,
                             ignoreSelection: true));
-                        Debug.Log("Selected Permanent: Done");
                     }
                 }
             }

Assets/CardEffect/BT15/Yellow/Kari_Kamiya_BT15_084.cs

@@ -122,10 +122,13 @@ public class Kari_Kamiya_BT15_084 : CEntity_Effect
                 {
                     if (CardEffectCommons.CanTriggerWhenLoseSecurity(hashtable, player => player == card.Owner))
                     {
-                        if (!GManager.instance.attackProcess.DoSecurityCheck)
+                        List<SkillInfo> skills = CardEffectCommons.GetSkillFromHashtable(hashtable);
+
+                        if(skills != null)
                         {
                             return true;
                         }
+                        //if (!GManager.instance.attackProcess.DoSecurityCheck)
                     }
                 }
 

Assets/CardEffect/BT16/Blue/ImperialdramonDragonMode_BT16_028.cs

@@ -262,7 +262,6 @@ namespace DCGO.CardEffects.BT16
                             isHand: true,
                             activateClass: activateClass,
                             successProcess: null,
-                            ignoreLevel: false,
                             ignoreSelection: true));
                 }
             }

Assets/CardEffect/BT16/Purple/DemonWoldOfTheCastleOfNineWolves_BT16_099.cs

@@ -104,7 +104,7 @@ namespace DCGO.CardEffects.BT16
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Play 1 card from trash", CanUseCondition, card);
-                activateClass.SetUpActivateClass(null, ActivateCoroutine, 1, true, EffectDiscription());
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, 1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -135,136 +135,154 @@ namespace DCGO.CardEffects.BT16
 
                     IEnumerator SuccessProcess()
                     {
-                        #region reduce play cost
-                        ChangeCostClass changeCostClass = new ChangeCostClass();
-                        changeCostClass.SetUpICardEffect($"Play Cost -2", CanUseCondition1, card);
-                        changeCostClass.SetUpChangeCostClass(changeCostFunc: ChangeCost, cardSourceCondition: CardSourceCondition, rootCondition: RootCondition, isUpDown: isUpDown, isCheckAvailability: () => false, isChangePayingCost: () => true);
-                        Func<EffectTiming, ICardEffect> getCardEffect = GetCardEffect;
-                        card.Owner.UntilCalculateFixedCostEffect.Add(getCardEffect);
-
-                        ICardEffect GetCardEffect(EffectTiming _timing)
+                        List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
                         {
-                            if (_timing == EffectTiming.None)
-                            {
-                                return changeCostClass;
-                            }
+                            new SelectionElement<bool>(message: $"Play Card", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"Not Play Card", value : false, spriteIndex: 1),
+                        };
 
-                            return null;
-                        }
+                        string selectPlayerMessage = "Will you play a card from trash?";
+                        string notSelectPlayerMessage = "The opponent is deciding to play a card from trash.";
 
-                        bool CanUseCondition1(Hashtable hashtable)
-                        {
-                            return true;
-                        }
+                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                        bool isPlaying = GManager.instance.userSelectionManager.SelectedBoolValue;
 
-                        int ChangeCost(CardSource cardSource, int Cost, SelectCardEffect.Root root, List<Permanent> targetPermanents)
+                        if (isPlaying)
                         {
-                            if (CardSourceCondition(cardSource))
+                            #region reduce play cost
+                            ChangeCostClass changeCostClass = new ChangeCostClass();
+                            changeCostClass.SetUpICardEffect($"Play Cost -2", CanUseCondition1, card);
+                            changeCostClass.SetUpChangeCostClass(changeCostFunc: ChangeCost, cardSourceCondition: CardSourceCondition, rootCondition: RootCondition, isUpDown: isUpDown, isCheckAvailability: () => false, isChangePayingCost: () => true);
+                            Func<EffectTiming, ICardEffect> getCardEffect = GetCardEffect;
+                            card.Owner.UntilCalculateFixedCostEffect.Add(getCardEffect);
+
+                            ICardEffect GetCardEffect(EffectTiming _timing)
                             {
-                                if (RootCondition(root))
+                                if (_timing == EffectTiming.None)
                                 {
-                                    if (PermanentsCondition(targetPermanents))
-                                    {
-                                        Cost -= 2;
-                                    }
+                                    return changeCostClass;
                                 }
-                            }
 
-                            return Cost;
-                        }
+                                return null;
+                            }
 
-                        bool PermanentsCondition(List<Permanent> targetPermanents)
-                        {
-                            if (targetPermanents == null)
+                            bool CanUseCondition1(Hashtable hashtable)
                             {
                                 return true;
                             }
 
-                            else
+                            int ChangeCost(CardSource cardSource, int Cost, SelectCardEffect.Root root, List<Permanent> targetPermanents)
                             {
-                                if (targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0)
+                                if (CardSourceCondition(cardSource))
                                 {
-                                    return true;
+                                    if (RootCondition(root))
+                                    {
+                                        if (PermanentsCondition(targetPermanents))
+                                        {
+                                            Cost -= 2;
+                                        }
+                                    }
                                 }
-                            }
 
-                            return false;
-                        }
+                                return Cost;
+                            }
 
-                        bool CardSourceCondition(CardSource cardSource)
-                        {
-                            if (cardSource.HasPlayCost)
+                            bool PermanentsCondition(List<Permanent> targetPermanents)
                             {
-                                if (cardSource.ContainsTraits("SoC"))
+                                if (targetPermanents == null)
                                 {
                                     return true;
                                 }
-                            }
-
-                            return false;
-                        }
 
-                        bool RootCondition(SelectCardEffect.Root root)
-                        {
-                            return true;
-                        }
-
-                        bool isUpDown()
-                        {
-                            return true;
-                        }
-                        #endregion
-
-                        if (card.Owner.TrashCards.Count(CanSelectCardCondition) >= 1)
-                        {
-                            List<CardSource> selectedCards = new List<CardSource>();
+                                else
+                                {
+                                    if (targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0)
+                                    {
+                                        return true;
+                                    }
+                                }
 
-                            int maxCount = 1;
+                                return false;
+                            }
 
-                            SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+                            bool CardSourceCondition(CardSource cardSource)
+                            {
+                                if (cardSource.HasPlayCost)
+                                {
+                                    if (cardSource.ContainsTraits("SoC"))
+                                    {
+                                        return true;
+                                    }
+                                }
 
-                            selectCardEffect.SetUp(
-                                selectPlayer: card.Owner,
-                                canTargetCondition: CanSelectCardCondition,
-                                canTargetCondition_ByPreSelecetedList: null,
-                                canEndSelectCondition: null,
-                                maxCount: maxCount,
-                                message: "Select 1 card to play.",
-                                canNoSelect: () => true,
-                                canEndNotMax: false,
-                                isShowOpponent: true,
-                                selectCardCoroutine: SelectCardCoroutine,
-                                afterSelectCardCoroutine: null,
-                                mode: SelectCardEffect.Mode.Custom,
-                                root: SelectCardEffect.Root.Trash,
-                                customRootCardList: null,
-                                canLookReverseCard: false,
-                                cardEffect: activateClass);
+                                return false;
+                            }
 
-                            selectCardEffect.SetUpCustomMessage("Select 1 card to play.", "The opponent is selecting 1 card to play.");
-                            selectCardEffect.SetUpCustomMessage_ShowCard("Played Card");
+                            bool RootCondition(SelectCardEffect.Root root)
+                            {
+                                return true;
+                            }
 
-                            yield return StartCoroutine(selectCardEffect.Activate());
+                            bool isUpDown()
+                            {
+                                return true;
+                            }
+                            #endregion
 
-                            IEnumerator SelectCardCoroutine(CardSource cardSource)
+                            if (card.Owner.TrashCards.Count(CanSelectCardCondition) >= 1)
                             {
-                                selectedCards.Add(cardSource);
+                                List<CardSource> selectedCards = new List<CardSource>();
+
+                                int maxCount = 1;
+
+                                SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                                selectCardEffect.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: CanSelectCardCondition,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: maxCount,
+                                    message: "Select 1 card to play.",
+                                    canNoSelect: () => true,
+                                    canEndNotMax: false,
+                                    isShowOpponent: true,
+                                    selectCardCoroutine: SelectCardCoroutine,
+                                    afterSelectCardCoroutine: null,
+                                    mode: SelectCardEffect.Mode.Custom,
+                                    root: SelectCardEffect.Root.Trash,
+                                    customRootCardList: null,
+                                    canLookReverseCard: false,
+                                    cardEffect: activateClass);
+
+                                selectCardEffect.SetUpCustomMessage("Select 1 card to play.", "The opponent is selecting 1 card to play.");
+                                selectCardEffect.SetUpCustomMessage_ShowCard("Played Card");
+
+                                yield return StartCoroutine(selectCardEffect.Activate());
+
+                                IEnumerator SelectCardCoroutine(CardSource cardSource)
+                                {
+                                    selectedCards.Add(cardSource);
 
-                                yield return null;
+                                    yield return null;
+                                }
+
+                                yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
+                                    cardSources: selectedCards,
+                                    activateClass: activateClass,
+                                    payCost: true,
+                                    isTapped: false,
+                                    root: SelectCardEffect.Root.Trash,
+                                    activateETB: true));
                             }
 
-                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
-                                cardSources: selectedCards,
-                                activateClass: activateClass,
-                                payCost: true,
-                                isTapped: false,
-                                root: SelectCardEffect.Root.Trash,
-                                activateETB: true));
+                            #region Remove Cost effect after use
+                            card.Owner.UntilCalculateFixedCostEffect.Remove(getCardEffect);
+                            #endregion
                         }
-
-                        #region Remove Cost effect after use
-                        card.Owner.UntilCalculateFixedCostEffect.Remove(getCardEffect);
-                        #endregion
                     }
                 }
             }

Assets/CardEffect/BT17/Purple/DexDoruGreymon_BT17_067.cs

@@ -117,7 +117,6 @@ namespace DCGO.CardEffects.BT17
                                 isHand: false,
                                 activateClass: activateClass,
                                 successProcess: null,
-                                ignoreLevel: false,
                                 ignoreSelection: true));
 
                             selectedPermanent.willBeRemoveField = false;

Assets/CardEffect/BT17/Purple/DexDorugamon_BT17_065.cs

@@ -117,7 +117,6 @@ namespace DCGO.CardEffects.BT17
                                 isHand: false,
                                 activateClass: activateClass,
                                 successProcess: null,
-                                ignoreLevel: false,
                                 ignoreSelection: true));
 
                             selectedPermanent.willBeRemoveField = false;

Assets/CardEffect/BT17/Purple/DexDorugoramon_BT17_073.cs

@@ -117,7 +117,6 @@ namespace DCGO.CardEffects.BT17
                                 isHand: false,
                                 activateClass: activateClass,
                                 successProcess: null,
-                                ignoreLevel: false,
                                 ignoreSelection: true));
 
                             selectedPermanent.willBeRemoveField = false;

Assets/CardEffect/BT17/Red/TakatoMatsuki_BT17_080.cs

@@ -322,11 +322,11 @@ namespace DCGO.CardEffects.BT17
                                 payCost: false,
                                 reduceCostTuple: null,
                                 fixedCostTuple: null,
-                                ignoreDigivolutionRequirementFixedCost: 1,
+                                ignoreDigivolutionRequirementFixedCost: 0,
                                 isHand: true,
                                 activateClass: activateClass,
                                 successProcess: null,
-                                ignoreLevel: true));
+                                ignoreRequirements: CardEffectCommons.IgnoreRequirement.All));
                         }
                     }
                 }

Assets/CardEffect/BT17/White/Greymon_BT17_102.cs

@@ -119,7 +119,10 @@ namespace DCGO.CardEffects.BT17
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                    if(card.PermanentOfThisCard().TopCard == card)
+                        return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+
+                    return false;
                 }
 
                 List<string> changeCardNames(CardSource cardSource, List<string> CardNames)

Assets/CardEffect/BT17/White/ImperialdramonPaladinMode_BT17_077.cs

@@ -281,9 +281,51 @@ namespace DCGO.CardEffects.BT17
 
                     List<CardSource> returnedSources = willReturnYourTrash ? card.Owner.TrashCards.Clone() : card.Owner.Enemy.TrashCards.Clone();
 
-                    yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddLibraryBottomCards(returnedSources));
+                    if (returnedSources.Count >= 1)
+                    {
+                        if (returnedSources.Count == 1)
+                        {
+                            yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddLibraryBottomCards(returnedSources));
+
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect2(returnedSources, "Deck Bottom Cards", true, true));
+                        }
+                        else
+                        {
+                            int maxCount = returnedSources.Count;
+
+                            SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                            selectCardEffect.SetUp(
+                            canTargetCondition: (cardSource) => true,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            canNoSelect: () => false,
+                            selectCardCoroutine: null,
+                            afterSelectCardCoroutine: AfterSelectCardCoroutine1,
+                            message: "Select cards to place at the bottom of the deck\n(cards will be placed back to the bottom of the deck so that cards with lower numbers are on top).",
+                            maxCount: maxCount,
+                            canEndNotMax: false,
+                            isShowOpponent: false,
+                            mode: SelectCardEffect.Mode.Custom,
+                            root: SelectCardEffect.Root.Custom,
+                            customRootCardList: returnedSources,
+                            canLookReverseCard: true,
+                            selectPlayer: card.Owner,
+                            cardEffect: activateClass);
+
+                            selectCardEffect.SetNotShowCard();
+                            selectCardEffect.SetNotAddLog();
+
+                            yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
 
-                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect2(returnedSources, "Deck Bottom Cards", true, true));
+                            IEnumerator AfterSelectCardCoroutine1(List<CardSource> cardSources)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddLibraryBottomCards(cardSources));
+
+                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect2(cardSources, "Deck Bottom Cards", true, true));
+                            }
+                        }
+                    }
 
                     if (returnedSources.Count(HasWhiteLevelSeven) > 0)
                         yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(3, activateClass));

Assets/CardEffect/BT17/Yellow/RikaNonaka_BT17_085.cs

@@ -311,7 +311,7 @@ namespace DCGO.CardEffects.BT17
                                 ignoreDigivolutionRequirementFixedCost: 4,
                                 isHand: true,
                                 activateClass: activateClass,
-                                ignoreLevel: true,
+                                ignoreRequirements: CardEffectCommons.IgnoreRequirement.All,
                                 successProcess: SuccessProcess()));
 
                             IEnumerator SuccessProcess()

Assets/CardEffect/BT6/Blue/IshidaYamato_BT6_088.cs

@@ -186,7 +186,7 @@ public class IshidaYamato_BT6_088 : CEntity_Effect
                             isHand: true,
                             activateClass: activateClass,
                             successProcess: SuccessProcess(),
-                            ignoreLevel: true));
+                            ignoreRequirements: CardEffectCommons.IgnoreRequirement.Level));
 
                         IEnumerator SuccessProcess()
                         {

Assets/CardEffect/BT6/Red/YagamiTaichi_BT6_087.cs

@@ -189,7 +189,7 @@ public class YagamiTaichi_BT6_087 : CEntity_Effect
                             isHand: true,
                             activateClass: activateClass,
                             successProcess: SuccessProcess(),
-                            ignoreLevel: true));
+                            ignoreRequirements: CardEffectCommons.IgnoreRequirement.Level));
 
                         IEnumerator SuccessProcess()
                         {

Assets/CardEffect/BT7/White/EvolutionAncient_BT7_110.cs

@@ -145,7 +145,7 @@ public class EvolutionAncient_BT7_110 : CEntity_Effect
                             isHand: true,
                             activateClass: activateClass,
                             successProcess: null,
-                            ignoreLevel: true));
+                            ignoreRequirements: CardEffectCommons.IgnoreRequirement.Level));
                     }
                 }
             }

Assets/CardEffect/EX1/Purple/Ladydevimon_EX1_060.cs

@@ -64,7 +64,10 @@ public class Ladydevimon_EX1_060 : CEntity_Effect
 
             bool PermanentCondition(Permanent permanent)
             {
-                return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
+                if(!permanent.IsToken)
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card);
+
+                return false;
             }
 
             bool RootCondition(SelectCardEffect.Root root)

Assets/CardEffect/EX6/Purple/Creepymon_EX6_058.cs

@@ -111,13 +111,13 @@ namespace DCGO.CardEffects.EX6
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Delete 1 opponent Digimon with the lowest level", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Delete 1 opponent Digimon with the lowest DP", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
                 {
-                    return "[When Digivolving] Delete 1 of your opponent's Digimon with the lowest level. For each level of the Digimon deleted by this effect, trash the top card of your deck.";
+                    return "[When Digivolving] Delete 1 of your opponent's Digimon with the lowest DP. For each level of the Digimon deleted by this effect, trash the top card of your deck.";
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -127,7 +127,7 @@ namespace DCGO.CardEffects.EX6
 
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
-                    return CardEffectCommons.IsMinLevel(permanent, card.Owner.Enemy);
+                    return CardEffectCommons.IsMinDP(permanent, card.Owner.Enemy);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)

Assets/CardEffect/EX7/Purple/LadyDevimonXAntibody_EX7_058.cs

@@ -172,7 +172,23 @@ namespace DCGO.CardEffects.EX7
 
                     if (CanActivateSecondEffectCondition(hashtable))
                     {
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayVoléeZerdrücken(activateClass));
+                        List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                        {
+                            new SelectionElement<bool>(message: $"Play Token", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"Not Play Token", value : false, spriteIndex: 1),
+                        };
+
+                        string selectPlayerMessage = "Will you play a token?";
+                        string notSelectPlayerMessage = "The opponent is choosing to play a token.";
+
+                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                        bool canPlay = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+                        if (canPlay)
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayVoléeZerdrücken(activateClass));
                     }
                 }
             }
@@ -307,7 +323,23 @@ namespace DCGO.CardEffects.EX7
 
                     if (CanActivateSecondEffectCondition(hashtable))
                     {
-                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayVoléeZerdrücken(activateClass));
+                        List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                        {
+                            new SelectionElement<bool>(message: $"Play Token", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"Not Play Token", value : false, spriteIndex: 1),
+                        };
+
+                        string selectPlayerMessage = "Will you play a token?";
+                        string notSelectPlayerMessage = "The opponent is choosing to play a token.";
+
+                        GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                        bool canPlay = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+                        if(canPlay)
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayVoléeZerdrücken(activateClass));
                     }
                 }
             }

Assets/CardEffect/LM/Yellow/Quantumon_LM_020.cs

@@ -156,20 +156,6 @@ namespace DCGO.CardEffects.LM
 
                             if (selectedCard != null)
                             {
-                                #region
-                                selectedCard.Owner.securityObject.securityBreakGlass.ShowBlueMatarial();
-
-                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().BreakSecurityEffect(selectedCard.Owner));
-
-                                yield return new WaitForSeconds(0.1f);
-
-                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().EnterSecurityCardEffect(selectedCard));
-
-                                yield return new WaitForSeconds(0.5f);
-
-                                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().DestroySecurityEffect(selectedCard));
-                                #endregion
-
                                 yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddLibraryTopCards(new List<CardSource>() { selectedCard }));
                             }
 
@@ -269,7 +255,19 @@ namespace DCGO.CardEffects.LM
                             canNotAffectedClass.SetUpCanNotAffectedClass(CardCondition: CardCondition, SkillCondition: SkillCondition);
                             selectedPermanent.UntilOpponentTurnEndEffects.Add((_timing) => canNotAffectedClass);
 
-                            bool CardCondition(CardSource cardSource)
+                            #region Log
+                            string log = "";
+
+                            
+                            log += $"\n{card.BaseENGCardNameFromEntity}({card.CardID}) Immunity:";
+                            log += $"\n{selectedCategory} effects";
+
+                            log += "\n";
+
+                            PlayLog.OnAddLog?.Invoke(log);
+                            #endregion
+
+                        bool CardCondition(CardSource cardSource)
                             {
                                 if (cardSource == card)
                                 {

Assets/CardEffect/ST17/Blue/Magnamon_ST17_13.cs

@@ -112,7 +112,7 @@ namespace DCGO.CardEffects.ST17
                 ContinuousController.instance.PlaySE(GManager.instance.GetComponent<Effects>().BuffSE);
 
                 ActivateClass activateClassDigivolve = new ActivateClass();
-                activateClassDigivolve.SetUpICardEffect("Digivolve intto this Digimon", CanUseConditionAfterBattle, card);
+                activateClassDigivolve.SetUpICardEffect("Digivolve into this Digimon", CanUseConditionAfterBattle, card);
                 activateClassDigivolve.SetUpActivateClass(CanActivateConditionAfterBattle, ActivateCoroutineAfterBattle, -1, true, EffectDiscriptionAfterBattle());
                 card.Owner.UntilEndBattleEffects.Add(GetCardEffectAfterBattle);
 
@@ -121,6 +121,11 @@ namespace DCGO.CardEffects.ST17
                     return "[Security] At the end of the battle, 1 of your Digimon may digivolve into this card without paying the digivolution cost.";
                 }
 
+                bool CanSelectCardConditionAferBattle(CardSource cardSource)
+                {
+                    return cardSource == card;
+                }
+
                 bool CanSelectPermanentConditionAfterBattle(Permanent permanent)
                 {
                     if (CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card))
@@ -145,7 +150,6 @@ namespace DCGO.CardEffects.ST17
 
                 IEnumerator ActivateCoroutineAfterBattle(Hashtable _hashtable)
                 {
-                    yield return null;
                     if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentConditionAfterBattle))
                     {
                         Permanent selectedPermanent = null;
@@ -181,7 +185,7 @@ namespace DCGO.CardEffects.ST17
 
                         if (selectedPermanent != null)
                         {
-                            if (card.CanPlayCardTargetFrame(selectedPermanent.PermanentFrame, false, activateClassDigivolve))
+                            /*if (card.CanPlayCardTargetFrame(selectedPermanent.PermanentFrame, false, activateClassDigivolve))
                             {
                                 PlayCardClass playCardClass = new PlayCardClass(
                                     cardSources: new List<CardSource>() { card },
@@ -193,8 +197,8 @@ namespace DCGO.CardEffects.ST17
                                     activateETB: true);
 
                                 yield return ContinuousController.instance.StartCoroutine(playCardClass.PlayCard());
-                            }
-                            /*yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DigivolveIntoExcecutingAreaCard(
+                            }*/
+                            yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DigivolveIntoExcecutingAreaCard(
                                 targetPermanent: selectedPermanent,
                                 cardCondition: CanSelectCardConditionAferBattle,
                                 payCost: false,
@@ -202,7 +206,7 @@ namespace DCGO.CardEffects.ST17
                                 fixedCostTuple: null,
                                 ignoreDigivolutionRequirementFixedCost: -1,
                                 activateClass: activateClass,
-                                successProcess: null));*/
+                                successProcess: null));
                         }
                     }
                 }

Assets/CardEffect/ST17/Green/HenryWong_ST17_10.cs

@@ -301,7 +301,7 @@ namespace DCGO.CardEffects.ST17
                                 isHand: true,
                                 activateClass: activateClass,
                                 successProcess: SuccessProcess(),
-                                ignoreLevel: true));
+                                ignoreRequirements: CardEffectCommons.IgnoreRequirement.All));
 
                             IEnumerator SuccessProcess()
                             {

Assets/Editor/Fixing Scripts/ScriptableObjects/CardEntity_Inconsistency.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:04f987b37ebaa977901be81967f6b9b9540d7ce38289e5f62c6143c146c97413
-size 484
+oid sha256:4717ec38a3e967bbfa3a4a9b388d3138607bc8b811bd40f8207c77f05fe2dfda
+size 503

Assets/Scripts/CardController.cs

@@ -3242,10 +3242,7 @@ public class IDestroySecurity
                 yield return ContinuousController.instance.StartCoroutine(new IReduceSecurity(
                     player: _player,
                     refSkillInfos: ref ContinuousController.instance.nullSkillInfos).ReduceSecurity());
-            }
 
-            if (discardedCards.Count >= 1)
-            {
                 #region "When security cards are trashed" effect
 
                 #region Hashtable setting
@@ -3563,16 +3560,6 @@ public class IBattle
 
                 yield return ContinuousController.instance.StartCoroutine(new DestroyPermanentsClass(LoserPermanents, hashtable).Destroy());
 
-                #region effect when determine whether to do security check
-                List<SkillInfo> skillInfos_Pierce = AutoProcessing.GetSkillInfos(hashtable, EffectTiming.OnDetermineDoSecurityCheck)
-                    .Filter(skillInfo => skillInfo.CardEffect != null && skillInfo.CardEffect.CanActivate(skillInfo.Hashtable));
-
-                if (skillInfos_Pierce.Count >= 1)
-                {
-                    GManager.instance.autoProcessing.PutStackedSkill(skillInfos_Pierce[0]);
-                }
-                #endregion
-
                 //Fix winner/loser permanents
                 int index = -1;
                 foreach (Permanent permanent in LoserPermanents)
@@ -3592,6 +3579,16 @@ public class IBattle
                     hashtable["LoserPermanents_real"] = LoserPermanents;
                 }
 
+                #region effect when determine whether to do security check
+                List<SkillInfo> skillInfos_Pierce = AutoProcessing.GetSkillInfos(hashtable, EffectTiming.OnDetermineDoSecurityCheck)
+                    .Filter(skillInfo => skillInfo.CardEffect != null && skillInfo.CardEffect.CanActivate(skillInfo.Hashtable));
+
+                if (skillInfos_Pierce.Count >= 1)
+                {
+                    GManager.instance.autoProcessing.PutStackedSkill(skillInfos_Pierce[0]);
+                }
+                #endregion
+
                 // "At the end of battle" effect
                 yield return ContinuousController.instance.StartCoroutine(GManager.instance.autoProcessing.StackSkillInfos(hashtable, EffectTiming.OnEndBattle));
 
@@ -3944,7 +3941,8 @@ public class IReduceSecurity
         #region Hashtable Setting
         Hashtable hashtable = new Hashtable()
         {
-            {"Player", _player}
+            {"Player", _player},
+            {"SkillInfo",_refSkillInfos }
         };
         #endregion
 

Assets/Scripts/CardEffectCommons.cs

@@ -6,7 +6,17 @@ using UnityEngine;
 using UnityEditor;
 
 public partial class CardEffectCommons
-{
+{ 
+    #region Digivolution Requirements
+    public enum IgnoreRequirement
+    {
+        None,
+        All,
+        Level,
+        Color
+    }
+    #endregion
+
     #region Play cards as new permanents
     public static IEnumerator PlayPermanentCards(List<CardSource> cardSources, ICardEffect activateClass, bool payCost, bool isTapped, SelectCardEffect.Root root, bool activateETB, bool isBreedingArea = false, int fixedCost = -1)
     {
@@ -382,8 +392,9 @@ public partial class CardEffectCommons
         bool isHand,
         ICardEffect activateClass,
         IEnumerator successProcess,
-        bool ignoreLevel = false,
-        bool ignoreSelection = false)
+        //bool ignoreLevel = false,
+        bool ignoreSelection = false,
+        IgnoreRequirement ignoreRequirements = IgnoreRequirement.None)
     {
         if (targetPermanent == null) yield break;
         if (targetPermanent.TopCard == null) yield break;
@@ -392,7 +403,7 @@ public partial class CardEffectCommons
        
         Player owner = targetPermanent.TopCard.Owner;
         SelectCardEffect.Root root = isHand ? SelectCardEffect.Root.Hand : SelectCardEffect.Root.Trash;
-        bool ignoreDigivolutionRequirement = ignoreDigivolutionRequirementFixedCost >= 0;
+        bool ignoreDigivolutionRequirement = !ignoreRequirements.Equals(IgnoreRequirement.None) || ignoreDigivolutionRequirementFixedCost >= 0;//  ignoreDigivolutionRequirementFixedCost >= 0 || ignoreRequirements;
 
         int fixedCost = -1;
 
@@ -414,13 +425,13 @@ public partial class CardEffectCommons
                 {
                     if (!cardSource.CanNotEvolve(targetPermanent))
                     {
-                        if (ignoreLevel
-                        || cardSource.CanPlayCardTargetFrame(
+                        if (cardSource.CanPlayCardTargetFrame(
                             frame: targetPermanent.PermanentFrame,
                             PayCost: payCost,
                             cardEffect: activateClass,
                             root: root,
-                            fixedCost: fixedCost))
+                            fixedCost: fixedCost,
+                            ignore: ignoreRequirements))
                         {
                             return true;
                         }
@@ -657,8 +668,11 @@ public partial class CardEffectCommons
             root: root,
             activateETB: true);
 
-        if (ignoreLevel) playCardClass.SetIgnoreLevel();
-        if (!ignoreDigivolutionRequirement && fixedCost >= 0) playCardClass.SetFixedCost(fixedCost);
+        if (ignoreRequirements.Equals(IgnoreRequirement.All) || ignoreRequirements.Equals(IgnoreRequirement.Level)) 
+            playCardClass.SetIgnoreLevel();
+
+        if (!ignoreDigivolutionRequirement && fixedCost >= 0) 
+            playCardClass.SetFixedCost(fixedCost);
 
         yield return ContinuousController.instance.StartCoroutine(playCardClass.PlayCard());
 

Assets/Scripts/CardEffectCommons/GetFromHashtable.cs

@@ -26,6 +26,26 @@ public partial class CardEffectCommons
     }
     #endregion
 
+    #region Get SkillInfo from hashtable
+    public static List<SkillInfo> GetSkillFromHashtable(Hashtable hashtable)
+    {
+        if (hashtable != null)
+        {
+            if (hashtable.ContainsKey("SkillInfo"))
+            {
+                if (hashtable["SkillInfo"] is List<SkillInfo>)
+                {
+                    List<SkillInfo> skillInfo = (List<SkillInfo>)hashtable["SkillInfo"];
+
+                    return skillInfo;
+                }
+            }
+        }
+
+        return null;
+    }
+    #endregion
+
     #region Get Root from hashtable
     public static SelectCardEffect.Root GetRootFromHashtable(Hashtable hashtable)
     {

Assets/Scripts/CardEffects/AddSkillClass.cs

@@ -19,6 +19,8 @@ public class AddSkillClass : ICardEffect, IAddSkillEffect
             getCardEffect = _getEffects(card, getCardEffect, timing);
         }
 
+        SetEffectSourceCard(card);
+
         return getCardEffect;
     }
 }

Assets/Scripts/CardSource.cs

@@ -346,7 +346,7 @@ public class CardSource : MonoBehaviour
     #endregion
 
     #region evoCosts
-    public List<Func<Permanent, int>> EvoCosts(bool ignoreLevel, bool checkAvailability)
+    public List<Func<Permanent, int>> EvoCosts(CardEffectCommons.IgnoreRequirement ignore, bool checkAvailability)
     {
         List<Func<Permanent, int>> EvoCosts = new List<Func<Permanent, int>>();
 
@@ -399,9 +399,12 @@ public class CardSource : MonoBehaviour
                     .Map<EvoCost, Func<Permanent, int>>(evoCost =>
                     (targetPermanent) =>
                     {
-                        if (targetPermanent.TopCard.CardColors.Contains(evoCost.CardColor))
+                        if(ignore.Equals(CardEffectCommons.IgnoreRequirement.All))
+                            return evoCost.MemoryCost;
+
+                        if (ignore.Equals(CardEffectCommons.IgnoreRequirement.Color) || targetPermanent.TopCard.CardColors.Contains(evoCost.CardColor))
                         {
-                            if (ignoreLevel || targetPermanent.Level == evoCost.Level)
+                            if (ignore.Equals(CardEffectCommons.IgnoreRequirement.Level) || targetPermanent.Level == evoCost.Level)
                             {
                                 return evoCost.MemoryCost;
                             }
@@ -418,7 +421,12 @@ public class CardSource : MonoBehaviour
     #region evo cost list
     public List<int> CostList(Permanent targetPermanent, bool ignoreLevel, bool checkAvailability)
     {
-        return EvoCosts(ignoreLevel, checkAvailability)
+        CardEffectCommons.IgnoreRequirement ignore = CardEffectCommons.IgnoreRequirement.None;
+
+        if(ignoreLevel)
+            ignore = CardEffectCommons.IgnoreRequirement.Level;
+
+        return EvoCosts(ignore, checkAvailability)
                 .Filter(evoCost => evoCost(targetPermanent) >= 0)
                 .Map(evoCost => evoCost(targetPermanent));
     }
@@ -816,7 +824,7 @@ public class CardSource : MonoBehaviour
     #endregion
 
     #region whether this card can be played at the frame
-    public bool CanPlayCardTargetFrame(FieldCardFrame frame, bool PayCost, ICardEffect cardEffect, SelectCardEffect.Root root = SelectCardEffect.Root.Hand, int fixedCost = -1, bool isBreedingArea = false)
+    public bool CanPlayCardTargetFrame(FieldCardFrame frame, bool PayCost, ICardEffect cardEffect, SelectCardEffect.Root root = SelectCardEffect.Root.Hand, int fixedCost = -1, bool isBreedingArea = false, CardEffectCommons.IgnoreRequirement ignore = CardEffectCommons.IgnoreRequirement.None)
     {
         bool isBattleAreaFrame = FieldCardFrame.isBattleAreaFrameID(frame.FrameID);
 
@@ -856,7 +864,7 @@ public class CardSource : MonoBehaviour
 
         if (frame.GetFramePermanent() != null)
         {
-            if (!CanEvolve(frame.GetFramePermanent(), true))
+            if (!CanEvolve(frame.GetFramePermanent(), true, ignore))
             {
                 return false;
             }
@@ -944,7 +952,7 @@ public class CardSource : MonoBehaviour
     #endregion
 
     #region whether the permanent can digivolve into this card
-    public bool CanEvolve(Permanent targetPermanent, bool checkAvailability)
+    public bool CanEvolve(Permanent targetPermanent, bool checkAvailability, CardEffectCommons.IgnoreRequirement ignore = CardEffectCommons.IgnoreRequirement.None)
     {
         if (targetPermanent != null)
         {
@@ -955,7 +963,7 @@ public class CardSource : MonoBehaviour
 
             if (targetPermanent.TopCard != null)
             {
-                foreach (Func<Permanent, int> EvoCost in EvoCosts(false, checkAvailability))
+                foreach (Func<Permanent, int> EvoCost in EvoCosts(ignore, checkAvailability))
                 {
                     if (EvoCost(targetPermanent) >= 0)
                     {

Assets/Scripts/Player.cs

@@ -1365,7 +1365,7 @@ public class Player : MonoBehaviour
                 #endregion
             }
 
-            #region プレイヤーの効果
+            #region Player effect
             foreach (ICardEffect cardEffect1 in player.EffectList(EffectTiming.None))
             {
                 if (cardEffect1 is ICannotIgnoreDigivolutionConditionEffect)

Assets/Scripts/SelectBurstDigivolutionEffect.cs

@@ -264,7 +264,7 @@ public class SelectBurstDigivolutionEffect : MonoBehaviour
 
                 string EffectDiscription1()
                 {
-                    return "At the end of the burst digivolution turn, trash this Digimon�f top card";
+                    return "At the end of the burst digivolution turn, trash this Digimon's top card";
                 }
 
                 ChangeDPClass rootEffect = new ChangeDPClass();
@@ -314,6 +314,8 @@ public class SelectBurstDigivolutionEffect : MonoBehaviour
 
                                 CardSource cardSource = permanent.TopCard;
 
+                                yield return ContinuousController.instance.StartCoroutine(new AceOverflowClass(new List<CardSource>() { cardSource }).Overflow());
+
                                 yield return ContinuousController.instance.StartCoroutine(CardObjectController.RemoveFromAllArea(cardSource));
 
                                 if (!cardSource.IsToken)

Assets/Scripts/TurnStateMachine.cs

@@ -599,18 +599,13 @@ public class TurnStateMachine : MonoBehaviourPunCallbacks
         }
 
         //Unsuspend raising area Permanents
-        foreach (Permanent permanent in gameContext.You.GetBreedingAreaPermanents())
+        foreach (Permanent permanent in gameContext.TurnPlayer.GetBreedingAreaPermanents())
         {
             if (permanent.IsSuspended)
             {
                 if (permanent.TopCard.Owner == gameContext.TurnPlayer)
                 {
-                    permanent.IsSuspended = false;
-
-                    if (permanent.ShowingPermanentCard != null)
-                    {
-                        permanent.ShowingPermanentCard.ShowPermanentData(true);
-                    }
+                    unsuspendPermanents.Add(permanent);
                 }
             }
         }