Example #1
0
    public T Get <T>(GameObject prefab) where T : PoolableEntity
    {
        PoolableEntity entity = null;

        PoolingData.Pool pool = this.poolingData.pools.Find(x => x.prefab is T && x.prefab.name == prefab.name);

        if (pool.prefab != null)
        {
            foreach (PoolableEntity e in pool.objects)
            {
                if (!e.isActive)
                {
                    entity = e;
                    break;
                }
            }
        }

        if (entity != null)
        {
            entity.isActive         = true;
            entity.transform.parent = pool.activeFolder;
        }

        return(entity as T);
    }
Example #2
0
        public Pool(Pool p, PoolableEntity[] a, Transform af, Transform iaf)
        {
            this.prefab = p.prefab;
            this.size   = p.size;

            this.objects        = a;
            this.activeFolder   = af;
            this.inactiveFolder = iaf;
        }
Example #3
0
        public Pool(PoolableEntity p, int s)
        {
            this.prefab = p;
            this.size   = s;

            this.objects        = null;
            this.activeFolder   = null;
            this.inactiveFolder = null;
        }
Example #4
0
    public void Stow(PoolableEntity entity)
    {
        Transform folder;
        Type      t = entity.GetType();

        folder = this.poolingData.pools.Find(x => x.prefab.GetType() == t && Array.IndexOf(x.objects, entity) > -1).inactiveFolder;

        entity.Reset();
        entity.transform.parent = folder;
    }
Example #5
0
        public Pool(Pool p, PoolableEntity[] a, Transform af, Transform iaf)
        {
            this.prefab = p.prefab;
            this.size   = p.size;
            this.entity = this.prefab.GetComponent <PoolableEntity>();

            this.entities       = a;
            this.activeFolder   = af;
            this.inactiveFolder = iaf;

            this.show = false;
        }
Example #6
0
        public Pool(GameObject p, int s)
        {
            this.prefab = p;
            this.size   = s;
            this.entity = p?.GetComponent <PoolableEntity>();

            this.entities       = null;
            this.activeFolder   = null;
            this.inactiveFolder = null;

            this.show = false;
        }
Example #7
0
    public void CreatePool(Transform f)
    {
        Pool           pp;
        GameObject     g;
        Transform      folder, objectFolder;
        Transform      activeFolder, inactiveFolder;
        PoolableEntity p;

        PoolableEntity[] objs;

        // scriptable object objectFolder
        g             = new GameObject();
        g.name        = this.name;
        folder        = g.transform;
        folder.parent = f;

        for (int k = 0; k < this.pools.Count; ++k)
        {
            pp   = this.pools[k];
            objs = new PoolableEntity[pp.size];

            // object folders
            g                   = new GameObject();
            g.name              = pp.prefab.name;
            objectFolder        = g.transform;
            objectFolder.parent = folder;

            g                   = new GameObject();
            g.name              = pp.prefab.name + " (Active)";
            activeFolder        = g.transform;
            activeFolder.parent = objectFolder;

            g                     = new GameObject();
            g.name                = pp.prefab.name + " (Inactive)";
            inactiveFolder        = g.transform;
            inactiveFolder.parent = objectFolder;

            for (int i = 0; i < pp.size; ++i)
            {
                g = Instantiate(pp.prefab);
                p = g.GetComponent <PoolableEntity>();

                // initialize
                p.transform.parent = inactiveFolder;
                p.Reset();

                objs[i] = p;
            }

            this.pools[k] = new Pool(pp, objs, activeFolder, inactiveFolder);
        }
    }
Example #8
0
    public void CreatePool(Transform f)
    {
        Pool           pp;
        GameObject     g;
        Transform      folder;
        Transform      activeFolder;
        Transform      inactiveFolder;
        PoolableEntity p;

        PoolableEntity[] objs;

        for (int k = 0; k < this.pools.Count; k++)
        {
            pp   = this.pools[k];
            objs = new PoolableEntity[pp.size];

            // folder
            g             = new GameObject();
            g.name        = pp.prefab.gameObject.name;
            folder        = g.transform;
            folder.parent = f;

            g                   = new GameObject();
            g.name              = pp.prefab.gameObject.name + " (Active)";
            activeFolder        = g.transform;
            activeFolder.parent = folder;

            g                     = new GameObject();
            g.name                = pp.prefab.gameObject.name + " (Inactive)";
            inactiveFolder        = g.transform;
            inactiveFolder.parent = folder;

            for (int i = 0; i < pp.size; i++)
            {
                p = Instantiate(pp.prefab);

                // initialize
                p.transform.parent = inactiveFolder;
                p.Reset();

                objs[i] = p;
            }

            this.pools[k] = new Pool(pp, objs, activeFolder, inactiveFolder);
        }
    }
Example #9
0
    public GameObject Create()
    {
        if (pool.Count == 0)
        {
            GameObject     new_go = (GameObject)Instantiate(template);
            PoolableEntity pe     = new_go.GetComponent <PoolableEntity>();
            if (!pe)
            {
                new_go.AddComponent <PoolableEntity>();
            }
            pe.pool = this;

            return(new_go);
        }

        GameObject go = pool.Dequeue();

        go.SetActive(true);
        return(go);
    }
Example #10
0
    public void Stow(PoolableEntity entity)
    {
        PoolingData.Pool pool;
        Transform        folder;
        Type             t;
        int index;

        t     = entity.GetType();
        index = 0;

        do
        {
            pool = this.poolingDatas[index++].pools.Find(x => x.entity.GetType() == t && Array.IndexOf(x.entities, entity) > -1);
        }while(!pool.prefab && index < this.poolingDatas.Length);

        folder = pool.inactiveFolder;

        entity.Reset();
        entity.transform.parent = folder;
    }
Example #11
0
 public void Init()
 {
     _pool           = new ObjectPool <PoolableEntity>(initialSize, () => Substitute.For <PoolableEntity>());
     _poolableEntity = Substitute.For <PoolableEntity>();
 }