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 FlowerInfo
{
    #region 变量

    public bool Plant
    {
        get { return Plant_; }
        set
        {
            Plant_ = value;

            if (Plant_)
            {
                Text.SetActive(true);

                ManaLan.Add(Text, new LanStr("Object", "FlowerItemG_Lab"));

                UIPartical.Begin();
            }
            else
            {
                Text.SetActive(false);
            }
        }
    }
    public bool Unlock
    {
        get { return Unlock_; }
        set
        {
            Unlock_ = value;

            if (Unlock_)
            {
                Image.material = null;

                if (Special)
                {
                    if (ManaGarden.MyFlowerSpec == 0)
                    {
                        ManaReso.Get("G_Regular").TweenForVec();

                        ManaReso.SetActive("G_Special", true);
                    }

                    ManaGarden.MyFlowerSpec++;
                }
                else
                {
                    ManaGarden.MyFlowerRegu++;
                }

                ManaCenter.SkillPlus += 0.1f;
            }
        }
    }

    public string ID
    {
        get
        {
            return "Flower" + ID_;
        }
    }
    public string Name
    {
        get
        {
            return Language.GetStr("FlowerName", ID);
        }
    }
    public string Description
    {
        get { return Language.GetStr("FlowerDesc", ID); }
    }

    public Sprite Icon
    {
        get { return ManaReso.LoadSprite(Icon_, Folder.Atlas2); }
    }

    public int ID_;
    public bool Plant_;
    public bool Unlock_;
    public string Icon_;

    public bool Special;

    public int UnlockAmt;
    public Current UnlockCur;

    public Slot Slot;
    public Text Text;
    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 = ManaReso.Get("FlowerItem", Folder.UI, false, ManaReso.Get("G_RegularGrid"),  false, ObjType.FlowerItem);

        Auxiliary.CompileDic(FlowerItem, ChildDic);

        Text = ChildDic["Lab"].GetComponent<Text>();
        Image = ChildDic["Icon"].GetComponent<Image>();
        Button = ChildDic["FlowerItem"].GetComponent<Button>();
        UIPartical = ChildDic["UIParticle System"].GetComponent<UIPartical>();

        ID_ = int.Parse(attribute[0].Value);
        Icon_ = attribute[5].Value;

        UnlockCur = Auxiliary.CurrentParse(attribute[3].Value);
        UnlockAmt = Auxiliary.IntParse(attribute[4].Value, 0);

        Image.sprite = Icon;

        Image.Resize(true, 0.25f, 0.25f);

        Button.onClick.AddListener
        (
            () =>
            {
                if (Plant)
                {
                    ManaAudio.PlayClip(Clip.BtnClip);

                    ManaGarden.ShowRetrieveCard(this);
                }
                else if (Unlock)
                {
                    ManaGarden.PlantFlower(this);
                }
                else
                {
                    ManaGarden.ShowUnlockCard(this);
                }
            }
        );
    }
}

public class Flower : Regist, IPointerClickHandler
{
    #region 变量

    #region MiniGame

    public OpType OpType
    {
        get { return OpType_; }
        set
        {
            OpType_ = value;

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

    public OpType OpType_;

    public SpriteRenderer FlowerIcon;
    public SpriteRenderer OperateBk;
    public SpriteRenderer OperateIcon;
    public SpriteRenderer OperateOutline;

    #endregion

    public bool Award
    {
        get { return Award_; }
        set
        {
            Award_ = value;

            if (Award_)
            {
                ShowAward();
            }
            else
            {
                GetAward();
            }
        }
    }
    public Sprite RipSprite
    {
        get
        {
            return ManaReso.LoadSprite("Rip", Folder.UI);
        }
    }
    public Sprite WaterSprite
    {
        get
        {
            return ManaReso.LoadSprite("Water", Folder.UI);
        }
    }
    public Sprite FertilizeSprite
    {
        get
        {
            return ManaReso.LoadSprite("Fertilize", Folder.UI);
        }
    }
    public FlowerInfo FlowerInfo
    {
        get { return FlowerInfo_; }
        set
        {
            FlowerInfo_ = value;

            ID = FlowerInfo.ID_;
            FlowerIcon.sprite = FlowerInfo.Icon;
        }
    }

    public bool Award_;
    private FlowerInfo FlowerInfo_;

    public int ID;

    public Slot Slot;
    public Animator ParticleAC;

    public Transform GoldBk;
    public Transform GoldIcon;
    public Transform NewFlowerEffect;

    public List<Transform> ElfList = new List<Transform>();

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


    public static string CoinFml;

    #endregion

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

        enabled = true;

        Auxiliary.CompileDic(transform, ChildDic);

        GoldBk = ChildDic["GoldBk"];
        GoldIcon = ChildDic["GoldIcon"];
        ParticleAC = ChildDic["FlashLight"].GetComponent<Animator>();
        FlowerIcon = ChildDic["FlowerIcon"].GetComponent<SpriteRenderer>();
        OperateBk = ChildDic["OperateBk"].GetComponent<SpriteRenderer>();
        OperateIcon = ChildDic["OperateIcon"].GetComponent<SpriteRenderer>();
        OperateOutline = ChildDic["OperateOutline1"].GetComponent<SpriteRenderer>();
        NewFlowerEffect = ChildDic["NewFlowerEffect"];

        GoldBk.CreateTweenSr(0, 1, 1f, false, true, Curve.EaseOutQuad);
        GoldIcon.CreateTweenSr(0, 1, 1f, false, true, Curve.EaseOutQuad);


        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();
        };

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

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

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

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

        return false;
    }


    #region MiniGame

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

        ChildDic["MiniGame"].SetActive(false);

        OperateBk.TweenBacScale();
    }

    public void GameBegin()
    {
        ChildDic["MiniGame"].SetActive(true);

        OperateBk.SetActive(false);
    }


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

        OperateIcon.SetAlpha(1);
        OperateOutline.SetAlpha(1);

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

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

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

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

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


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

        OperateBk.SetActive(true);

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

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

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

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


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

        if (opType != OpType)
        {
            OperateBk.TweenForSr();
            FlowerIcon.TweenForSr();

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

            ManaAudio.PlayClip(Clip.ErrorClip);

            return false;
        }
        else
        {
            ManaReso.GetHudText("+15", Color.white, 90, ChildDic["ScorePosTra"], ManaReso.Get("D_HudParent"), true);

            ManaMiniGame.Score += 15;

            PlayParticle();

            OpType = OpType.Null;

            OperateBk.TweenBacScale();

            OperateBk.SetActive(false);
            OperateIcon.SetActive(false);
            OperateOutline.SetActive(false);

            ManaAudio.PlayClip(Clip.BtnClip);

            return true;
        }
    }

    #endregion


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

    public void Retrieve()
    {
        ChildDic["Flash"].SetActive(false);
        ChildDic["Particle System"].SetActive(false);
        
        FlowerInfo.ChildDic["UIFlash"].SetActive(false);
        FlowerInfo.ChildDic["UIParticle System"].SetActive(false);

        NewFlowerEffect.SetActive(false);

        ManaReso.Save(this);

        RetrieveElf();

        Award_ = false;

        ResetAward();
    }

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

        ElfList = new List<Transform>();
    }

    public void PlayParticle()
    {
        ParticleAC.SetTrigger("Play");
    }


    public void GetAward()
    {
        ManaAudio.PlayClip(Clip.CurrentClip);

        PlayParticle();

        int coin;

        if (ManaVisit.InVisit)
        {
            int awardMin = Mathf.CeilToInt((float) Auxiliary.FmlParse(ManaVisit.AwardMinFml, "l", ManaCenter.Level.ToString()));
            int awardMax = Mathf.CeilToInt((float) Auxiliary.FmlParse(ManaVisit.AwardMaxFml, "l", ManaCenter.Level.ToString()));

            coin = Mathf.CeilToInt(Mathf.Lerp(awardMin, awardMax, Random.Range(0f, 1f)));

            ManaCenter.Coin += coin;
        }
        else
        {
            coin = Mathf.CeilToInt((float)Auxiliary.FmlParse(CoinFml, "l", Mathf.Clamp(ManaCenter.Level, 1, Mathf.Infinity).ToString()));

            ManaCenter.Coin += coin;
            ManaCenter.FlowerCoin++;
        }

        ManaReso.GetHudText("<(金币)>+" + coin, Color.white, 90, ChildDic["GoldPosTra"], ManaReso.Get("A_HudParent"), true);

        ResetAward();
    }

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

        GoldBk.GetTweenSr().Pause();
        GoldIcon.GetTweenSr().Pause();

        GoldBk.GetTweenSr().InOrigin = true;
        GoldIcon.GetTweenSr().InOrigin = true;
    }

    public void ShowAward()
    {
        GoldBk.SetY(transform.position.y + 2.5f);

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


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

            ManaReso.Get("G_Flower").TweenForCG();

            ManaGarden.ShowRetrieveCard(FlowerInfo);
        }
        else if (eventData.rawPointerPress.transform == GoldBk)
        {
            Award = false;
        }
    }
}