---
title: Schematics
url: "https://orkframework.com/guide/ork4/ork4-documentation/ork4-features/schematics/"
updated: "2026-07-31"
category: Features
---

# Schematics

Schematics are an integral part of ORK Framework.

# What are Schematics?

A schematic is a reusable, node-based blueprint for what you want to do.

It consists of connected nodes that work similar to a flow chart – each node performs a task and decides the next node that’ll be executed. There are [over 900 nodes](https://orkframework.com/guide/ork4/ork4-documentation/ork4-features/ork4-schematic-nodes/) available for different tasks, and you can add new nodes via scripting or call custom code and 3rd party functionality using function nodes.

Schematics are created in the [schematic editor](https://orkframework.com/guide/ork4/ork4-documentation/ork4-editor/schematic-editor/) using the [node editor](https://orkframework.com/guide/ork4/ork4-documentation/ork4-editor/node-editor/).

[![](https://orkframework.com/wp-content/uploads/ork4_schematic_editor__overview.png)](https://orkframework.com/wp-content/uploads/ork4_schematic_editor__overview.png)

## Using Schematics

So, what can you do with schematics? Pretty much everything, e.g.:

- animating battle actions
- animating and managing a battle starting and ending
- animating a cut-scene
- NPC interactions and dialogue
- procedurally/randomly creating a level
- enemy AI and behaviours
- level handling
- custom player/camera controls
- communication with 3rd party software
- and much more!

All of this is done by adding and connecting nodes, without writing a single line of code!

## Extending ORK with Schematics

Schematics are integrated in many parts of ORK and can optionally be used to extend functionality or add custom features without having to change ORK’s code or write custom code.

Here are some examples where you can use schematics to extend ORK functionality:

- equipping/unequipping equipment
- status value changes
- a combatant’s turn starting or ending
- an item being added to the inventory
- start/stop highlighting a combatant (e.g. during target selection)
- custom status changes of abilities or items

The schematic usually has access to context-related information, e.g. the combatant it’s used on, the equipment that’s being equipped or the values used to change the status value.

# Playing Schematics

Beside using schematics in ORK’s setup (where they are played automatically when it’s time to use them), schematics are mainly played by *Machine* components and other schematics.

Playing schematics by other schematics allows breaking down tasks into several schematics, making them reusable and shorten the time needed to create your game mechanics.

E.g. change the health of the player (or any other character in the game) and check for a death condition in a separate schematic allows reusing it wherever needed (like different attack schematics, for damaging and recovering health through items, etc.).

If something needs to be changed later, you only need to change it in this one schematic and not in all places where this game mechanic is used.

# Settings

The schematic’s *Settings* node marks the start of a schematic – the node connected to it’s slot is the first node that’ll be executed.

[![](https://orkframework.com/wp-content/uploads/ork4_schematics__start_node.png)](https://orkframework.com/wp-content/uploads/ork4_schematics__start_node.png)

Enabling *Use End Slots* in the settings node will add 2 additional slots, one to execute nodes when stopping the schematic (e.g. from the machine being destroyed or an action being interrupted) and one upon ending the schematic regularly (e.g. when the schematic branches into multiple endings and all of them should do some cleanup at the end).

[![](https://orkframework.com/wp-content/uploads/ork4_schematics__start_node_extended.png)](https://orkframework.com/wp-content/uploads/ork4_schematics__start_node_extended.png)

The *Settings* node also defines the schematic’s main settings, e.g. control blocks, actors, speakers and used resources (like prefabs, audio assets, etc.).

## Machine Start Variables

Define local variables that are exposed to the machine component using the schematic.

This can be used to quickly set local start variables and change their value in machine components.

## Initial Local Variables

Define local variables that will be set at the start of the schematic.

They’re not exposed to the machine component and will overrule start variables set by the machine component.

## Actors

Actors are combatants or objects that already exist. You’ll use actors in many nodes to perform a task, e.g. moving an actor to a position, playing a sound on an actor or change status values on an actor’s combatant.

There are default objects available without adding actors:

- **Machine Object**
   The object the schematic is running on.
   E.g. the machine component’s object or a combatant using an action.
- **Starting Object**
   The object that started the machine.
   E.g. the player that started an interaction or the targets of an action.
- **Camera**
   The camera object used by the schematic (by default the main camera of the scene).
- **Selected Data**
   Content stored in *Selected Data*.
   This can optionally be limited to only use stored object instances – otherwise it’ll also use objects from stored combatants, components, etc.
   Depending on the *Data Origin*, the list is either only available in the running schematic (*Local*), everywhere *(Global*) or through an object (*Object*, *Object ID*).
   E.g. you can add objects by finding them through their name or when they where hit by a raycast.
   Learn more about selected data in [this documentation](https://orkframework.com/guide/ork4/ork4-documentation/ork4-features/selected-data/).
- **Selected Object**
   The currently selected object.
   Objects with a *Selectable Object* component attached can be selected, e.g. by clicking on them or pressing a defined input key.
   See the *Object Selection* settings in the [game controls](https://orkframework.com/guide/ork4/ork4-documentation/section-controls/game-controls/) for details.

If you need additional objects of the scene, add them as an actor to the schematic. Beside selecting the actor in the machine component (*Object* type actor), you can also let the schematic find objects by name, tag or an attached component.

### Actor Types

The following actor types are available.

- **Machine Object**
   The actor is the machine’s object instance itself.
- **Starting Object**
   The actor is the object that started the machine (e.g. stepped into the trigger).
- **Allies (Battle)**
   Combatants that are allies of the player, machine object or starting object and participating in battle.
- **Battle Arena**
   The actor is the current battle arena, or an empty object instance at the center of all combatants currently in battle.
   Should only be used in schematics used to animate battle actions.
- **Combatant Group**
   The group of the player, machine object or starting object.
- **Combatants**
   All combatants based on defined conditions.
- **Enemies (Battle)**
   Combatants that are enemies of the player, machine object or starting object and participating in battle.
- **Find Object**
   The actor will search for an object instance in the scene when starting the schematic.
- **Object (Scene)**
   The actor is an object in the scene, selected in the machine component using this schematic.
- **Player**
   The actor is the player (i.e. leader of the player group).
   Can also be used if the player isn’t spawned to access the player’s combatant.
- **Player (Battle)**
   Combatants that are part of the player group and participating in battle.
- **Player Group**
   Defined members of the player group.
- **Selected Data**
   The actor is stored in selected data.
   Learn more about selected data in [this documentation](https://orkframework.com/guide/ork4/ork4-documentation/ork4-features/selected-data/).
- **Selected Object**
   The actor is the currently selected object.
   See the *Object Selection* settings in the [game controls](https://orkframework.com/guide/ork4/ork4-documentation/section-controls/game-controls/) for details.
- **Target Base**
   The actor is the battle spot(s) of the battle action’s target(s).
   Only available in schematics used to animate battle actions.
   When used in other schematics, only available when the ‘Starting Object’ is a combatant.
- **Target Center**
   The actor is center of the battle action’s target(s).
   Only available in schematics used to animate battle actions.
   When used in other schematics, only available when the ‘Starting Object’ is a combatant.
- **User Base**
   The actor is the battle spot of the battle action’s user.
   Only available in schematics used to animate battle actions.
   When used in other schematics, only available when the ‘Machine Object’ is a combatant.

You can also create custom actor type implementations by deriving your class from the *BaseActorType* class. Check the available actor classes for examples.

## Speakers

Speakers can be used in dialogues to display their content information (e.g. name, portraits).

Speakers can also define an object that is used for them, e.g. to display a dialogue at their position.

The speaker’s content information is defined using [object content](https://orkframework.com/guide/ork4/ork4-documentation/section-content/object-contents/). You can either use an object content asset, set up custom data in the speaker or use object content coming from the speaker’s object (via *Object Content* component).

Using object content for the speaker’s information allows creating reuseable speakers, e.g. when speaking with the same NPC in different schematics.

If the speaker’s object is a combatant, it’ll be able to use the combatant’s content information and portraits without having to use an object content.

## Assets and Resources

Schematics can use different assets, the available asset types depend on the used game engine.

While you can add those resources directly in the node you want to use them, you can use advanced functionality by adding them as resources to a schematic in the schematic’s settings (i.e. the start node). A single resource can use multiple assets that can be used in sequence, reversed sequence or randomly.

A single prefab resource will be used as damage sparks. Adding mutiple prefabs to the resource and using the *Random* use order will randomly spawn one of the added prefabs when used in a *Spawn Prefab* node.

### Unity: Supported Assets

- **Prefabs**
   E.g. to spawn prefabs in the scene.
- **Audio Clips**
   E.g. to play an audio clip on a game object.
- **Materials**
   E.g. to change the material of a renderer.
- **Sprites**
   E.g. to change the sprite of a game object.
- **Textures**
   E.g. to change the texture of a game object.

### Resource Overrides

By adding assets as resources to a schematic, you can override them in machine components and battle animations. This further increases the reusability of schematics, as you can create more generic schematics that perform a task, but use different assets on different occasions.

Overriding the previous prefab resource in an ability’s battle animation allows having different effects based on the used ability. E.g. a regular attack can have simple sparks while a fire attack can show fire sparks.

# Nodes

Each node represents a task that it’ll process, before executing the next node. As said, there are over 900 nodes available for various tasks, ranging from simple things  (like spawning a prefab, playing a sound or increasing a counter) to complex operations (like movement over time, raycasting or showing a dialogue).

You can add nodes via the context menu (right/context click), learn more about using the node editor in [this documentation](https://orkframework.com/guide/ork4/ork4-documentation/ork4-editor/node-editor/).

You can see a list of all available nodes in [this documentation](https://orkframework.com/guide/ork4/ork4-documentation/ork4-features/ork4-schematic-nodes/).

## Custom Nodes

You can create custom nodes by deriving from the *BaseSchematicNode* or *BaseSchematicCheckNode* classes. For examples it’s best to check out the available node implementations.

See the [custom nodes documentation](https://orkframework.com/guide/ork4/ork4-documentation/ork4-scripting/ork4-custom-nodes/) for details.

# Importing Dialogues

You can import dialogues to create a series of *Show Dialogue* nodes using the dialogue importer.

Open the *Dialogue Importer* using the context menu in the schematic node editor: **Open Dialogue Importer**

Learn more about it in [this documentation](https://orkframework.com/guide/ork4/ork4-documentation/ork4-features/dialogue-importer/).
