public PetIdleState(PetObject obj) : base(obj)
{
m_OwnerTarget = pet.owner.GetComponent <PlayerTarget>();
m_OwnerDamagable = pet.owner.GetComponent <DamagableObject>();
m_PetWeapon = pet.GetComponent <PetWeapon>();
m_PetTarget = pet.GetComponent <PlayerTarget>();
}
public void SetOwner(DamagableObject _owner)
{
if (owner == null)
{
owner = _owner;
}
}
protected override void MoveToNext()
{
if (currentPathIndex + 1 >= pathToTarget.Count)
{
//lock position so drones dont float away
lockPosition = StartCoroutine(LockPosition(transform.position));
//a little unclean
currentTarget = EnemyPathManager.Instance.EnemyDestination.Occupying.GetComponent <DamagableObject> ();
explicitTarget = true;
layersToHit.Add("Target");
FireCoroutine = StartCoroutine(Fire(currentTarget, currentTarget.GetComponentInChildren <Collider>()));
Debug.Log(currentTarget.GetComponentInChildren <Collider> ());
disengaging = false;
}
else
{
base.MoveToNext();
if (currentTarget == null)
{
LookAt(destinationPosition);
}
}
}
IEnumerator Fire()
{
firing = true;
if (rotating != null)
{
StopCoroutine(rotating);
}
rotating = StartCoroutine(SmoothLookAt(currentTarget.transform));
yield return(new WaitForSeconds(weaponChargeTime));
if (currentTarget == null)
{
//the target has been destroyed before this got a chance to shoot at it
firing = false;
yield break;
}
GameObject proj = Instantiate(projectile, transform.position, Quaternion.identity);
proj.GetComponent <Projectile> ().Launch(currentTarget.transform.position, this.damage, this.projectileSpeed, gameObject, new string[] { "Enemy" });
currentTarget = null;
firing = false;
}
//Search for targets if not firing. If there are no targets, disengage
protected override void Update()
{
//Currently attacking
if (firing == false)
{
//Needs a new target
if (currentTarget == null)
{
Collider[] cols = Physics.OverlapSphere(transform.position, attackRange, LayerMask.GetMask("Friendly"));
if (cols.Length > 0)
{
//decide which enemy to shoot - currently we just pick the first target found
currentTarget = cols [0].GetComponentInParent <DamagableObject> ();
FireCoroutine = StartCoroutine(Fire(currentTarget, cols[0]));
disengaging = false;
//No target found
}
else if (disengaging == false)
{
Disengage();
disengaging = true;
}
}
}
}
private IEnumerator Fire(DamagableObject target, Collider c)
{
firing = true;
Track(c.transform);
//the charge sound should finish just as the weapon fires
if (target is GamePlayer)
{
chargeAS.Play();
}
yield return(new WaitForSeconds(weaponChargeTime));
if (c != null)
{
OnFire(c);
}
firing = false;
if (explicitTarget == false)
{
currentTarget = null;
}
else
{
FireCoroutine = StartCoroutine(Fire(currentTarget, c));
}
}
void OnCollisionEnter(Collision collision)
{
DamagableObject damObj = collision.gameObject.GetComponent <DamagableObject>();
if (damObj)
{
damObj.TakeDamage(damage);
}
Destroy(gameObject);
}
void Start()
{
this.tag = "Asteroid";
DamagableObject damObj = gameObject.GetComponent <DamagableObject> ();
if (damObj)
{
damObj.OnDeath += Death;
}
}
void UpdatePathToTarget(Vector2 distanceBetween, float minDistance)
{
if (distanceBetween.x < minDistance && distanceBetween.y < 0.2f)
{
if (aiPhase == AIPhase.PathToEnemy)
{
aiPhase = AIPhase.InCombat;
}
else if (aiPhase == AIPhase.PathToPickup)
{
if (targetObject.gameObject.GetComponent <DamagableObject>() != null)
{
enemyControl = targetObject.gameObject.GetComponent <DamagableObject>();
aiPhase = AIPhase.BreakingCrate;
}
else
{
GetClosestTarget();
}
}
else if (aiPhase == AIPhase.FreePath)
{
if (navPath.Count == 0)
{
GetClosestTarget();
}
}
else
{
GetClosestTarget();
}
}
if (jumpPrepare)
{
if (playerControl.JumpCount == 0)
{
playerControl.Jump();
jumpPrepare = false;
}
}
else
{
if (destinationNode != null)
{
MoveTowardsNode(destinationNode);
}
}
if (destinationNode == null || Vector2.Distance(transform.position, destinationNode.node.transform.position) < 0.5f)
{
ChooseNextPathNode();
}
}
// Update is called once per frame
void Update()
{
currentGun = guns[currentGunIndex];
if (Input.GetKeyDown(KeyCode.Tab))
{
if (currentGunIndex + 1 < maxGunIndex)
{
currentGunIndex++;
}
else
{
currentGunIndex = 0;
}
}
if (Input.GetMouseButton(0) && currentGun.canShoot)
{
currentGun.canShoot = false;
StartCoroutine(reloadGun(currentGun));
if (currentGun.shotType == 0)
{
//Debug.Log("Gun shot");
RaycastHit2D hit = Physics2D.Raycast(gameObject.transform.position, gameObject.transform.up, 30000f, layerMask: LayerMask.GetMask("enemy"));
Debug.Log(hit.collider.gameObject.tag);
if (hit.collider.gameObject.tag == "enemy")
{
Debug.Log("Hit enemy");
DamagableObject d = hit.collider.GetComponent <DamagableObject>();
d.RecieveHit(currentGun.dmg);
}
for (int i = 0; i < 300; i++)
{
//GameObject p = Instantiate(particle, nose.position,Quaternion.identity);
//p.GetComponent<Rigidbody2D>().AddForce(gameObject.transform.up * Time.deltaTime, ForceMode2D.Impulse);
}
}
else if (currentGun.shotType == 1)
{
GameObject bul = Instantiate(currentGun.bullet, gameObject.transform.position, Quaternion.identity);
bul.transform.rotation = Quaternion.Euler(bul.transform.rotation.x + 45f, bul.transform.rotation.y + 45f, bul.transform.rotation.z + 45f);
bul.GetComponent <Rigidbody2D>().AddForce(gameObject.transform.up * miniGunBulSpeed, ForceMode2D.Impulse);
}
}
}
private void OnTriggerStay(Collider other)
{
DamagableObject damagableObject = other.GetComponent <DamagableObject> ();
if (damagableObject == null)
{
return;
}
Vector3 forceDirection = GetForceDirection(other.transform.position);
damagableObject.GetDamage(m_force, forceDirection, m_damage);
}
void OnCollisionEnter(Collision collision)
{
DamagableObject damObj = collision.gameObject.GetComponent <DamagableObject> ();
DamagableObject damObjMine = gameObject.GetComponent <DamagableObject> ();
if (damObj)
{
damObj.TakeDamage(damage);
}
if (damObjMine)
{
damObjMine.TakeDamage(damage);
}
}
void OnCollisionEnter(Collision col)
{
//we have defined layers and this isn't one of them
if (this.layersToHit == null || (this.layersToHit != null && layersToHit.Contains(LayerMask.LayerToName(col.gameObject.layer))))
{
DamagableObject dObj = col.collider.GetComponentInParent <DamagableObject> ();
if (dObj != null && dObj.enabled)
{
dObj.Hit(col.contacts[0].point, this.firedFrom, this.damage);
}
}
Destroy(rootParent.gameObject);
}
private void GetClosestTarget()
{
if (playerControl.IsDead)
{
return;
}
if (Random.Range(0, 100) < 50)
{
aiPhase = AIPhase.PathToEnemy;
enemyControl = enemies[Random.Range(0, enemies.Count)].GetComponentInParent <PlayerController>();
GetDestinationPath(enemyControl.transform.position);
return;
}
float distance = 100000;
int target = -1;
for (int i = 0; i < enemies.Count; i++)
{
if (!enemies[i].GetComponent <PlayerController>().IsDead&& !enemies[i].GetComponent <PlayerController>().Invulnerable)
{
float tempDistance = Vector2.Distance(enemies[i].position, rigidbody2D.position);
if (tempDistance < distance)
{
distance = tempDistance;
target = i;
}
}
}
if (target > -1)
{
aiPhase = AIPhase.PathToEnemy;
enemyControl = enemies[target].GetComponentInParent <PlayerController>();
GetDestinationPath(enemyControl.transform.position);
}
else
{
enemyControl = null;
}
}
protected override void Update()
{
//Attacking
Collider[] cols = Physics.OverlapSphere(transform.position, range, LayerMask.GetMask("Enemy"));
if (firing == false)
{
if (currentTarget == null)
{
foreach (Collider c in cols)
{
if (c.GetComponentInParent <Enemy>() != null && c.GetComponentInParent <Enemy> ().CurrentHealth > 0)
{
//decide which enemy to shoot - currently we just pick the first target found
currentTarget = c.GetComponentInParent <DamagableObject> ();
StartCoroutine(Fire());
break;
}
}
}
}
base.Update();
}
private void OnParticleCollision(GameObject other)
{
DamagableObject damObj = other.GetComponent <DamagableObject>();
damObj?.TakeDamage();
}
private bool IgnoreListContains(DamagableObject item)
{
return(ignoreList.Contains(item));
}
