Merge pull request #169 from DCGO2/BT22-Eggs

BT22 Eggs

Assets/CardEffect/BT22/Black/BT22_005.cs

@@ -0,0 +1,53 @@
+using System.Collections;
+using System.Collections.Generic;
+
+// Tsumemon
+namespace DCGO.CardEffects.BT22
+{
+    public class BT22_005 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Draw 1", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+                activateClass.SetHashString("BT22_005_Draw1");
+                activateClass.SetIsInheritedEffect(true);
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[Your Turn] [Once Per Turn] When any of your Digimon with the [Unidentified] or [CS] trait are played, <Draw 1> (Draw 1 card from your deck.)";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnPermanentPlay(hashtable, PermanentCondition, null);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnField(card)
+                        && CardEffectCommons.IsOwnerTurn(card);
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
+                        && (permanent.TopCard.HasUnidentifiedTraits || permanent.TopCard.HasCSTraits);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
+                }
+            }
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/BT22/Black/BT22_005.cs.meta

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

Assets/CardEffect/BT22/Green/BT22_001.cs

@@ -0,0 +1,58 @@
+using System.Collections;
+using System.Collections.Generic;
+
+// Puyoyomon
+namespace DCGO.CardEffects.BT22
+{
+    public class BT22_001 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            if (timing == EffectTiming.OnAddDigivolutionCards)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Draw 1", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+                activateClass.SetHashString("BT22_001_Draw1");
+                activateClass.SetIsInheritedEffect(true);
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[Your Turn] [Once Per Turn] When effects place Digimon cards with [Aqua] or [Sea Animal] in any of their traits in this Digimon's digivolution cards, <Draw 1> (Draw 1 card from your deck.)";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnAddDigivolutionCard(hashtable, PermanentCondition, null, CardCondition);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnField(card)
+                        && CardEffectCommons.IsOwnerTurn(card);
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
+                        && card.TopCardPermanent() == permanent;
+                }
+
+                bool CardCondition(CardSource cardSource)
+                {
+                    return cardSource.IsDigimon && (cardSource.HasAquaTraits || cardSource.HasSeaAnimalTraits);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
+                }
+            }
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/BT22/Green/BT22_001.cs.meta

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

Assets/CardEffect/BT22/Purple/BT22_006.cs

@@ -0,0 +1,54 @@
+using System.Collections;
+using System.Collections.Generic;
+
+// Moonmon
+namespace DCGO.CardEffects.BT22
+{
+    public class BT22_006 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            if (timing == EffectTiming.OnAddDigivolutionCards)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Draw 1", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
+                activateClass.SetHashString("BT22_006_Draw1");
+                activateClass.SetIsInheritedEffect(true);
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[Your Turn] [Once Per Turn] When effects place this Digimon's top stacked card as its bottom digivolution card, <Draw 1> (Draw 1 card from your deck.) and trash 1 card in your hand.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnAddDigivolutionCard(hashtable, permanent => PermanentCondition(permanent), cardEffect => cardEffect.EffectSourceCard != null, null)
+                        && CardEffectCommons.IsFromDigimon(hashtable);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnField(card)
+                        && CardEffectCommons.IsOwnerTurn(card);
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
+                        && card.TopCardPermanent() == permanent;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
+                }
+            }
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/BT22/Purple/BT22_006.cs.meta

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

Assets/CardEffect/BT22/White/BT22_007.cs

@@ -0,0 +1,253 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+// Mother Eater
+namespace DCGO.CardEffects.BT22
+{
+    public class BT22_007 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Start of Main Phase
+
+            if (timing == EffectTiming.OnStartMainPhase)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Add [Mother Eater]s to top of stack. if 10 or more in digivolution source, play 3 [Mother Eater]s", null, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[Breeding] [Start of Your Main Phase] Look at your Digi-Egg deck's top card. Among them, you may place [Mother Eater]s as this Digimon's top digivolution cards. Then, if this Digimon has 10 or more digivolution cards, you may play 3 [Mother Eater]s from its digivolution cards without paying the costs.";
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBreedingAreaDigimon(card);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (card.Owner.DigitamaLibraryCards.Count >= 1)
+                    {
+                        CardSource topEggCard = card.Owner.DigitamaLibraryCards[0];
+                        bool AddToBreedingArea = false;
+
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().ShowCardEffect(new List<CardSource>() { topEggCard }, "Revealed Cards", true, true));
+                        if (topEggCard.EqualsCardName("Mother Eater"))
+                        {
+                            List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                            {
+                                new SelectionElement<bool>(message: $"Yes", value : true, spriteIndex: 0),
+                                new SelectionElement<bool>(message: $"No", value : false, spriteIndex: 1),
+                            };
+
+                            string selectPlayerMessage = "Place as top digivolution card?";
+                            string notSelectPlayerMessage = "The opponent is choosing to place as top digivolution card";
+
+                            GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                            AddToBreedingArea = GManager.instance.userSelectionManager.SelectedBoolValue;
+                        }
+
+                        if (AddToBreedingArea)
+                        {
+                            Permanent thisPermanent = card.PermanentOfThisCard();
+                            yield return ContinuousController.instance.StartCoroutine(thisPermanent.AddDigivolutionCardsTop(new List<CardSource>() { topEggCard }, activateClass));
+                        }
+                    }
+
+                    if (card.PermanentOfThisCard().DigivolutionCards.Count >= 10)
+                    {
+                        List<CardSource> motherEaterCards = card.PermanentOfThisCard().DigivolutionCards.Filter(cardSource => cardSource.EqualsCardName("Mother Eater"));
+                        if (motherEaterCards.Count >= 3 && motherEaterCards.TrueForAll(cardSource => CardEffectCommons.CanPlayAsNewPermanent(cardSource: cardSource, payCost: false, cardEffect: activateClass)))
+                        {
+                            bool playDigimon = false;
+
+                            List<SelectionElement<bool>> selectionElements = new List<SelectionElement<bool>>()
+                            {
+                                new SelectionElement<bool>(message: $"Yes", value : true, spriteIndex: 0),
+                                new SelectionElement<bool>(message: $"No", value : false, spriteIndex: 1),
+                            };
+
+                            string selectPlayerMessage = "Place as top digivolution card?";
+                            string notSelectPlayerMessage = "The opponent is choosing to place as top digivolution card";
+
+                            GManager.instance.userSelectionManager.SetBoolSelection(selectionElements: selectionElements, selectPlayer: card.Owner, selectPlayerMessage: selectPlayerMessage, notSelectPlayerMessage: notSelectPlayerMessage);
+                            yield return ContinuousController.instance.StartCoroutine(GManager.instance.userSelectionManager.WaitForEndSelect());
+
+                            playDigimon = GManager.instance.userSelectionManager.SelectedBoolValue;
+
+                            if (playDigimon)
+                            {
+                                yield return ContinuousController.instance.StartCoroutine(
+                                    CardEffectCommons.PlayPermanentCards(
+                                    cardSources: motherEaterCards,
+                                    activateClass: activateClass,
+                                    payCost: false,
+                                    isTapped: false,
+                                    root: SelectCardEffect.Root.DigivolutionCards,
+                                    activateETB: true));
+                            }
+                        }
+                    }
+                }
+            }
+
+            #endregion
+
+            #region All Turns
+
+            if (timing == EffectTiming.None)
+            {
+                string EffectDiscription()
+                {
+                    return "[Breeding] [All Turns] All of your [Mother Eater]s in the battle area are treated as having 16000 DP.";
+                }
+
+                bool Condition()
+                {
+                    return CardEffectCommons.IsExistOnBreedingAreaDigimon(card);
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnOwnerBattleArea(permanent, card))
+                    {
+                        if (permanent.TopCard.EqualsCardName("Mother Eater"))
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }
+
+                cardEffects.Add(CardEffectFactory.ChangeDPStaticEffect(
+                permanentCondition: PermanentCondition,
+                changeValue: 16000,
+                isInheritedEffect: false,
+                card: card,
+                condition: Condition,
+                effectName: EffectDiscription));
+            }
+
+            #endregion
+
+            #region On Play
+
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Delete 1 Digimon", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[On Play] Delete 1 of your opponent's Digimon.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnField(card)
+                        && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, CanSelectCondition);
+                }
+
+                bool CanSelectCondition(Permanent permanent)
+                    => CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionPermanent(CanSelectCondition))
+                    {
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionPermanentCount(CanSelectCondition));
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: CanSelectCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: null,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Destroy,
+                            cardEffect: activateClass);
+
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                    }
+                }
+            }
+
+            #endregion
+
+            #region All Turns - Remove Field
+
+            if (timing == EffectTiming.WhenRemoveField)
+            {
+                List<Permanent> removedPermanents = new List<Permanent>();
+
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Place card as source", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, true, EffectDiscription());
+                activateClass.SetHashString("BT22_007_Save");
+                activateClass.SetIsInheritedEffect(true);
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[Breeding] [All Turns] [Once Per Turn] When any of your [Eater] trait Digimon would leave the battle area other than by your effects, you may place them as this Digimon's bottom digivolution cards.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenPermanentRemoveField(hashtable, IsEaterDigimon)
+                        && !CardEffectCommons.IsByEffect(hashtable, cardEffect => CardEffectCommons.IsOwnerEffect(cardEffect, card));
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    removedPermanents = CardEffectCommons.GetPermanentsFromHashtable(hashtable).Filter(IsEaterDigimon);
+
+                    return CardEffectCommons.IsExistOnBreedingArea(card);
+                }
+
+                bool IsEaterDigimon(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
+                        && permanent.TopCard.HasEaterTraits;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    foreach (Permanent permanent in removedPermanents)
+                    {
+                        permanent.HideDeleteEffect();
+                        permanent.HideHandBounceEffect();
+                        permanent.HideDeckBounceEffect();
+                        permanent.HideWillRemoveFieldEffect();
+                        yield return ContinuousController.instance.StartCoroutine(card.PermanentOfThisCard().AddDigivolutionCardsBottom(new List<CardSource>() { permanent.TopCard }, activateClass));
+                    }
+                }
+            }
+
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/BT22/White/BT22_007.cs.meta

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

Assets/CardEffect/BT22/Yellow/BT22_002.cs

@@ -0,0 +1,53 @@
+using System.Collections;
+using System.Collections.Generic;
+
+// Kyaromon
+namespace DCGO.CardEffects.BT22
+{
+    public class BT22_002 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            if (timing == EffectTiming.OnDestroyedAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Draw 1", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+                activateClass.SetHashString("BT22_002_Draw1");
+                activateClass.SetIsInheritedEffect(true);
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[Your Turn] [Once Per Turn] When any of your Tokens or other [Puppet] trait Digimon are deleted, <Draw 1> (Draw 1 card from your deck.).";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnPermanentDeleted(hashtable, permanent => PermanentCondition(permanent));
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnField(card)
+                        && CardEffectCommons.IsOwnerTurn(card);
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return card.TopCardPermanent() != permanent
+                        && (permanent.IsToken || permanent.IsDigimon && permanent.TopCard.HasPuppetTraits);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(new DrawClass(card.Owner, 1, activateClass).Draw());
+                }
+            }
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/BT22/Yellow/BT22_002.cs.meta

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

Assets/CardEffect/BT22/Yellow/BT22_003.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+// Tapmon
+namespace DCGO.CardEffects.BT22
+{
+    public class BT22_003 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            if (timing == EffectTiming.WhenLinked)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("-2000 DP", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+                activateClass.SetHashString("BT22_003_DpMinus");
+                activateClass.SetIsInheritedEffect(true);
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[Your Turn] [Once Per Turn] When this Digimon gets linked, 1 of your opponent's Digimon gets -2000 DP for the turn.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenLinked(hashtable, permanent => PermanentCondition(permanent), null);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnField(card)
+                        && CardEffectCommons.IsOwnerTurn(card)
+                        && CardEffectCommons.HasMatchConditionOpponentsPermanent(card, OpponentCondition);
+                }
+
+                bool PermanentCondition(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card)
+                        && card.TopCardPermanent() == permanent;
+                }
+
+                bool OpponentCondition(Permanent permanent) => CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.HasMatchConditionOpponentsPermanent(card, OpponentCondition))
+                    {
+                        Permanent targetPermanent = null;
+                        int maxCount = Math.Min(1, CardEffectCommons.MatchConditionOpponentsPermanentCount(card, OpponentCondition));
+
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: OpponentCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: false,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: SelectPermanentCoroutine,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                        {
+                            targetPermanent = permanent;
+                            yield return null;
+                        }
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon to -2000 DP for the turn.", "Your opponent is selecting 1 Digimon to -2000 DP for the turn.");
+                        yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+
+                        if (targetPermanent != null) yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.ChangeDigimonDP(targetPermanent: targetPermanent, changeValue: -2000, effectDuration: EffectDuration.UntilEachTurnEnd, activateClass: activateClass));
+                    }
+                }
+            }
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/BT22/Yellow/BT22_003.cs.meta

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

Assets/Scripts/CardSource.cs

@@ -304,6 +304,16 @@ public class CardSource : MonoBehaviour
 
     #endregion
 
+    #region Top card of permanent in the field containing this card
+
+    public Permanent TopCardPermanent()
+    {
+        return Owner.GetFieldPermanents().Find(permanent =>
+            (permanent.cardSources.Contains(this)) && !IsFlipped).TopCard.PermanentOfThisCard();
+    }
+
+    #endregion
+
     #region initialize
 
     public void Init()
@@ -586,6 +596,7 @@ public class CardSource : MonoBehaviour
         #endregion
 
         #region Assembly
+
         if (!isEvolution)
         {
             if (HasAssembly)
@@ -609,7 +620,7 @@ public class CardSource : MonoBehaviour
                         {
                             if (selectAssemblyClass.playCard == this)
                             {
-                                if(selectAssemblyClass.selectedAssemblyCards.Count == assemblyCondition.elementCount)
+                                if (selectAssemblyClass.selectedAssemblyCards.Count == assemblyCondition.elementCount)
                                     Cost -= assemblyCondition.reduceCost;
                             }
                         }
@@ -617,6 +628,7 @@ public class CardSource : MonoBehaviour
                 }
             }
         }
+
         #endregion
 
         Cost = GetChangedCostItselef(Cost, root, targetPermanents, checkAvailability);
@@ -634,6 +646,7 @@ public class CardSource : MonoBehaviour
     #endregion
 
     #region base play cost from entity
+
     public int BasePlayCostFromEntity
     {
         get
@@ -641,6 +654,7 @@ public class CardSource : MonoBehaviour
             return _cEntity_Base.PlayCost;
         }
     }
+
     #endregion
 
     #region get card cost of itself (refered by card effects)
@@ -912,7 +926,7 @@ public class CardSource : MonoBehaviour
 
         return _EffectList;
     }
-    
+
     #endregion
 
     #region whether this card can declare skill
@@ -1980,6 +1994,7 @@ public class CardSource : MonoBehaviour
     #endregion
 
     #region card level checked when Assembly
+
     public List<int> Level_Assembly
     {
         get
@@ -1988,14 +2003,17 @@ public class CardSource : MonoBehaviour
             cardLevel_Assembly.Add(TreatedLevel);
 
             #region the effects of itself
+
             EffectList(EffectTiming.None)
                 .Filter(cardEffect => cardEffect is IChangeCardLevelForAssemblyEffect && cardEffect.CanUse(null))
                 .ForEach(cardEffect => cardLevel_Assembly = ((IChangeCardLevelForAssemblyEffect)cardEffect).ChangeCardLevelForAssembly(cardLevel_Assembly, this));
+
             #endregion
 
             return cardLevel_Assembly;
         }
     }
+
     #endregion
 
     #region whether this card has at least 1 card name checked when digixros that equals the string
@@ -2325,7 +2343,9 @@ public class CardSource : MonoBehaviour
     #endregion
 
     #region whether this card has [Assembly]
+
     public bool HasAssembly => assemblyCondition != null;
+
     #endregion
 
     #region traits
@@ -2653,7 +2673,7 @@ public class CardSource : MonoBehaviour
     {
         get
         {
-            if(_cEntity_Base == null || _cEntity_Base.HasLevel)
+            if (_cEntity_Base == null || _cEntity_Base.HasLevel)
             {
                 return true;
             }
@@ -2791,6 +2811,7 @@ public class CardSource : MonoBehaviour
     #endregion
 
     #region Assembly requirement
+
     public AssemblyCondition assemblyCondition
     {
         get
@@ -2814,6 +2835,7 @@ public class CardSource : MonoBehaviour
             return null;
         }
     }
+
     #endregion
 
     #region whether this card can Burst digivolve
@@ -3343,8 +3365,9 @@ public class CardSource : MonoBehaviour
         get
         {
             return EqualsTraits("WG");
-         }
+        }
     }
+
     #endregion
 
     #region whether this card has "DM" trait
@@ -3356,7 +3379,7 @@ public class CardSource : MonoBehaviour
             return EqualsTraits("DM");
         }
     }
-    
+
     #endregion
 
     #region whether this card has "CS" trait
@@ -3406,10 +3429,34 @@ public class CardSource : MonoBehaviour
     }
 
     #endregion
+
+    #region whether this card has "Sea Animal" trait
+
+    public bool HasSeaAnimalTraits
+    {
+        get
+        {
+            return EqualsTraits("Sea Animal");
+        }
+    }
+
+    #endregion
+
+    #region whether this card has "Puppet" trait
+
+    public bool HasPuppetTraits
+    {
+        get
+        {
+            return EqualsTraits("Puppet");
+        }
+    }
+
+    #endregion
 }
 
 public class JogressCondition
-  
+
 {
     public JogressCondition(JogressConditionElement[] elements, int cost)
     {
@@ -3549,6 +3596,7 @@ public class AssemblyCondition
         this.elementCount = elementCount;
         this.reduceCost = reduceCost;
     }
+
     public AssemblyConditionElement element { get; private set; } = new AssemblyConditionElement(null);
     public Func<List<CardSource>, CardSource, bool> CanTargetCondition_ByPreSelecetedList { get; private set; } = null;
 
@@ -3565,6 +3613,7 @@ public class AssemblyConditionElement
 
         this.skipAllIfNoSelect = skipAllIfNoSelect;
     }
+
     public Func<CardSource, bool> CardCondition { get; private set; } = null;
     public bool skipAllIfNoSelect { get; private set; } = false;
 }