AOE ENEMY

UNITY // SPRING 2025

Adaptable code for an enemy which shoots a projectile at the player, then creates a poison ring and delivers tick damage.

This code shoots a projectile at the gameobject with the player tag. It then spawns an overlap sphere, and checks every half a second if the player is still within the sphere radius. If yes, it deals tick damage every half second. 

AOEEnemy Script

AOEEnemy Variables

[Header(“Target Settings”)]
private GameObject currentTarget;
private bool shootProjectile = true;

[Header(“Projectile Settings”)]
AOEProjectile clonedProjectile;
[SerializeField] private Transform projectileStartPosition;
[SerializeField] private GameObject poisonProjectile;
[SerializeField] private float timeBetweenShots = 8f;
[SerializeField] private float projectileSpeed = 0.2f;

The variables in the AOEEnemy script are used to control how the enemy shoots the projectile. The variables can be used to control:

  • What the enemy is shooting at
  • Where the enemy is shooting from
  • What projectile gameobject the enemy is shooting
  • The time between each projectile fired 
  • The speed at which the projectile travels from point A to point B

AOEEnemy Code Body

public void Start()
{
    currentTarget = GameObject.FindWithTag(“Player”);
}
 
public void Update()
{
    if(currentTarget != null)
    {
        AttemptToFire();
    }
}
 
public void AttemptToFire()
{
    if(shootProjectile == true)
    {
        shootProjectile = false;
        StartCoroutine(ShootWithDelay());
    }
}
 
private IEnumerator ShootWithDelay()
{
    SpawnProjectile();
    yield return new WaitForSeconds(timeBetweenFiring);
    shootProjectile = true;
}

On start, the AOEEnemy script will identify the target as the gameobject containing the “Player” tag set in the inspector. The AttemptToFire function is called in Update, and checks whether the shootProjectile boolean is set to true. When true, the boolean is immediately set to false, and starts the ShootWithDelay coroutine. This coroutine calls the SpawnProjectile function once before waiting the amount of time assigned by the timeBetweenFiring variable. After this time has passed, the shootProjectile boolean is once again set to true.

AOEEnemy Code Body Cont.

public void SpawnProjectile()
{
    GameObject projectile = Instantiate(poisonProjectile, projectileStartPosition.position, Quaternion.identity);
 
    clonedProjectile = projectile.GetComponent<AOEProjectile>();
 
    StartCoroutine(moveProjectile(projectile));
}
 
private IEnumerator moveProjectile(GameObject projectile)
{
    float time = 0f;
    Vector3 pStartPosition = projectile.transform.position;
 
    while(time < 1f)
    {
        projectile.transform.position = Vector3.Lerp(pStartPosition, currentTarget.transform.position, time);
        time += Time.deltaTime / projectileSpeed;
        yield return null;
    }
 
    projectile.gameObject.GetComponent<MeshRenderer>().enabled = false;
    Destroy(projectile.gameObject, clonedProjectile.poisonLifetime);
}

When called, the SpawnProjectile function creates a projectile gameobject and starts the moveProjectile coroutine, passing through the new projectile gameobject as a parameter. The moveProjectile coroutine then moves the projectile gameobject from point A to point B over the amount of time defined by projectileSpeed.

AOEProjectile Script

The variables in the AOEProjectile script are used to control how the projectile acts. The variables can be used to control:

  • The particle effect that will be spawned
  • The time before the damage starts taking effect
  • The amount of damage per tick
  • The time between damage ticks
  • The amount of time the area of effect will be active

AOEProjectile Variables

[Header(“Poison Settings”)]
ParticleController particle;
private Vector3 projectilePosition;
[SerializeField] private GameObject poisonParticle;
[SerializeField] private float poisonStartDelay = 2f;
[SerializeField] private float poisonDamagePerTick = 5f;
[SerializeField] private float timeBetweenTicks = 0.5f;
[SerializeField] public float poisonLifetime = 5f;

The AOEProjectile script calls OnTriggerEnter to detect when the projectile hits a collider. When triggered, the poison particle is spawned at the projectile location and starts the PoisonDelay coroutine. The coroutine waits the length defined by poisonStartDelay before calling the CheckIfPoisoned coroutine. The CheckIfPoisoned coroutine then spawns an overlap sphere to see if any of the colliders within the sphere contain the PlayerHealth component. If yes, the ApplyPoison function gets called from the PlayerHealth script, and the coroutine gets called again to continuously check if the player is still in the damage radius. 

AOEProjectile Code Body

private void OnTriggerEnter(Collider other)
{
    GameObject pParticle = Instantiate(poisonParticle, transform.position, Quaternion.Euler(90,0,0));
    particle = pParticle.GetComponent<ParticleController>();
    Destroy(pParticle, poisonLifetime);
    StartCoroutine(PoisonDelay());
    projectilePosition = transform.position;
}
 
private IEnumerator PoisonDelay()
{
    yield return new WaitForSeconds(poisonStartDelay);
    StartCoroutine(CheckIfPoisoned());
}
   
private IEnumerator CheckIfPoisoned()
{
    Collider[] colliders = Physics.OverlapSphere(transform.position, particle.poisonRadius);
    // OnDrawGizmos();
 
    foreach(Collider collider in colliders)
    {
        PlayerHealth aoeTargetCollider = collider.GetComponent<PlayerHealth>();
        if(aoeTargetCollider)
        {
            aoeTargetCollider.ApplyPoison(poisonDamagePerTick);
        }
    }
    yield return new WaitForSeconds(timeBetweenTicks);
    StartCoroutine(CheckIfPoisoned());
}
 
// private void OnDrawGizmos()
// {
//     Gizmos.DrawWireSphere(transform.position, poisonRadius);
// }

PlayerHealth Script

PlayerHealth Code Body

[Header(“Health”)]
public float currentHealth;
public float maxHealth;
 
void Awake()
{
    currentHealth = maxHealth;
}
 
public void sendDamage(float damageValue)
{
    currentHealth -= damageValue;
}
 
public void ApplyPoison(float damageAmount)
{
    sendDamage(damageAmount);
}

The PlayerHealth script defines variables for the current and maximum health. It contains two functions: a general SendDamage function, and the ApplyPoison function called from the AOEProjectile script. These functions are used to damage the player’s current health.

ParticleController Script

The ParticleController script is an additional script used to control specific settings of the particle system used in this project. The poisonRadius variable can be used to control the size of the area of effect.

ParticleController Code Body

[Header(“Particle Settings”)]
public Vector3 speed;

 

[Header(“Poison Settings”)]
[SerializeField] public float poisonRadius = 2f;

 

void Start()
{
    ParticleSystem particle = this.GetComponent<ParticleSystem>();

 

    var particleShape = particle.shape;
    particleShape.radius = poisonRadius;
}
   
void Update()
{
    transform.Rotate(speed * Time.deltaTime);
}

Like What You See?

Check out some of my other projects.

The Quarrior

VIDEO GAME // UNITY

A short boss battle game where a miner must defeat a cave dwelling rock titan to free their town’s mine.

Timber

VIDEO GAME TRAILER // UNREAL ENGINE 5 

Trailer for puzzle-platform video game Timber where players experience first-hand the devastating effects of a world without trees