Beispiel #1
0
    /// <summary>
    /// Create the specified definition and _async.
    /// </summary>
    /// <param name="definition">Definition.</param>
    /// <param name="_async">Object to attach async function</param>
    public void Create(PoolingDefinition definition, GameObject _async = null)
    {
        if (_pooledList.Length >= definition._amount)
        {
            return;             // ne ho già abbastanza qui dentro
        }
        if (_noPooling)
        {
            _tag           = definition._object.name;
            _prefabsObject = definition._object;
            _pooledAmount  = definition._amount;

            _loaded = true;
        }
        else
        {
            _tag           = definition._object.name;
            _prefabsObject = definition._object;
            _pooledAmount  = definition._amount;

            if (_async)
            {
                _async.GetComponent <MonoBehaviour>().StartCoroutine(__resize(_pooledAmount));
            }
            else
            {
                Resize(_pooledAmount);
            }
        }
    }
    IEnumerator __awake()
    {
        int index = 0;
        int count = _poolingDataBase.Length;

        if (count < _poolingDefinitions.Length)
        {
            _poolingDataBase = new Util_PoolManager[_poolingDefinitions.Length];

            while (count < _poolingDefinitions.Length)
            {
                Util_PoolManager o = new Util_PoolManager();

                o._noPooling = _noPooling;

                PoolingDefinition p = _poolingDefinitions[count++];

                if (p._amount == 0 && !_noPooling)
                {
                    Debug.LogWarning("Create a pooling with 0 element!");

                    continue;
                }

                o.Create(p, gameObject);

                yield return(o.waitingForCompletition());

                _poolingDataBase[index++] = o;
            }
        }

        yield return(new WaitForEndOfFrame());

        _loaded = true;

        __ENEMY   = Util_PoolManagerDatabase.GetInstance("ENEMY");
        __FX      = Util_PoolManagerDatabase.GetInstance("FX");
        __BULLETS = Util_PoolManagerDatabase.GetInstance("BULLETS");

                #if UNITY_EDITOR
        string children = "";

        for (int i = 0; i < transform.childCount; ++i)
        {
            children += transform.GetChild(i).name;
            children += "\n";
        }

        Debug.Log(transform.name);
        Debug.Log(children);
                #endif
    }
Beispiel #3
0
    public override void OnInspectorGUI()
    {
        serializedObject.Update();

        __refresh();

        // DrawDefaultInspector();

        Color c = GUI.backgroundColor;

        GUI.backgroundColor = Color.cyan;
        EditorGUILayout.HelpBox("Database parent.", MessageType.Info);
        GUI.backgroundColor = c;

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.LabelField(myScript.transform.parent.name, GUILayout.MaxWidth(150));

        if (GUILayout.Button(">", GUILayout.MaxWidth(30)))
        {
            Selection.activeGameObject = myScript.transform.parent.gameObject;
        }

        EditorGUILayout.EndHorizontal();

        EditorGUILayout.Space();
        EditorGUILayout.Space();
        EditorGUILayout.Space();

        GUI.backgroundColor = Color.cyan;
        EditorGUILayout.HelpBox("Async Pooling. Load everythig in 1 frames (sync) or bit for each frame (async)", MessageType.Info);
        GUI.backgroundColor = c;

        myScript._async = EditorGUILayout.Toggle("Async: ", myScript._async);

        EditorGUILayout.Space();

        GUI.backgroundColor = Color.cyan;
        EditorGUILayout.HelpBox("Ceate pooling when the gameobject is activated.", MessageType.Info);
        GUI.backgroundColor = c;

        myScript._loadAtStart = EditorGUILayout.Toggle("Load At Start: ", myScript._loadAtStart);

        EditorGUILayout.Space();

        GUI.backgroundColor = Color.cyan;
        EditorGUILayout.HelpBox("Enable pooling. If disable the object is create and destroy from memory.", MessageType.Warning);
        GUI.backgroundColor = c;

        myScript._noPooling = EditorGUILayout.Toggle("No pooling: ", myScript._noPooling);

        EditorGUILayout.Space();

        GUI.backgroundColor = Color.cyan;
        EditorGUILayout.HelpBox("TAG Pooling for key database key search. ( es: Util_PoolManagerDatabase.GetInstance(tag) )", MessageType.Info);
        GUI.backgroundColor = c;

        string tag = EditorGUILayout.TextField("TAG:", myScript._tag);

        if (tag != myScript._tag)
        {
            myScript._tag = tag;
            myScript.name = myScript._tag;
        }

        EditorGUILayout.Space();
        EditorGUILayout.Space();

        GUI.backgroundColor = Color.cyan;
        EditorGUILayout.HelpBox("Objects:", MessageType.Info);
        GUI.backgroundColor = c;

        bool lastCento = EditorGUILayout.Toggle("Last 100", _lastCento);

        int count = 0;

        if (lastCento)
        {
            count = myScript._poolingDefinitions.Length - 100;
        }
        if (count < 0)
        {
            count = 0;
        }

        if (lastCento != _lastCento)
        {
            _lastCento = lastCento;
        }

        if (lastCento && count != myScript._poolingDefinitions.Length)
        {
            if (GUILayout.Button("..."))
            {
                _lastCento = false;
            }
        }

        for (int i = count; i < myScript._poolingDefinitions.Length; ++i)
        {
            PoolingDefinition def = myScript._poolingDefinitions[i];

            if (def._object == null)
            {
                RemoveAt <PoolingDefinition>(ref myScript._poolingDefinitions, i);

                return;
            }

            EditorGUILayout.Space();
            EditorGUILayout.BeginHorizontal();

            EditorGUILayout.LabelField(def._object.name, GUILayout.MaxWidth(150));
            EditorGUILayout.LabelField("amount:", GUILayout.MaxWidth(64));
            int amount = EditorGUILayout.IntField(def._amount, GUILayout.MaxWidth(30));
            if (amount != def._amount)
            {
                def._amount = amount;
                myScript._poolingDefinitions[i] = def;
            }

            GUI.backgroundColor = Color.red;
            if (GUILayout.Button("-", GUILayout.MaxWidth(30)))
            {
                RemoveAt <PoolingDefinition>(ref myScript._poolingDefinitions, i);
                return;
            }
            GUI.backgroundColor = c;

            if (GUILayout.Button(">", GUILayout.MaxWidth(30)))
            {
                Selection.activeGameObject = def._object;
            }

            GUI.backgroundColor = c;

            EditorGUILayout.EndHorizontal();
        }

        EditorGUILayout.Space();
        EditorGUILayout.Space();

        EditorGUILayout.LabelField("Total: " + myScript._poolingDefinitions.Length);

        EditorGUILayout.Space();
        EditorGUILayout.Space();

        //
        {
            Event evt       = Event.current;
            Rect  drop_area = GUILayoutUtility.GetRect(0.0f, 50.0f, GUILayout.ExpandWidth(true));
            GUI.Box(drop_area, "Drag & Drop a object");

            switch (evt.type)
            {
            case EventType.DragUpdated:
            case EventType.DragPerform:
                if (!drop_area.Contains(evt.mousePosition))
                {
                    return;
                }

                DragAndDrop.visualMode = DragAndDropVisualMode.Copy;

                if (evt.type == EventType.DragPerform)
                {
                    DragAndDrop.AcceptDrag();

                    foreach (UnityEngine.Object dragged_object in DragAndDrop.objectReferences)
                    {
                        // Do On Drag Stuff here
                        //Debug.Log("Drag " + dragged_object.ToString());

                        PoolingDefinition [] newBuffer = new PoolingDefinition[myScript._poolingDefinitions.Length + 1];
                        System.Array.Copy(myScript._poolingDefinitions, newBuffer, myScript._poolingDefinitions.Length);

                        if (dragged_object != null)
                        {
                            newBuffer[myScript._poolingDefinitions.Length]         = new PoolingDefinition();
                            newBuffer[myScript._poolingDefinitions.Length]._object = (GameObject)dragged_object;
                            newBuffer[myScript._poolingDefinitions.Length]._amount = 1;
                        }

                        myScript._poolingDefinitions = newBuffer;
                    }
                }
                break;
            }
        }

        EditorGUILayout.Space();
        EditorGUILayout.Space();

        // mostra lista chiavi dentro Util_PoolLoading
        GUI.backgroundColor = Color.cyan;
        EditorGUILayout.HelpBox("Settare la chiave. Poi volendo durante il gioco si possono scaricare/caricare il pool che corrisponde a questa chiave", MessageType.Info);
        GUI.backgroundColor = c;

        if (_keys == null)
        {
            EditorGUILayout.Space();
            GUI.backgroundColor = Color.red;
            EditorGUILayout.HelpBox("Selezionare l'oggetto che ha lo script Util_PoolLoading per riempire la lista chiavi!", MessageType.Warning);
            GUI.backgroundColor = c;

            __refresh();
        }
        else
        {
            if (_keys.Length == 0)
            {
                __refresh();
            }

            for (int i = 0; i < _keys.Length; ++i)
            {
                if (string.IsNullOrEmpty(_keys[i]))
                {
                    RemoveAt <string>(ref _keys, i);
                }
            }

            myScript._key = EditorGUILayout.Popup("Select Key:", myScript._key, _keys);
        }

        EditorGUILayout.Space();

        GUI.backgroundColor = Color.cyan;
        EditorGUILayout.HelpBox("Aggiungi oggetto al database!", MessageType.Info);
        GUI.backgroundColor = c;

        GUI.backgroundColor = Color.green;
        if (GUILayout.Button("Add Object"))
        {
            PoolingDefinition [] newBuffer = new PoolingDefinition[myScript._poolingDefinitions.Length + 1];
            System.Array.Copy(myScript._poolingDefinitions, newBuffer, myScript._poolingDefinitions.Length);
            myScript._poolingDefinitions = newBuffer;
            if (myScript._poolingDefinitions[myScript._poolingDefinitions.Length - 1] != null)
            {
                myScript._poolingDefinitions[myScript._poolingDefinitions.Length - 1]._amount = 1;
            }
        }
        GUI.backgroundColor = c;

        serializedObject.ApplyModifiedProperties();
    }