Add one more pool script or improve default with prespawned nobs feature

[SnaiperoG3D]

To be able to fill in editor array of nobs, what should be prespawned on server, client, and host, which count should be prespawned on all of them, maybe something else. There is my script for 2.x Fishnet v as example

`using FishNet;
using FishNet.Object;
using FishNet.Utility.Extension;
using FishNet.Utility.Performance;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;

namespace NetworkPoolTest
{
public class NetworkPool : ObjectPool
{
public static NetworkPool Instance;

    /// <summary>
    /// True if to use object pooling.
    /// </summary>
    [Tooltip("True if to use object pooling.")]
    [SerializeField]
    private bool _enabled = true;

    /// <summary>
    /// Pooled network objects.
    /// </summary>
    private Dictionary<int, Stack<NetworkObject>> _cached = new Dictionary<int, Stack<NetworkObject>>();

    [Serializable]
    public class PoolObjects
    {
        [Header("Settings")]

        [Tooltip("Initial size of the pool when started on client")]
        public int startClientSize = 10;
        [Tooltip("Initial size of the pool when started on host")]
        public int startHostSize = 1;
        [Tooltip("Initial size of the pool when started on server")]
        public int startServerSize = 50;
        [Tooltip("Maximum objects to retain in this pool")]
        public int maxSize = 50;
        [Tooltip("Prefab to use for this pool")]
        public NetworkObject prefab;

        [Header("Diagnostics")]
        public int currentCount;
    }

    public PoolObjects[] poolObjects;

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            //Init();
        }
        else
            Destroy(this);
    }

    public void Init()
    {
        if (poolObjects == null || poolObjects.Length == 0)
            return;
        Debuger.Log("Network Pool Init CAll");
        for (int i = 0; i < poolObjects.Length; i++)
        {
            int l = InstanceFinder.NetworkManager.IsHost ? poolObjects[i].startHostSize : (InstanceFinder.NetworkManager.IsServer ? poolObjects[i].startServerSize : poolObjects[i].startClientSize);
            Stack<NetworkObject> cache = new Stack<NetworkObject>();
            short prefabId = poolObjects[i].prefab.PrefabId;
            NetworkObject prefab = InstanceFinder.NetworkManager.SpawnablePrefabs.GetObject(InstanceFinder.NetworkManager.IsServer, prefabId);
            NetworkObject nob;

            for (int j = 0; j < l; j++)
            {
                nob = Instantiate(prefab);
                nob.gameObject.SetActive(false);
                //nob.transform.SetParent(transform);
                //nob.ResetForObjectPool();
                cache.Push(nob);
            }

            _cached[prefabId] = cache;
        }
    }

    /// <summary>
    /// Returns an object that has been stored. A new object will be created if no stored objects are available.
    /// </summary>
    /// <param name="prefabId">PrefabId of the object to return.</param>
    /// <param name="asServer">True if being called on the server side.</param>
    /// <returns></returns>
    public override NetworkObject RetrieveObject(int prefabId, bool asServer)
    {
        //Quick exit/normal retrieval when not using pooling.
        if (!_enabled)
        {
            NetworkObject prefab = base.NetworkManager.SpawnablePrefabs.GetObject(asServer, prefabId);
            return Instantiate(prefab);
        }

        Stack<NetworkObject> cache;
        //No cache for prefabId yet, make one.
        if (!_cached.TryGetValueIL2CPP(prefabId, out cache))
        {
            cache = new Stack<NetworkObject>();
            _cached[prefabId] = cache;
        }

        NetworkObject nob;
        //Iterate until nob is populated just in case cache entries have been destroyed.
        do
        {
            if (cache.Count == 0)
            {
                NetworkObject prefab = base.NetworkManager.SpawnablePrefabs.GetObject(asServer, prefabId);
                /* A null nob should never be returned from spawnables. This means something
                 * else broke, likely unrelated to the object pool. */
                nob = Instantiate(prefab);
                //Can break instantly since we know nob is not null.
                break;
            }
            else
            {
                nob = cache.Pop();
            }

        } while (nob == null);

        //nob.transform.SetParent(null);
        //Debuger.Log($"return nob from pool with name: {nob.name}");
        nob.gameObject.SetActive(true);
        return nob;
    }

    /// <summary>
    /// Stores an object into the pool.
    /// </summary>
    /// <param name="instantiated">Object to store.</param>
    /// <param name="prefabId">PrefabId of the object.</param>
    /// <param name="asServer">True if being called on the server side.</param>
    /// <returns></returns>
    public override void StoreObject(NetworkObject instantiated, int prefabId, bool asServer)
    {
        //Pooling is not enabled.
        if (!_enabled)
        {
            Destroy(instantiated.gameObject);
            return;
        }

        Stack<NetworkObject> cache;
        if (!_cached.TryGetValue(prefabId, out cache))
        {
            cache = new Stack<NetworkObject>();
            _cached[prefabId] = cache;
        }

        instantiated.gameObject.SetActive(false);
       // instantiated.transform.SetParent(transform);
        instantiated.ResetForObjectPool();
        cache.Push(instantiated);
    }

    public void ClearPool()
    {
        Debuger.Log("Clear pool");
        //Stack<NetworkObject> cache;
        //foreach (KeyValuePair<int, Stack<NetworkObject>> item in _cached)
        //{
        //    //No cache for prefabId yet, make one.
        //    if (!_cached.TryGetValueIL2CPP(item.Key, out cache))
        //    {
        //        cache = new Stack<NetworkObject>();
        //    }
        //    do
        //    {
        //        Destroy(cache.Pop());
        //    } 
        //    while (cache.Count > 0);
        //}

        int l = transform.childCount;
        for (int i = 0; i < l; i++)
        {
            Destroy(transform.GetChild(i).gameObject);
        }

        _cached.Clear();
    }

    public void ShowPoolInfo(bool full = false)
    {
        if (poolObjects == null || poolObjects.Length == 0 || _cached.Count == 0)
        {
            Console.WriteLine("No pool objects in Network Pool");
            return;
        }

        NetworkObject prefab;
        Console.WriteLine(full ? "Total objects in pool:" : "Prespawned objects in pool:");

        if (full)
        {
            foreach (var item in _cached)
            {
                prefab = base.NetworkManager.SpawnablePrefabs.GetObject(true, item.Key);
                Console.WriteLine($"{prefab.name} : {item.Value.Count}");
            }
        }
        else
        {
            Stack<NetworkObject> cache;
            for (int i = 0; i < poolObjects.Length; i++)
            {
                prefab = poolObjects[i].prefab;
                if (!_cached.TryGetValueIL2CPP(poolObjects[i].prefab.PrefabId, out cache))
                    return;

                Console.WriteLine($"{prefab.name} : {cache.Count}");
            }
        }

        Console.WriteLine("End of Pool");
    }
}

}
`

[FirstGearGames]

I intended to add preloading pooled objects for awhile now. I will absolutely try to get this in asap, shouldn't be an issue given how ismple it is. You're welcome to harass me via DM to speed it up as well :)

[FirstGearGames]

• Added DefaultObjectPool.CacheObjects to preload pooled objects.
• Added DefaultObjectPool.ClearPool to destroy pooled objects.
• Improved exposed DefaultObjectPool.Cache.
  3.3.0