Merge branch '1.10.5-bugfixes' of https://github.com/DCGO2/DCGO into AppfuseSimplification

Assets/CardEffect/EX10/Black/EX10_035.cs

@@ -362,8 +362,8 @@ namespace DCGO.CardEffects.EX10
             if (timing == EffectTiming.SecuritySkill)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect($"Play 1 Level 5 or lower", CanUseCondition, card);
-                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetUpICardEffect($"Play 1 Level 5 or lower digimon with [Dark Masters] in text from hand or trash", CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDiscription());
                 activateClass.SetIsSecurityEffect(true);
                 cardEffects.Add(activateClass);
 
@@ -371,16 +371,114 @@ namespace DCGO.CardEffects.EX10
                 {
                     return "[Security] If this card was face-up, you may play 1 level 5 or lower card with [Dark Masters] in its text from your hand or trash without paying the cost.";
                 }
+
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerSecurityEffect(hashtable, card);
+                    return CardEffectCommons.CanTriggerSecurityEffect(hashtable, card)
+                        && (CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition) || CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
+                        && card.IsFlipped;
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    return cardSource.IsDigimon
+                        && cardSource.HasLevel && cardSource.Level <= 5
+                        && cardSource.HasText("Dark Masters");
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
+                    bool canSelectHand = CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition);
+                    bool canSelectTrash = CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition);
+
+                    if (canSelectHand || canSelectTrash)
+                    {
+                        if (canSelectHand && canSelectTrash)
+                        {
+                            List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                        {
+                            new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
+                        };
 
-                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.AddThisCardToHand(card, activateClass));
+                            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;
+                        }
+
+                        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 ContinuousController.instance.StartCoroutine(selectHandEffect.Activate());
+                        }
+                        else
+                        {
+                            SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                            selectCardEffect.SetUp(
+                                canTargetCondition: CanSelectCardCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                canNoSelect: () => true,
+                                selectCardCoroutine: SelectCardCoroutine,
+                                afterSelectCardCoroutine: null,
+                                message: "Select 1 card to add as source.",
+                                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 card to add as source.", "The opponent is selecting 1 card to add as source.");
+
+                            yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+                        }
+
+                        if (selectedCards.Any()) yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
+                                cardSources: selectedCards,
+                                activateClass: activateClass,
+                                payCost: false,
+                                isTapped: false,
+                                root: fromHand ? SelectCardEffect.Root.Hand : SelectCardEffect.Root.Trash,
+                                activateETB: true
+                        ));
+                    }
                 }
             }
 

Assets/CardEffect/EX10/Black/EX10_062.cs

@@ -65,7 +65,7 @@ namespace DCGO.CardEffects.EX10
 
             #region All Turns
 
-            if(timing == EffectTiming.OnLinkCardDiscarded)
+            if (timing == EffectTiming.OnLinkCardDiscarded)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Suspend to draw on trash", CanUseCondition, card);
@@ -97,11 +97,13 @@ namespace DCGO.CardEffects.EX10
             #endregion
 
             #region End of turn
+
             if (timing == EffectTiming.OnEndTurn)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("May app fuse", CanUseCondition, card);
+                activateClass.SetUpICardEffect("App fuse 1 digimon into digimon in hand", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDescription());
+                activateClass.SetHashString("EX10_062_AppFusion");
                 cardEffects.Add(activateClass);
 
                 string EffectDescription()
@@ -116,17 +118,8 @@ namespace DCGO.CardEffects.EX10
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleArea(card))
-                    {
-                        if (CardEffectCommons.IsOwnerTurn(card))
-                        {
-                            if (CardEffectCommons.HasMatchConditionOwnersPermanent(card, perm => CardEffectCommons.IsExistOnBattleAreaDigimon(card))) {
-                                return true;
-                            }
-                        }
-                        
-                    }
-                    return false;
+                    return CardEffectCommons.IsExistOnBattleArea(card)
+                        && CardEffectCommons.IsOwnerTurn(card);
                 }
 
                 bool CanSelectPermanent(Permanent permanent)
@@ -141,10 +134,10 @@ namespace DCGO.CardEffects.EX10
                                     return true;
                             }
                         }
-
                     }
                     return false;
                 }
+
                 bool CanSelectCard(CardSource card, Permanent permanent)
                 {
                     if (CardEffectCommons.IsExistOnHand(card))
@@ -231,6 +224,16 @@ namespace DCGO.CardEffects.EX10
                     }
                 }
             }
+
+            #endregion
+
+            #region Security Effect
+
+            if (timing == EffectTiming.SecuritySkill)
+            {
+                cardEffects.Add(CardEffectFactory.PlaySelfTamerSecurityEffect(card));
+            }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/EX10/Black/EX10_070.cs

@@ -10,8 +10,8 @@ namespace DCGO.CardEffects.EX10
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
-
             #region Ignore Color Requirment
+
             if (timing == EffectTiming.None)
             {
                 IgnoreColorConditionClass ignoreColorConditionClass = new IgnoreColorConditionClass();
@@ -45,9 +45,11 @@ namespace DCGO.CardEffects.EX10
                     return cardSource == card;
                 }
             }
+
             #endregion
 
             #region Main
+
             if (timing == EffectTiming.OptionSkill)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -60,11 +62,6 @@ namespace DCGO.CardEffects.EX10
                     return "[Main] <Draw 1>. Then, place this card in the battle area.";
                 }
 
-                bool CanSelectCardCondition(CardSource cardSource)
-                {
-                    return cardSource.EqualsTraits("Appmon") || cardSource.EqualsTraits("App Driver");
-                }
-
                 bool CanUseCondition(Hashtable hashtable)
                 {
                     return CardEffectCommons.CanTriggerOptionMainEffect(hashtable, card);
@@ -72,29 +69,15 @@ namespace DCGO.CardEffects.EX10
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.SimplifiedRevealDeckTopCardsAndSelect(
-                        revealCount: 3,
-                        simplifiedSelectCardConditions:
-                        new SimplifiedSelectCardConditionClass[]
-                        {
-                        new SimplifiedSelectCardConditionClass(
-                            canTargetCondition:CanSelectCardCondition,
-                            message: "Select 1 card with [Appmon]/[App Driver] in its traits.",
-                            mode: SelectCardEffect.Mode.AddHand,
-                            maxCount: 1,
-                            selectCardCoroutine: null)
-                        },
-                        remainingCardsPlace: RemainingCardsPlace.Trash,
-                        activateClass: activateClass
-                    ));
-
+                    yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlaceDelayOptionCards(card: card, cardEffect: activateClass));
                 }
             }
-            #endregion
 
+            #endregion
 
             #region Delay - link when link card trashed
+
             if (timing == EffectTiming.OnLinkCardDiscarded)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -234,8 +217,8 @@ namespace DCGO.CardEffects.EX10
                     }
                 }
             }
-            #endregion
 
+            #endregion
 
             #region Security
 
@@ -266,7 +249,6 @@ namespace DCGO.CardEffects.EX10
 
             #endregion
 
-
             return cardEffects;
         }
     }

Assets/CardEffect/EX10/Black/EX10_073.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
 
 //EX10 Deusmon
 namespace DCGO.CardEffects.EX10
@@ -13,6 +12,21 @@ namespace DCGO.CardEffects.EX10
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Static effects
+
+            #region Alternative Digivolution Cost
+
+            if (timing == EffectTiming.None)
+            {
+                bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.HasUltimateAppTraits;
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 5, ignoreDigivolutionRequirement: false, card: card, condition: null));
+            }
+
+            #endregion
+
             #region Link +1
 
             if (timing == EffectTiming.None) cardEffects.Add(CardEffectFactory.ChangeSelfLinkMaxStaticEffect(1, false, card, null));
@@ -106,13 +120,16 @@ namespace DCGO.CardEffects.EX10
             }
 
             #endregion
+
             #endregion
 
             #region When Digivolving/EoOT shared
+
             bool CanActivateConditionShared(Hashtable hashtable)
             {
-                return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
-                    (card.Owner.HandCards.Count > 0 || card.PermanentOfThisCard().cardSources.Any(source => source.CanLinkToTargetPermanent(card.PermanentOfThisCard(), false)));
+                return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                    && (CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectLinkCard)
+                    || CardEffectCommons.HasMatchConditionOwnersPermanent(card, ThisPermamentCondition));
             }
 
             bool CanSelectLinkCard(CardSource cardSource)
@@ -120,10 +137,16 @@ namespace DCGO.CardEffects.EX10
                 return cardSource.CanLinkToTargetPermanent(card.PermanentOfThisCard(), false);
             }
 
+            bool ThisPermamentCondition(Permanent permanent)
+            {
+                return permanent == card.PermanentOfThisCard()
+                    && permanent.DigivolutionCards.Exists(CanSelectLinkCard);
+            }
+
             IEnumerator SharedActivateCoroutine(Hashtable hashtable, ActivateClass activateClass)
             {
                 bool hasInHand = CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectLinkCard);
-                bool hasInSources = card.PermanentOfThisCard().DigivolutionCards.Count(CanSelectLinkCard) > 0;
+                bool hasInSources = card.PermanentOfThisCard().DigivolutionCards.Exists(CanSelectLinkCard);
                 CardSource selectedCard = null;
 
                 IEnumerator SelectCardCoroutine(CardSource cardSource)
@@ -132,6 +155,32 @@ namespace DCGO.CardEffects.EX10
                     yield return null;
                 }
 
+                if (hasInSources)
+                {
+                    SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+                    selectHandEffect.SetUp(
+                                selectPlayer: card.Owner,
+                                canTargetCondition: CanSelectLinkCard,
+                                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 card to link", "The opponent is selecting 1 card to link");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectHandEffect.Activate());
+                    if (selectedCard != null)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddLinkCard(selectedCard, activateClass));
+                        selectedCard = null;
+                    }
+                }
+
                 if (hasInHand)
                 {
                     SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
@@ -155,43 +204,15 @@ namespace DCGO.CardEffects.EX10
 
                     selectCardEffect.SetUpCustomMessage("Select 1 card to link", "The opponent is selecting 1 card to link");
 
-                    yield return StartCoroutine(selectCardEffect.Activate());
-                }
-
-                if (selectedCard != null)
-                {
-                    yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddLinkCard(selectedCard, activateClass));
-                    selectedCard = null;
+                    yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+                    if (selectedCard != null) yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddLinkCard(selectedCard, activateClass));
                 }
-
-                if (hasInSources)
-                {
-                    SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
-                    selectHandEffect.SetUp(
-                                selectPlayer: card.Owner,
-                                canTargetCondition: CanSelectLinkCard,
-                                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 card to link", "The opponent is selecting 1 card to link");
-
-                    yield return StartCoroutine(selectHandEffect.Activate());
-                }
-
-                if (selectedCard != null)
-                    yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddLinkCard(selectedCard, activateClass));
-
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -204,19 +225,15 @@ namespace DCGO.CardEffects.EX10
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
-                    {
-                        if (CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card))
-                        {
-                            return true;
-                        }
-                    }
-                    return false;
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
                 }
             }
+
             #endregion
 
             #region End Of Opponent's Turn
+
             if (timing == EffectTiming.OnEndTurn)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -229,20 +246,16 @@ namespace DCGO.CardEffects.EX10
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
-                    {
-                        if (CardEffectCommons.IsOpponentTurn(card))
-                        {
-                            return true;
-                        }
-                    }
-                    return false;
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card)
+                        && CardEffectCommons.IsOpponentTurn(card);
                 }
             }
+
             #endregion
 
             #region All Turns
-            if(timing == EffectTiming.OnLinkCardDiscarded)
+
+            if (timing == EffectTiming.OnLinkCardDiscarded)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Delete when trash", CanUseCondition, card);
@@ -254,7 +267,7 @@ namespace DCGO.CardEffects.EX10
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) && 
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
                         CardEffectCommons.CanTriggerOnTrashLinkedCard(hashtable, perm => perm == card.PermanentOfThisCard(), cardEffect => cardEffect != null, source => source != null);
                 }
 
@@ -298,7 +311,9 @@ namespace DCGO.CardEffects.EX10
                     }
                 }
             }
+
             #endregion
+
             return cardEffects;
         }
     }

Assets/CardEffect/EX10/Blue/EX10_012.cs

@@ -501,8 +501,8 @@ namespace DCGO.CardEffects.EX10
             if (timing == EffectTiming.SecuritySkill)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect($"Play 1 Level 5 or lower", CanUseCondition, card);
-                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetUpICardEffect($"Play 1 Level 5 or lower digimon with [Dark Masters] in text from hand or trash", CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDiscription());
                 activateClass.SetIsSecurityEffect(true);
                 cardEffects.Add(activateClass);
 
@@ -510,16 +510,114 @@ namespace DCGO.CardEffects.EX10
                 {
                     return "[Security] If this card was face-up, you may play 1 level 5 or lower card with [Dark Masters] in its text from your hand or trash without paying the cost.";
                 }
+
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerSecurityEffect(hashtable, card);
+                    return CardEffectCommons.CanTriggerSecurityEffect(hashtable, card)
+                        && (CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition) || CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
+                        && card.IsFlipped;
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    return cardSource.IsDigimon
+                        && cardSource.HasLevel && cardSource.Level <= 5
+                        && cardSource.HasText("Dark Masters");
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
+                    bool canSelectHand = CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition);
+                    bool canSelectTrash = CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition);
+
+                    if (canSelectHand || canSelectTrash)
+                    {
+                        if (canSelectHand && canSelectTrash)
+                        {
+                            List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                        {
+                            new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
+                        };
 
-                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.AddThisCardToHand(card, activateClass));
+                            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;
+                        }
+
+                        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 ContinuousController.instance.StartCoroutine(selectHandEffect.Activate());
+                        }
+                        else
+                        {
+                            SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                            selectCardEffect.SetUp(
+                                canTargetCondition: CanSelectCardCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                canNoSelect: () => true,
+                                selectCardCoroutine: SelectCardCoroutine,
+                                afterSelectCardCoroutine: null,
+                                message: "Select 1 card to add as source.",
+                                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 card to add as source.", "The opponent is selecting 1 card to add as source.");
+
+                            yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+                        }
+
+                        if (selectedCards.Any()) yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
+                                cardSources: selectedCards,
+                                activateClass: activateClass,
+                                payCost: false,
+                                isTapped: false,
+                                root: fromHand ? SelectCardEffect.Root.Hand : SelectCardEffect.Root.Trash,
+                                activateETB: true
+                        ));
+                    }
                 }
             }
 

Assets/CardEffect/EX10/Green/EX10_020.cs

@@ -12,6 +12,7 @@ namespace DCGO.CardEffects.EX10
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Hand - Main
+
             if (timing == EffectTiming.OnDeclaration)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -40,6 +41,7 @@ namespace DCGO.CardEffects.EX10
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
                     #region reduce play cost
+
                     if (card.Owner.CanReduceCost(null, card))
                         ContinuousController.instance.PlaySE(GManager.instance.GetComponent<Effects>().BuffSE);
 
@@ -77,7 +79,6 @@ namespace DCGO.CardEffects.EX10
                         {
                             return true;
                         }
-
                         else
                         {
                             if (targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0)
@@ -103,6 +104,7 @@ namespace DCGO.CardEffects.EX10
                     {
                         return true;
                     }
+
                     #endregion
 
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
@@ -114,6 +116,7 @@ namespace DCGO.CardEffects.EX10
                                             activateETB: true));
 
                     #region Delete Digimon Played
+
                     Permanent selectedPermanent = card.PermanentOfThisCard();
 
                     ActivateClass activateClass1 = new ActivateClass();
@@ -180,9 +183,11 @@ namespace DCGO.CardEffects.EX10
 
                         return null;
                     }
+
                     #endregion
                 }
             }
+
             #endregion
 
             #region On Play/When Attacking Shared
@@ -307,6 +312,7 @@ namespace DCGO.CardEffects.EX10
             #endregion
 
             #region All Turns
+
             if (timing == EffectTiming.None)
             {
                 bool Condition()
@@ -335,9 +341,11 @@ namespace DCGO.CardEffects.EX10
                 effectName: "[All Turns] This Digimon can only digivolve into [Apocalymon].")
                 );
             }
+
             #endregion
 
             #region On Deletion
+
             if (timing == EffectTiming.OnDestroyedAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -373,14 +381,16 @@ namespace DCGO.CardEffects.EX10
                     yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(card, false, true));
                 }
             }
+
             #endregion
 
             #region Security
+
             if (timing == EffectTiming.SecuritySkill)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect($"Play 1 Level 5 or lower", CanUseCondition, card);
-                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetUpICardEffect($"Play 1 Level 5 or lower digimon with [Dark Masters] in text from hand or trash", CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDiscription());
                 activateClass.SetIsSecurityEffect(true);
                 cardEffects.Add(activateClass);
 
@@ -388,18 +398,117 @@ namespace DCGO.CardEffects.EX10
                 {
                     return "[Security] If this card was face-up, you may play 1 level 5 or lower card with [Dark Masters] in its text from your hand or trash without paying the cost.";
                 }
+
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerSecurityEffect(hashtable, card);
+                    return CardEffectCommons.CanTriggerSecurityEffect(hashtable, card)
+                        && (CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition) || CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
+                        && card.IsFlipped;
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    return cardSource.IsDigimon
+                        && cardSource.HasLevel && cardSource.Level <= 5
+                        && cardSource.HasText("Dark Masters");
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
+                    bool canSelectHand = CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition);
+                    bool canSelectTrash = CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition);
+
+                    if (canSelectHand || canSelectTrash)
+                    {
+                        if (canSelectHand && canSelectTrash)
+                        {
+                            List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                        {
+                            new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
+                        };
+
+                            string selectPlayerMessage = "From which area do you 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;
+                        }
+
+                        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 ContinuousController.instance.StartCoroutine(selectHandEffect.Activate());
+                        }
+                        else
+                        {
+                            SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                            selectCardEffect.SetUp(
+                                canTargetCondition: CanSelectCardCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                canNoSelect: () => true,
+                                selectCardCoroutine: SelectCardCoroutine,
+                                afterSelectCardCoroutine: null,
+                                message: "Select 1 card to add as source.",
+                                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 card to add as source.", "The opponent is selecting 1 card to add as source.");
+
+                            yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+                        }
 
-                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.AddThisCardToHand(card, activateClass));
+                        if (selectedCards.Any()) yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
+                                cardSources: selectedCards,
+                                activateClass: activateClass,
+                                payCost: false,
+                                isTapped: false,
+                                root: fromHand ? SelectCardEffect.Root.Hand : SelectCardEffect.Root.Trash,
+                                activateETB: true
+                        ));
+                    }
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/EX10/Purple/EX10_057.cs

@@ -10,8 +10,10 @@ namespace DCGO.CardEffects.EX10
         public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
         {
             List<ICardEffect> cardEffects = new List<ICardEffect>();
+            ActivateClass deleteDigimonActivateClass = null;
 
             #region Hand - Main
+
             if (timing == EffectTiming.OnDeclaration)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -40,6 +42,7 @@ namespace DCGO.CardEffects.EX10
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
                     #region reduce play cost
+
                     if (card.Owner.CanReduceCost(null, card))
                         ContinuousController.instance.PlaySE(GManager.instance.GetComponent<Effects>().BuffSE);
 
@@ -77,7 +80,6 @@ namespace DCGO.CardEffects.EX10
                         {
                             return true;
                         }
-
                         else
                         {
                             if (targetPermanents.Count((targetPermanent) => targetPermanent != null) == 0)
@@ -103,6 +105,7 @@ namespace DCGO.CardEffects.EX10
                     {
                         return true;
                     }
+
                     #endregion
 
                     yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
@@ -114,13 +117,12 @@ namespace DCGO.CardEffects.EX10
                                             activateETB: true));
 
                     #region Delete Digimon Played
+
                     Permanent selectedPermanent = card.PermanentOfThisCard();
 
-                    ActivateClass activateClass1 = new ActivateClass();
-                    activateClass1.SetUpICardEffect("Delete this Digimon", CanUseCondition2, selectedPermanent.TopCard);
-                    activateClass1.SetUpActivateClass(CanActivateCondition1, ActivateCoroutine1, -1, false, EffectDiscription1());
-                    activateClass1.SetEffectSourcePermanent(selectedPermanent);
-                    selectedPermanent.UntilOwnerTurnEndEffects.Add(GetCardEffect);
+                    deleteDigimonActivateClass.SetUpICardEffect("Delete this Digimon", CanUseCondition2, selectedPermanent.TopCard);
+                    deleteDigimonActivateClass.SetUpActivateClass(CanActivateCondition1, ActivateCoroutine1, -1, false, EffectDiscription1());
+                    deleteDigimonActivateClass.SetEffectSourcePermanent(selectedPermanent);
 
                     if (!selectedPermanent.TopCard.CanNotBeAffected(activateClass))
                     {
@@ -134,27 +136,19 @@ namespace DCGO.CardEffects.EX10
 
                     bool CanUseCondition2(Hashtable hashtable1)
                     {
-                        if (CardEffectCommons.IsOpponentTurn(card))
-                        {
-                            if (CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(selectedPermanent, selectedPermanent.TopCard))
-                            {
-                                if (CardEffectCommons.CanTriggerOnEndAttack(hashtable1, selectedPermanent.TopCard))
-                                {
-                                    return true;
-                                }
-                            }
-                        }
-
-                        return false;
+                        return CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(selectedPermanent, selectedPermanent.TopCard);
                     }
 
                     bool CanActivateCondition1(Hashtable hashtable1)
                     {
                         if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent))
                         {
-                            if (!selectedPermanent.TopCard.CanNotBeAffected(activateClass))
+                            if (CardEffectCommons.IsOwnerTurn(selectedPermanent.TopCard))
                             {
-                                return true;
+                                if (!selectedPermanent.TopCard.CanNotBeAffected(activateClass))
+                                {
+                                    return true;
+                                }
                             }
                         }
 
@@ -167,22 +161,23 @@ namespace DCGO.CardEffects.EX10
                         {
                             yield return ContinuousController.instance.StartCoroutine(new DestroyPermanentsClass(
                             new List<Permanent>() { selectedPermanent },
-                            CardEffectCommons.CardEffectHashtable(activateClass1)).Destroy());
+                            CardEffectCommons.CardEffectHashtable(deleteDigimonActivateClass)).Destroy());
                         }
                     }
 
-                    ICardEffect GetCardEffect(EffectTiming _timing)
-                    {
-                        if (_timing == EffectTiming.OnEndTurn)
-                        {
-                            return activateClass1;
-                        }
-
-                        return null;
-                    }
                     #endregion
                 }
             }
+
+            #endregion
+
+            #region End of Turn (Only used if Hand - Main was activated)
+
+            if (timing == EffectTiming.OnEndTurn && deleteDigimonActivateClass != null)
+            {
+                cardEffects.Add(deleteDigimonActivateClass);
+            }
+
             #endregion
 
             #region On Play/When Attacking Shared
@@ -253,13 +248,13 @@ namespace DCGO.CardEffects.EX10
             if (timing == EffectTiming.OnAllyAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("1 Digimon and 1 Tamer cant suspend", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Delete 1 unsuspended Digimon", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateSharedCondition, ActivateCoroutine, -1, false, EffectDescription());
                 cardEffects.Add(activateClass);
 
                 string EffectDescription()
                 {
-                    return "[When Attacking] 1 of your opponent's Digimon and 1 of their Tamers can't suspend until their turn ends.";
+                    return "[When Attacking] Delete 1 of your opponent's unsuspended Digimon.";
                 }
 
                 bool CanUseCondition(Hashtable hashtable)
@@ -296,6 +291,7 @@ namespace DCGO.CardEffects.EX10
             #endregion
 
             #region All Turns
+
             if (timing == EffectTiming.None)
             {
                 bool Condition()
@@ -324,15 +320,16 @@ namespace DCGO.CardEffects.EX10
                 effectName: "[All Turns] This Digimon can only digivolve into [Apocalymon].")
                 );
             }
+
             #endregion
 
             #region On Deletion
+
             if (timing == EffectTiming.OnDestroyedAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Place this Digimon face up as bottom security, add top security to hand", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
-                activateClass.SetIsInheritedEffect(true);
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
@@ -340,7 +337,7 @@ namespace DCGO.CardEffects.EX10
                     return "[On Deletion] If you have no purple face-up security cards, place this Digimon face up as the bottom security card.";
                 }
 
-                bool FaceUpBlack(CardSource card)
+                bool FaceUpPurple(CardSource card)
                 {
                     return card.IsFlipped &&
                            card.CardColors.Contains(CardColor.Purple);
@@ -349,7 +346,7 @@ namespace DCGO.CardEffects.EX10
                 bool CanUseCondition(Hashtable hashtable)
                 {
                     return CardEffectCommons.CanTriggerOnDeletion(hashtable, card) &&
-                           !CardEffectCommons.HasMatchConditionOwnersSecurity(card, FaceUpBlack);
+                           !CardEffectCommons.HasMatchConditionOwnersSecurity(card, FaceUpPurple);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
@@ -362,14 +359,16 @@ namespace DCGO.CardEffects.EX10
                     yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(card, false, true));
                 }
             }
+
             #endregion
 
             #region Security
+
             if (timing == EffectTiming.SecuritySkill)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect($"Play 1 Level 5 or lower", CanUseCondition, card);
-                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, false, EffectDiscription());
+                activateClass.SetUpICardEffect($"Play 1 Level 5 or lower digimon with [Dark Masters] in text from hand or trash", CanUseCondition, card);
+                activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDiscription());
                 activateClass.SetIsSecurityEffect(true);
                 cardEffects.Add(activateClass);
 
@@ -377,18 +376,117 @@ namespace DCGO.CardEffects.EX10
                 {
                     return "[Security] If this card was face-up, you may play 1 level 5 or lower card with [Dark Masters] in its text from your hand or trash without paying the cost.";
                 }
+
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.CanTriggerSecurityEffect(hashtable, card);
+                    return CardEffectCommons.CanTriggerSecurityEffect(hashtable, card)
+                        && (CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition) || CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
+                        && card.IsFlipped;
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    return cardSource.IsDigimon
+                        && cardSource.HasLevel && cardSource.Level <= 5
+                        && cardSource.HasText("Dark Masters");
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable _hashtable)
                 {
-                    yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
+                    bool canSelectHand = CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition);
+                    bool canSelectTrash = CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition);
+
+                    if (canSelectHand || canSelectTrash)
+                    {
+                        if (canSelectHand && canSelectTrash)
+                        {
+                            List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                        {
+                            new SelectionElement<bool>(message: $"From hand", value : true, spriteIndex: 0),
+                            new SelectionElement<bool>(message: $"From trash", value : false, spriteIndex: 1),
+                        };
+
+                            string selectPlayerMessage = "From which area do you 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;
+                        }
 
-                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.AddThisCardToHand(card, activateClass));
+                        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 ContinuousController.instance.StartCoroutine(selectHandEffect.Activate());
+                        }
+                        else
+                        {
+                            SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+
+                            selectCardEffect.SetUp(
+                                canTargetCondition: CanSelectCardCondition,
+                                canTargetCondition_ByPreSelecetedList: null,
+                                canEndSelectCondition: null,
+                                canNoSelect: () => true,
+                                selectCardCoroutine: SelectCardCoroutine,
+                                afterSelectCardCoroutine: null,
+                                message: "Select 1 card to add as source.",
+                                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 card to add as source.", "The opponent is selecting 1 card to add as source.");
+
+                            yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+                        }
+
+                        if (selectedCards.Any()) yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
+                                cardSources: selectedCards,
+                                activateClass: activateClass,
+                                payCost: false,
+                                isTapped: false,
+                                root: fromHand ? SelectCardEffect.Root.Hand : SelectCardEffect.Root.Trash,
+                                activateETB: true
+                        ));
+                    }
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/EX10/Purple/EX10_060.cs

@@ -50,29 +50,35 @@ namespace DCGO.CardEffects.EX10
                         maxCount: maxCount,
                         canNoSelect: true,
                         canEndNotMax: false,
-                        selectPermanentCoroutine: null,
+                        selectPermanentCoroutine: SelectPermanentCoroutine,
                         afterSelectPermanentCoroutine: null,
-                        mode: SelectPermanentEffect.Mode.Destroy,
+                        mode: SelectPermanentEffect.Mode.Custom,
                         cardEffect: activateClass);
 
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    {
+                        selectedPermanent = permanent;
+                        yield return null;
+                    }
+
                     yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
                     #endregion
 
                     #region Attempt to delete selected permanent
 
-                    IEnumerator SuccessProcess(List<Permanent> deletedPermanents)
-                    {
-                        hasOpponentDeleted = true;
-                        yield return null;
-                    }
-
                     if (selectedPermanent != null) yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(
                         targetPermanents: new List<Permanent> { selectedPermanent },
                         activateClass: activateClass,
                         successProcess: SuccessProcess,
                         failureProcess: null));
 
+                    IEnumerator SuccessProcess(List<Permanent> deletedPermanents)
+                    {
+                        hasOpponentDeleted = true;
+                        yield return null;
+                    }
+
                     #endregion
 
                     if (!hasOpponentDeleted)

Assets/CardEffect/EX10/Purple/EX10_064.cs

@@ -12,6 +12,7 @@ namespace DCGO.CardEffects.EX10
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Name Change
+
             if (timing == EffectTiming.None)
             {
                 ChangeCardNamesClass changeCardNamesClass = new ChangeCardNamesClass();
@@ -59,9 +60,11 @@ namespace DCGO.CardEffects.EX10
                     return CardNames;
                 }
             }
+
             #endregion
 
             #region Start of Main Phase
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -89,13 +92,13 @@ namespace DCGO.CardEffects.EX10
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBreedingArea(card) &&
+                    return CardEffectCommons.IsExistOnBattleArea(card) &&
                            CardEffectCommons.IsOwnerTurn(card);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.IsExistOnBreedingArea(card) &&
+                    return CardEffectCommons.IsExistOnBattleArea(card) &&
                            (CardEffectCommons.HasMatchConditionOwnersHand(card, CanSelectCardCondition) ||
                            CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition));
                 }
@@ -217,9 +220,11 @@ namespace DCGO.CardEffects.EX10
                     }
                 }
             }
+
             #endregion
 
             #region All Turns
+
             if (timing == EffectTiming.BeforePayCost)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -338,13 +343,16 @@ namespace DCGO.CardEffects.EX10
                     }
                 }
             }
+
             #endregion
 
             #region Security
+
             if (timing == EffectTiming.SecuritySkill)
             {
                 cardEffects.Add(CardEffectFactory.PlaySelfTamerSecurityEffect(card));
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/EX10/Purple/EX10_065.cs

@@ -24,6 +24,8 @@ namespace DCGO.CardEffects.EX10
 
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
+                List<Permanent> playedPermanents = new List<Permanent>();
+
                 ActivateClass activateClass = new ActivateClass();
                 activateClass.SetUpICardEffect("Delete this tamer, give one of your played digimon Rush, then gain 1 memory", CanUseCondition, card);
                 activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
@@ -37,7 +39,7 @@ namespace DCGO.CardEffects.EX10
                 bool CanUseCondition(Hashtable hashtable)
                 {
                     return CardEffectCommons.IsExistOnField(card) &&
-                           CardEffectCommons.CanTriggerOnPermanentPlay(hashtable, PermamentCondition);
+                           CardEffectCommons.CanTriggerOnPermanentPlay(hashtable, CanTriggerCondition);
                 }
 
                 bool CanActivateCondition(Hashtable hashtable)
@@ -45,6 +47,16 @@ namespace DCGO.CardEffects.EX10
                     return CardEffectCommons.IsExistOnField(card);
                 }
 
+                bool CanTriggerCondition(Permanent permanent)
+                {
+                    if (PermamentCondition(permanent))
+                    {
+                        playedPermanents.Add(permanent);
+                        return true;
+                    }
+                    return false;
+                }
+
                 bool PermamentCondition(Permanent permanent)
                 {
                     return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
@@ -53,12 +65,6 @@ namespace DCGO.CardEffects.EX10
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
-                    List<Permanent> playedPermanents = null;
-                    foreach (Hashtable hash in CardEffectCommons.GetHashtablesFromHashtable(hashtable))
-                    {
-                        playedPermanents.Add(CardEffectCommons.GetPermanentFromHashtable(hash));
-                    }
-
                     if (playedPermanents != null)
                     {
                         yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(

Assets/CardEffect/EX10/Purple/EX10_067.cs

@@ -2,7 +2,8 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace DCGO.CardEffects
+// Ryoma Mogami
+namespace DCGO.CardEffects.EX10
 {
     public class EX10_067 : CEntity_Effect
     {
@@ -11,13 +12,16 @@ namespace DCGO.CardEffects
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Start of Your Turn
+
             if (timing == EffectTiming.OnStartTurn)
             {
                 cardEffects.Add(CardEffectFactory.SetMemoryTo3TamerEffect(card));
             }
+
             #endregion
 
             #region Your Turn
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -69,7 +73,7 @@ namespace DCGO.CardEffects
                     {
                         if (CardEffectCommons.CanActivateSuspendCostEffect(card))
                         {
-                            if(CardEffectCommons.HasMatchConditionPermanent(IsTamerHasSource))
+                            if (CardEffectCommons.HasMatchConditionPermanent(IsTamerHasSource))
                                 return true;
                         }
                     }
@@ -111,7 +115,7 @@ namespace DCGO.CardEffects
                         yield return null;
                     }
 
-                    if(selectedTamerPermanent != null)
+                    if (selectedTamerPermanent != null)
                     {
                         SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
 
@@ -145,7 +149,7 @@ namespace DCGO.CardEffects
                             yield return null;
                         }
 
-                        if(selectedSource.Count > 0)
+                        if (selectedSource.Count > 0)
                         {
                             List<Permanent> permanents = CardEffectCommons.GetPlayedPermanentsFromEnterFieldHashtable(
                                 hashtable: hashtable,
@@ -155,13 +159,16 @@ namespace DCGO.CardEffects
                     }
                 }
             }
+
             #endregion
 
             #region Security Effect
+
             if (timing == EffectTiming.SecuritySkill)
             {
                 cardEffects.Add(CardEffectFactory.PlaySelfTamerSecurityEffect(card));
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/EX10/Purple/EX10_071.cs

@@ -13,6 +13,7 @@ namespace DCGO.CardEffects.EX10
             List<ICardEffect> cardEffects = new List<ICardEffect>();
 
             #region Ignore Color Requirement
+
             if (timing == EffectTiming.None)
             {
                 IgnoreColorConditionClass ignoreColorConditionClass = new IgnoreColorConditionClass();
@@ -22,9 +23,9 @@ namespace DCGO.CardEffects.EX10
 
                 bool CanUseCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.HasMatchConditionPermanent((permanent) => 
+                    return CardEffectCommons.HasMatchConditionPermanent((permanent) =>
                            CardEffectCommons.IsOwnerPermanent(permanent, card) &&
-                           permanent.TopCard.ContainsCardName("Lucemon"),true);
+                           permanent.TopCard.ContainsCardName("Lucemon"), true);
                 }
 
                 bool CardCondition(CardSource cardSource)
@@ -32,9 +33,11 @@ namespace DCGO.CardEffects.EX10
                     return cardSource == card;
                 }
             }
+
             #endregion
 
             #region Main Effect
+
             if (timing == EffectTiming.OptionSkill)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -90,7 +93,7 @@ namespace DCGO.CardEffects.EX10
                             yield return null;
                         }
 
-                        if(selectedPermanent != null)
+                        if (selectedPermanent != null)
                         {
                             yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainRaid(
                                 targetPermanent: selectedPermanent,
@@ -116,9 +119,11 @@ namespace DCGO.CardEffects.EX10
                     }
                 }
             }
+
             #endregion
 
             #region End Of Your Turn
+
             if (timing == EffectTiming.OnEndTurn)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -199,36 +204,41 @@ namespace DCGO.CardEffects.EX10
 
                         if (selectedPermanent != null)
                         {
-                            SelectAttackEffect selectAttackEffect = GManager.instance.GetComponent<SelectAttackEffect>();
+                            if (selectedPermanent.CanAttack(activateClass, withoutTap: true))
+                            {
+                                SelectAttackEffect selectAttackEffect = GManager.instance.GetComponent<SelectAttackEffect>();
 
-                            selectAttackEffect.SetUp(
-                                attacker: card.PermanentOfThisCard(),
-                                canAttackPlayerCondition: () => true,
-                                defenderCondition: (permanent) => true,
-                                cardEffect: activateClass);
+                                selectAttackEffect.SetUp(
+                                    attacker: selectedPermanent,
+                                    canAttackPlayerCondition: () => true,
+                                    defenderCondition: (permanent) => true,
+                                    cardEffect: activateClass);
 
-                            selectAttackEffect.SetWithoutTap();
-                            selectAttackEffect.SetCanNotSelectNotAttack();
+                                selectAttackEffect.SetCanNotSelectNotAttack();
+                                selectAttackEffect.SetWithoutTap();
 
-                            yield return ContinuousController.instance.StartCoroutine(selectAttackEffect.Activate());
+                                yield return ContinuousController.instance.StartCoroutine(selectAttackEffect.Activate());
+                            }
                         }
                     }
                 }
             }
+
             #endregion
 
             #region Security
+
             if (timing == EffectTiming.SecuritySkill)
             {
                 ActivateClass activateClass = new ActivateClass();
-                activateClass.SetUpICardEffect("Play 1 Digimon from trash", CanUseCondition, card);
+                activateClass.SetUpICardEffect("Play 1 [Lucemon] from trash", CanUseCondition, card);
                 activateClass.SetUpActivateClass(null, ActivateCoroutine, -1, true, EffectDiscription());
                 activateClass.SetIsSecurityEffect(true);
                 cardEffects.Add(activateClass);
 
                 string EffectDiscription()
                 {
-                    return "[Security] You may play 1 [Lucemon] in its name from your trash without paying the cost.";
+                    return "[Security] You may play 1 [Lucemon] from your trash without paying the cost.";
                 }
 
                 bool CanSelectCardCondition(CardSource cardSource)
@@ -239,7 +249,7 @@ namespace DCGO.CardEffects.EX10
                         {
                             if (CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass))
                             {
-                                if (cardSource.ContainsCardName("Lucemon"))
+                                if (cardSource.EqualsCardName("Lucemon"))
                                 {
                                     return true;
                                 }
@@ -272,7 +282,7 @@ namespace DCGO.CardEffects.EX10
                                     canNoSelect: () => true,
                                     selectCardCoroutine: SelectCardCoroutine,
                                     afterSelectCardCoroutine: null,
-                                    message: "Select 1 card to play.",
+                                    message: "Select 1 [Lucemon] to play.",
                                     maxCount: maxCount,
                                     canEndNotMax: false,
                                     isShowOpponent: true,
@@ -283,10 +293,10 @@ namespace DCGO.CardEffects.EX10
                                     selectPlayer: card.Owner,
                                     cardEffect: activateClass);
 
-                        selectCardEffect.SetUpCustomMessage("Select 1 card to play.", "The opponent is selecting 1 card to play.");
-                        selectCardEffect.SetUpCustomMessage_ShowCard("Played Card");
+                        selectCardEffect.SetUpCustomMessage("Select 1 digimon to play.", "The opponent is selecting 1 digimon to play.");
+                        selectCardEffect.SetUpCustomMessage_ShowCard("Played Digimon");
 
-                        yield return StartCoroutine(selectCardEffect.Activate());
+                        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
 
                         IEnumerator SelectCardCoroutine(CardSource cardSource)
                         {
@@ -299,6 +309,7 @@ namespace DCGO.CardEffects.EX10
                     }
                 }
             }
+
             #endregion
 
             return cardEffects;

Assets/CardEffect/EX10/Purple/EX10_074.cs

@@ -33,10 +33,12 @@ namespace DCGO.CardEffects.EX10
             #endregion
 
             #region Blast Digivolve
+
             if (timing == EffectTiming.OnCounterTiming)
             {
                 cardEffects.Add(CardEffectFactory.BlastDigivolveEffect(card: card, condition: null));
             }
+
             #endregion
 
             #region Trash, then Delete effect
@@ -59,8 +61,8 @@ namespace DCGO.CardEffects.EX10
                 bool CanSelectPermanentCondition(Permanent permanent)
                 {
                     return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card) &&
-                           permanent.TopCard.HasPlayCost && 
-                           permanent.TopCard.GetCostItself <= 6 + (3 * Mathf.FloorToInt(card.Owner.TrashCards.Count/2));
+                           permanent.TopCard.HasPlayCost &&
+                           permanent.TopCard.GetCostItself <= 6 + (3 * Mathf.FloorToInt(card.Owner.TrashCards.Count / 2));
                 }
 
                 if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
@@ -85,6 +87,7 @@ namespace DCGO.CardEffects.EX10
             }
 
             #region On Play
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -98,9 +101,11 @@ namespace DCGO.CardEffects.EX10
                            CardEffectCommons.CanTriggerOnPlay(hashtable, card);
                 }
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -114,9 +119,11 @@ namespace DCGO.CardEffects.EX10
                            CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
                 }
             }
+
             #endregion
 
             #region When Attacking
+
             if (timing == EffectTiming.OnAllyAttack)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -130,11 +137,13 @@ namespace DCGO.CardEffects.EX10
                            CardEffectCommons.CanTriggerOnAttack(hashtable, card);
                 }
             }
+
             #endregion
 
             #endregion
 
             #region Return 2, De-Digivolve 2 effect
+
             string SecondEffectShortText() => "Return 2 cards to top of deck, <De-Digivolve 2>";
             string SecondEffectDiscription(string tag)
             {
@@ -150,7 +159,7 @@ namespace DCGO.CardEffects.EX10
             {
                 bool cardsAdded = false;
 
-                if(card.Owner.TrashCards.Count >= 10)
+                if (card.Owner.TrashCards.Count >= 10)
                 {
                     SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
 
@@ -183,10 +192,8 @@ namespace DCGO.CardEffects.EX10
                     {
                         if (cardSources.Count == 2)
                         {
-                            yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddLibraryBottomCards(cardSources));
-
+                            yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddLibraryTopCards(cardSources));
                             yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect(cardSources, "Deck Top Cards", true, true));
-
                             cardsAdded = true;
                         }
                     }
@@ -234,6 +241,7 @@ namespace DCGO.CardEffects.EX10
             }
 
             #region On Play
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -247,9 +255,11 @@ namespace DCGO.CardEffects.EX10
                            CardEffectCommons.CanTriggerOnPlay(hashtable, card);
                 }
             }
+
             #endregion
 
             #region When Digivolving
+
             if (timing == EffectTiming.OnEnterFieldAnyone)
             {
                 ActivateClass activateClass = new ActivateClass();
@@ -263,6 +273,7 @@ namespace DCGO.CardEffects.EX10
                            CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
                 }
             }
+
             #endregion
 
             #endregion