DCGO/Assets/Scripts/CardEffectCommons.cs

using System.Collections;
using System.Collections.Generic;
using System;
using System.Linq;
using UnityEngine;
using UnityEditor;

public partial class CardEffectCommons
{
    #region Play cards as new permanents
    public static IEnumerator PlayPermanentCards(List<CardSource> cardSources, ICardEffect activateClass, bool payCost, bool isTapped, SelectCardEffect.Root root, bool activateETB, bool isBreedingArea = false)
    {
        if (cardSources == null) yield break;

        cardSources = cardSources
        .Filter(cardSource => cardSource != null)
        .Filter(cardSource => CanPlayAsNewPermanent(
            cardSource: cardSource,
            payCost: payCost,
            cardEffect: activateClass,
            isBreedingArea: isBreedingArea));

        if (cardSources.Count == 0) yield break;

        PlayCardClass playCardClass = new PlayCardClass(
                cardSources: cardSources,
                hashtable: CardEffectHashtable(activateClass),
                payCost: payCost,
                targetPermanent: null,
                isTapped: isTapped,
                root: root,
                activateETB: activateETB);

        if (isBreedingArea)
        {
            playCardClass.SetIsBreedingArea();
        }

        yield return ContinuousController.instance.StartCoroutine(playCardClass.PlayCard());
    }
    #endregion

    #region Play option cards
    public static IEnumerator PlayOptionCards(List<CardSource> cardSources, ICardEffect activateClass, bool payCost, SelectCardEffect.Root root,
        bool setAddSecurityEndOption = false)
    {
        if (cardSources == null) yield break;

        cardSources = cardSources
        .Filter(cardSource => cardSource != null)
        .Filter(cardSource => !cardSource.CanNotPlayThisOption);

        if (cardSources.Count == 0) yield break;

        PlayCardClass playCard = new PlayCardClass(
                cardSources: cardSources,
                hashtable: CardEffectHashtable(activateClass),
                payCost: payCost,
                targetPermanent: null,
                isTapped: false,
                root: root,
                activateETB: true);

        if (activateClass != null)
        {
            playCard.SetShowEffect();
        }

        if (setAddSecurityEndOption)
        {
            playCard.SetAddSecurityEndOption();
        }

        yield return ContinuousController.instance.StartCoroutine(playCard.PlayCard());
    }
    #endregion

    #region Play Delay Option cards as new permanents
    public static IEnumerator PlaceDelayOptionCards(CardSource card, ICardEffect cardEffect, SelectCardEffect.Root root = SelectCardEffect.Root.Execution)
    {
        if (CanPlayAsNewPermanent(cardSource: card, payCost: false, cardEffect: cardEffect, isPlayOption: true))
        {
            PlayPermanentClass playPermanent = new PlayPermanentClass(
                cardSources: new List<CardSource>() { card },
                hashtable: CardEffectHashtable(cardEffect),
                targetPermanent: null,
                isTapped: false,
                root: root,
                ActivateETB: true);

            playPermanent.SetISPlayOption();

            yield return ContinuousController.instance.StartCoroutine(playPermanent.PlayPermanent());

            if (IsExistOnBattleArea(card))
            {
                card.PermanentOfThisCard().IsPlayedOptionPermanent = true;
            }
        }
    }
    #endregion

    #region Play 1 Token
    public static IEnumerator PlayToken(CEntity_Base tokenData, ICardEffect activateClass, bool isOwnerPermanent, bool isTapped)
    {
        if (activateClass == null) yield break;
        if (activateClass.EffectSourceCard == null) yield break;
        if (tokenData == null) yield break;

        CardSource card = activateClass.EffectSourceCard;

        Player player = isOwnerPermanent ? card.Owner : card.Owner.Enemy;

        if (card.Owner.fieldCardFrames.Count((frame) => frame.IsEmptyFrame() && frame.IsBattleAreaFrame()) >= 1)
        {
            CardSource tokenCard = CardObjectController.CreateCardSource(
                player.PlayerID,
                tokenData,
                true);

            if (CanPlayAsNewPermanent(cardSource: tokenCard, payCost: false, cardEffect: activateClass))
            {
                yield return ContinuousController.instance.StartCoroutine(new PlayCardClass(
                    cardSources: new List<CardSource>() { tokenCard },
                    hashtable: CardEffectHashtable(activateClass),
                    payCost: false,
                    targetPermanent: null,
                    isTapped: isTapped,
                    root: SelectCardEffect.Root.None,
                    activateETB: true).PlayCard());
            }
        }
    }
    #endregion

    #region Play 1 [Diaboromon] Token
    public static IEnumerator PlayDiaboromonToken(ICardEffect activateClass)
    {
        yield return ContinuousController.instance.StartCoroutine(PlayToken(
            tokenData: ContinuousController.instance.DiaboromonToken,
            activateClass: activateClass,
            isOwnerPermanent: true,
            isTapped: false
        ));
    }
    #endregion

    #region Play 1 [Amon of Crimson Flame] Token
    public static IEnumerator PlayAmonToken(ICardEffect activateClass)
    {
        yield return ContinuousController.instance.StartCoroutine(PlayToken(
            tokenData: ContinuousController.instance.AmonToken,
            activateClass: activateClass,
            isOwnerPermanent: true,
            isTapped: false
        ));
    }
    #endregion

    #region Play 1 [Umon of Blue Thunder] Token
    public static IEnumerator PlayUmonToken(ICardEffect activateClass)
    {
        yield return ContinuousController.instance.StartCoroutine(PlayToken(
            tokenData: ContinuousController.instance.UmonToken,
            activateClass: activateClass,
            isOwnerPermanent: true,
            isTapped: false
        ));
    }
    #endregion

    #region Play 1 [Fujitsumon] Token
    public static IEnumerator PlayFujitsumonToken(ICardEffect activateClass, bool isOwnerPermanent)
    {
        yield return ContinuousController.instance.StartCoroutine(PlayToken(
            tokenData: ContinuousController.instance.FujitsumonToken,
            activateClass: activateClass,
            isOwnerPermanent: isOwnerPermanent,
            isTapped: true
        ));
    }
    #endregion

    #region Play 1 [Gyuukimon] Token
    public static IEnumerator PlayGyuukimonToken(ICardEffect activateClass)
    {
        yield return ContinuousController.instance.StartCoroutine(PlayToken(
            tokenData: ContinuousController.instance.GyuukimonToken,
            activateClass: activateClass,
            isOwnerPermanent: true,
            isTapped: false
        ));
    }
    #endregion

    #region Security effect of "add this card to hand"
    public static IEnumerator AddThisCardToHand(CardSource card1, ICardEffect activateClass)
    {
        yield return new WaitForSeconds(0.5f);

        yield return ContinuousController.instance.StartCoroutine(card1.Owner.brainStormObject.CloseBrainstrorm(card1));

        yield return ContinuousController.instance.StartCoroutine(CardObjectController.AddHandCards(new List<CardSource>() { card1 }, false, activateClass));
    }
    #endregion

    #region Delete target permanents, and the effect determines whether the permanent has been deleted or not
    public static IEnumerator DeletePeremanentAndProcessAccordingToResult(List<Permanent> targetPermanents, ICardEffect activateClass, Func<List<Permanent>, IEnumerator> successProcess, Func<IEnumerator> failureProcess)
    {
        DestroyPermanentsClass destroyPermanentsClass = new DestroyPermanentsClass(targetPermanents, CardEffectHashtable(activateClass));

        yield return ContinuousController.instance.StartCoroutine(destroyPermanentsClass.Destroy());

        if (targetPermanents.Some((permanent) => destroyPermanentsClass.IsDestroyed(permanent)))
        {
            if (successProcess != null)
            {
                yield return ContinuousController.instance.StartCoroutine(successProcess(destroyPermanentsClass.DestroyedPermanents));
            }
        }

        else
        {
            if (failureProcess != null)
            {
                yield return ContinuousController.instance.StartCoroutine(failureProcess());
            }
        }
    }
    #endregion

    #region Bounce target 1 permanent, and the effect determines whether the permanent has been bounced or not
    public static IEnumerator BouncePeremanentAndProcessAccordingToResult(List<Permanent> targetPermanents, ICardEffect activateClass, IEnumerator successProcess, IEnumerator failureProcess)
    {
        HandBounceClaass bouncePermanentClass = new HandBounceClaass(targetPermanents, CardEffectHashtable(activateClass));

        yield return ContinuousController.instance.StartCoroutine(bouncePermanentClass.Bounce());

        if (targetPermanents.Some((permanent) => bouncePermanentClass.IsBounced(permanent)))
        {
            if (successProcess != null)
            {
                yield return ContinuousController.instance.StartCoroutine(successProcess);
            }
        }

        else
        {
            if (failureProcess != null)
            {
                yield return ContinuousController.instance.StartCoroutine(failureProcess);
            }
        }
    }
    #endregion

    #region Deck Bounce target 1 permanent, and the effect determines whether the permanent has been bounced or not
    public static IEnumerator DeckBouncePeremanentAndProcessAccordingToResult(List<Permanent> targetPermanents, ICardEffect activateClass, IEnumerator successProcess, IEnumerator failureProcess)
    {
        DeckBottomBounceClass deckBounceClass = new DeckBottomBounceClass(targetPermanents, CardEffectHashtable(activateClass));

        yield return ContinuousController.instance.StartCoroutine(deckBounceClass.DeckBounce());

        if (targetPermanents.Some((permanent) => deckBounceClass.IsDeckBounced(permanent)))
        {
            if (successProcess != null)
            {
                yield return ContinuousController.instance.StartCoroutine(successProcess);
            }
        }

        else
        {
            if (failureProcess != null)
            {
                yield return ContinuousController.instance.StartCoroutine(failureProcess);
            }
        }
    }
    #endregion

    #region Trash digivolution cards from top or bottom
    public static IEnumerator TrashDigivolutionCardsFromTopOrBottom(Permanent targetPermanent, int trashCount, bool isFromTop, ICardEffect activateClass)
    {
        if (activateClass == null) yield break;
        if (targetPermanent == null) yield break;
        if (targetPermanent.TopCard == null) yield break;
        if (targetPermanent.DigivolutionCards.Count((cardSource) => !cardSource.CanNotTrashFromDigivolutionCards(activateClass)) == 0) yield break;
        if (targetPermanent.TopCard.CanNotBeAffected(activateClass)) yield break;
        if (trashCount <= 0) yield break;

        List<CardSource> trashTargetCards = new List<CardSource>();

        for (int i = 0; i < trashCount; i++)
        {
            if (targetPermanent.DigivolutionCards.Count >= i + 1)
            {
                int index = isFromTop ? i : targetPermanent.DigivolutionCards.Count - 1 - i;
                CardSource trashTargetCard = targetPermanent.DigivolutionCards[index];

                trashTargetCards.Add(trashTargetCard);
            }
        }

        yield return ContinuousController.instance.StartCoroutine(new ITrashDigivolutionCards(targetPermanent, trashTargetCards, activateClass).TrashDigivolutionCards());
    }
    #endregion

    #region this Option card's Main effect
    public static ActivateClass OptionMainEffect(CardSource card) => card.EffectList(EffectTiming.OptionSkill).Find(cardEffect => cardEffect != null && cardEffect is ActivateClass && cardEffect.EffectDiscription.Contains("[Main]")) as ActivateClass;
    #endregion

    #region Add Option's Security effect that "Activate this card's Main effect" to cardEffects
    public static void AddActivateMainOptionSecurityEffect(CardSource card, ref List<ICardEffect> cardEffects, string effectName, string effectDiscription = "", Func<ICardEffect, IEnumerator> afterMainEffect = null)
    {
        if (OptionMainEffect(card) == null) return;

        cardEffects.Add(CardEffectFactory.ActivateMainOptionSecurityEffect(card, effectName, effectDiscription, afterMainEffect));
    }
    #endregion

    #region Target permanent Digivolves into Digimon card from hand or trash
    public static IEnumerator DigivolveIntoHandOrTrashCard(
        Permanent targetPermanent,
        Func<CardSource, bool> cardCondition,
        bool payCost,
        (int reduceCost, Func<CardSource, bool> reduceCostCardCondition)? reduceCostTuple,
        (int fixedCost, Func<CardSource, bool> fixedCostCardCondition)? fixedCostTuple,
        int ignoreDigivolutionRequirementFixedCost,
        bool isHand,
        ICardEffect activateClass,
        IEnumerator successProcess,
        bool ignoreLevel = false)
    {
        if (targetPermanent == null) yield break;
        if (targetPermanent.TopCard == null) yield break;
        if (activateClass == null) yield break;
        if (activateClass.EffectSourceCard == null) yield break;

        Player owner = targetPermanent.TopCard.Owner;
        SelectCardEffect.Root root = isHand ? SelectCardEffect.Root.Hand : SelectCardEffect.Root.Trash;
        bool ignoreDigivolutionRequirement = ignoreDigivolutionRequirementFixedCost >= 0;

        int fixedCost = -1;

        if (fixedCostTuple != null)
        {
            fixedCost = fixedCostTuple.Value.fixedCost;
        }

        if (ignoreDigivolutionRequirement)
        {
            fixedCost = ignoreDigivolutionRequirementFixedCost;
        }

        bool CanSelectCardCondition(CardSource cardSource)
        {
            if (cardSource.IsDigimon)
            {
                if (cardCondition == null || cardCondition(cardSource))
                {
                    if (!cardSource.CanNotEvolve(targetPermanent))
                    {
                        if (ignoreLevel
                        || cardSource.CanPlayCardTargetFrame(
                            frame: targetPermanent.PermanentFrame,
                            PayCost: payCost,
                            cardEffect: activateClass,
                            root: root,
                            fixedCost: fixedCost))
                        {
                            return true;
                        }
                    }
                }
            }

            return false;
        }

        #region reduce cost
        Func<EffectTiming, ICardEffect> getChangeCostEffect = null;

        if (reduceCostTuple != null)
        {
            bool PermanentCondition(Permanent permanent)
            {
                return permanent == targetPermanent;
            }

            bool CardCondition(CardSource cardSource)
            {
                if (cardSource != null)
                {
                    if (cardSource.Owner == owner)
                    {
                        if (reduceCostTuple.Value.reduceCostCardCondition == null || reduceCostTuple.Value.reduceCostCardCondition(cardSource))
                        {
                            return true;
                        }
                    }
                }

                return false;
            }

            getChangeCostEffect = ChangeDigivolutionCostPlayerEffect(
                permanentCondition: PermanentCondition,
                cardCondition: CardCondition,
                rootCondition: null,
                changeValue: -reduceCostTuple.Value.reduceCost,
                activateClass: activateClass,
                setFixedCost: false);

            if (getChangeCostEffect != null)
            {
                AddEffectToPlayer(
                    effectDuration: EffectDuration.UntilCalculateFixedCost,
                    card: targetPermanent.TopCard,
                    cardEffect: null,
                    timing: EffectTiming.None,
                    getCardEffect: getChangeCostEffect);
            }
        }
        #endregion

        #region set fixed cost
        Func<EffectTiming, ICardEffect> getFixedCostEffect = null;

        if (fixedCostTuple != null)
        {
            bool PermanentCondition(Permanent permanent)
            {
                return permanent == targetPermanent;
            }

            bool CardCondition(CardSource cardSource)
            {
                if (cardSource != null)
                {
                    if (cardSource.Owner == owner)
                    {
                        if (fixedCostTuple.Value.fixedCostCardCondition == null || fixedCostTuple.Value.fixedCostCardCondition(cardSource))
                        {
                            return true;
                        }
                    }
                }

                return false;
            }

            getFixedCostEffect = ChangeDigivolutionCostPlayerEffect(
                permanentCondition: PermanentCondition,
                cardCondition: CardCondition,
                rootCondition: null,
                changeValue: fixedCost,
                activateClass: activateClass,
                setFixedCost: true);

            if (getChangeCostEffect != null)
            {
                AddEffectToPlayer(
                    effectDuration: EffectDuration.UntilCalculateFixedCost,
                    card: targetPermanent.TopCard,
                    cardEffect: null,
                    timing: EffectTiming.None,
                    getCardEffect: getFixedCostEffect);
            }
        }
        #endregion

        #region ignore digivolution requirement
        Func<EffectTiming, ICardEffect> getIgnoreDigivolutionRequirementEffect = null;

        if (ignoreDigivolutionRequirement)
        {
            bool PermanentCondition(Permanent permanent)
            {
                return permanent == targetPermanent;
            }

            bool CardCondition(CardSource cardSource)
            {
                if (cardSource == null)
                {
                    return false;
                }

                if (cardSource.Owner != owner)
                {
                    return false;
                }

                if (cardCondition == null || cardCondition(cardSource))
                {
                    return true;
                }

                return false;
            }

            getIgnoreDigivolutionRequirementEffect = GainIgnoreDigivolutionRequirementPlayerEffect(
                permanentCondition: PermanentCondition,
                cardCondition: CardCondition,
                ignoreDigivolutionRequirement: ignoreDigivolutionRequirement,
                digivolutionCost: fixedCost,
                activateClass: activateClass);

            if (getIgnoreDigivolutionRequirementEffect != null)
            {
                AddEffectToPlayer(
                effectDuration: EffectDuration.UntilCalculateFixedCost,
                card: targetPermanent.TopCard,
                cardEffect: null,
                timing: EffectTiming.None,
                getCardEffect: getIgnoreDigivolutionRequirementEffect);
            }
        }
        #endregion

        List<CardSource> selectedCards = new List<CardSource>();

        IEnumerator SelectCardCoroutine(CardSource cardSource)
        {
            selectedCards.Add(cardSource);

            yield return null;
        }

        if (isHand)
        {
            if (owner.HandCards.Count(CanSelectCardCondition) >= 1)
            {
                int maxCount = 1;

                SelectHandEffect selectHandEffect = GManager.instance.GetComponent<SelectHandEffect>();

                selectHandEffect.SetUp(
                    selectPlayer: owner,
                    canTargetCondition: CanSelectCardCondition,
                    canTargetCondition_ByPreSelecetedList: null,
                    canEndSelectCondition: null,
                    maxCount: maxCount,
                    canNoSelect: true,
                    canEndNotMax: false,
                    isShowOpponent: true,
                    selectCardCoroutine: SelectCardCoroutine,
                    afterSelectCardCoroutine: null,
                    mode: SelectHandEffect.Mode.Custom,
                    cardEffect: activateClass);

                selectHandEffect.SetUpCustomMessage("Select 1 card to digivolve.", "The opponent is selecting 1 card to digivolve.");
                selectHandEffect.SetUpCustomMessage_ShowCard("Selected Card");

                yield return ContinuousController.instance.StartCoroutine(selectHandEffect.Activate());
            }
        }

        else
        {
            if (HasMatchConditionOwnersCardInTrash(targetPermanent.TopCard, CanSelectCardCondition))
            {
                int maxCount = 1;

                SelectCardEffect selectCardEffect = GManager.instance.GetComponent<SelectCardEffect>();

                selectCardEffect.SetUp(
                            canTargetCondition: CanSelectCardCondition,
                            canTargetCondition_ByPreSelecetedList: null,
                            canEndSelectCondition: null,
                            canNoSelect: () => true,
                            selectCardCoroutine: SelectCardCoroutine,
                            afterSelectCardCoroutine: null,
                            message: "Select 1 card to digivolve.",
                            maxCount: maxCount,
                            canEndNotMax: false,
                            isShowOpponent: true,
                            mode: SelectCardEffect.Mode.Custom,
                            root: SelectCardEffect.Root.Trash,
                            customRootCardList: null,
                            canLookReverseCard: true,
                            selectPlayer: owner,
                            cardEffect: activateClass);

                selectCardEffect.SetUpCustomMessage("Select 1 card to digivolve.", "The opponent is selecting 1 card to digivolve.");
                selectCardEffect.SetUpCustomMessage_ShowCard("Selected Card");

                yield return ContinuousController.instance.StartCoroutine(selectCardEffect.Activate());
            }
        }

        PlayCardClass playCardClass = new PlayCardClass(
            cardSources: selectedCards,
            hashtable: CardEffectHashtable(activateClass),
            payCost: payCost,
            targetPermanent: targetPermanent,
            isTapped: false,
            root: root,
            activateETB: true);

        if (ignoreLevel) playCardClass.SetIgnoreLevel();
        if (!ignoreDigivolutionRequirement && fixedCost >= 0) playCardClass.SetFixedCost(fixedCost);

        yield return ContinuousController.instance.StartCoroutine(playCardClass.PlayCard());

        #region release effect
        if (getChangeCostEffect != null) owner.UntilCalculateFixedCostEffect.Remove(getChangeCostEffect);
        #endregion

        #region release effect
        if (getFixedCostEffect != null) owner.UntilCalculateFixedCostEffect.Remove(getFixedCostEffect);
        #endregion

        #region release effect
        if (getIgnoreDigivolutionRequirementEffect != null) owner.UntilCalculateFixedCostEffect.Remove(getIgnoreDigivolutionRequirementEffect);
        #endregion

        if (selectedCards.Count >= 1)
        {
            if (IsDigivolvedByTheEffect(targetPermanent, selectedCards[0], activateClass))
            {
                if (successProcess != null)
                {
                    yield return ContinuousController.instance.StartCoroutine(successProcess);
                }
            }
        }
    }
    #endregion

    #region Get the effect given by EffectTiming
    public static Func<EffectTiming, ICardEffect> GetCardEffectByEffectTiming(EffectTiming timing, ICardEffect cardEffect) => (_timing) => _timing == timing ? cardEffect : null;
    #endregion
}