Sound Trigger Issue in Unity

[GiorgiNinua]

Hello everyone,

I’m having an issue with triggering a sound in Unity, and I’m hoping someone can help me figure out what I might be doing wrong.

I’m trying to make a monster play a sound when it first spots the player. I’m using FindObjectOfType<AudioManager>().Play("spotted"); in my script to trigger the sound. I’ve placed it in the section of my code where the monster should begin chasing the player. However, instead of playing the sound when the monster initially detects the player, it plays it after the player has hidden or escaped and the monster loses track of them.

Here’s a simplified version of my code where I’m triggering the sound:

if (hit.collider.gameObject.tag == "Player")
{
    walking = false;
    StopCoroutine("stayIdle");
    StopCoroutine("chaseRoutine");
    StartCoroutine("chaseRoutine");
    chasing = true;
    
    // Attempting to play the "spotted" sound
    FindObjectOfType<AudioManager>().Play("spotted");
}

The logic should, in theory, trigger the “spotted” sound as soon as the monster detects the player, but it doesn’t play at the right time. It only plays after the player breaks line of sight or hides, as if the sound is somehow delayed until the chasing phase is complete.

Has anyone encountered something similar, or does anyone have suggestions on what might be causing this? Could it be something to do with the order of code execution, or perhaps how I’m setting the chasing and idle states? Any insights would be greatly appreciated!

Here is the entire code if you need

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.SceneManagement;

public class haterAI : MonoBehaviour
{
    public NavMeshAgent ai;
    public List<Transform> destinations;
    public Animator aiAnim;
    public float walkSpeed, chaseSpeed, minIdleTime, maxIdleTime, idleTime, sightDistance, catchDistance, chaseTime, minChaseTime, maxChaseTime, jumpscareTime;
    public bool walking, chasing;
    public Transform player;
    Transform currentDest;
    Transform previousDest;
    Vector3 dest;
    public Vector3 rayCastOffset;
    public string deathScene;
    public float aiDistance;
    public GameObject hideText, stopHideText;

    void Start()
    {
        walking = true;
        previousDest = null;
        currentDest = GetRandomDestination(); 
    }

    void Update()
    {
        Vector3 direction = (player.position - transform.position).normalized;
        RaycastHit hit;
        aiDistance = Vector3.Distance(player.position, this.transform.position);

        if (Physics.Raycast(transform.position + rayCastOffset, direction, out hit, sightDistance))
        {
            if (hit.collider.gameObject.tag == "Player")
            {
                walking = false;
                StopCoroutine("stayIdle");
                StopCoroutine("chaseRoutine");
                StartCoroutine("chaseRoutine");
                chasing = true;
            }
        }

        if (chasing == true)
        {
                
            dest = player.position;
            ai.destination = dest;
            ai.speed = chaseSpeed;
            aiAnim.ResetTrigger("walk");
            aiAnim.ResetTrigger("idle");
            aiAnim.SetTrigger("sprint");


            if (aiDistance <= catchDistance)
            {
                player.gameObject.SetActive(false);
                aiAnim.ResetTrigger("walk");
                aiAnim.ResetTrigger("idle");
                hideText.SetActive(false);
                stopHideText.SetActive(false);
                aiAnim.ResetTrigger("sprint");
                aiAnim.SetTrigger("jumpscare");
                StartCoroutine(deathRoutine());
                chasing = false;
            }
        }

        if (walking == true)
        {
            dest = currentDest.position;
            ai.destination = dest;
            ai.speed = walkSpeed;
            aiAnim.ResetTrigger("sprint");
            aiAnim.ResetTrigger("idle");
            aiAnim.SetTrigger("walk");

            if (ai.remainingDistance <= ai.stoppingDistance)
            {
                aiAnim.ResetTrigger("sprint");
                aiAnim.ResetTrigger("walk");
                aiAnim.SetTrigger("idle");
                ai.speed = 0;
                StopCoroutine("stayIdle");
                StartCoroutine("stayIdle");
                walking = false;
            }
        }
    }

    public void stopChase()
    {
        walking = true;
        chasing = false;
        StopCoroutine("chaseRoutine");
        currentDest = GetRandomDestination(); 
    }

    IEnumerator stayIdle()
    {
        idleTime = Random.Range(minIdleTime, maxIdleTime);
        yield return new WaitForSeconds(idleTime);
        walking = true;
        currentDest = GetRandomDestination(); 
    }

    IEnumerator chaseRoutine()
    {
        chaseTime = Random.Range(minChaseTime, maxChaseTime);
        yield return new WaitForSeconds(chaseTime);
        stopChase();
    }

    IEnumerator deathRoutine()
    {
        yield return new WaitForSeconds(jumpscareTime);
        SceneManager.LoadScene(deathScene);
    }

   
    Transform GetRandomDestination()
    {
        Transform newDest;

       
        do
        {
            newDest = destinations[Random.Range(0, destinations.Count)];
        } while (newDest == previousDest && destinations.Count > 1);

        previousDest = newDest; 
        return newDest;
    }
}

Thanks so much in advance for your help!

[Kurt-Dekker]

@GiorgiNinua

Could it be something to do with the order of code execution, or perhaps how I’m setting the chasing and idle states?

That would be my first intuition.

Generally speaking…

… if you have to use StopCoroutine(); then coroutines are not the correct solution.

If you want to persist with all of this start/stop coroutine stuff it will be harder to debug what’s going on, but at the end of the day you will still need to debug it to find what is happening before you can begin to fix it.

By debugging you can find out exactly what your program is doing so you can fix it.

Unity - Manual: Debug C# code in Unity

Use the above techniques to get the information you need in order to reason about what the problem is.

You can also use Debug.Log(...); statements to find out if any of your code is even running. Don’t assume it is.

Once you understand what the problem is, you may begin to reason about a solution to the problem.

Here’s more random coroutine reading.

Coroutines in a nutshell:

Proper way to stop coroutine?

Coroutines are an IEnumerator object. They have their own internal state. It’s different from just calling InvokeRepeating(), which would restart a fresh function call each time. Here is ALL you need to know about coroutines in Unity: they are an IEnumerator, also known in some languages as a Generator. It is an object with a .MoveNext() method on it that “yields” the next thing with each subsequent call. That is what you create by calling an IEnumerator: you create the object, you do NOTHIN…

Destroying the object then restarting the scene

Hey Epoch, here’s how it goes down. A coroutine is just an IEnumerator object, and you make one by just calling a coroutine. When you do that, nothing happens. It’s like a water pump that needs to have its crank pumped, but nobody is pumping it so it sits there and does nothing. In Unity there’s a special agreement: if you hand that IEnumerator object into StartCoroutine(), which is a method belonging to the object where that StartCoroutine() call is located, what Unity does is starts “pumpin…

Splitting up larger tasks in coroutines:

Best Way to Split a Long-Running Function So it's Non-Blocking?

Technically, yeah, there’s always a way. But in practice, in the general sense it can get really hairy. Also, in the particular case of adding lots of GameObjects, I know they’re not linear: last I checked, adding 1000 GameObjects is WAY more than 10x slower than adding 100 Gameobjects, I presume due to inefficiencies in newly-added stuff, not sure/ No way to tell with a closed-source engine like Unity. Trying to tie into system timers and judge how long things have taken so far will get you …

Coroutines are NOT always an appropriate solution: know when to use them!

“Why not simply stop having so many coroutines ffs.” - orionsyndrome on Unity3D forums

Things to check before starting a coroutine?

The main thing to check before calling / making a coroutine is to ask yourself, “Does this even need to be a coroutine?” Generally, if your design requires you to call StopCoroutine(), then don’t make it a coroutine. If you just need something to happen a bit later, this is a more-robust approach: https://gist.github.com/kurtdekker/0da9a9721c15bd3af1d2ced0a367e24e If you’re flipping from one value to another, such as fading in, fading out, changing speeds slowly, etc., coroutines are an AW…

Heartbeat courutine fx

Again I would not reach for coroutines here. The reason: you can go below the critical health, then go up, then go back down, and every single point in there is a chance to screw up how many coroutines are actually running. Coroutines are great but they are the wrong solution for this problem. Instead, make a heartbeat script and have a variable to count if it is time yet: private float heartBeatYet; In your Update() function, calculate the desired rate of heartbeat based on health: float …

Our very own Bunny83 has also provided a Coroutine Crash Course:

Coroutines IEnumerator not working as expected

I’m kinda suprised that until now nobody has asked a question like this. Even though I have explained what a coroutine actually is several times in other questions it just shows that there is still quite a misunderstanding what a coroutine actually is. Lets just step back for a moment. Unity implements coroutines by utilizing a C# feature called “iterator blocks” or iterator methods (which are more generally known as Generator methods). C# ships with two relevant interfaces (IEnu…

And another overview by Anders Malmgren:

I'm addicted to using Coroutines. Any alternatives?

You need to understand the basics of what the Unity coroutine system is based on. Its not magic, its based on the fundamental basics of C# 3.0 which introduced the iterator pattern as part of their Linq feature. Any method that returns IEnumerator or IEnumerator<T> or IEnumerable/<T> can be iterated upon. This is actually a very easy concept. The IEnumerator interface as follows public interface IEnumerator { bool MoveNext(); object Current { get; } void Reset(); } Its…