garden_client/Assets/Script/Manage/GardenManager.cs

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;
using UnityEngine.EventSystems;

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

using Random = UnityEngine.Random;

public enum ElfType
{
    Bee_Red,
    Bee_Blue,
    Bee_White,
    Bee_Purple,
    Bee_Yellow,
    Beetle_Red,
    Beetle_Blue,
    Beetle_White,
    Beetle_Purple,
    Beetle_Yellow,
    Butterfly_Red,
    Butterfly_Blue,
    Butterfly_White,
    Butterfly_Purple,
    Butterfly_Yellow,
    Dragonfly_Red,
    Dragonfly_Blue,
    Dragonfly_White,
    Dragonfly_Purple,
    Dragonfly_Yellow,
}

public class GardenManager : Regist
{
    #region Config

    public static int Slot
    {
        get { return Slot_; }
        set
        {
            Slot_ = value;

            ResourceManager.SetText(ObjectLabel.G_CollectLab2, string.Format("{0}/{1}", Slot_, Page * 9));
        }
    }
    public static int Page
    {
        get { return PageList.Count; }
    }
    public static int MyFlower
    {
        get { return MyFlower_; }
        set
        {
            MyFlower_ = value;

            AchieveManager.UpdateStatus(AchieveType.FlowerAmt, MyFlower_);

            ResourceManager.SetText(ObjectLabel.F_FlowerLab, string.Format("{0}", MyFlower));
            ResourceManager.SetText(ObjectLabel.G_CollectLab1, string.Format("{0}/{1}", MyFlower, TotalFlower));

            if (MyFlower_ >= TutorialManager.MinFlowerForFindGame && Manager.Level >= TutorialManager.FindMinigameTutorialLevel)
            {
                if (TutorialManager.findMinigameTutorial)
                {
                    TutorialManager.PlayFindGame();
                }
            }
        }
    }
    public static int MyFlowerSpec
    {
        get { return MyFlowerSpec_; }
        set
        {
            MyFlowerSpec_ = value;

            MyFlower = MyFlowerSpec_ + MyFlowerRegu_;
        }
    }
    public static int MyFlowerRegu
    {
        get { return MyFlowerRegu_; }
        set
        {
            MyFlowerRegu_ = value;

            MyFlower = MyFlowerSpec_ + MyFlowerRegu_;
        }
    }
    public static int TotalFlowerSpec
    {
        get { return TotalFlowerSpec_; }
        set
        {
            TotalFlowerSpec_ = value;

            TotalFlower = TotalFlowerSpec_ + TotalFlowerRegu_;
        }
    }
    public static int TotalFlowerRegu
    {
        get { return TotalFlowerRegu_; }
        set
        {
            TotalFlowerRegu_ = value;

            TotalFlower = TotalFlowerSpec_ + TotalFlowerRegu_;
        }
    }

    public static int Slot_;
    public static int DefaultSlot = 1;
    private static int MyFlower_;
    private static int MyFlowerSpec_;
    private static int MyFlowerRegu_;
    private static int TotalFlowerSpec_;
    private static int TotalFlowerRegu_;

    public static int FirstUnlockFlowerID
    {
        get
        {
            foreach (var kv in FlowerInfoDic)
            {
                if (!kv.Value.Unlock)
                {
                    return kv.Key;
                }
            }

            return -1;
        }
    }
    public static List<int> UnlockedFlowerIDList
    {
        get
        {
            List<int> unlockedFlowerIDList = new List<int>();

            foreach (var kv in FlowerInfoDic)
            {
                if (kv.Value.Unlock)
                {
                    unlockedFlowerIDList.Add(kv.Key);
                }
            }

            return unlockedFlowerIDList;
        }
    }

    public static int TotalFlower;
    public static bool MiniLock = true;

    public static float ElfTimer;
    public static float StarTimer;
    public static float AwardTimer;

    public static Button RetrieveButton;
    public static Text RetrieveButtonLab;
    public static Button PurchaseButton;
    public static Text PurchaseButtonLab;

    public static FlowerInfo SeleInfo;
    public static GardenManager Instance;

    public static List<Slot> SlotList = new List<Slot>();
    public static List<Slot> PlantList = new List<Slot>();
    public static List<Star> StarList = new List<Star>();
    public static List<ElfType> ElfList = new List<ElfType>();
    public static List<Transform> PageList = new List<Transform>();

    public static Dictionary<int, FlowerInfo> FlowerInfoDic = new Dictionary<int, FlowerInfo>();

    public static TweenMatFloat FlowerCardMatTween;

    #endregion

    public void Update()
    {
        if (TutorialManager.NewplayerTutorial || Player.InDressRoom || SFSManager.GardenSmartFox.PlazaRoomController.JoinedPlazaRoom)
        {
            return;
        }

        ElfThread();

        StarThread();

        AwardThread();
    }


    public static float MinElfTime = 5;
    public static float MaxElfTime = 30;
    public void ElfThread()
    {
        if (!MiniLock)
        {
            return;
        }

        ElfTimer -= Time.deltaTime;

        if (ElfTimer < 0)
        {
            ElfTimer = Random.Range(MinElfTime, MaxElfTime);

            if (ElfList.Count > 0 && PlantList.Count > 0)
            {
                PlantList.Random()[0].Flower.GetElf(ElfList.Random()[0]);
            }
        }
    }

    public static float MinStarTime;
    public static float MaxStarTime;
    public void StarThread()
    {
        if (MiniLock && !Manager.MiniLock && !VisitManager.InVisit)
        {
            StarTimer -= Time.deltaTime;

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

                StarList.Add(ResourceManager.GetStar());
            }
        }
    }

    public static float MinAwardTime = 5;
    public static float MaxAwardTime = 15;
    public void AwardThread()
    {
        if (MiniLock)
        {
            AwardTimer -= Time.deltaTime;

            if (AwardTimer <= 0)
            {
                AwardTimer = Random.Range(MinAwardTime, MaxAwardTime);

                List<Flower> spareList = new List<Flower>();

                for (int i = 0; i < PlantList.Count; i++)
                {
                    if (PlantList[i].Flower.Award == false)
                    {
                        spareList.Add(PlantList[i].Flower);
                    }
                }

                if (spareList.Count > 0)
                {
                    spareList.Random()[0].Award = true;
                }
            }
        }
    }


    public override void InstantiatePrefabs()
    {
        ResourceManager.Get(ResourceLabel.Garden, Folder.Scene, true, transform, true, ObjType.Garden).AddScript<Garden>();

        for (int i = 0; i < DefaultPage; i++)
        {
            CreatePage();
        }

        #region 生成FlowerItem

        List<XmlAttributeCollection> attributeList = ConfigManager.GetFlowerConfig();

        for (int i = 0; i < attributeList.Count; i++)
        {
            FlowerInfo flowerInfo = new FlowerInfo(attributeList[i]);

            if (flowerInfo.Special)
            {
                TotalFlowerSpec++;
            }
            else
            {
                TotalFlowerRegu++;
            }

            FlowerInfoDic.Add(flowerInfo.ID_, flowerInfo);
        }

        #endregion
    }

    public override void FirstInit()
    {
        Instance = this;

        ElfTimer = Random.Range(MinElfTime, MaxElfTime);
        AwardTimer = Random.Range(MinAwardTime, MaxAwardTime);

        UnlockSlot();
        for (int i = 0; i < ConfigManager.GetPlayerInt(PlayerConfigLabel.ExtraSlot); i++)
        {
            UnlockSlot();
        }

        #region 读花朵存档

        List<int> flowerIDList = ConfigManager.GetFlowerList();

        for (int i = 0; i < flowerIDList.Count; i++)
        {
            FlowerInfoDic[flowerIDList[i]].Unlock = true;
        }


        List<int> flowerAmountList = ConfigManager.GetIntList(' ', PlayerConfigLabel.FlowerAmtList, null);

        for (int i = 0; i < flowerAmountList.Count; i++)
        {
            FlowerInfoDic[flowerIDList[i]].Amount = flowerAmountList[i];
        }


        List<KV<int, int>> plantList = ConfigManager.GetPlantList();

        for (int i = 0; i < plantList.Count; i++)
        {
            PlantFlower(plantList[i].Key, plantList[i].Value);
        }

        #endregion
    }

    public override void RegistReference()
    {
        RetrieveButton = ResourceManager.Get<Button>(ObjectLabel.H_Btn);
        RetrieveButtonLab = ResourceManager.Get<Text>(ObjectLabel.H_BtnLab);
        PurchaseButton = ResourceManager.Get<Button>(ObjectLabel.H_Btn1);
        PurchaseButtonLab = ResourceManager.Get<Text>(ObjectLabel.H_BtnLab1);
    }


    public static int DefaultPage = 2;
    public static int CriticalSlotAmt = 7;
    public static int TotalSlotAmtInOnePage = 9;
    public static void UnlockSlot()
    {
        for (int i = 0; i < SlotList.Count; i++)
        {
            if (SlotList[i].Lock == false)
            {
                Slot++;
                
                SlotList[i].Lock = true;
                SlotList[i].Available = true;
                
                if (Slot% TotalSlotAmtInOnePage == CriticalSlotAmt)
                {
                    if (Slot/ TotalSlotAmtInOnePage + DefaultPage >= Page)
                    {
                        CreatePage();
                    }
                }

                return;
            }
        }
    }


    private static float PageXOffset = 18.9f;
    public static void CreatePage()
    {
        Transform tra = ResourceManager.Get(ResourceLabel.Page, Folder.Scene, false, ResourceManager.Get("GardenPage"), false, ObjType.Page);

        float offset = Page*PageXOffset;

        tra.SetLX(offset);

        Vector3 pos = ResourceManager.Get("GardenPage").position;

        pos.x = -offset;
        
        Garden.PagePos.Add(pos);

        for (int i = 0; i < TotalSlotAmtInOnePage; i++)
        {
            Slot slot = tra.GetChild(i).GetComponent<Slot>();
            
            if (slot == null)
            {
                slot = tra.GetChild(i).AddScript<Slot>();
            }

            slot.Index = SlotList.Count;

            SlotList.Add(slot);
        }


        PageList.Add(tra);
    }

    public static void ShowPlantCard(FlowerInfo flowerInfo, Slot seleSlot = null)
    {
        ShowFlowerCard(flowerInfo, null, seleSlot);

        RetrieveButton.SetActive(false);
        PurchaseButton.SetActive(true);
    }

    public static void ShowRetrieveCard(FlowerInfo flowerInfo, Slot seleSlot = null)
    {
        ShowFlowerCard(flowerInfo, null, seleSlot);

        RetrieveButton.SetActive(true);
        PurchaseButton.SetActive(true);
    }

    public static void ShowUnlockCard(FlowerInfo flowerInfo, Slot seleSlot = null)
    {
        ShowFlowerCard(flowerInfo, Lib.GrayMat, seleSlot);

        RetrieveButton.SetActive(false);
        PurchaseButton.SetActive(true);
    }

    private static void ShowFlowerCard(FlowerInfo flowerInfo, Material material, Slot seleSlot)
    {
        SetRetrieveBtn(RetrieveButton, RetrieveButtonLab, seleSlot);
        SetPurchaseBtn(flowerInfo, PurchaseButton, PurchaseButtonLab);

        SeleInfo = flowerInfo;

        ResourceManager.Get(ObjectLabel.H_FlowerCard).TweenForCG();
        ResourceManager.SetText(ObjectLabel.H_Lab, flowerInfo.Name);

        SetPlantStatus(flowerInfo);

        Image image = ResourceManager.Get<Image>(ObjectLabel.H_Icon2);
        image.material = material;
        image.sprite = flowerInfo.Icon;
        image.Resize(true, 0.6125f, 0.6125f);
    }

    private static void SetRetrieveBtn(Button button, Text buttonLab, Slot seleSlot = null)
    {
        RetrieveButton = button;
        buttonLab.text = Language.GetStr(LanguageLabel.UI__H_BtnLab1);
        button.image.material = null;
        button.onClick.RemoveAllListeners();
        button.onClick.AddListener
        (
            () =>
            {
                AudioManager.PlayClip(Clip.BtnClip);

                RetriveFlower(seleSlot);
            }
        );
    }

    private static void SetPurchaseBtn(FlowerInfo flowerInfo, Button button, Text buttonLab)
    {
        if (flowerInfo.UnlockCur == Current.Free)
        {
            buttonLab.text = Language.GetStr(LanguageLabel.UI__H_BtnLab2);
            button.image.material = Lib.GrayMat;
            button.onClick.RemoveAllListeners();
            button.onClick.AddListener
            (
                () =>
                {
                    Bubble.Show(null, Language.GetStr(LanguageLabel.UI__H_BtnLab3));
                }
            );
        }
        else
        {
            buttonLab.text = Auxiliary.ImageParse(flowerInfo.UnlockCur) + flowerInfo.UnlockAmt;
            button.image.material = null;
            button.onClick.RemoveAllListeners();
            button.onClick.AddListener
            (
                () =>
                {
                    Manager.Pay
                    (
                        "",
                        flowerInfo.UnlockAmt,
                        flowerInfo.UnlockCur,
                        () =>
                        {
                            flowerInfo.Add();
                            SetPlantStatus(flowerInfo);
                            HttpManager.Save();

                            PlayFlowerCardMatTween();

                            AudioManager.PlayClip(Clip.CurrentClip);

                            ResourceManager.Get(ObjectLabel.H_Icon1).FindChild($"{ObjectLabel.H_UIFlashLight}/{ObjectLabel.H_UIParticleSystem}").GetComponent<UIPartical>().Begin();
                        },
                        StaticsManager.ItemID.解锁花朵,
                        StaticsManager.ConsumeModule.Shop,
                        true,
                        false,
                        () =>
                        {
                            ResourceManager.Get(ObjectLabel.H_FlowerCard).TweenBacCG();
                            TweenCG tweenCg = ResourceManager.Get(ObjectLabel.G_Flower).TweenBacCG();

                            tweenCg.AddEventOnetime
                            (
                                EventType.BackwardFinish,
                                () =>
                                {
                                    ResourceManager.Get(ObjectLabel.F_Manage0).TweenForVec();
                                }
                            );
                        }
                    );
                }
            );
        }
    }

    private static void SetPlantStatus(FlowerInfo flowerInfo)
    {
        if (flowerInfo.RemainAmount == 0)
        {
            ResourceManager.Get<Button>(ObjectLabel.H_Icon2).interactable = false;
            ResourceManager.SetActive(ObjectLabel.H_AmtLab, false);
            ResourceManager.SetActive(ObjectLabel.H_Desc, false);
            ResourceManager.SetActive(ObjectLabel.H_Rotate, false);
        }
        else
        {
            ResourceManager.SetActive(ObjectLabel.H_Desc, true);
            ResourceManager.Get<Button>(ObjectLabel.H_Icon2).interactable = true;
            ResourceManager.SetActive(ObjectLabel.H_AmtLab, true);
            ResourceManager.SetText(ObjectLabel.H_AmtLab, "x" + flowerInfo.RemainAmount);
            ResourceManager.SetActive(ObjectLabel.H_Rotate, true);
        }
    }

    private static void SetRetrieveStatus(FlowerInfo flowerInfo, Button button)
    {
        if (flowerInfo.PlantAmt == 0)
            button.SetActive(false);
        else
            button.SetActive(true);
    }

    private static void PlayFlowerCardMatTween()
    {
        if (ResourceManager.Get<Image>(ObjectLabel.H_Icon2).material != Lib.GrayMat)
        {
            return;
        }

        Material material = new Material(ResourceManager.Get<Image>(ObjectLabel.H_Icon2).material);

        MaterialUnit materialUnit = new MaterialUnit
        (
            material,
            ResourceManager.Get(ObjectLabel.H_Icon2),
            new List<string>()
            {
                "_GrayLerp",
            }
        );

        FlowerCardMatTween = materialUnit.CreateTweenMatFloat(1, 0, 1, true, true, Curve.EaseOutQuad, false);

        FlowerCardMatTween.OnForwardStart = () =>
        {
            materialUnit.Transform.GetComponent<Image>().material = materialUnit.Material;
        };

        FlowerCardMatTween.OnForwardFinish = () =>
        {
            ResourceManager.Get<Image>(ObjectLabel.H_Icon2).material = null;
        };

        materialUnit.TweenForMatFloat();
    }


    public static void RetriveFlower(Slot seleSlot = null)
    {
        if (seleSlot != null && seleSlot.Flower == null)
            seleSlot = null;

        if (seleSlot == null)
        {
            foreach (var slot in PlantList)
            {
                if (slot.Flower.FlowerInfo == SeleInfo)
                {
                    seleSlot = slot;
                    break;
                }
            }
        }

        seleSlot.Retrieve();
        SetPlantStatus(seleSlot.FlowerInfo);
        SetRetrieveStatus(seleSlot.FlowerInfo, RetrieveButton);
    }

    public static void RetriveFlowerAll()
    {
        for (int i = 0; i < PlantList.Count; i++)
        {
            PlantList[i--].Retrieve();
        }
    }


    public static void PlantFlower(int id, int index)
    {
        Slot slot = SlotList[index];

        FlowerInfo flowerInfo = FlowerInfoDic[id];

        slot.Plant(flowerInfo, false);
    }

    public static void PlantFlower(FlowerInfo flowerInfo)
    {
        Slot slot = null;

        for (int i = 0; i < SlotList.Count; i++)
        {
            if (SlotList[i].Available)
            {
                slot = SlotList[i];

                break;
            }
        }

        if (slot == null)
        {
            Bubble.Show(null, Language.GetStr(LanguageLabel.Common__NoValidSlot));
        }
        else
        {
            slot.Plant(flowerInfo, true);
            SetPlantStatus(flowerInfo);
            SetRetrieveStatus(flowerInfo, RetrieveButton);
            AudioManager.PlayClip(Clip.FlowerClip);
        }
    }


    public static void RetrieveAllElf()
    {
        for (int i = 0; i < PlantList.Count; i++)
        {
            PlantList[i].Flower.RetrieveElf();
        }
    }

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