Initial Creation of Partition keyword

Assets/Scripts/CardEffectCommons/KeyWordEffects/Partition.cs

@@ -0,0 +1,131 @@
+using System.Collections;
+using System.Collections.Generic;
+using System;
+using System.Linq;
+using UnityEngine;
+using static UnityEngine.UI.GridLayoutGroup;
+
+public partial class CardEffectCommons
+{
+    #region Can trigger [Partition]
+    public static bool CanTriggerPartition(Hashtable hashtable, CardSource card)
+    {
+        if (CanTriggerWhenPermanentRemoveField(hashtable, (permanent) => permanent.cardSources.Contains(card)))
+        {
+            if (!IsByBattle(hashtable))
+            {
+                if (!IsByEffect(hashtable, cardEffect => IsOwnerEffect(cardEffect, card)))
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+    #endregion
+
+    
+    #region Can activate [Partition]
+    public static bool CanActivatePartition(Permanent permanent)
+    {
+        if (IsPermanentExistsOnBattleArea(permanent))
+        {
+            if (permanent.DigivolutionCards.Count >= 1)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+    #endregion
+
+    #region Effect process of [Partition]
+    public static IEnumerator PartitionProcess(ICardEffect activateClass, Permanent permanent, Func<CardSource, bool> CanSelectCardCondition)
+    {
+        yield return ContinuousController.instance.StartCoroutine(new PartitionClass(permanent).Partition(activateClass, CanSelectCardCondition));
+    }
+    #endregion
+
+    #region Partition class
+    public class PartitionClass
+    {
+        public PartitionClass(Permanent permanent)
+        {
+            _permanent = permanent;
+        }
+
+        Permanent _permanent = null;
+
+
+        public IEnumerator Partition(ICardEffect activateClass, Func<CardSource, bool> CanSelectCardCondition)
+        {
+            if (_permanent != null)
+            {
+                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(_permanent));
+                CardSource topCard = _permanent.TopCard;
+
+                List<CardSource> selectedCards = new List<CardSource>();
+
+                if (_permanent.TopCard != null)
+                {
+
+                    //int maxCount = Math.Min(1, MatchConditionPermanentCount(CanSelectCardCondition));
+
+                    SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+                    selectCardEffect.SetUp(
+                            canTargetCondition: CanSelectCardCondition,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            canNoSelect: () => false,
+                            selectCardCoroutine: SelectCardCoroutine,
+                            afterSelectCardCoroutine: null,
+                            message: "Select card to play",
+                            maxCount: 1,
+                            canEndNotMax: false,
+                            isShowOpponent: false,
+                            mode: SelectCardEffect.Mode.Custom,
+                            root: SelectCardEffect.Root.DigivolutionCards,
+                            customRootCardList: _permanent.cardSources,
+                            canLookReverseCard: true,
+                            selectPlayer: topCard.Owner,
+                            cardEffect: activateClass);
+
+                    yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+                    IEnumerator SelectCardCoroutine(CardSource cardSource)
+                    {
+                        selectedCards.Add(cardSource);
+
+                        yield return null;
+                    }
+                }
+                
+                foreach(CardSource card in selectedCards)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.PlayPermanentCards(
+                        cardSources: new List<CardSource>() { card },
+                        activateClass: activateClass,
+                        payCost: false,
+                        isTapped: false,
+                        root: SelectCardEffect.Root.Trash,
+                        activateETB: true));
+                }
+
+                #region Play Log
+                string log = "";
+
+                log += $"\nPartition :";
+
+                log += $"\n{topCard.BaseENGCardNameFromEntity}({topCard.CardID})";
+
+                log += "\n";
+
+                GManager.instance.playLog.AddLogString(log);
+                #endregion
+            }
+        }
+    }
+    #endregion
+}

Assets/Scripts/CardEffectCommons/KeyWordEffects/Partition.cs.meta

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

Assets/Scripts/CardEffectFactory/KeyWordEffects/Partition.cs

@@ -0,0 +1,67 @@
+using System.Collections;
+using System.Collections.Generic;
+using System;
+using System.Linq;
+using UnityEngine;
+
+public partial class CardEffectFactory
+{
+    #region Trigger effect of [Partition] on oneself
+    public static ActivateClass PartitionSelfEffect(bool isInheritedEffect, CardSource card, Func<bool> condition, Func<CardSource, bool> canSelectPermanentCondition)
+    {
+        Permanent targetPermanent = card.PermanentOfThisCard();
+
+        bool CanUseCondition()
+        {
+            if (condition == null || condition())
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        return PartitionEffect(targetPermanent: targetPermanent, isInheritedEffect: isInheritedEffect, condition: CanUseCondition, cardCondition: canSelectPermanentCondition, card);
+    }
+    #endregion
+
+    #region Trigger effect of [Partition]
+    public static ActivateClass PartitionEffect(Permanent targetPermanent, bool isInheritedEffect, Func<bool> condition, Func<CardSource, bool> cardCondition, CardSource card)
+    {
+        if (targetPermanent == null) return null;
+        if (targetPermanent.TopCard == null) return null;
+        if (card == null) return null;
+
+        ActivateClass activateClass = new ActivateClass();
+        activateClass.SetUpICardEffect("Partition", CanUseCondition, card);
+        activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, DataBase.PartitionEffectDiscription());
+        activateClass.SetHashString($"Partition_{card.CardID}" + (isInheritedEffect ? "_inherited" : ""));
+        activateClass.SetIsInheritedEffect(isInheritedEffect);
+
+        bool CanUseCondition(Hashtable hashtable)
+        {
+            if (CardEffectCommons.CanTriggerFortitude(hashtable, card))
+            {
+                if (condition == null || condition())
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        bool CanActivateCondition(Hashtable hashtable)
+        {
+            return CardEffectCommons.CanActivatePartition(targetPermanent);
+        }
+
+        IEnumerator ActivateCoroutine(Hashtable _hashtable)
+        {
+            return CardEffectCommons.PartitionProcess(activateClass, targetPermanent, cardCondition);
+        }
+
+        return activateClass;
+    }
+    #endregion
+}

Assets/Scripts/CardEffectFactory/KeyWordEffects/Partition.cs.meta

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

Assets/Scripts/DataBase.cs

@@ -501,6 +501,11 @@ public class DataBase : MonoBehaviour
         return "<Alliance> (When this Digimon attacks, by suspending 1 of your other Digimon, this Digimon adds the suspended Digimon's DP and gains <Security Attack +1> for the attack.)";
     }
 
+    public static string PartitionEffectDiscription()
+    {
+        return "<Partition> (When this Digimon with 1 of each specified card in its digivolution cards would leave the battle area other than by one of your effects or in battle, you may play 1 of each card without paying their costs)";
+    }
+
     public static string ReplaceToASCII(string text)
     {
         if (string.IsNullOrEmpty(text))