Facepunch.ActionGraphs

Elements added by a call to .

Newly added variables. Newly added nodes. Newly added links.

Elements added by a call to .

Newly added variables. Newly added nodes. Newly added links.

Newly added variables.

Newly added nodes.

Newly added links.

Represents an async method as a directed graph. Control will enter through an "event" node, which can route signals through a network of other nodes that perform actions. Use to create a completely blank graph, or to create a graph that handles an event matching the signature of a particular delegate.

The definition of the graph input that represents the target of the graph.

The output of the graph's entry node that represents the target of the graph.

Identifies where this instance was deserialized from.

Library of node definitions available for use by this action graph.

Set of nodes added to this action graph.

Set of links added between nodes in this action graph.

Set of variables added to this action graph.

Arbitrary named values stored in this action graph, which will be included during serialization. Values must be serializable to JSON.

Entry point of the graph.

Primary output of the graph.

Nodes that emit return values or output signals from this graph to the caller.

Add a new node to this action graph, with the given .

Definition describing the properties, inputs and outputs of a node.

Add a new node to this action graph, with the given .

Definition describing the properties, inputs and outputs of a node. Optional parent node to create a child for.

Remove a node from this action graph. Any links into or out of the node will also be removed.

Node to remove.

Creates a completely blank action graph. This won't be invokable until an event node is added.

Source of node definitions for the new action graph.

Creates an action graph with an event node matching the signature of .

Source of node definitions for the new action graph. Delegate type to match the signature of.

Creates an action graph with an event node matching the signature of delegate type .

Delegate type to base this new action graph on. Source of node definitions for the new action graph.

Builds a that implements this graph.

For graphs composed only of expression nodes, evaluates all outputs based on the given input values.

Values to use for each named input.

Fires a signal from the of this graph with the given named values as input. The returned task will complete when all resulting actions have finished executing.

Values to use for each named input.

Returns a delegate factory implementing the current configuration of this action graph. This value is cached if the graph hasn't changed since the last time this was called.

Gets all known s created from this graph.

True during .

Restore a previously serialized graph from JSON in this instance.

Serialized action graph. Optional delegate type, must match the one used when serializing. Optional serializer options.

Increments each time this graph re-validates after a change.

Don't increment during next validation.

Adds all nodes to , sorted topologically. Will add error messages if cycles are detected.

Handler for events.

The link that was triggered. The value that was propagated, or null for signals.

If the given delegate is implemented as exactly one , get that graph and any input value overrides.

If the given delegate is implemented as one or more s, get those graphs and their input value overrides.

Wrapper for an invokable as a delegate, with optional overridden input values.

Wrapped action graph.

Delegate that is implemented by , with default arguments supplied by . This delegate will remain up-to-date even if the wrapped graph is modified, or default argument dictionary changes.

The type that will contain when compiled.

Dictionary of default arguments for any graph input parameters that aren't supplied by delegate parameters.

Wrapper for an invokable as a delegate, with optional overridden input values.

Delegate type for the compiled graph.

Lazily compiled once, wraps compiling (if changed) and then calling it.

Lazily compiled each time is called if has been modified.

Builds a delegate that calls the wrapped , supplying any default arguments from . This delegate will remain up-to-date even if the wrapped graph is modified, or default argument dictionary changes.

Gets a delegate implementing the current configuration of with default arguments provided by , (re)compiling if needed.

Extension methods for action graphs.

Add a new node to this action graph with the given definition ID.

Add a new node to this action graph, defined by the given method. The method must be already included in .

Delegate type of the method. Action graph to add a node to. Method defining a node.

Add a new node to this action graph, defined by the given method. The method must be already included in .

Adds a new node to this action graph, defined by the given expression type.

Add a new variable accessor node to this action graph.

Add a new constant accessor node to this action graph.

Interface for types that identify the source of an .

Controls how s are (de)serialized.

Add this input to any graphs deserialized in this scope, usually representing a "this" parameter holding the object this graph is embedded in. When serializing, omit this input from the serialized graph because we know it will be added automatically when deserializing. Re-use instances from this cache when deserializing, matching by . Graphs will be added to the cache when serializing or deserializing in this scope. When serializing, if is true, a minimal graph reference stub will be written instead of full graphs. For debugging / editors, describe where graphs deserialized in this scope came from. When deserializing, maps any graph s encountered. If true, and a is provided, write a reference stub when serializing graphs instead of the full JSON. If true, replace cached instance when deserializing. Otherwise, it'll only be replaced if its differs.

Controls how s are (de)serialized.

Re-use instances from this cache when deserializing, matching by . Graphs will be added to the cache when serializing or deserializing in this scope. When serializing, if is true, a minimal graph reference stub will be written instead of full graphs.

For debugging / editors, describe where graphs deserialized in this scope came from.

When deserializing, maps any graph s encountered.

If true, and a is provided, write a reference stub when serializing graphs instead of the full JSON.

If true, replace cached instance when deserializing. Otherwise, it'll only be replaced if its differs.

Default empty .

Severity level of a validation message.

Purely informative, there's nothing to fix.

Suggests that something might not be intended, but isn't an error.

Something is incorrect and must be fixed in order to pass validation.

Interface for action graph elements that can be the context of a .

Action graph this element belongs to.

Parent element in the graph. Parents will list all validation messages of their children.

Unique identifier for this graph element in a stack trace.

Extension methods related to validation and validation messages.

Gets all validation messages where this, or any child element, is the context.

Returns true if any contained validation messages are errors. An action graph can't be invoked if it has any errors.

A message generated during validation with a context, level, and value.

Action graph element most relevant to this message. Severity of the message. Message content.

A message generated during validation with a context, level, and value.

Action graph element most relevant to this message. Severity of the message. Message content.

Action graph element most relevant to this message.

Severity of the message.

Message content.

If true, this message was a cause for the action graph to fail validation.

Returns the message formatted as "[Level] Value (Context)".

Exception thrown when an invalid action graph is invoked.

Action graph element most relevant to this exception.

Used to re-use instances when deserializing.

Used to define ActionGraph nodes using static methods, properties, or constructors.

A unique name to identify this node type.

Used to define ActionGraph nodes using static methods, properties, or constructors.

A unique name to identify this node type.

Declares a method to not have any side effects, it only performs a calculation using its inputs and outputs a result.

Declares a method to have side effects, even if it's declared as readonly.

For binding in methods marked with a , this parameter should only be configurable in the inspector as a property and not have a dedicated input.

For binding in methods marked with a , this parameter represents the target instance object the method is executed on.

Declares that instances of the marked type can't be cached in a . For example, if they might contain an ID that needs to get fixed up post serialization.

Marks an output signal that will always be dispatched before the default output signal. Used on a parameter of a method marked with .

Marks a class extending that should be automatically added to a when is called.

Scopes for each signal output of action nodes. Scopes for each input that needs to be evaluated each time it is accessed. Scopes for each signal output of action nodes. Scopes for each input that needs to be evaluated each time it is accessed.

Scopes for each signal output of action nodes.

Scopes for each input that needs to be evaluated each time it is accessed.

Describes a node output in this scope. It can either have a local variable that gets set during the body of its node, or a constant expression that gets defined during the body.

Wraps a set of value inputs of action nodes that should be evaluated at the same time. Each referenced expression node in the scope will be evaluated at most once, so if the result of a node is used multiple times it will have the same value. This is both an optimization, and expected behaviour if things like random numbers are sampled.

The input or output parameter this scope was created from.

The scope immediately containing this one. The graph input node has no scope.

Inputs on action nodes included in this scope. This doesn't include inputs of referenced expression nodes.

If false, we need to re-evaluate the scope each time an input is accessed.

Operations accessor nodes can perform.

Replace the old value with the new value.

Replace the old value with old + new.

Replace the old value with old - new.

Replace the old value with old * new.

Replace the old value with old / new.

Replace the old value with old + 1.

Replace the old value with old - 1.

Base class for nodes that get / set values.

If true, don't bother storing the result in a local variable when accessing.

Base type for node definitions that run a bunch of output signals simultaneously, like or .

Given a method, returns a node binding specifying which properties, inputs and outputs the method has.

Helper type for input parameters of methods marked with . The value of this input can be evaluated on demand, for cases where it may change during the invocation of the node.

Actual input type.

Evaluate this input.

Nodes can be lazily evaluated expression without any signals, or actions that execute when receiving a signal.

A lazily evaluated node without any signals.

A node that performs an action when receiving an input signal.

Node inputs and outputs of this type will transmit signals rather than values.

Describes the behaviour and bindings of a node for use in an action graph.

Node library that will contain this node definition. Unique identifier of this node definition.

Node library containing this node definition.

Unique identifier of this node definition.

Title, description, and categorizing information about the node definition.

Attributes attached to this node definition.

True if this definition has an .

Attempts to get a binding based on property values and input types. Bindings are typed sets of named properties, inputs, and outputs. If a valid binding wasn't found, the result will contain messages explaining why.

Returns the identifier of this node definition.

We don't have a valid definition for this parameter.

This parameter must have a value / link, and has no default value.

This is the primary input / output signal.

Always serialize this property, even if it has the default value.

This input represents the this parameter of a method.

This input is conditionally accessed, so its source should be lazily evaluated.

This input should be evaluated each time it is accessed, instead of being cached.

This output signal will always be triggered.

The containing node won't await this output signal's completion.

Base interface for , and .

Parameter name.

Display info about this parameter.

Value type stored / transmitted by this parameter.

If true, a value must be provided for this parameter otherwise a validation error will be generated.

If true, this parameter wasn't found on the current node binding.

If this parameter was generated by reflection, contains the attributes of the source member.

Describes a property of a node that should be configurable in the inspector.

Name used to reference this property. What type is accepted for this property. Optional title and description of the property. If is false, this value will be used when no value is provided. If is , can hold a generic parameter constraining the type.

Describes a property of a node that should be configurable in the inspector.

Name used to reference this property.

What type is accepted for this property.

Optional title and description of the property.

If is false, this value will be used when no value is provided.

If is , can hold a generic parameter constraining the type.

Describes an input of a node.

Name used to reference this input. What type is accepted in this input. For input signals, this will be . Optional title and description of the input. If is false, this value will be used when no value is provided. Input signals that use this input.

Describes an input of a node.

Name used to reference this input.

What type is accepted in this input. For input signals, this will be .

Optional title and description of the input.

Input signals that use this input.

If is false, this value will be used when no value is provided.

If true, this input receives a signal that will cause the parent node to act.

If true, this input accepts an array of values. Each element can be connected to a different output.

For array input types, the type of an element of the array.

Describes an output of a node.

Name used to reference this output. What type is returned by this output. For signals, this will be . Optional title and description of the output. This output is only valid when one of these output signals fires. If empty, it's always valid.

Describes an output of a node.

Name used to reference this output.

What type is returned by this output. For signals, this will be .

Optional title and description of the output.

This output is only valid when one of these output signals fires. If empty, it's always valid.

If true, this output emits signals that can trigger other nodes to act.

Display information of a .

Display name of the node. Helpful text explaining the usage of the node. Category to help organize the node. Material icon for this node. If true, don't show this node definition in editor UI. Set of tags to help organize the node.

Display information of a .

Display name of the node.

Helpful text explaining the usage of the node.

Category to help organize the node.

Material icon for this node.

If true, don't show this node definition in editor UI.

Set of tags to help organize the node.

Pattern:
\\{\\s*(?<name>[a-zA-Z_]+)\\s*(?:\\:\\s*(?<format>[^}|]+\\s*))?(?:\\|\\s*(?<default>[^}]*)\\s*)?\\}
Explanation:


            ○ Match '{'.

            ○ Match a whitespace character atomically any number of times.

            ○ "name" capture group.

                ○ Match a character in the set [A-Z_a-z] greedily at least once.

            ○ Match a whitespace character greedily any number of times.

            ○ Optional (greedy).

                ○ Match ':'.

                ○ Match a whitespace character greedily any number of times.

                ○ "format" capture group.

                    ○ Match a character in the set [^|}] greedily at least once.

                    ○ Match a whitespace character greedily any number of times.

            ○ Optional (greedy).

                ○ Match '|'.

                ○ Match a whitespace character greedily any number of times.

                ○ "default" capture group.

                    ○ Match a character other than '}' greedily any number of times.

                ○ Match a whitespace character atomically any number of times.

            ○ Match '}'.

Convert a variable name to something more user friendly.

Attempts to read a serialized from a path.

Path describing the location of a serialized graph.

Given a that possibly extends a definition, get the generic instance type so we know what the type parameters are. Returns null if the given type doesn't actually extend the generic type.

Generates an expression that coerces a value to the given type.

Concatenate two expressions, each of which may return a , with the final value being the result of the latter expression.

Generates an expression that reads a named value from a .

A link connects one to a . They can either transmit values or signals. A signal will trigger the receiving node to act when the sending node fires its output.

The receiving node's input.

Where this link retrieves its value from.

The action graph containing this link.

If true, this link will transmit a signal from an action node to another.

The value type being transmitted by the link.

The value type the target requires from this link.

If true, this link is supplying one element of an input that accepts an array.

If is true, this is the index of the element in the receiving array.

Arbitrary named values stored in this link, which will be included during serialization. Values must be serializable to JSON.

Becomes false when this link is removed.

Collapses any no-op nodes to find the root source of this link.

Remove this link from the action graph, disconnecting it from the source and target.

If this link is from a source, return true and output the constant value.

If this link is from a source, return true and output the referenced variable.

Returns a string with the format "Link({Source}, {Target})".

The main building block of an action graph. Represents either an action or expression. An action node has input and output signals, and will act only when receiving a signal. Expression nodes have only input and output values, and will be evaluated lazily when one of its outputs is requested.

Keep hold of the model this node was deserialized from if there were any exceptions, so we can safely round-trip serialize even in the worst case. This will get cleared if any changes are made to the node.

Order of this node, such that any nodes linked to its inputs have a smaller index. Used during validation.

True if executing this node is async because one of its outputs involves running another async node. Used during validation.

Does the execution of this node produce an async task. Used during validation.

Unique id of this node in the containing .

Parent of a nested node.

Nodes that were created as children of this node.

Definition describing the behaviour and property / input / output bindings of this node.

Display information for this node.

Attributes provided by this node's current binding.

Arbitrary named values stored in this node, which will be included during serialization. Values must be serializable to JSON.

Constant named values stored in this node.

Named inputs of this node, that may either link to the outputs of other nodes, or be assigned a constant value.

Named outputs of this node, that may link to the inputs of other nodes.

All properties or links that reference a variable.

All current input and output links attached to this node.

Nested constant / variable nodes are serialized as links. We can also skip serializing nested nodes with no references.

Parent of this node.

Will become false if this node was removed from its action graph.

Notify the containing graph that this node needs updating.

Remove this node from the containing graph. Any links into or out of the node will also be removed.

Returns a string with the format "Node{ID}".

Is this node an action or an expression?

Sets the named properties and inputs to the given values.

Immediately update this node's binding based on its input types and property values.

The parent node of this parameter.

The name of this parameter.

Current definition of this parameter, including type and display information.

Value type of this parameter.

Display info for this parameter.

If this parameter was generated using reflection, contains the attributes attached to the reflected member.

Base class for properties, inputs, and outputs of nodes.

Definition type for this parameter.

Returns A string with the format "{Node}.{Name}".

A named constant value stored inside a node.

If true, this property references a .

Constant value assigned to this parameter.

Attempts to get either the current assigned value, or default value for optional properties. Returns false if this property is required and has no assigned value.

Current assigned or default value. True if this node has an assigned or default value.

Attempts to get either the current assigned value, or default value for optional properties. Throws an exception if this property is required and has no assigned value.

Attempts to get either the current assigned value, or default value for optional properties. Throws an exception if this property is required and has no assigned value, or the assigned value is the wrong type.

A named input of a node. Inputs can connect to outputs of other nodes, or have a constant value. Use to set which output this input links to, or if this input can accept an array of values.

If true, this input accepts an array of values. Each element can be connected to a different output with or .

If true, this input receives a signal that will cause the parent node to act.

If true, this input is linked to an output.

Gets the type arriving in this input. Returns null if unlinked.

If this is linked to a single output, gets that link.

If this is linked to an array of outputs, gets the connecting links.

Gets any links connected to this input.

For array input types, the type of an element of the array.

Constant source value for this input.

If this input is connected to an array of outputs, gets the index of the given link in that array. Returns -1 if not found.

Link to get the index of.

Removes all links from this input.

Clears any existing links or constant value, and sets this input to be linked to the given output.

Output to link to.

If this input accepts an array of links, replaces a link in that array to the given output.

Output to link to. Index into the link array to set the link.

If this input accepts an array of links, inserts a link in that array to the given output.

Output to link to. Index into the link array to insert the link.

If this input accepts an array of links, clears any existing links or constant value and sets this input to be linked to the given array of outputs.

Array of outputs to link to.

If this input accepts an array of links, clears any existing links or constant value and sets this input to be linked to the given array of outputs.

Array of outputs to link to.

A named output of a node. Use , or to connect this output to an input.

If true, this output emits signals that can trigger other nodes to act.

Are any nodes invoked by this output async? Used during validation.

All links currently connected to this output.

If true, this output has at least one connected input.

Special names for parameters of built-in node types.

Constant named values stored in a node.

Used by:

Named inputs of a node, that may either link to the outputs of other nodes, or be assigned a constant value.

Used by nodes.

Used by:

All current links into inputs of this node.

Named outputs of a node, that may link to the inputs of other nodes.

Used by nodes.

Default output of most nodes that produce a single value.

All current links from outputs of this node.

A collection of named node properties, inputs, and outputs with specific types, as provided by a . Bindings may depend on the property values or currently linked input types of a node.

Display information for the bound node. Named constant values stored in a node. Named inputs that can be provided either from the outputs of other nodes, or with constant values. Named outputs that can be connected to the inputs of other nodes. Can contain warnings or errors if this binding isn't fully valid. Optional binding target data used by .

A collection of named node properties, inputs, and outputs with specific types, as provided by a . Bindings may depend on the property values or currently linked input types of a node.

Display information for the bound node.

Named constant values stored in a node.

Named inputs that can be provided either from the outputs of other nodes, or with constant values.

Named outputs that can be connected to the inputs of other nodes.

Can contain warnings or errors if this binding isn't fully valid.

Optional binding target data used by .

Is this node an action or an expression?

A message generated when attempting to bind a set of named property values and input types. Becomes a during action graph validation.

Which property, input or output this message is relevant to. Message severity. Message content.

A message generated when attempting to bind a set of named property values and input types. Becomes a during action graph validation.

Which property, input or output this message is relevant to. Message severity. Message content.

Which property, input or output this message is relevant to.

Message severity.

Message content.

Returned by .

If true, this assembly was previously added so it was skipped. Any exceptions thrown when attempting to add methods can be found here.

Returned by .

If true, this assembly was previously added so it was skipped. Any exceptions thrown when attempting to add methods can be found here.

If true, this assembly was previously added so it was skipped.

Any exceptions thrown when attempting to add methods can be found here.

Contains a library of s, each with a unique identifier. Custom node definitions can be added with , or from methods marked with either or when using .

Contains a library of s, each with a unique identifier. An is required to wrap reflection methods. Use an if no access control is needed.

Dictionary of all added definitions, indexed by their s.

Node definition for the entry point of the graph. Each graph can only have one such entry point.

Helper node for accessing a graph input parameter.

Node definition for output signals of the graph. Each graph can have at most one primary output.

A node implemented by an action graph.

Node definition for getting or setting values.

Node definition for providing constant values.

Node definition for getting or setting static or instance properties.

Node definition for calling a named method.

Node definition for calling a constructor to create an instance.

A node that does nothing, just forwards an input to its output.

A node with no inputs or outputs, only metadata. Useful for holding documentation.

Invoked when an async graph, invoked as a delegate returning , throws an exception.

Add a custom node definition. The must be unique in this library. See also for an easier way to implement custom nodes.

Custom node definition to add.

Adds a node definition for each method annotated with either or in the given assembly.

Gets a node definition by identifier. Returns null if not found.

Unique identifier of the node definition to find.

Gets a node definition by the method that implements it. Method must already be added with .

Gets a node definition by the operator it implements.

Operator of the node definition to find.

Removes all custom node definitions from this library.

Returns true if the given method has been marked as pure. Pure methods have no (visible) side effects, and so can be turned into expression nodes.

Method to test.

Returns true if the given parameter should be a property on a node, rather than an input or output.

Parameter to test.

Gets all existing graphs created with this .

Gets all existing graphs created with this with the given .

Nodes providing basic control flow structures like branches and loops.

An action to perform in a branch or loop.

Output signal for a node, fired for each element of an enumerable.

Element type.

Output signal for a node, fired for each value in the range.

Nodes relating to numbers and geometry.

Represents a null reference.

Extension methods for types.

Adds the ability for this to convert , , and instances implemented with action graphs.

An implementation of this interface will wrap reflection calls, allowing custom access control. See for a default implementation with no access control.

Gets an identifier string that can later be used by to deserialize a type instance.

Load a type from an identifier, as produced by .

Gets a named property declared on the given type. Should return null if the property isn't found, or if it isn't allowed to be accessed.

Declaring type that contains the property. Property name.

Gets a named field declared on the given type. Should return null if the field isn't found, or if it isn't allowed to be accessed.

Declaring type that contains the field. Field name.

Returns true if is allowed to read from this property. Basic checks, like if a get method exists, will have already been performed.

Returns true if is allowed to write to this property. Basic checks, like if a set method exists, will have already been performed.

Returns true if is allowed to read from this field.

Returns true if is allowed to read from this field. Basic checks, like if it is marked , will have already been performed.

Gets all constructors declared on the given type.

Declaring type that contains the constructors.

Gets all methods with the given name declared on the given type.

Declaring type that contains the methods. Method name.

Gets a nested type from its name and the containing type. Should return null if the type isn't found, or if it isn't allowed to be accessed.

Declaring type that contains the nested type. Short name of the nested type, not the fully qualified name.

Makes an array type from the given element type and optional rank. Should throw an exception if creating such an array is forbidden.

Type of each element in the array. Optional number of dimensions of the array.

Makes a generic instance type from the given generic type definition and type arguments. Should throw an exception if the arguments aren't valid for the generic type definition, or if creating such a type is forbidden.

Generic type definition with one or more open type parameters. Type arguments to use when creating the generic instance type.

A default implementation of with no access control.

Variables have a name and type, and are local to each invocation of an . They are assigned with a node, and read with .

The name of this variable, unique in its action graph.

Value type stored in this variable.

Initial value of the variable before being assigned.

Arbitrary named values stored in this variable, which will be included during serialization. Values must be serializable to JSON.

All node properties that currently reference this variable.

The action graph this variable belongs to.

Becomes false when this variable is removed.

Remove this variable from its action graph. This will clear any references to it.

Returns the name of the variable.

Keep hold of the node the variable type was deserialized from if there were any exceptions, so we can safely round-trip serialize even in the worst case. This will get cleared if any changes are made to the variable.

Replace legacy expanded output system with parented nodes. Expanded outputs generated outputs with names like "output.X" to get the "X" property of "output".

Custom -derived type for the ParameterPattern method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Determine whether at base.runtextpos is a match for the regular expression.

The text being scanned by the regular expression. true if the regular expression matches at the current position; otherwise, false.

Helper methods used by generated -derived implementations.

Default timeout value set in , or if none was set.

Whether is non-infinite.

Pops 2 values from the backtracking stack.

Pushes 1 value onto the backtracking stack.

Pushes 2 values onto the backtracking stack.

Pushes 3 values onto the backtracking stack.

Supports searching for characters in or not in "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz".