Rework Collision Top be static effect instead of activated

Assets/Scripts/Script/AttackProcess.cs

@@ -352,7 +352,7 @@ public class AttackProcess : MonoBehaviourPunCallbacks
                 canTargetCondition_ByPreSelecetedList: null,
                 canEndSelectCondition: null,
                 maxCount: maxCount,
-                canNoSelect: (!IsBlocking),
+                canNoSelect: !AttackingPermanent.HasCollision,
                 canEndNotMax: false,
                 selectPermanentCoroutine: SelectPermanentCoroutine,
                 afterSelectPermanentCoroutine: null,

Assets/Scripts/Script/CardEffectCommons/KeyWordEffects/Collision.cs

@@ -34,7 +34,7 @@ public partial class CardEffectCommons
             return false;
         }
 
-        ActivateClass collision = CardEffectFactory.CollisionSelfStaticEffect(false, targetPermanent.TopCard, CanUseCondition);
+        CollisionClass collision = CardEffectFactory.CollisionSelfStaticEffect(false, targetPermanent.TopCard, CanUseCondition);
 
         AddEffectToPermanent(targetPermanent: targetPermanent, effectDuration: effectDuration, card: card, cardEffect: collision, timing: EffectTiming.OnCounterTiming);
 
@@ -44,38 +44,4 @@ public partial class CardEffectCommons
         }
     }
     #endregion
-
-    #region Can activate [Collision]
-    public static bool CanActivateCollision(CardSource cardSource)
-    {
-        return IsExistOnBattleArea(cardSource) &&
-               cardSource.Owner.Enemy.GetBattleAreaDigimons().Count >= 1 &&
-               GManager.instance.attackProcess.IsAttacking &&
-               GManager.instance.attackProcess.AttackingPermanent == cardSource.PermanentOfThisCard();
-    }
-    #endregion
-
-    #region Effect process of [Collision]
-    public static IEnumerator CollisionProcess(CardSource cardSource, ICardEffect activateClass, Func<IEnumerator> beforeOnAttackCoroutine = null)
-    {
-        List<Permanent> enemyDigimons = cardSource.Owner.Enemy.GetBattleAreaDigimons();
-
-        if (CanActivateCollision(cardSource))
-        {
-            foreach (Permanent enemyDigimon in enemyDigimons)
-            {
-                if (enemyDigimon.TopCard.CanNotBeAffected(activateClass))
-                    continue;
-
-                yield return ContinuousController.instance.StartCoroutine(GainBlocker(
-                        targetPermanent: enemyDigimon,
-                        effectDuration: EffectDuration.UntilEndAttack,
-                        activateClass: activateClass));
-            }
-
-            if (HasMatchConditionOpponentsPermanent(cardSource, permanent => permanent.HasBlocker))
-                GManager.instance.attackProcess.IsBlocking = true;
-        }
-    }
-    #endregion
 }

Assets/Scripts/Script/CardEffectFactory/KeyWordEffects/Collision.cs

@@ -7,10 +7,8 @@ using UnityEngine;
 public partial class CardEffectFactory
 {
     #region Static effect of [Collision] on oneself
-    public static ActivateClass CollisionSelfStaticEffect(bool isInheritedEffect, CardSource card, Func<bool> condition)
+    public static CollisionClass CollisionSelfStaticEffect(bool isInheritedEffect, CardSource card, Func<bool> condition)
     {
-        Permanent targetPermanent = card.PermanentOfThisCard();
-
         bool PermanentCondition(Permanent permanent) => permanent == card.PermanentOfThisCard();
 
         bool CanUseCondition()
@@ -40,21 +38,16 @@ public partial class CardEffectFactory
     #endregion
 
     #region Static effect of [Collision]
-    public static ActivateClass CollisionStaticEffect(
+    public static CollisionClass CollisionStaticEffect(
         Func<Permanent, bool> permanentCondition,
         bool isInheritedEffect,
         CardSource card,
         Func<bool> condition)
     {
-        ActivateClass activateClass = new ActivateClass();
-        activateClass.SetUpICardEffect("Collision", CanUseCondition, card);
-        activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
-        activateClass.SetIsInheritedEffect(isInheritedEffect);
-
-        string EffectDiscription()
-        {
-            return DataBase.CollisionEffectDiscription();
-        }
+        CollisionClass collisionClass = new ();
+        collisionClass.SetUpICardEffect("Collision", CanUseCondition, card);
+        collisionClass.SetUpCollisionClass(PermanentCondition);
+        collisionClass.SetIsInheritedEffect(isInheritedEffect);
 
         bool PermanentCondition(Permanent permanent)
         {
@@ -80,17 +73,7 @@ public partial class CardEffectFactory
             return false;
         }
 
-        bool CanActivateCondition(Hashtable hashtable)
-        {
-            return true;
-        }
-
-        IEnumerator ActivateCoroutine(Hashtable _hashtable)
-        {
-            return CardEffectCommons.CollisionProcess(card, activateClass);
-        }
-
-        return activateClass;
+        return collisionClass;
     }
     #endregion
 }

Assets/Scripts/Script/CardEffectInterfaces.cs

@@ -529,4 +529,11 @@ public interface IOptionResolutionEffect
     bool CanResolve(CardSource optionCard);
     IEnumerator Resolve(CardSource optionCard);
 }
+#endregion
+
+#region Collision
+public interface ICollisionEffect
+{
+    bool HasCollision(Permanent permanent);
+}
 #endregion

Assets/Scripts/Script/CardEffects/CollisionClass.cs

@@ -0,0 +1,30 @@
+using System;
+
+public class CollisionClass : ICardEffect, ICollisionEffect
+{
+    public void SetUpCollisionClass(Func<Permanent, bool> PermanentCondition)
+    {
+        this.PermanentCondition = PermanentCondition;
+    }
+
+    Func<Permanent, bool> PermanentCondition { get; set; }
+
+    public bool HasCollision(Permanent permanent)
+    {
+        if (PermanentCondition != null)
+        {
+            if (permanent != null)
+            {
+                if (permanent.TopCard != null)
+                {
+                    if (PermanentCondition(permanent))
+                    {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+}

Assets/Scripts/Script/Permanent.cs

@@ -2373,6 +2373,20 @@ public class Permanent
     {
         get
         {
+            #region if attacking digimon has collision
+            if (GManager.instance.attackProcess.ActiveAttack())
+            {
+                Permanent attackingPermanent = GManager.instance.attackProcess.AttackingPermanent;
+
+                if (attackingPermanent != null
+                    && attackingPermanent.TopCard.Owner != TopCard.Owner
+                    && attackingPermanent.HasCollision)
+                {
+                    return true;
+                }
+            }
+            #endregion
+
             foreach (Player player in GManager.instance.turnStateMachine.gameContext.Players_ForTurnPlayer)
             {
                 #region Effects of permanents in play
@@ -2954,15 +2968,64 @@ public class Permanent
     {
         get
         {
-            foreach (ICardEffect cardEffect in this.EffectList(EffectTiming.OnAllyAttack))
+            foreach (Player player in GManager.instance.turnStateMachine.gameContext.Players_ForTurnPlayer)
             {
-                if (cardEffect is ActivateICardEffect)
+                foreach (Permanent permanent in player.GetFieldPermanents())
                 {
-                    if (cardEffect.EffectName == "Collision")
+                    #region Permanent Effects
+                    foreach (ICardEffect cardEffect in permanent.EffectList(EffectTiming.OnCounterTiming))
                     {
-                        return true;
+                        if (cardEffect is ICollisionEffect)
+                        {
+                            if (cardEffect.CanTrigger(null))
+                            {
+                                if (((ICollisionEffect)cardEffect).HasCollision(this))
+                                {
+                                    return true;
+                                }
+                            }
+                        }
                     }
+                    #endregion
                 }
+
+                #region Effects of faceup security
+                foreach (CardSource source in player.SecurityCards)
+                {
+                    if (source.IsFlipped)
+                        continue;
+
+                    foreach (ICardEffect cardEffect in source.EffectList(EffectTiming.OnCounterTiming))
+                    {
+                        if (cardEffect is ICollisionEffect)
+                        {
+                            if (cardEffect.CanTrigger(null))
+                            {
+                                if (((ICollisionEffect)cardEffect).HasCollision(this))
+                                {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                }
+                #endregion
+
+                #region Player Effects
+                foreach (ICardEffect cardEffect in player.EffectList(EffectTiming.OnCounterTiming))
+                {
+                    if (cardEffect is ICollisionEffect)
+                    {
+                        if (cardEffect.CanTrigger(null))
+                        {
+                            if (((ICollisionEffect)cardEffect).HasCollision(this))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                }
+                #endregion
             }
 
             return false;