Hierarchical Tag Forge

Why use Hierarchical Tag Forge?

Hierarchical Tag Forge is a production-grade, Unreal-style hierarchical gameplay tag framework for Unity. It gives you a single, consistent vocabulary you can use across your entire project; abilities, AI states, items, units, weapons, buffs/debuffs, events, UI flows, quest flags, and more; while keeping runtime lookups fast, deterministic, and scalable as your content grows. Instead of relying on fragile string comparisons, scattered enums, one-off manager scripts, or concrete type references, you maintain a centralized Gameplay Tag Database and query it efficiently at runtime through optimized access patterns designed for real game workloads.

A core focus of Hierarchical Tag Forge is performance: the runtime APIs and query evaluation are structured for zero-GC allocation during gameplay querying, enabling frequent checks and complex evaluations without avoidable garbage collections; ideal for AI, combat, state machines, and systemic gameplay. 

///KEY STRENGTHS///

Hierarchical organization: Define tags in a clean parent/child structure (e.g., Ability.Magic.Fire.Fireball) that scales to large projects.

Fast runtime access: Designed for repeated tag checks in hot gameplay loops.

Zero-GC querying: Query evaluation is built to avoid per-call allocations during runtime usage.

Three ways to use tags (choose your workflow):

• Code-authored tags: declare tags directly in code for fully code-driven pipelines.
• Editor-authored tags + generated code references: create tags in the Tag Manager, bake, then reference them in code via generated constants.
• No-code / Inspector-driven: select and use tags through custom property drawers, prebuilt components, and assets without writing tag strings manually.

Automated code generation: Bake generates a flat static class containing constant tag references, giving you clean, typo-proof access in code without hand-authoring declarations.

Editor-first authoring: Dedicated tooling for daily tag creation, browsing, and maintenance.

Tag pickers & property drawers: Inspector-ready UX for selecting tags and containers safely; no string entry, no guessing.

Query Builder UI: Build and visualize tag queries in-editor rather than hand-authoring complex logic.

GAS-style Requirements Query asset: Author requirement logic like Require All, Require Any, and Block Any (great for ability gating, interactions, equipment rules, and state constraints).

Reactive gameplay support (built-in, minimal setup):

Hierarchical Tag Forge includes a practical “ownership” component out of the box:

• A tag owner surface to represent “this object currently has these tags.”

This enables common production patterns; doors, interactables, devices, UI states, buffs, or world triggers, to be driven by tags immediately.

Production validation/baking: Catch hierarchy issues, collisions, and invalid data early, before runtime.

Scales with content: Works whether you have dozens of tags or tens of thousands.

///HIERARCHICAL TAG FORGE INCLUDES///

Gameplay Tag Database (core asset):

A centralized database asset that stores and organizes your hierarchical tags. This becomes the source of truth for your project’s tag vocabulary.

Tag Manager (Editor Window):

A purpose-built editor tool for creating, organizing, searching, and maintaining your tags quickly. Designed for day-to-day production iteration.

Tag Pickers / Property Drawers:

Inspector-ready UI for selecting tags and tag containers safely and quickly; no fragile string entry, no guesswork.

Query Builder UI:

An editor interface for authoring and inspecting tag queries. Useful for designers and programmers alike when building complex condition logic.

Tag Requirements Query (GAS-style):

A dedicated “requirements” style asset for common gating logic:

• Require All
• Require Any
• Block Any

Ideal for abilities, interactions, equippables, AI behaviors, quest conditions, and UI state gating.

Code-Declared Tags:

Support for declaring tags in code for stable global references and structured workflows.

Bake + Automated Code Generation:

A bake workflow that validates your database and can generate code for easy runtime access. Generated output includes a flat static class of constant tag references, enabling a workflow where users:

• author tags in the Tag Manager,
• bake,
• reference tags in code via generated constants (no string typing, no manual declarations).

Validation & Baking Pipeline:

A bake/validation pass to ensure your database is internally consistent and runtime-ready.

Demo Scene + Template Code:

A complete demo scene with prebuilt example code that demonstrates the expected usage patterns across the system. The examples are designed to be directly reusable with minimal changes.

Performance TestHarness (Profiling):

A dedicated TestHarness intended for profiling and validation, including stress scenarios such as 100,000s of queries across 1,000s of owners per frame, so users can measure real runtime cost and confirm the zero-allocation query approach in their own project context.

Choose your preferred integration style:

• Add an observer component to react to tag state via rules + UnityEvents.No-code / Inspector-driven: use drawers + prebuilt components/assets.
  Add a tag owner component to objects that own tags.
  
• Generated constants: author tags in-editor, bake, and reference them via a generated flat static constants class.
• Code-authored tags: declare tags in code directly.

Use tags at runtime via tag fields, tag containers, and queries; driving AI decisions, ability gating, item rules, animation states, quest flags, UI flows, and more.

Use the demo + TestHarness to accelerate integration and validate performance.

///WHAT HIERARCHICAL TAG FORGE IS NOT///

It is not an ability system, inventory system, quest system, or AI framework.

It does not replace your gameplay architecture; it provides a high-performance vocabulary layer that makes your systems cleaner, more consistent, and easier to scale.

///DISCLAIMERS///

• None of the assets shown in videos/screenshots are included unless explicitly stated.

• Runtime performance depends on project scale, usage patterns, and hardware; the system is designed to minimize allocations during querying and keep lookups efficient for frequent gameplay checks. While all querying is allocation free some allocation is required for mutation such as adding and removing tags from a container, using bulk tag changes will keep allocation to a minimal during those scenarios. 

• General knowledge of C# concepts such as events, ref/in keywords is required to use this asset fully. 

• All performance benchmarks were tested on the following processor: 

12th Gen Intel(R) Core(TM) i9-12900K (3.20 GHz)

///SUPPORT/ CONTACT///

If you run into issues or have feature requests, contact me directly. For bug reports, please include:

• Unity version
• Summary of the problem
• Steps to reproduce
• Screenshots (if applicable)

Email: anthony.halstead@carryforgestudio.com

Discord: https://discord.gg/9RCShGqktS

Website: https://carryforgestudio.com

YouTube: CARRY FORGE - YouTube