private IEnumerator SpawnEnemyCluster()
{
spwanDone = false;
for (int i = 0; i < waves[currentWave].monsterList.Count; i++)
{
for (int j = 0; j < waves[currentWave].monsterList[i].Count; j++)
{
float spawnDelay = waves[currentWave].spawnEffectTime;
GameObject spawnEffect = ObjectPool.Instance.GetObject(PoolObjectType.VFXEnemySpawn);
Vector3 spawnPosition = spawnPoints.GetRandom().position;
if (spawnEffect)
{
spawnEffect.GetComponent <VFXOneOff>().Play(spawnDelay);
spawnEffect.transform.position = spawnPosition;
}
PoolObjectType enemy = waves[currentWave].monsterList[i].Type.ToPoolObject();
SpawnEnemy(spawnPosition, enemy);
yield return(new WaitForSeconds(1.0f));
//Timing.RunCoroutine(DelayAction(() => SpawnEnemy(spawnPosition, enemy), spawnDelay), coroutineName);
}
}
spwanDone = true;
// currentWave++;
}
public static PoolObject InstantiatePrefab(PoolObjectType objType)
{
GameObject obj = null;
switch (objType)
{
case PoolObjectType.ATTACKINFO:
{
obj = Instantiate(Resources.Load("AttackInfo", typeof(GameObject)) as GameObject);
break;
}
case PoolObjectType.PUTTER:
{
obj = Instantiate(Resources.Load("Putter", typeof(GameObject)) as GameObject);
break;
}
case PoolObjectType.PUTTER_VFX:
{
obj = Instantiate(Resources.Load("orbShatter", typeof(GameObject)) as GameObject);
break;
}
}
return(obj.GetComponent <PoolObject>());
}
public PooledObject SpawnFromPool(PoolObjectType tag, Vector3 pos = default, Quaternion rot = default, GameObject parent = null)
{
if (!PoolDictionary.ContainsKey(tag))
{
Debug.Log("PoolObjects with Tag " + tag + " doesn't exist ..");
return(null);
}
PooledObject objToSpawn;
if (PoolDictionary[tag].Count != 0)
{
objToSpawn = PoolDictionary[tag].Peek();
objToSpawn.gameObject.SetActive(true);
var transform1 = objToSpawn.transform;
transform1.position = pos;
transform1.rotation = rot;
objToSpawn.Init();
objToSpawn.OnObjectSpawn();
PoolDictionary[tag].Dequeue();
}
else
{
objToSpawn = ExpandPool(tag, pos, rot);
}
if (parent)
{
objToSpawn.transform.SetParent(parent.transform);
}
return(objToSpawn);
}
public T GetFromPool <T>(PoolObjectType type, Vector3 position, Vector3 rotation) where T : class
{
if (!_pool.ContainsKey(type))
{
return(null);
}
GameObject gameObject;
if (_pool[type].Count == 0)
{
var poolObjectSetting = _poolObjectsSetting.FirstOrDefault(p => p.Type == type);
gameObject = InstantiatePoolableObject(poolObjectSetting.Prefab).gameObject;
}
else
{
gameObject = _pool[type][0];
_pool[type].RemoveAt(0);
}
gameObject.SetActive(true);
gameObject.transform.position = position;
gameObject.transform.parent = null;
gameObject.transform.rotation = Quaternion.Euler(rotation);
return(gameObject.GetComponent <T>());
}
private BoomerangBullet SpawnBullet()
{
BoomerangBullet boomerangBullet = null;
PoolObjectType poolObjType = PoolObjectType.BoomerangProjectile;
GameObject boomerangObject = ObjectPool.Instance.GetObject(poolObjType);
if (boomerangObject)
{
boomerangBullet = boomerangObject.GetComponent <BoomerangBullet>();
if (boomerangBullet)
{
boomerangBullet.transform.position = bulletSpawnPoint.position;
boomerangBullet.transform.forward = transform.forward;
boomerangBullet.transform.rotation = Quaternion.Euler(0f, boomerangBullet.transform.rotation.eulerAngles.y, 0f);
boomerangBullet.Initialize(boomerangSpeed, damage, timeUntilBoomerangDestroyed, rayDistanceMultiplier, raycastLayermask, maxDistance, maxBounces);
if (wielderStats.gameObject.CompareTag(Strings.Tags.PLAYER))
{
boomerangBullet.SetShooterType(false);
}
else
{
boomerangBullet.SetShooterType(true);
}
}
}
return(boomerangBullet);
}
public Pool(ref List <GameObject> prefabs, PoolObjectType poolObjectType, int size)
{
this.objects = new List <GameObject>();
this.prefabs = prefabs;
this.size = size;
this.poolObjectType = poolObjectType;
}
/// <summary>
/// 播放环境特效和音效
/// </summary>
public static void PlayEnvironmentEffect(int chair, PoolObjectType effectType)
{
//播放特效
GameCenter.Scene.PlayPlayerEffect(chair, effectType);
//播放特效声音
PlayEnvironmentSound(effectType.ToString());
}
public Pool(ref List <GameObject> prefabs, PoolObjectType poolObjectType, int size)
{
this.prefabs = prefabs;
this.size = size;
this.poolObjectType = poolObjectType;
this.name = poolObjectType.ToString();
}
/// <summary>
/// 播发特效
/// </summary>
public static EffectObject PlayMahjongEffect(PoolObjectType effectType)
{
string name = effectType.ToString();
return(GameCenter.Pools.GetPool <ObjectPoolComponent>(PoolUitlity.Po_EffectObject)
.Pop <EffectObject>(EffectObject.AssetsNamePrefix + name, (go) => { return go.Type == effectType; }));
}
public void DestroyPool(PoolObjectType objectType, GameObject gO)
{
gO.SetActive(false);
_objectPool[objectType].Enqueue(gO);
gO.transform.position = Vector3.zero;
gO.transform.rotation = Quaternion.identity;
}
public PooledObject GetPooledObject(PoolObjectType objectType)
{
PooledObject pooledObject = null;
bool didFindObject = false;
for (int i = 0; i < pooledObjects.Count; i++)
{
PooledObject obj = pooledObjects[i];
if (obj.objectType == objectType)
{
pooledObject = obj;
//pooledObject.isActive = true;
RemovePooledObject(pooledObject);
didFindObject = true;
break;
}
}
if (!didFindObject)
{
pooledObject = CreatePrefab(objectType);
//pooledObject.isActive = true;
}
//Debug.Log("Get object from pool");
return(pooledObject);
}
public static PoolObject InstantiatePrefab(PoolObjectType objType)
{
GameObject obj = null;
switch (objType)
{
case PoolObjectType.ATTACKINFO:
{
obj = Instantiate(Resources.Load("AttackInfo", typeof(GameObject)) as GameObject);
break;
}
case PoolObjectType.HAMMER_OBJ:
{
obj = Instantiate(Resources.Load("ThorHammer", typeof(GameObject)) as GameObject);
break;
}
case PoolObjectType.HAMMER_VFX:
{
obj = Instantiate(Resources.Load("VFX_HammerDown", typeof(GameObject)) as GameObject);
break;
}
case PoolObjectType.DAMAGE_WHITE_VFX:
{
obj = Instantiate(Resources.Load("VFX_Damage_White", typeof(GameObject)) as GameObject);
break;
}
}
return(obj.GetComponent <PoolObject>());
}
private void CreateObjectsOnAwake(PoolObjectType objectType, int numObjects)
{
for (int i = 0; i < numObjects; i++)
{
var obj = CreatePrefab(objectType);
AddPooledObject(obj);
}
}
public void InitBullet(PoolObjectType type, int iDamage, Transform firePoint, float force)
{
_type = type;
Damage = iDamage;
GetComponent <Rigidbody2D>().AddForce(firePoint.up * -force, ForceMode2D.Impulse);
_animator = GetComponent <Animator>();
Cooling();
}
public void SpawnFromPool(PoolObjectType objectType, Vector3 spawnPos, Quaternion rotation)
{
GameObject gO = _objectPool[objectType].Dequeue();
gO.transform.position = spawnPos;
gO.transform.rotation = rotation;
gO.SetActive(true);
}
public void ReturnToPool(PoolObjectType type, GameObject gameObject)
{
if (!_pool.ContainsKey(type))
{
return;
}
_pool[type].Add(gameObject);
}
public static PoolObject InstantiatePrefab(PoolObjectType objType)
{
GameObject obj = null;
switch (objType)
{
case PoolObjectType.ATTACKINFO:
{
obj = Instantiate(Resources.Load("AttackInfo", typeof(GameObject)) as GameObject);
break;
}
case PoolObjectType.LADLE:
{
obj = Instantiate(Resources.Load("Ladle", typeof(GameObject)) as GameObject);
break;
}
case PoolObjectType.BOWL:
{
obj = Instantiate(Resources.Load("Bowl", typeof(GameObject)) as GameObject);
break;
}
case PoolObjectType.BOMB:
{
obj = Instantiate(Resources.Load("Bomb", typeof(GameObject)) as GameObject);
break;
}
case PoolObjectType.BELLYFLOP_VFX:
{
obj = Instantiate(Resources.Load("VFX_HammerDown", typeof(GameObject)) as GameObject);
break;
}
case PoolObjectType.FIREBALL:
{
obj = Instantiate(Resources.Load("Fireball", typeof(GameObject)) as GameObject);
break;
}
case PoolObjectType.RIFLE:
{
obj = Instantiate(Resources.Load("RIFLE", typeof(GameObject)) as GameObject);
break;
}
case PoolObjectType.CORK:
{
obj = Instantiate(Resources.Load("CORK", typeof(GameObject)) as GameObject);
break;
}
}
return(obj.GetComponent <PoolObject>());
}
private void SpawnPoolObjectAtCurrentPosition(PoolObjectType poolObject)
{
GameObject effect = ObjectPool.Instance.GetObject(poolObject);
if (effect)
{
effect.transform.position = transform.position;
}
}
public GameObject SpawnFromPool(PoolObjectType objectType, Vector3 spawnPosition, Quaternion rotation)
{
GameObject spawnedGMO = _objectPool[objectType].Dequeue();
spawnedGMO.SetActive(true);
spawnedGMO.transform.position = spawnPosition;
spawnedGMO.transform.rotation = rotation;
return(spawnedGMO);
}
private IEnumerator GenerateRoutine_Weapon(PoolObjectType type)
{
GameObject ob = GetPoolObject(type);
ob.transform.position = new Vector2(UnityEngine.Random.Range(-2.0f, 2.0f), UnityEngine.Random.Range(-3, 3));
ob.gameObject.SetActive(true);
yield return(new WaitForSeconds(2.0f));
CoolObject(ob, type);
}
private void GenerateBullets(PoolObjectType type, Quaternion[] spreadAngle)
{
obs = new GameObject[weaponData.NumberOfBullets];
for (int i = 0; i < weaponData.NumberOfBullets; i++)
{
newVecs[i] = spreadAngle[i] * firePoint.forward;
obs[i] = PoolManager.instance.GetPoolObject(type);
obs[i].GetComponent <Bullet>().SetDirection(newVecs[i]);
obs[i].transform.position = firePoint.position;
obs[i].gameObject.SetActive(true);
}
}
private PoolInfo GetPoolByType(PoolObjectType type)
{
for (int i = 0; i < listOfPool.Count; i++)
{
if (type == listOfPool[i].type)
{
return(listOfPool[i]);
}
}
return(null);
}
public void CollObject(GameObject ob, PoolObjectType type)
{
ob.SetActive(false);
ob.transform.position = defaultPos;
PoolInfo selected = GetPoolByType(type);
List <GameObject> pool = selected.pool;
if (!pool.Contains(ob))
{
pool.Add(ob);
}
}
public GameObject GetObject(PoolObjectType poolObject)
{
Pool currentPool = pools.Find(pool => pool.poolObjectType == poolObject);
if (currentPool != null)
{
return(currentPool.GetObject());
}
string debugMessage = "No object found. Create a pool for this object";
Debug.LogFormat("<color=#ffff00>" + debugMessage + "</color>");
return(null);
}
public void Despawn(PooledObject obj)
{
PoolObjectType tag = obj.GetComponent <IPooledObject>().PoolType;
if (PoolDictionary.ContainsKey(tag))
{
PoolDictionary[tag].Enqueue(obj);
obj.OnObjectDespawn();
obj.gameObject.SetActive(false);
}
else
{
Debug.LogError("Trying to despawn object which is not pooled !");
}
}
/// <summary>
/// CPG等特效和声音
/// </summary>
/// <param name="chair">座位号</param>
/// <param name="effectType">特效对象</param>
/// <param name="music">特效声音</param>
public static void PlayOperateEffect(int chair, PoolObjectType effectType)
{
MahjongUserInfo data = GameCenter.DataCenter.Players[chair];
string sound = Sex(data.SexI);
string source = sound;
if (LanguageVoice == (int)CtrlSwitchType.Close)
{
source = GameKey + sound;
}
//播放特效
GameCenter.Hud.UIPanelController.PlayPlayerUIEffect(chair, effectType);
//播放特效声音
PlaySound(sound + "_" + effectType.ToString(), source);
}
private void CoolPool(PoolObjectType type)
{
var selected = GetPoolByType(type);
var container = selected.container.transform;
for (var i = 0; i < container.childCount; i++)
{
if (!container.GetChild(i))
{
return;
}
var ob = container.GetChild(i).gameObject;
CoolObject(ob, type);
}
}
private void AddToPool(PoolObjectType type, int count = 1)
{
for (int i = 0; i < count; i++)
{
GameObject g = Instantiate(poolDictionary[type].Prefab, transform);
PoolObject poolObject = g.GetComponent <PoolObject>();
if (poolObject == null)
{
Debug.LogWarning("Expecting PoolObject component on " + type);
continue;
}
poolObject.Type = type;
g.transform.SetParent(poolDictionary[type].Container.transform);
ReturnToPool(type, g);
}
}
public MonoBehaviour getRandomPoolObjectByType(PoolObjectType _poolObjectType)
{
List <int> _indexes = new List <int>();
for (int i = 0; i < _poolObjects.Length; i++)
{
if (_poolObjects[i].poolObject.poolObjectType == _poolObjectType)
{
_indexes.Add(i);
}
}
int _finalIndex = _indexes[Random.Range(0, _indexes.Count)];
return(getPoolObjectByIndex(_finalIndex));
}
//public void RemovePooledObject(P)
private PooledObject CreatePrefab(PoolObjectType objType)
{
PooledObject obj = null;
switch (objType)
{
case PoolObjectType.LIGHT_FRAGMENT:
obj = Instantiate(lightFragPrefab).GetComponent <PooledObject>();
break;
case PoolObjectType.ITEM_HIGHLIGHT:
obj = Instantiate(itemHighlightPrefab).GetComponent <PooledObject>();
break;
}
return(obj);
}
