Game Bridge

Interaction processes localized dialogue, actions, routes, audio, Conditions and authored item references/events. It manages participants, scene selection, node visits and the active narrative session.

1. Assign the required SceneData entries and configure the controlling character and presentation outputs.
2. Use BeginInteraction(character) for a conversation, BeginMonologue(character) for a solo session, or BeginScene() / BeginAt(nodeUID) for an explicit entry.
3. Call MoveNext() to continue; use Pause(), Resume() and EndSession() for their specific lifecycle actions.

A compatible BeginInteraction call can add a participant to an existing conversation. Use InterruptWith for a suspend/resume interruption workflow. Your scene objects and UI decide how the processed story appears.

Bind a player or NPC GameObject to the character authored in Storyteller. The binding resolves by character UID within the assigned SceneData.

1. Attach InteractableCharacter to the player or NPC.
2. Assign SceneData and select the corresponding authored character.
3. Pass that component to the Interaction entry method your game uses.

Character data can include localized profiles, evolution relationships and personality traits. The runtime exposes named trait queries and updates. A participant joining a compatible conversation must resolve to the same source SceneData.

Conditions decide when configured actions run. Use general Conditions for an Interaction-wide behavior, node-specific Conditions for a particular node, or standalone Conditions explicitly processed by your game.

1. Choose Value from and select a public member or shared variable. Traverse returned objects and collection elements with the member picker.
2. Choose the comparison and Compare with: a constant, another live member or an explicitly owned shared variable.
3. Add calls to On condition met. Multiple bool checks use AND; all checks must succeed.
4. Configure processing mode, update rate and Repeat deliberately. Process the Condition through its owning Interaction or an explicit ProcessConditionData call.

Processing and timing

Caller Driven evaluates when its owner or caller processes it. A standalone Self Driven, Once Per Frame Condition begins monitoring after ProcessConditionData is called. Enabling a component alone does not start a new monitor. Interaction-owned Conditions retain the Interaction lifecycle.

Once Per NodeData follows the Interaction’s node-visit lifecycle. Auto Start explicitly invokes the event when processed; Use Time chooses a timed path such as node Delay, Duration, Realtime Delay or a custom wait. Use Time is an alternative to the bool-check path. Use a separate guard Condition when a timed action also needs a live-state check.

With Auto Start and Use Time off, an empty bool-check list does not invoke events. Repeat can cause repeated spawning or advancement; guard those actions with session/visit identity.

Bind a physical GameObject to the stable UID of an authored World Item. Item references, gameplay actions and runtime state all resolve to that identity.

1. Author the World Item and its initial state in Storyteller, then push the scene.
2. Attach WorldItem to its scene object and bind SceneData and the item UID.
3. Configure events such as OnReferenced, OnTaken, OnUsed, OnOwnerChanged or OnConsumed to drive the visual and gameplay response.

Taking an item changes possession; ownership is separate. Methods such as Take, GiveTo, Drop, PlaceIn, TransferOwnershipTo, Use and Consume update narrative state. Events control physical movement, visibility and animation. Read the full item workflow →

Make a door, switch, terminal or ordinary prop respond to input, Conditions and events. It can also select a configured story route.

1. Attach InteractableObject to the prop and configure its Conditions/events.
2. Call Interact from your input system, or enable proximity interaction with an assigned target and key.
3. Configure the optional world prompt and route selection when needed.

Icon visibility distance and interaction distance are separate settings. A visible prompt does not guarantee the interactor is close enough to activate the object.

An optional scene-level access point for inventory bridges, UI, animation and gameplay queries.

1. Add the manager to a scene-system object and register its SceneData sets.
2. Use GetItemState, GetWorldItem or GetWorldItemGameObject with the appropriate scene and item UID.
3. Use InitializeAll or the scene-specific initialization methods, and ResetScene / ResetAll when starting fresh state.

The manager provides access to item state and scene bindings; design the inventory UI and physical behavior using your game’s own objects and event calls.

Detect collider entry/exit and forward interaction availability to compatible receivers. Automatic entry interaction is optional.

1. Attach CollisionInteractionTrigger to the object that owns the trigger area and assign the Interaction.
2. Configure colliders and the Unity trigger-physics setup; add compatible receivers to the intended targets.
3. Enable automatic interaction on entry only when your game should begin the conversation immediately.

Receive range notifications on a character, World Item or ordinary interactable object.

1. Attach CollisionInteractionReceiver to the target with the relevant collider.
2. Configure enter/exit StorytellerEvents to show prompts, update availability or invoke game behavior.
3. Test both entering and leaving the area, including how your UI behaves when the object becomes unavailable.

Select a branch of the current story route from a UI button or a clicked world object.

1. Assign Interaction and the intended Route Number.
2. Connect a UI button’s onClick to SwitchRoute, or connect a Ray Click event on a collider-equipped world object.
3. Activate the intended dialogue route and keep the Interaction unpaused while selecting it.

This component selects a route output. Use Ray Click directly with other event targets for world-object clicks that do not involve a dialogue route.

Detect camera ray hits on an object’s colliders and invoke click or hover events, independently of an active dialogue route.

1. Attach RayClick to a collider-equipped prop and configure the camera/raycast settings.
2. Connect click and hover StorytellerEvents to World Item actions, InteractableObject.Interact or your own public functions.
3. For a clickable route option, connect On Click to RouteClickListener.SwitchRoute.

Persist configured GameObjects, components and supported data with ordered JSON save/load operations and named slots.

1. Choose the targets, components and supported members your game needs to save.
2. Order prerequisites before dependent systems. Save and load process configured targets from top to bottom.
3. Choose a folder and slot, then connect Save and Load to UI, input or StorytellerEvents. Configure automatic lifecycle behavior only when desired.

The save pipeline supports atomic file replacement, backups, callbacks and transform restoration options. Coordinate physical object state with your gameplay systems. Shared event variables and arbitrary generated UI require an explicit persistence strategy.

Persist narrative progression and runtime World Item state separately from the generalized game-state pipeline.

1. Assign the target Interaction and choose a slot with SetActiveSlot.
2. Call Save to capture narrative state, then Load to restore it. Enable Load On Start only when intended.
3. Coordinate the slot and load order with SaveManager and the SceneData/runtime setup.

Narrative restoration uses node identities and can retain a pending load until required runtime data is ready. Runtime item state is restored without replaying the current item event. Test a save mid-conversation, after a choice, after an item action and across scene changes.