public GameObject SpawnFromPool(string tag, Vector3 position, Quaternion rotation) { if (!poolDictionary.ContainsKey(tag)) { Debug.LogWarning("Pool with tag " + tag + " doesn't exist!"); return(null); } IPoolableObject poolableObject = poolDictionary [tag].Peek().GetComponent <IPoolableObject>(); if (poolableObject.GetAlive()) { return(null); } GameObject objectToSpawn = poolDictionary [tag].Dequeue(); objectToSpawn.SetActive(true); objectToSpawn.transform.position = position; objectToSpawn.transform.rotation = rotation; //IPoolableObject poolableObject = objectToSpawn.GetComponent<IPoolableObject> (); if (poolableObject != null) { poolableObject.OnObjectSpawn(); } poolDictionary [tag].Enqueue(objectToSpawn); return(objectToSpawn); }
public void release(GameObject releasedObject, PoolableTypes objectType) { if (activeGameObjects.Contains(releasedObject)) { List <GameObject> instanciatedGameObjectsList; if (disabledGameObjects.TryGetValue(objectType, out instanciatedGameObjectsList)) { instanciatedGameObjectsList.Add(releasedObject); } IPoolableObject ipo = releasedObject.GetComponent <IPoolableObject>(); if (ipo == null) { ipo = releasedObject.GetComponentInChildren <IPoolableObject>(); } ipo.OnRelease(); activeGameObjects.Remove(releasedObject); if (objectType == PoolableTypes.Enemy) { enemyList.Remove(releasedObject); } else if (objectType == PoolableTypes.PlayerBot) { playerBotList.Remove(releasedObject); } releasedObject.SetActive(false); } }
public virtual bool TryReturnObject(T o) { bool result; lock (this.lockObj) { if (this.freeStack.Count == 0) { this.freeStack.Push(o); } else { if (!o.Preallocated) { return(false); } IPoolableObject poolableObject = this.freeStack.Peek(); if (!poolableObject.Preallocated) { T t = this.freeStack.Pop(); IDisposable disposable = t as IDisposable; if (disposable != null) { disposable.Dispose(); } } this.freeStack.Push(o); } result = true; } return(result); }
public object PopObject(object inPrefab) { Debug.Assert((inPrefab is IPoolableObject) == true, "Error: " + inPrefab + " does not implement IPoolableObject"); object rtnVal = null; System.Type type = inPrefab.GetType(); List <IPoolableObject> poolableObjects; if (pools.TryGetValue(type, out poolableObjects)) { if (poolableObjects.Count == 0) { IPoolableObject poolableObj = (IPoolableObject)inPrefab; rtnVal = poolableObj.CreateInstance(); } else { IPoolableObject poolableObj = poolableObjects[poolableObjects.Count - 1]; poolableObjects.Remove(poolableObj); poolableObj.Activate(); rtnVal = poolableObj.GetValue(); } } else { IPoolableObject poolableObj = (IPoolableObject)inPrefab; rtnVal = poolableObj.CreateInstance().GetValue(); } return(rtnVal); }
protected virtual void StartPooling() { foreach (var item in StringGameObjectDictionary) { if (!_objectPool.ContainsKey(item.Key)) { List <GameObject> newList = new List <GameObject>(); int objectsToCreate; GameObject testInstatiated = Instantiate(StringGameObjectDictionary[item.Key], transform.position, transform.rotation); IPoolableObject testPoolable = testInstatiated.GetComponent <IPoolableObject>(); if (testPoolable != null) { objectsToCreate = testPoolable.instances; } else { objectsToCreate = baseNumberOfItems; } DestroyImmediate(testInstatiated.gameObject); for (int i = 0; i < objectsToCreate; i++) { GameObject instatiated = Instantiate(StringGameObjectDictionary[item.Key], transform.position, transform.rotation); instatiated.transform.SetParent(this.transform); IPoolableObject poolable = instatiated.GetComponent <IPoolableObject>(); if (poolable != null) { poolable.PoolReset(); } instatiated.SetActive(false); newList.Add(instatiated); } _objectPool[item.Key] = newList; } } }
public void Push(IPoolableObject po) { if (!po.m_isUsing) { return; } po.m_isUsing = false; m_poolQueue.Enqueue(po); }
void Start() { pooledInstance = 0; poolDictionary = new Dictionary <string, Queue <GameObject> >(); poolContainers = new Dictionary <string, Transform>(); foreach (Pool pool in pools) { if (pool.prefab != null) { if (pool.size <= 0) { Debug.LogError("Invalid pool capacity for " + pool.prefab.name); continue; } Queue <GameObject> objectPool = new Queue <GameObject>(pool.size + 1); // container GameObject container = new GameObject(); container.name = pool.prefab.name + " container"; container.transform.parent = transform; container.transform.position = Vector3.zero; container.transform.rotation = Quaternion.identity; container.transform.localScale = Vector3.one; pool.hasPoolInterface = pool.prefab.GetComponent <IPoolableObject>() != null; sortedPools.Add(pool.prefab.name, pool); // pool for (int i = 0; i < pool.size; i++) { GameObject obj = Instantiate(pool.prefab); obj.name = pool.prefab.name; obj.transform.parent = container.transform; obj.transform.position = Vector3.zero; obj.transform.rotation = Quaternion.identity; obj.transform.localScale = Vector3.one; obj.SetActive(false); if (pool.hasPoolInterface) { IPoolableObject poolInterface = obj.GetComponent <IPoolableObject>(); poolInterface.OnInit(); } objectPool.Enqueue(obj); } pooledInstance += pool.size; poolDictionary.Add(pool.prefab.name, objectPool); poolContainers.Add(pool.prefab.name, container.transform); } } }
public void SetObjectInStorage(IPoolableObject currentObject) { var go = currentObject as IPoolableObject; var type = go.GetObjectType(); if (!_objectStorage.ContainsKey(type)) { _objectStorage.Add(type, new List <IPoolableObject>()); } _objectStorage[type].Add(currentObject); go.DisablePoolObject(_storageTransform); }
public IPoolableObject Pop() { if (m_poolQueue.Count == 0) { Push(Create(m_original)); } IPoolableObject popObject = m_poolQueue.Dequeue(); popObject.m_isUsing = true; return(popObject); }
//NOTE:要素数が増えるとパフォーマンスに影響が出るかもしれないので、できる限り初期化ロード時点で済ませておくべきか //一回で除外する数を小さくするか public void LogoutFromPool(IPoolableObject RemoveObj, string PoolName = "") { string poolName = string.IsNullOrEmpty(PoolName) ? DefaultPoolName : PoolName; if (poolDict.ContainsKey(poolName)) { if (poolDict[poolName].Contains(RemoveObj)) { poolDict[poolName].Remove(RemoveObj); } Debug.Log($"{poolName}の残り要素数 == " + poolDict[poolName].Count); } }
//NOTE:要素数が増えるとパフォーマンスに影響が出るかもしれないので、できる限り初期化の時点で済ませておくべきか //一回でログインする数を小さくするか public void LoginToPool(IPoolableObject AddObj, string PoolName = "") { string poolName = string.IsNullOrEmpty(PoolName) ? DefaultPoolName : PoolName; if (poolDict.ContainsKey(poolName)) { if (!poolDict[poolName].Contains(AddObj)) { poolDict[poolName].Add(AddObj); } Debug.Log($"{poolName}更新後の要素数 == " + poolDict[poolName].Count); } }
public void DisposeObject(T obj) { if (obj != null) { IPoolableObject poolableObj = obj as IPoolableObject; if (poolableObj != null) { poolableObj.Reset(); } if (_objects.Count < _capactiy) { _objects.Enqueue(obj); } } }
public void CreateAtPosition(Vector3 position, Quaternion rotation) { IPoolableObject available = GetNextAvailableObject(); if (available != null) { available.ResetPoolObject(position); //Debug.Log("Create From Pool"); } else { pool.Add(GameObject.Instantiate(prefab, position, rotation)); //Debug.Log("Create New"); } }
/// <summary> /// Returns an object from the pool initialized to the given position and rotation /// </summary> /// <returns>The object.</returns> /// <param name="position">Position.</param> /// <param name="rotation">Rotation.</param> public IPoolableObject GetObject(Vector3 position, Quaternion rotation) { if (IsEmpty()) { Debug.LogError("Cannot remove object from empty pool"); return(null); } IPoolableObject obj = pool[0]; pool.RemoveAt(0); obj.Init(position, rotation); return(obj); }
public IPoolableObject ProvideObject(Type objectType) { IPoolableObject currentobject = null; if (_storage.CheckObjectInStorage(objectType)) { currentobject = _storage.GetObjectInStorage(objectType); } else { currentobject = _creator.CreatePoolObject(objectType); } return(currentobject); }
/// <summary> /// Adds the object. /// </summary> /// <param name="obj">Object.</param> public void AddObject(IPoolableObject obj) { if (obj == null) { Debug.LogError("Cannot add null gameobject to pool"); } if (pool == null) { pool = new List <IPoolableObject>(); } obj.Release(); pool.Add(obj); }
public virtual void RecycleObject(GameObject incommingGameObject) { IPoolableObject baseShoot = incommingGameObject.GetComponent <IPoolableObject>(); if (baseShoot != null) { string objectType = baseShoot.PoolReset(); List <GameObject> objects = _objectPool[objectType]; if (!objects.Contains(incommingGameObject)) { incommingGameObject.SetActive(false); objects.Add(incommingGameObject); } } }
public void Destroy(GameObject go) { if (go == null) { return; } IPoolableObject poolable = go.GetComponent <IPoolableObject>(); if (poolable != null) { PoolManager.Instance.Push(poolable); return; } Object.Destroy(go); }
public static void Return(IPoolableObject itemToReturn) { if (poolContainer == null) { poolContainer = new GameObject("Pool container").transform; poolContainer.gameObject.SetActive(false); } if (!pools.ContainsKey(itemToReturn.Prefab)) { pools.Add(itemToReturn.Prefab, new Queue <IPoolableObject>()); } itemToReturn.gameObject.transform.SetParent(poolContainer); itemToReturn.gameObject.SetActive(false); pools[itemToReturn.Prefab].Enqueue(itemToReturn); }
public virtual GameObject getObjectOfType(string objectType, SpawnPosition spawnerTransform) { if (StringGameObjectDictionary.ContainsKey(objectType)) { List <GameObject> objects = _objectPool[objectType]; if (objects.Count > 0) { GameObject g = objects[0]; g.SetActive(true); IPoolableObject baseShoot = g.GetComponent <IPoolableObject>(); if (baseShoot != null) { baseShoot.PoolAdquire(spawnerTransform, objectType, this); } if (objects.Contains(g)) { objects.Remove(g); } return(g); } else { GameObject instatiated = Instantiate(StringGameObjectDictionary[objectType], transform.position, transform.rotation); Debug.Log(string.Format("--- New Instance Created of Type {0} consider to increase the number of base instances", instatiated.name)); instatiated.transform.SetParent(this.transform); IPoolableObject baseShoot = instatiated.GetComponent <IPoolableObject>(); if (gameObject.name == "EnemyPool") { Debug.Log("EnemyPool"); } if (baseShoot != null) { baseShoot.PoolAdquire(spawnerTransform, objectType, this); } return(instatiated); } } else { return(null); } }
public void PushObject(object objectToPool) { IPoolableObject poolableObject = (IPoolableObject)objectToPool; poolableObject.Deactivate(); System.Type type = objectToPool.GetType(); List <IPoolableObject> poolableObjects; if (pools.TryGetValue(type, out poolableObjects)) { poolableObjects.Add(poolableObject); } else { poolableObjects = new List <IPoolableObject>(); poolableObjects.Add(poolableObject); pools.Add(type, poolableObjects); } }
public T Spawn() { if (_currentIndex < Count) { T obj = _pool.Peek(); _currentIndex++; IPoolableObject po = obj as IPoolableObject; po.Respawn(); return(obj); } else { T obj = new T(); _pool.Push(obj); _currentIndex++; IPoolableObject po = obj as IPoolableObject; po.New(); return(obj); } }
public static IPoolableObject Get(IPoolableObject prefab) { IPoolableObject item; if (!pools.ContainsKey(prefab)) { pools.Add(prefab, new Queue <IPoolableObject>()); } if (pools[prefab].Count > 0) { item = pools[prefab].Dequeue(); item.gameObject.transform.parent = null; } else { item = GameObject.Instantiate(prefab.gameObject).GetComponent <IPoolableObject>(); item.Prefab = prefab; } return(item); }
public GameObject SpawnPoolObject(string tag, Vector3 position, Quaternion rotation) { if (!poolDictionary.ContainsKey(tag)) { return(null); } GameObject objectToSpawn = poolDictionary[tag].Dequeue(); objectToSpawn.SetActive(true); objectToSpawn.transform.position = position; objectToSpawn.transform.rotation = rotation; IPoolableObject pooledObj = objectToSpawn.GetComponent <IPoolableObject>(); if (pooledObj != null) { pooledObj.OnObjectSpawn(); } poolDictionary[tag].Enqueue(objectToSpawn); return(objectToSpawn); }
public static IPoolableObject getRandomObjectFromPool(IPoolableObject[] objects) { int i; int sumOfWeights = 0; int index = -1; for (i = 0; i < objects.Length; ++i) { sumOfWeights += objects[i].getPoolWeight(); } //bug with Random.Range() needs +1 to randomly choose last element in the range int randomNumber = Random.Range(0, sumOfWeights + 1); sumOfWeights = 0; for (i = 0; i < objects.Length; ++i) { sumOfWeights += objects[i].getPoolWeight(); if (randomNumber <= sumOfWeights) { index = i; break; } } return objects[index]; }
public void ReturnObject(IPoolableObject currentObject) { _storage.SetObjectInStorage(currentObject); }
public void ReturnPlayer(IPoolableObject poolable) { _playerPool.ReturnObjectToPool(poolable); }
public void Push(IPoolableObject po) { }
public GameObject get(PoolableTypes objectType, Transform locationData = null, Guid parentGuid = new Guid()) { List <GameObject> instanciatedGameObjectsList; if (disabledGameObjects.TryGetValue(objectType, out instanciatedGameObjectsList)) { int lastIndex = instanciatedGameObjectsList.Count - 1; GameObject go = instanciatedGameObjectsList[lastIndex]; instanciatedGameObjectsList.RemoveAt(lastIndex); activeGameObjects.Add(go); IPoolableObject ipo = go.GetComponent <IPoolableObject>(); if (ipo == null) { ipo = go.GetComponentInChildren <IPoolableObject>(); } if (locationData != null) { go.transform.position = locationData.position; go.transform.rotation = locationData.rotation; go.transform.forward = locationData.forward; } ipo.OnPoolCreation(); if (parentGuid != Guid.Empty) { Guid objectId = Guid.Empty; Guid getId; Bot botScript = go.GetComponent <Bot>(); if (botScript != null) { objectId = botScript.Id; } else { SavableObject savableObjectScript = go.GetComponent <SavableObject>(); if (savableObjectScript != null) { objectId = savableObjectScript.Id; } } if (objectId != Guid.Empty && !GameObjectStateManager.Instance.ParentIds.TryGetValue(objectId, out getId)) { GameObjectStateManager.Instance.ParentIds.Add(objectId, parentGuid); } } go.SetActive(true); if (objectType == PoolableTypes.Enemy) { enemyList.Add(go); } else if (objectType == PoolableTypes.PlayerBot) { playerBotList.Add(go); } return(go); } return(null); }
public void ReturnObjectToPool(IPoolableObject poolableObject) { _objectPool.Enqueue(poolableObject); }
public void ReturnParticles(IPoolableObject poolable) { _particlePool.ReturnObjectToPool(poolable); }