Find time since a variable was changed

Question

How would you find the time since a certain variable was changed? Take for example a boolean variable, how would you find the time since it was last changed? I want to use the boolean variable as a trigger (activating the trigger when it's true), but only after an exact, constant time (such as 0.5s) has passed since it was changed to true (it can only be changed from false to true).

Here is the code I have:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class hitRegistration : MonoBehaviour
{

    AudioSource hitSound;
    private bool hitState = false;
    // Use this for initialization
    void Start()
    {
        hitSound = gameObject.GetComponent<AudioSource>();
    }
    void OnMouseOver()
    {
        Debug.Log("Mouse is over game object.");
        if (Input.GetKey(KeyCode.X) && hitState == false)
        {
            hitSound.Play();
            hitState = true;
        }
    }
    private void OnMouseExit()
    {
        Debug.Log("Mouse is no longer over game object.");
        if (hitState == true)
        {
            // sound clip gets cut if the cursor leaves before its finished.
            Destroy(gameObject);
        }
    }

    // Update is called once per frame
    void Update()
    {

    }
}

"OnMouseOver()" Is simply a function that is called when the mouse is placed over the game object in question. I want to delay destroying the game object until a certain time has passed.

Answer 1

First off, as noted in a comment, you are probably trying to solve this problem the wrong way and you are probably asking an "XY" question -- a question where you are asking a question about a proposed bad solution instead of asking a question about the actual problem you face.

To answer the question you actually asked, for better or worse: there is no way to associate behaviours with reading or writing a variable in C#, but you can associate behaviours with a property:

private bool hitState; // The "backing store".
private bool HitState 
{
  get 
  {
    return hitState;
  }
  set
  {
    hitState = value;
  }
}

You would then use HitState rather than hitState throughout the rest of your class.

Now you can add whatever logic you want that happens when the property is read or written:

private DateTime hitStateTime = default(DateTime);
private bool hitState; // The "backing store".
private bool HitState 
{
  get 
  {
    return hitState;
  }
  set
  {
    hitState = value;
    hitStateSet = DateTime.Now;
  }
}

Now you know when it was set. And so on.

Answer 2

Unless you really need to keep track of how much time has passed on each single frame, one way to do what you are asking for is to use Unity Coroutines.

A coroutine is a method that runs in parallel with the main thread. To solve your question, you can first create a coroutine in the same script, that waits and then does the thing you want to have delayed. A couroutine in Unity is a method that takes up to one parameter and has an IEnumerator return type. You use yield return WaitForSeconds(t); inside the coroutine to have it delay for t seconds.

Then, once it's time to die, check if the mouse is currently hovering over the object with isHovered (set in your OnMouseOver/OnMouseExit methods). If it is, keep a note that it's time to die. If it isn't, then it can die immediately.

IEnumerator WaitToDie(float delaySeconds) 
{
    yield return new WaitForSeconds(delaySeconds);

    // If the mouse is on the object, let OnMouseExit know we're ready to die
    if (isHovered) 
    {
        readyToDie = true;
    } 
    // Otherwise, just die
    else 
    {
        Destroy(gameObject)
    }

}

And then inside your OnMouseOver code, run the coroutine after starting the sound

void OnMouseOver()
{
    isHovered = true;

    Debug.Log("Mouse is over game object.");
    if (Input.GetKey(KeyCode.X) && !hitState)
    {

        hitState = true;
        hitSound.Play();

        // we want to delay for half a second before processing the hit.
        float delaySeconds = 0.5; 
        IEnumerator coroutine = WaitToDie(delaySeconds);

        StartCoroutine(coroutine);
    }
}

And in your OnMouseExit, let everything know that you're done hovering and check if it's past time to die or not.

private void OnMouseExit()
{
    isHovered = false;
    Debug.Log("Mouse is no longer over game object.");

    if (readyToDie) {
        Destroy(gameObject);
    } 

}

Altogether this code will have the object die when both the mouse is off the object AND the time has elapsed.

As a sidenote, I think you might want to revisit how you are checking for a hit, unless your really want to trigger from the player holding X and then moving the mouse over the object. If you intend to trigger any time X is pressed down while the mouse is on top, you might want to put the check in Update and check Input.GetKey(KeyCode.X) && !hitState && isHovered

Answer 3

keep a seperate variable(DateTime) and call it lastUpdate. then be sure to set it to DateTime.Now, each time the bool you're tracking is updated. then when you need to see how long its been you can just subtract:

DateTime lengthOfTime = DateTime.Now-lastUpdate;

from lengthOfTime you can now access how many days, hours, minutes, and/or seconds have passed.

im on my phone so take it easy on my pseudo-code.

good luck