added progress keyword

Assets/Scripts/CardEffectCommons/KeyWordEffects/Progress.cs

@@ -0,0 +1,113 @@
+using System.Collections;
+using System.Collections.Generic;
+using System;
+using System.Linq;
+using UnityEngine;
+
+public partial class CardEffectCommons
+{
+    #region Target 1 Digimon gains [Progress]
+    public static IEnumerator GainProgress(Permanent targetPermanent, EffectDuration effectDuration, ICardEffect activateClass)
+    {
+        if (targetPermanent == null) yield break;
+        if (!IsPermanentExistsOnBattleArea(targetPermanent)) yield break;
+        if (activateClass == null) yield break;
+        if (activateClass.EffectSourceCard == null) yield break;
+
+        CardSource card = activateClass.EffectSourceCard;
+
+        bool PermanentCondition(Permanent permanent) => permanent == targetPermanent;
+
+        bool CanUseCondition()
+        {
+            if (IsPermanentExistsOnBattleArea(targetPermanent))
+            {
+                if (!targetPermanent.TopCard.CanNotBeAffected(activateClass))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        ActivateClass progress = CardEffectFactory.ProgressStaticEffect(permanentCondition: PermanentCondition, isInheritedEffect: false, card: card, condition: CanUseCondition);
+
+        AddEffectToPermanent(targetPermanent: targetPermanent, effectDuration: effectDuration, card: card, cardEffect: progress, timing: EffectTiming.OnAllyAttack);
+
+        if (!targetPermanent.TopCard.CanNotBeAffected(activateClass))
+        {
+            yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateBuffEffect(targetPermanent));
+        }
+    }
+    #endregion
+
+    #region Can activate [Progress]
+    public static bool CanActivateProgress(CardSource cardSource)
+    {
+        if (IsExistOnBattleArea(cardSource))
+        {
+            if (GManager.instance.attackProcess.IsAttacking)
+            {
+                if (GManager.instance.attackProcess.AttackingPermanent == cardSource.PermanentOfThisCard())
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+    #endregion
+
+    #region Effect process of [Progress]
+    public static IEnumerator ProgressProcess(CardSource cardSource, ICardEffect activateClass, Func<IEnumerator> beforeOnAttackCoroutine = null)
+    {
+        Permanent selectedPermanent = cardSource.PermanentOfThisCard();
+
+        if (CanActivateProgress(cardSource))
+        {
+            CanNotAffectedClass canNotAffectedClass = new CanNotAffectedClass();
+            canNotAffectedClass.SetUpICardEffect("Isn't affected by opponent's Digimon's effect", CanUseCondition1, cardSource);
+            canNotAffectedClass.SetUpCanNotAffectedClass(CardCondition: CardCondition, SkillCondition: SkillCondition);
+            selectedPermanent.UntilEndAttackEffects.Add((_timing) => canNotAffectedClass);
+
+            yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateBuffEffect(selectedPermanent));
+
+            bool CanUseCondition1(Hashtable hashtable)
+            {
+                return CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent);
+            }
+
+            bool CardCondition(CardSource cardSource)
+            {
+                if (CardEffectCommons.IsPermanentExistsOnBattleArea(selectedPermanent))
+                {
+                    if (cardSource == selectedPermanent.TopCard)
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            bool SkillCondition(ICardEffect cardEffect)
+            {
+                if (cardEffect != null)
+                {
+                    if (cardEffect.EffectSourceCard != null)
+                    {
+                        if (IsOpponentEffect(cardEffect,cardSource))
+                        {
+                            return true;
+                        }
+                    }
+                }
+
+                return false;
+            }
+        }
+    }
+    #endregion
+}

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

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

Assets/Scripts/CardEffectFactory/KeyWordEffects/Progress.cs

@@ -0,0 +1,93 @@
+using System.Collections;
+using System.Collections.Generic;
+using System;
+using System.Linq;
+using UnityEngine;
+
+public partial class CardEffectFactory
+{
+    #region Static effect of [Progress] on oneself
+    public static ActivateClass ProgressSelfStaticEffect(bool isInheritedEffect, CardSource card, Func<bool> condition)
+    {
+        Permanent targetPermanent = card.PermanentOfThisCard();
+
+        bool PermanentCondition(Permanent permanent) => permanent == card.PermanentOfThisCard();
+
+        bool CanUseCondition()
+        {
+            if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+            {
+                if (GManager.instance.attackProcess.IsAttacking)
+                {
+                    if (GManager.instance.attackProcess.AttackingPermanent == card.PermanentOfThisCard())
+                    {
+                        if (condition == null || condition())
+                        {
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        return ProgressStaticEffect(permanentCondition: PermanentCondition, isInheritedEffect: isInheritedEffect, card: card, condition: CanUseCondition);
+    }
+    #endregion
+
+    #region Static effect of [Progress]
+    public static ActivateClass ProgressStaticEffect(
+        Func<Permanent, bool> permanentCondition,
+        bool isInheritedEffect,
+        CardSource card,
+        Func<bool> condition)
+    {
+        ActivateClass activateClass = new ActivateClass();
+        activateClass.SetUpICardEffect("Progress", CanUseCondition, card);
+        activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+        activateClass.SetIsInheritedEffect(isInheritedEffect);
+
+        string EffectDiscription()
+        {
+            return DataBase.ProgressEffectDiscription();
+        }
+
+        bool PermanentCondition(Permanent permanent)
+        {
+            if (CardEffectCommons.IsPermanentExistsOnBattleArea(permanent))
+            {
+                if (permanentCondition == null || permanentCondition(permanent))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        bool CanUseCondition(Hashtable hashtable)
+        {
+            if (condition == null || condition())
+            {
+                if(PermanentCondition(card.PermanentOfThisCard()))
+                    return true;
+            }
+
+            return false;
+        }
+
+        bool CanActivateCondition(Hashtable hashtable)
+        {
+            return true;
+        }
+
+        IEnumerator ActivateCoroutine(Hashtable _hashtable)
+        {
+            return CardEffectCommons.ProgressProcess(card, activateClass);
+        }
+
+        return activateClass;
+    }
+    #endregion
+}

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

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

Assets/Scripts/DataBase.cs

@@ -557,6 +557,11 @@ public class DataBase : MonoBehaviour
         return "<Execute> (At the end of your turn, this Digimon may attack. At the end of that attack, delete this Digimon. Your opponent's unsuspended Digimon can also be attacked with this effect.)";
     }
 
+    public static string ProgressEffectDiscription()
+    {
+        return "<Progress> (While attacking, your opponent's effects don't affect this Digimon.)";
+    }
+
     public static string ReplaceToASCII(string text)
     {
         if (string.IsNullOrEmpty(text))