The Advanced Gameplay Tags Manager System (AGTMS) is a production-ready Unreal Engine plugin designed to simplify and enhance the control of Gameplay Tags within any game project.
It provides developers with a clean, structured approach to managing tags across multiple layers, ensuring consistent behavior, easier debugging, and complete control over active, blocked, and permanent states.
The system is fully blueprint-friendly and can be integrated seamlessly into both small prototypes and large-scale projects.
Active, Blocked, and Permanent layers for full control over character states.
• Smart Validation ChecksAutomatic protection against invalid add/remove operations using layered rules.
• Bi-Directional Conflict RulesFlexible conflict engine that prevents incompatible tags in both directions.
• Runtime Tag ReplacementInstantly swap tags (e.g., unarmed → rifle) with zero manual logic.
• Event-Driven ArchitectureDispatchers for tag added/removed, blocked tags, conflicts events.
• Runtime Blacklist SupportTemporarily restrict certain tags inside zones, triggers, or gameplay states.
• Save & Load ReadyBuilt-in serialization for restoring full tag state across levels or sessions.
• Blueprint-Only, High PerformanceNo ticks, clean logic, scalable, and fully compatible with Animation Blueprints & Choosers.
• Plug-and-Play IntegrationDrop the component in any character and start using it immediately.
eliminates the complexity of managing large tag systems by offering a unified, reliable solution.
Instead of manually creating rules, checks, and tag validations, developers can rely on a powerful, pre-built framework that reduces development time, prevents logic errors, and keeps gameplay behavior consistent.
This plugin is designed to fit any workflow, whether you're building a first-person shooter, an open-world adventure.
Unreal Engine gives you : GameplayTag, GameplayTagContainer, Add Tag, Remove Tag, MatchesTag, HasTag...etc
There are no : [PermanentLayer][ActiveLayer][BlockedLayer]
Conflict Handling, events dispatchers , rule logic ..... and others things
This gives your game a AAA level of control—especially if you're going to do an Ability System or Character States.
Our component is professional State Management ,
You are the one who designs the rules of the system.
also unreal engine not gives you Multi-Tag Operations with Array of tags , this component plug & play
, reusable
GamePlay Tags in Unreal Engine are just the foundation.
We built a complete framework on top of them:
✔ Active/Blocked/Permanent Layers
✔ Conflict System
✔ Debug System
✔ Events
✔ Tag Utilities
✔ Multi-Tag System
✔ Reusable Component
✔ AAA Architecture
This isn't readily available and gives your game significantly more power, control, and organization.
You simply need to employ it in your own way to build your game and benefit from it.
| RowName | PermanentTags | Conflict rules |
|---|---|---|
| RowName == ActorType | PermanentLayer | tag + array(conflicted with tags) |
then we should type character in actortype input in initializepermtag function to select the right row from dataTable
also if you forget to reverse the rule like can't aiming while jumping don't worry conflict rule will check it in biDirectional
Component created for : Windows / UE 5.3 - 5.7
but component should work in any platform or version that support gameplay tags
Sample project created in : Windows / UE 5.6 - Ue 5.7
Represents the tags currently applied to the character during gameplay.
These tags define the character’s live state (e.g.)
character.movement.run character.weapon.rifle
A temporary blacklist that prevents certain active tags from being added.
Useful for restricted areas, gameplay zones, physics puzzles, stealth rooms, etc.
A high-level category reserved for tags that must never be removed unless explicitly forced.
Useful for class attributes, character abilities, or permanent game modes.
A powerful rule engine that prevents incompatible tags from co-existing.
The check works both ways In case you forgot to add the reverse rule:
If A conflicts with B → B conflicts with A If B is active → A cannot be added
If A is active → B cannot be added
This guarantees stable & predictable gameplay logic.
A shortcut operation to swap tags immediately.
Example:
aiming.unarmed → aiming.rifle
You can save and restore the entire tag state using built-in functions:
GetSerializedTags → LoadSerializedTags
Useful for respawns, save systems, or switching levels.
The system fires multiple events whenever tags change:
OnTagAddedOnTagBlocked
OnTagRemovedOnTagConflict
OnTagsSerializedOnTagsLoaded
Events allow disconnected systems (UI, animations, weapons, effects…) to react instantly.
This section provides a complete reference for all public functions included in the Advanced Gameplay Tags Manager Component. Each function is organized by category and explained in a clear, concise, and technical manner.
Called once on BeginPlay.
Loads default permanent tags from component settings and pushes them into:
Permanent Layer
Active Layer
Ensures consistent startup state.
Input: Target(Obj ref) → Component Reference
Input: ActorType(Name) → RowName
RowName == ActorType in DataTable to fetch the row for specific ActorType
Input: Debug(Bool) → True/False
this debug bool print messages on screen to see if everything work correctly or not
Logic :
1. Prevent twice calling and print error if that happend
2. Validation for inputs to make sure inputs not empty or ActorType is wrong
3. Check for any duplicated values and print error message
4. Check for any Conflict rules if we add 2 conflicted tags with each other
5. Prepare active layer and permanent layer [Success]
Adds a single Gameplay Tag to the Active Layer.
This operation performs full validation before adding the tag to ensure system stability and predictable behavior.
Input: Tag(GameplayTag) → Tag we want to add.
Input: Print(bool) → To print debug messages for development.
Output: IsAdded(bool) → To use it for conditions.
Output: Reason(String) → To print Reason to know success or why fail or just use Print(True)
Adds multiple tags into the Active Layer in a single batch operation.
Each tag is validated independently using the exact same logic as AddActiveTag().
Input: Tags(GameplayTagContainer) → Tags we want to add.
Adds a single Gameplay Tag to the Blocked Layer.
Blocked Tags immediately prevent any tag from being activated if it appears in this list.
This layer has the highest priority in the system.
Input: Tag(GameplayTag) → Tag we want to add.
Input: Print(bool) → To print debug messages for development.
Output: IsAdded(bool) → To use it for conditions.
Output: Reason(String) → To print Reason to know success or why fail or just use Print(True)
Same as AddBlockedTag
Adds multiple tags to the Blocked Layer in one batch.
Each tag passes through full validation independently.
Removes a single tag from the Active Layer.
Input: Tag(GameplayTag) → Tag we want to remove.
Input: Print(bool) → To print debug messages for development.
Output: IsRemoved(bool) → To use it for conditions.
Output: Reason(String) → To print Reason to know success or why fail or just use Print(True)
Batch-removes multiple active tags at once.
Input: Tag(GameplayTag) → Tag we want to remove.
Input: Print(bool) → To print debug messages for development.
Output: IsRemoved(bool) → To use it for conditions.
Output: Reason(String) → To print Reason to know success or why fail or just use Print(True)
Removes a single tag from the Blocked Layer.
Input: Tag(GameplayTag) → Tag we want to remove.
Input: Print(bool) → To print debug messages for development.
Output: IsRemoved(bool) → To use it for conditions.
Output: Reason(String) → To print Reason to know success or why fail or just use Print(True)
Batch-removes multiple blocked tags at once.
Input: Tag(GameplayTagContainer) → Tag we want to remove.
Input: Print(bool) → To print debug messages for development.
Output: IsRemoved(bool) → To use it for conditions.
Output: Reason(String) → To print Reason to know success or why fail or just use Print(True)
Replaces an existing active tag with another tag.
Input: OldTag(GameplayTag) → old Tag we want to replace.
Input: NewTag(GameplayTag) → New tag we want to add
Input: Debug(bool) → To print debug messages for development.
Output: IsReplaced(bool) → To use it for conditions.
Replaces an existing Blocked tag with another tag.
Input: OldTag(GameplayTag) → old Tag we want to replace.
Input: NewTag(GameplayTag) → New tag we want to add
Input: Debug(bool) → To print debug messages for development.
Output: IsReplaced(bool) → To use it for conditions.
Clears all Active Tags stored inside the gameplay container.
Input: print(bool) → To print debug messages to see if layer empty or not for development.
KeepPermanent = true → Permanent tags remain untouched.
KeepPermanent = false → All active tags are removed, including permanent ones.
Clears all Blocked Tags stored inside the gameplay container.
Input: print(bool) → To print debug messages to see if layer empty or not for development.
Clears all Permanent Tags stored inside the gameplay container.
Input: print(bool) → To print debug messages to see if layer empty or not for development.
Returns the current Active Gameplay Tag Container stored in the component.
Input: print(bool) → To print tags in the container for development.
ReturnValue: Output(GameplayTagContainer) → full snapshot of all active tags, including both temporary and permanent ones because permanent mean always active during.
Same as GetActive but it's get BlockedTags
Same as GetActive,Getblocked but it's get PermanentTags
Checks whether a specific Gameplay Tag is currently active inside the component.
Boolean – True if the tag exists in the Active container (temporary or permanent), otherwise False.
Checks if the specified Gameplay Tag is currently blocked and should not be activated.
Boolean – True if the tag exists in the Blocked container , otherwise False.
Checks whether a specific Gameplay Tag is currently exist inside the Permanent Layer.
Boolean – True if the tag exists in the Permanent container , otherwise False.
Generates a serialized snapshot of the ActiveTags layer current state.
This snapshot is used for saving or restoring gameplay actiev tags at runtime.
Loads a previously saved tag structure and restores it into the component while preserving the Permanent Tags layer.
Resets the component to a clean state by removing all Active and Blocked tags while preserving Permanent Tags.
Permanent Tags always remain active throughout the entire game lifetime and are re-applied automatically after the reset.
Validates whether an input tag can be added by checking the Conflict Rules defined inside the DataTable.
This includes a full bi-directional conflict check, ensuring the user can't forget to define the reverse conflict.
Example:
If A conflicts B
But the developer forgot to add "B conflicts A"
The system still catches it.
Internal helper function used to prevent adding a tag that already exists in either the Active or Blocked layers.
To safely access your Gameplay Tags Component from the Animation Blueprint—without access errors, thread issues, or invalid references—you must use a shadowing structure variable.
This ensures the AnimBP works only with copied data, not live references, which prevents runtime crashes and keeps performance high.
The Animation Blueprint runs on a separate thread and cannot reliably read Actor Component data directly.
So we create a structure variable inside the AnimBP, for example such as:
Struct: AnimStateData
Active Tags (GameplayTagContainer)
Blocked Tags (GameplayTagContainer)
Permanent Tags (GameplayTagContainer)
Optional booleans (IsAiming, IsArmed, etc) — derived from tags
Or any other data that is relevant to your project
This struct becomes the safe mirrored state of the component.
The Character BP pushes updated tag data to the AnimBP every time something changes.
Create a Custom Event:
Event UpdateTagState (Input: AnimStateData Struct) → Set the shadowing variable
Whenever tags change:
OnActiveTagAdded
OnActiveTagRemoved
OnBlockedTagAdded
OnBlockedTagRemoved
Replace events
Clear events
You simply call UpdateTagState and pass the struct.
This guarantees the AnimBP is always synced.
✔ Zero access errors
✔ Zero crashes
✔ Safe for multithreading
✔ UI / Animation / Gameplay always synced✔ Perfect for Motion Matching + Chooser
✔ Component remains modular and reusable
✔ Production-ready for AAA pipelines
>
1. Create Structure and call it → AnimDataState
2. add booleans variable you need and variables for gameplaytags containers (Anyway it just for example you can make it as you like )
3. go to your Character blueprint then create new function let's call it UpdateAnimStateTags
4. create a variable call it → AnimStateData and set variable type → your structure
5. Then Create some local variables to fill our structure like shown in the image
6. by using function IsTagActive we can fill our booleans
also tags container we can use GetFunctions to save Tags container
7. let's pass data to AnimStateData(struct).
8. go to your animation blueprint and create a variable AnimStateData
9. let's fill it in Game thread don't do anything in animation blueprint again close it
go back to function UpdateAnimStateTags in your character blueprint
send Data from the character variable cast it to animation graph variable
Let's see how to use it with chooser Table]
timer by event and check looping in 0.02 50Hz or 0.033 30Hz
We aim to keep the Advanced Gameplay Tags Manager System clean, stable, and easy to integrate.
Future updates will focus on:
Additional quality-of-life functions based on community feedback
More plug-and-play examples (Animation BP, Motion Matching, Restricted Zones, Item Systems)
Improved error-handling and debugging helpers
Optional performance-friendly utilities for large projects
Documentation refinements and new usage guides
We are committed to supporting the system with practical, meaningful updates—not unnecessary features.