A list of all available nodes for formulas.

Formulas are used to calculate a value and uses individual nodes to manipulate the result. There are currently 63 formula nodes available (excluding nodes from extensions, e.g. ORK Framework).

Base #

Layer Gate #

Connects two layers.

Empty #

This is an empty node.
This node being empty can be the result of a custom node script not being found (e.g. removed from the project).

Random #

Randomly executes a next node out of a list of defined nodes.

Comment #

Leave a comment in your formula.
This node does nothing and is only for commentary purposes.

Chance #

Which node will be executed next is decided by chance.
The chance is checked against a random number between two values (default 0 and 100, you can change this in the game settings).
The next node of the first defined value range, that includes the chance, will be executed.
If no range contains the chance, ‘Failed’ will be executed.

Loop #

Increases an int variable by one until it reaches a defined maximum value.
Use this node to easily loop nodes for a number of times before continuing with the rest of the formula.
If the loop finished (i.e. the int variable being max count or larger), ‘Finished’ will be executed next, otherwise ‘Loop’.

Math Function #

Uses a Mathf function on the current value of the formula.

Unity Console #

Prints a text to the Unity console using ‘Debug.Log()’.

Begin Sub Calculation #

Starts a new calculation as part of the formula (i.e. used as ‘left parenthesis’).
Everything within a sub calculation will be calculated until it’s corresponding ‘End Sub Calculation’ node and added to the previous formula value using the defined operator.
Any open sub calculation will be closed at the end of the formula’s calculation, before using the formula’s min/max value limits.

End Sub Calculation #

Closes the last opened sub calculation (i.e. used as ‘right parenthesis’).
The sub calculation’s current value (result) will be used to change the previous formula value using it’s corresponding ‘Begin Sub Calculation’ node’s operator.

Float #

Float Atan2 #

Uses the angle in radians whose Tan is y/x to change the current formula value or stores it into a float variable.

Float Clamp #

Clamps a float value between a minimum and maximum and stores it into a float variable.

Float Delta Angle #

Calculates the shortest difference between two angles and stores it into a float variable.

Float Inverse Lerp #

Calculates the Lerp parameter between two values and stores it into a float variable.

Float Lerp #

Interpolates between two values and stores it into a float variable.

Float Move Towards #

Moves a value current toward target and stores it into a float variable.

Float Perlin Noise #

Generates 2D perlin noise and stores it into a float variable.

Float Ping Pong #

PingPongs or loops (repeats) a value, so that it is never larger than length and never smaller than 0, and stores it into a float variable.

Float Smooth Step #

Interpolates between two values with smoothing at the limits and stores it into a float variable.

Float To Angle #

Changes a float value into an angle (i.e. between 0 and 360) and stores it into a float variable.
E.g. -90 will become 270, 480 will become 120.

Float is Power of 2 #

Checks if an int value is power of two.
If check is valid, ‘Success’ will be executed, otherwise ‘Failed’.

Position #

Distance #

The distance between user and target is used.

Check Distance #

The distance between user and target is checked with the current value of the formula or a defined value.
If the check is true, ‘Success’ will be executed next, otherwise ‘Failed’.

Angle #

The angle between user and target (-180 – 180) is used.

Check Angle #

The angle between user and target is checked with the current value of the formula or a defined value.
If the check is true, ‘Success’ will be executed next, otherwise ‘Failed’.

Check Orientation #

Checks the orientation from user to target (e.g. if the target is in front of the user).
If the check is true, ‘Success’ will be executed next, otherwise ‘Failed’.

Check Height Differences #

Checks if the target is above or below the user.
If the check is valid, ‘Success’ will be executed next, otherwise ‘Failed’.

Selected Data #

Clear Selected Data #

Clears/removes selected data.
Either removes all data of a defined data key, or removes all data.

Selected Data Count #

Checks how many data is stored in a selected data list or uses the count to change the formula value.
When checking and if the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.

Select Selected Data #

Uses the first, last, a random or all content from another selected data as selected data.
E.g. select a random content from a list of data.
If something was stored, ‘Success’ will be executed, otherwise (i.e. nothing left to store) ‘Failed’.

Select Variable Handlers #

Uses variable handlers to change selected data.
A variable handler stores all variables of an origin, e.g. the global variables or object variables of a game object.

Select Components #

Uses components to change selected data.

Select Game Objects #

Uses game objects to change selected data.

Value #

Value #

A single value is used.

Random Value #

A random value between two values is used.

Minimum Value #

The smaller value of two values is used.

Maximum Value #

The bigger value of two values is used.

Check Value #

A value (e.g. the current value of the formula will be checked with a defined value.
If the check is true, ‘Success’ will be executed next, otherwise ‘Failed’.

Limit Value #

The current value of the formula will be limited.

Function Value #

The return value of a called function is used.
Requires a function that takes a ‘FormulaCall’ as parameter, which gives you access to the user/target of the formula, current value and local variables/selected data, e.g.:
public float YourFunction(FormulaCall call)

Field Value #

The value of an int or float field/property is used.

Variable #

Store Formula Value #

Stores the current value of the formula into a float variable.

Change Variables #

Changes variables.

Check Variables #

Checks if variables have certain values.
If the check is true, ‘Success’ will be executed, otherwise ‘Failed’.

Variable Fork #

Checks if a single variable for certain values.
If a variable condition is valid, it’s next node will be executed.
If no variable condition is valid, ‘Failed’ will be executed.

Clear Variables #

Removes all variables and variable lists.

Store Function Result #

Stores the return value of a function into a variable.
Supports string, bool, int/float and Vector3 return values.
If a variable is changed, ‘Success’ will be executed, otherwise ‘Failed’.

Store Field #

Stores the value of a field or property into a variable.
Supports string, bool, int/float and Vector2/Vector3 values.
If a variable is changed, ‘Success’ will be executed, otherwise ‘Failed’.

Variable Transfer #

Transfers all variables and variable lists from one origin to another (local, global and object).

Variable Exists #

Checks if a variable exists (i.e it has been set).
If the check is valid, ‘Success’ will be executed, otherwise ‘Failed’.

Vector3 #

Vector3 Transform Value #

Transforms a Vector3 value between local and world space of a game object and stores the result into a variable

Vector3 Angle #

Uses the angle in degree between two Vector3 to change the current formula value or stores it into a float variable.

Vector3 Magnitude #

Uses the magnitude (length) or square magnitude (squared length) of a Vector3 to change the current formula value or stores it into a float variable..

Vector3 Clamp #

Store a Vector3 with it’s axes clamped between two values into a variable.

Vector3 Clamp Magnitude #

Store a Vector3 with it’s magnitude clamped to a max length into a variable.

Vector3 Lerp #

Store the linear or spherical interpolation between two Vector3 into a variable.

Vector3 Move Towards #

Moves the Vector3 current in a straight line towards a target and stores it into a variable.

Vector3 Rotate Towards #

Rotates the Vector3 current towards a target and stores it into a variable.

Vector3 Ortho Normalize #

Make two or three Vector3 variables normalized and orthogonal to each other.

Vector3 Multiply #

Multiplies a Vector3 with a float and stores it into a variable.

Vector3 Divide #

Divides a Vector3 by a float and stores it into a variable.

Vector3 Rotate #

Rotates a Vector3 and stores it into a variable.

Vector3 To Angle #

Changes all axes of a Vector3 value into a angles (i.e. between 0 and 360) and stores it into a Vector3 variable.
E.g. -90 will become 270, 480 will become 120.