public virtual void Fire()
{
canFire = false;
if (Time.time < nextFireAllowed)
{
return;
}
if (reloader != null)
{
if (reloader.isReloading)
{
return;
}
if (reloader.roundsRemainingInClip == 0)
{
return;
}
reloader.TakeFromClipEnemy(1);
}
nextFireAllowed = Time.time + rateOfFire;
Vector3 aim = new Vector3(aimTarget.position.x, this.transform.position.y, aimTarget.position.z);
muzzle.LookAt(aim + aimTargetOffset);
EnemyProjectile newBullet = Instantiate(projectile, muzzle.position, muzzle.rotation);
FireEffect();
audioFire.Play();
canFire = true;
}
private void OnTriggerEnter2D(Collider2D col)
{
//collision with a projectile
//collision with an enemy
//IceSkullProjectile
//Enemy_Projectile p
if (!Launched)
{
EnemyProjectile proj = col.gameObject.GetComponent <EnemyProjectile>();
if ((proj != null) && (proj.enabled) && (proj.Live) && (CanFreezeProjectiles))
{
freezeProjectile(proj);
GameObject.Destroy(proj.gameObject, 10f);
return;
}
}
GenericEnemy en = col.gameObject.GetComponent <GenericEnemy>();
if ((en != null) && (en.Alive) && (!col.isTrigger))
{
if (!Launched)
{
if (BlizzardField)
{
en.freeze(1.2f);
FreezePoof.Play();
}
}
return;
}
}
private void Shoot()
{
if (this.PlayerDetected() && shootCooldown <= 0)
{
animator.SetBool("cheerleaderThrow", true);
//animator.Play("cheerleaderThrow", 0, 4.0f / 18.0f);
// Generate a vector from the enemy to the player
Vector2 randomizer = new Vector2(Random.Range(-1.0f, 1.0f), Random.Range(-1.0f, 1.0f));
Vector2 projectileVector = (DirectionToPlayer() + randomizer).normalized * enemyProjectile.totalSpeed;
if (projectileVector.x > 0)
{
spriteRenderer.flipX = false;
}
else
{
spriteRenderer.flipX = true;
}
// Create the enemy projectile
EnemyProjectile newProjectile = Instantiate(enemyProjectile);
newProjectile.transform.position = this.transform.position;
newProjectile.setSpeed(projectileVector.x, projectileVector.y);
// Reset the cooldown
shootCooldown = shootCooldownMax;
}
else if (!PlayerDetected())
{
animator.SetBool("cheerleaderThrow", false);
}
}
public virtual void onHit(EnemyProjectile proj, Vector3 KnockBackDirection)
{
if (this.tag == Constants.PLAYER_STRING)
{
m_Health -= ENEMY_DAMAGE;
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.tag.Equals("Projectile"))
{
EnemyProjectile old = collision.gameObject.GetComponent <EnemyProjectile>();
if (old != null && !old.Hit && old.Reflect)
{
Vector2 original = old.Velocity;
float magnitude = original.magnitude;
Projectile proj = collision.gameObject.AddComponent <PlayerProjectile>();
proj.SetAttributes(old);
Destroy(old);
// Version 1 (opposite direction)
// proj.InitialVelocity = -original;
// Version 2 (shield direction)
// proj.Velocity = dir * magnitude;
// Version 3 (physics reflection)
proj.InitialVelocity = (Vector3)original + 2 * Vector3.Project(original, dir).magnitude *dir.normalized
+ Vector3.Project(PlayerManager.player.battleAlien.GetComponent <PlayerBattleController>().Velocity, dir);
}
}
}
public virtual void onHit(EnemyProjectile proj)
{
if (this.tag == Constants.PLAYER_STRING)
{
m_Health -= ENEMY_DAMAGE;
}
}
void PopProjectileOffStack(float speed, string type, float positionX, float positionY)
{
EnemyProjectile poppedEnemyProjectile = prefabPools.PopEnemyProjectile();
if (poppedEnemyProjectile != null)
{
poppedEnemyProjectile.enabled = true;
if (enemyID != 113)
{
poppedEnemyProjectile.PopOffStack(enemyDamage, speed, type, positionX, positionY);
}
else
{
switch (type)
{
case "EnemyProjectileRocket":
poppedEnemyProjectile.PopOffStack(enemyDamage * 0.5f, speed, type, positionX, positionY);
break;
case "EnemyProjectileFire":
poppedEnemyProjectile.PopOffStack(enemyDamage * 0.045f, speed, type, positionX, positionY);
break;
case "EnemyProjectileBomb":
poppedEnemyProjectile.PopOffStack(enemyDamage * 0.5f, speed, type, positionX, positionY);
break;
default:
poppedEnemyProjectile.PopOffStack(enemyDamage, speed, type, positionX, positionY);
break;
}
}
}
}
private void Fire()
{
EnemyProjectile projectile = Instantiate(projectileToFire, transform.position, transform.rotation);
projectileCooldownCounter = ProjectileCooldownCounter();
StartCoroutine(projectileCooldownCounter);
}
public override void onHit(EnemyProjectile proj)
{
if (m_InvulnerabilityTimer <= 0.0f)
{
//not invulnerable so take damage
if (m_Health > 0.0f)
{
//Take damage
m_Health -= ENEMY_DAMAGE;
//Knockback
KnockBackPlayer(proj.gameObject.transform.forward);
//play sound
playSound();
}
m_HealthRegenTimer = HealthRegenTime;
m_InvulnerabilityTimer = InvulnerabilityTimer;
m_PlayerRenderer.material = i_InvulnerableMaterial;
//update health bar
m_Hud.SetHealth(m_Health, m_Player);
}
}
IEnumerator FireProjectile()
{
if (myProjectile != null)
{
int repeats = 5;
float waitTime = (float)rateOfFire / (2 * repeats);
EnemyProjectile projectile = null;
do
{
GameObject newProjectile = Instantiate(myProjectile, this.transform.position, this.transform.rotation) as GameObject;
newProjectile.transform.parent = transform.parent.parent;
if (newProjectile != null)
{
projectile = newProjectile.GetComponent <EnemyProjectile> ();
}
else
{
Debug.LogWarning("Unable to spawn projectile for " + gameObject.name);
yield return(new WaitForSeconds(waitTime));
}
if (projectile != null)
{
projectile.SetEnemy(enemy);
projectile.SetStats(damage, range, speed);
}
else
{
Debug.LogWarning("Unable to get projectile for " + gameObject.name);
yield return(new WaitForSeconds(waitTime));
}
} while (projectile == null && repeats-- > 0);
}
}
private void PhaseOne()
{
if (shootTime >= shootDelay)
{
int startAngle = Random.Range(0, 361);
int step = 0;
if (difficulty == Global.RECRUIT)
{
step = 90;
}
else if (difficulty == Global.VETEREN)
{
step = 60;
}
else if (difficulty == Global.BATTLEH)
{
step = 45;
}
for (int i = 0; i < 361; i += step)
{
EnemyProjectile e = Instantiate(projectiles [0], shootPos [0].position,
Quaternion.Euler(0, 0, i + startAngle)).GetComponent <EnemyProjectile> ();
e.Setup(player, 2);
}
shootTime = 0;
}
}
private void DestroySelf()
{
Destroy(gameObject);
if (Global.Difficulty == Global.RECRUIT)
{
for (int i = 0; i < 15; i++)
{
EnemyProjectile e = Instantiate(projectiles [Random.Range(0, projectiles.Length)], transform.position,
Quaternion.Euler(0, 0, Random.Range(0, 361))).GetComponent <EnemyProjectile>();
e.Setup(player, Random.Range(1.45f, 3.28f), 1);
e.SetRadius(0.1f);
}
}
else if (Global.Difficulty == Global.VETEREN)
{
for (int i = 0; i <= 20; i++)
{
EnemyProjectile e = Instantiate(projectiles [Random.Range(0, projectiles.Length)], transform.position,
Quaternion.Euler(0, 0, Random.Range(0, 361))).GetComponent <EnemyProjectile>();
e.Setup(player, Random.Range(2.18f, 3.63F), 1);
e.SetRadius(0.1f);
}
}
else if (Global.Difficulty == Global.BATTLEH)
{
for (int i = 0; i <= 32; i++)
{
EnemyProjectile e = Instantiate(projectiles [Random.Range(0, projectiles.Length)], transform.position,
Quaternion.Euler(0, 0, Random.Range(0, 361))).GetComponent <EnemyProjectile>();
e.Setup(player, Random.Range(1.45f, 3.63F), 1);
e.SetRadius(0.1f);
}
}
}
private void DestroySelf()
{
Destroy(gameObject);
if (Global.Difficulty == Global.RECRUIT)
{
for (int i = 0; i <= Random.Range(0, 2); i++)
{
EnemyProjectile e = Instantiate(projectiles [Random.Range(0, 3)], transform.position + (transform.up * -0.3f),
Quaternion.Euler(0, 0, (180 + transform.eulerAngles.z) + 90 - Random.Range(0, 181))).GetComponent <EnemyProjectile>();
e.Setup(player, Random.Range(1.45f, 3.63F), 1);
e.SetRadius(0.1f);
}
}
else if (Global.Difficulty == Global.VETEREN)
{
for (int i = 0; i <= 2; i++)
{
EnemyProjectile e = Instantiate(projectiles [Random.Range(0, 3)], transform.position + (transform.up * -0.3f),
Quaternion.Euler(0, 0, (180 + transform.eulerAngles.z) + 90 - Random.Range(0, 181))).GetComponent <EnemyProjectile>();
e.Setup(player, Random.Range(1.45f, 3.63F), 1);
e.SetRadius(0.1f);
}
}
else if (Global.Difficulty == Global.BATTLEH)
{
for (int i = 0; i <= 5; i++)
{
EnemyProjectile e = Instantiate(projectiles [Random.Range(0, 3)], transform.position + (transform.up * -0.3f),
Quaternion.Euler(0, 0, (180 + transform.eulerAngles.z) + 90 - Random.Range(0, 181))).GetComponent <EnemyProjectile>();
e.Setup(player, Random.Range(1.45f, 3.63F), 1);
e.SetRadius(0.1f);
}
}
}
private void Shoot(float shotAngle)
{
Vector2 shotDir = new Vector2(Mathf.Cos(shotAngle * Mathf.Deg2Rad), Mathf.Sin(shotAngle * Mathf.Deg2Rad));
EnemyProjectile newProjectile = Instantiate(projectile, transform.position, Quaternion.identity).GetComponent <EnemyProjectile>();
newProjectile.SetDirection(shotDir);
}
public override void Shoot()
{
if (shootTime > shootDelay)
{
// Instantiate (BULLET PREFAB, SHOOT POSITION, Z ROTATION + SPREAD IF THERE IS ANY)
EnemyProjectile e = Instantiate(projectiles [0], shootPos [0].position,
Quaternion.Euler(0, 0, transform.eulerAngles.z + 30f + spread - 2 * Random.value * spread))
.GetComponent <EnemyProjectile>();
e.Setup(player, 2.18f, 1);
e.SetRadius(0.1f);
EnemyProjectile e1 = Instantiate(projectiles[0], shootPos[0].position,
Quaternion.Euler(0, 0, transform.eulerAngles.z + 20f + spread - 2 * Random.value * spread))
.GetComponent <EnemyProjectile>();
e1.Setup(player, 2.18f, 1);
e1.SetRadius(0.1f);
EnemyProjectile e2 = Instantiate(projectiles[0], shootPos[0].position,
Quaternion.Euler(0, 0, transform.eulerAngles.z + spread - 2 * Random.value * spread))
.GetComponent <EnemyProjectile>();
e2.Setup(player, 2.18f, 1);
e2.SetRadius(0.1f);
EnemyProjectile e3 = Instantiate(projectiles[0], shootPos[0].position,
Quaternion.Euler(0, 0, transform.eulerAngles.z + -20f + spread - 2 * Random.value * spread))
.GetComponent <EnemyProjectile>();
e3.Setup(player, 2.18f, 1);
e3.SetRadius(0.1f);
EnemyProjectile e4 = Instantiate(projectiles[0], shootPos[0].position,
Quaternion.Euler(0, 0, transform.eulerAngles.z + -30f + spread - 2 * Random.value * spread))
.GetComponent <EnemyProjectile>();
e4.Setup(player, 2.18f, 1);
e4.SetRadius(0.1f);
shootTime = 0;
}
}
public override bool CollidedWithEnemy(EnemyProjectile p)
{
if (p.CollisionSpheres != null)
{
foreach (BoundingSphere b in p.CollisionSpheres)
{
if (b.Intersects(this.collisionSphere))
{
return(true);
}
}
}
if (p.CollisionBoxes != null)
{
foreach (BoundingBox b in p.CollisionBoxes)
{
if (b.Intersects(this.collisionSphere))
{
return(true);
}
}
}
return(false);
}
public override bool Shoot()
{
if (CurrentShotCooldown <= 0.0f)
{
if (!base.Shoot())
{
return(false);
}
GameObject obj = Instantiate(Projectile, child.position, Quaternion.identity);
if (obj)
{
BasicProjectile prj = obj.GetComponent <BasicProjectile>();
if (prj)
{
prj.Damage = WeaponDamage;
prj.Direction = transform.parent.forward;
prj.ImpulseDirection = transform.parent.transform.forward;
}
else
{
EnemyProjectile eprj = obj.GetComponent <EnemyProjectile>();
if (eprj)
{
eprj.Damage = WeaponDamage;
eprj.Direction = transform.parent.forward;
eprj.ImpulseDirection = transform.parent.transform.forward;
}
}
CurrentShotCooldown = ShotCooldown;
bIsShooting = true;
}
}
return(true);
}
protected void SendProjectile()
{
GameObject obj = Instantiate(projectile, shotPoint.position, Quaternion.identity) as GameObject;
EnemyProjectile proj = obj.gameObject.GetComponent <EnemyProjectile>();
proj.SetDamage(damage);
}
// Update is called once per frame
void Update()
{
movementDirection = Vector3.zero;
if (PlayerScript.Instance != null)
{
Vector3 targetDiff = PlayerScript.Instance.transform.position - transform.position;
targetDiff.y = 0;
transform.rotation = Quaternion.LookRotation(targetDiff);
if (targetDiff.sqrMagnitude > MoveDistance * MoveDistance)
{
movementDirection = targetDiff.normalized * speed;
}
if (Cooldown < fireRate)
{
Cooldown += Time.deltaTime;
}
else if (targetDiff.sqrMagnitude <= fireDistance * fireDistance)
{
Vector3 firePoint = transform.position;
firePoint.y += fireHeight;
GameObject projectileObject = Instantiate(projectile, firePoint, Quaternion.identity);
EnemyProjectile firingProjectile = projectileObject.GetComponent <EnemyProjectile>();
firingProjectile.Direction = targetDiff;
firingProjectile.ProjectileColor = color;
Cooldown = 0;
}
}
}
public void freezeProjectile(EnemyProjectile proj)
{
proj.Live = false;
proj.enabled = false;
FrozenProjectile frp = GameObject.Instantiate(FrozenProjectilePrefab, proj.transform.position, proj.transform.rotation).GetComponent <FrozenProjectile>();
FreezePoof.Play();
foreach (ParticleSystem p in proj.gameObject.GetComponentsInChildren <ParticleSystem>())
{
if (!p.transform.Equals(this.transform))
{
p.transform.SetParent(null);
if (p.main.loop)
{
p.Stop();
}
}
else
{
//p.enabled = false;
p.Stop();
}
GameObject.Destroy(p.gameObject, p.main.duration);
}
Rigidbody2D rb = proj.GetComponent <Rigidbody2D>();
if (rb != null)
{
GameObject.Destroy(rb);
}
frp.transform.SetParent(proj.transform);
frp.transform.position = frp.transform.position + new Vector3(0f, 0f, -2f);
}
private void TimerVolleyFinished(float secondsOverflow)
{
VolleyData volley = data.volley;
float[] angles = UtilSpread.PopulateAngle(volley.spreadAngle,
data.volley.projectile.angle,
volley.projectileCount);
foreach (float a in angles)
{
float angle = a;
if (data.refs.player != null)
{
if (volley.aimAtPlayer)
{
Vector3 playerPos = data.refs.player.transform.position;
angle += Angle.FromPoint(transform.position, playerPos).GetDegrees();
//UtilHeading2D.SignedAngleToPoint(transform.position, playerPos);
}
}
Quaternion rotation = Quaternion.AngleAxis(angle, Vector3.forward);
GameObject projectile = Instantiate(prefabProjectile, transform.position, rotation);
EnemyProjectile proj = projectile.GetComponent <EnemyProjectile>();
EnemyProjectile.Data projData = data.volley.projectile.DeepCopy();
projData.angle = angle;
proj.SetData(projData);
Velocity2D leftMovement = projectile.GetComponent <Velocity2D>();
leftMovement.SetVelocity(new Vector2(-data.projectileLeftSpeed, 0.0f));
projectile.GetComponent <TimeScale>().SetData(timeScale);
}
data.volley.projectile.angle += data.volleyDirectionDeltaPerShot;
}
private void PhaseOne()
{
if (shootTime >= shootDelay)
{
EnemyProjectile e = Instantiate(projectiles[0], shootPos[0].position,
Quaternion.Euler(0, 0, transform.eulerAngles.z))
.GetComponent <EnemyProjectile>();
e.Setup(player, Random.Range(1.5f, 3f), 1);
e.SetRadius(0.65f);
if (difficulty == Global.BATTLEH)
{
EnemyProjectile e1 = Instantiate(projectiles[1], shootPos[0].position,
Quaternion.Euler(0, 0, transform.eulerAngles.z - 30))
.GetComponent <EnemyProjectile>();
e1.Setup(player, Random.Range(1.5f, 3f), 1);
e1.SetRadius(0.25f);
EnemyProjectile e2 = Instantiate(projectiles[1], shootPos[0].position,
Quaternion.Euler(0, 0, transform.eulerAngles.z + 30))
.GetComponent <EnemyProjectile>();
e2.Setup(player, Random.Range(1.5f, 3f), 1);
e2.SetRadius(0.25f);
}
shootTime = 0;
}
}
void spawnProjectile()
{
if (isDead)
{
return;
}
float distanceToPlayer = 0;
float randomX = 0;
float randomY = 0;
while (distanceToPlayer <= 3.5f || distanceToPlayer >= 10f) // Don't spawn too close or far from the player
{
randomX = Random.Range(-10, 10);
randomY = Random.Range(1, 6);
distanceToPlayer = Vector3.Distance(player.transform.position, new Vector3(randomX, randomY));
}
Vector3 spawnPosition = new Vector3(randomX, randomY);
EnemyProjectile ep = Instantiate(projectile, spawnPosition, Quaternion.identity).GetComponent <EnemyProjectile>();
ep.homeInitially();
ep.initialize(power, bulletSpeed, 0);
ep.setDelay(0.5f);
ep.setScale(0.75f);
ep.setColor(new Color(0.15f, 0.8f, 0.15f));
}
void Shoot()
{
EnemyProjectile p = enemyBulletPooler.ProjectileFromPool();
p.transform.position = transform.position + new Vector3(0, -1, 0);
audioSource.Play();
}
private void OnTriggerEnter2D(Collider2D collision)
{
EnemyProjectile enemyProjectile = collision.GetComponent <EnemyProjectile>();
if (enemyProjectile != null && enemyProjectile.CurrenyEnemeyType == EnemyTypeCheck.Type.Bomber)
{
ParticleSystem particle = Instantiate(_hitVFX, transform.position, Quaternion.identity);
particle.Play();
Destroy(particle, particle.main.duration);
Instantiate(_bulletSound, gameObject.transform.position, Quaternion.identity);
enemyProjectile.DestroyBullet = true;
RecycleBullet();
}
IDamageableType <float> damageable = collision.GetComponent <EnemyHealth>();
if (damageable != null)
{
damageable.TakeDamage(_turretData.machineGun.damage, DispenserData.Type.Normal);
//StartCoroutine(HitExplosion());
//For now will work like so
ParticleSystem particle = Instantiate(_hitVFX, transform.position, Quaternion.identity);
particle.Play();
Destroy(particle, particle.main.duration);
Instantiate(_bulletSound, gameObject.transform.position, Quaternion.identity);
RecycleBullet();
}
}
private void PhaseTwo()
{
if (shootTime >= shootDelay)
{
int shootAmount = 0;
if (difficulty == Global.RECRUIT)
{
shootAmount = 3;
}
else if (difficulty == Global.VETEREN)
{
shootAmount = 6;
}
else if (difficulty == Global.BATTLEH)
{
shootAmount = 10;
}
for (int i = 0; i < shootAmount; i++)
{
EnemyProjectile e = Instantiate(projectiles [1], shootPos [0].position,
Quaternion.Euler(0, 0, transform.eulerAngles.z - 45 + Random.Range(0, 91)))
.GetComponent <EnemyProjectile> ();
e.Setup(player, 2);
}
shootTime = 0;
}
}
private void FixedUpdate()
{
while (timerVolley.TimeUp(data.refs.ts.DeltaTime()))
{
VolleyData volley = data.volley;
float[] angles = UtilSpread.PopulateAngle(volley.spreadAngle,
data.volley.projectile.angle,
volley.projectileCount);
foreach (float a in angles)
{
float angle = a;
if (data.refs.player != null)
{
if (volley.aimAtPlayer)
{
Vector3 playerPos = data.refs.player.transform.position;
angle += UtilHeading2D.SignedAngleToPoint(transform.position, playerPos);
}
}
Quaternion rotation = Quaternion.AngleAxis(angle, Vector3.forward);
GameObject projectile = Instantiate(prefabProjectile, transform.position, rotation);
EnemyProjectile proj = projectile.GetComponent <EnemyProjectile>();
EnemyProjectile.Data projData = data.volley.projectile.DeepCopy();
projData.angle = angle;
proj.SetData(projData);
Velocity2D leftMovement = projectile.GetComponent <Velocity2D>();
Velocity2D.Data v2d = new Velocity2D.Data(
new Velocity2D.Data.Refs(data.refs.ts),
new Vector2(-data.projectileLeftSpeed, 0.0f));
leftMovement.SetData(v2d);
}
data.volley.projectile.angle += data.volleyDirectionDeltaPerShot;
}
}
private void ShootSubProjectile(GameObject subProjectile, float angleDegrees)
{
Vector2 shotDir = new Vector2(Mathf.Cos(angleDegrees * Mathf.Deg2Rad), Mathf.Sin(angleDegrees * Mathf.Deg2Rad));
EnemyProjectile newSubProjectile = Instantiate(subProjectile, transform.position, Quaternion.identity).GetComponent <EnemyProjectile>();
newSubProjectile.SetDirection(shotDir);
}
private void ShootAtPlayer()
{
Vector2 shotDir = (Vector2)(manager.target.position - transform.position).normalized;
EnemyProjectile newProjectile = Instantiate(projectile, transform.position, Quaternion.identity).GetComponent <EnemyProjectile>();
newProjectile.SetDirection(shotDir);
}
void Attack()
{
GameObject projectileObject = Instantiate(projectilePrefab, rigidbody2D.position + Vector2.up * 0.5f, Quaternion.identity);
EnemyProjectile projectile = projectileObject.GetComponent <EnemyProjectile>();
projectile.EnemyAttack(2500);
}
void OnTriggerEnter(Collider obj)
{
if(obj.tag == "BeanBag" || obj.tag == "BeanBagLauncher" || obj.tag == "CollideWithMovingPlatforms")
{
return;
}
if(obj.gameObject.GetComponent(typeof(Attackable)) as Attackable != null)//checks to see if the object that has been hit is attackable
{
Attackable attackable = obj.gameObject.GetComponent(typeof(Attackable)) as Attackable; //if so call the onhit function and pass in the gameobject
EnemyProjectile tempProjectile = new EnemyProjectile();
Vector3 KnockBackDirection = new Vector3( m_CurrentVelocity.x, 0, m_CurrentVelocity.y);
attackable.onHit(tempProjectile, KnockBackDirection);
}
//destroy gameobject;
Destroy(this.gameObject);
}
protected override void Awake()
{
base.Awake ();
if(stat != null) {
stat.hpChangeCallback += OnHPChange;
}
if(entMove != null) {
entMove.onDirXChange += onDirXChange;
}
//projectiles within enemies are considered melees
//default off
mMelee = GetComponentInChildren<EnemyProjectile>();
meleeMode = Melee.Off;
}
public override void onHit(EnemyProjectile proj)
{
if (this.tag == Constants.PLAYER_STRING)
{
m_Health -= ENEMY_DAMAGE;
if (!m_HasAlreadyDead)
m_Animator.playAnimation(AnimatorMusicalMortar.Animations.Hit);
}
}
//Ignore enemys
public void onHit(EnemyProjectile proj)
{
return;
}
public override void onHit(EnemyProjectile proj, Vector3 KnockBackDirection)
{
if(m_InvulnerabilityTimer <= 0.0f)
{
//not invulnerable so take damage
if(m_Health > 0.0f)
{
//Take damage
m_Health -= ENEMY_DAMAGE;
//Knockback
KnockBackPlayer(KnockBackDirection);
//play sound
playSound();
}
m_HealthRegenTimer = HealthRegenTime;
m_InvulnerabilityTimer = InvulnerabilityTimer;
m_PlayerRenderer.material = i_InvulnerableMaterial;
//update health bar
m_Hud.SetHealth (m_Health, m_Player);
}
}
//Ignore enemys
public void onHit(EnemyProjectile proj, Vector3 KnockBackDirection)
{
return;
}
public virtual void onHit(EnemyProjectile proj, Vector3 KnockBackDirection)
{
if (this.tag == Constants.PLAYER_STRING)
m_Health -= ENEMY_DAMAGE;
}
public override void onHit(EnemyProjectile proj)
{
return;
}
public virtual void onHit(EnemyProjectile proj)
{
if (this.tag == Constants.PLAYER_STRING)
m_Health -= ENEMY_DAMAGE;
}
void Awake()
{
proj_instance = projectile.GetComponent<EnemyProjectile>(); ;
//proj_instance = Instantiate(projectile) as Projectile;
}
