Checkpoint

Assets/CardBaseEntity/BT2/Blue/Digimon/BT2_024_P1.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:37826777c3cf7a60e0d11a4ee65b47521353e7cf57263611e66d1053353d8280
-size 1143
+oid sha256:4cf48ae739ae3c4eb54b55653180e3d6f823afe4400fc1761250e423408213f8
+size 1140

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

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:dbb66167a6ccc04920573e765b4be18bfaa72599da2f277d91322df6a3b5f92e
-size 1188
+oid sha256:255233010ea7ef3505f09001a4945e0dea124f6b83d35abd7575f815d0f3188e
+size 1200

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

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:82d8a983c81a70614cf792d6b87e59b1f1a98ba1c2eccb4a0b3685ee84594d28
-size 1188
+oid sha256:3215df855c6b8dd5ff38609a45b176f4d6d6ba1df4b1c7f023dcf1fcc95a7aff
+size 1200

Assets/CardBaseEntity/ST12/Red/Digimon/ST12_03_P1.asset

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6c08b570d7a862549f72a15ae42ca8f28e501505069d51ca9592c58762f8e286
+oid sha256:18e93ecd8d702cb195fcdceda36191a9544843df9bf3739c8a375d7bd3845d49
 size 1091

Assets/CardEffect/BT1/Red/BT1_010.cs

@@ -1,10 +1,5 @@
 using System.Collections;
 using System.Collections.Generic;
-using UnityEngine;
-using System.Linq;
-using Photon;
-using System;
-using Photon.Pun;
 
 public class BT1_010 : CEntity_Effect
 {
@@ -69,4 +64,4 @@ public class BT1_010 : CEntity_Effect
 
         return cardEffects;
     }
-}
+}

Assets/CardEffect/BT17/Yellow/BT17_098.cs

@@ -144,10 +144,13 @@ namespace DCGO.CardEffects.BT17
                                     {
                                         if (permanent.DigivolutionCards.Count >= 1)
                                         {
+                                            if (permanent.TopCard.IsACE) yield return ContinuousController.instance.StartCoroutine(new AceOverflowClass(new List<CardSource> { permanent.TopCard }).Overflow());
+
                                             yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddSecurityCard(permanent.TopCard));
 
                                             yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateRecoveryEffect(permanent.TopCard.Owner));
 
+
                                             yield return ContinuousController.instance.StartCoroutine(new IAddSecurity(permanent.TopCard.Owner).AddSecurity());
 
                                             permanent.willBeRemoveField = false;

Assets/CardEffect/BT18/Black/BT18_072.cs

@@ -198,6 +198,30 @@ namespace DCGO.CardEffects.BT18
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
                 {
+                    int degenrationMaxCount = 2;
+                    int degenrationCount = 0;
+
+                    SelectCountEffect selectCountEffect = GManager.instance.GetComponent<SelectCountEffect>();
+                    if (selectCountEffect != null)
+                    {
+                        selectCountEffect.SetUp(
+                            SelectPlayer: card.Owner,
+                            targetPermanent: null,
+                            MaxCount: degenrationMaxCount,
+                            CanNoSelect: false,
+                            Message: "How much will you De-Digivolve?",
+                            Message_Enemy: "The opponent is choosing how much to De-Digivolve.",
+                            SelectCountCoroutine: SelectCountCoroutine);
+
+                        yield return ContinuousController.instance.StartCoroutine(selectCountEffect.Activate());
+
+                        IEnumerator SelectCountCoroutine(int count)
+                        {
+                            degenrationCount = count;
+                            yield return null;
+                        }
+                    }
+
                     SelectPermanentEffect selectPermanentEffect =
                         GManager.instance.GetComponent<SelectPermanentEffect>();
 
@@ -216,14 +240,14 @@ namespace DCGO.CardEffects.BT18
                         mode: SelectPermanentEffect.Mode.Custom,
                         cardEffect: activateClass);
 
-                    selectPermanentEffect.SetUpCustomMessage("Select 2 Digimon to De-Digivolve 2.",
-                        "The opponent is selecting 2 Digimon to De-Digivolve 2.");
+                    selectPermanentEffect.SetUpCustomMessage("Select Digimons to De-Digivolve",
+                        "The opponent is selecting Digimons to De-Digivolve");
                     yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
 
                     IEnumerator SelectPermanentCoroutine(Permanent permanent)
                     {
                         yield return ContinuousController.instance.StartCoroutine(
-                            new IDegeneration(permanent, 2, activateClass).Degeneration());
+                            new IDegeneration(permanent, degenrationCount, activateClass, true).Degeneration());
                     }
                 }
             }

Assets/CardEffect/BT18/Green/BT18_052.cs

@@ -140,7 +140,7 @@ namespace DCGO.CardEffects.BT18
 
                     IEnumerator DeDigivolvePermanent(Permanent permanent)
                     {
-                        yield return ContinuousController.instance.StartCoroutine(new IDegeneration(permanent, maxCount, activateClass).Degeneration());
+                        yield return ContinuousController.instance.StartCoroutine(new IDegeneration(permanent, maxCount, activateClass, true).Degeneration());
                     }
                 }
             }

Assets/CardEffect/BT18/Yellow/BT18_042.cs

@@ -97,6 +97,7 @@ namespace DCGO.CardEffects.BT18
 
                     IEnumerator SelectCardCoroutine(CardSource cardSource)
                     {
+                        if (cardSource.IsACE) yield return ContinuousController.instance.StartCoroutine(new AceOverflowClass(new List<CardSource> { cardSource }).Overflow());
                         yield return ContinuousController.instance.StartCoroutine(
                             CardObjectController.AddSecurityCard(cardSource, toTop: false));
 
@@ -178,6 +179,7 @@ namespace DCGO.CardEffects.BT18
 
                     IEnumerator SelectCardCoroutine(CardSource cardSource)
                     {
+                        if (cardSource.IsACE) yield return ContinuousController.instance.StartCoroutine(new AceOverflowClass(new List<CardSource> { cardSource }).Overflow());
                         yield return ContinuousController.instance.StartCoroutine(
                             CardObjectController.AddSecurityCard(cardSource, toTop: false));
 

Assets/CardEffect/BT19/Red/BT19_011.cs

@@ -250,7 +250,8 @@ namespace DCGO.CardEffects.BT19
 
                     if (card.Owner.CanAddMemory(activateClass))
                     {
-                        yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(destroyTargetPermanents.Count, activateClass));
+                        var memoryGain = destroyTargetPermanents.Count - destroyTargetPermanents.Filter(x => CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(x, card)).Count;
+                        if (memoryGain > 0) yield return ContinuousController.instance.StartCoroutine(card.Owner.AddMemory(memoryGain, activateClass));
                     }
                 }
             }

Assets/CardEffect/BT2/Black/BT2_066.cs

@@ -68,6 +68,30 @@ public class BT2_066 : CEntity_Effect
                     {
                         if (CardEffectCommons.HasMatchConditionPermanent(CanSelectPermanentCondition))
                         {
+                            int degenrationMaxCount = 2;
+                            int degenrationCount = 0;
+
+                            SelectCountEffect selectCountEffect = GManager.instance.GetComponent<SelectCountEffect>();
+                            if (selectCountEffect != null)
+                            {
+                                selectCountEffect.SetUp(
+                                    SelectPlayer: card.Owner,
+                                    targetPermanent: null,
+                                    MaxCount: degenrationMaxCount,
+                                    CanNoSelect: false,
+                                    Message: "How much will you De-Digivolve?",
+                                    Message_Enemy: "The opponent is choosing how much to De-Digivolve.",
+                                    SelectCountCoroutine: SelectCountCoroutine);
+
+                                yield return ContinuousController.instance.StartCoroutine(selectCountEffect.Activate());
+
+                                IEnumerator SelectCountCoroutine(int count)
+                                {
+                                    degenrationCount = count;
+                                    yield return null;
+                                }
+                            }
+
                             int maxCount = Math.Min(2, CardEffectCommons.MatchConditionPermanentCount(CanSelectPermanentCondition));
 
                             SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
@@ -106,7 +130,7 @@ public class BT2_066 : CEntity_Effect
 
                                 if (selectedPermanent != null)
                                 {
-                                    yield return ContinuousController.instance.StartCoroutine(new IDegeneration(selectedPermanent, 2, activateClass).Degeneration());
+                                    yield return ContinuousController.instance.StartCoroutine(new IDegeneration(selectedPermanent, degenrationCount, activateClass).Degeneration());
                                 }
 
                                 yield return null;

Assets/CardEffect/EX8/Black/EX8_052.cs

@@ -192,8 +192,7 @@ namespace DCGO.CardEffects.EX8
 
                 bool CanActivateCondition(Hashtable hashtable)
                 {
-                    return CardEffectCommons.HasMatchConditionPermanent(OpponentsDigimon) &&
-                           CardEffectCommons.HasMatchConditionPermanent(IsOptionCard);
+                    return CardEffectCommons.HasMatchConditionPermanent(IsOptionCard);
                 }
 
                 IEnumerator ActivateCoroutine(Hashtable hashtable)
@@ -236,27 +235,30 @@ namespace DCGO.CardEffects.EX8
 
                         IEnumerator SuccessProcess()
                         {
-                            SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
-
-                            selectPermanentEffect.SetUp(
-                                selectPlayer: card.Owner,
-                                canTargetCondition: OpponentsDigimon,
-                                canTargetCondition_ByPreSelecetedList: null,
-                                canEndSelectCondition: null,
-                                maxCount: 1,
-                                canNoSelect: false,
-                                canEndNotMax: false,
-                                selectPermanentCoroutine: SelectPermanentCoroutine,
-                                afterSelectPermanentCoroutine: null,
-                                mode: SelectPermanentEffect.Mode.Custom,
-                                cardEffect: activateClass);
-
-                            selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to De-Digivolve.", "The opponent is selecting 1 Digimon to De-Digivolve.");
-                            yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
-
-                            IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                            if (CardEffectCommons.HasMatchConditionPermanent(OpponentsDigimon))
                             {
-                                yield return ContinuousController.instance.StartCoroutine(new IDegeneration(permanent, 2, activateClass).Degeneration());
+                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                                selectPermanentEffect.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: OpponentsDigimon,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: 1,
+                                    canNoSelect: false,
+                                    canEndNotMax: false,
+                                    selectPermanentCoroutine: SelectPermanentCoroutine,
+                                    afterSelectPermanentCoroutine: null,
+                                    mode: SelectPermanentEffect.Mode.Custom,
+                                    cardEffect: activateClass);
+
+                                selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to De-Digivolve.", "The opponent is selecting 1 Digimon to De-Digivolve.");
+                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                                IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                                {
+                                    yield return ContinuousController.instance.StartCoroutine(new IDegeneration(permanent, 2, activateClass).Degeneration());
+                                }
                             }
                         }
                     }

Assets/CardEffect/EX8/Blue/EX8_029.cs

@@ -361,7 +361,7 @@ namespace DCGO.CardEffects.EX8
             if (timing == EffectTiming.None)
             {
                 DisableEffectClass invalidationClass = new DisableEffectClass();
-                invalidationClass.SetUpICardEffect("Ignore [When Digivolving] Effect", CanUseCondition, card);
+                invalidationClass.SetUpICardEffect("[On Plays] can't activate", CanUseCondition, card);
                 invalidationClass.SetUpDisableEffectClass(DisableCondition: InvalidateCondition);
                 cardEffects.Add(invalidationClass);
 

Assets/CardEffect/EX8/Yellow/EX8_033.cs

@@ -280,6 +280,15 @@ namespace DCGO.CardEffects.EX8
                     {
                         if (CardEffectCommons.HasMatchConditionOwnersCardInTrash(card, CanSelectCardCondition))
                         {
+                            CardSource selectedCard = null;
+
+                            IEnumerator SelectCardCoroutine(CardSource cardSource)
+                            {
+                                selectedCard = cardSource;
+
+                                yield return null;
+                            }
+
                             int maxCount = Math.Min(1, card.Owner.TrashCards.Count(CanSelectCardCondition));
 
                             SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
@@ -290,19 +299,37 @@ namespace DCGO.CardEffects.EX8
                                 canEndSelectCondition: null,
                                 canNoSelect: () => false,
                                 selectCardCoroutine: null,
-                                afterSelectCardCoroutine: null,
+                                afterSelectCardCoroutine: AfterSelectCardCoroutine,
                                 message: "Select 1 card to add to your hand.",
                                 maxCount: maxCount,
                                 canEndNotMax: false,
                                 isShowOpponent: true,
-                                mode: SelectCardEffect.Mode.AddHand,
-                                root: SelectCardEffect.Root.Trash,
-                                customRootCardList: null,
+                                mode: SelectCardEffect.Mode.Custom,
+                                root: SelectCardEffect.Root.Custom,
+                                customRootCardList: card.Owner.TrashCards,
                                 canLookReverseCard: true,
                                 selectPlayer: card.Owner,
                                 cardEffect: activateClass);
 
                             yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                            IEnumerator AfterSelectCardCoroutine(List<CardSource> cardSources)
+                            {
+                                if (cardSources.Count == 1)
+                                {
+                                    var card = cardSources[0];
+                                    var message = card.IsDigiEgg ? "Sent Digi-Egg to egg deck" : "Sent Card to Hand";
+                                    if (card.IsDigiEgg)
+                                    {
+                                        yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddLibraryBottomCards(cardSources));
+                                    }
+                                    else
+                                    {
+                                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.AddThisCardToHand(selectedCard, activateClass));
+                                    }
+                                    yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect(cardSources, message, true, true));
+                                }
+                            }
                         }
                     }
                 }

Assets/CardEffect/P/Blue/P_042.cs

@@ -0,0 +1,70 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace DCGO.CardEffects
+{
+    public class P_042 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            if (timing == EffectTiming.None)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Reveal top 5 cards of deck", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[On Play] Reveal the top 5 cards of your deck. Add 1 Tamer card among them to your hand. Place the cards at the bottom of your deck in any order.";
+                }
+
+                bool CanSelectCardCondition(CardSource cardSource)
+                {
+                    return cardSource.IsTamer;
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleArea(card))
+                    {
+                        if (card.Owner.LibraryCards.Count >= 1)
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable _hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.SimplifiedRevealDeckTopCardsAndSelect(
+                        revealCount: 5,
+                        simplifiedSelectCardConditions:
+                        new SimplifiedSelectCardConditionClass[]
+                        {
+                        new SimplifiedSelectCardConditionClass(
+                            canTargetCondition:CanSelectCardCondition,
+                            message: "Select 1 Tamer card.",
+                            mode: SelectCardEffect.Mode.Custom,
+                            maxCount: 1,
+                            selectCardCoroutine: null),
+                        },
+                        remainingCardsPlace: RemainingCardsPlace.DeckBottom,
+                        activateClass: activateClass
+                    ));
+                }
+            }
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/P/Blue/P_042.cs.meta

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

Assets/Scripts/CardController.cs

@@ -3666,16 +3666,25 @@ public class IBattle
 #region De-digivolve
 public class IDegeneration
 {
-    public IDegeneration(Permanent permanent, int DegenerationCount, ICardEffect cardEffect)
+    /// <summary>
+    /// De-Digivolve Class
+    /// </summary>
+    /// <param name="permanent">Target Permanent</param>
+    /// <param name="DegenerationCount">De-Digivolve Amount</param>
+    /// <param name="cardEffect">Card Effect</param>
+    /// <param name="DegenerationCountRuling">Should we enforce rule to select De-digivolve amount before digimon, disabled by default</param>
+    public IDegeneration(Permanent permanent, int DegenerationCount, ICardEffect cardEffect, bool? DegenerationCountRuling = null)
     {
         _permanent = permanent;
         _degenerationCount = DegenerationCount;
         _cardEffect = cardEffect;
+        _degenerationCountRuling = DegenerationCountRuling;
     }
 
     Permanent _permanent = null;
-    int _degenerationCount = 0;
+    int _degenerationCount;
     ICardEffect _cardEffect = null;
+    bool? _degenerationCountRuling;
 
     public IEnumerator Degeneration()
     {
@@ -3690,7 +3699,7 @@ public class IDegeneration
 
         SelectCountEffect selectCountEffect = GManager.instance.GetComponent<SelectCountEffect>();
 
-        if (selectCountEffect != null)
+        if (selectCountEffect != null && _degenerationCountRuling == null)
         {
             Player selectPlayer = _cardEffect.EffectSourceCard.Owner;
 

Assets/Scripts/CardEffectCommons/MinMax_DP_Cost_Level/Cost/IsMaxCost.cs

@@ -1,9 +1,5 @@
-using System.Collections;
-using System.Collections.Generic;
-using System;
 using System.Linq;
-using UnityEngine;
-using System.Security;
+
 
 public partial class CardEffectCommons
 {
@@ -16,22 +12,23 @@ public partial class CardEffectCommons
         if (!permanent.IsDigimon && !permanent.IsTamer) return false;
         if (!permanent.TopCard.HasPlayCost) return false;
 
-        List<Permanent> permanents = permanent.TopCard.Owner.GetBattleAreaPermanents();
-        List<int> costs = new List<int>();
-
         if (IsDigimonOnly)
         {
-            costs = permanent.TopCard.Owner.GetBattleAreaPermanents().Filter(permanent1 =>
-                permanent1.IsDigimon && permanent1.TopCard.HasPlayCost)
-                .Map(permanent1 => permanent1.TopCard.GetCostItself);
+            if (!permanent.IsDigimon) return false;
+            var costs = permanent.TopCard.Owner.GetBattleAreaDigimons()
+                .Filter(x => x.TopCard.HasPlayCost)
+                .Select(x => x.TopCard.GetCostItself).ToList();
+
+            return costs.Count >= 1 && permanent.TopCard.GetCostItself == costs.Max();
+
         }
         else
         {
-            costs = permanent.TopCard.Owner.GetBattleAreaPermanents().Filter(permanent1 =>
-                (permanent1.IsDigimon || permanent1.IsTamer) && permanent1.TopCard.HasPlayCost)
-                .Map(permanent1 => permanent1.TopCard.GetCostItself);
-        }
+            var costs = permanent.TopCard.Owner.GetBattleAreaPermanents()
+                .Filter(x => (x.IsDigimon || x.IsTamer) && x.TopCard.HasPlayCost)
+                .Select(x => x.TopCard.GetCostItself).ToList();
 
-        return costs.Count >= 1 && permanent.TopCard.GetCostItself == costs.Max();
+            return costs.Count >= 1 && permanent.TopCard.GetCostItself == costs.Max();
+        }
     }
 }

Assets/Scripts/CardEffectCommons/MinMax_DP_Cost_Level/Cost/IsMinCost.cs

@@ -1,9 +1,5 @@
-using System.Collections;
-using System.Collections.Generic;
 using System;
 using System.Linq;
-using UnityEngine;
-using System.Security;
 
 public partial class CardEffectCommons
 {
@@ -17,24 +13,21 @@ public partial class CardEffectCommons
         if (condition != null && !condition(permanent)) return false;
         if (!permanent.TopCard.HasPlayCost) return false;
 
-        List<Permanent> permanents = permanent.TopCard.Owner.GetBattleAreaPermanents();
-        List<int> costs = new List<int>();
-
         if (IsDigimonOnly)
         {
-            costs = permanents
-                .Filter(permanent1 => condition == null || (condition != null && condition(permanent1)))
-                .Filter(permanent1 => permanent1.IsDigimon && permanent1.TopCard.HasPlayCost)
-                .Map(permanent1 => permanent1.TopCard.GetCostItself);
+            if (!permanent.IsDigimon) return false;
+            var costs = permanent.TopCard.Owner.GetBattleAreaDigimons()
+                .Filter(x => x.TopCard.HasPlayCost)
+                .Select(x => x.TopCard.GetCostItself).ToList();
+
+            return costs.Count >= 1 && permanent.TopCard.GetCostItself == costs.Min();
         }
         else
         {
-            costs = permanents
-                .Filter(permanent1 => condition == null || (condition != null && condition(permanent1)))
-                .Filter(permanent1 => (permanent1.IsDigimon || permanent1.IsTamer) && permanent1.TopCard.HasPlayCost)
-                .Map(permanent1 => permanent1.TopCard.GetCostItself);
+            var costs = permanent.TopCard.Owner.GetBattleAreaPermanents()
+                 .Filter(x => (x.IsDigimon || x.IsTamer) && x.TopCard.HasPlayCost)
+                 .Select(x => x.TopCard.GetCostItself).ToList();
+            return costs.Count >= 1 && permanent.TopCard.GetCostItself == costs.Min();
         }
-
-        return costs.Count >= 1 && permanent.TopCard.GetCostItself == costs.Min();
     }
 }