One exec-pin fire from an async action. pin indexes the node's exec-output list (execList). outputs are packed onto the node's data-out for this fire. A terminal fire ends the action and resumes the graph past the no
Base class for an in-flight async action. Start() runs once with the resolved node inputs; Tick() runs each frame and pushes any fired events. Return true while still active, false to retire (a terminal event also retire
Asset-load provider for the AsyncLoadAsset action. Visual Scripting sits far below the asset system, so the node owns only the latent plumbing: the module that wires the asset manager installs one of these and the node p
Navigation provider for the AIMoveTo action, installed by the AI/navigation plugin. Same contract: no provider means OnFailed rather than a pawn that pretends it arrived.
Gameplay state behind WaitInputAction, WaitOverlap and WaitAttributeChange. Input, trigger volumes and the ability system all live above Visual Scripting, so the Game module installs one of these; the actions own only th
Process-wide registry of async-action factories. Visual Script registers the built-in actions on first use; gameplay can Register() real implementations (asset load, AI move-to) over the shipped stubs by reusing the same
A class member variable — per-instance state the graphs read/write through GetVar/SetVar nodes (the Visual Script analog of a Blueprint variable). type picks the VisualScriptValue storage; defaultValue seeds it when
A custom function — a named, callable sub-graph with typed parameters and an optional return (the Visual Script analog of a Blueprint function). A CallGraphFunction node invokes it by name; GetParam nodes read its argume
An event dispatcher — a multicast delegate. A Broadcast node fires every bound handler (a custom function by name), passing the broadcast arguments as the handler's parameters. The Visual Script analog of a Blueprint Eve
A macro boundary pin — one entry on a macro's input or output side. An exec pin is a flow tunnel; a data pin carries a typed value. The macro instance node mirrors these onto its own pins, and expansion inlines the macro
A macro — a reusable subgraph with N named exec/data inputs and outputs, INLINED at compile time (the VM never sees a MacroInstance). The Visual Script analog of a Blueprint macro. The body graph's entry is a MacroInput
A named component slot — the class-description form of "this actor carries component X with these defaults". Slots apply to the backing ECS entity at OnConstruct; a child class (or later an instance) redeclaring a slot w
The gameplay layer's native-parent hosting. A class whose native parent has no backing class of its own (a game's AFirstPersonCharacter, any MActorComponent) spawns as an instance of THAT parent with a host component car
Pure data operation for a VisualScriptNodeKind::Pure node. Operand type (int vs float) is inferred from the inputs; logic ops coerce to bool. Two inputs except Neg/Not/Abs/Sqrt/Sin/Cos/Floor/Ceil/Round/Sign/ToString (one
A CallFunction input pin: a literal constant, or a link to an upstream node's output. The VM keeps a per-node output store; a linked input reads from outputs[link.node].
Bumped when the on-disk graph schema gains a field. Loaders accept anything <= this; missing fields fall back to their defaults, so an older .vscript always reads. v1 = original; v2 = object refs, macros, multi-exec-in pins; v3 = multi-track Timeline tracks/keys + async-action nodes; v4 = persisted node canvas positions + comment extents; v5 = authority nodes (HasAuthority / SwitchHasAuthority) — an older build maps the unknown kind strings to CallFunction, so the Newer warning is the only thing standing between such a graph and silent misbehavior; v6 = replicated class variables + component-slot placement (transform and attach parent) + the ClassRef node. An older build drops the first two silently — the class still loads and runs, it just stops replicating and puts every slot back on the actor's own entity — and maps the unknown ClassRef kind onto CallFunction, which is why the Newer warning matters; v7 = per-variable Instance Editable and Expose on Spawn. An older build drops both silently: instance-editable degrades to "no inspector row", which is cosmetic, but expose-on-spawn does not — the spawn node keeps the extra input pins the author wired and the old VM refuses the call on arity, so the spawn stops happening rather than happening with default values; v8 = per-variable RepNotify function name. An older build drops it silently and the variable keeps replicating with no hook — the client state still converges, only the reaction to it goes missing, so the Newer warning is advisory rather than load-bearing here; v9 = the MakeText node and its ns/key/src properties. An older build maps the unknown kind onto CallFunction, so the node stops producing a string at all — a label goes blank rather than going untranslated, which is why the Newer warning matters again here; v10 = NativeDefault blocks, the property values a class sets on its native parent. An older build drops them and the parent keeps its C++ values, so a class tuned in the editor plays differently without erroring.
The exposed values of one spawn, armed for the duration of the spawn call on the calling thread. The gameplay layer's spawn path consumes them at the one moment that works — after the fresh instance has its class bound (
Network role of a graph run. Standalone (the default) is "no session": every RPC-flagged call executes locally, UE-style. Authority is the server/host (or a client-local actor that was never replicated — it is its own au
What the routeRpc hook did with a call it was handed. Sent = the call left on the wire and must NOT run locally; RunLocal = the resolved destination is this machine (e.g. a Client RPC whose owning client is the listen ho
One instance's resolution of graph nodes to entries in its variable store: by node index, the GetVar / SetVar / container-mutator variable, latch state or Timeline state the node reads and writes, null until the node fir
One call's parameters and locals, laid out by slot: the values in one vector, the names pointing at the function's own declarations. A call used to build an unordered_map — a node allocation and a string copy per local a
Execution context for a graph run: the call target + its class (for call-by-reflection), an optional per-instance variable store that GetVar/SetVar nodes read and write, and (for custom functions) the VisualScriptClass w
Debugger hook — the runtime half of the Visual Script DAP. When installed, the VM calls onNode before dispatching every exec node (breakpoint check / single-step); returning false ABORTS the run (debugger stop). ctx.vars
One item on the VM's explicit exec stack. Capturing execution in data (rather than the C++ call stack) is what lets a Delay suspend and resume the graph.
A suspended graph run — saved when a Delay or Timeline fires. Holds the remaining exec stack + the node outputs computed so far (so data links across the wait still resolve). graph must stay alive (event graphs live in
Container shape of a pin. type keeps describing the ELEMENT type, so an array of ints is { type = Int, container = Array } — the pin colouring and the reflected-call marshalling both keep working off type alone.
How an Object CONSTANT resolves to a live actor. A hard pointer can never persist (the object doesn't exist at load time), so a serialized object pin carries a symbolic reference resolved against the world when the graph
A struct value known only by name (FTransform, any copyable MSTRUCT): an owned, constructed instance, deep-copied with the value. It is what lets a Custom pin hand a thunk a pointer to exactly the C++ type it casts to.
The owning handle of a value's out-of-line part. Copies SHARE the block and the first mutable access through a shared handle clones it, so copying a string or container value — every pin read, variable read and argument
32 bytes on a 64-bit build: the tags, one 16-byte slot shared by every scalar, the quaternion and the object handle, and one pointer to the copy-on-write block holding strings, containers and struct instances. It used to