Creating a countdown Timer in Unity

Question

I want to create a countdown timer in a Unity game I am creating. Up until now my game was running for a specific time but I was using InvokeRepeating to end the game after the set time.

But now I want to display the time left in a GUI text. One approach could be to use InvokeRepeating again but this time call it every second to decrement the timer. With this approach though it would mean do extra calculations for when a minute passes in order to display time appropriately and not just display the whole time in seconds.

Is there a different approach? Does Unity have any timers built in? Also which is the more efficient method?

Answer 1

Alternatively, you could use System.Timers.Timer which is probably the most performant of any solution. The following example shows a countdown for 100 seconds.

System.Timers.Timer LeTimer;
int BoomDown = 100;
void Start ()
{
    //Initialize timer with 1 second intervals
    LeTimer = new System.Timers.Timer (1000);
    LeTimer.Elapsed +=
        //This function decreases BoomDown every second
        (object sender, System.Timers.ElapsedEventArgs e) => BoomDown--;
}

void Update ()
{
    //When BoomDown reaches 0, BOOM!
    if (BoomDown <= 0)
        Debug.Log ("Boom!");
}

Answer 2

Coroutines are you friend I think on this one...

http://docs.unity3d.com/Manual/Coroutines.html

Here is an example:

void Start () {
    StartCoroutine ("Countdown", 10);
}

private IEnumerator Countdown(int time){
    while(time>0){
        Debug.Log(time--);
        yield return new WaitForSeconds(1);
    }
    Debug.Log("Countdown Complete!");
}

Answer 3

The code below might look complicated but once you understand it, you will be able to see its power of reusablity. (it's kind of countup but further down you will understand how to make it countdown if you understand how the code works)

public IEnumerator Count(
    float targetTime,
    System.Action<float> receiveTimeElapsed = null,
    System.Func<bool> actionCondition = null,
    System.Action conditionalAction = null,
    System.Action onCountStart = null,
    System.Action onCountEnd = null)
{
    onCountStart?.Invoke();

    float timeElapsed = 0f;
    receiveTimeElapsed?.Invoke(timeElapsed);

    while (timeElapsed < targetTime)
    {
        if (actionCondition != null && actionCondition.Invoke())
            conditionalAction?.Invoke();

        yield return null;

        timeElapsed += Time.deltaTime;

        receiveTimeElapsed?.Invoke(timeElapsed);
    }

    if (actionCondition != null && actionCondition.Invoke())
        conditionalAction?.Invoke();

    onCountEnd?.Invoke();
}

private float _timeElapsed;
private int _count;

private void Awake()
{
    this.StartCoroutine(
        this.Count(
            5f,
            (timeElapsed) =>
            {
                this._timeElapsed = timeElapsed;
                Debug.Log("Time Elapsed: " + this._timeElapsed);
            },
            () => { return this._timeElapsed >= (this._count + 1); },
            () =>
            {
                this._count++;

                Debug.Log("Countdown: " + this._count);
            },
            () => { Debug.Log("Countdown: " + this._count); },
            () => { Debug.Log("On countdown end"); }
        )
    );
}

If you think that it's too much or you may not need all this checking for null. To simplify the method you could create a similar methods that will do the same but without some actions.

But I would optimize only when it hits the performance, though, I like early optimization. This one is not the case as it's not intended to be used 1000000 times per frame. As well as removing null checks and some actions would be a micro-optimization.

Also you can always add more actions, for while loop condition check and for the way time elapsing is calculated.

For example, add getElapsingValue:

public IEnumerator Count(
    float targetTime,
    System.Func<float> getElapsingValue,
    System.Action<float> receiveTimeElapsed = null,
    System.Func<bool> actionCondition = null,
    System.Action conditionalAction = null,
    System.Action onCountStart = null,
    System.Action onCountEnd = null)
{
    onCountStart?.Invoke();

    float timeElapsed = 0f;
    receiveTimeElapsed?.Invoke(timeElapsed);

    while (timeElapsed < targetTime) // You want to add func here to make it more scalable.
    {
        if (actionCondition != null && actionCondition.Invoke())
            conditionalAction?.Invoke();

        yield return null;

        timeElapsed += getElapsingValue.Invoke();

        receiveTimeElapsed?.Invoke(timeElapsed);
    }

    if (actionCondition != null && actionCondition.Invoke())
        conditionalAction?.Invoke();

    onCountEnd?.Invoke();
}

private float _timeElapsed;
private int _count;

private void Awake()
{
    this.StartCoroutine(
        this.Count(
            5f,
            () => { return Time.deltaTime; },
            (timeElapsed) =>
            {
                this._timeElapsed = timeElapsed;
                Debug.Log("Time Elapsed: " + this._timeElapsed);
            },
            () => { return this._timeElapsed >= (this._count + 1); },
            () =>
            {
                this._count++;

                Debug.Log("Countdown: " + this._count);
            },
            () => { Debug.Log("Countdown: " + this._count); },
            () => { Debug.Log("On countdown end"); }
        )
    );
}

To actually take countdown value you need to edit the method. Or you could simply do this this._countdown - this._count which will give you the desired value anyway.

Answer 4

This seemed a simple solution: you can use st.Reset() etc as you need in your own code.

[SerializeField] private TextMeshProUGUI countDownDisplay;
Stopwatch st = new Stopwatch();

void SomeEvent() {
    st.Start();
}

void Update()
{
    if (st.IsRunning)
    {
        int secondsUntilDestructSequence = 5;
        int elaspedSeconds = Mathf.RoundToInt((st.ElapsedMilliseconds / 1000) % 60f);
        int secondsRemaining = secondsUntilDestructSequence - elaspedSeconds;
        countDownDisplay.text = "Countdown remaining: " + secondsRemaining;
        if (secondsRemaining==0) Debug.Log("Game Over");
    }
}

Answer 5

[SerializeField] private Text _textTimer;

[SerializeField] private sbyte _seconds;
[SerializeField] private sbyte _minutes;
[SerializeField] private sbyte _hours;


// Start is called before the first frame update
void Start()
{
    StartCoroutine(Timer());
}


IEnumerator Timer()
{
    while(true)
    {
        _seconds--;

        if(_seconds < 0)
        {
            _seconds += 60;
            _minutes--;
        }

        if (_minutes < 0)
        { 
            _minutes += 60;
            _hours--;
        }

        _textTimer.text = $"{_hours:D2}:{_minutes:D2}:{_seconds:D2}";

        if (_seconds == 0 && _minutes == 0 && _hours == 0)
            StopAllCoroutines();

        yield return new WaitForSeconds(1);
    }
}