Timer

public Timer();

Creates a stopped Timer Entity outside the tree. Defaults: WaitTime = 1 second, ProcessCallback = Idle; Autostart, OneShot, Paused and IgnoreTimeScale are false. Add it to the active tree before Start.

public bool Autostart { get; set; }

Automatically starts the timer at Ready, then resets to false. This is not an immediate start command for an already ready object: use Start for that. Autostart is suppressed for the document being edited in the editor.

public bool IgnoreTimeScale { get; set; }

Selects unscaled time. Does not automatically allow processing when ProcessMode prohibits it under pause.

public bool OneShot { get; set; }

If true, automatic expiry stops the countdown before Timeout. If false, expiry adds WaitTime and processing continues. The timer remains an Entity in the tree; this mode does not delete it.

public bool Paused { get; set; }

Pauses this Timer rather than the whole EntityTree. Tree ProcessMode conditions remain separate.

public Timer.TimerProcessCallback ProcessCallback { get; set; }

Selects the update phase: Idle for process frames, Physics for physics ticks. Does not select a separate thread or bypass Paused or ProcessMode conditions.

public double TimeLeft { get; }

Remaining countdown in seconds, clamped to a minimum of zero; read-only. A stopped timer reports 0; a paused timer retains its countdown. A zero value alone does not mean the Entity was deleted.

public double WaitTime { get; set; }

Interval in seconds. Supply a finite positive number; a value <= 0 reports a native error and retains the previous interval, rather than guaranteeing a CLR exception. Changing this property neither starts the timer nor resets its remaining time. Very short intervals depend on the chosen update rate; this is not an independent high-precision system timer.

public double GetTimeLeft();

Returns TimeLeft without changing timer state. See the property contract for details.

public Timer.TimerProcessCallback GetTimerProcessCallback();

Returns ProcessCallback without changing timer state. See the property contract for details.

public double GetWaitTime();

Returns WaitTime without changing timer state. See the property contract for details.

public bool HasAutostart();

Returns Autostart without changing timer state. See the property contract for details.

public bool IsIgnoringTimeScale();

Returns IgnoreTimeScale without changing timer state. See the property contract for details.

public bool IsOneShot();

Returns OneShot without changing timer state. See the property contract for details.

public bool IsPaused();

Returns Paused without changing timer state. See the property contract for details.

public bool IsStopped();

Checks GetTimeLeft() <= 0. Returns true for a new or stopped timer; a pause with positive remaining time is not a stop. An overdue repeating timer can also report zero: the method does not inspect the processing flag or Entity existence.

public void SetAutostart(bool enable);

Sets Autostart with the same rules as the property. This is not a separate timer-start operation.

public void SetIgnoreTimeScale(bool ignore);

Sets IgnoreTimeScale with the same rules as the property. This is not a separate timer-start operation.

public void SetOneShot(bool enable);

Sets OneShot with the same rules as the property. This is not a separate timer-start operation.

public void SetPaused(bool paused);

Sets Paused with the same rules as the property. This is not a separate timer-start operation.

public void SetTimerProcessCallback(Timer.TimerProcessCallback callback);

Sets ProcessCallback with the same rules as the property. This is not a separate timer-start operation.

public void SetWaitTime(double timeSec);

Sets WaitTime with the same rules as the property. This is not a separate timer-start operation.

public void Start(double timeSec = -1d);

Starts or resets the countdown in the active tree. A positive timeSec first replaces WaitTime; zero and negative values reuse the previous interval. Does not clear Paused. Calling outside the tree reports a native error; do not rely on a CLR exception.

The complete example validates inputs and subscribes before starting. The returned Timer remains a child of parent after expiry. Call Stop to cancel its countdown; use QueueFree when the Entity is no longer needed.

using System;
using Reckfell;

public static class TimerExample
{
    // The returned Timer remains a child of parent after its one timeout.
    public static Timer StartOnce(Entity parent, double seconds, Action onTimeout)
    {
        ArgumentNullException.ThrowIfNull(parent);
        ArgumentNullException.ThrowIfNull(onTimeout);
        if (!parent.IsInsideTree())
            throw new ArgumentException("Parent must be inside the active tree.", nameof(parent));
        if (!double.IsFinite(seconds) || seconds <= 0)
            throw new ArgumentOutOfRangeException(nameof(seconds));
        var timer = new Timer { OneShot = true };
        parent.AddChild(timer);
        timer.Timeout += onTimeout;
        timer.Start(seconds);
        return timer;
    }
}

public void Stop();

Stops processing, makes the visible TimeLeft zero and clears Autostart. Does not emit Timeout or delete the Entity. Safe outside the tree. An await for Timeout is not automatically cancelled or completed.

public event Action Timeout;

Argument-free signal for automatic countdown expiry. Subscribe before Start. With OneShot the timer is already stopped; a repeating timer continues processing. Stop does not itself emit this signal.