> For the complete documentation index, see [llms.txt](https://morningheartgames.gitbook.io/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://morningheartgames.gitbook.io/docs/gameplay-ability-toolkit/integrations/game-creator/visual-scripting.md).

# Visual Scripting Workflows

This page is for wiring real Game Creator graphs: inputs, combat events, conditional branches, feedback, and one-off project logic that should not become hard-coded ability runtime.

Configure as much as possible in `GameCreatorAbilityDefinition`, then use Game Creator Visual Scripting for input, event reactions, condition gates, debug hooks, and project-specific behavior.

## Input

Use Game Creator Press and Release Triggers to call:

| Node            | Use                                                                  |
| --------------- | -------------------------------------------------------------------- |
| `Press Input`   | Dispatches a GAT logical input press to an `AbilitySystemComponent`. |
| `Release Input` | Dispatches the matching release.                                     |

Add `GameCreatorAbilityInputGate` to actors that receive those triggers. The gate ensures one physical press cannot repeatedly dispatch the same GAT press until release.

For targeted abilities, keep `Input > Suppress Presses While Targeting` enabled so target confirmation clicks do not also trigger unrelated abilities.

## Effects And Attributes

Use recipe fields for common effect application:

* `SelfEffect` mode for buffs and self-applied effects.
* `Projectile > Impact Effects` for projectile hits.
* `Melee > Hit Effects` for montage-timed attacks.
* `Channel > Resource Tick Effect` and `Tick Effects` for held abilities.
* `Movement > Self Effects` for temporary movement states.

Use Essential Visual Scripting nodes when graph logic needs direct control:

* `Apply Effect`
* `Remove Gameplay Effect`
* `Remove Last Applied Gameplay Effect`
* `Change Gameplay Attribute Value`
* `Compare Gameplay Attribute`
* runtime effect and attribute getters

When runtime code already owns the logic, prefer direct GAT effect and attribute APIs. Add Visual Scripting nodes only for operations that are useful across multiple skills.

## Tags

Tags are the normal bridge between GAT state and Game Creator graph logic.

Common workflows:

* Add a state tag before an interaction and remove it when the interaction ends.
* Wait for a tag to appear or disappear before continuing a Game Creator graph.
* Block or unblock abilities with matching tags during cinematic, targeting, stun, channel, or invulnerability states.
* Count owned tags for UI or debug displays.

## Targeting

For normal targeted projectile recipes, configure `Target` in the ability Inspector. Use Visual Scripting targeting nodes when a graph needs manual control:

| Node Family                         | Use                                                                                |
| ----------------------------------- | ---------------------------------------------------------------------------------- |
| `Start Current Ability Targeting`   | Starts a `TargetCollector`, stores it in context, and can wait for confirm/cancel. |
| `Wait Current Ability Targeting`    | Pauses until the active session confirms or cancels.                               |
| `Confirm Current Ability Targeting` | Confirms the active collector.                                                     |
| `Cancel Current Ability Targeting`  | Cancels the active collector.                                                      |
| `Collect Current Ability Targets`   | Uses a GAT `TraceShape` and stores hit targets in the current context.             |

Targeting results are stored in the current ability context: target actor, target point, collector object, confirm/cancel state, and target count.

![Target collector filtering and indicator authoring.](/files/3qHsv2CFi8V1tAKfb1RC)

## Montage

Use the ability `Cast`, `Swing`, `Hold`, or `Move` steps for common montage playback. Use montage nodes when a graph needs explicit control:

* `Play Montage`
* `Wait for Current Ability Montage Notify`
* `Wait for Current Ability Montage Completed`
* `Stop Montage`
* `Set Current Ability Montage Play Rate`
* `Jump Current Ability Montage Section`

The Game Creator bridge routes GAT `AnimationMontage` playback through a Game Creator-aware animation driver when the owner is a Game Creator `Character`.

## Projectile

Use `Projectile` or `TargetedProjectile` execution modes for most skills. Visual Scripting nodes are available when a graph needs lower-level projectile flow:

* `Launch Projectile`
* `Wait for Current Ability Projectile Impact`
* `Apply Area Impact`

Projectile impact data is stored in the current ability context: projectile object, impact point, impact target, and whether impact was received.

## Channel

Use `Channel` execution mode for hold skills. The recipe handles tick interval, resource tick effect, tick effects, hit area, cue tag, and end-on-release.

Use Visual Scripting nodes for custom graph-controlled channel logic:

* `Apply Channel Tick`
* `Trigger Channel Cue`

The context stores cue parameters and hit targets so follow-up instructions can read the same tick results.

## Hitbox

Melee recipes usually open and close hit windows from montage markers. Visual Scripting hit nodes are available for custom timing:

* `Apply Hit Shape`
* `Open Weapon Hitbox Window`
* `Poll Weapon Hitbox Window`
* `Close Weapon Hitbox Window`

Use `Apply Hit Shape` for trace-based one-shot hits. Use the hitbox window nodes when the hit area should remain open for a montage interval and poll deterministically.

## Cues

Use cue nodes for gameplay feedback:

* `Trigger Gameplay Cue`
* `Trigger Current Ability Cue`
* `Set Current Ability Cue Parameters`
* `Cleanup Gameplay Cues`

Recipe systems already set useful cue parameters for channel, projectile, and hit flows. Use context cue getters when a graph needs to read or adjust those values.

## Context Helpers

Current ability context nodes are the preferred way to communicate between recipe events, Visual Scripting modules, and runtime helpers.

Use context helpers to:

* set or read target actor and target point;
* add, clear, and count hit targets;
* store bool, decimal, string, position, and object variables;
* read input name and ability level;
* inspect targeting, montage, projectile, commit, and effect apply results;
* build cue parameters from the active ability state.

Add new context helpers only for state that is stable across recipe events. Short-lived implementation details should stay inside runtime code.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://morningheartgames.gitbook.io/docs/gameplay-ability-toolkit/integrations/game-creator/visual-scripting.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.