Callables is an abstraction of visual scripting that defines the core of Gameplay Ingredients Runtime. A Callable is a script that can be Called, to perform a certain task. There are two main types of callable used in gameplay ingredients : Logic and Actions. In order to call them out of gameplay events, Events are not Callables per se but use callables to start scritping chains of calls.

Through Gameplay Ingredients, there are many more scripts that makes use of callables : State Machines, Factories, Counters, Timers, Interactive, some Rigs, and also some Managers


Callables can be called, passing an Instigator argument: a source object that was involved in the script execution, and that can be processed by any Callable in the chain of calls.

For Example : A OnTriggerEnter Event, can call a DelayLogic, then a DestroyObjectAction defined on destroying the instigator. In this case, the Instigator will be first set by the OnTriggerEvent to be the object that entered the trigger (for example, the player). Then it will be passed to the Delay Logic, then to the Destroy Object. This final action will use its instigator argument which is the player game object that entered the trigger, and will be able to destroy it.

Difference with UnityEvents

While UnityEvents are convenient as they can call most of the C# API, the Callable can only call callables. However, the need for automatic instigator propagation, call reordering and debug handling of all these calls makes the use of Callables more suited. Regardles of that, the UnityEventAction is provided to be able to perform UnityEvent calls at anytime. However, the instigator still can't be passed on as argument to these UnityEvent calls at the moment.

Editing Callable Lists

Events, Logic and Actions (but also other components such as States, Managers, Factories, ... ) can call scripts from other callable components. Editing in inspector of these lists can be achieved through a reorderable list where calls can be added in chronological order.

  • Click the + button to add a new entry, then drag onto the Object field the game object or the component you want to add.

  • You can use the popup drop-down to select any callable component on the target game object.

Previewing the hierarchy of calls

You can preview the hierarchy of calls in editor by using the Callable Tree Explorer Window. This window allows you to get an overview of what's being called.

You can also enable Verbose Call Logging in the Gameplay Ingredients Settings asset.

Calling Callables (C#)

Callables can be Called using the Static Method GameplayIngredients.Callable.Call(call, instigator) where call can be of the following:

  • single Callable object
  • Callable[] array

instigator parameter is of type GameObject and defaults to null so it's mandatory.

Performance and Update Calls

Because calling an update message object has performance implications in unity, most of the callable system is designed to be run at non-update time. In order to perform runtime update calls, prefer using Rigs (still under development)

An option is still available in settings to enable some of the update calls. Use at your own risk !

Writing Callables

You can write your own callables my making them derive from the ICallable interface, or derive from GameplayIngredients.Actions.ActionBase or GameplayIngredients.Logic.LogicBase if you prefer to be consistent to the events-logic-actions philosophy.

The ICallable interface is pretty straightforward:

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

namespace GameplayIngredients
    public interface ICallable
        void Execute(GameObject instigator = null);


Implementing Callables enable you to reference them in the Callable Lists, and view them in the Callable Tree Explorer