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.IncomeBuff) + 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;

                float unlockFlowerRate = UnlockFlowerRate[Rate];
                float extraRate = (score - RateStandard[Rate])/10*0.01f;

                unlockFlowerRate += extraRate;
                unlockFlowerRate = Mathf.Min(1, unlockFlowerRate);

                if (Random.Range(0f, 1f) <= unlockFlowerRate)
                {
                    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);    
        //}
        flowerIDs.MySort((id0, id1) => id1 > id0);
        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, //记住花的消失顺序
    FindSolo, //找落单的花
    FindMissing, //找不见了的花
}

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 FindSoloGameStatusParent;
    public static Transform FindMissingGameStatusParent;
    public static Transform PunchGameOperateParent;
    public static Transform MemoryGameOperateParent;
    public static Transform FindSoloGameOperateParent;
    public static Transform FindSoloGameCorrectButtonParent;
    public static Transform FindMissingGameOperateParent;

    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 FindSoloCorrectScore = 40;
    public static List<int> FindSoloGameSlotIDs = new List<int> {0, 1, 2, 3, 4, 5, 6, 7, 8};
    public static List<int> FindSoloGameIndexList = new List<int>();
    public static List<int> FindSoloGameFlowerIDs = new List<int>();


    public static Flower FindMissingNewFlower;
    public static Flower FindMissingCorrectFlower;
    public static int FindMissingCorrectScore = 60;
    public static float FindMissingGameFadeTimer;
    public static float FindMissingGameCurrentFadeTime;
    public static float FindMissingGameDecreaseTime = 0.5f;
    public static float FindMissingGameFlowerDisappearTime = 0.5f;
    public static float FindMissingGameFlowerMinDisplayTime = 1f;
    public static float FindMissingGameFlowerMaxDisplayTime = 3f;
    public static List<int> FindMissingGameSlotIDs = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
    public static List<int> FindMissingGameFlowerIDs = new List<int>();
    public static Transform FindMissingGameMask;

    public static float MemoryGameFlowerFadeTime = 2f;
    public static float MemoryGameFlowerFadeTimer;
    public static float MemoryGameCurrentFlowerFadeTime;
    public static int MemoryGameMaxFadeAmt = 6;
    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 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_FindSoloGameBtns = new List<Transform>();
    public static List<Transform> D_FindSoloGameIcons = new List<Transform>();
    public static List<Transform> D_FindSoloGameArrows = new List<Transform>();
    public static List<Transform> D_FindMissingGameBtns = new List<Transform>();
    public static List<Transform> D_FindMissingGameIcons = new List<Transform>();
    public static List<Transform> D_FindMissingGameArrows = 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();

            FindSoloGameThread();

            FindMissingGameThread();
        }

        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 < MemoryGameMaxFadeAmt)
        {
            MemoryGameFlowerFadeTimer -= Time.deltaTime;
            
            if (MemoryGameFlowerFadeTimer <= 0)
            {
                MemoryGameFlowerFadeTimer = MemoryGameCurrentFlowerFadeTime;

                MemoryGameFadeNext();
            }
        }

        DropAwardThread();
    }

    private void FindSoloGameThread()
    {
        if (miniGameType != MiniGameType.FindSolo)
        {
            return;
        }

        GameTimer += Time.deltaTime;

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

            return;
        }

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

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

        DropAwardThread();
    }

    private void FindMissingGameThread()
    {
        if (miniGameType != MiniGameType.FindMissing)
        {
            return;
        }

        GameTimer += Time.deltaTime;

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

            return;
        }

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

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

        if (FindMissingGameFadeTimer >= 0)
        {
            FindMissingGameFadeTimer -= Time.deltaTime;

            if (FindMissingGameFadeTimer <= 0)
            {
                FindMissingFadeFlowers();
            }
        }

        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);
        FindSoloGameStatusParent = ResourceManager.Get(CanvasLabel.D_Status3);
        FindMissingGameStatusParent = ResourceManager.Get(CanvasLabel.D_FindMissingGameStatus);
        PunchGameOperateParent = ResourceManager.Get(CanvasLabel.D_Operate1);
        MemoryGameOperateParent = ResourceManager.Get(CanvasLabel.D_Operate2);
        FindSoloGameOperateParent = ResourceManager.Get(CanvasLabel.D_Operate3);
        FindMissingGameOperateParent = ResourceManager.Get(CanvasLabel.D_FindMissingGamePanel);

        FindMissingGameMask = ResourceManager.Get(CanvasLabel.D_FindMissingGameMask);
        FindMissingGameMask.CreateTweenGra(0, 0.25f, true, false, Curve.EaseOutQuad);

        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_FindSoloGameBtns.Add(ResourceManager.Get(CanvasLabel.D_FlowerBtn7));
        D_FindSoloGameBtns.Add(ResourceManager.Get(CanvasLabel.D_FlowerBtn8));
        D_FindSoloGameBtns.Add(ResourceManager.Get(CanvasLabel.D_FlowerBtn9));

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

        D_FindSoloGameArrows.Add(ResourceManager.Get(CanvasLabel.D_FlowerArrow7));
        D_FindSoloGameArrows.Add(ResourceManager.Get(CanvasLabel.D_FlowerArrow8));
        D_FindSoloGameArrows.Add(ResourceManager.Get(CanvasLabel.D_FlowerArrow9));

        D_FindMissingGameBtns.Add(ResourceManager.Get(CanvasLabel.D_FindMissingGameButton0));
        D_FindMissingGameBtns.Add(ResourceManager.Get(CanvasLabel.D_FindMissingGameButton1));
        D_FindMissingGameBtns.Add(ResourceManager.Get(CanvasLabel.D_FindMissingGameButton2));

        D_FindMissingGameIcons.Add(ResourceManager.Get(CanvasLabel.D_FindMissingGameIcon0));
        D_FindMissingGameIcons.Add(ResourceManager.Get(CanvasLabel.D_FindMissingGameIcon1));
        D_FindMissingGameIcons.Add(ResourceManager.Get(CanvasLabel.D_FindMissingGameIcon2));

        D_FindMissingGameArrows.Add(ResourceManager.Get(CanvasLabel.D_FindMissingGameArrow0));
        D_FindMissingGameArrows.Add(ResourceManager.Get(CanvasLabel.D_FindMissingGameArrow1));
        D_FindMissingGameArrows.Add(ResourceManager.Get(CanvasLabel.D_FindMissingGameArrow2));
    }


    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);
        //FindSoloGameOperateParent.SetActive(false);
        //FindMissingGameOperateParent.SetActive(false);

        bool memoryGameAvailable = Manager.GardenLevel >= TutorialManager.MemoryMinigameTutorialLevel;
        bool findSoloGameAvailable = GardenManager.TotalUnlockFlower >= TutorialManager.MinFlowerForFindSoloGame && Manager.GardenLevel >= TutorialManager.FindSoloMinigameTutorialLevel;
        bool findMissingGameAvailable = GardenManager.TotalUnlockFlower >= TutorialManager.MinFlowerForFindMissingGame && Manager.GardenLevel >= TutorialManager.FindMissingMinigameTutorialLevel;

        availableGameTypes.Add(MiniGameType.Punch);
        if (memoryGameAvailable)
        {
            availableGameTypes.Add(MiniGameType.Memory);
        }
        if (findSoloGameAvailable)
        {
            availableGameTypes.Add(MiniGameType.FindSolo);
        }
        if (findMissingGameAvailable)
        {
            availableGameTypes.Add(MiniGameType.FindMissing);
        }
        
        float posibility = Random.Range(0f, 1f);
        for (int i = 0; i < availableGameTypes.Count; i++)
        {
            float average = 1f/availableGameTypes.Count;
            float leftBorder = average*i;
            float rightBorder = average*(i+1);
            if (posibility >= leftBorder && posibility <= rightBorder)
            {
                return availableGameTypes[i];
            }
        }
        return MiniGameType.Punch;
    }


    public static void GameEnter(MiniGameType type)
    {
        PunchGameOperateParent.SetActive(false);
        MemoryGameOperateParent.SetActive(false);
        FindSoloGameOperateParent.SetActive(false);
        FindMissingGameOperateParent.SetActive(false);

        miniGameType = type;

        TryGetNewFlower();

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

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

        if (miniGameType == MiniGameType.FindSolo)
        {
            EnterFindSoloGame();
        }

        if (miniGameType == MiniGameType.FindMissing)
        {
            EnterFindMissingGame();
        }

        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;
        MemoryGameFlowerFadeTimer = MemoryGameFlowerFadeTime;
        FindMissingGameCurrentFadeTime = FindMissingGameFlowerMaxDisplayTime;
        DropGoldTimer = Random.Range(DropGoldMinIndex, DropGoldMaxIndex);
        GameTimer = 0;
        CurrentCreateOperateTime = CreateOperateTime;
        MemoryGameCurrentFlowerFadeTime = MemoryGameFlowerFadeTime;
        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.FindSolo)
        {
            FindSoloGameRoundBegin(true);
        }

        if (miniGameType == MiniGameType.FindMissing)
        {
            FindMissingGameRoundBegin();
        }

        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);
        ResourceManager.Get(CanvasLabel.D_FindMissingGameDesc).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 OnFindSoloGameButtonClick(int id, int btnIndex)
    {
        if (!Game)
        {
            return;
        }

        if (Panalty)
        {
            return;
        }

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

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

            Score += FindSoloCorrectScore;

            flower.PlayFlashLight();

            AudioManager.PlayClip(AudioLabel.ClickButton);

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

            D_FindSoloGameIcons[btnIndex].TweenForGra();
            D_FindSoloGameBtns[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 (FindSoloGameIndexList.Count == 0)
        {
            return;
        }


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

            FindSoloGameIndexList.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 (FindSoloGameIndexList.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 EnterFindSoloGame()
    {
        FindSoloGameOperateParent.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(FindSoloGameOperateParent);
        MinigameTimerParent.SetParent(FindSoloGameStatusParent);
        DisplayGrid.SetParent(FindSoloGameStatusParent);

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

        FindSoloGameRoundReset(true);
    }

    public static void EnterFindMissingGame()
    {
        FindMissingGameOperateParent.SetActive(true);
        MinigameTimerParent.SetParent(FindMissingGameStatusParent);
        DisplayGrid.SetParent(FindMissingGameStatusParent);
        MinigameBeginButtonParent.SetParent(FindMissingGameOperateParent);
        PrepareText.SetParent(ResourceManager.Get(CanvasLabel.D_FindMissingGamePrepareLayout));
        ResourceManager.Get(CanvasLabel.D_FindMissingGameMask).GetTweenGra().InDestination = true;
        for (int i = 0; i < D_FindMissingGameBtns.Count; i++)
        {
            D_FindMissingGameBtns[i].GetTweenCG().InOrigin = true;
            D_FindMissingGameBtns[i].SetActive(false);
        }
        ResourceManager.SetActive(CanvasLabel.D_Begin, true);
        ResourceManager.SetActive(CanvasLabel.D_FindMissingGameDesc, true);

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


        MemoryGameCurrentFlowerFadeTime -= MemoryGameCurrentFlowerFadeTime * MemoryGameDecreaseRate;

        MemoryGameFlowerFadeTimer = MemoryGameCurrentFlowerFadeTime;


        MemoryGameFadeList = new List<Flower>();

        FindSoloGameIndexList = new List<int>();

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

        for (int i = 0; i < randomList.Count; i++)
        {
            FindSoloGameIndexList.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 < FindSoloGameIndexList.Count; i++)
        {
            Flower flower = MinigameFlowerDictionary[FindSoloGameIndexList[i]];

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

                flower.PlayFlashLight();

                flower.StopNewFlowerEffec();
                PlayNewflowerEffectFlag = false;

                flower.FlowerIcon.TweenForSr();

                if (MemoryGameFadeList.Count == MemoryGameMaxFadeAmt)
                {
                    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 FindSoloGameRoundEnd()
    {
        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)
                {
                    FindSoloGameRoundReset();

                    FindSoloGameRoundBegin();
                }
            },
            1.5f
        );
    }

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

        MinigameIdleFlowerList = new List<Flower>();

        FindSoloGameFlowerIDs = new List<int>();

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


        FlowerInfo flowerInfo;

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

        FindSoloGameFlowerIDs.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 != FindSoloGameFlowerIDs[0]; });

            if (slotIDs.Count == 1)
            {
                if (!FindSoloGameFlowerIDs.Contains(flowerInfo.ID))
                {
                    continue;
                }
            }
            else
            {
                FindSoloGameFlowerIDs.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>()
        {
            FindSoloGameFlowerIDs[0],
        };

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

            idList.RemoveAt(0);
            idList.Insert(Random.Range(0, 3), FindSoloGameFlowerIDs[0]);
        }
        else if (FindSoloGameFlowerIDs.Count > 2)
        {
            idList.AddRange(FindSoloGameFlowerIDs.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.FindSoloMinigameTutorial && id == FindSoloGameFlowerIDs[0])
            {
                FindSoloGameCorrectButtonParent = D_FindSoloGameBtns[i];
                Button button = FindSoloGameCorrectButtonParent.GetComponent<Button>();
                button.onClick.RemoveAllListeners();
                button.onClick.AddListener(() => { OnFindSoloGameButtonClick(id, index); TutorialManager.EndClickFindSoloCorrectButton(); });
            }
            else
            {
                Button button = D_FindSoloGameBtns[i].GetComponent<Button>();
                button.onClick.RemoveAllListeners();
                button.onClick.AddListener(() => { OnFindSoloGameButtonClick(id, index); });
            }
        }
    }

    public static void FindSoloGameRoundBegin(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.FindSoloMinigameTutorial)
        {
            TutorialManager.ShowFindSoloCorrectButton(FindSoloGameCorrectButtonParent.GetChild(1), FindSoloGameCorrectButtonParent);
        }
    }


    public static void FindMissingGameRoundStartOperate()
    {
        List<Flower> flowers = new List<Flower>(MinigameIdleFlowerList);
        flowers = flowers.Disturb();
        for (int i = 1; i < flowers.Count; i++)
        {
            flowers[i].FlowerIcon.TweenBacSr();
        }
        if (FindMissingNewFlower != null)
        {
            FindMissingNewFlower.PlayNewFlowerEffec();
        }
        List<Flower> buttonFlowers = new List<Flower>();
        buttonFlowers.Add(flowers[0]);
        for (int i = 1; i < flowers.Count; i++)
        {
            int index = i;
            if (!buttonFlowers.MyContains(flower => flower.ID == flowers[index].ID))
            {
                buttonFlowers.Add(flowers[index]);
            }
        }
        List<Image> icons = new List<Image>();
        for (int i = 0; i < D_FindMissingGameIcons.Count; i++)
        {
            icons.Add(D_FindMissingGameIcons[i].GetComponent<Image>());
        }
        List<Button> buttons = new List<Button>();
        for (int i = 0; i < D_FindMissingGameBtns.Count; i++)
        {
            buttons.Add(D_FindMissingGameBtns[i].GetComponent<Button>());
        }
        FindMissingCorrectFlower = buttonFlowers[0];
        Image correctImage = icons.Random()[0];
        int correctIndex = icons.IndexOf(correctImage);
        Button correctButton = buttons[correctIndex];
        icons.RemoveAt(correctIndex);
        buttons.RemoveAt(correctIndex);
        correctImage.sprite = buttonFlowers[0].FlowerInfo.Icon;
        icons[0].sprite = buttonFlowers[1].FlowerInfo.Icon;
        icons[1].sprite = buttonFlowers[2].FlowerInfo.Icon;
        float deltaSIzeX = 1.0625f;
        float deltaSIzeY = 1.0625f;
        correctImage.Resize(true, deltaSIzeX, deltaSIzeY);
        icons[0].Resize(true, deltaSIzeX, deltaSIzeY);
        icons[1].Resize(true, deltaSIzeX, deltaSIzeY);
        correctButton.TweenForCG();
        buttons[0].TweenForCG();
        buttons[1].TweenForCG();
        correctButton.onClick.RemoveAllListeners();
        buttons[0].onClick.RemoveAllListeners();
        buttons[1].onClick.RemoveAllListeners();
        correctButton.onClick.AddListener(() => OnFindMissingGameRightButtonClick(correctButton, correctImage));
        buttons[0].onClick.AddListener(() => OnFindMissingGameWrongButtonClick(buttons[0], icons[0]));
        buttons[1].onClick.AddListener(() => OnFindMissingGameWrongButtonClick(buttons[1], icons[1]));
        if (TutorialManager.FindMissingMinigameTutorial)
        {
            TutorialManager.ShowFindMissingCorrectButton(D_FindMissingGameArrows[correctIndex], D_FindMissingGameBtns[correctIndex]);
            correctButton.AddButtonEventOnetime(TutorialManager.EndClickFindMissingCorrectButton);
        }
    }

    public static void FindMissingGameRoundEnd()
    {
        if (FindMissingNewFlower != null)
        {
            FindMissingNewFlower.StopNewFlowerEffec();
        }
        for (int i = 0; i < MinigameIdleFlowerList.Count; i++)
        {
            MinigameIdleFlowerList[i].FlowerIcon.TweenForSr();
        }
        DelayCall.Call
        (
            0.5f, () =>
            {
                FindMissingGameRoundReset(false);
                FindMissingGameRoundBegin();
            }
        );
    }

    public static void FindMissingGameRoundReset(bool firstRound)
    {
        if (!firstRound)
        {
            FindMissingGameCurrentFadeTime -= FindMissingGameDecreaseTime;
            FindMissingGameCurrentFadeTime = Mathf.Max(FindMissingGameCurrentFadeTime, FindMissingGameFlowerMinDisplayTime);
            for (int i = 0; i < MinigameIdleFlowerList.Count; i++)
            {
                MinigameIdleFlowerList[i].RetrieveFlower();
            }
            MinigameIdleFlowerList = new List<Flower>();
        }
        List<int> idList = new List<int>(FindMissingGameSlotIDs);
        Flower flower;
        if (MinigameAward.HaveNewFlowerFlag)
        {
            FindMissingNewFlower = null;
            List<FlowerInfo> flowerInfos = new List<FlowerInfo>(GardenManager.FlowerInfoDictionary.Values.ToList());
            for (int i = 0; i < flowerInfos.Count; i++)
            {
                if (!flowerInfos[i].Unlock)
                {
                    flowerInfos.RemoveAt(i);
                    i--;
                }
            }
            flowerInfos = flowerInfos.Disturb();
            for (int i = 0; i < 3; i++)
            {
                flower = ResourceManager.GetFlower(flowerInfos[i], MinigameSlots[idList[i]]);
                MinigameIdleFlowerList.Add(flower);
            }
            for (int i = 3; i < 9; i++)
            {
                flower = ResourceManager.GetFlower(flowerInfos.Random()[0], MinigameSlots[idList[i]]);
                MinigameIdleFlowerList.Add(flower);
            }
        }
        else
        {
            int specialSlotID = idList.Random(1, true, true)[0];
            FindMissingNewFlower = ResourceManager.GetFlower(GardenManager.FlowerInfoDictionary[MinigameAward.UnlockFlowerID], MinigameSlots[specialSlotID]);
            MinigameIdleFlowerList.Add(FindMissingNewFlower);
            List<FlowerInfo> flowerInfos = new List<FlowerInfo>(GardenManager.FlowerInfoDictionary.Values.ToList());
            for (int i = 0; i < flowerInfos.Count; i++)
            {
                if (!flowerInfos[i].Unlock || flowerInfos[i].ID == MinigameAward.UnlockFlowerID)
                {
                    flowerInfos.RemoveAt(i);
                    i--;
                }
            }
            flowerInfos = flowerInfos.Disturb();
            for (int i = 0; i < 2; i++)
            {
                flower = ResourceManager.GetFlower(flowerInfos[i], MinigameSlots[idList[i]]);
                MinigameIdleFlowerList.Add(flower);
            }
            for (int i = 2; i < 8; i++)
            {
                flower = ResourceManager.GetFlower(flowerInfos.Random()[0], MinigameSlots[idList[i]]);
                MinigameIdleFlowerList.Add(flower);
            }
        }

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

    public static void FindMissingGameRoundBegin()
    {
        if (FindMissingNewFlower != null)
        {
            FindMissingNewFlower.PlayNewFlowerEffec();
        }
        FindMissingGameFadeTimer = FindMissingGameCurrentFadeTime;
        for (int i = 0; i < MinigameIdleFlowerList.Count; i++)
        {
            MinigameIdleFlowerList[i].FlowerIcon.TweenBacSr();
        }
    }

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

        if (FindMissingNewFlower != null)
        {
            FindMissingNewFlower.StopNewFlowerEffec();
        }

        DelayCall.Call
        (
            FindMissingGameFlowerDisappearTime,
            FindMissingGameRoundStartOperate
        );
    }

    public static void OnFindMissingGameRightButtonClick(Button button, Image icon)
    {
        if (!Game)
        {
            return;
        }

        if (Panalty)
        {
            return;
        }

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

        Score += FindSoloCorrectScore;

        FindMissingCorrectFlower.PlayFlashLight();
        FindMissingCorrectFlower.FlowerIcon.TweenBacSr();

        AudioManager.PlayClip(AudioLabel.ClickButton);

        for (int i = 0; i < D_FindMissingGameBtns.Count; i++)
        {
            D_FindMissingGameBtns[i].TweenBacCG();
        }
        DelayCall.Call(0.5f, FindMissingGameRoundEnd);
    }

    public static void OnFindMissingGameWrongButtonClick(Button button, Image icon)
    {
        if (!Game)
        {
            return;
        }

        if (Panalty)
        {
            return;
        }

        Panalty = true;
        PanaltyTimer = PanaltyTime;

        icon.TweenForGra();
        button.Shake(0.5f, 3, new Vector3(20f, 0, 0), Curve.EaseOutQuad);

        AudioManager.PlayClip(AudioLabel.Error);
    }


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