garden_client/Assets/Script/Manage/ResourceManager.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,
    Atlas,
    Atlas2,
    Effect,
    Audio,
    Scene,
    Config,
    Discard,
    PlazaRoom,
}

public enum ObjType
{
    Null,

    Firework,
    LightwallUI,

    Player,

    SlotPage,
    Flower,
    Garden,
    Tutorial,
    CloseItem,
    DressRoom,

    Canvas,
    EventSystem,
    MainCamera,

    ChestTimer,
    NickName,
    MessageBox,
    HudText,
    MailItem,
    GardenInfoItem,
    PlazaroomInfoItem,
    SkillItem,
    SignItem,
    RankItem,
    PlazaRoomItem,
    FlowerItem,
    AchieveItem,
    CommentItem,

    Music,

    Star,
    FlyGold,
    ADChest,
    PlazaRoomChest,
    DropGold,
    DropDiamond,
    PlazaRoomStar,

    Bee,
    Beetle,
    Butterfly,
    Dragonfly,
}

public class AsyncRequest
{
    public UnityAction Callback;
    public AssetBundleRequest Request;
}

public class ResourceManager : Regist
{
    #region Config

    public static bool AsyncLoadFlag;
    public static bool AsyncInstantiateFlag;

    public static Coroutine AsyncLoadRoutine;
    public static Coroutine InstantiateRoutine;

    public static List<UnityAction> AsyncList = new List<UnityAction>();
    public static List<AssetBundleRequest> RequestList = new List<AssetBundleRequest>();
    public static List<KV<AsyncRequest, UnityAction>> InstantiateList = new List<KV<AsyncRequest, UnityAction>>();

    private static string UnityDefaultSuffix = "(Clone)";

    public static Dictionary<string, Sprite> SpriteDictionary = new Dictionary<string, Sprite>();
    public static Dictionary<string, Object> ObjectDictionary = new Dictionary<string, Object>();
    public static Dictionary<string, Transform> TransformDictionary = new Dictionary<string, Transform>();
    public static Dictionary<ObjType, List<Transform>> ObjectPool = new Dictionary<ObjType, List<Transform>>();
    public static Dictionary<GameObject, ObjType> ObjectPoolDictionary = new Dictionary<GameObject, ObjType>();

    public static ResourceManager Instance;

    #endregion

    public override bool InitAtOnce()
    {
        if (base.InitAtOnce())
        {
            return true;
        }

        Instance = this;

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

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

        TransformDictionary.Add(objPool.name, objPool);

        AsyncLoadRoutine = StartCoroutine(IAsyncLoad());
        InstantiateRoutine = StartCoroutine(IAsyncInstancitate());

        return false;
    }

    #region TransformDictionary

    public static T Get<T>(string goName, bool warn = true)
    {
        Transform tra;

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

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

            return t;
        }
        else
        {
            if (warn)
            {
                throw new Exception(goName);
            }
            else
            {
                return default(T);
            }
        }
    }

    public static T[] Gets<T>(string goName, bool warn = true)
    {
        Transform tra;

        if (TransformDictionary.TryGetValue(goName, out tra))
        {
            T[] t = tra.GetComponentsInChildren<T>();

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

            return t;
        }
        else
        {
            if (warn)
            {
                throw new Exception(goName);
            }
            else
            {
                return default(T[]);
            }
        }
    }

    public static Transform Get(string goName, bool warn = true)
    {
        Transform tra;

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

    #endregion

    #region ObjPool

    public static void Save<T>(T t, bool warn = false) where T : Component
    {
        Save(t.gameObject);
    }

    public static void Save(GameObject go, bool warn = false)
    {
        ObjType objType;

        if (!ObjectPoolDictionary.TryGetValue(go, out objType))
        {
            throw new Exception();
        }

        List<Transform> traList;

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

            go.SetActive(false);

            traList.Add(go.transform);

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


    public static bool Contains<T>(T t) where T : Component
    {
        return Contains(t.gameObject);
    }

    public static bool Contains(GameObject go)
    {
        foreach (var kv in ObjectPool)
        {
            if (kv.Value.Contains(go.transform))
            {
                return true;
            }
        }

        return false;
    }

    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 Text SetText(string goName)
    {
        Text text = Get<Text>(goName);

        text.text = Language.GetStr(LabelUtility.CombineLanguageLabel(LanguageLabel.UI, goName));

        return text;
    }

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

        text.text = str;

        return text;
    }

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

        image.sprite = sprite;

        return image;
    }

    public static Transform SetActive(string goName, bool active)
    {
        Transform tra = Get(goName);

        tra.SetActive(active);

        return tra;
    }

    public static Button SetButtonEvent(string goName, UnityAction onClick)
    {
        Button button = Get<Button>(goName);

        button.onClick = new Button.ButtonClickedEvent();

        button.onClick.AddListener(onClick);

        return button;
    }

    public static Button AddButtonEvent(string goName, UnityAction onClick)
    {
        Button button = Get<Button>(goName);

        button.onClick.AddListener(onClick);

        return button;
    }

    public static Button PushButtonEvent(string goName, UnityAction onClick)
    {
        Button button = Get<Button>(goName);

        Button.ButtonClickedEvent click = button.onClick;

        button.onClick = new Button.ButtonClickedEvent();

        button.onClick.AddListener(onClick);
        button.onClick.AddListener(click.Invoke);

        return button;
    }

    public static Button AddButtonEventOnetime(string goName, UnityAction onClick)
    {
        Button button = Get<Button>(goName);

        onClick += () =>
        {
            button.onClick.RemoveListener(onClick);
        };

        button.onClick.AddListener(onClick);

        return button;
    }

    public static Button PushButtonEventOnetime(string goName, UnityAction onClick)
    {
        Button button = Get<Button>(goName);

        onClick += () =>
        {
            button.onClick.RemoveListener(onClick);
        };

        Button.ButtonClickedEvent click = button.onClick;

        button.onClick = new Button.ButtonClickedEvent();

        button.onClick.AddListener(onClick);
        button.onClick.AddListener(click.Invoke);

        return button;
    }

    #endregion


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

        if (ObjectDictionary.TryGetValue(goName, out obj))
        {
            if (objType != ObjType.Null)
            {
                ObjectPool.UniqueAdd(objType, new List<Transform>());
            }
            
            return (T) obj;
        }
        else
        {
            T t = Bundle.Load<T>(goName, folder);
            
            if (t == null)
            {
                throw new Exception(goName + " " + folder);
            }

            ObjectDictionary.Add(goName, t);

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

            return t;
        }
    }

    public static Sprite LoadSprite(string goName, Folder folder)
    {
        if (SpriteDictionary.ContainsKey(goName))
        {
            return SpriteDictionary[goName];
        }
        else
        {
            return Load<Sprite>(goName, folder);
        }
    }


    public static Transform Get(string goName, Folder folder, bool compile, Transform par, bool worldSpace, ObjType objType = ObjType.Null, Type type = 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(UnityDefaultSuffix, "");

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

            if (objType != ObjType.Null)
            {
                ObjectPoolDictionary.Add(go, objType);
            }

            if (type != null)
            {
                go.AddComponent(type);
            }

            return go.transform;
        }
        else
        {
            if (compile)
            {
                Auxiliary.CompileDic(tra, TransformDictionary);
            }

            GameObject prefab = Load<GameObject>(goName, folder, objType);

            tra.SetParent(par);

            if (worldSpace)
            {
                tra.position = prefab.transform.position;
            }
            else
            {
                tra.localPosition = prefab.transform.position;
            }

            if (type != null)
            {
                if (tra.GetComponent(type) == null)
                {
                    tra.AddComponent(type);
                }
            }

            return tra;
        }
    }

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

        if (tra == null)
        {
            GameObject go = Load<GameObject>(goName, folder, objType);
            
            go = Instantiate(go, pos, Quaternion.identity, par);
            go.name = go.name.Replace(UnityDefaultSuffix, "");

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

            if (objType != ObjType.Null)
            {
                ObjectPoolDictionary.Add(go, objType);
            }

            if (type != null)
            {
                go.AddComponent(type);
            }

            return go.transform;
        }
        else
        {
            if (compile)
            {
                Auxiliary.CompileDic(tra, TransformDictionary);
            }

            tra.SetParent(par);

            tra.position = pos;

            if (type != null)
            {
                if (tra.GetComponent(type) == null)
                {
                    tra.AddComponent(type);
                }
            }

            return tra;
        }
    }


    private static float StarMinOffset = -0.0001f;
    private static float StarMaxOffset = -0.001f;
    public static Star GetStar()
    {
        int slotIndex = Random.Range(0, GardenManager.TotalSlotInOnePage);

        bool forceLeft = slotIndex == GardenManager.RightTopSlotIndex || slotIndex == GardenManager.RightDownSlotIndex;
        bool forceRight = slotIndex == GardenManager.LeftTopSlotIndex || slotIndex == GardenManager.LeftDownSlotIndex;

        slotIndex += Garden.CurrentPage* GardenManager.TotalSlotInOnePage;


        Slot slot = GardenManager.SlotList[slotIndex];

        Vector3 pos = slot.transform.position;

        Transform tra = Get(ResourceLabel.Star, Folder.Scene, false, null, pos, ObjType.Star);

        Star star = tra.GetComponent<Star>();

        tra.parent = slot.transform;
        tra.SetLZ(-0.1f + Random.Range(StarMinOffset, StarMaxOffset));

        if (star == null)
        {
            star = tra.AddComponent<Star>();

            star.Init(pos.y, forceLeft, forceRight);
        }
        else
        {
            star.Init(pos.y, forceLeft, forceRight);
        }

        return star;
    }


    public static ADChest GetADChest()
    {
        Transform tra = Get(ResourceLabel.ADChest, Folder.Scene, false, Get(GardenLabel.SlotPage), true, ObjType.ADChest);

        ADChest chest = tra.GetComponentInChildren<ADChest>(true);

        if (chest == null)
        {
            chest = tra.GetChild(0).AddComponent<ADChest>();

            chest.Init(tra.position.y, false, false);
        }
        else
        {
            chest.Init(tra.position.y, false, false);
        }

        return chest;
    }


    public static PlazaRoomChest GetPlazaRoomChest(Vector3 position)
    {
        Transform tra = Get(ResourceLabel.PlazaRoomChest, Folder.Scene, false, Get(ResourceLabel.PlazaRoom), position, ObjType.PlazaRoomChest);

        PlazaRoomChest chest = tra.GetComponentInChildren<PlazaRoomChest>(true);

        if (chest == null)
        {
            chest = tra.GetChild(0).AddComponent<PlazaRoomChest>();
        }

        return chest;
    }


    public static Drop GetDrop(ObjType objType)
    {
        AudioManager.PlayClip(AudioLabel.Minigame_DropAward);

        Vector3 leftPos = Get(GardenLabel.Minigame_DropAward_LeftBorder).position;
        Vector3 rightPos;

        if (MiniGameManager.miniGameType == MiniGameType.Punch || MiniGameManager.miniGameType == MiniGameType.Find)
        {
            rightPos = Get(GardenLabel.FindMinigame_DropAward_RightBorder).position;
        }
        else
        {
            rightPos = Get(GardenLabel.MemoryMinigame_DropAward_RightBorder).position;
        }

        Vector3 pos = Vector3.Lerp(leftPos, rightPos, Random.Range(0, 1f));

        Transform tra;

        if (objType == ObjType.DropGold)
        {
            tra = Get(ResourceLabel.DropGold, Folder.Scene, false, null, pos, objType, typeof(DropGold));
        }
        else if(objType == ObjType.DropDiamond)
        {
            tra = Get(ResourceLabel.DropDiamond, Folder.Scene, false, null, pos, objType, typeof(DropDiamond));
        }
        else
        {
            throw new Exception();
        }

        Drop drop = tra.GetComponent<Drop>();

        drop.InitAtOnce();
        drop.ResetStatus();

        return drop;
    }


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

        tra.localScale = new Vector3(1, 1, 1);

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

        flower.InitAtOnce();

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

        flower.SetCollider(collider);

        return flower;
    }

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

        tra.localScale = new Vector3(1, 1, 1);

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

        flower.InitAtOnce();

        flower.FlowerInfo = flowerInfo;

        flower.SetCollider(false);

        return flower;
    }


    public static TextPlus GetInfoItem(string infoItemName, Transform parent, ObjType objType)
    {
        Transform tra = Get(infoItemName, Folder.UI, false, parent, false, objType);

        TextPlus text = tra.GetComponent<TextPlus>();

        TweenRoot tween = text.CreateTweenGra(0, 1, 0.25f, true, true, Curve.EaseOutQuad);

        tween.OnBackwardFinish = () =>
        {
            Save(text);
        };

        return text;
    }


    public static HudText GetHudText(string str, Color color, int size, Transform posTra, Transform parTra, bool scene, float speed = 7.5f, float time = 0.5f, float stay = 0.5f)
    {
        Vector3 pos;

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

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

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

        hudText.Show(str, color, size, speed, time, stay);

        return hudText;
    }


    public static Ranktem GetRanktem(string rank, string praise, string serialNumber)
    {
        Transform tra = Get(ResourceLabel.RankItem, Folder.UI, false, Get(ObjectLabel.S_Grid), false, ObjType.RankItem, typeof(Ranktem));

        Ranktem ranktem = tra.GetComponent<Ranktem>();

        ranktem.InitAtOnce();

        ranktem.Reset(rank, praise, serialNumber);

        return ranktem;
    }


    public static CommentItem GetCommentItem(string nickname, string serialNumber, string content)
    {
        Transform tra = Get(ResourceLabel.CommentItem, Folder.UI, false, Get(ObjectLabel.Q_Grid), false, ObjType.CommentItem, typeof(CommentItem));

        CommentItem commentItem = tra.GetComponent<CommentItem>();

        commentItem.InitAtOnce();

        commentItem.Reset(nickname, serialNumber, content);

        return commentItem;
    }


    private static char ElfSeperator = '_';
    private static float ElfMinOffset = 0.001f;
    private static float ElfMaxOffset = 0.1f;
    public static Transform GetElf(Flower flower, Vector4 offset, ElfType elfType)
    {
        Transform tra;

        Bounds bounds = flower.FlowerIcon.bounds;
        Vector3 pos = flower.FlowerIcon.transform.position + new Vector3(0, 0, -5f);
        Transform par = flower.transform;


        ObjType obj = elfType.ToString().Split(ElfSeperator)[0].ToEnum<ObjType>();

        pos.z -= Random.Range(ElfMinOffset, ElfMaxOffset);

        tra = Get(obj.ToString(), Folder.Scene, false, par, pos, obj);

        Elf elf = tra.GetChild(0).GetComponent<Elf>();

        if (elf == null)
        {
            elf = tra.GetChild(0).AddScript<Elf>();
        }

        tra.GetComponentInChildren<SpriteRenderer>().sprite = LoadSprite(elfType.ToString(), Folder.Atlas2);


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

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

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


        elf.ParentFlower = flower;
        elf.Animator.SetTrigger("Play");

        return tra;
    }


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

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

        skillRoot.SkillItem = tra;

        return tra;
    }


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

        return tra;
    }
    

    public static ParticleSystem GetFirework(Vector3 pos)
    {
        Transform tra = Get(ResourceLabel.Firework, Folder.Effect, false, null, pos, ObjType.Firework, typeof(Effect));

        ParticleSystem particle = tra.GetComponent<ParticleSystem>();

        particle.Play();

        return particle;
    }


    public static ParticleSystem GetLightwall()
    {
        Transform tra = Get(ResourceLabel.LightwallUI, Folder.Effect, false, Get(ObjectLabel.Canvas), false, ObjType.LightwallUI, typeof(Effect));

        ParticleSystem particle = tra.GetComponent<ParticleSystem>();

        if(particle != null)
            particle.Play();

        return particle;
    }


    public static void AsyncLoad<T>(string goName, Folder folder, UnityAction callback = null)
    {
        KV<AsyncRequest, UnityAction> kv = new KV<AsyncRequest, UnityAction>();

        AssetBundleRequest bundleRequest = Bundle.LoadAsync<T>(goName, folder);
        
        AsyncRequest asyncRequest = new AsyncRequest();
        asyncRequest.Request = bundleRequest;
        asyncRequest.Callback = callback;

        kv.Key = asyncRequest;
        kv.Value = () =>
        {
            ObjectDictionary.UniqueAdd(goName, bundleRequest.asset);
        };

        RequestList.Add(bundleRequest);

        InstantiateList.Add(kv);
    }

    public static void AsyncLoad(string goName, int amt, Folder folder, ObjType objType, bool ui = false, bool canvas = false, UnityAction callback = null)
    {
        KV<AsyncRequest, UnityAction> kv = new KV<AsyncRequest, UnityAction>();

        AssetBundleRequest bundleRequest = Bundle.LoadAsync<object>(goName, folder);
        
        AsyncRequest asyncRequest = new AsyncRequest();
        asyncRequest.Request = bundleRequest;
        asyncRequest.Callback = callback;

        kv.Key = asyncRequest;
        kv.Value = () =>
        {
            ObjectDictionary.UniqueAdd(goName, bundleRequest.asset);

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

            GameObject go;

            if (ui)
            {
                go = (GameObject)Instantiate(bundleRequest.asset, GameObject.Find(LogoSceneLabel.ManagerGame).transform.GetChild(0).GetChild(0));
            }
            else
            {
                go = (GameObject)Instantiate(bundleRequest.asset);
            }

            ObjectPoolDictionary.Add(go, objType);

            go.name = go.name.Replace(UnityDefaultSuffix, "");

            Save(go);

            if (ui)
            {
                go.SetParent(GameObject.Find(LogoSceneLabel.ManagerGame).transform.GetChild(0).GetChild(0));
            }
        };


        RequestList.Add(bundleRequest);

        for (int i = 0; i < amt; i++)
        {
            InstantiateList.Add(kv);
        }
    }

    public static void AddAsyncLoad<T>(string goName, Folder folder, UnityAction callback = null)
    {
        AsyncList.Add
        (
            () =>
            {
                AsyncLoad<T>(goName, folder, callback);
            }
        );
    }

    public static void AddAsyncLoad(string goName, int amt, Folder folder, ObjType objType, bool ui = false, bool canvas = false, UnityAction callback = null)
    {
        AsyncList.Add
        (
            () =>
            {
                AsyncLoad(goName, amt, folder, objType, ui, canvas, callback);
            }
        );
    }


    public void StopAllAsync()
    {
        StopCoroutine(AsyncLoadRoutine);
        StopCoroutine(InstantiateRoutine);
    }

    public static IEnumerator IAsyncLoad()
    {
        while (true)
        {
            if (RequestList.Count > 0)
            {
                yield return null;
            }
            else
            {
                if (AsyncList.Valid() && !AsyncLoadFlag)
                {
                    AsyncLoadFlag = true;

                    Auxiliary.Instance.DelayCall
                    (
                        () =>
                        {
                            AsyncLoadFlag = false;

                            AsyncList[0].SafeInvoke();

                            AsyncList.RemoveAt(0);
                        },
                        1
                    );

                    yield return null;
                }
                else
                {
                    yield return null;
                }
            }
        }
    }

    public static IEnumerator IAsyncInstancitate()
    {
        while (true)
        {
            if (AsyncInstantiateFlag)
            {
                yield return null;
            }

            if (!InstantiateList.Valid())
            {
                yield return null;
            }
            else
            {
                if (Time.deltaTime > 0.333f)
                {
                    yield return null;
                }

                if (!InstantiateList[0].Key.Request.isDone)
                {
                    yield return null;
                }
                else
                {
                    InstantiateList[0].Key.Callback.SafeInvoke();

                    RequestList.Remove(InstantiateList[0].Key.Request);
                    
                    UnityAction action = InstantiateList[0].Value;

                    InstantiateList.RemoveAt(0);

                    AsyncInstantiateFlag = true;

                    Auxiliary.Instance.DelayCall
                    (
                        () =>
                        {
                            if (!Logo.Complete)
                            {
                                action.SafeInvoke();

                                AsyncInstantiateFlag = false;
                            }
                        },
                        1
                    );

                    yield return null;
                }
            }
        }
    }
}