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;
}
private static void BindConnectors(PrefabPool <MapNodesConnector> connectorPool, IEnumerable <IMapNode> selectables)
{
if (connectorPool == null || selectables == null)
{
return;
}
connectorPool.RecycleAll();
IMapNode last = null;
foreach (var selectable in selectables)
{
if (last == null)
{
last = selectable;
continue;
}
var connector = connectorPool.Get();
connector.SetPositions(last.Position, selectable.Position);
connector.SetSelectable(selectable);
last = selectable;
}
}
private void Awake()
{
// Time.timeScale = 0.1f;
gm = Object.FindObjectOfType <GameManager>();
sound = Object.FindObjectOfType <AudioManager>();
linePool = new PrefabPool(linePrefab, board.transform, 5);
}
private void Start()
{
bulletPool = new PrefabPool(bulletPrefab);
// don't shoot right after spawning
cooldown = TimeBetweenShots;
avatar = GetComponent <BaseAvatar>();
}
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);
}
public void Init(Transform scrollRect)
{
root = new GameObject("Pool").transform;
root.SetParent(scrollRect, false);
pool = new PrefabPool(Prefab, PoolSize,
onFree: o => o.transform.SetParent(root, false));
}
private void Awake()
{
mTurret = transform.Find("Turret");
mBase = transform.Find("Base");
mFirePos = mTurret.Find("FirePos");
mBullet = PrefabPool.GetPrefab();
}
//激活相应的怪物
//返回该怪物的transform
public Transform Spawn(Transform trans, Vector3 pos, Quaternion rot)
{
Transform active;
//先查找m_lPrefabPools列表中有没有想要激活的怪物
//有的话调用接口激活这个怪物（DespawnList中有的情况下）或创建该怪物的游戏对象
//没有的话调用接口新建一个PrefabPool，加到m_lPrefabPools中
//创建该怪物的游戏对象，添加到m_lSpawn中
//PrefabPool prefabpool = new PrefabPool(trans);
//m_lPrefabPools.Count == 0 ?
for (int i = 1; i <= m_lPrefabPools.Count; i++)
{
// PrefabPool prefabpool = m_lPrefabPools[i];
if (m_lPrefabPools[i].m_obj == trans.gameObject)
{
active = m_lPrefabPools[i].SpawnInstance(pos, rot);
active.parent = m_Group;//??????????????????????????????????????????????????
return(active);
}
}
PrefabPool pref = new PrefabPool(trans);
m_lPrefabPools.Add(pref);
pref.SpawnNew(pos, rot).parent = m_Group;//????????????????????????????????????????????
return(pref.SpawnNew(pos, rot));
}
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();
}
/// <summary>
/// 预加载模型
/// </summary>
/// <param name="prefab_path"></param>
/// <param name="resourceNameType"></param>
public bool PreloadModel(string prefab_path, FileNameType fileNameType = FileNameType.NONE)
{
if (string.IsNullOrEmpty(prefab_path))
{
Debug.LogError("Effect_name is null");
return(false);
}
string effectprefab_path = FormatFileName(prefab_path, fileNameType);
string realName = GetNameWithRemovePath(effectprefab_path);
if (EffectSpawnPool.GetPrefabPool(realName) == null)
{
PrefabPool prefabPool = GetModelPrefabPool(realName, effectprefab_path, fileNameType);
if (prefabPool == null)
{
return(false);
}
#if UNITY_EDITOR
if (!EffectSpawnPool._perPrefabPoolOptions.Contains(prefabPool))
{
EffectSpawnPool._perPrefabPoolOptions.Add(prefabPool);
}
#endif
EffectSpawnPool.CreatePrefabPool(prefabPool);
}
return(true);
}
void Start()
{
if (fxPrefab)
{
pool = InitPool(fxPrefab);
}
}
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);
}
}
protected override void StartSample()
{
ChromosomesCleanupEnabled = true;
ShowPreviousInfoEnabled = false;
m_brickPool = new PrefabPool(BrickPrefab);
Time.timeScale = TimeScale;
}
/// <summary>
/// 为指定对象创建缓存池
/// </summary>
/// <param name="_pp"></param>
private void CreatePrefabPool(PrefabPool _pp)
{
r1 = _pp;
if (!spawnPool._perPrefabPoolOptions.Contains(r1))
{
//r1 = new PrefabPool(Resources.Load<Transform>("momo"));
//默认初始化5个Prefab实例
r1.preloadAmount = 5;
//开启限制
r1.limitInstances = true;
//关闭无限取Prefab
r1.limitFIFO = true;
//限制池子里最大的Prefab实例数量,这个和preloadAmount是相互冲突的，如果都设置了，那么默认取limitAmount
r1.limitAmount = 5;
//开启自动清理池子
r1.cullDespawned = true;
//缓存池自动清理，但是始终保留几个对象不清理。
r1.cullAbove = 10;
//每过多久执行一遍自动清理，单位是秒
r1.cullDelay = 5;
//每次清理几个
r1.cullMaxPerPass = 5;
//初始化内存池
spawnPool._perPrefabPoolOptions.Add(r1);
}
}
// Use this for initialization
void Start()
{
// Pre-loading
PrefabPool.GetInstance();
MediaPool.GetInstance();
stateController = new StateController("192.168.137.1", 50000);
stateController.SetListener(this);
// wormholeReceiver = new WormholeImageReceiver ();
// wormholeReceiver.SetListener (this);
directorTask = null;
directorTaskLock = new System.Object();
emailSender = new EmailSender();
pageStack = new Stack <Page> ();
pageStack.Push(new MainPage(this));
// pageStack.Push (new DoorNavigationPage (this));
// pageStack.Push (new WebPage (this));
// pageStack.Push (new WormholePage(this));
// pageStack.Push (new EmailInputPage (this));
// pageStack.Push (new EndPage (this));
}
void Awake()
{
startSpeedPercentage = scrollManager.GetSpeedPercentage();
bounds.center = transform.position;
poolManager = FindObjectOfType <PoolManager>();
prefabPool = poolManager.AddPool(objectToEmit);
}
void Start()
{
//方法1 直接在场景物体上挂SpawnPool
spawnPool = PoolManager.Pools["Shapes"];
//方法2 直接代码新建池
refabPool = new PrefabPool(Resources.Load <Transform>("momo"));
}
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);
}
/// <summary>
/// Setup the PrefabPool. Change to test different settings.
/// </summary>
private void Start()
{
this.pool = PoolManager.Pools.Create(this.poolName);
// Make the pool's group a child of this transform for demo purposes
this.pool.group.parent = this.transform;
// Set the pool group's local position for demo purposes
this.pool.group.localPosition = new Vector3(1.5f, 0, 0);
this.pool.group.localRotation = Quaternion.identity;
// Create a prefab pool, set culling options but don't need to pre-load any
// If no options are needed, this can be skipped entirely. Just use spawn()
// and a PrefabPool will be created automatically with defaults
PrefabPool prefabPool = new PrefabPool(testPrefab);
prefabPool.preloadAmount = 5; // This is the default so may be omitted
prefabPool.cullDespawned = true;
prefabPool.cullAbove = 10;
prefabPool.cullDelay = 1;
prefabPool.limitInstances = true;
prefabPool.limitAmount = 5;
prefabPool.limitFIFO = true;
this.pool.CreatePrefabPool(prefabPool);
this.StartCoroutine(Spawner());
// NEW EXAMPLE... Preabs[] dict
// In the Shapes pool, we know we have a prefab "Cube". This example uses
// just this name to get a reference to the prefab and spawn an instance
Transform cubePrefab = PoolManager.Pools["Shapes"].prefabs["Cube"];
Transform cubeinstance = PoolManager.Pools["Shapes"].Spawn(cubePrefab);
cubeinstance.name = "Cube (Spawned By CreationExample.cs)"; // So we can see it.
}
private void Loaded()
{
PlayerCount = Settings.PlayerCount;
NoBlood = Settings.NoBlood;
UseMouse = Settings.IsMouse;
GodMode = Settings.GodMode;
Shaker = Camera.GetComponent <CameraShaker>();
//SplashText("Level " + Level + "!", Color.yellow);
LevelSlider.maxValue = 1;
HpSlider.maxValue = MaxHp;
ManaSlider.maxValue = MaxMana;
HpRegenSpeed += 0.5f;
ManaSpendSpeed--;
FireCoolDown -= 0.02f;
BulletPool = new PrefabPool <Bullet>(BulletPrefabPath);
EnemyPool = new PrefabPool <Enemy>(EnemyPrefabPath);
CurrentHp = MaxHp;
CurrentMana = MaxMana;
LevelSlider.maxValue = NextScore;
Lose = false;
_skillCoolDown = 0;
if (PlayerCount == 1)
{
Player2.gameObject.SetActive(false);
SecondPanel.gameObject.SetActive(false);
}
Shaker.ShakeOnce(4f, 3f, 2f, 2f);
}
//设置EnemyPool各项参数
void PoolSetting(PrefabPool pool, int count)
{
pool.preloadAmount = count;
pool.cullDespawned = false;
pool.limitInstances = false;
pool.limitFIFO = false;
}
//创建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);
}
}
}
protected virtual void Start()
{
canAttack = false;
canMove = false;
view = GetComponent <PhotonView>();
canvas = GameObject.FindGameObjectWithTag("MenuCanvas").GetComponent <GameCanvas>();
lifelinkParticle = Instantiate(particleLL, transform, true);
lifelinkParticle.transform.localPosition = new Vector3(0, -0.2f, 0);
if (view.isMine)
{
pool = GameObject.FindGameObjectWithTag("PrefabPool").GetComponent <PrefabPool>();
cam.SetActive(true);
canvasPlayer.gameObject.SetActive(true);
menu = Instantiate(escMenuPrefab).GetComponent <EscMenu>();
menu.gameObject.transform.SetParent(canvasPlayer.transform, false);
menu.gameObject.SetActive(false);
menu.p = this;
string val = "0/" + maxUltCharges.ToString();
canvas.GetComponent <PhotonView>().RPC("RPC_SetStats", PhotonTargets.All, 3, val, teamOn, playerNum);
try
{
grabHitbox.gameObject.SetActive(true);
grabHitbox.teamOn = teamOn;
}
catch
{
//must be Bunt.
}
}
}
public PrefabPool AddPool(GameObject prefab)
{
PrefabPool poolToAdd = new PrefabPool(prefab, defaultPoolSize, this, expandableByDefault);
_poolDictionary.Add(prefab, poolToAdd);
return(poolToAdd);
}
/// <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);
}
/// <summary>
/// Add a pool of the specified GameObject (if one doesn't exist)
/// </summary>
private void AddPool(GameObject go)
{
var newPrefabPool = new PrefabPool();
if (PoolCollection == null)
{
PoolCollection = new List <PrefabPool>();
}
if (PoolCollection != null)
{
foreach (PrefabPool pp in PoolCollection)
{
if (pp.Prefab.gameObject.name == go.name)
{
EditorUtility.DisplayDialog("Pool Manager",
"<PoolManager> already manages a GameObject with the name '" + go.name +
"'.\n\nIf you are attempting to manage multiple GameObjects sharing the same name, you will need to first give them unique names.",
"OK");
return;
}
}
}
newPrefabPool.Prefab = go.GetComponent <PoolObject>();
PoolCollection.Add(newPrefabPool);
while (PoolCollection.Count > PrefabFoldouts.Count)
{
PrefabFoldouts.Add(false);
}
}
public Transform Spawn(Transform tra, Vector3 pos, Quaternion rot)
{
//1.先判断当前m_PrefabPools列表是否大于零,否的话（即等于零，当前列表为空，当前场景中从未创建任何游戏对象的对象池）
////新建一个当前要创建的游戏对象的PrefabPool,将其添加到m_lPrefabPools列表，将其父对象设为m_Group，
//2.转到SpawnNew
//3.大于零，开始for循环查找当前列表中是否有想要创建的游戏对象的PrefabPool（tra.gameobject == m_lPrefabPools[i].obj）
// 没有的话执行2
//4.有的话，转到SpawnInstance
if (null == m_lPrefabPools)
{
Debug.Log("需要初始化");
}
if (m_lPrefabPools.Count > 0)
{
for (int i = 1; i <= m_lPrefabPools.Count; i++)
{
if (m_lPrefabPools[i].obj == tra.gameObject)
{
return(m_lPrefabPools[i].SpawnInstance(pos, rot));
}
}
}
Debug.Log("开始进入New PrefabPool");
//return NewPrefabPool(tra,pos,rot);
PrefabPool prefabpool = new PrefabPool(tra, this);
m_lPrefabPools.Add(prefabpool);
//prefabpool.sp = this;
//prefabpool.SpawnNew(pos, rot).parent = m_Group;
return(prefabpool.SpawnNew(pos, rot));
}
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 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);
}
// Use this for initialization
void Start()
{
if (instance != null)
{
Destroy(gameObject);
}
instance = this;
DontDestroyOnLoad(gameObject);
//mainBundle = AssetBundle.LoadFromFile ("AssetBundles/AssetBundles");
//Debug.Log (mainBundle.name);
//string log = "";
// foreach (string name in mainBundle.GetAllAssetNames()) {
// log += name + " ";
//}
//mainManifest = (AssetBundleManifest) mainBundle.LoadAllAssets()[0];
//Debug.Log (log);
//foreach (string name in mainManifest.GetAllAssetBundles ()) {
// log += name + " ";
//}
// Debug.Log (log);
baseBundle = AssetBundle.LoadFromFile("AssetBundles/base");
foreach (GameObject obj in baseBundle.LoadAllAssets <GameObject>())
{
Debug.Log(obj.name);
prefabs.Add(obj.name, obj);
}
}
// Token: 0x06000867 RID: 2151
public static void ForceMemoryCleanUp()
{
foreach (SpawnPool spawnPool in UnityEngine.Object.FindObjectsOfType(typeof(SpawnPool)) as SpawnPool[])
{
for (int i = spawnPool._prefabPools.Count - 1; i >= 0; i--)
{
PrefabPool prefabPool = spawnPool._prefabPools[i];
int j = 0;
int count = prefabPool.despawned.Count;
while (j < count)
{
if (prefabPool.despawned[j] != null)
{
UnityEngine.Object.Destroy(prefabPool.despawned[j].gameObject);
}
j++;
}
prefabPool._despawned.Clear();
if (prefabPool.spawned.Count <= 0)
{
spawnPool.prefabs._prefabs.Remove(prefabPool.prefab.name);
spawnPool._prefabPools.RemoveAt(i);
}
}
}
RsResourceManager.UnloadUnusedAssets(true);
}
public Transform Spawn(Transform prefab, Vector3 pos, Quaternion rot)
{
int i = 0;
Transform transform;
while (i < this._prefabPools.Count)
{
PrefabPool prefabPool = this._prefabPools[i];
if (prefabPool.prefabGO == prefab.gameObject)
{
transform = prefabPool.SpawnInstance(pos, rot);
if (transform == null)
{
return(null);
}
if (transform.parent != this.group)
{
transform.parent = this.group;
}
this.spawned.Add(transform);
return(transform);
}
else
{
i++;
}
}
PrefabPool prefabPool2 = new PrefabPool(prefab);
this.CreatePrefabPool(prefabPool2);
transform = prefabPool2.SpawnInstance(pos, rot);
transform.parent = this.group;
this.spawned.Add(transform);
return(transform);
}
public static void CreatePrefab(string poolName, string prefabPath, int preload, int cullAbove) {
PrefabPool prefabPool = new PrefabPool((Resources.Load(prefabPath) as GameObject).transform);
prefabPool.preloadAmount = preload; // This is the default so may be omitted
// prefabPool.cullDespawned = false;
prefabPool.cullAbove = cullAbove;
prefabPool.cullDelay = 1;
// prefabPool.limitInstances = false; // This is the default so may be omitted
// prefabPool.limitAmount = 20; // This is the default so may be omitted
PoolManager.Pools[poolName].CreatePrefabPool(prefabPool);
}
public static void CreatePrefab(string poolName, Transform obj, int preload, int cullAbove) {
PrefabPool prefabPool = new PrefabPool(obj);
prefabPool.preloadAmount = preload; // This is the default so may be omitted
// prefabPool.cullDespawned = false;
prefabPool.cullAbove = cullAbove;
prefabPool.cullDelay = 1;
// prefabPool.limitInstances = false; // This is the default so may be omitted
// prefabPool.limitAmount = 20; // This is the default so may be omitted
PoolManager.Pools[poolName].CreatePrefabPool(prefabPool);
}
/// <summary>
/// This is used by Spawner.cs, You should never need to access this.
/// This is only used when Pool Manager is present.
/// </summary>
/// <param name="prefab">The Prefab to start pooling.</param>
/// <param name="amount">The number of prefabs to pool.</param>
public static void ReadyPreSpawn(Transform prefab, int amount)
{
#if POOLMANAGER_INSTALLED
if (!PoolManager.Pools.ContainsKey(poolName))
(new GameObject(poolName)).AddComponent<SpawnPool>();
PrefabPool item = new PrefabPool(prefab);
item.preloadAmount = amount;
PoolManager.Pools[poolName].CreatePrefabPool(item);
#endif
}
void Start() {
if (spawnFromPool) {
PrefabPool[] pools = FindObjectsOfType<PrefabPool>();
foreach (PrefabPool p in pools) {
if (p.identifier == prefabPoolIdentifier) {
pool = p;
break;
}
}
if (pool == null) {
Debug.LogError("No prefab pool found with identifier " + prefabPoolIdentifier);
this.enabled = false;
}
} else if (spawnOnCollision == null) {
Debug.LogError("No prefab selected");
this.enabled = false;
}
source = GetComponent<AudioSource>();
score = FindObjectOfType<ScoreTracker>();
}
public void AddPrefabToPool(Transform prefab)
{
//if(characterManager.MakeSpawnPool())
//{
if(ownerManager.effectsPool != null)
ownerManager.MakeSpawnPool();
if(ownerManager.effectsPool.GetPrefabPool(prefab) == null)
{
PrefabPool prefabPool = new PrefabPool(prefab);;
prefabPool.preloadAmount = 1;
prefabPool.preloadFrames = 5;
ownerManager.effectsPool.CreatePrefabPool(prefabPool);
}
}
private void InitPrefabPool(Transform prefab)
{
PrefabPool prefabPool = new PrefabPool(prefab);
prefabPool.cullAbove = 5;
prefabPool.cullDelay = 10;
prefabPool.cullMaxPerPass = 10;
prefabPool.cullDespawned = true;
PoolManager.Pools["misc"].CreatePrefabPool(prefabPool);
}
/// <summary>
/// Add a pool of the specified GameObject (if one doesn't exist)
/// </summary>
private void AddPool(GameObject go)
{
PrefabPool newPrefabPool = new PrefabPool();
if (PoolCollection == null)
PoolCollection = new List<PrefabPool>();
if (PoolCollection != null)
foreach (PrefabPool pp in PoolCollection)
if (pp.Prefab.gameObject.name == go.name)
{
EditorUtility.DisplayDialog("Pool Manager", "<PoolManager> already manages a GameObject with the name '" + go.name + "'.\n\nIf you are attempting to manage multiple GameObjects sharing the same name, you will need to first give them unique names.", "OK");
return;
}
newPrefabPool.Prefab = go.GetComponent<PoolObject>();
PoolCollection.Add(newPrefabPool);
while(PoolCollection.Count > PrefabFoldouts.Count)
PrefabFoldouts.Add(false);
}
public static void CreatePrefabPool(string prefabName, int preloadAmount = 1, int cullAbove = 5)
{
if (PoolMgr.spawnPoolByName == null)
{
global::Debug.Log(new object[]
{
"spawnPoolByName is not created!"
});
return;
}
if (PoolMgr.spawnPoolByName.prefabs.ContainsKey(prefabName))
{
return;
}
GameObject gameObject = Res.Load<GameObject>(prefabName, false);
if (gameObject == null)
{
global::Debug.LogError(new object[]
{
string.Format("Res.Load error, name = {0}", prefabName)
});
return;
}
PrefabPool prefabPool = new PrefabPool(gameObject.transform);
prefabPool.name = prefabName;
prefabPool.preloadAmount = preloadAmount;
prefabPool.cullDespawned = true;
prefabPool.cullAbove = cullAbove;
prefabPool.cullDelay = 3;
prefabPool._logMessages = false;
PoolMgr.spawnPoolByName.CreatePrefabPool(prefabPool);
}
//*************************************************************//
void Awake ()
{
putAditionalSolidObjectsToTheElementsArray ();
_backgroundTextures = new List < Texture2D > ();
object[] textureObjects = Resources.LoadAll ( "Textures/Background", typeof ( Texture2D ));
foreach ( object textureObject in textureObjects )
{
if ( textureObject is Texture2D )
{
_backgroundTextures.Add (( Texture2D ) textureObject );
}
}
_currentSpecifcLevelData = new SpecificLevelData ();
levelGrid = new int[NUMBER_OF_LAYERS][][];
gameElementsOnLevel = new GameObject[NUMBER_OF_LAYERS][][];
charactersOnLevel = new List < CharacterData > ();
enemiesOnLevel= new List < MNEnemyComponent > ();
redirectorsOnLevel = new List < RedirectorComponent > ();
for ( int i = 0; i < NUMBER_OF_LAYERS; i++ )
{
levelGrid[i] = new int[LEVEL_WIDTH * 20][];
gameElementsOnLevel[i] = new GameObject[LEVEL_WIDTH * 20][];
for ( int j = 0; j < LEVEL_WIDTH * 20; j++ )
{
levelGrid[i][j] = new int[LEVEL_HEIGHT];
gameElementsOnLevel[i][j] = new GameObject[LEVEL_HEIGHT];
}
}
_tileInteractivePrefab = ( GameObject ) Resources.Load ( "Tile/tileInteractive" );
_tileInteractiveTrolleyPrefab = ( GameObject ) Resources.Load ( "Tile/tileInteractiveTrolley" );
_tileInteractivePrefab3x1 = ( GameObject ) Resources.Load ( "Tile/tileInteractive3x1" );
_tileInteractivePrefabPool = PrefabPool.GetPool ("_tileInteractivePrefab");
_slugPrefabPool = PrefabPool.GetPool ("_slugPrefab");
loadLevel ();
}
public static void CreatePrefabPool(Transform prefab, int preloadAmount = 2, int cullAbove = 5)
{
if (PoolMgr.spawnPool == null)
{
global::Debug.Log(new object[]
{
"spawnPool is not created!"
});
return;
}
PrefabPool prefabPool = PoolMgr.spawnPool.GetPrefabPool(prefab);
if (prefabPool != null)
{
return;
}
prefabPool = new PrefabPool(prefab);
prefabPool.preloadAmount = preloadAmount;
prefabPool.cullDespawned = true;
prefabPool.cullAbove = cullAbove;
prefabPool.cullDelay = 3;
prefabPool._logMessages = false;
PoolMgr.spawnPool.CreatePrefabPool(prefabPool);
}
public void OnInit(string tag, Component who)
{
Global.AssetLoadManager.LoadAsset<GameObject>("prefab/" + tag, tag, (prefab) =>
{
GameObject go = GameObject.Instantiate(prefab) as GameObject;
if (go == null) return;
entity = go;
entity.name = tag;
pool = who as PrefabPool;
//判断类型， 后期类型多了后，会改条件
particle = entity.GetComponentInChildren<ParticleSystem>();
Reset();
if (callback != null) callback(this);
});
}
