Which timer is more efficient ?

Questions & Answers
1

Hey everyone - I was wondering which of these methods would be more efficient in terms of performance - both are easy to implement and easy to read.

Method 1 :

private float timer = 0f;
private float coolDown = 10f;

void Start(){

    timer = coolDown;

}

void Update() {

    if(timer <= coolDown) 

        timer -= time.deltaTime; 

    if(timer < 0f ) 
        
        timer = 0f;
        CallSomeFunction();

}

private void CallSomeFunction(){

    //some code;
    timer = coolDown;

}

this how I did it for quite a while .
Recently I stumbled upon something like this :

Method 2 : 

private float timer = 0f;
private float coolDown = 10f;



Update(){
    if(timer + coolDown > Time.fixedTime){

        // CallSomeFunction;
    }

}

private void CallSomeFunction(){

    // function stuff
    timer = Time.fixedTime;

}

I know - in the end both methods (should - if I didn’t make some stupid errors) work and they both should not make significant efficiency differences , BUT method 2 would create some really big numbers if I would run the game for a couple of days without a break -wouldn’t it ? On the other hand, I would save on those stupid conditions for the timer.
btw. I know how to use Mathf.Clamp(timer, 0, coolDown); I just don’t like it. ( however if clamping is very good prog. practice please let me know - i am pretty new and want to learn properly!)

Thank you for your help and opinions.
Cheers 

Daniel
2

Personally, I use this:

public float thingyDelay = 5.0f;
private float thingyNext = 0.0f;

void Update()
{
    if (Time.time > thingyNext)
    {
        thingyNext = Time.time + thingyDelay;
        doThingy();
    }

}

I don’t think you have to worry about overflow (the max float value is something like 3.4x10^38 which translates to 1.1x10^31 years). As MadDave mentions, precision decreases with larger float numbers, but unless you’re planning to leave your app running solidly for a couple of centuries, I wouldn’t worry.

4

How about using Invoke which is much less hard to read. I notice in a number of these examples the function is called repeatedly after the timer runs out - that might be desired (and InvokeRepeating provides this functionality) or it might be undesired which requires a lot more code.

A coroutine is another way to avoid having all of those timing checks when the condition has elapsed.

3

Big numbers are generally bad. Float precision decreases as numbers get bigger, that’s why I would always go for option 1.
Performance is really not an issue here. It’s very hard to say which version is actually faster.