protected override void Awake()
{
base.Awake();
// references
poolObject = (PoolObject)GetComponent(typeof(PoolObject));
}
// инициализация пула
public void Initialize(int count, PoolObject sample, Transform objects_parent)
{
objects = new List<PoolObject>(); // инициализация листа
objectsParent = objects_parent; // забираем папаньку
for (int i = 0; i < count; i++)
{
AddObject(sample, objects_parent);
}
}
public ObjectInstance(GameObject objectInstance) {
gameObject = objectInstance;
transform = gameObject.transform;
gameObject.SetActive(false);
if (gameObject.GetComponent<PoolObject>()) {
hasPoolObjectComponent = true;
poolObjectScript = gameObject.GetComponent<PoolObject>();
}
}
// добавление нового объекта в пул
void AddObject(PoolObject sample, Transform objects_parent)
{
GameObject temp = GameObject.Instantiate(sample.gameObject);
temp.name = sample.name;
temp.transform.SetParent(objects_parent);
objects.Add(temp.GetComponent<PoolObject>());
if (temp.GetComponent<Animator>())
{
temp.GetComponent<Animator>().StartPlayback();
}
temp.SetActive(false);
}
void AddPoolObject(PoolObject po, int count)
{
if (po == null)
Debug.Log("po null");
else if (po.poolPrefab == null)
Debug.Log("po.poolPrefab null, " + po.name);
Transform t = ((GameObject)Instantiate(po.poolPrefab)).transform;
t.SetParent(inactiveListTransform);
t.name = po.name + count;
po.inactiveList.Add(t);
DeactivateObject(t);
}
public override void OnInspectorGUI()
{
if(m_reference == null)
{
m_reference = (PoolObject)target;
}
EditorGUILayout.LabelField("Pool name: ", m_reference.PoolName);
EditorGUILayout.ObjectField("Game object: ", m_reference.PoolableObject, typeof(GameObject), false);
EditorGUILayout.IntField("Initial count: ", m_reference.InitialCount);
EditorGUILayout.Toggle("Incremental: ", m_reference.IncrementalPool);
}
// Use this for initialization
void Start()
{
curHP = HP;
myTag = tag;
Player = GameObject.FindGameObjectWithTag("Player");
myPoolObject = GetComponent<PoolObject>();
myTransform = transform;
StartCoroutine(EnemyCoroutine());
PlayerTag = "Player";
if (tag.Equals("Enemy_Unbreakable") == false)
{
Health = myTransform.Find("Canvas").Find("Health").GetComponent<Image>();
Health.fillAmount = (curHP * 1.0f) / HP;
}
}
// initial configuration
void Configure()
{
targetAspect = targetAspectRatio.x / targetAspectRatio.y;
poolObjects = new PoolObject[poolSize];
for (int i = 0; i < poolObjects.Length; i++)
{
GameObject go = Instantiate(Prefab) as GameObject; // instantiate a prefab
Transform t = go.transform; // get transform of newly instantiated prefab
t.SetParent(transform); // set new inst. prefab's parent to its spawner obj
t.position = Vector3.one * 1000; // move (way) off screen to start
poolObjects[i] = new PoolObject(t); // new poolobject with this object's transform
}
if (spawnImmediate)
{
SpawnImmediate();
}
}
void Configure()
{
targetAspect = targetAspectRatio.x / targetAspectRatio.y;
poolObjects = new PoolObject[poolSize];
for (int i = 0; i < poolObjects.Length; i++)
{
GameObject go = Instantiate(Prefab) as GameObject;
Transform t = go.transform;
t.SetParent(transform);
t.position = Vector3.one * 1000;
poolObjects[i] = new PoolObject(t);
}
if (spawnImmediate)
{
SpawnImmediate();
}
}
/// <summary>
/// Constructor, se encargar de guardar las referencias que vamos a necesitar para crear el objecto que queremos poolear,
/// vamos a pedir un stock inicial,Como vamos a crear cada objeto y sus funciones de como inicializarlos y finalizarlos,ademas de preguntar si lo queremos dinamico al pool
/// </summary>
/// <param name="initialStock"></param>
/// <param name="factoryMethod"></param>
/// <param name="initialize"></param>
/// <param name="finalize"></param>
/// <param name="isDinamic"></param>
public Pool(int initialStock, CallbackFactory factoryMethod, PoolObject <T> .PoolCallback initialize, PoolObject <T> .PoolCallback finalize, bool isDinamic)
{
//Creamos una lista de objetos Pooleables
_poolList = new List <PoolObject <T> >();
//Guardamos las referencias para cuando los necesitemos.
_factoryMethod = factoryMethod;
_isDinamic = isDinamic;
_count = initialStock;
_init = initialize;
_finalize = finalize;
//Generamos el stock inicial.
for (int i = 0; i < _count; i++)
{
_poolList.Add(new PoolObject <T>(_factoryMethod(), _init, _finalize));
}
}
/// <summary>
/// Despawn the specified GameObject, returning it to its pool.
/// If the GameObject has no pool, it is destroyed instead.
/// </summary>
public static void Despawn(GameObject go)
{
if (go == null)
{
return;
}
PoolObject po = go.GetComponent <PoolObject>();
if (po == null || !PoolExists(po.PrefabName))
{
Destroy(go);
}
else
{
Pools[po.PrefabName].Despawn(go);
}
}
public void CreatePool(GameObject obj, int size)
{
int poolkey = obj.GetInstanceID();
if (!pool.ContainsKey(poolkey))
{
pool.Add(poolkey, new Queue <PoolObject>());
GameObject o = new GameObject(obj.name);
o.transform.parent = transform;
for (int i = 0; i < size; i++)
{
PoolObject newBoulder = new PoolObject(Instantiate(obj) as GameObject);
pool[poolkey].Enqueue(newBoulder);
newBoulder.setParent(o.transform);;
}
}
}
public static PoolObject Spawn <T>(Transform parent = null) where T : PoolObject
{
//spawn object and pull it out of dictionary stack
Type type = typeof(T);
if (poolObjects[type].Count > 0)
{
PoolObject obj = poolObjects[type].Pop(); //Pop it out of the stack
obj.OnSpawn(); //PoolObject version of Start()
obj.transform.SetParent(parent);
obj.gameObject.SetActive(true); //Activate it
return(obj);
}
else
{
return(null);
}
}
public void ObjectPoolTest_AllocateAndRecycle_ObjectNull()
{
//option
PoolObject po = SafeObjectPool <PoolObject> .Instance.Allocate();
//Assert
Assert.IsNotNull(po);
Assert.AreEqual(10, po.id);
//option
bool isRecycle = SafeObjectPool <PoolObject> .Instance.Recycle(po);
//Assert
Assert.IsTrue(isRecycle);
Assert.AreEqual(0, po.id);
SafeObjectPool <PoolObject> .Instance.Dispose();
}
public T Get()
{
for (int i = 0; i < _pool.Count; i++)
{
if (!_pool[i].IsActive)
{
_enableMethod(_pool[i].Content);
_pool[i].IsActive = true;
return(_pool[i].Content);
}
}
PoolObject <T> newObj = new PoolObject <T>(_factoryMethod);
_enableMethod(newObj.Content);
newObj.IsActive = true;
_pool.Add(newObj);
return(newObj.Content);
}
public void AddObject(PoolObject sample, Transform objectsParent)
{
GameObject temp;
if (sample.gameObject.scene.name == null)
{
temp = GameObject.Instantiate(sample.gameObject);
temp.name = sample.name;
temp.transform.SetParent(objectsParent);
}
else
{
temp = sample.gameObject;
}
objects.Add(temp.GetComponent <PoolObject>());
temp.SetActive(false);
}
public bool TryInstantiate(Vector3 position, Quaternion rotation, Transform camRef)
{
PoolObject objectToReuse = poolQueue.Peek();
if (!objectToReuse.gameObject.activeSelf)
{
poolQueue.Dequeue();
poolQueue.Enqueue(objectToReuse);
objectToReuse.transform.position = position;
objectToReuse.transform.rotation = rotation;
objectToReuse.OnObjectReuse();
objectToReuse.SetCam(camRef); // this clearly belongs here lolol
return(true);
}
return(false);
}
private void Shot()
{
if (!IsShotReady())
{
return;
}
Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
Vector2 direction = mousePos - transform.position;
float angle = Mathf.Atan2(direction.x, direction.y) * Mathf.Rad2Deg;
PoolObject bullet = PoolManager.Get(1);
bullet.transform.position = transform.position;
bullet.transform.rotation = Quaternion.Euler(0, 0, -angle);
Bullet comp = bullet.GetComponent <Bullet>();
comp.Init(_stats.shotSpeed, _stats.bulletDestroyDelay);
_lastShotTime = Time.time;
}
public void addToPool(PoolObject poolObject)
{
GameObject parent = new GameObject("Parentof" + objectsInPool.Count);
objectsInPool.Add(poolObject);
List <GameObject> tempPool = new List <GameObject>();
for (int i = 0; i < poolObject.numberToPool; i++)
{
GameObject go = MonoBehaviour.Instantiate(poolObject.objectPrefab);
go.transform.parent = parent.transform;
poolItems pi = (poolItems)pool.Count;
go.transform.name = pi.ToString();
go.SetActive(false);
tempPool.Add(go);
}
pool.Add(tempPool);
}
/// <summary>
/// 将一个对象放入对象池
/// </summary>
/// <param name="go"></param>
/// <param name="isSetInactive">是否将放入的物体设为不激活状态（obj.SetActive(false)）</param>
public static void DestroyGameObjectByPool(GameObject go, bool isSetInactive = true)
{
string key = go.name.Replace("(Clone)", "");
if (s_objectPool.ContainsKey(key) == false)
{
s_objectPool.Add(key, new List <GameObject>());
}
if (s_objectPool[key].Contains(go))
{
throw new Exception("DestroyGameObjectByPool:-> Repeat Destroy GameObject !" + go);
}
s_objectPool[key].Add(go);
if (isSetInactive)
{
go.SetActive(false);
}
else
{
go.transform.position = s_OutOfRange;
}
go.name = key;
go.transform.SetParent(PoolParent);
PoolObject po = go.GetComponent <PoolObject>();
if (po)
{
po.OnRecycle();
}
if (createPools.ContainsKey(key) && createPools[key].Contains(go))
{
createPools[key].Remove(go);
//Debug.LogWarning(go.name + " ==>>" + createPools[key].Count);
if (createPools[key].Count == 0)
{
createPools.Remove(key);
AssetsPoolManager.DestroyByPool(key);
}
}
}
public void OnEnemySurvival()
{
_estadoEnemigo = EstadoEnemigo.vivo;
poolObjectEnemy = GetComponent <PoolObject>();
float opcion = Random.Range(MinRangeRandom, TypeRandom);
if (gm == null)
{
gm = GameManager.instanceGameManager;
}
Debug.Log("Enemigos Abatidos:" + gm.countEnemysDead);
if ((gm.countEnemysDead % gm.RondasPorJefe) != 0 || gm.countEnemysDead == 0)
{
switch ((int)opcion)
{
case 0:
//Debug.Log("ENTRE BALANCEADO");
//Cambiar el sprite del enemigo Balanceado.
typeEnemy = TiposDeEnemigo.Balanceado;
break;
case 1:
//Debug.Log("ENTRE AGRESIVO");
//Cambiar el sprite del enemigo Agresivo.
typeEnemy = TiposDeEnemigo.Agresivo;
break;
case 2:
//Debug.Log("ENTRE DEFENSIVO");
//Cambiar el sprite del enemigo Defensivo.
typeEnemy = TiposDeEnemigo.Defensivo;
break;
}
}
else if ((gm.countEnemysDead % gm.RondasPorJefe) == 0 && gm.countEnemysDead > 1)
{
//Cambiar el sprite del jefe correspondiente
Debug.Log("Soy tremendo jefe");
typeEnemy = TiposDeEnemigo.Jefe;
typeBoss = TiposDeJefe.ProfeAnatomia;
}
CheckInitialSprite();
SetPorcentageMovements();
}
private IEnumerator CoSpawnEnemys()
{
yield return(new WaitForSeconds(startWait));
float generateInterval = interval.max;
while (!_gameover)
{
Vector3 spawnPosition = new Vector3(spawnX, Random.Range(spawnY.min, spawnY.max), 0f);
Pool enemyPool = enemyPools[Random.Range(0, enemyPools.Length)];
PoolObject poolObj = enemyPool.Pop();
poolObj.transform.position = spawnPosition;
poolObj.transform.rotation = Quaternion.identity;
yield return(new WaitForSeconds(generateInterval));
generateInterval = Mathf.Clamp(generateInterval - intervalAccel, interval.min, interval.max);
}
}
public PoolObject UsePoolObject(PoolObject poolobject, Vector3 transform, Quaternion rotation)
{
int poolid = poolobject.GetInstanceID();
if (!poolDictionary.ContainsKey(poolid))
{
CreatePool(poolobject);
}
if (poolDictionary[poolid].Count == 0)
{
poolDictionary[poolid].Enqueue(CreatePoolObject(poolobject, poolid));
}
PoolObject pooledObject = poolDictionary[poolid].Dequeue();
pooledObject.transform.position = transform;
pooledObject.transform.rotation = rotation;
pooledObject.gameObject.SetActive(true);
return(pooledObject);
}
/// <summary>
/// 清空对象池
/// </summary>
public static void CleanPool(bool isClearAssetsAndBundle)
{
Debug.LogWarning("清空对象池");
foreach (string name in s_objectPool.Keys)
{
if (s_objectPool.ContainsKey(name))
{
List <GameObject> l_objList = s_objectPool[name];
for (int i = 0; i < l_objList.Count; i++)
{
GameObject go = l_objList[i];
PoolObject po = go.GetComponent <PoolObject>();
if (po)
{
po.OnObjectDestroy();
}
if (isClearAssetsAndBundle)
{
GameObject.DestroyImmediate(go, true);
}
else
{
Destroy(go);
}
}
//if (isClearAssetsAndBundle && !createPools.ContainsKey(name))
//{
// //if (ResourcesConfigManager.GetIsExitRes(name))
// //{
// // Debug.LogWarning("卸载资源:" + name);
// // ResourceManager.UnLoad(name);
// //}
// AssetsPoolManager.DestroyByPool(name);
//}
l_objList.Clear();
}
}
s_objectPool.Clear();
}
private void configure()
{
targetApsect = TargetApsectRatio.x / TargetApsectRatio.y;
poolObjectArray = new PoolObject[PoolSize];
for (var i = 0; i < poolObjectArray.Length; i++)
{
var newGameObject = Instantiate(Prefab);
var newTransform = newGameObject.transform;
newTransform.SetParent(transform);
newTransform.position = Vector3.one * 1000;
poolObjectArray[i] = new PoolObject(newTransform);
}
if (SpawnImediate)
{
spawnObjectImediate();
}
}
public PoolObject Get()
{
PoolObject obj = null;
if (queue.Count > 0)
{
obj = queue.Dequeue();
obj.gameObject.SetActive(true);
}
else if (instanceCount < maxInstances)
{
instanceCount++;
obj = Instantiate <PoolObject>(prefab);
obj.transform.parent = transform;
obj.gameObject.SetActive(true);
}
return(obj);
}
private PoolObject InstantiateNewPoolObject(PoolObject poolObjectToSpawn, List <PoolObject> poolListToAdd)
{
//New poolObject
PoolObject newPoolObject = (PoolObject)Instantiate(poolObjectToSpawn, Vector3.zero, Quaternion.identity);
// start disabled
newPoolObject.DisablePoolObject();
//use this as the transform to keep pool objects organised.
newPoolObject.transform.SetParent(transform);
//make sure there is a pool object script on the new object
newPoolObject.gameObject.AddComponent <PoolObject>();
//Add to the pool list
poolListToAdd.Add(newPoolObject);
return(newPoolObject);
}
void Configure() //called in awake
{
//spawning pool objects
targetAspect = targetAspectRatio.x / targetAspectRatio.y;
poolObjects = new PoolObject[poolSize];
for (int i = 0; i < poolObjects.Length; i++)
{
GameObject go = Instantiate(Prefab) as GameObject; // go short for gameobject,creating object spawning into game, only happen once (spawning prefab and casting it as gameobject)
Transform t = go.transform; //need to store transforms
t.SetParent(transform); //paralaxer on all parent objects, so t will set the parent (whatever script is attached to
t.position = Vector3.one * 1000; //initialize it off screen
poolObjects[i] = new PoolObject(t); //value passed a parameter within the instructor poolObject we need
}
if (spawnImmediate) // if its true
{
SpawnImmediate();
}
}
void Awake()
{
PrefabManager.Instance.LoadPrefabs_Editor();
foreach (KeyValuePair <PrefabNames, int> kv in PoolConfigs)
{
string prefabName = kv.Key.ToString();
GameObject go_Prefab = PrefabManager.Instance.GetPrefab(prefabName);
if (go_Prefab)
{
GameObject go = new GameObject("Pool_" + prefabName);
GameObjectPool pool = go.AddComponent <GameObjectPool>();
pool.transform.SetParent(transform);
PoolDict.Add(kv.Key, pool);
PoolObject po = go_Prefab.GetComponent <PoolObject>();
pool.Initiate(po, kv.Value);
}
}
}
public PoolObject GetFromPool(string i_FXName, float px , float py , float scaleX , float scaleY)
{
if (pool.ContainsKey (i_FXName)) {
if (pool [i_FXName].Count > 0) {
PoolObject p = pool [i_FXName] [0];
pool [i_FXName].RemoveAt (0);
p.gameObject.SetActive (true);
p.myTransform.position = new Vector2 (px, py);
p.myTransform.localScale = new Vector2 (scaleX, scaleY);
p.isActive = true;
p.OutOfPool ();
return p;
} else {
return CreateSinglePoolObject (i_FXName);
}
}
return null;
}
public IEnumerator InstantiateSphere(int poolNum, int insPerFrame, Action stepAction = null)
{
Objects = new PoolObject[poolNum];
var count = 0;
for (int i = 0; i < poolNum; i++)
{
Objects[i] = new PoolObject();
Objects[i].Obj = CreateSphere(new Vector2(0, 0), 1);
Objects[i].Obj.name = i.ToString();
count++;
if (count >= insPerFrame)
{
stepAction?.Invoke();
count = 0;
yield return(null);
}
}
}
void Start()
{
if (_linkedPool == null)
{
_linkedPool = OneMeshPool.GetPool(_poolIdName);
}
if (_linkedPool != null)
{
_linkedObject = _linkedPool.Next(true, true);
if (_linkedObject != null)
{
_linkedObject.transform.parent = this.transform;
_linkedObject.transform.localPosition = Vector3.zero;
_linkedObject.transform.localScale = this.transform.localScale;
return;
}
}
Destroy(this.gameObject);
}
public IEnumerator InstantiateAction(Func <GameObject> create, int poolNum, int insPerFrame, Action stepAction = null)
{
Objects = new PoolObject[poolNum];
var count = 0;
for (int i = 0; i < poolNum; i++)
{
Objects[i] = new PoolObject();
Objects[i].Obj = create();
Objects[i].Obj.name = i.ToString();
count++;
if (count >= insPerFrame)
{
stepAction?.Invoke();
count = 0;
yield return(null);
}
}
}
void Configure_Label()
{
labelObjects = new PoolObject[poolSize];
int counter = 0;
for (int i = 0; i < poolObjects.Length; i++)
{
randomizer : int rnd = Random.Range(0, Label_Prefabs.Length);
if (!Label_Prefabs[rnd].beenChosen)
{
counter++;
if (counter == Label_Prefabs.Length)
{
counter = 0;
int savedInt = rnd;
for (int j = 0; j < Label_Prefabs.Length; j++)
{
Label_Prefabs[j].beenChosen = false;
if (j == savedInt)
{
Label_Prefabs[j].beenChosen = true;
}
}
}
}
else
{
goto randomizer;
}
GameObject go = Instantiate(Label_Prefabs[rnd].prefab) as GameObject;
Label_Prefabs[rnd].beenChosen = true;
Transform t = go.transform;
t.SetParent(transform);
t.position = Vector3.one * 1000;
labelObjects[i] = new PoolObject(t);
}
}
/// <summary>
/// 将对象返回到池。
/// </summary>
public void ReturnObjectToPool(PoolObject poolObject)
{
poolObject.transform.SetParent(parent, false);
switch (poolBehaviour)
{
case PoolBehaviour.GameObject:
poolObject.gameObject.SetActive(false);
break;
case PoolBehaviour.CanvasGroup:
poolObject.canvasGroup.alpha = 0f;
poolObject.canvasGroup.interactable = false;
poolObject.canvasGroup.blocksRaycasts = false;
break;
}
poolObject.isInPool = true;
}
private void SpawnSlash(SkillUser user)
{
PoolObject slash = user.userPool.SpawnTargetObject(meleeHitPrefab, 2);
slash.transform.position = user.transform.position;
DamageSource dmg = slash.GetComponent <DamageSource>();
dmg.damageValue = (int)user.userStats.strength.Value;
dmg.hostileTo = user.userStats.enemyEntitySets;
dmg.knockbackForce = baseKnockbackForce;
dmg.skillType = SkillType.Melee;
dmg.damageType = DamageType.Physical;
//slash.transform.rotation = user.userAim.optionalRotatingPointer.rotation; //temporario, não ideal, precisamos de um método pra calcular rotação
user.userAim.RotateObjectToAim(slash.transform);
dmg.owner = user.userStats;
dmg.manaReplenishAmount = 2;
}
public List <PoolObject> GetAllActiveObjects(int id)
{
List <PoolObject> list = new List <PoolObject>();
if (id > PoolItems.Count || id < 0)
{
Debug.Log("Requesting illegal object with id " + id);
return(null);
}
for (int count = 0; count < _pool[id].Count; ++count)
{
PoolObject obj = _pool[id][count];
if (obj.IsActive)
{
list.Add(obj);
}
}
return(list);
}
/// <summary>
/// Adiciona objeto ao Pool
/// </summary>
/// <param name="object_">Object.</param>
public void AddObjectToPool(PoolObject templateObject_, int times_)
{
if (_currentIndex > _pool.Length) return; //Nao ha mais espacos para inserir
for (int i = 0; i < times_; i++){
_pool[_currentIndex] = GameObject.Instantiate(templateObject_) as PoolObject;
_pool[_currentIndex].gameObject.SetActive(false);
_pool[_currentIndex].ObjectAddedToPool();
_pool[_currentIndex].Pool = templateObject_.Pool; // Recupera a referencia de um unico PoolManager por Template
_currentIndex++; // Soma mais um para o proximo objeto ser adicionado corretamente
}
// Estrutura os filhos dentro do template
for (int i = 0; i < _pool.Length; i++)
{
if (_pool[i] != null)
{
_pool[i].transform.parent = DefaultParent;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="prefab"></param>
/// <param name="poolParent"></param>
/// <returns></returns>
public Pool CreatePool(PoolObject prefab, Transform poolParent = null)
{
Pool pool = new Pool(this, prefab);
poolList.Add(pool);
pools.Add(prefab, pool);
if (poolParent == null)
{
poolParent = new GameObject(prefab.name).transform;
poolParent.parent = parent;
}
pool.Initialize(poolParent);
return pool;
}
/// <summary>
/// Create pool and cache prefab.
/// </summary>
/// <param name="poolManager"></param>
/// <param name="prefab"></param>
/// <param name="parent"></param>
public Pool(PoolManager poolManager, PoolObject prefab, Transform parent = null)
{
this.poolManager = poolManager;
if (prefab != null)
{
this.prefab = prefab;
}
}
void CreatePoolTable(PoolObject[] poolTable, int initialPoolAmmout)
{
for (int i = 0; i < poolTable.Length; i++)
{
poolTable[i] = Instantiate(poolTable[i], Vector3.zero, Quaternion.identity) as PoolObject;
/*SkillBase _skillBase = poolTable[i] as SkillBase;
if (_skillBase != null)
_skillBase.SetupSkill();*/
poolTable[i].name += " Table";
poolTable[i].gameObject.SetActive(false);
poolTable[i].Pool = new PoolManager();
poolTable[i].Pool.Initialize(initialPoolAmmout, poolTable[i].transform);
poolTable[i].Pool.AddObjectToPool(poolTable[i], initialPoolAmmout);
/*if (_skillBase != null)
{
for (int j = 0; j < _skillBase.Pool.Length; j++)
{
((SkillBase)_skillBase.Pool[j]).SetupSkill();
}
}*/
poolTable[i].transform.parent = this.transform;
}
}
protected virtual void Awake()
{
myTransform = transform;
myPoolObject = GetComponent<PoolObject>();
}
/// <summary>
/// Push gameObject back into the pool.
/// </summary>
/// <param name="poolObject">GameObject to return to the pool.</param>
public void Push(PoolObject poolObject)
{
pool.Push(poolObject.gameObject);
ActiveCount--;
}
/// <summary>
/// Hides and returns assigned poolobject to this pool
/// </summary>
/// <param name="obj"></param>
public virtual void Return(PoolObject obj)
{
obj.gameObject.SetActive(false);
m_Instances.Enqueue(obj.gameObject);
}
/// <summary>
///
/// </summary>
/// <param name="prefab"></param>
/// <returns></returns>
public Pool GetPool(PoolObject prefab)
{
return poolList.FirstOrDefault(p => p.prefab == prefab);
}
public PoolList(GameObject Prefab)
{
m_Prefab = Prefab;
m_ActivePool = null;
m_FreePool = null;
m_NumAllocated = 0;
m_NumReused = 0;
m_Container = new GameObject();
m_Container.name = Prefab.name;
m_Container.transform.parent = sInstance.gameObject.transform;
}
internal GameObject AllocatedFromPool(Vector3 spawnPosition, Quaternion spawnRotation)
{
PoolObject NewPoolObject;
if(m_FreePool == null)
{
m_NumAllocated++;
NewPoolObject = PoolObject.Create (m_Prefab, this, spawnPosition, spawnRotation);
NewPoolObject.m_Next = m_ActivePool;
m_ActivePool = NewPoolObject;
}
else
{
m_NumReused++;
NewPoolObject = m_FreePool;
NewPoolObject.Reuse(this, spawnPosition, spawnRotation);
// next free pool entry is now the head
m_FreePool = m_FreePool.m_Next;
// link node into active pool
NewPoolObject.m_Next = m_ActivePool;
m_ActivePool = NewPoolObject;
}
NewPoolObject.m_GameObject.SetActive(true);
NewPoolObject.m_GameObject.name = m_Prefab.name + m_NumAllocated.ToString();
return (NewPoolObject.m_GameObject);
}
/// <summary>
/// Retrieve the next available gameObject from the corresponding pool. Creates a new pool if necessary.
/// </summary>
/// <param name="prefab">Type of gameObject to return.</param>
/// <param name="life">Time in seconds till gameObject gets disabled.</param>
/// <returns>Enabled gameObject.</returns>
public GameObject Pop(PoolObject prefab, float life)
{
while (true)
{
Pool pool;
if (pools.TryGetValue(prefab, out pool))
{
return pool.Pop(life);
}
CreatePool(prefab);
}
}
internal bool Release(GameObject ThisGameObject)
{
PoolObject LastObject = null;
PoolObject CheckObject = m_ActivePool;
while(CheckObject != null)
{
if(CheckObject.m_GameObject == ThisGameObject)
{
// unlink from active pool
if(LastObject == null)
m_ActivePool = CheckObject.m_Next;
else
LastObject.m_Next = CheckObject.m_Next;
// add to free pool
CheckObject.m_Next = m_FreePool;
m_FreePool = CheckObject;
ThisGameObject.SetActive(false);
return (true);
}
LastObject = CheckObject;
CheckObject = CheckObject.m_Next;
}
return (false);
}
internal static PoolObject Create(GameObject Prefab, PoolList Creator, Vector3 spawnPosition, Quaternion spawnRotation)
{
PoolObject NewPoolObject = new PoolObject();
NewPoolObject.m_Next = null;
NewPoolObject.m_GameObject = GameObject.Instantiate(Prefab) as GameObject;
NewPoolObject.m_GameObject.transform.parent = Creator.m_Container.transform;
NewPoolObject.m_GameObject.transform.position = spawnPosition;
NewPoolObject.m_GameObject.transform.rotation = spawnRotation;
return(NewPoolObject);
}
//o(1)
public void ReturnObjectToPool(PoolObject po)
{
if (poolName.Equals(po.poolName))
{
objectsInUse--;
/* we could have used availableObjStack.Contains(po) to check if this object is in pool.
* While that would have been more robust, it would have made this method O(n)
*/
if (po.isPooled)
{
#if UNITY_EDITOR
Debug.LogWarning(po.gameObject.name + " is already in pool. Why are you trying to return it again? Check usage.");
#endif
}
else
{
AddObjectToPool(po);
}
}
else
{
Debug.LogError(string.Format("Trying to add object to incorrect pool {0} {1}", po.poolName, poolName));
}
}
/// <summary>
/// Retrieve the next available gameObject from the corresponding pool. Creates a new pool if necessary.
/// </summary>
/// <param name="prefab">Type of gameObject to return.</param>
/// <param name="position"></param>
/// <param name="rotation"></param>
/// <param name="life">Time in seconds till gameObject gets disabled.</param>
/// <returns>Enabled gameObject.</returns>
public GameObject Pop(PoolObject prefab, Vector3 position, Quaternion rotation, float life)
{
while (true)
{
Pool pool;
if (pools.TryGetValue(prefab, out pool))
{
Transform popped = pool.Pop(life).transform;
popped.position = position;
popped.rotation = rotation;
return popped.gameObject;
}
CreatePool(prefab);
}
}
//o(1)
private void AddObjectToPool(PoolObject po)
{
//add to pool
po.gameObject.SetActive(false);
po.gameObject.name = poolName;
availableObjStack.Push(po);
po.isPooled = true;
//add to a root obj
po.gameObject.transform.SetParent(rootObj.transform, false);
}
// Use this for initialization
void Start()
{
BulletTransform = transform;
BulletPoolObject = GetComponent<PoolObject>();
StartCoroutine(BulletCoroutine());
}
