Learn more about interactable components.

All interactable components can use general conditions to determine if they can be started.

Start Types #

Interactable components have to be started by something in order to perform their tasks, e.g. playing a schematic, opening a shop or changing the current area of the game.

The following start types are available in all interactable components.

Animation (Unity) #

Animation start types are available in Unity and are used to start components by animation events (e.g. in Mecanim animations) or from UI.

Animation Event #

Starts when receiving an animation event without any parameter.

Can also be used by UI components when firing UnityEvents.

Animation Event (float) #

Starts when receiving an animation event with a float parameter.

The parameter is available as local double variable via the variable key parameter.

Can also be used by UI components when firing UnityEvents.

Animation Event (int) #

Starts when receiving an animation event with an int parameter.

The parameter is available as local long variable via the variable key parameter.

Can also be used by UI components when firing UnityEvents.

Animation Event (string) #

Starts when receiving an animation event with a string parameter.

The parameter is available as local string variable via the variable key parameter.

Can also be used by UI components when firing UnityEvents.

Animator IK #

Starts before updating the internal IK system of an animator (OnAnimatorIK).

Animator Move #

Starts each frame after state machines and animations have been evaluated, but before Animator IK (OnAnimatorMove).

Joint Break #

Starts when a joint attached to the object instance breaks (OnJointBreak).

UI Game Object #

Starts when used by UI components firing UnityEvents with an object instance parameter.

The used game object will be the starting object of the component.

Application (Unity) #

Application start types are available in Unity and are started by events coming from the game’s application.

Focus Gained #

Starts when the application gets focus (OnApplicationFocus true).

Focus Lost #

Starts when the application loses focus (OnApplicationFocus false).

Paused #

Starts when the application is paused (OnApplicationPause true).

Quit #

Starts before the application is closed (OnApplicationQuit).

Unpaused #

Starts when the application is unpaused (OnApplicationPause false).

Auto #

Auto start types are available in all engines and automatically start the component on defined events.

Change Notification #

Starts by getting notified of changes, e.g. variable changes or a combatant’s status changes.

Destroy #

Starts when the object/component is destroyed.

Disable #

Starts when the object/component is disabled.

Enable #

Starts when the object/component is enabled.

Ready #

Starts when the object/component is added to the scene (only starts once).

Scene Loaded #

Starts when a new scene was loaded.

Collision #

Collision start types are available in all engines and start the component upon collision events.

Collision Enter #

Starts when an object starts colliding with the component’s object.

Collision Exit #

Starts when an object stops colliding with the component’s object.

Collision Stay #

Starts while an object is continuously colliding with the component’s object.

Particle Collision #

Starts when a particle collides with the machine’s object.

Interaction #

Interaction start types are available in all engines and start the component upon player interaction.

Drop #

Starts when the player drops something (from UI) on the component’s object.

Requires a collider and the object being on a layer that can be hit by the raycast set up in UI settings.

Input Key #

Starts when the player presses an input key.

Interact #

Starts on player interaction.

Mouse Down #

Starts when a mouse button is pressed down on the component’s object.

Mouse Drag #

Starts when a mouse drag is performed on the component’s object.

Mouse Enter #

Starts when the mouse cursor enters the component’s object.

Mouse Exit #

Starts when the mouse cursor leaves the component’s object.

Mouse Over #

Starts while the mouse cursor is over the component’s object.

Mouse Up #

Starts when a mouse button has been released after being pressed down on the component’s object.

Mouse Up As Button #

Starts when a mouse button has been released over the component’s object it has been pressed down.

None #

The none start type is available in all engines.

Can’t be started automatically, e.g. use schematics to start.

You can also just not add a start type instead.

Renderer (Unity) #

Renderer start types are available in Unity and start the component based on renderer events.

Became Invisible #

Starts when the machine’s game object is no longer visible by any camera (OnBecameInvisible).

Became Visible #

Starts when the machine’s game object became visible by any camera (OnBecameVisible).

Post Render #

Starts after a camera finished rendering the scene (OnPostRender, only on cameras).

Pre Cull #

Starts before the camera culls the scene (OnPreCull).

Pre Render #

Starts before a camera starts rendering the scene (OnPreRender, only on cameras).

Render Object #

Starts after the camera has rendered the scene (OnRenderObject).

This is similar to Post Render, but is called on all game objects, not only the camera.

Will Render Object #

Starts once for each camera the object is visible in during culling (OnWillRenderObject).

Tag #

The tag start type is available in all engines.

Starts when called using matching tags, e.g. via schematics, HUDs or status changes.

Tick #

Tick start types are available in all engines and start the component on frame or physics update ticks.

Late Tick #

Starts every frame update after all ‘Tick’ updates have finished.

Physics Tick #

Starts every physics update.

Tick #

Starts every frame update.

Trigger #

Trigger start types are available in all engines and start the component upon trigger/area events.

Unity: Uses a collider with Is Trigger enabled for the trigger events.

Trigger Enter #

Starts when something enters the trigger/area.

Trigger Exit #

Starts when something exits the trigger/area.

Trigger Stay #

Starts when something stays in the trigger/area.

Interaction Controller Component #

The Interaction Controller component is used to start Interact start types.

An interaction is available to the player while it is within the player’s interaction controller’s bounds (area).

You can add multiple interaction controllers to the player and have them interact with different things based on organizer types. E.g. use a small area for talking to NPCs close up while allowing to pick up items all around the player.

Unity: Needs a collider with Is Trigger enabled for the area. For physics detecting something entering the trigger, a Rigidbody component has to be involved as well.

Selectable Object Component #

The Selectable Object component is used to mark an object as selectable.

This is used by the Selectable Object type interaction control, where you interact with the currently selected object instead of an object within the interaction controller.

Machine (Schematic) Component #

The Machine (Schematic) component is used to start a schematic.

The machine’s gizmo icon changes depending on the first added start type.

Additional settings further specify the schematic’s execution.

Execution Type #

The Execution Type defines how a machine is executed:

• Single
  The machine can be executed once at the same time.
  I.e. it can’t be executed again while it’s already running.
• Multi
  The machine can be executed multiple times at the same time.
  Each execution will run it’s own, separate instance of the schematic.
• Blocking
  The machine can be executed once at the same time.
  Other Blocking machines can’t be executed while the machine is running and the machine can’t start while another Blocking machine is running.
  In short, only one Blocking machine can run at a time.

Priority #

You can optionally prioritize a machine’s schematic, this will update a schematic before other schematics. When multiple schematics are prioritized, they’re order descending by their Priority number, i.e. the schematic with the highest priority number will be updated first.

However, prioritized machines will start playing the schematic in the next frame, not in the frame they’re started (as not prioritized machines do). This is due to waiting for all prioritized machines that are started in a frame and ordering them according to their Priority number. I.e. a priority machine ensures starting before other priority machines with a lower priority.

Template Machine Component #

The Tempalte Machine component uses a machine template and automatically adds a Machine (Schematic) component matching the template’s setup during play.

The template’s setup is used when the scene was loaded or the object with the component is spawned. You can optionally add a delay to adding the template’s setup to the object.

Item Collector Component #

The Item Collector component is used to pick up items or access item boxes.

Collection Type #

The Collection Type setting defines if a single item or an item box is used.

How the UI for the item collection or item box access is displayed to the player is defined in the item collection settings.

Single Item #

Optionally spawns the prefab of the item that can be collected. Interaction with the prefab is also possible.

If multiple items are added, one of them is used randomly.

Single item collection uses a Scene ID to determine if an item has already been collected or not. The scene ID can be used either per scene or globally.

Item Box #

All added items are placed into an item box and can be collected. The player can also put items from the inventory into an item box.

Box collection uses a Box ID, which is always used globally and not per scene. The box ID can also be used to access the item box without an item collector, e.g. via schematics or Inventory Exchange menu screen parts. All item boxes using the same box ID will share their content.

Scene Changer Component #

The Scene Changer component is used to load a new scene.

Scene Load #

Depending on the engine you’ll have different scene load types available.

Unity #

The following scene load types are available:

• Load Level
  Closes all currently loaded scenes and loads a scene.
• Load Level Additive
  Adds the scene to the currently loaded scenes.
• Load Async
  Closes all currently loaded scenes and loads a scene asynchronously in the background.
• Load Async Additive
  Adds the scene to the currently loaded scenes and loads it asynchronously in the background.

Player Spawning #

Optionally spawn the player at a defined Spawn Point, a fixed position or a previously remembered position in the scene (Scene Position).

Screen Fades #

Loading a scene can fade the screen during load (fade out before load, fade in after load).

You can optionally override the default screen fade settings defined in the UI settings.

Change After Load #

You can optionally change variables after loading the new scene.

Shop Interaction Component #

The Shop Interaction component is used to open a shop.

Alternatively, you can also use a schematic to open a shop, e.g. adding a bit of dialogue before or after shopping.

Optionally use a Shop ID to identify the shop and save it’s content. Shop IDs are used globally.

A shop can optionally belong to a faction to impact prices based on faction standings.

Area Component #

The Area component is used to change the current area information of the game.

A typical setup will use Trigger Enter or Ready start types to change the area either when the player enters the object’s area or when loading the scene.

Unity: Uses a collider with Is Trigger enabled to define the area for trigger start types.

Music Player Component #

The Music Player component is used to change the currently playing music.

A typical setup will use Trigger Enter or Ready start types to change the music either when the player enters the object’s area or when loading the scene.

Unity: Uses a collider with Is Trigger enabled to define the area for trigger start types.

Learn more about playing music in this documentation.

Save Point Component #

The Save Point component is used to access the save point dialogue or save game menu.

Learn more about save games in this documentation.

Variable Changer Component #

The Variable Changer component is used to change variables.

You can also change variables using schematics and other features, but sometimes you just want to change a variable without doing anything else.

E.g. the ORK 4 Unity Quickstart 3D tutorials use variable changes to set the name of the battle scene when loading the World or Dungeon scenes.