/// <summary>
/// 以游戏物体或预设为模板，从对象池中获取闲置对象
/// </summary>
public GameObject FromPool(int poolName, ref GameObject template, OnGameObjectPoolItem onInit = null, bool visible = true)
{
GameObject result = null;
bool flag = CheckPoolResult(poolName, ref mPool, ref result);
if (result == null)
{
result = Object.Instantiate(template);
}
else
{
if (flag && (PoolContainer != null))
{
PoolContainer.Get(result);
}
else
{
}
}
result.SetActive(visible);
onInit?.Invoke(result);
return(result);
}
/// <summary>
/// 以脚本类型为模板，从对象池中获取闲置对象
/// </summary>
public T FromComponentPool <T>(int poolName, ref T template, OnComponentPoolItem <T> onInit = null, bool visible = true) where T : Component
{
Tester.Instance.Log(TesterBaseApp.Instance, TesterBaseApp.LOG, template == null, "error: template is null, the type is ".Append(typeof(T).ToString()));
Component tempResult = null;
bool flag = CheckPoolResult(poolName, ref mCompPool, ref tempResult);
if (tempResult == null)
{
tempResult = Object.Instantiate(template);
}
else
{
if (flag && (PoolContainer != null))
{
PoolContainer.Get(tempResult.gameObject);
}
}
T result = (T)tempResult;
result.gameObject.SetActive(visible);
onInit?.Invoke(result);
return(result);
}
void PoolContainerDestroyed(PoolContainer poolContainer)
{
if (ParentPoolContainer == null || poolContainer == ParentPoolContainer)
{
DestroyImmediate(gameObject);
}
}
private void Initialize()
{
if (_initialized)
{
return;
}
_initialized = true;
if (_tempContainer == null)
{
_tempContainer = new GameObject(TEMP_CONTAINER_NAME).AddComponent <PoolContainer>();
}
_tempContainer.RegisterOnDestroy(SceneTransitioning);
if (_persistedContainer == null)
{
_persistedContainer = new GameObject(PERSISTED_CONTAINER_NAME).AddComponent <PoolContainer>();
_persistedContainer.SetAsPersisted();
}
if (persistAcrossScenes)
{
_persistedContainer.RegisterOnLevelWasLoaded(Reregister);
}
}
public static void Main(string[] args)
{
using (PoolContainer<IComplexContruct> poolContainer = new PoolContainer<IComplexContruct>(PoolSize, VideoFactory))
{
int concurrentThreads = 3;
int remaining = concurrentThreads;
List<Task> taskList = new List<Task>();
for (int index = 0; index < concurrentThreads; index++)
{
int threadIndex = index;
taskList.Add(Task.Factory.StartNew(() =>
{
Thread.CurrentThread.Name = string.Format("Thread No: {0}", threadIndex);
for (int j = 0; j < 2; j++)
{
using (IComplexContruct complexConstruct = poolContainer.Acquire())
{
using (IComplexContruct complexConstructNew = poolContainer.Acquire())
{
complexConstruct.Test();
complexConstructNew.Test();
}
}
}
}));
}
Task.WaitAll(taskList.ToArray());
Console.WriteLine("Multi-Threaded pooling test finished!\n");
}
Console.ReadLine();
}
public GamePool()
{
Bullet = PoolContainer.CreatePool <PoolObject>(StaticPrm.PoolPath.PATH_BULLET);
TankGreen = PoolContainer.CreatePool <PoolObject>(StaticPrm.PoolPath.PATH_TANK_GREEN);
TankRed = PoolContainer.CreatePool <PoolObject>(StaticPrm.PoolPath.PATH_TANK_RED);
TankPurple = PoolContainer.CreatePool <PoolObject>(StaticPrm.PoolPath.PATH_TANK_PURPLE);
}
public void Reward(PoolContainer pooler, Vector3 spawnPosition)
{
PoolObject po = pooler.SpawnTargetObject(reward.thisPoolObject, 2);
po.transform.position = spawnPosition;
rewarded = true;
questUpdateEvent.Raise();
}
private void Reregister()
{
if (_tempContainer == null)
{
_tempContainer = new GameObject(TEMP_CONTAINER_NAME).AddComponent <PoolContainer>();
}
_tempContainer.RegisterOnDestroy(SceneTransitioning);
}
public void Initialize()
{
_player = _playerFilter.Components1[0];
_map = _world.CreateEntityWith <MapComponent>();
_map.LastCoords = new CubeCoords(0, 0);
_map.PoolB = PoolContainer.CreatePool(Utils.BackPrefabPath);
_map.PoolF = PoolContainer.CreatePool(Utils.ForePrefabPath);
MapGenRandomNeighbours.GenerateMap(out _map.MapB, out _map.MapF, MapSize, MapSeed);
RenderFull(new CubeCoords(0, 0), Fow);
}
public void Destroy()
{
_poolContainers = null;
_zombiePool = null;
_coinsPool = null;
_path.Clear();
_path = null;
_alreadyEnergy.Clear();
_alreadyEnergy = null;
_alreadyCoins.Clear();
_alreadyCoins = null;
m_AllLevels = null;
m_EasyLevelsPrefabs = null;
m_NormalLevelsPrefabs = null;
m_HardLevelsPrefabs = null;
}
public T GetClone <T>(T prefab) where T : Component
{
if (_pool.ContainsKey(prefab))
{
var tempList = _pool[prefab];
foreach (var item in tempList)
{
if (!item)
{
continue;
}
if (!item.gameObject.activeSelf)
{
item.gameObject.SetActive(true);
item.transform.parent = null;
return(item as T);
}
}
var tempInstance = MonoBehaviour.Instantiate(prefab) as T;
tempList.Add(tempInstance);
return(tempInstance);
}
else
{
if (!_poolContainer)
{
var temp = new GameObject("PoolWrapper");
_poolContainer = temp.AddComponent <PoolContainer>();
if (_poolContainer)
{
_poolContainer.OnDestroyWrapper += PoolContainerOnDestroy;
_poolContainer.transform.position = Vector3.zero;
_poolContainer.gameObject.SetActive(false);
}
}
var component = prefab as Component;
_pool.Add(component, new List <Component>());
return(GetClone <T>(prefab));
}
}
public void ToPool(int poolName, GameObject target, OnGameObjectPoolItem onRevert = null, bool visible = false)
{
if (target == null || mIsDispose)
{
return;
}
else
{
}
onRevert?.Invoke(target);
if (mPool.IsContainsKey(poolName))
{
int elmMax = (mPoolElmMax.IsContainsKey(poolName)) ? mPoolElmMax[poolName] : int.MaxValue;
Stack <GameObject> pool = mPool[poolName];
if (pool.Count < elmMax)
{
pool.Push(target);
if (PoolContainer != default)
{
PoolContainer.Collect(target, visible);
}
else
{
target.SetActive(visible);
}
}
else
{
Debug.Log(target);
Object.DestroyImmediate(target);
}
}
else
{
Stack <GameObject> pool = new Stack <GameObject>();
mPool[poolName] = pool;
ToPool(poolName, target, onRevert);
}
}
public GameObject getPoolObject(GameObjectType type_obj)
{
GameObject result = null;
if (!poolObjects.ContainsKey(type_obj))
{
poolObjects[type_obj] = new PoolContainer();
}
else
{
result = poolObjects[type_obj].getEmptyObject();
}
if (result == null)
{
result = InstanceObject(type_obj);
}
return(result);
}
public void ToPool <T>(int poolName, T target, OnComponentPoolItem <T> onRevert = null, bool visible = false) where T : Component
{
if (target == null || mIsDispose)
{
return;
}
else
{
}
onRevert?.Invoke(target);
if (mCompPool.IsContainsKey(poolName))
{
int elmMax = mCompPoolElmMax.IsContainsKey(poolName) ? mCompPoolElmMax[poolName] : int.MaxValue;
Stack <Component> pool = mCompPool[poolName];
if (pool.Count < elmMax)
{
pool.Push(target);
if (PoolContainer != null)
{
PoolContainer.Collect(target.gameObject, visible);
}
else
{
target.gameObject.SetActive(visible);
}
}
else
{
Object.DestroyImmediate(target.gameObject);
}
}
else
{
Stack <Component> pool = new Stack <Component>();
mCompPool[poolName] = pool;
ToPool(poolName, target, onRevert);
}
}
public void InstantiatePoolItem()
{
foreach (PoolContainer container in containerList)
{
if (container != null)
{
PoolContainer poolContainer = Instantiate(container) as PoolContainer;
ObjectPoolManager.Instance.poolContainedList.Add(poolContainer);
ObjectPoolManager.Instance.SetObjectPool(
poolContainer.PoolList,
poolContainer.poolSize,
poolContainer.itemPrefab,
this.transform);
}
else
{
Debug.LogWarning("containerPrefab missing : " + container);
}
}
}
public void GetInstanceFromContainer(GetInstanceFromPoolEvent e, Node any, [JoinAll] Optional <MapWithContainer> map)
{
if (!map.IsPresent())
{
e.Instance = Object.Instantiate <GameObject>(e.Prefab).transform;
if (e.AutoRecycleTime > 0f)
{
Object.Destroy(e.Instance.gameObject, e.AutoRecycleTime);
}
}
else
{
PoolContainer container;
MainPoolContainerComponent mainPoolContainer = map.Get().mainPoolContainer;
if (!mainPoolContainer.PrefabToPoolDict.TryGetValue(e.Prefab, out container))
{
Transform transform = new GameObject(e.Prefab.name + "_PoolContainer").transform;
transform.SetParent(mainPoolContainer.MainContainerTransform);
PoolContainer container2 = transform.gameObject.AddComponent <PoolContainer>();
container2.ItemsRoot = transform;
container2.CustomPrefab = e.Prefab;
container = container2;
mainPoolContainer.PrefabToPoolDict.Add(e.Prefab, container2);
}
Transform poolTransform = container.Get().PoolTransform;
e.Instance = poolTransform;
if (e.AutoRecycleTime > 0f)
{
RecycleAfterTime component = poolTransform.gameObject.GetComponent <RecycleAfterTime>();
if (component)
{
component.Timeout = e.AutoRecycleTime;
}
else
{
poolTransform.gameObject.AddComponent <RecycleAfterTime>().Timeout = e.AutoRecycleTime;
}
}
}
}
private void InitPoolAndSpawnFirst()
{
var parent = GameObject.FindGameObjectWithTag(Tag.FieldPool).transform;
//create zombie pool
_zombiePool = PoolContainer.CreatePool(ZombiePrefabs[0], parent);
//create coin pool
_coinsPool = PoolContainer.CreatePool(CoinPrefab, parent);
//create fields pool
_poolContainers = new PoolContainer[m_EasyLevelsPrefabs.Count
+ m_NormalLevelsPrefabs.Count
+ m_HardLevelsPrefabs.Count];
m_AllLevels = new List <GameObject>();
m_AllLevels.AddRange(m_EasyLevelsPrefabs);
m_AllLevels.AddRange(m_NormalLevelsPrefabs);
m_AllLevels.AddRange(m_HardLevelsPrefabs);
for (int i = 0; i < _poolContainers.Length; i++)
{
_poolContainers[i] = PoolContainer.CreatePool(new List <GameObject>(m_AllLevels)[i], parent);
}
// spawn zombies for default level
SpawnZombie(0, m_DefaultLevelTransform);
//init ground size
// _groundSize = firstObject.PoolTransform.FindRecursiveByTag(Tag.Ground).localScale.y;
_groundSize = 30f;
// add any level, it won't be generated, because level0 is already presented
_path.Add(new Field(0));
// -1 and 0 fields are already on scene so spawn some more fields forward
for (int i = 0; i < ForwardSpawnCount; i++)
{
PopOrSpawnById(i + 1);
}
}
public GameObject GetItemFromPool(string poolName)
{
PoolContainer poolContainer = poolContainers.Find((x) => { return(x.IsPoolOf(poolName)); });
return(poolContainer.GetItemFromPool());
}
public PoolsObject()
{
Bullets = PoolContainer.CreatePool <PoolObjectExt>(pathBullet);
Mobs = PoolContainer.CreatePool <PoolObjectExt>(pathMob);
}
/// <summary>
/// Video factory.
/// </summary>
/// <param name="poolContainer">The pool container.</param>
/// <returns></returns>
public static IComplexContruct VideoFactory(PoolContainer<IComplexContruct> poolContainer)
{
return new PooledConstruct<VideoFrame>(poolContainer, new VideoFrame());
}
public void SetPool(PoolContainer pool)
{
Pool = pool;
}
public PoolsObject()
{
Blocks = PoolContainer.CreatePool <PoolObject>(pathBlock);
Booms = PoolContainer.CreatePool <PoolObjectBoom>(pathBoom);
}
public void ReturnItemToPool(PoolItem poolItem)
{
PoolContainer poolContainer = poolContainers.Find((x) => { return(x.IsPoolOf(poolItem.PoolName)); });
poolContainer.ReturnItemToPool(poolItem);
}
public PoolsObject()
{
Enemies = PoolContainer.CreatePool <PoolObjectExt>(pathEnemy);
}
