> 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/subsystems/subsystems.md).

# Subsystem Guide

> Online doc: <https://morningheartgames.gitbook.io/docs/gameplay-ability-toolkit/subsystems/subsystems?fallback=true>

Gameplay Ability Toolkit is easiest to learn as a set of cooperating subsystems. Each page in this section explains one subsystem in the same practical shape: what it does, when to use it, which assets or components it needs, how to configure it in the Unity Editor, how it behaves at runtime, and where to inspect examples.

![Practical map of the Gameplay Ability Toolkit subsystems.](/files/nG40MLZQkhUfLm5oGmt7)

Use this section when you know the area you are working in. Use [Getting Started](/docs/gameplay-ability-toolkit/try-it/01-getting-started.md) when you want a first end-to-end setup, and use the [Cookbook](/docs/gameplay-ability-toolkit/build-with-it/07-cookbook.md) when you want a copyable gameplay pattern.

## Common Indie Developer Questions

| If you are asking                                                                       | Read                                                                                                                                                                                                         |
| --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Where does runtime state live on a character, dummy, interactable, or projectile owner? | [AbilitySystemComponent](/docs/gameplay-ability-toolkit/subsystems/ability-system-component.md)                                                                                                              |
| Which project assets must exist before anything works?                                  | [Configuration and Dashboard](/docs/gameplay-ability-toolkit/subsystems/configuration-dashboard.md)                                                                                                          |
| How do Health, Mana, Stamina, Damage, Armor, or Speed work?                             | [Attributes](/docs/gameplay-ability-toolkit/subsystems/attributes.md), then [Modifiers and Magnitudes](/docs/gameplay-ability-toolkit/subsystems/modifiers-magnitudes.md)                                    |
| How do I build attacks, spells, skills, item uses, or AI actions?                       | [Abilities](/docs/gameplay-ability-toolkit/subsystems/abilities.md), then [Authoring Abilities](/docs/gameplay-ability-toolkit/build-with-it/03-authoring-abilities.md)                                      |
| How do I build damage, healing, buffs, debuffs, costs, cooldowns, DoTs, or passives?    | [Effects](/docs/gameplay-ability-toolkit/subsystems/effects.md), then [Authoring Effects](/docs/gameplay-ability-toolkit/build-with-it/04-authoring-effects.md)                                              |
| How do I gate rules with stunned, guarding, burning, invulnerable, or silenced state?   | [Gameplay Tags](/docs/gameplay-ability-toolkit/subsystems/tags.md), [Abilities](/docs/gameplay-ability-toolkit/subsystems/abilities.md), and [Effects](/docs/gameplay-ability-toolkit/subsystems/effects.md) |
| How do keyboard, gamepad, AI, or trigger inputs reach abilities?                        | [Core Input](/docs/gameplay-ability-toolkit/subsystems/input.md), then [Unity Input System](/docs/gameplay-ability-toolkit/integrations/unity-input-system.md) if you use the package                        |
| How do I make action games feel responsive around cooldowns or recovery windows?        | [Input Buffering](/docs/gameplay-ability-toolkit/subsystems/input-buffering.md)                                                                                                                              |
| How do target selectors, AoEs, traces, and filters work?                                | [Targeting](/docs/gameplay-ability-toolkit/subsystems/targeting.md)                                                                                                                                          |
| How do async ability steps, channels, waits, and cancellation work?                     | [Ability Tasks and Timing](/docs/gameplay-ability-toolkit/subsystems/tasks-timing.md)                                                                                                                        |
| How do systems send tagged payloads to abilities or listeners?                          | [Gameplay Events](/docs/gameplay-ability-toolkit/subsystems/gameplay-events.md)                                                                                                                              |
| How do VFX/SFX/UI-style notifications fire without hard-coded ability references?       | [Gameplay Cues](/docs/gameplay-ability-toolkit/subsystems/gameplay-cues.md)                                                                                                                                  |
| How do timed animations, casts, hit windows, combo windows, and overlays work?          | [Montage](/docs/gameplay-ability-toolkit/subsystems/montage.md)                                                                                                                                              |
| How do I show runtime state on screen?                                                  | [Runtime UI](/docs/gameplay-ability-toolkit/subsystems/runtime-ui.md)                                                                                                                                        |
| How do I debug noisy or missing runtime behavior?                                       | [Logging](/docs/gameplay-ability-toolkit/subsystems/logging.md) and the relevant subsystem page.                                                                                                             |
| Which tests document the contracts?                                                     | [Tests and Verification](/docs/gameplay-ability-toolkit/subsystems/tests-verification.md)                                                                                                                    |

## Subsystem Map

The actor-level center is `AbilitySystemComponent`. It owns runtime tags, attributes, effects, abilities, and the input queue for one GameObject. Project-level assets such as `GASConfiguration`, `GameplayTagAsset`, `AbilityInputLibrary`, and `GameplayCueLibrary` provide shared definitions. Optional modules add concrete input, animation, UI, and Game Creator abilities without changing the core runtime contracts.

```mermaid
flowchart LR
    Config["GASConfiguration"] --> ASC["AbilitySystemComponent"]
    Tags["GameplayTagAsset"] --> ASC
    Inputs["AbilityInputLibrary"] --> ASC
    Cues["GameplayCueLibrary"] --> ASC
    ASC --> RuntimeTags["RuntimeTags"]
    ASC --> RuntimeAttributes["RuntimeAttributes"]
    ASC --> RuntimeEffects["RuntimeEffects"]
    ASC --> RuntimeAbilities["RuntimeAbilities"]
    ASC --> InputQueue["AbilityInputQueue"]
    RuntimeAbilities --> Tasks["Ability Tasks"]
    RuntimeAbilities --> Targeting["Targeting"]
    RuntimeAbilities --> Montage["Montage"]
    RuntimeEffects --> GameplayCues["Gameplay Cues"]
    ASC --> UI["Runtime UI"]
```

## Source and Test Index

| Subsystem                   | Source folder                           | Related tests                                                                                                                                              |
| --------------------------- | --------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| AbilitySystemComponent      | `Core/`                                 | `DevelopmentTests/GameplayAbilityToolkit/Core.Tests/Editor/AbilitySystemLifecycleTests.cs`, `DevelopmentTests/GameplayAbilityToolkit/Core.Tests/PlayMode/` |
| Configuration and Dashboard | `Core/Editor/`                          | `DevelopmentTests/GameplayAbilityToolkit/Core.Tests/Editor/Configuration/`, `GASSetupHealthWindowQuickSetupTests.cs`                                       |
| Attributes                  | `Core/Attributes/`                      | `DevelopmentTests/GameplayAbilityToolkit/Core.Tests/Editor/Attributes/`                                                                                    |
| Gameplay Tags               | `Core/Tags/`                            | `DevelopmentTests/GameplayAbilityToolkit/Core.Tests/Editor/Tags/`, `RuntimeTagsTests.cs`                                                                   |
| Abilities                   | `Core/Abilities/`                       | `DevelopmentTests/GameplayAbilityToolkit/Core.Tests/Editor/Abilities/`                                                                                     |
| Effects                     | `Core/Effects/`                         | `DevelopmentTests/GameplayAbilityToolkit/Core.Tests/Editor/Effects/`                                                                                       |
| Modifiers and Magnitudes    | `Core/Modifiers/`                       | `ModifierMagnitudeTests.cs`, `ModifierMagnitudeDeepContractTests.cs`                                                                                       |
| Core Input                  | `Core/Input/`                           | `DevelopmentTests/GameplayAbilityToolkit/Core.Tests/Editor/Input/`                                                                                         |
| Input Buffering             | `Core/Input/Buffering/`                 | `DevelopmentTests/GameplayAbilityToolkit/Core.Input.Buffering.Tests/Editor/`                                                                               |
| Targeting                   | `Core/Targeting/`                       | `DevelopmentTests/GameplayAbilityToolkit/Core.Tests/Editor/Targeting/`                                                                                     |
| Ability Tasks and Timing    | `Core/Task/`, `Core/Timing/`            | `DevelopmentTests/GameplayAbilityToolkit/Core.Tests/Editor/Tasks/`                                                                                         |
| Gameplay Events             | `Core/Events/`                          | Ability and system interaction tests                                                                                                                       |
| Gameplay Cues               | `Core/Cue/`                             | `DevelopmentTests/GameplayAbilityToolkit/Core.Tests/Editor/Cues/`                                                                                          |
| Montage                     | `Core/Montage/`, `Core/Editor/Montage/` | `DevelopmentTests/GameplayAbilityToolkit/Core.Tests/Editor/Montage/`, `MontageTaskTests.cs`                                                                |
| Runtime UI                  | `UI/`                                   | `DevelopmentTests/GameplayAbilityToolkit/UI.Tests/Editor/`                                                                                                 |
| Logging                     | `Core/Logging/`                         | `TargetingCueMontageLoggingDeepContractTests.cs`                                                                                                           |
| Unity Input System          | `InputSystem/`                          | `DevelopmentTests/GameplayAbilityToolkit/InputSystem.Tests/Editor/`                                                                                        |
| Animancer                   | `Animancer/`                            | Manual montage verification unless project adds Animancer-specific tests                                                                                   |
| Game Creator                | `GameCreator/`                          | `DevelopmentTests/GameplayAbilityToolkit/GameCreator.Tests/Editor/`                                                                                        |

## Documentation Pattern

Each subsystem page uses the same reading order:

1. Read **What It Does** to understand the responsibility.
2. Read **When To Use It** to confirm the subsystem is the right tool.
3. Read **Editor Setup** before creating assets.
4. Read **Runtime Flow** before writing custom code.
5. Use **Configuration Checklist**, **Debugging Checklist**, and **Common Mistakes** during implementation.
6. Use **Examples and Tests** when you need a working reference.

## Naming Rules

Reader-facing copy uses **Gameplay Ability Toolkit**. Technical identifiers remain unchanged: `GameplayAbilityToolkit.Core`, `AbilitySystemComponent`, `GASConfiguration`, `GameplayAbilityToolkit/`, and `GAS` are the actual Unity and C# names.


---

# 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/subsystems/subsystems.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.
