Merge branch 'develop' into Guard-and-MAchine-Empire

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

@@ -0,0 +1,69 @@
+using System;
+using System.Collections;
+
+public partial class CardEffectCommons
+{
+    #region Can activate [Engage]
+    public static bool CanActivateEngage(CardSource cardSource, ICardEffect activateClass)
+    {
+        return IsExistOnBattleArea(cardSource)
+            && cardSource.PermanentOfThisCard().CanAttack(activateClass)
+            && !GManager.instance.attackProcess.IsAttacking;
+    }
+    #endregion
+
+    #region Effect process of [Engage]
+    public static IEnumerator EngageProcess(CardSource cardSource, ICardEffect activateClass, Func<IEnumerator> beforeOnAttackCoroutine = null)
+    {
+        if (CanActivateEngage(cardSource, activateClass))
+        {
+            SelectAttackEffect selectAttackEffect = GManager.instance.GetComponent<SelectAttackEffect>();
+
+            selectAttackEffect.SetUp(
+                attacker: cardSource.PermanentOfThisCard(),
+                canAttackPlayerCondition: () => true,
+                defenderCondition: (permanent) => true,
+                cardEffect: activateClass);
+
+            yield return ContinuousController.instance.StartCoroutine(selectAttackEffect.Activate());
+        }
+    }
+    #endregion
+
+    #region Target 1 Digimon gains [Engage]
+    public static IEnumerator GainEngage(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 CanUseCondition()
+        {
+            return IsPermanentExistsOnBattleArea(targetPermanent)
+                && !targetPermanent.TopCard.CanNotBeAffected(activateClass);
+        }
+
+        ActivateClass engage = CardEffectFactory.EngageEffect(
+            targetPermanent: targetPermanent,
+            isInheritedEffect: false,
+            condition: CanUseCondition,
+            rootCardEffect: activateClass,
+            card: card);
+
+        AddEffectToPermanent(
+            targetPermanent: targetPermanent,
+            effectDuration: effectDuration,
+            card: card,
+            cardEffect: engage,
+            timing: EffectTiming.OnEndTurn);
+
+        if (!targetPermanent.TopCard.CanNotBeAffected(activateClass))
+        {
+            yield return ContinuousController.instance.StartCoroutine(GManager.instance.GetComponent<Effects>().CreateBuffEffect(targetPermanent));
+        }
+    }
+    #endregion
+}

Assets/Scripts/Script/CardEffectCommons/KeyWordEffects/Engage.cs.meta

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

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

@@ -0,0 +1,73 @@
+using System;
+using System.Collections;
+
+public partial class CardEffectFactory
+{
+    #region [Engage] self effect
+    public static ActivateClass EngageSelfStaticEffect(bool isInheritedEffect, CardSource card, Func<bool> condition, bool isLinkedEffect = false)
+    {
+        return EngageEffect(
+            targetPermanent: card.PermanentOfThisCard(),
+            isInheritedEffect,
+            condition,
+            rootCardEffect: null,
+            card,
+            beforeOnAttackCoroutine: null,
+            isLinkedEffect
+        );
+    }
+    #endregion
+
+    #region [Engage] effect
+    public static ActivateClass EngageEffect(
+        Permanent targetPermanent,
+        bool isInheritedEffect,
+        Func<bool> condition,
+        ICardEffect rootCardEffect,
+        CardSource card,
+        Func<IEnumerator> beforeOnAttackCoroutine = null,
+        bool isLinkedEffect = false)
+    {
+        if (targetPermanent == null) return null;
+        if (targetPermanent.TopCard == null) return null;
+        if (card == null) return null;
+
+        ActivateClass activateClass = new ActivateClass();
+        activateClass.SetUpICardEffect("Engage", CanUseCondition, card);
+        activateClass.SetUpActivateClass(CanActivateCondition, ActivateCoroutine, -1, true, EffectDescription());
+        activateClass.SetIsInheritedEffect(isInheritedEffect);
+
+        string EffectDescription()
+        {
+            return $"{DataBase.EngageEffectDescription()}";
+        }
+
+        if (rootCardEffect != null)
+        {
+            activateClass.SetIsInheritedEffect(false);
+            activateClass.SetEffectSourcePermanent(targetPermanent);
+            activateClass.SetRootCardEffect(rootCardEffect);
+        }
+
+        bool CanUseCondition(Hashtable hashtable)
+        {
+            return CardEffectCommons.IsOwnerTurn(card)
+                && CardEffectCommons.IsPermanentExistsOnBattleAreaDigimon(targetPermanent);
+        }
+
+        bool CanActivateCondition(Hashtable hashtable)
+        {
+            return CardEffectCommons.CanActivateEngage(targetPermanent.TopCard, activateClass)
+                && (condition == null
+                    || condition());
+        }
+
+        IEnumerator ActivateCoroutine(Hashtable _hashtable)
+        {
+            return CardEffectCommons.EngageProcess(targetPermanent.TopCard, activateClass, beforeOnAttackCoroutine);
+        }
+
+        return activateClass;
+    }
+    #endregion
+}

Assets/Scripts/Script/CardEffectFactory/KeyWordEffects/Engage.cs.meta

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

Assets/Scripts/Script/DataBase.cs

@@ -568,6 +568,11 @@ public class DataBase : MonoBehaviour
     {
         return "<Guard> (When any of your other Digimon would leave the battle area by your opponent's effects, by deleting this Digimon, they don't leave.)";
     }
+    
+    public static string EngageEffectDescription()
+    {
+        return "<Engage> (At the end of your turn, this Digimon may attack.)";
+    }
 
     public static string ReplaceToASCII(string text)
     {

Assets/Scripts/Script/GManager.cs

@@ -597,7 +597,12 @@ public class GManager : MonoBehaviourPun
         {
             turnStateMachine.QueueMainPhaseAction(You, new CheatAction(You.PlayerID, CheatAction.Type.LoseMemory));
         }
-
+        
+        //Add security to hand
+        if (Input.GetKey(KeyCode.LeftControl) && Input.GetKeyDown(KeyCode.H))
+        {
+            turnStateMachine.QueueMainPhaseAction(You, new CheatAction(You.PlayerID, CheatAction.Type.RemoveFromSecurity));
+        }
     }
 
     public IEnumerator DrawCard(Player _player)
@@ -700,5 +705,32 @@ public class GManager : MonoBehaviourPun
 
         yield return StartCoroutine(turnStateMachine.SetMainPhase());
     }
+
+    public IEnumerator RemoveFromSecurity (Player _player)
+    {
+        SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();
+    
+        selectCardEffect.SetUp(
+            canTargetCondition: (cardSource) => true,
+            canTargetCondition_ByPreSelecetedList: null,
+            canEndSelectCondition: null,
+            canNoSelect: () => true,
+            selectCardCoroutine: null,
+            afterSelectCardCoroutine: null,
+            message: "Select Cards to add to hand",
+            maxCount: _player.SecurityCards.Count,
+            canEndNotMax: true,
+            isShowOpponent: false,
+            mode: SelectCardEffect.Mode.AddHand,
+            root: SelectCardEffect.Root.Security,
+            customRootCardList: null,
+            canLookReverseCard: true,
+            selectPlayer: _player,
+            cardEffect: null);
+    
+        yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
+
+        yield return StartCoroutine(turnStateMachine.SetMainPhase());
+    }
     #endregion
 }

Assets/Scripts/Script/MainPhaseAction/CheatAction.cs

@@ -12,6 +12,7 @@ public class CheatAction : MainPhaseAction
         PlaceCardInSecurityFaceup,
         GainMemory,
         LoseMemory,
+        RemoveFromSecurity,
     }
 
     Type CheatType;
@@ -66,6 +67,9 @@ public class CheatAction : MainPhaseAction
                 case Type.LoseMemory:
                     gameManager.StartCoroutine(gameManager.AlterMemory(player, -1));
                     break;
+                case Type.RemoveFromSecurity:
+                    gameManager.StartCoroutine(gameManager.RemoveFromSecurity(player));
+                    break;
                 default:
                     break;
             }