Pardon our dust! Docs for Yarn Spinner for Unity 3.2 and Yarn Spinner for Godot C# are on docs.yarnspinner.dev (the old docs site). Docs for Yarn Spinner for Unity 3.3 (pre-release, out ASAP), Yarn Spinner for Godot GDScript and Yarn Spinner for Unreal Engine (work in progress) are on /docs/ (the new docs site).

ActionRegistrationExtension

Contains extension methods for IActionRegistration objects.
public static class ActionRegistrationExtension

Inherits from System.Object

#Methods

#AddCommandHandler(IActionRegistration, string, System.Action)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler(this IActionRegistration registration, string commandName, System.Action handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler(IActionRegistration, string, System.Func<Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler(this IActionRegistration registration, string commandName, System.Func<Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler(IActionRegistration, string, System.Func<IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler(this IActionRegistration registration, string commandName, System.Func<IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler(IActionRegistration, string, System.Func<System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler(this IActionRegistration registration, string commandName, System.Func<System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler(IActionRegistration, string, System.Func<YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler(this IActionRegistration registration, string commandName, System.Func<YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(IActionRegistration, string, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(this IActionRegistration registration, string commandName, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(IActionRegistration, string, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(this IActionRegistration registration, string commandName, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(IActionRegistration, string, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this IActionRegistration registration, string commandName, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(IActionRegistration, string, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this IActionRegistration registration, string commandName, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(IActionRegistration, string, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this IActionRegistration registration, string commandName, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(IActionRegistration, string, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this IActionRegistration registration, string commandName, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(IActionRegistration, string, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this IActionRegistration registration, string commandName, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9>(IActionRegistration, string, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this IActionRegistration registration, string commandName, System.Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1, T2, T3, T4, T5, T6, T7, T8, T9>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8>(IActionRegistration, string, System.Action<T1, T2, T3, T4, T5, T6, T7, T8>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8>(this IActionRegistration registration, string commandName, System.Action<T1, T2, T3, T4, T5, T6, T7, T8> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1, T2, T3, T4, T5, T6, T7, T8>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7, T8>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, T8, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7>(IActionRegistration, string, System.Action<T1, T2, T3, T4, T5, T6, T7>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7>(this IActionRegistration registration, string commandName, System.Action<T1, T2, T3, T4, T5, T6, T7> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1, T2, T3, T4, T5, T6, T7>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6, T7>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6, T7>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, T7, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, T7, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6>(IActionRegistration, string, System.Action<T1, T2, T3, T4, T5, T6>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6>(this IActionRegistration registration, string commandName, System.Action<T1, T2, T3, T4, T5, T6> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1, T2, T3, T4, T5, T6>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5, T6>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5, T6>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, T6, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, T6, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5>(IActionRegistration, string, System.Action<T1, T2, T3, T4, T5>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5>(this IActionRegistration registration, string commandName, System.Action<T1, T2, T3, T4, T5> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1, T2, T3, T4, T5>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4, T5>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4, T5>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, T5, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, T5, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4>(IActionRegistration, string, System.Action<T1, T2, T3, T4>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4>(this IActionRegistration registration, string commandName, System.Action<T1, T2, T3, T4> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1, T2, T3, T4>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4>(IActionRegistration, string, System.Func<T1, T2, T3, T4, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4>(IActionRegistration, string, System.Func<T1, T2, T3, T4, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4>(IActionRegistration, string, System.Func<T1, T2, T3, T4, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3, T4>(IActionRegistration, string, System.Func<T1, T2, T3, T4, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3, T4>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, T4, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, T4, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3>(IActionRegistration, string, System.Action<T1, T2, T3>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3>(this IActionRegistration registration, string commandName, System.Action<T1, T2, T3> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1, T2, T3>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3>(IActionRegistration, string, System.Func<T1, T2, T3, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3>(IActionRegistration, string, System.Func<T1, T2, T3, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3>(IActionRegistration, string, System.Func<T1, T2, T3, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2, T3>(IActionRegistration, string, System.Func<T1, T2, T3, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2, T3>(this IActionRegistration registration, string commandName, System.Func<T1, T2, T3, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, T3, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2>(IActionRegistration, string, System.Action<T1, T2>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2>(this IActionRegistration registration, string commandName, System.Action<T1, T2> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1, T2>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2>(IActionRegistration, string, System.Func<T1, T2, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2>(this IActionRegistration registration, string commandName, System.Func<T1, T2, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2>(IActionRegistration, string, System.Func<T1, T2, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2>(this IActionRegistration registration, string commandName, System.Func<T1, T2, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2>(IActionRegistration, string, System.Func<T1, T2, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2>(this IActionRegistration registration, string commandName, System.Func<T1, T2, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1, T2>(IActionRegistration, string, System.Func<T1, T2, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1, T2>(this IActionRegistration registration, string commandName, System.Func<T1, T2, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, T2, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1>(IActionRegistration, string, System.Action<T1>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1>(this IActionRegistration registration, string commandName, System.Action<T1> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerAction<T1>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1>(IActionRegistration, string, System.Func<T1, Coroutine>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1>(this IActionRegistration registration, string commandName, System.Func<T1, Coroutine> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, Coroutine>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1>(IActionRegistration, string, System.Func<T1, IEnumerator>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1>(this IActionRegistration registration, string commandName, System.Func<T1, IEnumerator> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, IEnumerator>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1>(IActionRegistration, string, System.Func<T1, System.Threading.Tasks.Task>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1>(this IActionRegistration registration, string commandName, System.Func<T1, System.Threading.Tasks.Task> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, System.Threading.Tasks.Task>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddCommandHandler<T1>(IActionRegistration, string, System.Func<T1, YarnTask>)

Adds a command handler and registers the command with Yarn as one that can be called.
public static void AddCommandHandler<T1>(this IActionRegistration registration, string commandName, System.Func<T1, YarnTask> handler);

Parameters

  • commandNamestring
    The name of the command.
  • handlerFunc<T1, Yarn.Unity.YarnTask>
    The CommandHandler that will be invoked when the command is called.

You can also register commands via the YarnCommandAttribute attribute on your methods.

When this command handler has been added, it can be called from your Yarn scripts like so:

     <<commandName param1 param2>>
     

If handler is a method that returns a YarnTask, Task, Awaitable, or UniTask when the command is run, the DialogueRunner will wait for the task to finish before delivering any more content.

If handler is a method that returns a Coroutine, when the command is run, the DialogueRunner will wait for the returned coroutine to stop before delivering any more content.

If handler is a method that returns an System.Collections.IEnumerator, when the command is run, the DialogueRunner will start a coroutine using that method and wait for that coroutine to stop before delivering any more content.

#AddFunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>)

Add a new function that returns a value, so that it can be called from Yarn scripts.
public static void AddFunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(this IActionRegistration registration, string name, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> implementation);

Type Parameters

  • TResult
    The result of the function.

Parameters

  • namestring
    The name of the function to add.
  • implementationFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>
    The System.Delegate that should be invoked when this function is called.

You can also register functions via the YarnFunctionAttribute attribute on your methods.

When this function has been registered, it can be called from your Yarn scripts like so:

     <<if myFunction(1, 2) == true>>
         myFunction returned true!
     <<endif>>
     

See also

  • Library

#AddFunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>)

Add a new function that returns a value, so that it can be called from Yarn scripts.
public static void AddFunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(this IActionRegistration registration, string name, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> implementation);

Type Parameters

  • TResult
    The result of the function.

Parameters

  • namestring
    The name of the function to add.
  • implementationFunc<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>
    The System.Delegate that should be invoked when this function is called.

You can also register functions via the YarnFunctionAttribute attribute on your methods.

When this function has been registered, it can be called from your Yarn scripts like so:

     <<if myFunction(1, 2) == true>>
         myFunction returned true!
     <<endif>>
     

See also

  • Library

#AddFunction<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult>)

Add a new function that returns a value, so that it can be called from Yarn scripts.
public static void AddFunction<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this IActionRegistration registration, string name, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> implementation);

Type Parameters

  • TResult
    The result of the function.

Parameters

  • namestring
    The name of the function to add.
  • implementationFunc<T1, T2, T3, T4, T5, T6, T7, T8, TResult>
    The System.Delegate that should be invoked when this function is called.

You can also register functions via the YarnFunctionAttribute attribute on your methods.

When this function has been registered, it can be called from your Yarn scripts like so:

     <<if myFunction(1, 2) == true>>
         myFunction returned true!
     <<endif>>
     

See also

  • Library

#AddFunction<T1, T2, T3, T4, T5, T6, T7, TResult>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, T7, TResult>)

Add a new function that returns a value, so that it can be called from Yarn scripts.
public static void AddFunction<T1, T2, T3, T4, T5, T6, T7, TResult>(this IActionRegistration registration, string name, System.Func<T1, T2, T3, T4, T5, T6, T7, TResult> implementation);

Type Parameters

  • TResult
    The result of the function.

Parameters

  • namestring
    The name of the function to add.
  • implementationFunc<T1, T2, T3, T4, T5, T6, T7, TResult>
    The System.Delegate that should be invoked when this function is called.

You can also register functions via the YarnFunctionAttribute attribute on your methods.

When this function has been registered, it can be called from your Yarn scripts like so:

     <<if myFunction(1, 2) == true>>
         myFunction returned true!
     <<endif>>
     

See also

  • Library

#AddFunction<T1, T2, T3, T4, T5, T6, TResult>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, T6, TResult>)

Add a new function that returns a value, so that it can be called from Yarn scripts.
public static void AddFunction<T1, T2, T3, T4, T5, T6, TResult>(this IActionRegistration registration, string name, System.Func<T1, T2, T3, T4, T5, T6, TResult> implementation);

Type Parameters

  • TResult
    The result of the function.

Parameters

  • namestring
    The name of the function to add.
  • implementationFunc<T1, T2, T3, T4, T5, T6, TResult>
    The System.Delegate that should be invoked when this function is called.

You can also register functions via the YarnFunctionAttribute attribute on your methods.

When this function has been registered, it can be called from your Yarn scripts like so:

     <<if myFunction(1, 2) == true>>
         myFunction returned true!
     <<endif>>
     

See also

  • Library

#AddFunction<T1, T2, T3, T4, T5, TResult>(IActionRegistration, string, System.Func<T1, T2, T3, T4, T5, TResult>)

Add a new function that returns a value, so that it can be called from Yarn scripts.
public static void AddFunction<T1, T2, T3, T4, T5, TResult>(this IActionRegistration registration, string name, System.Func<T1, T2, T3, T4, T5, TResult> implementation);

Type Parameters

  • TResult
    The result of the function.

Parameters

  • namestring
    The name of the function to add.
  • implementationFunc<T1, T2, T3, T4, T5, TResult>
    The System.Delegate that should be invoked when this function is called.

You can also register functions via the YarnFunctionAttribute attribute on your methods.

When this function has been registered, it can be called from your Yarn scripts like so:

     <<if myFunction(1, 2) == true>>
         myFunction returned true!
     <<endif>>
     

See also

  • Library

#AddFunction<T1, T2, T3, T4, TResult>(IActionRegistration, string, System.Func<T1, T2, T3, T4, TResult>)

Add a new function that returns a value, so that it can be called from Yarn scripts.
public static void AddFunction<T1, T2, T3, T4, TResult>(this IActionRegistration registration, string name, System.Func<T1, T2, T3, T4, TResult> implementation);

Type Parameters

  • TResult
    The result of the function.

Parameters

  • namestring
    The name of the function to add.
  • implementationFunc<T1, T2, T3, T4, TResult>
    The System.Delegate that should be invoked when this function is called.

You can also register functions via the YarnFunctionAttribute attribute on your methods.

When this function has been registered, it can be called from your Yarn scripts like so:

     <<if myFunction(1, 2) == true>>
         myFunction returned true!
     <<endif>>
     

See also

  • Library

#AddFunction<T1, T2, T3, TResult>(IActionRegistration, string, System.Func<T1, T2, T3, TResult>)

Add a new function that returns a value, so that it can be called from Yarn scripts.
public static void AddFunction<T1, T2, T3, TResult>(this IActionRegistration registration, string name, System.Func<T1, T2, T3, TResult> implementation);

Type Parameters

  • TResult
    The result of the function.

Parameters

  • namestring
    The name of the function to add.
  • implementationFunc<T1, T2, T3, TResult>
    The System.Delegate that should be invoked when this function is called.

You can also register functions via the YarnFunctionAttribute attribute on your methods.

When this function has been registered, it can be called from your Yarn scripts like so:

     <<if myFunction(1, 2) == true>>
         myFunction returned true!
     <<endif>>
     

See also

  • Library

#AddFunction<T1, T2, TResult>(IActionRegistration, string, System.Func<T1, T2, TResult>)

Add a new function that returns a value, so that it can be called from Yarn scripts.
public static void AddFunction<T1, T2, TResult>(this IActionRegistration registration, string name, System.Func<T1, T2, TResult> implementation);

Type Parameters

  • TResult
    The result of the function.

Parameters

  • namestring
    The name of the function to add.
  • implementationFunc<T1, T2, TResult>
    The System.Delegate that should be invoked when this function is called.

You can also register functions via the YarnFunctionAttribute attribute on your methods.

When this function has been registered, it can be called from your Yarn scripts like so:

     <<if myFunction(1, 2) == true>>
         myFunction returned true!
     <<endif>>
     

See also

  • Library

#AddFunction<T1, TResult>(IActionRegistration, string, System.Func<T1, TResult>)

Add a new function that returns a value, so that it can be called from Yarn scripts.
public static void AddFunction<T1, TResult>(this IActionRegistration registration, string name, System.Func<T1, TResult> implementation);

Type Parameters

  • TResult
    The result of the function.

Parameters

  • namestring
    The name of the function to add.
  • implementationFunc<T1, TResult>
    The System.Delegate that should be invoked when this function is called.

You can also register functions via the YarnFunctionAttribute attribute on your methods.

When this function has been registered, it can be called from your Yarn scripts like so:

     <<if myFunction(1, 2) == true>>
         myFunction returned true!
     <<endif>>
     

See also

  • Library

#AddFunction<TResult>(IActionRegistration, string, System.Func<TResult>)

Add a new function that returns a value, so that it can be called from Yarn scripts.
public static void AddFunction<TResult>(this IActionRegistration registration, string name, System.Func<TResult> implementation);

Type Parameters

  • TResult
    The result of the function.

Parameters

  • namestring
    The name of the function to add.
  • implementationFunc<TResult>
    The System.Delegate that should be invoked when this function is called.

You can also register functions via the YarnFunctionAttribute attribute on your methods.

When this function has been registered, it can be called from your Yarn scripts like so:

     <<if myFunction(1, 2) == true>>
         myFunction returned true!
     <<endif>>
     

See also

  • Library

Generated from Yarn Spinner for Unity 3.3.