//创建enemyPool
void GenerateEnemyPool()
{
enemySpawnPool = PoolManager.Pools.Create(enemyPool);
enemySpawnPool.group.parent = transform;
enemySpawnPool.dontDestroyOnLoad = true;
if (SceneManager.GetActiveScene().name == Game.Instance.StaticData.Level3)
{
shellEnemyInfo = Game.Instance.StaticData.shellEnemyList;
foreach (EnemyInfo info in shellEnemyInfo)
{
PrefabPool prefabPool = new PrefabPool(info.Prefab.transform);
PoolSetting(prefabPool, 4);
enemySpawnPool.CreatePrefabPool(prefabPool);
}
}
else
{
enemyInfo = Game.Instance.StaticData.enemyList;
foreach (EnemyInfo info in enemyInfo)
{
PrefabPool prefabPool = new PrefabPool(info.Prefab.transform);
PoolSetting(prefabPool, 4);
enemySpawnPool.CreatePrefabPool(prefabPool);
}
bossEnemyInfo = Game.Instance.StaticData.bossEnemyList;
foreach (EnemyInfo info in bossEnemyInfo)
{
PrefabPool prefabPool = new PrefabPool(info.Prefab.transform);
PoolSetting(prefabPool, 12);
enemySpawnPool.CreatePrefabPool(prefabPool);
}
}
}
public Transform PlayEffect(string effectName, float delayDestroy = 0f)
{
if (!m_EffectDic.ContainsKey(effectName))
{
GameObject go = LoadEffect(effectName);
if (go == null)
{
return(null);
}
m_EffectDic[effectName] = go.transform;
PrefabPool prefabPool = new PrefabPool(m_EffectDic[effectName]);
prefabPool.PreloadAmount = 0; //预加载数量
prefabPool.IsCullDespawned = true; //是否开启缓存池自动清理
prefabPool.CullAbove = 1; //缓存池自动清理 但是始终保留对象的个数
prefabPool.CullDelay = 5; //多长时间清理一次 秒
prefabPool.CullMaxPerPass = 2; //每次清理几个
m_EffectPool.CreatePrefabPool(prefabPool);
}
Transform effect = m_EffectPool.Spawn(m_EffectDic[effectName]);
if (delayDestroy > 0f)
{
DestroyEffect(effect, delayDestroy);
}
return(effect);
}
private void pool_Initialize()
{
NotePool = PoolManager.Pools.Create("MusicNote", this.gameObject);
NotePool.dontDestroyOnLoad = true;
pool_singleNote = new PrefabPool(PlayerCollection.PlayerNoteCollection["singleOne"].transform);
pool_singleNote.preloadAmount = 5;
pool_singleNote.cullDespawned = true;
pool_singleNote.cullAbove = 20;
pool_singleNote.cullDelay = 10;
NotePool.CreatePrefabPool(pool_singleNote);
pool_singleNote = new PrefabPool(PlayerCollection.PlayerNoteCollection["singleTwo"].transform);
pool_singleNote.preloadAmount = 5;
pool_singleNote.cullDespawned = true;
pool_singleNote.cullAbove = 20;
pool_singleNote.cullDelay = 10;
NotePool.CreatePrefabPool(pool_singleNote);
beamsone_1 = new PrefabPool(PlayerCollection.PlayerNoteCollection["beamOne_1"].transform);
beamsone_1.preloadAmount = 10;
beamsone_1.cullDespawned = true;
beamsone_1.cullAbove = 20;
beamsone_1.cullDelay = 10;
NotePool.CreatePrefabPool(beamsone_1);
beamstwo_1 = new PrefabPool(PlayerCollection.PlayerNoteCollection["beamTwo_1"].transform);
beamstwo_1.preloadAmount = 10;
beamstwo_1.cullDespawned = true;
beamstwo_1.cullAbove = 20;
beamstwo_1.cullDelay = 10;
NotePool.CreatePrefabPool(beamstwo_1);
}
//创建effectPool
void GenerateEffectPool()
{
effectSpawnPool = PoolManager.Pools.Create(effectPool);
effectSpawnPool.group.parent = transform;
enemyEffectInfo = Game.Instance.StaticData.enemyEffectList;
foreach (EffectInfo info in enemyEffectInfo)
{
PrefabPool prefabPool = new PrefabPool(info.Prefab.transform);
switch (info.Prefab.name)
{
case "GenerationEffect":
PoolSetting(prefabPool, 8);
break;
case "DeadEffect":
PoolSetting(prefabPool, 6);
break;
case "BubbleSinisterAttackEffect":
PoolSetting(prefabPool, 50);
break;
case "BubbleAngryAttackEffect":
PoolSetting(prefabPool, 4);
break;
}
effectSpawnPool.CreatePrefabPool(prefabPool);
}
bossEffectInfo = Game.Instance.StaticData.bossEffectList;
foreach (EffectInfo info in bossEffectInfo)
{
PrefabPool prefabPool = new PrefabPool(info.Prefab.transform);
switch (info.Prefab.name)
{
case "MarkEffect":
PoolSetting(prefabPool, 20);
break;
case "ThunderEffect":
PoolSetting(prefabPool, 20);
break;
}
effectSpawnPool.CreatePrefabPool(prefabPool);
}
if (SceneManager.GetActiveScene().name == Game.Instance.StaticData.Level3)
{
bonfireEffectInfo = Game.Instance.StaticData.bonfireEffect;
PrefabPool prefabPool = new PrefabPool(bonfireEffectInfo.Prefab.transform);
if (bonfireEffectInfo.Prefab.name == "BonfireEffect")
{
PoolSetting(prefabPool, 2);
}
effectSpawnPool.CreatePrefabPool(prefabPool);
}
}
static void CreatePrefabPool(SpawnPool spawnPool, Transform prefab, int num)
{
if (spawnPool._perPrefabPoolOptions.Any(c => c.prefab.name == prefab.name))
{
return;
}
PrefabPool refabPool = new PrefabPool(prefab);
refabPool.preloadTime = false;
refabPool.preloadFrames = 2;
refabPool.preloadDelay = 1.0f;
//默认初始化两个Prefab
refabPool.preloadAmount = num;
//开启限制
refabPool.limitInstances = true;
//关闭无限取Prefab
refabPool.limitFIFO = true;
//限制池子里最大的Prefab数量
refabPool.limitAmount = num * 10;
//开启自动清理池子
refabPool.cullDespawned = false;
//最终保留
refabPool.cullAbove = 0;
//多久清理一次
refabPool.cullDelay = 5;
//每次清理几个
refabPool.cullMaxPerPass = num;
spawnPool._perPrefabPoolOptions.Add(refabPool);
spawnPool.CreatePrefabPool(refabPool);
}
private void InitPool()
{
for (int i = 0; i < 2; i++)
{
Transform tr = Resources.Load <Transform>(_prefabPaths[i]);
PrefabPool refabPool = new PrefabPool(tr);
//默认初始化两个Prefab
refabPool.preloadAmount = 2;
//开启限制
refabPool.limitInstances = false;
//关闭无限取Prefab
refabPool.limitFIFO = false;
//限制池子里最大的Prefab数量
refabPool.limitAmount = 5;
//开启自动清理池子
refabPool.cullDespawned = true;
//最终保留
refabPool.cullAbove = 10;
//多久清理一次
refabPool.cullDelay = 5;
//每次清理几个
refabPool.cullMaxPerPass = 5;
//初始化内存池
spawnPool._perPrefabPoolOptions.Add(refabPool);
spawnPool.CreatePrefabPool(spawnPool._perPrefabPoolOptions[spawnPool.Count]);
}
}
public void InitBuffTipsViewPool()
{
_buffTipsDic.Clear();
if (!_buffTipsViewPool)
{
GameObject go = new GameObject(POOL_NAME);
_buffTipsViewPool = go.transform;
_buffTipsViewPool.SetParent(UI.UIMgr.instance.basicCanvas.transform, false);
//create _spawnPoll
_spawnPool = PoolController.instance.CreatePool(POOL_NAME, BuffTipsView.PREFAB_PATH, true);
_spawnPool.matchPoolScale = true;
_prefab = ResMgr.instance.Load <GameObject>(BuffTipsView.PREFAB_PATH);
_prefabPool = new PrefabPool(_prefab.transform);
_prefabPool.preloadAmount = 5; //默认初始化5个Prefab
_prefabPool.limitInstances = true; //开启限制
_prefabPool.limitFIFO = true; //开启无限取Prefab
_prefabPool.limitAmount = 20; //限制池子里最大的Prefab数量
_prefabPool.preloadTime = true; //开启预加载
_prefabPool.preloadFrames = 2; //每帧加载个数
_prefabPool.preloadDelay = 2; //延迟几秒开始预加载
_prefabPool.cullDespawned = true; //开启自动清理
_prefabPool.cullAbove = 5; //缓存池自动清理，但是始终保存几个对象不清理
_prefabPool.cullDelay = 10; //每过多久执行一次清理(销毁)，单位秒
_prefabPool.cullMaxPerPass = 2; //每次自动清理个数
//初始化内存池
//_spawnPool._perPrefabPoolOptions.Add(_prefabPool);
_spawnPool.CreatePrefabPool(_prefabPool);
}
}
/// <summary>
/// 初始化单一对象池子，并设置默认属性
/// </summary>
/// <param name="prefab"></param>
private void InitPrefabPool(Transform prefab)
{
if (_objectPool.GetPrefabPool(prefab) == null)
{
PrefabPool prefabPool = new PrefabPool(prefab);
prefabPool.preloadAmount = _preloadAmount;
prefabPool.preloadTime = _preloadTime;
if (_preloadTime)
{
prefabPool.preloadFrames = _preloadFrames;
prefabPool.preloadDelay = _preloadDelay;
}
prefabPool.limitInstances = _limitInstances;
if (_limitInstances)
{
prefabPool.limitAmount = _limitAmount;
prefabPool.limitFIFO = _limitFIFO;
}
prefabPool.cullDespawned = _cullDespawned;
if (_cullDespawned)
{
prefabPool.cullAbove = _cullAbove;
prefabPool.cullDelay = _cullDelay;
prefabPool.cullMaxPerPass = _cullMaxPerPass;
}
prefabPool._logMessages = _logPoolMessage;
_objectPool._perPrefabPoolOptions.Add(prefabPool);
_objectPool.CreatePrefabPool(prefabPool);
}
}
/// <summary>
/// 缓存池预加载一个 Prefab
/// </summary>
/// <param name="pool">缓存池</param>
/// <param name="preloadCount">预加载的实例个数</param>
/// <param name="limitCount">缓存池实例限制</param>
public void PreloadPrefab(SpawnPool pool, GameObject prefab, int preloadCount, int limitCount)
{
if (pool.GetPrefabPool(prefab.transform) != null)
{
Debug.LogWarning("Create A Exist Prefab Pool");
return;
}
PrefabPool prefabPool = new PrefabPool(prefab.transform);
if (limitCount > 0)
{
preloadCount = Mathf.Min(preloadCount, limitCount);
prefabPool.limitAmount = limitCount;
prefabPool.preloadAmount = preloadCount;
prefabPool.limitInstances = true;
}
else
{
prefabPool.preloadAmount = preloadCount;
prefabPool.limitInstances = false;
}
pool.CreatePrefabPool(prefabPool);
}
protected override void OnMainUIComplete()
{
base.OnMainUIComplete();
m_IsFighting = true;
PlayerCtrl.Instance.SetMainCityData();
m_GameLevelId = SceneMgr.Instance.CurGameLevelSceneId;
m_Grade = SceneMgr.Instance.CurGameLevelGrade;
regionEntityList = GameLevelRegionDBModel.Instance.GetRegionListByGameLevelId(m_GameLevelId);
m_CurSelectRegionIndex = 0;
EnterRegion(m_CurSelectRegionIndex);
m_AllMonsterCount = GameLevelMonsterDBModel.Instance.GetLevelMonsterCount(m_GameLevelId, m_Grade);
m_AllMonsterID = GameLevelMonsterDBModel.Instance.GetLevelAllMonsterId(m_GameLevelId, m_Grade);
m_Pool = PoolManager.Pools.Create("Monster");
m_Pool.group.parent = null;
m_Pool.group.localPosition = Vector3.zero;
for (int i = 0; i < m_AllMonsterID.Length; i++)
{
Transform t = GameUtil.LoadSprite(m_AllMonsterID[i]).transform;
PrefabPool prefabPool = new PrefabPool(t);
prefabPool.preloadAmount = 5;
prefabPool.cullDespawned = true;
prefabPool.cullAbove = 5;
prefabPool.cullDelay = 2;
prefabPool.cullMaxPerPass = 2;
m_Pool.CreatePrefabPool(prefabPool);
}
Global.Instance.CurPlayer.ToIdle(IdleType.IdleFight);
GameLevelCtrl.Instance.CurGameLevelTotalExp = 0;
GameLevelCtrl.Instance.CurGameLevelTotalGold = 0;
GameLevelCtrl.Instance.CurGameLevelKillMonsterDic.Clear();
GameLevelCtrl.Instance.CurGameLevelGetGoodsList.Clear();
}
protected override void OnStart()
{
base.OnStart();
AssetBundleMgr.Instance.LoadOrDownload("Download/Prefab/UIPrefab/UIOther/UITipItem.assetbundle", "UITipItem", (GameObject obj) =>
{
m_TipItem = obj.transform;
m_TipPool = PoolManager.Pools.Create("TipPool");
m_TipPool.group.parent = transform;
m_TipPool.group.localPosition = Vector3.zero;
PrefabPool prefabPool = new PrefabPool(m_TipItem);
prefabPool.preloadAmount = 5; //预加载数量
prefabPool.cullDespawned = true; //是否开启缓存池自动清理模式
prefabPool.cullAbove = 10; // 缓存池自动清理 但是始终保留几个对象不清理
prefabPool.cullDelay = 2; //多长时间清理一次 单位是秒
prefabPool.cullMaxPerPass = 2; //每次清理几个
m_TipPool.CreatePrefabPool(prefabPool);
});
//m_TipItem = ResourcesMgr.Instance.Load(ResourcesMgr.ResourceType.UIOther, "UITipItem", cache: true, returnClone: false).transform;
}
public void CreateCharacterPool(string path, string poolName, bool forever, System.Action <SpawnPool> callBack)
{
ResMgr.instance.Load <GameObject>(path, (_prefab) =>
{
if (!_prefab)
{
if (callBack != null)
{
callBack(null);
}
return;
}
if (ContainsPool(poolName))
{
if (callBack != null)
{
callBack(GetPool(poolName));
}
return;
}
GameObject poolGO = new GameObject(poolName);
poolGO.transform.SetParent(transform, false);
SpawnPool spawnPool = PoolManager.Pools.Create(poolName, poolGO);
spawnPool.matchPoolScale = true;
PrefabPool _prefabPool = new PrefabPool(_prefab.transform);
if (path.Contains("player/") || path.Contains("pet/"))
{
_prefabPool.preloadAmount = 2; //默认初始化5个Prefab
_prefabPool.limitInstances = true; //开启限制
_prefabPool.limitFIFO = true; //开启无限取Prefab
_prefabPool.limitAmount = 15; //限制池子里最大的Prefab数量
_prefabPool.cullAbove = 2; //缓存池自动清理，但是始终保存几个对象不清理
}
else
{
_prefabPool.preloadAmount = 1; //默认初始化5个Prefab
_prefabPool.limitInstances = true; //开启限制
_prefabPool.limitFIFO = true; //开启无限取Prefab
_prefabPool.limitAmount = 10; //限制池子里最大的Prefab数量
_prefabPool.cullAbove = 1; //缓存池自动清理，但是始终保存几个对象不清理
}
_prefabPool.preloadTime = true; //开启预加载
_prefabPool.preloadFrames = 1; //每帧加载个数
_prefabPool.preloadDelay = 0; //延迟几秒开始预加载
_prefabPool.cullDespawned = true; //开启自动清理
_prefabPool.cullDelay = 60; //每过多久执行一次清理(销毁)，单位秒
_prefabPool.cullMaxPerPass = 1; //每次自动清理个数
//初始化内存池
//_spawnPool._perPrefabPoolOptions.Add(_prefabPool);
spawnPool.CreatePrefabPool(_prefabPool);
_spawnPoolDic.Add(poolName, forever);
_pathDic.Add(poolName, path);
if (callBack != null)
{
callBack(spawnPool);
}
}, 0);
}
private void CreatePrefabPool(Transform tmp)
{
m_prefabPool = new PrefabPool(tmp);
//默认初始化两个Prefab
m_prefabPool.preloadAmount = 1;
//初始化内存池
m_spawnPool._perPrefabPoolOptions.Add(m_prefabPool);
m_spawnPool.CreatePrefabPool(m_prefabPool);
}
//将对象放入对象池
public void SpawnObject(string poolName, string objName, int objNumber, out SpawnPool spawnPool)
{
spawnPool = PoolManager.Pools [poolName];
PrefabPool prefabPool = new PrefabPool(Resources.Load <Transform> (objName));
prefabPool.preloadAmount = objNumber;
spawnPool._perPrefabPoolOptions.Add(prefabPool);
spawnPool.CreatePrefabPool(spawnPool._perPrefabPoolOptions[spawnPool.Count]);
}
private void InsertPool(SpawnPool pool, GameObject obj)
{
PrefabPool prefabPool = new PrefabPool(obj.transform);
prefabPool.preloadAmount = 1;
prefabPool.limitAmount = 1;
pool._perPrefabPoolOptions.Add(prefabPool);
pool.CreatePrefabPool(prefabPool);
}
public void AddPrefabPool(string s, int amount = 5)
{
if (mPoolList == null || !mPoolList.Contains(s))
{
PrefabPool prePool = GetPrefabPool(s, amount);
if (prePool != null)
{
spawnPool._perPrefabPoolOptions.Add(prePool);
spawnPool.CreatePrefabPool(prePool);
}
}
}
public static bool CreateNewEffectPoolItem(string prefabName, System.Action call)
{
//Debug.LogWarning("2JW : <color=red>Commmons Effect</color> - " + prefabName);
if (EffectLoads.ContainsKey(prefabName))
{
EffectLoads[prefabName].Add(call);
return(false);
}
EffectLoads.Add(prefabName, new List <System.Action>());
EffectLoads[prefabName].Add(call);
GameObject oriEff = null;
if (TempOriEffectsDic.ContainsKey(prefabName))
{
oriEff = TempOriEffectsDic[prefabName];
}
else
{
oriEff = ResourceMgr.Load(string.Format("Effect/_Common/{0}", prefabName)) as GameObject;
if (oriEff == null)
{
Debug.LogWarning("2JW : not effect <color=red>Commmons Effect</color> - " + prefabName + " : " + oriEff, oriEff);
EffectLoads[prefabName].Clear();
EffectLoads.Remove(prefabName);
return(false);
}
//Debug.LogWarning("2JW : " + oriEff);
TempOriEffectsDic.Add(prefabName, oriEff);
}
//AssetbundleLoader.GetEffect(prefabName, (obj) =>
{
//Debug.LogWarning("2JW : " + _GameInfo);
//Debug.LogWarning("2JW : " + _GameInfo.effectPool);
//CreatePoolItem(_GameInfo.effectPool, oriEff);
PrefabPool prefabPool = new PrefabPool(((GameObject)oriEff).transform);
prefabPool.preloadAmount = 1;
prefabPool.AddSpawnCount = 3;
effectPool.CreatePrefabPool(prefabPool, true);
for (int i = 0; i < EffectLoads[prefabName].Count; i++)
{
EffectLoads[prefabName][i]();
}
EffectLoads[prefabName].Clear();
EffectLoads.Remove(prefabName);
}//, false);
return(false);
}
private void InitializeFloatPanelPoolManager()
{
SpawnPool spawnPool = PoolManager.Pools["MessageBox"];
PrefabPool floatPanelPool = new PrefabPool(PanelManager.FloatPanel.GetPanel());
floatPanelPool.preloadAmount = 3;
floatPanelPool.limitInstances = true;
floatPanelPool.limitAmount = 3;
spawnPool.CreatePrefabPool(floatPanelPool);
}
//注册
public void Regist(string InName, Transform NewObj)
{
PrefabPool ReturnPool = new PrefabPool();
if (!GamePool.prefabPools.TryGetValue(InName, out ReturnPool) && NewObj != null)
{
ReturnPool = null;
ReturnPool = new PrefabPool(NewObj.transform);
ReturnPool.cullDespawned = true;
ReturnPool.cullDelay = 5;
GamePool.CreatePrefabPool(ReturnPool);
}
}
private void InitializeMessageBoxPoolManager()
{
SpawnPool spawnPool = PoolManager.Pools.Create("UIRoot/MessageBox");
PrefabPool messageboxPool = new PrefabPool(PanelManager.MessageBox.GetPanel());
messageboxPool.preloadAmount = 1;
messageboxPool.limitInstances = true;
messageboxPool.limitAmount = 1;
spawnPool.CreatePrefabPool(messageboxPool);
}
/// <summary>
/// 创建预设体对象池接口
/// </summary>
/// <param name="prefabTrans">预设体Transform</param>
/// <param name="preloadAmount">预先加载对象数量</param>
/// <returns></returns>
public PrefabPool CreatePrefabPool(string spawnPoolName, Transform prefabTrans, int preloadAmount, System.Type type = null)
{
m_spawnPool = PoolManager.Pools[spawnPoolName];
PrefabPool prefabPool = new PrefabPool(prefabTrans);
prefabPool.preloadAmount = preloadAmount;
prefabPool.preloadTime = false;
prefabPool.limitInstances = true;
prefabPool.limitAmount = 200;
prefabPool.scriptType = type;
m_spawnPool._perPrefabPoolOptions.Add(prefabPool);
m_spawnPool.CreatePrefabPool(m_spawnPool._perPrefabPoolOptions[m_spawnPool._perPrefabPoolOptions.Count - 1]);
return(prefabPool);
}
public void CreatePoolChildrenGo(string _poolName, Transform _childenPrefab, CPoolChildrenData _poolChildrenData = null)
{
SpawnPool spawnPool = GetPool(_poolName);
if (spawnPool == null)
{
return;
}
PrefabPool refabPool = new PrefabPool(_childenPrefab);
if (!spawnPool._perPrefabPoolOptions.Contains(refabPool))
{
refabPool = new PrefabPool(_childenPrefab);
//预先实例化个数
refabPool.preloadAmount = 20;
//开启限制
refabPool.limitInstances = true;
//关闭无限取Prefab
refabPool.limitFIFO = false;//如果我们限制了缓存池里面只能有10个Prefab，如果不勾选它，那么你拿第11个的时候就会返回null。如果勾选它在取第11个的时候他会返回给你前10个里最不常用的那个。
//限制池子里最大的Prefab数量
refabPool.limitAmount = 50;
//开启自动清理池子
refabPool.cullDespawned = true;
//最终保留
refabPool.cullAbove = 20;
//多久清理一次
refabPool.cullDelay = 5;
//每次清理几个
refabPool.cullMaxPerPass = 5;
//初始化内存池
spawnPool._perPrefabPoolOptions.Add(refabPool);
//spawnPool.CreatePrefabPool(spawnPool._perPrefabPoolOptions[spawnPool.Count]);
for (int i = 0; i < spawnPool._perPrefabPoolOptions.Count; i++)
{
spawnPool.CreatePrefabPool(spawnPool._perPrefabPoolOptions[i]);
}
}
}
public PrefabPool AddPrefabPool(Transform poolItem)
{
PrefabPool prefabPool = mSpawnPool.GetPrefabPool(poolItem.gameObject);
if (prefabPool != null)
{
return(prefabPool);
}
//TODO SpawnPool Settings...
prefabPool = new PrefabPool(poolItem);
//TODO PrefabPool Settings...
mSpawnPool.CreatePrefabPool(prefabPool);
return(prefabPool);
}
//创建bulletPool
void GenerateBulletPool()
{
bulletSpawnPool = PoolManager.Pools.Create(bulletPool);
bulletSpawnPool.group.parent = transform;
bossBulletInfo = Game.Instance.StaticData.bossBulletList;
foreach (BulletInfo info in bossBulletInfo)
{
PrefabPool prefabPool = new PrefabPool(info.Prefab.transform);
if (info.Prefab.name == "BubbleBossBullet")
{
PoolSetting(prefabPool, 50);
}
bulletSpawnPool.CreatePrefabPool(prefabPool);
}
playerBulletInfo = Game.Instance.StaticData.playerBulletList;
foreach (BulletInfo info in playerBulletInfo)
{
PrefabPool prefabPool = new PrefabPool(info.Prefab.transform);
if (info.Prefab.name == "PlayerBullet")
{
PoolSetting(prefabPool, 30);
}
bulletSpawnPool.CreatePrefabPool(prefabPool);
}
enemyBulletInfo = Game.Instance.StaticData.enemyBulletList;
foreach (BulletInfo info in enemyBulletInfo)
{
PrefabPool prefabPool = new PrefabPool(info.Prefab.transform);
if (info.Prefab.name == "EnemyBubbleMoveBullet")
{
PoolSetting(prefabPool, 50);
}
bulletSpawnPool.CreatePrefabPool(prefabPool);
}
}
// Use this for initialization
void Awake()
{
tf = transform;
headSprRdr = tf.GetComponent <SpriteRenderer>();
_pool = GlobalController.instance.getCurPool();
pp = new PrefabPool(GlobalController.instance.prefabSetting.tail);
_pool.CreatePrefabPool(pp);
pp.preloadAmount = 5;
pp.limitInstances = false;
_tailList = new List <Transform>();
tailIdx = new List <Coord>();
_isDead = false;
}
public PathologicalGames.SpawnPool getCurPool()
{
if (_pool != null)
{
return(_pool);
}
_pool = gameObject.AddComponent <SpawnPool>();
PrefabPool pp = new PrefabPool(GlobalController.instance.prefabSetting.bullet);
_pool.CreatePrefabPool(pp);
pp.preloadAmount = 10;
pp.limitInstances = false;
return(_pool);
}
/// <summary>
/// 播放特效
/// </summary>
/// <param name="effectName"></param>
public void PlayEffect(string effectPath, string effectName, System.Action <Transform> onComplete)
{
if (m_EffectPool == null)
{
return;
}
if (!m_EffectDic.ContainsKey(effectName))
{
AssetBundleMgr.Instance.LoadOrDownload(effectPath + ".assetbundle", effectName,
(GameObject obj) =>
{
if (!m_EffectDic.ContainsKey(effectName))
{
//如果特效没有播放过
m_EffectDic[effectName] = obj.transform;
PrefabPool prefabPool = new PrefabPool(m_EffectDic[effectName]);
prefabPool.preloadAmount = 0; //预加载数量
prefabPool.cullDespawned = true; //是否开启缓存池自动清理模式
prefabPool.cullAbove = 5; // 缓存池自动清理 但是始终保留几个对象不清理
prefabPool.cullDelay = 2; //多长时间清理一次 单位是秒
prefabPool.cullMaxPerPass = 2; //每次清理几个
m_EffectPool.CreatePrefabPool(prefabPool);
if (onComplete != null)
{
onComplete(m_EffectPool.Spawn(m_EffectDic[effectName]));
}
}
else
{
if (onComplete != null)
{
onComplete(m_EffectPool.Spawn(m_EffectDic[effectName]));
}
}
});
}
else
{
if (onComplete != null)
{
onComplete(m_EffectPool.Spawn(m_EffectDic[effectName]));
}
}
}
public void InitPrefabPool(string path, Transform prefab, int preloadAmount = 1, int limitAmount = 50, int cullAbove = 5, int cullMaxPerPass = 5)
{
if (!Contains(path))
{
PrefabPool pool = new PrefabPool(prefab);
pool.name = path;
pool.preloadAmount = preloadAmount; // 预加载个数
pool.limitInstances = true; // 是否限制
pool.limitFIFO = true; // 关闭无限取prefab
pool.limitAmount = limitAmount; // 限制池子里最大的Prefab数量
pool.cullDespawned = true; // 自动清除缓冲池
pool.cullAbove = cullAbove; // 最终保留
pool.cullDelay = 10; // 多久清理一次
pool.cullMaxPerPass = cullMaxPerPass; // 每次清理几个
prefabPool.CreatePrefabPool(pool);
}
}
public static void SingletonPrefabPool(SpawnPool spawnPool, Object obj)
{
GameObject prefab = (GameObject)obj;
PrefabPool prefabPool = new PrefabPool(prefab.transform);
prefabPool.preloadAmount = 1; // default initialize one prefab
prefabPool.limitInstances = false; // open limit
prefabPool.limitFIFO = false; // close infinite clone prefab
prefabPool.limitAmount = 1; // limit max prefab in pool
prefabPool.cullDespawned = true; // open auto despawn mode
prefabPool.cullAbove = 1; // how many prefabs finally keeped
prefabPool.cullDelay = 5; // how long to clean once
prefabPool.cullMaxPerPass = 5; // how many to clean every time
spawnPool._perPrefabPoolOptions.Add(prefabPool);
spawnPool.CreatePrefabPool(prefabPool);
}
static void CreatePoolItem(SpawnPool targetPool, object obj)
{
//Debug.LogWarning("2JW : CreatePoolItem In TargetPool - " + targetPool, targetPool);
if (obj == null)
{
Debug.LogWarning("2JW : CreatePoolItem In obj - " + obj); return;
}
PrefabPool prefabPool = new PrefabPool(((GameObject)obj).transform);
prefabPool.preloadAmount = 1;
prefabPool.AddSpawnCount = 3;
targetPool.CreatePrefabPool(prefabPool, true);
//#if DEBUG
//Debug.Log("CreatePoolItem " + ((GameObject)obj).name);
//#endif
}
