garden_client/Assets/Script/Manage/ManaReso.cs

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

using System;
using System.Collections;
using System.Linq.Expressions;
using System.ComponentModel;
using System.Collections.Generic;

using Object = UnityEngine.Object;
using Random = UnityEngine.Random;
using Component = UnityEngine.Component;

public enum Folder
{
    UI,
    Skill,
    Config,
    Object,
    Shader,
    Garden,
    Character,
}

public enum ObjType
{
    Null,
    Flower,
    HudText,
    FlowerItem,
    AchieveItem,

    DropGold,
    DropDiamond,

    BeeRed,
    BeeBlue,
    BeeWhite,
    BeePurple,
    BeeYellow,

    ButterflyRed,
    ButterflyBlue,
    ButterflyWhite,
    ButterflyPurple,
    ButterflyYellow,
}

public class ManaReso : Regist
{
    #region 变量

    public static Dictionary<string, Object> ObjDic;
    public static Dictionary<string, Transform> TraDic;
    public static Dictionary<ObjType, List<Transform>> ObjectPool;

    #endregion

    public override void Instantiate()
    {
        TraDic = new Dictionary<string, Transform>();
        ObjDic = new Dictionary<string, Object>();
        ObjectPool = new Dictionary<ObjType, List<Transform>>();

        Transform objPool = new GameObject("ObjPool").transform;

        objPool.parent = transform;
        objPool.SetActive(false);

        TraDic.Add(objPool.name, objPool);
    }

    public override void TutorialInstantiate()
    {
        Instantiate();
    }


    public static T Load<T>(string goName, Folder folder, ObjType objType = ObjType.Null) where T : Object
    {
        Object obj;

        if (ObjDic.TryGetValue(goName, out obj))
        {
            return (T)obj;
        }
        else
        {
            T t;

            if (folder == Folder.UI)
            {
                t = Bundle.UI.LoadAsset<T>(goName);
            }
            else if (folder == Folder.Skill)
            {
                t = Bundle.Skill.LoadAsset<T>(goName);
            }
            else if (folder == Folder.Config)
            {
                t = Bundle.Config.LoadAsset<T>(goName);
            }
            else if (folder == Folder.Object)
            {
                t = Bundle.Object.LoadAsset<T>(goName);
            }
            else if (folder == Folder.Shader)
            {
                t = Bundle.Shader.LoadAsset<T>(goName);
            }
            else if (folder == Folder.Garden)
            {
                t = Bundle.Garden.LoadAsset<T>(goName);
            }
            else if (folder == Folder.Character)
            {
                t = Bundle.Character.LoadAsset<T>(goName);
            }
            else
            {
                throw new Exception();
            }

            if (t == null)
            {
                throw new Exception(goName);
            }

            ObjDic.Add(goName, t);

            if (objType != ObjType.Null)
            {
                ObjectPool.Add(objType, new List<Transform>());
            }

            return t;
        }
    }

    public static Transform Get(string goName, Folder folder, bool compile, Transform par, Vector3 pos, ObjType objType = ObjType.Null)
    {
        Transform tra = Get(objType);

        if (tra != null)
        {
            tra.SetParent(par);

            tra.position = pos;

            return tra;
        }
        else
        {
            GameObject go = Load<GameObject>(goName, folder, objType);

            go = Instantiate(go, pos, Quaternion.identity, par);
            go.name = go.name.Replace("(Clone)", "");

            if (compile)
            {
                Auxiliary.CompileDic(go.transform, TraDic);
            }

            return go.transform;
        }
    }

    public static Transform Get(string goName, Folder folder, bool compile, Transform par, bool worldSpace, ObjType objType = ObjType.Null)
    {
        Transform tra = Get(objType);

        if (tra == null)
        {
            GameObject go = Load<GameObject>(goName, folder, objType);

            go = Instantiate(go, par, worldSpace);
            go.name = go.name.Replace("(Clone)", "");

            if (compile)
            {
                Auxiliary.CompileDic(go.transform, TraDic);
            }

            return go.transform;
        }
        else
        {
            tra.SetParent(par);

            return tra;
        }
    }


    public static DropGold GetGold()
    {
        Vector3 pos = Vector3.Lerp(Get("LeftPosTraMini").position, Get("RightPosTraMini").position, Random.Range(0, 1f));
        pos.z = -2;

        Transform tra = Get("DropGold", Folder.UI, false, null, pos, ObjType.DropGold);

        DropGold dropGold = tra.GetComponent<DropGold>();

        if (dropGold == null)
        {
            dropGold = tra.AddComponent<DropGold>();
        }

        dropGold.ResetSta();

        return dropGold;
    }

    public static DropDiamond GetDiamond()
    {
        Vector3 pos = Vector3.Lerp(Get("LeftPosTraMini").position, Get("RightPosTraMini").position, Random.Range(0, 1f));
        pos.z = -2;

        Transform tra = Get("DropDiamond", Folder.UI, false, null, pos, ObjType.DropDiamond);

        DropDiamond dropDiamond = tra.GetComponent<DropDiamond>();

        if (dropDiamond == null)
        {
            dropDiamond = tra.AddComponent<DropDiamond>();
        }

        dropDiamond.ResetSta();

        return dropDiamond;
    }

    public static Flower GetFlower(FlowerInfo flowerInfo, Slot slot, bool collider)
    {
        Transform tra = Get("Flower", Folder.Garden, false, slot.transform, false, ObjType.Flower);

        Flower flower = tra.GetComponent<Flower>();

        if (flower == null)
        {
            flower = tra.AddComponent<Flower>();

            flower.ObjType = ObjType.Flower;
            flower.LocalPos = flower.transform.localPosition;
        }
        else
        {
            flower.GoldBk.SetActive(false);
            flower.transform.localPosition = flower.LocalPos;
        }

        flower.FlowerInfo = flowerInfo;
        flower.Slot = slot;

        flower.SetCollider(collider);

        return flower;
    }

    public static Flower GetFlower(FlowerInfo flowerInfo, Transform par)
    {
        Transform tra = Get("Flower", Folder.Garden, false, par, false, ObjType.Flower);

        Flower flower = tra.GetComponent<Flower>();

        if (flower == null)
        {
            flower = tra.AddComponent<Flower>();

            flower.ObjType = ObjType.Flower;
            flower.LocalPos = flower.transform.localPosition;
        }
        else
        {
            flower.GoldBk.SetActive(false);
            flower.transform.localPosition = flower.LocalPos;
        }

        flower.FlowerInfo = flowerInfo;

        flower.SetCollider(false);

        return flower;
    }

    public static HudText GetHudText(string str, Color color, int size, Transform posTra, Transform parTra, bool scene)
    {
        Vector3 pos;

        if (scene)
        {
            pos = Camera.main.WorldToScreenPoint(posTra.position);
        }
        else
        {
            pos = posTra.position;
        }

        Transform tra = Get("HudText", Folder.UI, false, parTra, pos, ObjType.HudText);

        HudText hudText = tra.GetComponent<HudText>();

        if (hudText == null)
        {
            hudText = tra.AddComponent<HudText>();
            hudText.ObjType = ObjType.HudText;
        }

        hudText.Show(str, color, size);

        return hudText;
    }

    public static Transform GetAnim(Bounds bounds, ObjType obj, Vector3 pos, Transform parTra)
    {
        Transform tra;

        tra = Get(obj.ToString(), Folder.Character, false, parTra, pos, obj);

        ObjRoot objRoot = tra.GetComponent<ObjRoot>();

        if (objRoot == null)
        {
            tra.AddComponent<ObjRoot>().ObjType = obj;

            tra.GetChild(0).AddComponent<AnimationReceiver>();
        }

        if (Random.Range(0f, 1f) <= 0.5f)
        {
            tra.SetEY(180);
        }
        else
        {
            tra.SetEY(0);
        }

        float offsetX = Mathf.Lerp(-0.75f*bounds.extents.x, 0.75f*bounds.extents.x, Random.Range(0f, 1f));
        float offsetY = Mathf.Lerp(0, 0.75f*bounds.extents.y, Random.Range(0f, 1f));

        tra.position += new Vector3(offsetX, offsetY, 0);

        return tra;
    }

    public static Transform GetSkillItem(SkillRoot skillRoot)
    {
        Transform tra;

        if (skillRoot.SkillTab == SkillTab.Elf)
        {
            tra = Get("SkillItem", Folder.UI, false, Get("Fd_Grid"), false);
        }
        else if (skillRoot.SkillTab == SkillTab.Store)
        {
            tra = Get("SkillItem", Folder.UI, false, Get("Fc_Grid"), false);
        }
        else if (skillRoot.SkillTab == SkillTab.Magic)
        {
            tra = Get("SkillItem", Folder.UI, false, Get("Fb_Grid"), false);
        }
        else if (skillRoot.SkillTab == SkillTab.Garden)
        {
            tra = Get("SkillItem", Folder.UI, false, Get("Fa_Grid"), false);
        }
        else
        {
            throw new Exception();
        }

        skillRoot.SkillItem = tra;

        return tra;
    }

    public static Transform GetAchieveItem()
    {
        Transform tra = Get("AchieveItem", Folder.UI, false, ManaReso.Get("M_Grid"), false, ObjType.AchieveItem);

        ObjRoot objRoot = tra.GetComponent<ObjRoot>();

        if (objRoot == null)
        {
            tra.AddComponent<ObjRoot>().ObjType = ObjType.AchieveItem;
        }

        return tra;
    }

    public static Transform GetFlowerItemH()
    {
        Transform tra = Get("FlowerItemH", Folder.UI, false, Get("H_Grid"), false, ObjType.FlowerItem);

        ObjRoot objRoot = tra.GetComponent<ObjRoot>();

        if (objRoot == null)
        {
            objRoot = tra.AddComponent<ObjRoot>();
        }

        objRoot.ObjType = ObjType.FlowerItem;

        return objRoot.transform;
    }


    #region TraDic

    public static T Get<T>(string goName)
    {
        Transform tra;

        if (TraDic.TryGetValue(goName, out tra))
        {
            T t = tra.GetComponent<T>();

            if (t == null)
            {
                throw new Exception();
            }

            return t;
        }
        else
        {
            throw new Exception(goName);
        }
    }

    public static Transform Get(string goName)
    {
        Transform tra;

        if (TraDic.TryGetValue(goName, out tra))
        {
            return tra;
        }
        else
        {
            throw new Exception(goName);
        }
    }

    #endregion

    #region ObjPool

    public static void Save<T>(T t, bool warn = true) where T : Component
    {
        Transform tra = t.transform;

        ObjRoot objRoot = tra.GetComponent<ObjRoot>();

        if (objRoot == null)
        {
            throw new Exception();
        }

        List<Transform> traList;

        if (ObjectPool.TryGetValue(objRoot.ObjType, out traList))
        {
            if (traList.Contains(tra))
            {
                if (warn)
                {
                    throw new Exception();
                }
                else
                {
                    return;
                }
            }

            tra.SetActive(false);

            traList.Add(tra);

            tra.transform.SetParent(Get("ObjPool"));
        }
        else
        {
            throw new Exception();
        }
    }

    public static void Save(GameObject go, bool warn = true)
    {
        ObjRoot objRoot = go.GetComponent<ObjRoot>();

        if (objRoot == null)
        {
            throw new Exception();
        }

        List<Transform> traList;

        if (ObjectPool.TryGetValue(objRoot.ObjType, out traList))
        {
            if (traList.Contains(go.transform))
            {
                if (warn)
                {
                    throw new Exception();
                }
                else
                {
                    return;
                }
            }

            go.SetActive(false);

            traList.Add(go.transform);

            go.transform.SetParent(Get("ObjPool"));
        }
        else
        {
            throw new Exception();
        }
    }


    public static void SaveUI<T>(T t, bool warn = true) where T : Component
    {
        Transform tra = t.transform;

        ObjRoot objRoot = tra.GetComponent<ObjRoot>();

        if (objRoot == null)
        {
            throw new Exception();
        }

        List<Transform> traList;

        if (ObjectPool.TryGetValue(objRoot.ObjType, out traList))
        {
            if (traList.Contains(tra))
            {
                if (warn)
                {
                    throw new Exception();
                }
                else
                {
                    return;
                }
            }

            tra.SetActive(false);

            traList.Add(tra);

            tra.transform.SetParent(Get("J_ObjPool"));
        }
        else
        {
            throw new Exception();
        }
    }

    public static void SaveUI(GameObject go, bool warn = true)
    {
        ObjRoot objRoot = go.GetComponent<ObjRoot>();

        if (objRoot == null)
        {
            throw new Exception();
        }

        List<Transform> traList;

        if (ObjectPool.TryGetValue(objRoot.ObjType, out traList))
        {
            if (traList.Contains(go.transform))
            {
                if (warn)
                {
                    throw new Exception();
                }
                else
                {
                    return;
                }
            }

            go.SetActive(false);

            traList.Add(go.transform);

            go.transform.SetParent(Get("J_ObjPool"));
        }
        else
        {
            throw new Exception();
        }
    }


    public static Transform Get(ObjType objType)
    {
        List<Transform> traList;

        if (ObjectPool.TryGetValue(objType, out traList))
        {
            if (traList.Count > 0)
            {
                Transform tra = traList[0];

                tra.SetActive(true);

                traList.RemoveAt(0);

                return tra.transform;
            }
        }

        return null;
    }

    #endregion

    #region ShortCut

    public static void SetText(string goName)
    {
        Text text = Get<Text>(goName);

        text.text = Language.GetStr("UI", goName);
    }

    public static void SetText(string goName, string str)
    {
        Text text = Get<Text>(goName);

        text.text = str;
    }

    public static void SetSprite(string goName, Sprite sprite)
    {
        Image image = Get<Image>(goName);

        image.sprite = sprite;
    }

    public static void SetActive(string goName, bool active)
    {
        Get(goName).SetActive(active);
    }

    public static void SetButtonEvent(string goName, params UnityAction[] onClicks)
    {
        Button button = Get<Button>(goName);

        button.onClick = new Button.ButtonClickedEvent();

        for (int i = 0; i < onClicks.Length; i++)
        {
            button.onClick.AddListener(onClicks[i]);
        }
    }

    public static void AddButtonEvent(string goName, params UnityAction[] onClicks)
    {
        Button button = Get<Button>(goName);

        for (int i = 0; i < onClicks.Length; i++)
        {
            button.onClick.AddListener(onClicks[i]);
        }
    }

    #endregion
}