public void returnItemToStack(string tag, returnableObject returnable)
{
if (returnable.gameObject.activeSelf)
{
ObjectPooling.instance.addToPool(tag, returnable);
}
}
//TODO: Make rotation not so severe
//Throws item, since enemy use different versions this is virtual
public virtual void throwItem(string tag, bool flipThrowableX = false)
{
returnableObject throwable = ObjectPooling.instance.SpawnFromPool(tag, throwHolder.transform.position, Quaternion.identity, true, true, transform.localScale.x);
Transform throwableTrans = throwable.gameObject.transform;
throwableTrans.DOMove(new Vector3(transform.position.x + (enemyRangedRange * transform.localScale.x), Target.position.y, transform.position.z), throwSpeed).OnComplete(() => returnItemToStack(tag, throwable));
}
private void Sets()
{
canAttack = false;
currentTrigger = TriggerStates.None;
animEvents.SetAgent(agent);
me = new returnableObject(gameObject, GetComponent <Rigidbody>(), GetComponent <NavMeshAgent>());
}
private void Awake()
{
player = PlayerManager.instance.Player.GetComponent <PlayerController>();
if (me == null)
{
me = new returnableObject(gameObject, null, null);
}
}
private void ReturnToPool()
{
if (me == null)
{
me = new returnableObject(gameObject, null, null);
}
ObjectPooling.instance.addToPool(poolTag, me);
}
private void Start()
{
poolDictionary = new Dictionary <string, Queue <returnableObject> >();
CreateParent();
Transform sceneParentTransform = sceneParent.transform;
foreach (Pool pool in pools)
{
Queue <returnableObject> objectPool = new Queue <returnableObject>();
for (int i = 0; i < pool.size; i++)
{
GameObject obj = Instantiate(pool.prefab, sceneParentTransform);
Rigidbody rb = null;
NavMeshAgent agent = null;
if (pool.getRigidBody)
{
rb = obj.GetComponent <Rigidbody>();
}
if (pool.getAgent)
{
agent = obj.GetComponent <NavMeshAgent>();
}
returnableObject ourReturnable = new returnableObject(obj, rb, agent);
if (pool.setreturnable)
{
if (obj.CompareTag("Enemy"))
{
obj.GetComponent <Enemy>().me = ourReturnable;
}
else if (obj.CompareTag("Coin"))
{
obj.GetComponent <PickUpCoin>().me = ourReturnable;
}
else if (obj.CompareTag("Ranged"))
{
obj.GetComponent <SlimeBall>().me = ourReturnable;
}
else if (obj.CompareTag("Food"))
{
obj.GetComponent <PickUpFood>().me = ourReturnable;
}
else if (obj.CompareTag("Throwable"))
{
obj.GetComponent <ThrowableObject>().me = ourReturnable;
}
else if (obj.CompareTag("HomingMissle"))
{
obj.GetComponent <HomingMissle>().me = ourReturnable;
}
}
obj.SetActive(false);
objectPool.Enqueue(ourReturnable);
}
poolDictionary.Add(pool.tag, objectPool);
}
}
private void Awake()
{
Target = PlayerManager.instance.Player.transform;
targetCont = Target.GetComponent <PlayerController>();
if (me == null)
{
me = new returnableObject(gameObject, null, null);
}
}
public override void throwItem(string tag, bool flipThrowableX = false)
{
float Rand = Random.Range(transform.position.z - .5f, transform.position.z + .5f);
returnableObject throwable = ObjectPooling.instance.SpawnFromPool(tag, throwHolder.transform.position, Quaternion.identity, true, true, transform.localScale.x);
Transform throwableTrans = throwable.gameObject.transform;
throwableTrans.DOMove(new Vector3(transform.position.x + (enemyRangedRange * transform.localScale.x), Target.position.y, Rand), 1).OnComplete(() => returnItemToStack(tag, throwable));
//anim.SetInteger(stateHash, 0);
}
private void attackTree()
{
if (!hit)
{
hit = true;
returnableObject item = ObjectPooling.instance.SpawnFromPool(dropTag, itemHeight, Quaternion.identity, true);
StartCoroutine(falling(item.gameObject.transform));
}
}
//Change to using Initialize in the future
public override void Activate()
{
thrownPrefab = ObjectPooling.instance.SpawnFromPool("Grenade", player.position, Quaternion.identity, false);
trans = thrownPrefab.gameObject.transform;
Vector3 throwDis = trans.position;
throwDis.x += 3 * player.localScale.x;
throwDis.y += .2f;
trans.DOJump(throwDis, 3, 1, 1).OnComplete(explode);
}
public void addToPool(string tag, returnableObject objToAdd)
{
if (!poolDictionary.ContainsKey(tag))
{
Debug.LogWarning("Pool with tag " + tag + " Doesn't exist");
return;
}
poolDictionary[tag].Enqueue(objToAdd);
objToAdd.gameObject.SetActive(false);
}
public override void throwItem(string tag, bool flipThrowableX = false)
{
for (int i = 3; i < 6; i++)
{
float angle = i * Mathf.PI * 2f / 8;
Vector3 anglePos = new Vector3(Mathf.Cos(angle) * enemyRangedRange * transform.localScale.x * (-1), 0, Mathf.Sin(angle) * enemyRangedRange * transform.localScale.x * (-1));
returnableObject throwable = ObjectPooling.instance.SpawnFromPool(tag, throwHolder.transform.position, Quaternion.identity, true, true, transform.localScale.x);
Transform throwableTrans = throwable.gameObject.transform;
throwableTrans.DOMove(throwHolder.transform.position + anglePos, 1).OnComplete(() => returnItemToStack(tag, throwable));
}
}
private void Awake()
{
if (me == null)
{
me = new returnableObject(gameObject, GetComponent <Rigidbody>(), null);
}
stats = PlayerManager.instance.Player.GetComponent <PlayerController>().myStats;
myCol = GetComponent <Collider>();
ballSprite = transform.GetChild(0).GetComponent <SpriteRenderer>();
splatSprite = transform.GetChild(1).GetComponent <SpriteRenderer>();
}
public void OnTriggerEnter(Collider other)
{
if (other.CompareTag("Player"))
{
if (me == null)
{
me = new returnableObject(gameObject, null, null);
}
player.AddHealth(Mathf.Ceil(player.myStats.maxHealth * healthPercent));
ObjectPooling.instance.addToPool(poolTag, me);
}
}
private void Update()
{
if (compareTime > time)
{
if (me == null)
{
me = new returnableObject(gameObject, null, null);
}
ObjectPooling.instance.addToPool(poolTag, me);
}
else
{
compareTime += Time.deltaTime;
}
}
void Awake()
{
sRenderer = GetComponent <SpriteRenderer>();
col = GetComponent <BoxCollider>();
amount = transform.childCount;
for (int i = 0; i < amount; i++)
{
children.Add(new ChildObj());
children[i].obj = transform.GetChild(i).gameObject;
children[i].tran = transform.GetChild(i);
children[i].obj.SetActive(false);
}
sRenderer.enabled = false;
col.enabled = false;
me = new returnableObject(gameObject, null, null);
}
private void Start()
{
Rigidbody rb = null;
NavMeshAgent agent = null;
if (getAgent)
{
agent = GetComponent <NavMeshAgent>();
}
if (getRigidBody)
{
rb = GetComponent <Rigidbody>();
}
me = new returnableObject(gameObject, rb, agent);
}
public returnableObject getRefrenceFromPool(string tag, Vector3 position, Quaternion rotation)
{
if (!poolDictionary.ContainsKey(tag))
{
Debug.LogWarning("Pool with tag " + tag + " Doesn't exist");
return(null);
}
if (poolDictionary[tag].Count > 0)
{
returnableObject objToReference = poolDictionary[tag].Dequeue();
objToReference.gameObject.transform.position = position;
objToReference.gameObject.transform.rotation = rotation;
return(objToReference);
}
else
{
return(null);
}
}
//TODO: requeue is not actually used
public returnableObject SpawnFromPool(string tag, Vector3 position, Quaternion rotation, bool reQueue, bool oppositeScaleX = false, float scalex = 0)
{
if (!poolDictionary.ContainsKey(tag))
{
Debug.LogWarning("Pool with tag " + tag + " Doesn't exist");
return(null);
}
returnableObject objToSpawn = poolDictionary[tag].Dequeue();
objToSpawn.gameObject.transform.position = position;
objToSpawn.gameObject.transform.rotation = rotation;
if (oppositeScaleX)
{
Vector3 flip = objToSpawn.gameObject.transform.localScale;
flip.x = Mathf.Abs(flip.x) * scalex;
objToSpawn.gameObject.transform.localScale = flip;
}
objToSpawn.gameObject.SetActive(true);
return(objToSpawn);
}
public void fireRangedBlob()
{
returnableObject rangedShot = ObjectPooling.instance.SpawnFromPool("PlayerBlob", slimeBlobFireBox.position, slimeBlobFireBox.rotation, true);
rangedShot.rb.AddForce(transform.right * transform.localScale.x * 3 * myStats.Range, ForceMode.Impulse);
}
private void Start()
{
apple = transform.GetChild(0).gameObject;
me = new returnableObject(transform.parent.gameObject, null, null);
}
private void OnEnable()
{
bottomArrow = ObjectPooling.instance.SpawnFromPool("BottomArrow", new Vector3(transform.position.x, 0, transform.position.z), Quaternion.identity, false);
}
