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 System.Linq;
using Random = UnityEngine.Random;

public class MinigameAward
{
    #region Config

    public static int DropCoin;
    public static int DropDiamond;
    public static string DisplayContent;
    
    public int Rate; //小游戏评级

    public int Score;
    public float MinScore = 1;
    public float MaxScore = Mathf.Infinity;

    public int CoinAward;
    public int DiamondAward; 
    public bool HaveDiamondFlag;

    public static int UnlockFlowerID;
    public static bool UnlockFlowerFlag;
    public static bool HaveNewFlowerFlag;

    #region 配置

    public int MinDiamondAward;
    public int MaxDiamondAward;

    public string CoinAwardFml;
    public string UnlockFlowerFml;
    public string DiamondAwardFml;
    public static string FlowerIDRateFml; //根据花的ID计算获得的概率
    public static string FlowerAmtRateFml; //根据花的数量计算获得的概率

    public List<float> RateStandard = new List<float>();
    public List<float> UnlockFlowerRate = new List<float>();

    #endregion

    #endregion

    public void GetAward(int score)
    {
        #region 获得奖励

        #region Rate

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

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

        #endregion

        #region Reset

        UnlockFlowerFlag = false;
        HaveDiamondFlag = false;

        #endregion


        StringBuilder sb = new StringBuilder();

        #region Coin

        CoinAward = (int)Auxiliary.FmlParse(CoinAwardFml, "s", Score.ToString(), "l", Mathf.Clamp(Manager.GardenLevel, 1, 9999).ToString());
        CoinAward = (int)(CoinAward * (1 + Manager.SkillPlus) + DropCoin);
        CoinAward = (int) Mathf.Clamp(CoinAward, 1, Mathf.Infinity);

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

        ResourceManager.SetActive(CanvasLabel.Da_CoinLab, true);

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

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

        #endregion

        #region Diamond

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

            DiamondAward = (int)(Mathf.Lerp(MinDiamondAward, MaxDiamondAward, Random.Range(0, 1f)) + DropDiamond);

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

            ResourceManager.SetActive(CanvasLabel.Da_DiamondLab, true);

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

            ResourceManager.SetActive(CanvasLabel.Da_Diamond, true);

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

                DiamondAward = DropDiamond;

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

                ResourceManager.SetActive(CanvasLabel.Da_DiamondLab, true);

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

                ResourceManager.SetActive(CanvasLabel.Da_Diamond, true);

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

        #endregion

        #region Flower

        if (TutorialManager.NewplayerTutorial)
        {
            UnlockFlowerFlag = true;

            FlowerInfo flowerInfo = GardenManager.FlowerInfoDictionary[1];

            ResourceManager.SetActive(CanvasLabel.Da_FlowerIcon, true);

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

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

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

                if (Random.Range(0, 1f) <= UnlockFlowerRate[Rate])
                {
                    FlowerInfo flowerInfo = GardenManager.FlowerInfoDictionary[UnlockFlowerID];

                    flowerInfo.Add();


                    ResourceManager.SetActive(CanvasLabel.Da_Flower, true);

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

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

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

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

        #endregion

        DisplayContent = sb.ToString();

        DropCoin = 0;
        DropDiamond = 0;

        #endregion

        ResourceManager.SetActive(CanvasLabel.Da_Info, true);

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

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

                    SetupAnimation();
                },
                2
            );
    }

    public static int SelectUnlockFlowerID(List<int> flowerIDs)
    {
        //foreach (var flowerID in flowerIDs)
        //{
        //    Debug.Log(flowerID);    
        //}

        List<float> weights = new List<float>();
        for (int j = 0; j < flowerIDs.Count; j++)
        {
            FlowerInfo flowerInfo = GardenManager.FlowerInfoDictionary[flowerIDs[j]];
            float flowerIDRate = (float) Auxiliary.FmlParse(FlowerIDRateFml, "i", flowerIDs[j].ToString());
            float flowerAmtRate = (float) Auxiliary.FmlParse(FlowerAmtRateFml, "a", flowerInfo.amount.ToString());
            float weight = flowerIDRate*flowerAmtRate;
            weights.Add(weight);
        }

        for (int i = 0; i < 20; i++)
        {
            for (int j = 0; j < weights.Count; j++)
            {
                weights[j] = weights[j]*(1 + i*0.1f);
                if (Random.Range(0f, 1f) <= weights[j])
                {
                    return flowerIDs[j];
                }
            }
        }
        return flowerIDs[weights.MyMaxIndex(f => f)];
    }

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

        #region Reset

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

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

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

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

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

        if (UnlockFlowerFlag)
        {
            ResourceManager.SetActive(CanvasLabel.Da_FlowerGroup, true);
        }

        if (HaveDiamondFlag)
        {
            ResourceManager.SetActive(CanvasLabel.Da_DiamondGroup, true);
        }

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

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


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

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

        #endregion


        #region 花

        TweenRoot tween;

        if (UnlockFlowerFlag)
        {
            tween = ResourceManager.Get(CanvasLabel.Da_CoinLab).GetTweenNumber();

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

        #endregion

        #region 按钮

        if (UnlockFlowerFlag)
        {
            tween = ResourceManager.Get(CanvasLabel.Da_FlowerGroup).GetTweenScale();

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

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

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

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

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

        #endregion

        #region 得分

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

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

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

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

        #endregion

        #region 五角星

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

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

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


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

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

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


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


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

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


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

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


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

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

        #endregion

        #region 金币钻石

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

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

                if (HaveDiamondFlag)
                {
                    ResourceManager.Get(CanvasLabel.Da_DiamondGroup).TweenReForScale();
                }
            }
        );

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

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

        if (HaveDiamondFlag)
        {
            tween = ResourceManager.Get(CanvasLabel.Da_DiamondGroup).GetTweenScale();

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

        #endregion

        #endregion
    }


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

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

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

        GardenManager.MinCreateStarTime = float.Parse(strings[0]);
        GardenManager.MaxCreateStarTime = float.Parse(strings[1]);

        GardenManager.CreateStarTimer = Mathf.Lerp(GardenManager.MinCreateStarTime, GardenManager.MaxCreateStarTime, Random.Range(0f, 1f));


        CoinAwardFml = attribute[1].Value;
        UnlockFlowerFml = attribute[4].Value;
        DiamondAwardFml = attribute[3].Value;
        FlowerIDRateFml = attribute[12].Value;
        FlowerAmtRateFml = attribute[13].Value;

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

        MinDiamondAward = int.Parse(strings[0]);
        MaxDiamondAward = int.Parse(strings[1]);

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

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

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

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

public enum MiniGameType
{
    None, //需要重置
    Punch, //打地鼠
    Memory, //记住花的消失顺序
    Find, //找落单的花
}

public class MiniGameManager : Regist 
{
    #region Config

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

            ResourceManager.SetText(CanvasLabel.D_ScoreLab, ScoreTextPrefix + score);
        }
    }
    private static int score;
    public static string ScoreTextPrefix;

    public static bool Game
    {
        get { return game; }
        set
        {
            game = value;

            if (game)
            {
                ResourceManager.SetText(CanvasLabel.D_StatusLab, Language.GetStr(LanguageLabel.UI__D_StatusLab1));
            }
            else
            {
                ResourceManager.SetText(CanvasLabel.D_StatusLab, Language.GetStr(LanguageLabel.UI__D_StatusLab0));
            }
        }
    }
    private static bool game;

    public static bool Pause
    {
        get { return pause; }
        set
        {
            pause = value;

            if (Game)
            {
                if (pause)
                {
                    ResourceManager.SetText(CanvasLabel.D_StatusLab, Language.GetStr(LanguageLabel.UI__D_StatusLab2));
                }
                else
                {
                    ResourceManager.SetText(CanvasLabel.D_StatusLab, Language.GetStr(LanguageLabel.UI__D_StatusLab1));
                }
            }
            else if (IsPrepare)
            {
                if (pause)
                {
                    PrepareText.GetStreamScale().Pause();
                }
                else
                {
                    PrepareText.GetStreamScale().Resume();
                }
            }
        }
    }
    private static bool pause;

    public static bool Panalty
    {
        get { return panalty; }
        set
        {
            panalty = value;

            if (Game)
            {
                if (panalty)
                {
                    ResourceManager.SetText(CanvasLabel.D_StatusLab, Language.GetStr(LanguageLabel.UI__D_StatusLab3));
                }
                else
                {
                    ResourceManager.SetText(CanvasLabel.D_StatusLab, Language.GetStr(LanguageLabel.UI__D_StatusLab1));
                }
            }
        }
    }
    private static bool panalty;

    public static float GameTimer
    {
        get { return gameTimer; }
        set
        {
            gameTimer = value;

            MinigameTimerText.text = (GameTime-gameTimer).ToString("0.0");

            MinigameTimerBk.fillAmount = gameTimer/GameTime;

            MinigameTimerBk.material.SetFloat(MaterialLabel.TimerMatFill, MinigameTimerBk.fillAmount);
        }
    }
    private static float gameTimer;

    public static Text PrepareText;
    public static Text MinigameTimerText;
    public static Image MinigameTimerBk;

    public static Transform DisplayGrid;
    public static Transform MinigameTimerParent;
    public static Transform MinigameBeginButtonParent;
    public static Transform PunchGameStatusParent;
    public static Transform MemoryGameStatusParent;
    public static Transform FindGameStatusParent;
    public static Transform PunchGameOperateParent;
    public static Transform MemoryGameOperateParent;
    public static Transform FindGameOperateParent;
    public static Transform FindGameCorrectButtonParent;

    public static List<Drop> DropAwardList = new List<Drop>();
    public static List<Flower> MinigameIdleFlowerList = new List<Flower>();
    public static Dictionary<int, Flower> MinigameFlowerDictionary = new Dictionary<int, Flower>();


    public static int PunchCorrectScore = 15;
    public static int PunchGameSlotAmt = 9;
    public static List<int> PunchGameSlotIDs = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
    public static List<Flower> PunchGameOperateList = new List<Flower>();

    public static int MaxFadeAmt = 6;
    public static int FindCorrectScore = 40;
    public static List<int> FindGameSlotIDs = new List<int> {0, 1, 2, 3, 4, 5, 6, 7, 8};
    public static List<int> FindGameIndexList = new List<int>();
    public static List<int> FindGameFlowerIDs = new List<int>();

    public static int MemoryCorrectScore = 20;
    public static float MemoryGameDecreaseRate = 0.3f;
    public static List<int> MemoryGameSlotIDs = new List<int> { 0, 1, 3, 4, 6, 7 };
    public static List<Flower> MemoryGameFadeList = new List<Flower>();

    public static int MiniGameIndex; //从上一次掉落钻石开始计起 进行了几次小游戏

    public static bool IsPrepare;
    public static bool PlayNewflowerEffectFlag;

    public static float CreateOperateTime = 1.5f;
    public static float CreateOperateTimer;
    public static float OperateDecreaseRate = 0.03f;
    public static float CurrentCreateOperateTime;
    public static bool PunchGameTutorialFlag = true;

    public static int DropGoldMinIndex = 3;
    public static int DropGoldMaxIndex = 6;
    public static int DropDiamondMinIndex = 5;
    public static int DropDiamondMaxIndex = 9;
    public static float DropDiamondRate = 0.01f;
    public static float DropDiamondOffsetTime = 5;
    public static float DropGoldTimer;
    public static float DropDiamondTimer;
    public static bool CreateDropDiamondFlag;

    public static float FlowerFadeTime = 2f;
    public static float FlowerFadeTimer;
    public static float CurrentFlowerFadeTime;

    public static float PanaltyTime = 1f;
    public static float PanaltyTimer;

    public static float PrepareTime = 3;
    public static float PrepareTimer;

    public static float GameTime = 45f;

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

    public static MiniGameType miniGameType;

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

    public static MinigameAward MinigameAward;

    #endregion

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

        if (Game)
        {
            PunchGameThread();

            MemoryGameThread();

            FindGameThread();
        }

        if (IsPrepare)
        {
            PrepareThread();
        }
    }

    private void PunchGameThread()
    {
        if (miniGameType != MiniGameType.Punch)
        {
            return;
        }

        GameTimer += Time.deltaTime;

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

            return;
        }

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

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

        if (MinigameIdleFlowerList.Count > 0)
        {
            CreateOperateTimer -= Time.deltaTime;

            if (CreateOperateTimer <= 0)
            {
                CurrentCreateOperateTime -= CurrentCreateOperateTime * OperateDecreaseRate;

                CreateOperateTimer = CurrentCreateOperateTime;

                CreatePunchGameOperate();
            }
        }

        DropAwardThread();
    }

    private void MemoryGameThread()
    {
        if (miniGameType != MiniGameType.Memory)
        {
            return;
        }

        GameTimer += Time.deltaTime;

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

            return;
        }

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

            if (PanaltyTimer <= 0)
            {
                Panalty = false;
            }
        }
        
        if (MemoryGameFadeList.Count < MaxFadeAmt)
        {
            FlowerFadeTimer -= Time.deltaTime;
            
            if (FlowerFadeTimer <= 0)
            {
                FlowerFadeTimer = CurrentFlowerFadeTime;

                MemoryGameFadeNext();
            }
        }

        DropAwardThread();
    }

    private void FindGameThread()
    {
        if (miniGameType != MiniGameType.Find)
        {
            return;
        }

        GameTimer += Time.deltaTime;

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

            return;
        }

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

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

        DropAwardThread();
    }

    private void DropAwardThread()
    {
        DropGoldTimer -= Time.deltaTime;

        if (DropGoldTimer < 0)
        {
            DropGoldTimer = Random.Range(DropGoldMinIndex, DropGoldMaxIndex);

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

        if (CreateDropDiamondFlag)
        {
            DropDiamondTimer -= Time.deltaTime;

            if (DropDiamondTimer < 0)
            {
                CreateDropDiamondFlag = false;

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

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

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

            GameBegin();
        }
    }


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

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

    public override void RegistReference()
    {
        DisplayGrid = ResourceManager.Get(CanvasLabel.D_Grid);
        MinigameBeginButtonParent = ResourceManager.Get(CanvasLabel.D_Begin);
        MinigameTimerParent = ResourceManager.Get(CanvasLabel.D_Timer);

        PunchGameStatusParent = ResourceManager.Get(CanvasLabel.D_Status1);
        MemoryGameStatusParent = ResourceManager.Get(CanvasLabel.D_Status2);
        FindGameStatusParent = ResourceManager.Get(CanvasLabel.D_Status3);
        PunchGameOperateParent = ResourceManager.Get(CanvasLabel.D_Operate1);
        MemoryGameOperateParent = ResourceManager.Get(CanvasLabel.D_Operate2);
        FindGameOperateParent = ResourceManager.Get(CanvasLabel.D_Operate3);

        MinigameTimerText = ResourceManager.Get<Text>(CanvasLabel.D_TimerLab);
        PrepareText = ResourceManager.Get<Text>(CanvasLabel.D_PrepareLab);

        MinigameTimerBk = ResourceManager.Get<Image>(CanvasLabel.D_TimerIcon);

        MinigameSlots.Add(ResourceManager.Get(GardenLabel.MinigameSlot1));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.MinigameSlot2));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.MinigameSlot3));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.MinigameSlot4));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.MinigameSlot5));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.MinigameSlot6));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.MinigameSlot7));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.MinigameSlot8));
        MinigameSlots.Add(ResourceManager.Get(GardenLabel.MinigameSlot9));

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

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

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

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

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

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

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


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

        if (newFlowerFlag)
        {
            List<int> flowerIDs = GardenManager.FlowerInfoDictionary.Keys.ToList();

            MinigameAward.UnlockFlowerID = MinigameAward.SelectUnlockFlowerID(flowerIDs);
            MinigameAward.HaveNewFlowerFlag = false;
        }
        else
        {
            MinigameAward.HaveNewFlowerFlag = true;
        }
    }

    public static void ResetNewFlowerFlag()
    {
        float flowerRate = (float) Auxiliary.FmlParse(MinigameAward.UnlockFlowerFml, "l", Manager.GardenLevel.ToString(), "f", GardenManager.TotalUnlockFlower.ToString());

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

    public static MiniGameType SelectMinigameType(List<MiniGameType> availableGameTypes)
    {
        PunchGameOperateParent.SetActive(false);
        MemoryGameOperateParent.SetActive(false);
        FindGameOperateParent.SetActive(false);

        bool memoryGameAvailable = Manager.GardenLevel >= TutorialManager.MemoryMinigameTutorialLevel;
        bool findGameAvailable = GardenManager.TotalUnlockFlower >= TutorialManager.MinFlowerForFindGame && Manager.GardenLevel >= TutorialManager.FindMinigameTutorialLevel;
        availableGameTypes.Add(MiniGameType.Punch);
        if (memoryGameAvailable)
        {
            availableGameTypes.Add(MiniGameType.Memory);
        }
        if (findGameAvailable)
        {
            availableGameTypes.Add(MiniGameType.Find);
        }


        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)
        {
            miniGameType = MiniGameType.Punch;
        }
        else if (posibility <= memoryGameThreshold)
        {
            miniGameType = MiniGameType.Memory;
        }
        else if (posibility <= findGameThreshold)
        {
            miniGameType = MiniGameType.Find;
        }
        else
        {
            throw new Exception();
        }

        return miniGameType;
    }


    public static void GameEnter(MiniGameType type)
    {
        miniGameType = type;

        TryGetNewFlower();

        if (miniGameType == MiniGameType.Punch)
        {
            EnterPunchGame();
        }

        if (miniGameType == MiniGameType.Memory)
        {
            EnterMemoryGame();
        }

        if (miniGameType == MiniGameType.Find)
        {
            EnterFindGame();
        }

        ScoreTextPrefix = Language.GetStr(LanguageLabel.UI__D_ScoreLab);

        MinigameTimerBk.fillAmount = 0;
        MinigameTimerText.text = GameTime.ToString("0");

        ResourceManager.Get(CanvasLabel.C_MiniGame).TweenBacCG();
        ResourceManager.Get(GardenLabel.Minigame).TweenForVec();
        ResourceManager.Get(CanvasLabel.D_MiniGame).TweenForCG();
        AudioManager.PlayClip(AudioLabel.Bubble);
    }

    public static void GameBegin()
    {
        ConfigManager.SaveBoolToConfig(PlayerConfigLabel.NewFlowerFlag, false);

        Game = true;
        MiniGameIndex++;

        Score = 0;

        CreateOperateTimer = CreateOperateTime;
        FlowerFadeTimer = FlowerFadeTime;
        DropGoldTimer = Random.Range(DropGoldMinIndex, DropGoldMaxIndex);
        GameTimer = 0;
        CurrentCreateOperateTime = CreateOperateTime;
        CurrentFlowerFadeTime = FlowerFadeTime;
        DropDiamondTimer = Random.Range(0f, GameTime - DropDiamondOffsetTime);

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

        if (miniGameType == MiniGameType.Punch)
        {
            for (int i = 0; i < MinigameIdleFlowerList.Count; i++)
            {
                MinigameIdleFlowerList[i].GameBegin();
            }
        }

        if (miniGameType == MiniGameType.Memory)
        {
            MemoryGameRoundReset();
        }

        if (miniGameType == MiniGameType.Find)
        {
            FindGameRoundBegin(true);
        }

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

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

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

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

        if (miniGameType == MiniGameType.Punch)
        {
            ResourceManager.Get(CanvasLabel.D_Rip1).SetActive(true);
            ResourceManager.Get(CanvasLabel.D_Water1).SetActive(true);
            ResourceManager.Get(CanvasLabel.D_Fertilize1).SetActive(true);
        }

        if (miniGameType == MiniGameType.Memory)
        {
            ResourceManager.Get(CanvasLabel.D_Mask).TweenForGra();

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

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

        PrepareText.StreamForScale();
    }

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

        //if (Game)
        //{
            Manager.MinigameFlag = false;

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

            ResetNewFlowerFlag();
        //}

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

        if (Manager.MinigameCDTimer > 0)
        {
            ResourceManager.Get(CanvasLabel.C_MiniGame).TweenForRect();
        }


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

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

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

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

            DropAwardList.RemoveAt(i--);
        }
    }

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

        MinigameAward.GetAward(Score);

        Manager.PlayMinigameAmt++;

        ConfigManager.SaveIntToConfig(PlayerConfigLabel.CurrentMinigameType, MiniGameType.None.GetHashCode());

        GameEnd();
    }


    public static void OnFindGameButtonClick(int id, int btnIndex)
    {
        if (!Game)
        {
            return;
        }

        if (Panalty)
        {
            return;
        }

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

            ResourceManager.GetHudText($"+{FindCorrectScore}", Color.white, 90, flower.ChildDic[FlowerLabel.ScorePos], ResourceManager.Get(CanvasLabel.D_HudParent), true);

            Score += FindCorrectScore;

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

    public static void OnMemoryGameClick(int index, int slotIndex)
    {
        if (Panalty || !MemoryGameFadeList.Valid())
        {
            return;
        }

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


        if (slotIndex == FindGameIndexList[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);

            FindGameIndexList.RemoveAt(0);


            Flower flower = MinigameFlowerDictionary[slotIndex];

            ResourceManager.GetHudText($"+{MemoryCorrectScore}", Color.white, 90, flower.ChildDic[FlowerLabel.ScorePos], ResourceManager.Get(CanvasLabel.D_HudParent), true);

            Score += MemoryCorrectScore;

            flower.PlayFlashLight();


            if (!MinigameAward.HaveNewFlowerFlag && MinigameAward.UnlockFlowerID == flower.ID && !PlayNewflowerEffectFlag)
            {
                flower.PlayNewFlowerEffec();
                PlayNewflowerEffectFlag = true;
            }


            AudioManager.PlayClip(AudioLabel.ClickButton);

            TweenRoot tween = flower.FlowerIcon.TweenBacSr();

            if (FindGameIndexList.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 CreatePunchGameOperate()
    {
        AudioManager.PlayClip(AudioLabel.Bubble);

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

            Flower flower = MinigameIdleFlowerList[4];
            flower.CreateOp(PunchGameOperateList.Count, OpType.Water);

            PunchGameOperateList.Add(flower);
            MinigameIdleFlowerList.Remove(flower);

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

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

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

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

            flower.CreateOp(PunchGameOperateList.Count);

            PunchGameOperateList.Add(flower);
            MinigameIdleFlowerList.Remove(flower);
        }
    }

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

        if (PunchGameOperateList[0].Operate(opType))
        {
            MinigameIdleFlowerList.Add(PunchGameOperateList[0]);

            PunchGameOperateList.Remove(PunchGameOperateList[0]);

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


    public static void EnterPunchGame()
    {
        PunchGameOperateParent.SetActive(true);

        MinigameTimerParent.SetParent(PunchGameStatusParent);

        DisplayGrid.SetParent(PunchGameStatusParent);
        MinigameBeginButtonParent.SetParent(PunchGameOperateParent);

        PrepareText.SetParent(ResourceManager.Get(CanvasLabel.D_PrepareLayout1));


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

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


        if (MinigameAward.HaveNewFlowerFlag)
        {
            for (int i = 0; i < PunchGameSlotAmt; i++)
            {
                while (true)
                {
                    FlowerInfo flowerInfo = GardenManager.FlowerInfoDictionary.Random();

                    if (flowerInfo.Unlock)
                    {
                        MinigameIdleFlowerList.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.FlowerInfoDictionary[MinigameAward.UnlockFlowerID], MinigameSlots[specialSlotID]);

            flower.PlayNewFlowerEffec();

            MinigameIdleFlowerList.Add(flower);

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

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

                        MinigameIdleFlowerList.Add(flower);

                        break;
                    }
                }
            }
        }
    }

    public static void EnterMemoryGame()
    {
        MemoryGameOperateParent.SetActive(true);

        MinigameTimerParent.SetParent(MemoryGameStatusParent);

        DisplayGrid.SetParent(MemoryGameStatusParent);
        MinigameBeginButtonParent.SetParent(MemoryGameOperateParent);

        PrepareText.SetParent(ResourceManager.Get(CanvasLabel.D_PrepareLayout2));


        ResetMemoryGameButtons();

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

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

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

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

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

        Flower flower;

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

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

                        MinigameIdleFlowerList.Add(flower);

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

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

            flower = ResourceManager.GetFlower(GardenManager.FlowerInfoDictionary[MinigameAward.UnlockFlowerID], MinigameSlots[specialSlotID]);

            flower.PlayNewFlowerEffec();

            MinigameIdleFlowerList.Add(flower);

            MinigameFlowerDictionary.Add(specialSlotID, flower);

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

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

                        MinigameIdleFlowerList.Add(flower);

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

                        break;
                    }
                }
            }
        }

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

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

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

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

        MinigameBeginButtonParent.SetParent(FindGameOperateParent);
        MinigameTimerParent.SetParent(FindGameStatusParent);
        DisplayGrid.SetParent(FindGameStatusParent);

        PrepareText.SetParent(ResourceManager.Get(CanvasLabel.D_PrepareLayout3));

        FindGameRoundReset(true);
    }


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

    public static void MemoryGameRoundReset()
    {
        for (int i = 0; i < MemoryGameFadeList.Count; i++)
        {
            MinigameIdleFlowerList.Add(MemoryGameFadeList[i]);
        }


        CurrentFlowerFadeTime -= CurrentFlowerFadeTime * MemoryGameDecreaseRate;

        FlowerFadeTimer = CurrentFlowerFadeTime;


        MemoryGameFadeList = new List<Flower>();

        FindGameIndexList = new List<int>();

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

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

            i--;
        }

        ResetMemoryGameButtons();
    }

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

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

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

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

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

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

    public static void MemoryGameFadeNext()
    {
        for (int i = 0; i < FindGameIndexList.Count; i++)
        {
            Flower flower = MinigameFlowerDictionary[FindGameIndexList[i]];

            if (MemoryGameFadeList.UniqueAdd(flower))
            {
                MinigameIdleFlowerList.Remove(flower);

                flower.PlayFlashLight();

                flower.StopNewFlowerEffec();
                PlayNewflowerEffectFlag = false;

                flower.FlowerIcon.TweenForSr();

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

                break;
            }
        }
    }

    public static int GetMemoryGameButtonIndex(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 static void FindGameRoundEnd()
    {
        if (MinigameIdleFlowerList[0].ID == MinigameAward.UnlockFlowerID)
        {
            MinigameIdleFlowerList[0].StopNewFlowerEffec();
        }


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

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

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

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

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

        MinigameIdleFlowerList = new List<Flower>();

        FindGameFlowerIDs = new List<int>();

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


        FlowerInfo flowerInfo;

        if (firstRound && !MinigameAward.HaveNewFlowerFlag)
        {
            flowerInfo = GardenManager.FlowerInfoDictionary[MinigameAward.UnlockFlowerID];
        }
        else
        {
            flowerInfo = GardenManager.FlowerInfoDictionary.Random(false, flowerIndo => { return flowerIndo.Unlock; });
        }

        FindGameFlowerIDs.Add(flowerInfo.ID);

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

        while (slotIDs.Count > 0)
        {
            flowerInfo = GardenManager.FlowerInfoDictionary.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++)
            {
                MinigameIdleFlowerList.Add(ResourceManager.GetFlower(flowerInfo, MinigameSlots[slotIDs.Random(1, true, true)[0]]));
            }
        }

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

            MinigameIdleFlowerList[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(CanvasLabel.D_FlowerIcon7, GardenManager.FlowerInfoDictionary[idList[0]].Icon).Resize(true, deltaSIzeX, deltaSIzeY);
        ResourceManager.SetSprite(CanvasLabel.D_FlowerIcon8, GardenManager.FlowerInfoDictionary[idList[1]].Icon).Resize(true, deltaSIzeX, deltaSIzeY);
        ResourceManager.SetSprite(CanvasLabel.D_FlowerIcon9, GardenManager.FlowerInfoDictionary[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])
            {
                FindGameCorrectButtonParent = D_FindGameBtns[i];
                Button button = FindGameCorrectButtonParent.GetComponent<Button>();
                button.onClick.RemoveAllListeners();
                button.onClick.AddListener(() => { OnFindGameButtonClick(id, index); TutorialManager.EndClickCorrectButton(); });
            }
            else
            {
                Button button = D_FindGameBtns[i].GetComponent<Button>();
                button.onClick.RemoveAllListeners();
                button.onClick.AddListener(() => { OnFindGameButtonClick(id, index); });
            }
        }
    }

    public static void FindGameRoundBegin(bool firstRound = false)
    {
        if (firstRound && !MinigameAward.HaveNewFlowerFlag)
        {
            MinigameIdleFlowerList[0].PlayNewFlowerEffec();
        }

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

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

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


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