garden_client/Assets/Script/Object/Flower.cs

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Serialization;
using UnityEngine.EventSystems;

using System;
using System.Xml;
using System.Collections;
using System.Collections.Generic;

using Random = UnityEngine.Random;

public enum OpType
{
    Rip,
    Null,
    Water,
    Fertilize,
}

public class FlowerLabel
{
    public static string AwardGoldBk = "AwardGoldBk";
    public static string AwardGoldIcon = "AwardGoldIcon";
    public static string AwardGoldPos = "AwardGoldPos";
    public static string FlashLight = "FlashLight";
    public static string FlowerIcon = "FlowerIcon";
    public static string OperatePanelBk = "OperatePanelBk";
    public static string OperateIcon = "OperateIcon";
    public static string OperateOutlineParent = "OperateOutlineParent";
    public static string NewFlowerEffect = "NewFlowerEffect";
    public static string FlowerShadow = "FlowerShadow";
    public static string ScorePos = "ScorePos";
    public static string MiniGamePanel = "MiniGamePanel";
    public static string Flash = "Flash";
    public static string ParticleSystem = "ParticleSystem";
    public static string AwardGoldBkLeftPos = "AwardGoldBkLeftPos";
}

public class FlowerInfo
{
    #region Config

    public int Amount
    {
        get { return amount; }
        set
        {
            amount = value;

            AmountText.SetActive(true);

            AmountText.text = AmountTextPrefix + amount;
        }
    }
    public int amount;

    public int RemainAmount
    {
        get { return Amount - PlantAmt; }
    }

    public int PlantAmt;

    public bool IsPlanted
    {
        get { return PlantAmt > 0; }
    }

    public bool Unlock
    {
        get { return unlock; }
        set
        {
            unlock = value;

            if (unlock)
            {
                Image.material = null;

                if (IsSpecial)
                {
                    if (GardenManager.TotalUnlockSpecialFlower == 0)
                    {
                        ResourceManager.Get(CanvasLabel.G_Regular).TweenForVec();

                        ResourceManager.SetActive(CanvasLabel.G_Special, true);
                    }

                    GardenManager.TotalUnlockSpecialFlower++;
                }
                else
                {
                    GardenManager.TotalUnlockNormalFlower++;
                }

                Amount = 1;
                Manager.FlowerPlus += SkillPlus;
            }
        }
    }
    public bool unlock;

    public bool IsSpecial;
    public float SkillPlus = 0.1f;
    public static string IDPrefix = "Flower";
    public static string AmountTextPrefix = "x";

    public string FullID
    {
        get
        {
            return IDPrefix + ID;
        }
    }
    public int ID;

    public string Name
    {
        get
        {
            return Language.GetStr(LanguageLabel.CombineLanguageLabel(LanguageLabel.FlowerName, FullID));
        }
    }
    public string Description
    {
        get { return null; }
    }

    public Sprite Icon
    {
        get { return ResourceManager.LoadSprite(icon, Folder.Atlas2); }
    }
    public string icon;

    public int UnlockCost;
    public float AwardCoinBuff;
    public Current UnlockCur;
    public float itemSize;
    public float flowerCardSize;
    public float minigameSize;

    public Text StatusText;
    public Text AmountText;
    public Image Image;
    public Button Button;
    public UIPartical UIPartical;
    public Transform FlowerItem;

    public Dictionary<string, Transform> ChildDic = new Dictionary<string, Transform>();

    #endregion

    public FlowerInfo(XmlAttributeCollection attribute)
    {
        FlowerItem = ResourceManager.Get(ResourceLabel.FlowerItem, Folder.UI, false, ResourceManager.Get(CanvasLabel.G_RegularGrid),  false, ObjType.FlowerItem);

        FlowerItem.AddComponent<FlowerItem>();

        Auxiliary.CompileDic(FlowerItem, ChildDic);

        StatusText = ChildDic[FlowerItemLabel.Status].GetComponent<Text>();
        Image = ChildDic[FlowerItemLabel.Icon].GetComponent<Image>();
        Button = ChildDic[FlowerItemLabel.FlowerItem].GetComponent<Button>();
        UIPartical = ChildDic[FlowerItemLabel.UIParticleSystem].GetComponent<UIPartical>();
        AmountText = ChildDic[FlowerItemLabel.Amount].GetComponent<Text>();

        ID = int.Parse(attribute[0].Value);
        icon = attribute[5].Value;

        UnlockCur = Auxiliary.CurrentParse(attribute[3].Value);
        UnlockCost = Auxiliary.StringToInt(attribute[4].Value, 0);
        AwardCoinBuff = Auxiliary.StringToFloat(attribute[7].Value, 1);
        itemSize = Auxiliary.StringToFloat(attribute[8].Value, 1);
        flowerCardSize = Auxiliary.StringToFloat(attribute[9].Value, 1);
        minigameSize = Auxiliary.StringToFloat(attribute[10].Value, 1);

        Image.sprite = Icon;

        Image.Resize(true, itemSize, itemSize);

        Button.onClick.AddListener
        (
            () =>
            {
                if (IsPlanted)
                {
                    AudioManager.PlayClip(AudioLabel.ClickButton);

                    GardenManager.ShowRetrieveCard(this);
                }
                else if (Unlock)
                {
                    GardenManager.ShowPlantCard(this);
                }
                else
                {
                    GardenManager.ShowUnlockCard(this);
                }
            }
        );
    }

    public void Add()
    {
        if (Unlock)
            Amount++;
        else
            Unlock = true;
    }
}

public class Flower : Regist, IPointerClickHandler
{
    #region Config

    #region MiniGame

    public OpType PunchGameOperateType
    {
        get { return punchGameOperateType; }
        set
        {
            punchGameOperateType = value;

            if (punchGameOperateType == OpType.Rip)
            {
                OperateIcon.sprite = RipSprite;
            }
            else if (punchGameOperateType == OpType.Water)
            {
                OperateIcon.sprite = WaterSprite;
            }
            else if (punchGameOperateType == OpType.Fertilize)
            {
                OperateIcon.sprite = FertilizeSprite;
            }
        }
    }
    public OpType punchGameOperateType;

    public SpriteRenderer FlowerIcon;
    public SpriteRenderer OperatePanelBk;
    public SpriteRenderer OperateIcon;
    public SpriteRenderer OperateOutlineParent;

    #endregion

    public bool HaveAward
    {
        get { return haveAward; }
        set
        {
            haveAward = value;

            if (haveAward)
            {
                ShowAward();
            }
            else
            {
                GetAward();
            }
        }
    }
    public bool haveAward;

    public Sprite RipSprite
    {
        get
        {
            return ResourceManager.LoadSprite(ResourceLabel.Rip, Folder.UI);
        }
    }
    public Sprite WaterSprite
    {
        get
        {
            return ResourceManager.LoadSprite(ResourceLabel.Water, Folder.UI);
        }
    }
    public Sprite FertilizeSprite
    {
        get
        {
            return ResourceManager.LoadSprite(ResourceLabel.Fertilize, Folder.UI);
        }
    }

    public FlowerInfo FlowerInfo
    {
        get { return flowerInfo; }
        set
        {
            flowerInfo = value;

            ID = FlowerInfo.ID;
            FlowerIcon.sprite = FlowerInfo.Icon;
        }
    }
    private FlowerInfo flowerInfo;

    public SpriteRenderer ShadowSR;

    public int ID;
    public Slot Slot;
    public Animator FlashLightAC;
    public Transform AwardGoldBk;
    public Transform AwardGoldIcon;
    public MaterialUnit NewFlowerEffectMatUnit;
    public ParticleSystem NewFlowerEffect;

    public List<Transform> ElfList = new List<Transform>();
    public Dictionary<string, Transform> ChildDic = new Dictionary<string, Transform>();

    public static string AwardCoinFml;

    #endregion

    #region MiniGame

    public void GameOver()
    {
        PunchGameOperateType = OpType.Null;

        ChildDic[FlowerLabel.MiniGamePanel].SetActive(false);

        OperatePanelBk.TweenBacScale();
    }

    public void GameBegin()
    {
        ChildDic[FlowerLabel.MiniGamePanel].SetActive(true);

        OperatePanelBk.SetActive(false);
    }


    public void SetFirstOp()
    {
        OperatePanelBk.TweenForScale();

        OperateIcon.SetAlpha(1);
        OperateOutlineParent.SetAlpha(1);

        OperateIcon.SetActive(true);
        OperateOutlineParent.SetActive(true);
    }

    public void SetThirdOp()
    {
        OperateIcon.SetAlpha(0.5f);
        OperateOutlineParent.SetAlpha(0.5f);

        OperateIcon.SetActive(true);
        OperateOutlineParent.SetActive(false);
    }

    public void SetSecondOp()
    {
        OperateIcon.SetAlpha(1);
        OperateOutlineParent.SetAlpha(1);

        OperateIcon.SetActive(true);
        OperateOutlineParent.SetActive(false);
    }


    public void CreateOp(int sequence)
    {
        float random = Random.Range(0f, 1f);

        OperatePanelBk.SetActive(true);

        if (random <= 0.3333333f)
        {
            PunchGameOperateType = OpType.Rip;
        }
        else if (random <= 0.6666666f)
        {
            PunchGameOperateType = OpType.Water;
        }
        else
        {
            PunchGameOperateType = OpType.Fertilize;
        }

        if (sequence == 0)
        {
            SetFirstOp();
        }
        else if (sequence == 1)
        {
            SetSecondOp();
        }
        else
        {
            SetThirdOp();
        }
    }

    public void CreateOp(int sequence, OpType opType)
    {
        PunchGameOperateType = opType;
        OperatePanelBk.SetActive(true);

        if (sequence == 0)
        {
            SetFirstOp();
        }
        else if (sequence == 1)
        {
            SetSecondOp();
        }
        else
        {
            SetThirdOp();
        }
    }


    public bool Operate(OpType opType)
    {
        if (opType == OpType.Rip)
        {
            ResourceManager.Get(CanvasLabel.D_Rip2).TweenForScale();
        }
        else if (opType == OpType.Water)
        {
            ResourceManager.Get(CanvasLabel.D_Water2).TweenForScale();
        }
        else if (opType == OpType.Fertilize)
        {
            ResourceManager.Get(CanvasLabel.D_Fertilize2).TweenForScale();
        }

        if (opType != PunchGameOperateType)
        {
            TweenRoot tween = FlowerIcon.CreateTweenSr(new Color(1, 1, 1), new Color(1, 0.5f, 0.5f), 0.2f, true, true, Curve.EaseOutQuad, false, true);

            tween.OnForwardFinish += () =>
            {
                FlowerIcon.TweenBacSr();
            };

            OperatePanelBk.TweenForSr();
            FlowerIcon.TweenForSr();

            OperateIcon.Shake(0.5f, 3, new Vector3(0.2f, 0, 0), Curve.EaseOutQuad);

            AudioManager.PlayClip(AudioLabel.Error);

            return false;
        }
        else
        {
            ResourceManager.GetHudText($"+{MiniGameManager.PunchCorrectScore}", Color.white, 90, ChildDic[FlowerLabel.ScorePos], ResourceManager.Get(CanvasLabel.D_HudParent), true);

            MiniGameManager.Score += MiniGameManager.PunchCorrectScore;

            PlayFlashLight();

            PunchGameOperateType = OpType.Null;

            OperatePanelBk.TweenBacScale();

            OperatePanelBk.SetActive(false);
            OperateIcon.SetActive(false);
            OperateOutlineParent.SetActive(false);

            AudioManager.PlayClip(AudioLabel.ClickButton);

            return true;
        }
    }

    #endregion

    public override bool InitAtOnce()
    {
        if (base.InitAtOnce())
        {
            return true;
        }

        enabled = true;

        Auxiliary.CompileDic(transform, ChildDic);

        AwardGoldBk = ChildDic[FlowerLabel.AwardGoldBk];
        AwardGoldIcon = ChildDic[FlowerLabel.AwardGoldIcon];
        FlashLightAC = ChildDic[FlowerLabel.FlashLight].GetComponent<Animator>();
        FlowerIcon = ChildDic[FlowerLabel.FlowerIcon].GetComponent<SpriteRenderer>();
        OperatePanelBk = ChildDic[FlowerLabel.OperatePanelBk].GetComponent<SpriteRenderer>();
        OperateIcon = ChildDic[FlowerLabel.OperateIcon].GetComponent<SpriteRenderer>();
        OperateOutlineParent = ChildDic[FlowerLabel.OperateOutlineParent].GetComponent<SpriteRenderer>();
        NewFlowerEffect = ChildDic[FlowerLabel.NewFlowerEffect].GetComponent<ParticleSystem>();
        ShadowSR = ChildDic[FlowerLabel.FlowerShadow].GetComponent<SpriteRenderer>();

        AwardGoldBk.CreateTweenSr(0, 1, 1f, false, true, Curve.EaseOutQuad);
        AwardGoldIcon.CreateTweenSr(0, 1, 1f, false, true, Curve.EaseOutQuad);


        #region 新花粒子特效

        Renderer renderer = NewFlowerEffect.GetComponent<Renderer>();

        Material material = new Material(renderer.material);

        renderer.material = material;

        NewFlowerEffectMatUnit = new MaterialUnit(material, NewFlowerEffect.transform, new List<string>() { "_Alpha" });

        NewFlowerEffectMatUnit.CreateTweenMatFloat(0, 1, 0.25f, false, true, Curve.EaseOutQuad);

        #endregion

        TweenRoot tween = OperatePanelBk.CreateTweenSr(new Color(1, 1, 1), new Color(1, 0.5f, 0.5f), 0.2f, true, true, Curve.EaseOutQuad, false, true);

        tween.OnForwardFinish += () =>
        {
            OperatePanelBk.TweenBacSr();
        };

        tween = OperatePanelBk.CreateTweenScale(OperatePanelBk.transform.localScale + new Vector3(0.1f, 0.1f, 0.1f), 0.25f, false, true, Curve.EaseOutQuad);

        tween.OnBackwardFinish += () =>
        {
            if (PunchGameOperateType != OpType.Null)
            {
                OperatePanelBk.SetActive(true);
            }
        };

        return false;
    }


    public void GetElf(ElfType elfType, float xMin = -0.75f, float xMax = 0.75f, float yMin = 0, float yMax = 0.75f)
    {
        ElfList.Add(ResourceManager.GetElf(this, new Vector4(xMin, xMax, yMin, yMax), elfType));
    }

    public void RetrieveFlower()
    {
        ChildDic[FlowerLabel.Flash].SetActive(false);
        ChildDic[FlowerLabel.ParticleSystem].SetActive(false);
        
        FlowerInfo.ChildDic[FlowerItemLabel.UIFlash].SetActive(false);
        FlowerInfo.ChildDic[FlowerItemLabel.UIParticleSystem].SetActive(false);

        ShadowSR.SetAlpha(1);

        StopNewFlowerEffec();

        ResourceManager.Save(this);

        RetrieveElf();

        haveAward = false;

        ResetAward();
    }

    public void RetrieveElf()
    {
        for (int i = 0; i < ElfList.Count; i++)
        {
            ResourceManager.Save(ElfList[i]);
        }

        ElfList = new List<Transform>();
    }

    public void PlayFlashLight()
    {
        FlashLightAC.SetTrigger("Play");
    }

    public void PlayNewFlowerEffec()
    {
        NewFlowerEffectMatUnit.TweenForMatFloat();
    }

    public void StopNewFlowerEffec()
    {
        NewFlowerEffectMatUnit.TweenBacMatFloat();
    }


    public void GetAward()
    {
        AudioManager.PlayClip(AudioLabel.GetCurrent);

        PlayFlashLight();

        int coin;
        if (VisitManager.InVisit)
        {
            int awardMin = Mathf.CeilToInt((float)Auxiliary.FmlParse(VisitManager.AwardMinFml, "l", Manager.GardenLevel.ToString()));
            int awardMax = Mathf.CeilToInt((float)Auxiliary.FmlParse(VisitManager.AwardMaxFml, "l", Manager.GardenLevel.ToString()));
            coin = Mathf.CeilToInt(Mathf.Lerp(awardMin, awardMax, Random.Range(0f, 1f)));
        }
        else
        {

            coin = Mathf.CeilToInt((float)Auxiliary.FmlParse(AwardCoinFml, "l", Mathf.Clamp(Manager.GardenLevel, 1, Mathf.Infinity).ToString()) * FlowerInfo.AwardCoinBuff);
            Manager.TotalFlowerAwardCoin++;
        }

        Transform flyGold = ResourceManager.Get(ResourceLabel.FlyGold, Folder.Scene, false, null, AwardGoldIcon.position, ObjType.FlyGold);
        TweenRoot tweenRoot = flyGold.GetTweenSr();
        if (tweenRoot == null)
        {
            tweenRoot = flyGold.CreateTweenSr(1, 0, 0.25f, true, false, Curve.EaseOutQuad);
            tweenRoot.AddEventOnetime(EventType.ForwardFinish, () => { ResourceManager.Save(flyGold); });
        }
        else
        {
            tweenRoot.InOrigin = true;
        }
        
        Move2D move2D = new Move2D(flyGold);
        move2D.Restrain2D = Restrain2D.Y;
        Vector3 destination = Camera.main.ScreenToWorldPoint(ResourceManager.Get(CanvasLabel.C_Coin).position);
        move2D.StartMove(destination, 0.5f, false, Curve.EaseOutQuad);

        move2D = new Move2D(flyGold);
        move2D.Restrain2D = Restrain2D.X;
        destination = Camera.main.ScreenToWorldPoint(ResourceManager.Get(CanvasLabel.C_Coin).position);
        move2D.StartMove(destination, 0.5f, false, Curve.Linear);

        DelayCall.Call
        (
            0.4f,
            () =>
            {
                tweenRoot.StartForward();
                Manager.AddCoin(coin, StaticsManager.ItemID.获得金币, StaticsManager.ConsumeModule.ClickFlower);
            }
        );

        ResourceManager.GetHudText($"{TransferLabel.CoinSprite}+{coin}", Color.white, 90, ChildDic[FlowerLabel.AwardGoldPos], ResourceManager.Get(CanvasLabel.A_HudParent), true);

        ResetAward();
    }

    public void ResetAward()
    {
        AwardGoldBk.SetActive(false);

        AwardGoldBk.GetTweenSr().Pause();
        AwardGoldIcon.GetTweenSr().Pause();

        AwardGoldBk.GetTweenSr().InOrigin = true;
        AwardGoldIcon.GetTweenSr().InOrigin = true;
    }

    public void ShowAward()
    {
        AwardGoldBk.SetX(ChildDic[FlowerLabel.AwardGoldBkLeftPos].position.x);
        AwardGoldBk.GetComponent<SpriteRenderer>().flipX = true;

        AwardGoldBk.SetY(transform.position.y + 2.5f);

        AwardGoldBk.TweenReForSr();
        AwardGoldIcon.TweenReForSr();

        AwardGoldBk.MoveOffset2D
        (
            new Vector3(0, 0.5f, 0),
            1f,
            true,
            Curve.EaseOutQuad
        );
    }


    public void OnPointerClick(PointerEventData eventData)
    {
        if (eventData.rawPointerPress.transform == transform)
        {
            if (VisitManager.InVisit)
            {
                return;
            }

            ResourceManager.Get(CanvasLabel.G_Flower).TweenForCG();

            GardenManager.ShowRetrieveCard(FlowerInfo, Slot);
        }
        else if (eventData.rawPointerPress.transform == AwardGoldBk)
        {
            HaveAward = false;
        }
    }


    public void OnDisable()
    {
        FlashLightAC.transform.GetChild(0).SetActive(false);
        FlashLightAC.transform.GetChild(1).SetActive(false);
    }
}