lordknightmon X and moonmillenniummon

Assets/CardEffect/BT19/Purple/LordKnightmonXAntibody_BT19_073.cs

@@ -0,0 +1,243 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DCGO.CardEffects.BT19
+{
+    public class LordKnightmonXAntibody_BT19_073 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Alternate Digivolution Requirement
+            if (timing == EffectTiming.None)
+            {
+                static bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.EqualsCardName("LordKnightmon");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 1, ignoreDigivolutionRequirement: false, card: card, condition: null));
+            }
+            #endregion
+
+            #region Collision/Piercing
+            if (timing == EffectTiming.OnCounterTiming)
+            {
+                cardEffects.Add(CardEffectFactory.CollisionSelfStaticEffect(false, card, null));
+            }
+
+            if (timing == EffectTiming.OnDetermineDoSecurityCheck)
+            {
+                cardEffects.Add(CardEffectFactory.PierceSelfEffect(isInheritedEffect: false, card: card, condition: null));
+            }
+            #endregion
+
+            #region When Digivolving
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("<De-Digivolve 1> 1 of your opponent's Digimon for each of your Digimon", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] <De-Digivolve 1> 1 of your opponent's Digimon for each of your Digimon. Then, 1 of your opponent's Digimon can't digivolve until the end of their turn.";
+                }
+
+                bool IsOpponenetsDigimon(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOpponentBattleAreaDigimon(permanent, card);
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    if (CardEffectCommons.IsExistOnBattleAreaDigimon(card))
+                        return card.Owner.GetBattleAreaDigimons().Count > 0;
+
+                    return false;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    int maxCount = card.Owner.GetBattleAreaDigimons().Count;
+
+                    SelectPermanentEffect selectDeDigivolvePermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    for (int i = 0; i < maxCount; i++)
+                    {
+                        selectDeDigivolvePermanentEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: IsOpponenetsDigimon,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: 1,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: DeDigivolvePermanent,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Custom,
+                        cardEffect: activateClass);
+
+                        yield return ContinuousController.instance.StartCoroutine(selectDeDigivolvePermanentEffect.Activate());
+                    }
+
+                    IEnumerator DeDigivolvePermanent(Permanent permanent)
+                    {
+                        yield return ContinuousController.instance.StartCoroutine(new IDegeneration(permanent, 1, activateClass).Degeneration());
+                    }
+
+                    SelectPermanentEffect selectCannotEvoEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                    selectCannotEvoEffect.SetUp(
+                        selectPlayer: card.Owner,
+                        canTargetCondition: IsOpponenetsDigimon,
+                        canTargetCondition_ByPreSelecetedList: null,
+                        canEndSelectCondition: null,
+                        maxCount: maxCount,
+                        canNoSelect: false,
+                        canEndNotMax: false,
+                        selectPermanentCoroutine: SelectPermanentCoroutine,
+                        afterSelectPermanentCoroutine: null,
+                        mode: SelectPermanentEffect.Mode.Custom,
+                        cardEffect: activateClass);
+
+                    selectCannotEvoEffect.SetUpCustomMessage("Select 1 Digimon can not digivolve.", "The opponent is selecting 1 Digimon can not digivolve.");
+
+                    yield return ContinuousController.instance.StartCoroutine(selectCannotEvoEffect.Activate());
+
+                    IEnumerator SelectPermanentCoroutine(Permanent permanent)
+                    {
+                        Permanent selectedPermanent = permanent;
+
+                        CanNotDigivolveClass canNotPutFieldClass = new CanNotDigivolveClass();
+                        canNotPutFieldClass.SetUpICardEffect("Can't Digivolve", CanUseCondition1, card);
+                        canNotPutFieldClass.SetUpCanNotEvolveClass(permanentCondition: PermanentCondition, cardCondition: CardCondition);
+                        selectedPermanent.UntilOwnerTurnEndEffects.Add(GetCardEffect);
+
+                        ContinuousController.instance.PlaySE(GManager.instance.GetComponent<Effects>().DebuffSE);
+
+                        yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateDebuffEffect(selectedPermanent));
+
+                        bool CanUseCondition1(Hashtable hashtable)
+                        {
+                            return true;
+                        }
+
+                        bool PermanentCondition(Permanent permanent)
+                        {
+                            if (permanent == selectedPermanent)
+                            {
+                                if (permanent.TopCard != null)
+                                {
+                                    if (permanent.IsDigimon || permanent.IsTamer)
+                                    {
+                                        if (!permanent.TopCard.CanNotBeAffected(canNotPutFieldClass))
+                                        {
+                                            return true;
+                                        }
+                                    }
+                                }
+                            }
+
+                            return false;
+                        }
+
+                        bool CardCondition(CardSource cardSource)
+                        {
+
+                            if (cardSource.Owner == card.Owner.Enemy)
+                            {
+                                if (cardSource.IsDigimon || cardSource.IsTamer)
+                                {
+                                    if (!cardSource.CanNotBeAffected(canNotPutFieldClass))
+                                    {
+                                        return true;
+                                    }
+                                }
+                            }
+
+                            return false;
+
+                        }
+
+                        ICardEffect GetCardEffect(EffectTiming _timing)
+                        {
+                            if (_timing == EffectTiming.None)
+                            {
+                                return canNotPutFieldClass;
+                            }
+
+                            return null;
+                        }
+
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.GainCantUnsuspendUntilOpponentTurnEnd(
+                                    targetPermanent: selectedPermanent,
+                                    activateClass: activateClass
+                                ));
+
+                    }
+                }
+            }
+            #endregion
+
+            #region All Turns
+            if (timing == EffectTiming.None)
+            {
+                string EffectName()
+                {
+                    return "+3000 DP";
+                }
+                bool PermanentCondition(Permanent permanent)
+                {
+                    if (CardEffectCommons.IsPermanentExistsOnBattleArea(permanent))
+                    {
+                        if (permanent.IsDigimon)
+                        {
+                            if (permanent.TopCard.HasText("Knightmon"))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+
+                    return false;
+                }
+
+                bool HasKnighmonOrXAntibody(CardSource source)
+                {
+                    return source.EqualsCardName("X Antibody") || source.EqualsCardName("Knightmon");
+                }
+
+                bool CanUseCondition()
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
+                           card.PermanentOfThisCard().DigivolutionCards.Count(HasKnighmonOrXAntibody) > 0;
+                }
+
+                cardEffects.Add(CardEffectFactory.AllianceStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    isInheritedEffect: false,
+                    card: card, condition: CanUseCondition));
+
+                cardEffects.Add(CardEffectFactory.ChangeDPStaticEffect(
+                    permanentCondition: PermanentCondition,
+                    changeValue: 3000,
+                    isInheritedEffect: false,
+                    card: card, 
+                    condition: CanUseCondition,
+                    effectName: EffectName));
+            }
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/BT19/Purple/LordKnightmonXAntibody_BT19_073.cs.meta

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

Assets/CardEffect/BT19/Purple/MoonMillenniummon_BT19_075.cs

@@ -0,0 +1,345 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace DCGO.CardEffects.BT19
+{
+    public class MoonMillenniummon_BT19_075 : CEntity_Effect
+    {
+        public override List<ICardEffect> CardEffects(EffectTiming timing, CardSource card)
+        {
+            List<ICardEffect> cardEffects = new List<ICardEffect>();
+
+            #region Alternate Digivolution Requirement
+            if (timing == EffectTiming.None)
+            {
+                static bool PermanentCondition(Permanent targetPermanent)
+                {
+                    return targetPermanent.TopCard.EqualsCardName("Millenniummon");
+                }
+
+                cardEffects.Add(CardEffectFactory.AddSelfDigivolutionRequirementStaticEffect(permanentCondition: PermanentCondition, digivolutionCost: 2, ignoreDigivolutionRequirement: false, card: card, condition: null));
+            }
+            #endregion
+
+            #region On Play/When Digivolving Shared
+            bool CardTrashed(CardSource source)
+            {
+                return true;
+            }
+
+            bool IsTamer(Permanent permanent)
+            {
+                return CardEffectCommons.IsPermanentExistsOnOpponentBattleArea(permanent, card) &&
+                       permanent.IsTamer;
+            }
+            #endregion
+
+            #region On Play
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Your opponent trashes cards in their hand so that 5 remain", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[On Play] Your opponent trashes cards in their hand so that 5 remain. For every 2 trashed by this effect, delete 1 of their Tamers.";
+                }               
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerOnPlay(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    List<CardSource> trashed = new List<CardSource>();
+
+                    if(card.Owner.Enemy.HandCards.Count > 5)
+                    {
+                        int maxCount = card.Owner.Enemy.HandCards.Count - 5;
+
+                        SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                        selectHandEffect.SetUp(
+                            selectPlayer: card.Owner.Enemy,
+                            canTargetCondition: CardTrashed,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            isShowOpponent: true,
+                            selectCardCoroutine: null,
+                            afterSelectCardCoroutine: AllSelectedCards,
+                            mode: SelectHandEffect.Mode.Discard,
+                            cardEffect: activateClass);
+
+                        selectHandEffect.SetUpCustomMessage($"Select {maxCount} card(s) to trash.", $"The opponent is selecting {maxCount} card(s) to trash.");
+
+                        yield return StartCoroutine(selectHandEffect.Activate());
+
+                        IEnumerator AllSelectedCards(List<CardSource> sources)
+                        {
+                            trashed = sources;
+                            yield return null;
+                        }
+
+                        if(trashed.Count > 2)
+                        {
+                            if (CardEffectCommons.HasMatchConditionPermanent(IsTamer))
+                            {
+                                int maxDeletes = Math.Min(Mathf.FloorToInt(trashed.Count/2), CardEffectCommons.MatchConditionPermanentCount(IsTamer));
+
+                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                                selectPermanentEffect.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: IsTamer,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: maxDeletes,
+                                    canNoSelect: false,
+                                    canEndNotMax: false,
+                                    selectPermanentCoroutine: null,
+                                    afterSelectPermanentCoroutine: null,
+                                    mode: SelectPermanentEffect.Mode.Destroy,
+                                    cardEffect: activateClass);
+
+                                selectPermanentEffect.SetUpCustomMessage($"Select {maxDeletes} Tamer(s) to delete.", $"The opponent is selecting {maxDeletes} Tamer(s) to delete.");
+
+                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                            }
+                        }
+                    }
+                }
+            }
+            #endregion
+
+            #region When Digivolving
+            if (timing == EffectTiming.OnEnterFieldAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Your opponent trashes cards in their hand so that 5 remain", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, false, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[When Digivolving] Your opponent trashes cards in their hand so that 5 remain. For every 2 trashed by this effect, delete 1 of their Tamers.";
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
+                           CardEffectCommons.CanTriggerWhenDigivolving(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    List<CardSource> trashed = new List<CardSource>();
+
+                    if (card.Owner.Enemy.HandCards.Count > 5)
+                    {
+                        int maxCount = card.Owner.Enemy.HandCards.Count - 5;
+
+                        SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();
+
+                        selectHandEffect.SetUp(
+                            selectPlayer: card.Owner.Enemy,
+                            canTargetCondition: CardTrashed,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: maxCount,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            isShowOpponent: true,
+                            selectCardCoroutine: null,
+                            afterSelectCardCoroutine: AllSelectedCards,
+                            mode: SelectHandEffect.Mode.Discard,
+                            cardEffect: activateClass);
+
+                        selectHandEffect.SetUpCustomMessage($"Select {maxCount} card(s) to trash.", $"The opponent is selecting {maxCount} card(s) to trash.");
+
+                        yield return StartCoroutine(selectHandEffect.Activate());
+
+                        IEnumerator AllSelectedCards(List<CardSource> sources)
+                        {
+                            trashed = sources;
+                            yield return null;
+                        }
+
+                        if (trashed.Count > 2)
+                        {
+                            if (CardEffectCommons.HasMatchConditionPermanent(IsTamer))
+                            {
+                                int maxDeletes = Math.Min(Mathf.FloorToInt(trashed.Count / 2), CardEffectCommons.MatchConditionPermanentCount(IsTamer));
+
+                                SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                                selectPermanentEffect.SetUp(
+                                    selectPlayer: card.Owner,
+                                    canTargetCondition: IsTamer,
+                                    canTargetCondition_ByPreSelecetedList: null,
+                                    canEndSelectCondition: null,
+                                    maxCount: maxDeletes,
+                                    canNoSelect: false,
+                                    canEndNotMax: false,
+                                    selectPermanentCoroutine: null,
+                                    afterSelectPermanentCoroutine: null,
+                                    mode: SelectPermanentEffect.Mode.Destroy,
+                                    cardEffect: activateClass);
+
+                                selectPermanentEffect.SetUpCustomMessage($"Select {maxDeletes} Tamer(s) to delete.", $"The opponent is selecting {maxDeletes} Tamer(s) to delete.");
+
+                                yield return ContinuousController.instance.StartCoroutine(selectPermanentEffect.Activate());
+                            }
+                        }
+                    }
+                }
+            }
+            #endregion
+
+            #region All Turns
+            if (timing == EffectTiming.WhenRemoveField)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Delete [Composite] trait digimon to prevent removal", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDiscription());
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[All Turns] When this Digimon would leave the battle area, by deleting 1 of your Digimon with the [Composite] trait, it doesn't leave.";
+                }
+
+                bool HasCompositeTrait(Permanent permanent)
+                {
+                    return CardEffectCommons.IsPermanentExistsOnOwnerBattleAreaDigimon(permanent, card) &&
+                           permanent.TopCard.EqualsTraits("Composite");                           
+                           
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.CanTriggerWhenRemoveField(hashtable, card);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
+                           CardEffectCommons.HasMatchConditionOwnersPermanent(card, HasCompositeTrait);
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    bool deleted = false;
+                    Permanent selectedPermanent = card.PermanentOfThisCard();
+
+                    if (CardEffectCommons.HasMatchConditionPermanent(HasCompositeTrait))
+                    {
+                        SelectPermanentEffect selectPermanentEffect = GManager.instance.GetComponent<SelectPermanentEffect>();
+
+                        selectPermanentEffect.SetUp(
+                            selectPlayer: card.Owner,
+                            canTargetCondition: HasCompositeTrait,
+                            canTargetCondition_ByPreSelecetedList: null,
+                            canEndSelectCondition: null,
+                            maxCount: 1,
+                            canNoSelect: true,
+                            canEndNotMax: false,
+                            selectPermanentCoroutine: null,
+                            afterSelectPermanentCoroutine: null,
+                            mode: SelectPermanentEffect.Mode.Custom,
+                            cardEffect: activateClass);
+
+                        selectPermanentEffect.SetUpCustomMessage("Select 1 Digimon that will trash digivolution cards.", "The opponent is selecting 1 Digimon that will trash digivolution cards.");
+
+                        yield return ContinuousController.instance.StartCoroutine(CardEffectCommons.DeletePeremanentAndProcessAccordingToResult(
+                        targetPermanents: new List<Permanent>() { card.PermanentOfThisCard() },
+                        activateClass: activateClass,
+                        successProcess: permanents => SuccessProcess(),
+                        failureProcess: null));
+
+                        IEnumerator SuccessProcess()
+                        {
+                            deleted = true;
+
+                            yield return null;
+                        }
+
+                        if (deleted)
+                        {
+                            selectedPermanent.willBeRemoveField = false;
+
+                            selectedPermanent.HideDeleteEffect();
+                            selectedPermanent.HideHandBounceEffect();
+                            selectedPermanent.HideDeckBounceEffect();
+                            selectedPermanent.HideWillRemoveFieldEffect();
+                        }
+                    }
+                    
+                }
+            }
+            #endregion
+
+            #region All Turns
+            if (timing == EffectTiming.OnDestroyedAnyone)
+            {
+                ActivateClass activateClass = new ActivateClass();
+                activateClass.SetUpICardEffect("Trash your opponent's top security card", CanUseCondition, card);
+                activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, 1, false, EffectDiscription());
+                activateClass.SetHashString("TrashSecurity_BT19-075");
+                cardEffects.Add(activateClass);
+
+                string EffectDiscription()
+                {
+                    return "[All Turns] [Once Per Turn] When other Digimon or Tamers are deleted, trash your opponent's top security card.";
+                }
+
+                bool OtherPermanentDeleted(Permanent permanent)
+                {
+                    return permanent.IsDigimon || permanent.IsTamer && 
+                           permanent != card.PermanentOfThisCard();
+                }
+
+                bool CanUseCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) && 
+                           CardEffectCommons.CanTriggerOnPermanentDeleted(hashtable, OtherPermanentDeleted);
+                }
+
+                bool CanActivateCondition(Hashtable hashtable)
+                {
+                    return CardEffectCommons.IsExistOnBattleAreaDigimon(card) &&
+                           card.Owner.Enemy.SecurityCards.Count > 0;
+                }
+
+                IEnumerator ActivateCoroutine(Hashtable hashtable)
+                {
+                    yield return ContinuousController.instance.StartCoroutine(new IDestroySecurity(
+                    player: card.Owner.Enemy,
+                    destroySecurityCount: 1,
+                    cardEffect: activateClass,
+                    fromTop: true).DestroySecurity());
+                }
+            }
+            #endregion
+
+            return cardEffects;
+        }
+    }
+}

Assets/CardEffect/BT19/Purple/MoonMillenniummon_BT19_075.cs.meta

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

Assets/Scripts/CardEffectCommons/KeyWordEffects/Alliance.cs

@@ -175,4 +175,47 @@ public partial class CardEffectCommons
         }
     }
     #endregion
+
+    #region Player gains effect to have Digimon gains [Alliance]
+    public static IEnumerator GainAlliancePlayerEffect(Func<Permanent, bool> permanentCondition, EffectDuration effectDuration, ICardEffect activateClass)
+    {
+        if (activateClass == null) yield break;
+        if (activateClass.EffectSourceCard == null) yield break;
+
+        CardSource card = activateClass.EffectSourceCard;
+
+        bool PermanentCondition(Permanent permanent)
+        {
+            if (IsPermanentExistsOnBattleArea(permanent))
+            {
+                if (!permanent.TopCard.CanNotBeAffected(activateClass))
+                {
+                    if (permanentCondition == null || permanentCondition(permanent))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        bool CanUseCondition()
+        {
+            return true;
+        }
+
+        AllianceClass alliance = CardEffectFactory.AllianceStaticEffect(permanentCondition: PermanentCondition, isInheritedEffect: false, card: card, condition: CanUseCondition);
+
+        AddEffectToPlayer(effectDuration: effectDuration, card: card, cardEffect: alliance, timing: EffectTiming.None);
+
+        foreach (Permanent permanent in GManager.instance.turnStateMachine.gameContext.PermanentsForTurnPlayer)
+        {
+            if (PermanentCondition(permanent))
+            {
+                yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateBuffEffect(permanent));
+            }
+        }
+    }
+    #endregion
 }

Assets/Scripts/CardEffectFactory/KeyWordEffects/Alliance.cs

@@ -77,4 +77,40 @@ public partial class CardEffectFactory
         return activateClass;
     }
     #endregion
+
+    #region Static effect of [Alliance]
+    public static AllianceClass AllianceStaticEffect(Func<Permanent, bool> permanentCondition, bool isInheritedEffect, CardSource card, Func<bool> condition)
+    {
+        string effectName = "Alliance";
+
+        AllianceClass allianceClass = new AllianceClass();
+        allianceClass.SetUpICardEffect(effectName, CanUseCondition, card);
+        allianceClass.SetUpAllianceClass(PermanentCondition: PermanentCondition);
+
+        if (isInheritedEffect)
+        {
+            allianceClass.SetIsInheritedEffect(true);
+        }
+
+        bool CanUseCondition(Hashtable hashtable)
+        {
+            return condition == null || condition();
+        }
+
+        bool PermanentCondition(Permanent permanent)
+        {
+            if (CardEffectCommons.IsPermanentExistsOnBattleArea(permanent))
+            {
+                if (permanentCondition == null || permanentCondition(permanent))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        return allianceClass;
+    }
+    #endregion
 }

Assets/Scripts/CardEffectInterfaces.cs

@@ -51,6 +51,13 @@ public interface IRebootEffect
 }
 #endregion
 
+#region "Target permanent gains Alliance" effect
+public interface IAllianceEffect
+{
+    bool HasAlliance(Permanent permanent);
+}
+#endregion
+
 #region "Treat target permanent as Digimon" effect
 public interface ITreatAsDigimonEffect
 {

Assets/Scripts/CardEffects/AllianceClass.cs

@@ -0,0 +1,35 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.Linq;
+using Photon;
+using System;
+
+public class AllianceClass : ICardEffect, IAllianceEffect
+{
+    public void SetUpAllianceClass(Func<Permanent, bool> PermanentCondition)
+    {
+        this.PermanentCondition = PermanentCondition;
+    }
+
+    Func<Permanent, bool> PermanentCondition { get; set; }
+
+    public bool HasAlliance(Permanent permanent)
+    {
+        if (PermanentCondition != null)
+        {
+            if (permanent != null)
+            {
+                if (permanent.TopCard != null)
+                {
+                    if (PermanentCondition(permanent))
+                    {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+}

Assets/Scripts/CardEffects/AllianceClass.cs.meta

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