garden_client/Assets/Script/Manage/MiniGameManager.cs

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

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

using Random = UnityEngine.Random;

public class Award
{
    #region Config

    public static int BonusCoin;
    public static int BonusDiamond;
    public static string Info;
    
    public int Rate; 
    public int Coin;
    public int Score; 
    public int Diamond; 
    public bool FlowerFlag;
    public bool DiamondFlag;

    #region 配置

    public static int FlowerID;
    public static bool FlowerLock;

    public int DiamondMin;
    public int DiamondMax;

    public string CoinFml;
    public string FlowerFml;
    public string DiamondFml;
    public static string FlowerIDRateFml;
    public static string FlowerAmtRateFml;

    public List<float> Odds = new List<float>();
    public List<float> Standard = new List<float>();

    #endregion

    #endregion

    private float MinScore = 1;
    private float MaxScore = Mathf.Infinity;
    public void GetAward(int score)
    {
        #region 获得奖励

        #region Rate

        Score = (int)Mathf.Clamp(score, MinScore, MaxScore);

        if (Score < Standard[1])
        {
            Rate = 0;
        }
        else if (Score < Standard[2])
        {
            Rate = 1;
        }
        else
        {
            Rate = 2;
        }

        #endregion

        #region Reset

        FlowerFlag = false;
        DiamondFlag = false;

        #endregion


        StringBuilder sb = new StringBuilder();

        #region Coin

        Coin = (int)Auxiliary.FmlParse(CoinFml, "s", Score.ToString(), "l", Mathf.Clamp(Manager.Level, 1, 9999).ToString());
        Coin = (int)(Coin * (1 + Manager.SkillPlus) + BonusCoin);
        Coin = (int) Mathf.Clamp(Coin, 1, Mathf.Infinity);

        ResourceManager.Get<Text>(ObjectLabel.Da_CoinLab).text = Coin.ToString();
        ResourceManager.Get<Text>(ObjectLabel.Da_CoinLab).Resize(true, false);
        ResourceManager.Get<ContentSizeFitter>(ObjectLabel.Da_CoinGroup).enabled = true;

        ResourceManager.SetActive(ObjectLabel.Da_CoinLab, true);

        Manager.AddCoin(Coin, StaticsManager.ItemID.获得金币, StaticsManager.ConsumeModule.MiniGame);

        sb.AppendFormat("{0}{1}{2}    ", Language.GetStr(LanguageLabel.UI__J_Info0), TransferLabel.CoinSprite, Coin);

        #endregion

        #region Diamond

        float diamondRate = (float)Auxiliary.FmlParse(DiamondFml, "l", Mathf.Clamp(Manager.Level, 1, 1000).ToString());
        
        if (Random.Range(0, 1f) <= diamondRate)
        {
            DiamondFlag = true;

            Diamond = (int)(Mathf.Lerp(DiamondMin, DiamondMax, Random.Range(0, 1f)) + BonusDiamond);

            ResourceManager.Get<Text>(ObjectLabel.Da_DiamondLab).text = Diamond.ToString();
            ResourceManager.Get<Text>(ObjectLabel.Da_DiamondLab).Resize(true, false);
            ResourceManager.Get<ContentSizeFitter>(ObjectLabel.Da_DiamondGroup).enabled = true;

            ResourceManager.SetActive(ObjectLabel.Da_DiamondLab, true);

            Manager.AddDiamond(Diamond, StaticsManager.ItemID.获得钻石, StaticsManager.ConsumeModule.MiniGame);

            ResourceManager.SetActive(ObjectLabel.Da_Diamond, true);

            sb.AppendFormat("{0}{1}{2}    ", Language.GetStr(LanguageLabel.UI__J_Info0), TransferLabel.DiamondSprite, Diamond);
        }
        else
        {
            if (BonusDiamond > 0)
            {
                DiamondFlag = true;

                Diamond = BonusDiamond;

                ResourceManager.Get<Text>(ObjectLabel.Da_DiamondLab).text = Diamond.ToString();
                ResourceManager.Get<Text>(ObjectLabel.Da_DiamondLab).Resize(true, false);
                ResourceManager.Get<ContentSizeFitter>(ObjectLabel.Da_DiamondGroup).enabled = true;

                ResourceManager.SetActive(ObjectLabel.Da_DiamondLab, true);

                Manager.AddDiamond(Diamond, StaticsManager.ItemID.获得钻石, StaticsManager.ConsumeModule.MiniGame);

                ResourceManager.SetActive(ObjectLabel.Da_Diamond, true);

                sb.AppendFormat("{0}{1}{2}    ", Language.GetStr(LanguageLabel.UI__J_Info0), TransferLabel.DiamondSprite, Diamond);
            }
            else
            {
                Diamond = 0;
            }
        }

        #endregion

        #region Flower

        if (TutorialManager.NewplayerTutorial)
        {
            FlowerFlag = true;

            FlowerInfo flowerInfo = GardenManager.FlowerInfoDic[1];

            ResourceManager.SetActive(ObjectLabel.Da_FlowerIcon, true);

            ResourceManager.Get<Image>(ObjectLabel.Da_FlowerIcon).sprite = flowerInfo.Icon;
            ResourceManager.Get<Image>(ObjectLabel.Da_FlowerIcon).Resize(true, 0.25f, 0.25f);

            ResourceManager.SetText(ObjectLabel.Da_FlowerLab, flowerInfo.Name);

            sb.AppendFormat("{0}{1}{2}", Language.GetStr(LanguageLabel.UI__J_Info0), TransferLabel.FlowerSprite, flowerInfo.Name);
        }
        else
        {       
            if (!FlowerLock)
            {
                FlowerFlag = true;

                if (Random.Range(0, 1f) <= Odds[Rate])
                {
                    FlowerInfo flowerInfo = GardenManager.FlowerInfoDic[FlowerID];

                    flowerInfo.Add();


                    ResourceManager.SetActive(ObjectLabel.Da_Flower, true);

                    ResourceManager.Get<Image>(ObjectLabel.Da_FlowerIcon).sprite = flowerInfo.Icon;
                    ResourceManager.Get<Image>(ObjectLabel.Da_FlowerIcon).Resize(true, 0.25f, 0.25f);

                    ResourceManager.SetText(ObjectLabel.Da_FlowerLab, flowerInfo.Name);

                    sb.AppendFormat("{0}{1}{2}", Language.GetStr(LanguageLabel.UI__J_Info0), TransferLabel.FlowerSprite, flowerInfo.Name);
                }
                else
                {
                    ResourceManager.SetActive(ObjectLabel.Da_Flower, false);

                    ResourceManager.SetText(ObjectLabel.Da_FlowerLab, Language.GetStr(LanguageLabel.UI__Da_HigherScore));
                }
            }
        }

        #endregion

        Info = sb.ToString();

        BonusCoin = 0;
        BonusDiamond = 0;

        #endregion

        ResourceManager.SetActive(ObjectLabel.Da_Info, true);

        Auxiliary.Instance.DelayCall
            (
                () =>
                {
                    ResourceManager.Get<Text>(ObjectLabel.Da_CoinLab).SetLayoutDirty();
                    ResourceManager.Get<Text>(ObjectLabel.Da_DiamondLab).SetLayoutDirty();

                    ResourceManager.Get<ContentSizeFitter>(ObjectLabel.Da_CoinGroup).enabled = false;
                    ResourceManager.Get<ContentSizeFitter>(ObjectLabel.Da_DiamondGroup).enabled = false;

                    InitializeAnim();
                },
                2
            );
    }

    public void InitializeAnim()
    {
        #region 构造动画

        #region Reset

        ResourceManager.Get(ObjectLabel.Da_Info).TweenForCG();

        ResourceManager.SetText(ObjectLabel.Da_Tit, Language.GetStr(LanguageLabel.UI__Da_Tit1));
        ResourceManager.SetText(ObjectLabel.Da_CoinLab, "0");
        ResourceManager.SetText(ObjectLabel.Da_DiamondLab, "0");

        ResourceManager.SetActive(ObjectLabel.Da_Lab, false);
        ResourceManager.SetActive(ObjectLabel.Da_Quit, false);
        ResourceManager.SetActive(ObjectLabel.Da_Cancel, false);

        ResourceManager.SetActive(ObjectLabel.Da_CoinLab, false);
        ResourceManager.SetActive(ObjectLabel.Da_ScoreTit, false);
        ResourceManager.SetActive(ObjectLabel.Da_ScoreLab, false);
        ResourceManager.SetActive(ObjectLabel.Da_GetAward, false);
        ResourceManager.SetActive(ObjectLabel.Da_DiamondLab, false);

        ResourceManager.SetActive(ObjectLabel.Da_VGroup, true);
        ResourceManager.SetActive(ObjectLabel.Da_HGroup1, false);
        ResourceManager.SetActive(ObjectLabel.Da_FlowerGroup, false);
        ResourceManager.SetActive(ObjectLabel.Da_DiamondGroup, false);

        if (FlowerFlag)
        {
            ResourceManager.SetActive(ObjectLabel.Da_FlowerGroup, true);
        }

        if (DiamondFlag)
        {
            ResourceManager.SetActive(ObjectLabel.Da_DiamondGroup, true);
        }

        Auxiliary.Instance.DelayCall
        (
            () =>
            {
                ResourceManager.Get<VerticalLayoutGroup>(ObjectLabel.Da_VGroup).enabled = false;

                ResourceManager.SetActive(ObjectLabel.Da_CoinGroup, false);
                ResourceManager.SetActive(ObjectLabel.Da_FlowerGroup, false);
                ResourceManager.SetActive(ObjectLabel.Da_DiamondGroup, false);
            },
            1
        );


        float timeCoin = Mathf.Lerp(0, 1.5f, Mathf.Clamp01(Coin / 15f));
        float timeScore = Mathf.Lerp(0, 1.5f, Mathf.Clamp01(Score / 50f));
        float timeDiamond = Mathf.Lerp(0, 1.5f, Mathf.Clamp01(Diamond / 15f));

        float time = Mathf.Max(timeCoin, timeDiamond);
        
        ResourceManager.Get(ObjectLabel.Da_CoinLab).CreateTweenNumber(0, Coin, time, false, true, Curve.EaseOutQuad);
        ResourceManager.Get(ObjectLabel.Da_ScoreLab).CreateTweenNumber(0, Score, timeScore, false, true, Curve.EaseOutQuad);
        ResourceManager.Get(ObjectLabel.Da_DiamondLab).CreateTweenNumber(0, Diamond, time, false, true, Curve.EaseOutQuad);

        #endregion


        #region 花

        TweenRoot tween;

        if (FlowerFlag)
        {
            tween = ResourceManager.Get(ObjectLabel.Da_CoinLab).GetTweenNumber();

            tween.AddEventOnetime
            (
                EventType.ForwardFinish,
                () =>
                {
                    ResourceManager.Get(ObjectLabel.Da_FlowerGroup).TweenReForScale();
                }
            );
        }

        #endregion

        #region 按钮

        if (FlowerFlag)
        {
            tween = ResourceManager.Get(ObjectLabel.Da_FlowerGroup).GetTweenScale();

            tween.AddEventOnetime
            (
                EventType.ForwardFinish,
                () =>
                {
                    ResourceManager.Get(ObjectLabel.Da_GetAward).TweenReForCG();
                }
            );
        }
        else
        {
            tween = ResourceManager.Get(ObjectLabel.Da_CoinLab).GetTweenNumber();

            tween.AddEventOnetime
            (
                EventType.ForwardFinish,
                () =>
                {
                    ResourceManager.Get(ObjectLabel.Da_GetAward).TweenReForCG();
                }
            );
        }

        if (TutorialManager.NewplayerTutorial)
        {
            tween = ResourceManager.Get(ObjectLabel.Da_GetAward).GetTweenCG();

            tween.AddEventOnetime
            (
                EventType.ForwardFinish,
                () =>
                {
                    Tutorial.HightScreen(ResourceManager.Get(ObjectLabel.Da_Arrow0), ResourceManager.Get(ObjectLabel.Da_Arrow1), ResourceManager.Get(ObjectLabel.Da_GetAward));
                }
            );
        }

        ResourceManager.AddButtonEventOnetime
        (
            ObjectLabel.Da_GetAward,
            () =>
            {
                ResourceManager.Get(ObjectLabel.Da_VGroup).GetComponent<VerticalLayoutGroup>().enabled = true;
            }
        );

        #endregion

        #region 得分

        if (Rate == 0)
        {
            tween = ResourceManager.Get(ObjectLabel.Da_Star1).GetTweenScale();
        }
        else if (Rate == 1)
        {
            tween = ResourceManager.Get(ObjectLabel.Da_Star2).GetTweenScale();
        }
        else if (Rate == 2)
        {
            tween = ResourceManager.Get(ObjectLabel.Da_Star3).GetTweenScale();
        }

        tween.AddEventOnetime
        (
            EventType.ForwardFinish,
            () =>
            {
                ResourceManager.Get(ObjectLabel.Da_ScoreTit).TweenReForFont();
            }
        );

        tween = ResourceManager.Get(ObjectLabel.Da_ScoreTit).GetTweenFont();
        tween.InOrigin = true;

        tween.AddEventOnetime
        (
            EventType.ForwardFinish,
            () =>
            {
                ResourceManager.Get(ObjectLabel.Da_ScoreLab).TweenReForNumber();
            }
        );

        #endregion

        #region 五角星

        tween = ResourceManager.Get(ObjectLabel.Da_Star3).GetTweenScale();
        tween.InOrigin = true;

        tween = ResourceManager.Get(ObjectLabel.Da_Star2).GetTweenScale();
        tween.InOrigin = true;

        tween = ResourceManager.Get(ObjectLabel.Da_Star1).GetTweenScale();
        tween.InOrigin = true;


        tween = ResourceManager.Get(ObjectLabel.Da_Info).GetTweenCG();

        tween.AddEventOnetime
        (
            EventType.ForwardFinish,
            () =>
            {
                ResourceManager.Get(ObjectLabel.Da_Star1).TweenReForScale();

                ResourceManager.SetActive(ObjectLabel.Da_HGroup1, true);
            }
        );


        if (Rate == 0)
        {
            ResourceManager.SetActive(ObjectLabel.Da_Star2, false);
            ResourceManager.SetActive(ObjectLabel.Da_Star3, false);
        }
        else if (Rate == 1)
        {
            ResourceManager.SetActive(ObjectLabel.Da_Star2, true);
            ResourceManager.SetActive(ObjectLabel.Da_Star3, false);


            tween = ResourceManager.Get(ObjectLabel.Da_Star1).GetTweenScale();

            tween.AddEventOnetime
            (
                EventType.ForwardFinish,
                () =>
                {
                    ResourceManager.Get(ObjectLabel.Da_Star2).TweenReForScale();
                }
            );
        }
        else if (Rate == 2)
        {
            ResourceManager.SetActive(ObjectLabel.Da_Star2, true);
            ResourceManager.SetActive(ObjectLabel.Da_Star3, true);


            tween = ResourceManager.Get(ObjectLabel.Da_Star1).GetTweenScale();

            tween.AddEventOnetime
            (
                EventType.ForwardFinish,
                () =>
                {
                    ResourceManager.Get(ObjectLabel.Da_Star2).TweenReForScale();
                }
            );


            tween = ResourceManager.Get(ObjectLabel.Da_Star2).GetTweenScale();

            tween.AddEventOnetime
            (
                EventType.ForwardFinish,
                () =>
                {
                    ResourceManager.Get(ObjectLabel.Da_Star3).TweenReForScale();
                }
            );
        }

        #endregion

        #region 金币钻石

        tween = ResourceManager.Get(ObjectLabel.Da_ScoreLab).GetTweenNumber();

        tween.AddEventOnetime
        (
            EventType.ForwardFinish,
            () =>
            {
                ResourceManager.Get(ObjectLabel.Da_CoinGroup).TweenReForScale();

                if (DiamondFlag)
                {
                    ResourceManager.Get(ObjectLabel.Da_DiamondGroup).TweenReForScale();
                }
            }
        );

        tween = ResourceManager.Get(ObjectLabel.Da_CoinGroup).GetTweenScale();

        tween.AddEventOnetime
        (
            EventType.ForwardFinish,
            () =>
            {
                ResourceManager.Get(ObjectLabel.Da_CoinLab).TweenReForNumber();
            }
        );

        if (DiamondFlag)
        {
            tween = ResourceManager.Get(ObjectLabel.Da_DiamondGroup).GetTweenScale();

            tween.AddEventOnetime
            (
                EventType.ForwardFinish,
                () =>
                {
                    ResourceManager.Get(ObjectLabel.Da_DiamondLab).TweenReForNumber();
                }
            );
        }

        #endregion

        #endregion
    }


    public Award(XmlAttributeCollection attribute)
    {
        Flower.FlowerCoinFml = attribute[8].Value;
        DropGold.CoinFml = attribute[7].Value;

        Star.CD = float.Parse(attribute[9].Value);
        Star.Time = float.Parse(attribute[11].Value);

        string[] strings = attribute[10].Value.Split(',');

        GardenManager.MinStarTime = float.Parse(strings[0]);
        GardenManager.MaxStarTime = float.Parse(strings[1]);

        GardenManager.StarTimer = Mathf.Lerp(GardenManager.MinStarTime, GardenManager.MaxStarTime, Random.Range(0f, 1f));


        CoinFml = attribute[1].Value;
        FlowerFml = attribute[4].Value;
        DiamondFml = attribute[3].Value;
        FlowerIDRateFml = attribute[12].Value;
        FlowerAmtRateFml = attribute[13].Value;

        strings = attribute[2].Value.Split(',');

        DiamondMin = int.Parse(strings[0]);
        DiamondMax = int.Parse(strings[1]);

        strings = attribute[5].Value.Split(',');

        Odds = new List<float>()
        {
            float.Parse(strings[0]),
            float.Parse(strings[1]),
            float.Parse(strings[2]),
        };

        strings = attribute[6].Value.Split(',');

        Standard = new List<float>()
        {
            float.Parse(strings[0]),
            float.Parse(strings[1]),
            float.Parse(strings[2]),
        };
    }

    public static int SelectAwardFlowerID(List<int> flowerIDs)
    {
        for (int i = 0; i < flowerIDs.Count; i++)
        {
            FlowerInfo flowerInfo = GardenManager.FlowerInfoDic[flowerIDs[i]];
            float flowerIDRate = (float)Auxiliary.FmlParse(FlowerIDRateFml, "i", flowerIDs[i].ToString());
            if (Random.Range(0f, 1f) <= flowerIDRate)
            {
                float flowerAmtRate = (float) Auxiliary.FmlParse(FlowerAmtRateFml, "a", flowerInfo.amount.ToString());
                if (Random.Range(0f, 1f) <= flowerAmtRate)
                {
                    return flowerIDs[i];
                }
            }
        }

        return flowerIDs.Random(1)[0];
    }
}

public class MiniGameManager : Regist 
{
    #region Config

    public static int Score
    {
        get { return Score_; }
        set
        {
            Score_ = value;

            ResourceManager.SetText(ObjectLabel.D_ScoreLab, ScoreLab + Score_);
        }
    }
    public static bool Game
    {
        get { return Game_; }
        set
        {
            Game_ = value;

            if (Game_)
            {
                ResourceManager.SetText(ObjectLabel.D_StatusLab, Language.GetStr(LanguageLabel.UI__D_StatusLab1));
            }
            else
            {
                ResourceManager.SetText(ObjectLabel.D_StatusLab, Language.GetStr(LanguageLabel.UI__D_StatusLab0));
            }
        }
    }
    public static bool Pause
    {
        get { return Pause_; }
        set
        {
            Pause_ = value;

            if (Game)
            {
                if (Pause_)
                {
                    ResourceManager.SetText(ObjectLabel.D_StatusLab, Language.GetStr(LanguageLabel.UI__D_StatusLab2));
                }
                else
                {
                    ResourceManager.SetText(ObjectLabel.D_StatusLab, Language.GetStr(LanguageLabel.UI__D_StatusLab1));
                }
            }
            else if (Prepare)
            {
                if (Pause_)
                {
                    PrepareLab.GetStreamScale().Pause();
                }
                else
                {
                    PrepareLab.GetStreamScale().Resume();
                }
            }
        }
    }
    public static bool Panalty
    {
        get { return Panalty_; }
        set
        {
            Panalty_ = value;

            if (Game)
            {
                if (Panalty_)
                {
                    ResourceManager.SetText(ObjectLabel.D_StatusLab, Language.GetStr(LanguageLabel.UI__D_StatusLab3));
                }
                else
                {
                    ResourceManager.SetText(ObjectLabel.D_StatusLab, Language.GetStr(LanguageLabel.UI__D_StatusLab1));
                }
            }
        }
    }
    public static float GameTimer
    {
        get { return GameTimer_; }
        set
        {
            GameTimer_ = value;

            TimerLab.text = (GameTime-GameTimer_).ToString("0.0");

            TimerBk.fillAmount = GameTimer_/GameTime;

            TimerBk.material.SetFloat(MaterialLabel.TimerMatFill, TimerBk.fillAmount);
        }
    }

    private static int Score_;
    private static bool Game_;
    private static bool Pause_;
    private static bool Panalty_;
    private static float GameTimer_;

    public static Text TimerLab;
    public static Text PrepareLab;

    public static Image TimerBk;
    public static Award Award;

    public static Transform Grid;
    public static Transform Timer;
    public static Transform Begin;
    public static Transform PunchGameStatus;
    public static Transform MemoryGameStatus;
    public static Transform FindGameStatus;
    public static Transform PunchGameOperate;
    public static Transform MemoryGameOperate;
    public static Transform FindGameOperate;
    public static Transform FindGameCorrectBtn;

    public static int MaxFadeAmt = 6;
    public static List<int> IndexList = new List<int>();
    public static List<int> FindGameFlowerIDs = new List<int>();
    public static List<Drop> DropList = new List<Drop>();
    public static List<Flower> OperateList = new List<Flower>();
    public static List<Flower> IdleList = new List<Flower>();
    public static List<Flower> FadeList = new List<Flower>();
    public static Dictionary<int, Flower> FlowerDic = new Dictionary<int, Flower>();

    public static int MiniGameIndex;
    public static string ScoreLab;

    public static bool PunchGame;
    public static bool MemoryGame;
    public static bool FindGame;
    public static bool Prepare;
    public static bool FlowerLock;
    public static bool TutorialLock = true;
    public static bool DropDiamond;

    public static float OpTimer;
    public static float FadeTimer;
    public static float GoldTimer;
    public static float PanaltyTimer;
    public static float PrepareTimer;
    public static float DiamondTimer;

    public static float MinMinigameCD = 180;
    public static float MaxMinigameCD = 300;

    public static float OpTime = 1.5f;
    public static float FadeTime = 2f;
    public static float GameTime = 45f;
    public static float PanaltyTime = 1f;
    public static float PrepareTime = 3;
    public static float NewOpTime;
    public static float NewFadeTime;

    public static List<Transform> D_MemoryGameBtns = new List<Transform>();
    public static List<Transform> D_MemoryGameIcons = new List<Transform>();
    public static List<Transform> D_MemoryGameTicks = new List<Transform>();
    public static List<Transform> D_MemoryGameArrows = new List<Transform>();
    public static List<Transform> D_FindGameBtns = new List<Transform>();
    public static List<Transform> D_FindGameIcons = new List<Transform>();
    public static List<Transform> D_FindGameArrows = new List<Transform>();
    public static List<Transform> MinigameSlots = new List<Transform>();

    #endregion

    private void Update()
    {
        if (Pause)
        {
            return;
        }

        if (Game)
        {
            PunchGameThread();

            MemoryGameThread();

            FindGameThread();
        }

        if (Prepare)
        {
            PrepareThread();
        }
    }


    private float OperateDecreaseRate = 0.03f;
    private void PunchGameThread()
    {
        if (!PunchGame)
        {
            return;
        }

        GameTimer += Time.deltaTime;

        if (GameTimer >= GameTime)
        {
            GameOver();

            return;
        }

        if (Panalty)
        {
            PanaltyTimer -= Time.deltaTime;

            if (PanaltyTimer <= 0)
            {
                Panalty = false;
            }
        }

        if (IdleList.Count > 0)
        {
            OpTimer -= Time.deltaTime;

            if (OpTimer <= 0)
            {
                NewOpTime -= NewOpTime * OperateDecreaseRate;

                OpTimer = NewOpTime;

                CreateOperate();
            }
        }

        BonusThread();
    }

    private void MemoryGameThread()
    {
        if (!MemoryGame)
        {
            return;
        }

        GameTimer += Time.deltaTime;

        if (GameTimer >= GameTime)
        {
            GameOver();

            return;
        }

        if (Panalty)
        {
            PanaltyTimer -= Time.deltaTime;

            if (PanaltyTimer <= 0)
            {
                Panalty = false;
            }
        }
        
        if (FadeList.Count < MaxFadeAmt)
        {
            FadeTimer -= Time.deltaTime;
            
            if (FadeTimer <= 0)
            {
                FadeTimer = NewFadeTime;

                Fade();
            }
        }

        BonusThread();
    }

    private void FindGameThread()
    {
        if (!FindGame)
        {
            return;
        }

        GameTimer += Time.deltaTime;

        if (GameTimer >= GameTime)
        {
            GameOver();

            return;
        }

        if (Panalty)
        {
            PanaltyTimer -= Time.deltaTime;

            if (PanaltyTimer <= 0)
            {
                Panalty = false;
            }
        }

        BonusThread();
    }

    private static int DropGoldMinTime = 3;
    private static int DropGoldMaxTime = 6;
    private void BonusThread()
    {
        GoldTimer -= Time.deltaTime;

        if (GoldTimer < 0)
        {
            GoldTimer = Random.Range(DropGoldMinTime, DropGoldMaxTime);

            DropList.Add(ResourceManager.GetDrop(ObjType.DropGold));
        }

        if (DropDiamond)
        {
            DiamondTimer -= Time.deltaTime;

            if (DiamondTimer < 0)
            {
                DropDiamond = false;

                DropList.Add(ResourceManager.GetDrop(ObjType.DropDiamond));
            }
        }
    }

    private void PrepareThread()
    {
        PrepareTimer -= Time.deltaTime;

        if (PrepareTimer <= 0)
        {
            Prepare = false;

            GameBegin();
        }
    }


    public override void FirstInit()
    {
        Award = new Award(ConfigManager.GetAwardConfig());

        MiniGameIndex = ConfigManager.GetIntFormConfig(PlayerConfigLabel.MiniGameIndex);
    }

    public override void RegistReference()
    {
        Grid = ResourceManager.Get(ObjectLabel.D_Grid);
        Begin = ResourceManager.Get(ObjectLabel.D_Begin);
        Timer = ResourceManager.Get(ObjectLabel.D_Timer);

        PunchGameStatus = ResourceManager.Get(ObjectLabel.D_Status1);
        MemoryGameStatus = ResourceManager.Get(ObjectLabel.D_Status2);
        FindGameStatus = ResourceManager.Get(ObjectLabel.D_Status3);
        PunchGameOperate = ResourceManager.Get(ObjectLabel.D_Operate1);
        MemoryGameOperate = ResourceManager.Get(ObjectLabel.D_Operate2);
        FindGameOperate = ResourceManager.Get(ObjectLabel.D_Operate3);

        TimerLab = ResourceManager.Get<Text>(ObjectLabel.D_TimerLab);
        PrepareLab = ResourceManager.Get<Text>(ObjectLabel.D_PrepareLab);

        TimerBk = ResourceManager.Get<Image>(ObjectLabel.D_TimerIcon);

        MinigameSlots.Add(ResourceManager.Get(GardenLabel.SlotMini1));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.SlotMini2));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.SlotMini3));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.SlotMini4));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.SlotMini5));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.SlotMini6));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.SlotMini7));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.SlotMini8));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.SlotMini9));

        D_MemoryGameBtns.Add(ResourceManager.Get(ObjectLabel.D_FlowerBtn1));
        D_MemoryGameBtns.Add(ResourceManager.Get(ObjectLabel.D_FlowerBtn2));
        D_MemoryGameBtns.Add(ResourceManager.Get(ObjectLabel.D_FlowerBtn3));
        D_MemoryGameBtns.Add(ResourceManager.Get(ObjectLabel.D_FlowerBtn4));
        D_MemoryGameBtns.Add(ResourceManager.Get(ObjectLabel.D_FlowerBtn5));
        D_MemoryGameBtns.Add(ResourceManager.Get(ObjectLabel.D_FlowerBtn6));

        D_MemoryGameTicks.Add(ResourceManager.Get(ObjectLabel.D_FlowerTick1));
        D_MemoryGameTicks.Add(ResourceManager.Get(ObjectLabel.D_FlowerTick2));
        D_MemoryGameTicks.Add(ResourceManager.Get(ObjectLabel.D_FlowerTick3));
        D_MemoryGameTicks.Add(ResourceManager.Get(ObjectLabel.D_FlowerTick4));
        D_MemoryGameTicks.Add(ResourceManager.Get(ObjectLabel.D_FlowerTick5));
        D_MemoryGameTicks.Add(ResourceManager.Get(ObjectLabel.D_FlowerTick6));

        D_MemoryGameIcons.Add(ResourceManager.Get(ObjectLabel.D_FlowerIcon1));
        D_MemoryGameIcons.Add(ResourceManager.Get(ObjectLabel.D_FlowerIcon2));
        D_MemoryGameIcons.Add(ResourceManager.Get(ObjectLabel.D_FlowerIcon3));
        D_MemoryGameIcons.Add(ResourceManager.Get(ObjectLabel.D_FlowerIcon4));
        D_MemoryGameIcons.Add(ResourceManager.Get(ObjectLabel.D_FlowerIcon5));
        D_MemoryGameIcons.Add(ResourceManager.Get(ObjectLabel.D_FlowerIcon6));

        D_MemoryGameArrows.Add(ResourceManager.Get(ObjectLabel.D_FlowerArrow1));
        D_MemoryGameArrows.Add(ResourceManager.Get(ObjectLabel.D_FlowerArrow2));
        D_MemoryGameArrows.Add(ResourceManager.Get(ObjectLabel.D_FlowerArrow3));
        D_MemoryGameArrows.Add(ResourceManager.Get(ObjectLabel.D_FlowerArrow4));
        D_MemoryGameArrows.Add(ResourceManager.Get(ObjectLabel.D_FlowerArrow5));
        D_MemoryGameArrows.Add(ResourceManager.Get(ObjectLabel.D_FlowerArrow6));

        D_FindGameBtns.Add(ResourceManager.Get(ObjectLabel.D_FlowerBtn7));
        D_FindGameBtns.Add(ResourceManager.Get(ObjectLabel.D_FlowerBtn8));
        D_FindGameBtns.Add(ResourceManager.Get(ObjectLabel.D_FlowerBtn9));

        D_FindGameIcons.Add(ResourceManager.Get(ObjectLabel.D_FlowerIcon7));
        D_FindGameIcons.Add(ResourceManager.Get(ObjectLabel.D_FlowerIcon8));
        D_FindGameIcons.Add(ResourceManager.Get(ObjectLabel.D_FlowerIcon9));

        D_FindGameArrows.Add(ResourceManager.Get(ObjectLabel.D_FlowerArrow7));
        D_FindGameArrows.Add(ResourceManager.Get(ObjectLabel.D_FlowerArrow8));
        D_FindGameArrows.Add(ResourceManager.Get(ObjectLabel.D_FlowerArrow9));
    }


    private static int FindScore = 40;
    public static void OperateFindGame(int id, int btnIndex)
    {
        if (!Game)
        {
            return;
        }

        if (Panalty)
        {
            return;
        }

        if (FindGameFlowerIDs[0] == id)
        {
            Flower flower = IdleList.Find(tempFlower => { return tempFlower.ID == id; });

            ResourceManager.GetHudText($"+{FindScore}", Color.white, 90, flower.ChildDic[FlowerLabel.ScorePosTra], ResourceManager.Get(ObjectLabel.D_HudParent), true);

            Score += FindScore;

            flower.PlayFlashLight();

            AudioManager.PlayClip(AudioLabel.ClickButton);

            FindGameRoundEnd();
        }
        else
        {
            Panalty = true;
            PanaltyTimer = PanaltyTime;

            D_FindGameIcons[btnIndex].TweenForGra();
            D_FindGameBtns[btnIndex].Shake(0.5f, 3, new Vector3(20f, 0, 0), Curve.EaseOutQuad);

            AudioManager.PlayClip(AudioLabel.Error);
        }
    }

    private static int MemoryScore = 20;
    private static bool PlayingNewflowerEffect;
    public static void OperateMemoryGame(int index, int slotIndex)
    {
        if (Panalty || !FadeList.Valid())
        {
            return;
        }

        if (IndexList.Count == 0)
        {
            return;
        }


        if (slotIndex == IndexList[0])
        {
            D_MemoryGameBtns[index].GetComponent<Image>().material = Lib.GrayMat;
            D_MemoryGameBtns[index].GetComponent<Button>().interactable = false;
            D_MemoryGameIcons[index].GetComponent<Image>().material = Lib.GrayMat;
            D_MemoryGameTicks[index].SetActive(true);

            IndexList.RemoveAt(0);


            Flower flower = FlowerDic[slotIndex];

            ResourceManager.GetHudText($"+{MemoryScore}", Color.white, 90, flower.ChildDic[FlowerLabel.ScorePosTra], ResourceManager.Get(ObjectLabel.D_HudParent), true);

            Score += MemoryScore;

            flower.PlayFlashLight();


            if (!Award.FlowerLock && Award.FlowerID == flower.ID && !PlayingNewflowerEffect)
            {
                flower.PlayNewFlowerEffec();
                PlayingNewflowerEffect = true;
            }


            AudioManager.PlayClip(AudioLabel.ClickButton);

            TweenRoot tween = flower.FlowerIcon.TweenBacSr();

            if (IndexList.Count == 0)
            {
                tween.AddEventOnetime
                (
                    EventType.BackwardFinish,
                    () =>
                    {
                        MemoryGameRoundEnd();
                        MemoryGameRoundReset();
                        MemoryGameRoundBegin();
                    }
                );
            }
        }
        else
        {
            Panalty = true;
            PanaltyTimer = PanaltyTime;
            
            D_MemoryGameIcons[index].TweenForGra();
            D_MemoryGameBtns[index].Shake(0.5f, 3, new Vector3(20f, 0, 0), Curve.EaseOutQuad);

            AudioManager.PlayClip(AudioLabel.Error);
        }
    }

    public static void OperatePunchGame(OpType opType)
    {
        if (Panalty || !OperateList.Valid())
        {
            return;
        }

        if (OperateList[0].Operate(opType))
        {
            IdleList.Add(OperateList[0]);

            OperateList.Remove(OperateList[0]);

            if (OperateList.Count >= 2)
            {
                OperateList[0].SetFirstOp();
                OperateList[1].SetSecondOp();
            }
            else if (OperateList.Count >= 1)
            {
                OperateList[0].SetFirstOp();
            }
        }
        else
        {
            Panalty = true;
            PanaltyTimer = PanaltyTime;
        }
    }

    public static void ResetOprerate()
    {
        ResourceManager.Get<Image>(ObjectLabel.D_FlowerBtn1).material = null;
        ResourceManager.Get<Image>(ObjectLabel.D_FlowerBtn2).material = null;
        ResourceManager.Get<Image>(ObjectLabel.D_FlowerBtn3).material = null;
        ResourceManager.Get<Image>(ObjectLabel.D_FlowerBtn4).material = null;
        ResourceManager.Get<Image>(ObjectLabel.D_FlowerBtn5).material = null;
        ResourceManager.Get<Image>(ObjectLabel.D_FlowerBtn6).material = null;

        ResourceManager.Get<Button>(ObjectLabel.D_FlowerBtn1).interactable = true;
        ResourceManager.Get<Button>(ObjectLabel.D_FlowerBtn2).interactable = true;
        ResourceManager.Get<Button>(ObjectLabel.D_FlowerBtn3).interactable = true;
        ResourceManager.Get<Button>(ObjectLabel.D_FlowerBtn4).interactable = true;
        ResourceManager.Get<Button>(ObjectLabel.D_FlowerBtn5).interactable = true;
        ResourceManager.Get<Button>(ObjectLabel.D_FlowerBtn6).interactable = true;

        ResourceManager.Get<Image>(ObjectLabel.D_FlowerIcon1).material = null;
        ResourceManager.Get<Image>(ObjectLabel.D_FlowerIcon2).material = null;
        ResourceManager.Get<Image>(ObjectLabel.D_FlowerIcon3).material = null;
        ResourceManager.Get<Image>(ObjectLabel.D_FlowerIcon4).material = null;
        ResourceManager.Get<Image>(ObjectLabel.D_FlowerIcon5).material = null;
        ResourceManager.Get<Image>(ObjectLabel.D_FlowerIcon6).material = null;

        ResourceManager.SetActive(ObjectLabel.D_FlowerTick1, false);
        ResourceManager.SetActive(ObjectLabel.D_FlowerTick2, false);
        ResourceManager.SetActive(ObjectLabel.D_FlowerTick3, false);
        ResourceManager.SetActive(ObjectLabel.D_FlowerTick4, false);
        ResourceManager.SetActive(ObjectLabel.D_FlowerTick5, false);
        ResourceManager.SetActive(ObjectLabel.D_FlowerTick6, false);
    }

    public static void CreateOperate()
    {
        AudioManager.PlayClip(AudioLabel.Bubble);

        if (TutorialManager.NewplayerTutorial && TutorialLock)
        {
            Pause = true;
            TutorialLock = false;

            Flower flower = IdleList[4];
            flower.CreateOp(OperateList.Count, OpType.Water);

            OperateList.Add(flower);
            IdleList.Remove(flower);

            Tutorial.HightScreen(ResourceManager.Get(ObjectLabel.D_WaterArrow0), ResourceManager.Get(ObjectLabel.D_WaterArrow1), ResourceManager.Get(ObjectLabel.D_Water1));

            Tutorial.SetArea(OperateList[0].OperateIcon.transform, 0.1f, 0.125f);

            ResourceManager.AddButtonEventOnetime
            (
                ObjectLabel.D_Water2,
                () =>
                {
                    Pause = false;

                    Tutorial.HightDisable();
                }
            );
        }
        else
        {
            Flower flower = IdleList[Random.Range(0, IdleList.Count)];

            flower.CreateOp(OperateList.Count);

            OperateList.Add(flower);
            IdleList.Remove(flower);
        }
    }


    public static void Fade()
    {
        for (int i = 0; i < IndexList.Count; i++)
        {
            Flower flower = FlowerDic[IndexList[i]];

            if (FadeList.UniqueAdd(flower))
            {
                IdleList.Remove(flower);

                flower.PlayFlashLight();

                flower.StopNewFlowerEffec();
                PlayingNewflowerEffect = false;

                flower.FlowerIcon.TweenForSr();

                if (FadeList.Count == MaxFadeAmt)
                {
                    MemoryGameRoundBegin();
                }

                break;
            }
        }
    }

    public static void InitializeMode()
    {
        PunchGame = false;
        MemoryGame = false;
        FindGame = false;

        PunchGameOperate.SetActive(false);
        MemoryGameOperate.SetActive(false);
        FindGameOperate.SetActive(false);

        bool memoryGameAvailable = Manager.Level >= TutorialManager.MemoryMinigameTutorialLevel;
        bool findGameAvailable = GardenManager.MyFlower >= TutorialManager.MinFlowerForFindGame && Manager.Level >= TutorialManager.FindMinigameTutorialLevel;

        float punchGameThreshold;
        float memoryGameThreshold;
        float findGameThreshold;

        if (memoryGameAvailable && findGameAvailable)
        {
            punchGameThreshold = 0.33f;
            memoryGameThreshold = 0.66f;
            findGameThreshold = 1f;
        }
        else if (memoryGameAvailable)
        {
            punchGameThreshold = 0.5f;
            memoryGameThreshold = 1;
            findGameThreshold = 0;
        }
        else if (findGameAvailable)
        {
            punchGameThreshold = 0.5f;
            memoryGameThreshold = 0;
            findGameThreshold = 1;
        }
        else
        {
            punchGameThreshold = 1;
            memoryGameThreshold = 0;
            findGameThreshold = 0;
        }

        float posibility = Random.Range(0f, 1f);

        if (posibility <= punchGameThreshold)
        {
            PunchGame = true;
        }
        else if (posibility <= memoryGameThreshold)
        {
            MemoryGame = true;
        }
        else if (posibility <= findGameThreshold)
        {
            FindGame = true;
        }

        if (TutorialManager.MemoryMinigameTutorial)
        {
            PunchGame = false;
            MemoryGame = true;
            FindGame = false;
        }

        if (TutorialManager.FindMinigameTutorial)
        {
            PunchGame = false;
            MemoryGame = false;
            FindGame = true;
        }
    }


    public static void SetNewFlowerStatus()
    {
        bool newFlowerFlag = ConfigManager.GetBoolFormConfig(PlayerConfigLabel.NewFlowerFlag);

        if (newFlowerFlag)
        {
            List<int> unlockedFlowerIDList = GardenManager.UnlockedFlowerIDList;

            if (GardenManager.FirstUnlockFlowerID != -1)
                unlockedFlowerIDList.Add(GardenManager.FirstUnlockFlowerID);

            Award.FlowerID = Award.SelectAwardFlowerID(unlockedFlowerIDList);
            Award.FlowerLock = false;
        }
        else
        {
            Award.FlowerLock = true;
        }
    }

    public static void ResetNewFlowerStatus()
    {
        float flowerRate = (float) Auxiliary.FmlParse(Award.FlowerFml, "l", Manager.Level.ToString(), "f", GardenManager.MyFlower.ToString());

        if (Random.Range(0, 1f) <= flowerRate)
        {
            ConfigManager.SaveBoolToConfig(PlayerConfigLabel.NewFlowerFlag, true);
        }
        else
        {
            ConfigManager.SaveBoolToConfig(PlayerConfigLabel.NewFlowerFlag, false);
        }
    }


    public static void GameEnd()
    {
        PrepareLab.GetStreamScale().InOrigin = true;

        if (Game)
        {
            Manager.MiniLock = false;

            Manager.MiniTimer = Mathf.Lerp(MinMinigameCD, MaxMinigameCD, Random.Range(0, 1f));

            ResetNewFlowerStatus();
        }


        ResourceManager.Get(ObjectLabel.C_MiniGame).TweenForCG();

        if (Manager.MiniTimer > 0)
        {
            ResourceManager.Get(ObjectLabel.C_MiniGame).TweenForRect();
        }


        Score = 0;
        Pause = false;
        Game = false;
        Panalty = false;
        Prepare = false;
        GameTimer = GameTime;

        for (int i = 0; i < OperateList.Count; i++)
        {
            OperateList[i].GameOver();
        }

        for (int i = 0; i < IdleList.Count; i++)
        {
            IdleList[i].GameOver();
        }

        for (int i = 0; i < DropList.Count; i++)
        {
            DropList[i].Retrieve();

            DropList.RemoveAt(i--);
        }
    }

    public static void GameOver()
    {
        AudioManager.PlayClip(AudioLabel.MinigameEnd);

        Award.GetAward(Score);

        Manager.MiniGameAmt++;

        FlowerLock = false;

        GameEnd();
    }

    public static void GameEnter()
    {
        if (TutorialManager.NewplayerTutorial)
        {
            Award.FlowerID = 1;
            Award.FlowerLock = true;

            InitializeMode();
        }
        else
        {
            if (!FlowerLock)
            {
                InitializeMode();

                FlowerLock = true;
            }
        }

        SetNewFlowerStatus();

        if (TutorialManager.MemoryMinigameTutorial)
        {
            InitializeMode();
        }

        if (PunchGame)
        {
            EnterPunchGame();
        }

        if (MemoryGame)
        {
            EnterMemoryGame();
        }

        if (FindGame)
        {
            EnterFindGame();
        }

        ScoreLab = Language.GetStr(LanguageLabel.UI__D_ScoreLab);

        TimerBk.fillAmount = 0;
        TimerLab.text = GameTime.ToString("0");

        ResourceManager.Get(ObjectLabel.C_MiniGame).TweenBacCG();
    }

    private static int PunchGameSlotAmt = 9;
    private static List<int> PunchGameSlotIDs = new List<int> {0, 1, 2, 3, 4, 5, 6, 7, 8};
    public static void EnterPunchGame()
    {
        PunchGameOperate.SetActive(true);

        Timer.SetParent(PunchGameStatus);

        Grid.SetParent(PunchGameStatus);
        Begin.SetParent(PunchGameOperate);

        PrepareLab.SetParent(ResourceManager.Get(ObjectLabel.D_PrepareLayout1));


        ResourceManager.SetActive(ObjectLabel.D_Rip1, false);
        ResourceManager.SetActive(ObjectLabel.D_Water1, false);
        ResourceManager.SetActive(ObjectLabel.D_Fertilize1, false);

        ResourceManager.SetActive(ObjectLabel.D_Begin, true);
        ResourceManager.SetActive(ObjectLabel.D_DescA, true);


        if (Award.FlowerLock)
        {
            for (int i = 0; i < PunchGameSlotAmt; i++)
            {
                while (true)
                {
                    FlowerInfo flowerInfo = GardenManager.FlowerInfoDic.Random();

                    if (flowerInfo.Unlock)
                    {
                        IdleList.Add(ResourceManager.GetFlower(flowerInfo, MinigameSlots[i]));

                        break;
                    }
                }
            }
        }
        else
        {
            List<int> idList = new List<int>();

            idList = new List<int>(PunchGameSlotIDs);

            int specialSlotID = idList.Random(1, true, true)[0];

            Flower flower = ResourceManager.GetFlower(GardenManager.FlowerInfoDic[Award.FlowerID], MinigameSlots[specialSlotID]);

            flower.PlayNewFlowerEffec();

            IdleList.Add(flower);

            for (int i = 0; i < idList.Count; i++)
            {
                while (true)
                {
                    FlowerInfo flowerInfo = GardenManager.FlowerInfoDic.Random();

                    if (flowerInfo.Unlock)
                    {
                        flower = ResourceManager.GetFlower(flowerInfo, MinigameSlots[idList[i]]);

                        IdleList.Add(flower);

                        break;
                    }
                }
            }
        }
    }

    private static List<int> MemoryGameSlotIDs = new List<int> {0, 1, 3, 4, 6, 7};
    public static void EnterMemoryGame()
    {
        MemoryGameOperate.SetActive(true);

        Timer.SetParent(MemoryGameStatus);

        Grid.SetParent(MemoryGameStatus);
        Begin.SetParent(MemoryGameOperate);

        PrepareLab.SetParent(ResourceManager.Get(ObjectLabel.D_PrepareLayout2));


        ResetOprerate();

        ResourceManager.Get(ObjectLabel.D_Mask).TweenBacGra();

        ResourceManager.SetActive(ObjectLabel.D_FlowerBtn1, false);
        ResourceManager.SetActive(ObjectLabel.D_FlowerBtn2, false);
        ResourceManager.SetActive(ObjectLabel.D_FlowerBtn3, false);
        ResourceManager.SetActive(ObjectLabel.D_FlowerBtn4, false);
        ResourceManager.SetActive(ObjectLabel.D_FlowerBtn5, false);
        ResourceManager.SetActive(ObjectLabel.D_FlowerBtn6, false);

        ResourceManager.SetActive(ObjectLabel.D_Begin, true);
        ResourceManager.SetActive(ObjectLabel.D_DescB, true);

        List<int> idList = new List<int>(MemoryGameSlotIDs);

        FlowerDic = new Dictionary<int, Flower>();

        Flower flower;

        if (Award.FlowerLock)
        {
            for (int i = 0; i < idList.Count; i++)
            {
                while (true)
                {
                    FlowerInfo flowerInfo = GardenManager.FlowerInfoDic.Random();

                    if (flowerInfo.Unlock)
                    {
                        flower = ResourceManager.GetFlower(flowerInfo, MinigameSlots[idList[i]]);

                        IdleList.Add(flower);

                        FlowerDic.Add(idList[i], flower);

                        break;
                    }
                }
            }
        }
        else
        {
            int specialSlotID = idList.Random(1, true, true)[0];

            flower = ResourceManager.GetFlower(GardenManager.FlowerInfoDic[Award.FlowerID], MinigameSlots[specialSlotID]);

            flower.PlayNewFlowerEffec();

            IdleList.Add(flower);

            FlowerDic.Add(specialSlotID, flower);

            for (int i = 0; i < idList.Count; i++)
            {
                while (true)
                {
                    FlowerInfo flowerInfo = GardenManager.FlowerInfoDic.Random();

                    if (flowerInfo.Unlock)
                    {
                        flower = ResourceManager.GetFlower(flowerInfo, MinigameSlots[idList[i]]);

                        IdleList.Add(flower);

                        FlowerDic.Add(idList[i], flower);

                        break;
                    }
                }
            }
        }

        for (int i = 0; i < IdleList.Count; i++)
        {
            IdleList[i].FlowerIcon.CreateTweenSr(1, 0, 0.25f, true, false, Curve.EaseOutQuad, false, true);
        }
    }

    public static void EnterFindGame()
    {
        FindGameOperate.SetActive(true);

        ResourceManager.SetActive(ObjectLabel.D_Begin, true);
        ResourceManager.SetActive(ObjectLabel.D_DescC, true);

        ResourceManager.SetActive(ObjectLabel.D_FlowerBtn7, false);
        ResourceManager.SetActive(ObjectLabel.D_FlowerBtn8, false);
        ResourceManager.SetActive(ObjectLabel.D_FlowerBtn9, false);

        Begin.SetParent(FindGameOperate);
        Timer.SetParent(FindGameStatus);
        Grid.SetParent(FindGameStatus);

        PrepareLab.SetParent(ResourceManager.Get(ObjectLabel.D_PrepareLayout3));

        FindGameRoundReset(true);
    }

    private static int DropDiamondMinIndex = 5; 
    private static int DropDiamondMaxIndex = 9; 
    private static float DropDiamondRate = 0.01f;
    private static float DropDiamondOffsetTime = 5;
    public static void GameBegin()
    {
        ConfigManager.SaveBoolToConfig(PlayerConfigLabel.NewFlowerFlag, false);

        Game = true;
        MiniGameIndex++;

        Score = 0;

        OpTimer = OpTime;
        FadeTimer = FadeTime;
        GoldTimer = Random.Range(DropGoldMinTime, DropGoldMaxTime);
        GameTimer = 0;
        NewOpTime = OpTime;
        NewFadeTime = FadeTime;
        DiamondTimer = Random.Range(0f, GameTime - DropDiamondOffsetTime);

        StaticsManager.GetInstance().UseItem(StaticsManager.ItemID.开始小游戏, StaticsManager.ItemType.小游戏, "1", StaticsManager.ConsumeModule.None);

        if (PunchGame)
        {
            for (int i = 0; i < IdleList.Count; i++)
            {
                IdleList[i].GameBegin();
            }
        }

        if (MemoryGame)
        {
            MemoryGameRoundReset();
        }

        if (FindGame)
        {
            FindGameRoundBegin(true);
        }

        if (Random.Range(DropDiamondMinIndex, DropDiamondMaxIndex) <= MiniGameIndex)
        {
            MiniGameIndex = 0;

            DropDiamond = true;
        }
        else
        {
            if (Random.Range(0, 1f) <= DropDiamondRate)
            {
                DropDiamond = true;
            }
            else
            {
                DropDiamond = false;
            }
        }
    }

    public static void GamePrepare()
    {
        Prepare = true;
        PrepareTimer = PrepareTime;

        ResourceManager.Get(ObjectLabel.D_Begin).SetActive(false);
        ResourceManager.Get(ObjectLabel.D_DescA).SetActive(false);
        ResourceManager.Get(ObjectLabel.D_DescB).SetActive(false);
        ResourceManager.Get(ObjectLabel.D_DescC).SetActive(false);

        if (PunchGame)
        {
            ResourceManager.Get(ObjectLabel.D_Rip1).SetActive(true);
            ResourceManager.Get(ObjectLabel.D_Water1).SetActive(true);
            ResourceManager.Get(ObjectLabel.D_Fertilize1).SetActive(true);
        }

        if (MemoryGame)
        {
            ResourceManager.Get(ObjectLabel.D_Mask).TweenForGra();

            ResourceManager.SetActive(ObjectLabel.D_FlowerBtn1, true);
            ResourceManager.SetActive(ObjectLabel.D_FlowerBtn2, true);
            ResourceManager.SetActive(ObjectLabel.D_FlowerBtn3, true);
            ResourceManager.SetActive(ObjectLabel.D_FlowerBtn4, true);
            ResourceManager.SetActive(ObjectLabel.D_FlowerBtn5, true);
            ResourceManager.SetActive(ObjectLabel.D_FlowerBtn6, true);

            float deltaSIzeX = 1.0625f;
            float deltaSIzeY = 1.0625f;
            ResourceManager.SetSprite(ObjectLabel.D_FlowerIcon1, FlowerDic[0].FlowerInfo.Icon).Resize(true, deltaSIzeX, deltaSIzeY);
            ResourceManager.SetSprite(ObjectLabel.D_FlowerIcon2, FlowerDic[1].FlowerInfo.Icon).Resize(true, deltaSIzeX, deltaSIzeY);
            ResourceManager.SetSprite(ObjectLabel.D_FlowerIcon3, FlowerDic[3].FlowerInfo.Icon).Resize(true, deltaSIzeX, deltaSIzeY);
            ResourceManager.SetSprite(ObjectLabel.D_FlowerIcon4, FlowerDic[4].FlowerInfo.Icon).Resize(true, deltaSIzeX, deltaSIzeY);
            ResourceManager.SetSprite(ObjectLabel.D_FlowerIcon5, FlowerDic[6].FlowerInfo.Icon).Resize(true, deltaSIzeX, deltaSIzeY);
            ResourceManager.SetSprite(ObjectLabel.D_FlowerIcon6, FlowerDic[7].FlowerInfo.Icon).Resize(true, deltaSIzeX, deltaSIzeY);
        }

        PrepareLab.StreamForScale();
    }


    public static void MemoryGameRoundEnd()
    {
        ResourceManager.Get(ObjectLabel.D_Mask).TweenForGra();
    }

    private static float MemoryGameDecreaseRate = 0.3f;
    public static void MemoryGameRoundReset()
    {
        for (int i = 0; i < FadeList.Count; i++)
        {
            IdleList.Add(FadeList[i]);
        }


        NewFadeTime -= NewFadeTime * MemoryGameDecreaseRate;

        FadeTimer = NewFadeTime;


        FadeList = new List<Flower>();

        IndexList = new List<int>();

        List<int> randomList = new List<int>(MemoryGameSlotIDs);

        for (int i = 0; i < randomList.Count; i++)
        {
            IndexList.Add(randomList.Random(1, true, true)[0]);

            i--;
        }

        ResetOprerate();
    }

    public static void MemoryGameRoundBegin()
    {
        ResourceManager.Get(ObjectLabel.D_Mask).TweenBacGra();

        if (TutorialManager.MemoryMinigameTutorial)
        {
            TutorialManager.PlayMemoryGame();
        }
    }

    private static List<int> FindGameSlotIDs = new List<int> {0, 1, 2, 3, 4, 5, 6, 7, 8};
    public static void FindGameRoundEnd()
    {
        if (IdleList[0].ID == Award.FlowerID)
        {
            IdleList[0].StopNewFlowerEffec();
        }


        for (int i = 0; i < IdleList.Count; i++)
        {
            IdleList[i].FlowerIcon.TweenForSr();
        }

        ResourceManager.Get(ObjectLabel.D_FlowerBtn7).TweenBacCG();
        ResourceManager.Get(ObjectLabel.D_FlowerBtn8).TweenBacCG();
        ResourceManager.Get(ObjectLabel.D_FlowerBtn9).TweenBacCG();

        Auxiliary.Instance.DelayCall
        (
            () =>
            {
                if (Game)
                {
                    FindGameRoundReset();

                    FindGameRoundBegin();
                }
            },
            1.5f
        );
    }

    public static void FindGameRoundReset(bool firstRound = false)
    {
        ExtList.ForEach(IdleList, flower => { flower.FlowerIcon.SetAlpha(1); flower.FlowerIcon.SetActive(true); flower.Retrieve();});

        IdleList = new List<Flower>();

        FindGameFlowerIDs = new List<int>();

        List<int> slotIDs = new List<int>(FindGameSlotIDs);


        FlowerInfo flowerInfo;

        if (firstRound && !Award.FlowerLock)
        {
            flowerInfo = GardenManager.FlowerInfoDic[Award.FlowerID];
        }
        else
        {
            flowerInfo = GardenManager.FlowerInfoDic.Random(false, flowerIndo => { return flowerIndo.Unlock; });
        }

        FindGameFlowerIDs.Add(flowerInfo.ID_);

        IdleList.Add(ResourceManager.GetFlower(flowerInfo, MinigameSlots[slotIDs.Random(1, true, true)[0]]));

        while (slotIDs.Count > 0)
        {
            flowerInfo = GardenManager.FlowerInfoDic.Random(false, info => { return info.Unlock && info.ID_ != FindGameFlowerIDs[0]; });

            if (slotIDs.Count == 1)
            {
                if (!FindGameFlowerIDs.Contains(flowerInfo.ID_))
                {
                    continue;
                }
            }
            else
            {
                FindGameFlowerIDs.UniqueAdd(flowerInfo.ID_);
            }

            int amt = Mathf.Min(Random.Range(2, 9), slotIDs.Count);

            for (int i = 0; i < amt; i++)
            {
                IdleList.Add(ResourceManager.GetFlower(flowerInfo, MinigameSlots[slotIDs.Random(1, true, true)[0]]));
            }
        }

        for (int i = 0; i < IdleList.Count; i++)
        {
            IdleList[i].FlowerIcon.CreateTweenSr(1, 0, 0.25f, true, false, Curve.EaseOutQuad, false, true).AlphaOnly = true;

            IdleList[i].FlowerIcon.GetTweenSr().InDestination = true;
        }


        List<int> idList = new List<int>()
        {
            FindGameFlowerIDs[0],
        };

        if (FindGameFlowerIDs.Count == 2)
        {
            idList.Add(FindGameFlowerIDs[1]);
            idList.Add(FindGameFlowerIDs[1]);

            idList.RemoveAt(0);
            idList.Insert(Random.Range(0, 3), FindGameFlowerIDs[0]);
        }
        else if (FindGameFlowerIDs.Count > 2)
        {
            idList.AddRange(FindGameFlowerIDs.Random(2, true, false, id => { return id != idList[0]; }));

            idList = idList.Disturb();
        }
        else
        {
            throw new Exception();
        }

        float deltaSIzeX = 1.0625f;
        float deltaSIzeY = 1.0625f;
        ResourceManager.SetSprite(ObjectLabel.D_FlowerIcon7, GardenManager.FlowerInfoDic[idList[0]].Icon).Resize(true, deltaSIzeX, deltaSIzeY);
        ResourceManager.SetSprite(ObjectLabel.D_FlowerIcon8, GardenManager.FlowerInfoDic[idList[1]].Icon).Resize(true, deltaSIzeX, deltaSIzeY);
        ResourceManager.SetSprite(ObjectLabel.D_FlowerIcon9, GardenManager.FlowerInfoDic[idList[2]].Icon).Resize(true, deltaSIzeX, deltaSIzeY);

        for (int i = 0; i < idList.Count; i++)
        {
            int id = idList[i];
            int index = i;

            if (firstRound && TutorialManager.FindMinigameTutorial && id == FindGameFlowerIDs[0])
            {
                FindGameCorrectBtn = D_FindGameBtns[i];
                Button button = FindGameCorrectBtn.GetComponent<Button>();
                button.onClick.RemoveAllListeners();
                button.onClick.AddListener(() => { OperateFindGame(id, index); TutorialManager.EndClickCorrectButton(); });
            }
            else
            {
                Button button = D_FindGameBtns[i].GetComponent<Button>();
                button.onClick.RemoveAllListeners();
                button.onClick.AddListener(() => { OperateFindGame(id, index); });
            }
        }
    }

    public static void FindGameRoundBegin(bool firstRound = false)
    {
        if (firstRound && !Award.FlowerLock)
        {
            IdleList[0].PlayNewFlowerEffec();
        }

        ResourceManager.Get(ObjectLabel.D_FlowerBtn7).TweenReForCG();
        ResourceManager.Get(ObjectLabel.D_FlowerBtn8).TweenReForCG();
        ResourceManager.Get(ObjectLabel.D_FlowerBtn9).TweenReForCG();

        for (int i = 0; i < IdleList.Count; i++)
        {
            IdleList[i].FlowerIcon.TweenBacSr();
        }

        if (firstRound && TutorialManager.FindMinigameTutorial)
        {
            TutorialManager.ShowCorrectButton(FindGameCorrectBtn.GetChild(1), FindGameCorrectBtn);
        }
    }


    public static int MemoryGameIndexMap(int slotIndex)
    {
        if (slotIndex == 0)
        {
            return 0;
        }
        else if (slotIndex == 1)
        {
            return 1;
        }
        else if (slotIndex == 3)
        {
            return 2;
        }
        else if (slotIndex == 4)
        {
            return 3;
        }
        else if (slotIndex == 6)
        {
            return 4;
        }
        else if (slotIndex == 7)
        {
            return 5;
        }
        else
        {
            throw new Exception();
        }
    }


    public void OnApplicationPause(bool pause)
    {
        if (!pause)
        {
            if (!TutorialManager.NewplayerTutorial)
            {
                if (Game || Prepare)
                {
                    ResourceManager.Get<Button>(ObjectLabel.D_Quit).onClick.Invoke();
                }
            }
        }
    }
}