WaitForSecondsAction

Concrete Action that pauses execution for a configurable number of seconds using the Yield async system. This is the canonical example of an async, cancellable action.

Definition

Namespace: Paragon.Core.ActionSystem Assembly: Paragon.dll

public class WaitForSecondsAction : Action

Inheritance: Action → WaitForSecondsAction

Remarks

WaitForSecondsAction demonstrates the recommended pattern for time-based async actions. It uses Yield.WaitForSeconds() from Paragon.Core.Async, which integrates with the CancellableTask system — meaning this action is automatically cancellable at the yield point without any manual cancellation token handling.

The duration field is marked with [Variable], allowing it to be set via the Inspector, through the variable API (SetVariable), or bound from an ActionVariable.

Quick Lookup

Goal	How
Wait 2 seconds	Set duration to 2f, call Execute()
Set duration via API	action.SetVariable("duration", 2f)
Cancel mid-wait	action.Cancel()
Await completion	await action.ExecuteAsync()

Methods

OnExecute

Awaits the configured duration using the Yield system. Cancellation is automatically handled at the yield point.

protected override async Task OnExecute()

Behavior: Calls await Yield.WaitForSeconds(duration), which suspends execution for duration seconds (in real time). If Cancel() is called during the wait, the CancellableTask terminates execution at the yield point.

Properties (Variable Fields)

Field	Type	Access	Description
duration	float	private / [Variable]	Time in seconds to wait before completing

Common Pitfalls

Do not use Task.Delay() as a replacement Task.Delay() does not integrate with Unity's frame loop or the CancellableTask system. Always use Yield.WaitForSeconds() for time-based waiting in actions.

Duration is applied before execution Because duration is a [Variable] field, its value is synced from the variable system via ApplyFieldVariables() before OnExecute() runs. Setting the variable via SetVariable("duration", value) before calling Execute() will be reflected correctly.

Examples

Basic Usage

var wait = new WaitForSecondsAction();
wait.SetVariable("duration", 3f);
await wait.ExecuteAsync(); // Resumes after 3 seconds

In an ActionSequence

// Create a sequence with a delay between actions
var sequence = new ActionSequence();
sequence.Add(new LogAction());           // Logs immediately
sequence.Add(new WaitForSecondsAction()); // Waits (set duration via variable)
sequence.Add(new LogAction());           // Logs after wait

Cancellation

var wait = new WaitForSecondsAction();
wait.SetVariable("duration", 10f);
wait.Execute(); // Fire-and-forget

// Later, cancel the wait early
if (wait.IsRunning)
    wait.Cancel();

See Also

• Action — base class with lifecycle documentation

• TestAction — synchronous implementation example

• Implementations Overview — all built-in actions