Actor Tag vocabulary

BertaDevKit provides 40 explicit names across 16 subfamilies under Berta.ActorTag.* for Unreal Engine 5.8. They describe static actor classifications, opt-in capabilities, and actor-level reference markers. Native Gameplay Tags supply a selectable dictionary; projects copy a selected tag's name into native Actor Tags (AActor::Tags, an array of FName). This adds no runtime tag container or gameplay system.

Registration does not assign tags to actors or implement capabilities. A marker does not prove current availability, authorization, or state. Every Anchor/Point entry identifies an actor used as a spatial reference: read the actor's existing transform or project-owned data. The name supplies no component, socket, transform, area bounds, or route data of its own.

Installation and registration

Copy the existing BertaDevKit plugin into your UE 5.8 project's Plugins directory, preserving Config/Tags/BertaActorTags.ini and Source. Build the project for your engine installation.
Enable BertaDevKit in Edit → Plugins, including its existing declared prerequisites. BertaGASCompanionExt and GAS Companion are not required for this vocabulary. No new plugin or module is needed.
Restart Editor. In Edit → Project Settings → Project → Gameplay Tags, keep Import Tags From Config enabled for the native config dictionary workflow. Do not silently override a project's deliberate import policy.
Open Manage Gameplay Tags, search for Berta.ActorTag.Targeting.Focusable, and inspect its BertaActorTags.ini source and description. Select it in an FGameplayTag property. Actor Tags remain manually entered names in Details → Actor → Tags; that array does not become a Gameplay Tag picker.

The base Runtime module resolves its own descriptor with IPluginManager, combines the base directory with Config/Tags, and calls UGameplayTagsManager::AddTagIniSearchPath() at its existing Default startup phase. GameplayTags is already a dependency; Projects is private for descriptor lookup. The list uses [/Script/GameplayTags.GameplayTagsList] and repeated GameplayTagList= rows without +, following the existing verified additional-source convention. Intermediate parents are implicit picker nodes, not explicit entries.

The provider plugin must be installed, enabled, and available when dictionary consumers load, including the relevant deployed build. Disabling it leaves any serialized Actor Tag FName values as ordinary names, but removes this provider's registered selections and descriptions. Keep config with the plugin and inspect staging in the actual packaging environment; an Editor build does not prove packaged availability. See the shared registration and import details for UE 5.8 source evidence and staging considerations.

Matching and ownership

SelectedTag.GetTagName() returns an FName. Actor Has Tag / AActor::ActorHasTag() compares that complete name against the actor's Tags array. There is no hierarchical matching. An actor tagged Berta.ActorTag.Targeting.Focusable does not thereby match Berta.ActorTag.Targeting, and storing only the parent does not match the child. Gameplay Tag container hierarchy queries are a separate API and do not change Actor Tag behavior.

FName comparisons are case-insensitive. Case changes do not create distinct Actor Tags; retain the canonical PascalCase spelling for readable serialized data and consistent documentation. A different suffix or segment is a different name. NAME_None is not a successful native ActorHasTag query.

Actor Tags and Component Tags are separate arrays. A tag on a cube's StaticMeshComponent is not an Actor Tag on its owning actor; Actor Has Tag does not inspect components. Component Has Tag examines the component's own ComponentTags instead.

The vocabulary provides no automatic assignment, tag-to-actor synchronization, capability implementation, manual-name validation, or replication guarantee. UE 5.8's AActor::Tags property is editable/Blueprint writable but is not declared replicated. Even a replicated actor does not gain tag synchronization from this catalog. Projects own networking, authority, lifecycle, and validation. A plain actor needs no ASC, interface, or extra component to store these names or pass Actor Has Tag.

Relationship to the existing Gameplay Tags catalog

The 474-tag catalog remains in BertaGASCompanionExt with its existing semantics and dependency requirements. Similar terms are not aliases; consumers must choose the intended source and matching API.

Existing family	Distinction from Actor Tag markers
`Berta.Targeting.*`	Query modes, relations, and filter requests interpreted by a resolver; ActorTag Targeting marks an individual actor's eligibility.
`Berta.Interaction.*`	Interaction affordances and availability vocabulary for project-owned providers; ActorTag Interaction is a static actor capability opt-in, not proof it can act now.
`Berta.State.` / `Berta.Status.`	Conditions owned over time by gameplay systems; Focusable and LockOnTarget never mean currently focused or locked.
`Berta.Camera.*`	Camera policies; ActorTag Camera identifies candidate actors, spatial references, or project-interpreted exclusion/occlusion markers.
`Berta.AI.*`	AI behaviors, perception labels, and roles; ActorTag AI marks spatial reference actors rather than a running AI decision.
`Berta.Damage.` / `Berta.Effect.`	Damage/effect classifications; ActorTag Combat describes the actor itself without applying damage or defining component hit zones.
`Berta.World.` / `Berta.Quest.`	World metadata and quest participant records; ActorTag World and Quest provide actor references without area geometry or objective progress.
`Berta.Item.` / `Berta.Inventory.`	Item classifications and inventory conditions/events; Lootable and Harvestable identify source actors without transactions or available quantities.
`Berta.UI.` / `GameplayCue.Berta.`	UI context/state and cosmetic cue identifiers; UI/VFX anchors only identify reference actors and execute no presentation.

Blueprint: Sandbox camera focus

The Sandbox's GA_CameraFocusToggle workflow combines GAS Companion, Ultimate Gameplay Camera, Enhanced Input, and BertaDevKit. Those systems belong to the ability workflow; the cube only stores a native Actor Tag. This is a manual integration recipe, not a verified Sandbox change.

Place an ordinary cube. Enter Berta.ActorTag.Targeting.Focusable in Details → Actor → Tags on the actor, not its mesh component.
In the ability, create an FGameplayTag variable such as RequiredActorTag, selecting the registered Berta.ActorTag.Targeting.Focusable value.
Discover candidates with Multi Sphere Trace By Channel. Collision must allow the trace to detect the actor first: enable query collision and configure the chosen trace channel's responses. Review blockers and trace extent when an expected candidate is absent; a tag cannot make an undetected actor appear in hit results.
For each usable Hit Actor, evaluate the selected tag through Get Tag Name → Actor Has Tag, with that Hit Actor as the target. Use the returned Boolean to filter candidates.
The ability owns final selection, distance/visibility rules, current focus state, clearing or toggling focus, and camera behavior. Revalidate targets as needed. Eligibility alone never activates UGC or applies a camera operation.

Enhanced Input → GA_CameraFocusToggle
    Multi Sphere Trace By Channel → Out Hits → For Each → Hit Actor
    RequiredActorTag → Get Tag Name → Actor Has Tag (Target = Hit Actor)
        True → ability-owned final selection → camera behavior

The complete FName must match. No ASC, interface, or additional component is required on the cube, even though the ability's owner uses GAS Companion. The private Sandbox was not accessed or modified for this feature.

Prefer filtering already discovered trace/overlap candidates or retaining project-owned references over repeated full-world Actor Tag searches. Get All Actors With Tag iterates actors; running it every frame can become expensive and may require additional world/streaming lifetime handling. Profile the actual selection workflow.

C++ integration

Use native APIs in an existing project-owned consumer; no wrapper library is needed. Include Engine and GameplayTags in the consuming module's appropriate dependencies.

#include "GameFramework/Actor.h"
#include "GameplayTagContainer.h"

// Select this value through an existing reflected property, or resolve it
// after the enabled provider has registered its dictionary.
const FGameplayTag RequiredActorTag = FGameplayTag::RequestGameplayTag(
    FName(TEXT("Berta.ActorTag.Targeting.Focusable")));

// HitActor comes from the project's trace. Invalid hits are expected input.
if (IsValid(HitActor) && RequiredActorTag.IsValid() &&
    HitActor->ActorHasTag(RequiredActorTag.GetTagName()))
{
    // The project evaluates final eligibility and performs its camera action.
}

RequestGameplayTag expects the provider's registration to exist; avoid resolving names in unrelated global/static initialization. Projects may expose an existing FGameplayTag property with meta=(Categories="Berta.ActorTag") to narrow its picker. That metadata does not validate manually entered Actor Tags or assign them. Author Actor Tags deliberately in level/Blueprint defaults or project-owned spawning code.

Approved reference

Each explicit entry below has actor-level meaning. Suggested uses are project responsibilities. All spatial markers share the transform/data limitation described above; all capabilities need an implementation and current-availability checks.

AI

Berta.ActorTag.AI.CoverPoint

Meaning: Actor used as a spatial reference for AI cover selection.

Suggested usage: Place reference actors at authored cover locations.

Limitations: Does not prove protection, occupancy, reachability, or cover geometry.

Berta.ActorTag.AI.GuardPoint

Meaning: Actor used as a spatial reference for an AI guarding location.

Suggested usage: Resolve a guard's assigned post from a marked actor.

Limitations: Does not assign guards, define a radius, or start behavior.

Berta.ActorTag.AI.InvestigationPoint

Meaning: Actor used as a spatial reference for an investigation destination.

Suggested usage: Identify authored locations for an AI investigation routine.

Limitations: Does not create stimuli, select a route, or mark investigation state.

Berta.ActorTag.AI.LookAtPoint

Meaning: Actor used as a spatial reference for AI gaze decisions.

Suggested usage: Offer a point of interest to project-owned AI logic.

Limitations: Does not rotate the AI or implement an animation constraint.

Berta.ActorTag.AI.PatrolPoint

Meaning: Actor used as a spatial reference in an AI patrol route.

Suggested usage: Identify authored patrol stops for a project route definition.

Limitations: Does not supply route order, navigation paths, or patrol behavior.

Animation

Berta.ActorTag.Animation.LookAtTarget

Meaning: Actor eligible to serve as an animation look-at reference.

Suggested usage: Select a subject for project-owned gaze or aim animation.

Limitations: Does not supply bones, sockets, IK, or AI gaze decisions.

Camera

Berta.ActorTag.Camera.CameraAnchor

Meaning: Actor used as a spatial reference for camera placement.

Suggested usage: Identify authored positions for a project camera rig.

Limitations: Does not create a camera component, socket, or view transition.

Berta.ActorTag.Camera.CameraIgnore

Meaning: Actor opted out of a project's camera target-selection policy.

Suggested usage: Exclude a marked actor when project selection logic reads it.

Limitations: Does not automatically exclude collision, traces, rendering, or occlusion.

Berta.ActorTag.Camera.CameraOccluder

Meaning: Actor classified as a candidate occluder for camera obstruction policy.

Suggested usage: Classify obstacles considered by project-owned obstruction handling.

Limitations: Does not prove current obstruction or configure collision or fading.

Berta.ActorTag.Camera.CameraTarget

Meaning: Actor eligible for selection as a camera subject.

Suggested usage: Offer a subject to project camera framing or follow selection.

Limitations: Does not set a ViewTarget or imply current focus or lock-on.

Cinematic

Berta.ActorTag.Cinematic.CinematicAnchor

Meaning: Actor used as a spatial reference for cinematic staging.

Suggested usage: Locate an authored staging reference from sequence setup logic.

Limitations: Does not bind Sequencer tracks or initiate cinematic playback.

Combat

Berta.ActorTag.Combat.Damageable

Meaning: Actor classified as an intended recipient of project-defined damage.

Suggested usage: Filter candidate actors before calling the project's damage implementation.

Limitations: Does not create health, guarantee vulnerability, or process damage.

Berta.ActorTag.Combat.Explosive

Meaning: Actor classified as an explosive object under project combat rules.

Suggested usage: Recognize an explosive prop during project-owned combat selection.

Limitations: Does not detonate, apply radial damage, or indicate imminent explosion.

Berta.ActorTag.Combat.WeakPoint

Meaning: The tagged actor itself is classified as a weak point.

Suggested usage: Mark a separately authored weak-point actor used by combat logic.

Limitations: Does not identify arbitrary component hit zones or multiply damage.

Debug

Berta.ActorTag.Debug.DebugTarget

Meaning: Actor designated as a subject for project debugging tools.

Suggested usage: Filter actors offered to an existing debug inspection workflow.

Limitations: Does not start inspection or enforce Development-only execution.

Berta.ActorTag.Debug.TestActor

Meaning: Actor deliberately classified as a test subject in project setup.

Suggested usage: Identify authored test actors in a controlled test level.

Limitations: Does not execute tests or exclude the actor from packaging.

Gameplay

Berta.ActorTag.Gameplay.ActivationTarget

Meaning: Actor eligible to receive project-interpreted activation requests.

Suggested usage: Identify a mechanism considered by existing activation logic.

Limitations: Does not implement an interface, dispatch requests, or imply active state.

Interaction

Berta.ActorTag.Interaction.Inspectable

Meaning: Actor offering inspection as an intended interaction capability.

Suggested usage: Offer an inspection candidate to a project interaction flow.

Limitations: Does not provide descriptive content or implement inspection presentation.

Berta.ActorTag.Interaction.Interactable

Meaning: Actor opted into general project interaction candidate selection.

Suggested usage: Filter discovered actors before evaluating specific interaction rules.

Limitations: Does not guarantee availability, permissions, or any interaction implementation.

Berta.ActorTag.Interaction.Openable

Meaning: Actor offering opening as an intended interaction capability.

Suggested usage: Recognize a door or container in existing interaction logic.

Limitations: Does not unlock, animate, or indicate currently open state.

Berta.ActorTag.Interaction.Pickupable

Meaning: Actor offering pickup as an intended interaction capability.

Suggested usage: Identify an object considered by project pickup handling.

Limitations: Does not attach actors, transfer inventory, or guarantee pickup availability.

Berta.ActorTag.Interaction.Talkable

Meaning: Actor offering conversation as an intended interaction capability.

Suggested usage: Identify a potential speaker for project dialogue selection.

Limitations: Does not provide dialogue data or initiate a conversation.

Inventory

Berta.ActorTag.Inventory.Harvestable

Meaning: Actor classified as an intended source of harvested resources.

Suggested usage: Offer a resource node to project-owned harvesting logic.

Limitations: Does not provide yields, depletion state, tools, or inventory transactions.

Berta.ActorTag.Inventory.Lootable

Meaning: Actor classified as an intended source of loot.

Suggested usage: Offer a container or remains to project-owned loot handling.

Limitations: Does not generate items or guarantee available contents or access.

Berta.ActorTag.Navigation.ClimbPoint

Meaning: Actor used as a spatial reference for climbing route selection.

Suggested usage: Identify an authored climbing destination or route reference.

Limitations: Does not supply ledge geometry, traversal animation, or reachability checks.

Berta.ActorTag.Navigation.TeleportDestination

Meaning: Actor used as a spatial destination reference for teleportation.

Suggested usage: Read a destination actor's transform in project teleport logic.

Limitations: Does not teleport actors or validate clearance, access, or authority.

Berta.ActorTag.Navigation.Waypoint

Meaning: Actor used as a spatial reference along a navigation route.

Suggested usage: Identify a route stop independently of AI-specific patrol meaning.

Limitations: Does not establish ordering, path links, or a navigation mesh.

Quest

Berta.ActorTag.Quest.ObjectiveTarget

Meaning: Actor eligible to be referenced by a quest objective.

Suggested usage: Identify a candidate actor for project-owned objective binding.

Limitations: Does not identify a particular quest or track objective progress.

Spawn

Berta.ActorTag.Spawn.Checkpoint

Meaning: Actor marked as a checkpoint reference for project logic.

Suggested usage: Identify an authored checkpoint location for a project checkpoint system.

Limitations: Only a marker; does not save, activate checkpoints, or implement respawning.

Berta.ActorTag.Spawn.RespawnPoint

Meaning: Actor used as a spatial reference for respawn placement.

Suggested usage: Offer a return location to project-owned respawn selection.

Limitations: Does not trigger respawn or supply safety, team, or cooldown rules.

Berta.ActorTag.Spawn.SpawnPoint

Meaning: Actor used as a spatial reference for initial spawn placement.

Suggested usage: Offer an initial location to project-owned spawning logic.

Limitations: Does not create actors or replace native PlayerStart selection.

Targeting

Berta.ActorTag.Targeting.AimAssistTarget

Meaning: Actor eligible for consideration by project aim assistance.

Suggested usage: Filter discovered candidates before project aim-assist scoring.

Limitations: Does not adjust input or prove visibility, range, or current selection.

Berta.ActorTag.Targeting.Focusable

Meaning: Actor eligible for focus selection under project rules.

Suggested usage: Filter trace hits in GA_CameraFocusToggle before final camera selection.

Limitations: Does not indicate current focus or perform camera behavior.

Berta.ActorTag.Targeting.Highlightable

Meaning: Actor eligible for highlighting by project presentation logic.

Suggested usage: Offer an actor to an existing hover or selection highlight flow.

Limitations: Does not apply materials, outlines, or indicate currently highlighted state.

Berta.ActorTag.Targeting.LockOnTarget

Meaning: Actor eligible for lock-on selection under project rules.

Suggested usage: Filter candidates before project-owned lock-on scoring and selection.

Limitations: Does not indicate a current lock or maintain target tracking.

UI

Berta.ActorTag.UI.TooltipTarget

Meaning: Actor eligible to serve as the subject of a tooltip.

Suggested usage: Identify an actor whose project-owned data can populate a tooltip.

Limitations: Does not provide tooltip text, widgets, or current hover state.

Berta.ActorTag.UI.UIAnchor

Meaning: Actor used as a spatial reference for UI placement or projection.

Suggested usage: Project the actor's position for an existing world label.

Limitations: Does not create widgets, define offsets, or select component sockets.

VFX

Berta.ActorTag.VFX.VFXAnchor

Meaning: Actor used as a spatial reference for visual effect placement.

Suggested usage: Read the actor's transform in project-owned effect spawning logic.

Limitations: Does not spawn Niagara systems, attach components, or execute Gameplay Cues.

World

Berta.ActorTag.World.AreaAnchor

Meaning: Actor used as a spatial reference for a project-defined world area.

Suggested usage: Associate an authored area with a known reference actor.

Limitations: Does not supply area bounds, volumes, membership, or streaming rules.

Berta.ActorTag.World.WorldMarker

Meaning: Actor classified as a general world reference marker.

Suggested usage: Identify an authored point of interest for project-owned world logic.

Limitations: Does not supply a unique identifier, map icon, or persistence.

Renames and serialized FName migration

Canonical names are serialized API. Preserve them unless a vocabulary revision is explicitly approved. A Gameplay Tag redirect may help supported FGameplayTag deserialization, but does not migrate arbitrary serialized FName values in Actor Tags or text compared by project code.

For an approved rename:

Inventory old names in placed actors (including external actor packages), Blueprint defaults, spawn/config code, data assets, save games, and external data. Static text search alone cannot inspect every binary reference.
Register the approved destination and plan any FGameplayTag redirects separately. Review name collisions and compatibility before changing the approval fingerprint.
Explicitly replace old Actor Tag FName values in affected assets and update code/config consumers. Load and deliberately resave the relevant assets; account for inherited defaults and instance overrides. Update project-owned save/data loading paths for supported older versions.
Restart Editor, verify dictionary resolution and exact Actor Tag comparisons, then exercise spawning, loading, and supported saved/network/deployment scenarios. Remove compatibility data only after the project's migration policy permits it.
Update documentation and the independent ActorTag approval contract together after review. Do not change the existing 474-tag fingerprints for an ActorTag-only revision. This feature adds no redirects or migration utility.

Verification and manual acceptance

Run python Scripts/Validate-GameplayTagCatalog.py and mkdocs build --strict from the repository root. The checker preserves the independent 474-name / 23-family approval contract and checks these 40 names / 16 subfamilies, syntax, ordering, comments, collisions, and reference coverage. The approved ActorTag SHA-256 is c5fe8e14d33dbab83a7a43448ec73c71245c1533d8ab5b1c23fa406716589baf (sort full names lexically, join with LF, append one LF, encode UTF-8).

Compile BertaDevKitHostEditor Win64 Development using UE 5.8 UBT / Build.bat, with the normal host configuration and BertaGASCompanionExt disabled. Static checks and compilation do not establish runtime registration or Sandbox behavior. No redundant C++ test of Unreal's ActorHasTag implementation is needed for this dictionary.

Nicolás should perform these checks manually; do not launch Unreal as part of the static/build workflow:

Enable BertaDevKit with BertaGASCompanionExt disabled.
Restart the UE 5.8 Editor.
Confirm Berta.ActorTag.Targeting.Focusable appears in Gameplay Tag Manager with source BertaActorTags.ini and its intended eligibility description.
Inspect representative entries from different subfamilies, such as Berta.ActorTag.AI.CoverPoint, Berta.ActorTag.Spawn.Checkpoint, and Berta.ActorTag.VFX.VFXAnchor.
Place a plain cube in a test level.
Enter the complete Focusable canonical name in its Actor → Tags array.
Select the matching registered FGameplayTag in Blueprint.
Run Get Tag Name → Actor Has Tag with the cube as target.
Verify a positive result and a negative result using an untagged cube or another approved name.
Query the parent prefix and a child name supplied as plain FName values; neither should automatically match the stored Focusable name. Do not register a test child. Also confirm a case-only spelling change still compares equal.
Confirm the plain cube needs no ASC, interface, or extra component; confirm a tag placed only on the mesh component does not satisfy Actor Has Tag.
Exercise the GA_CameraFocusToggle trace workflow manually in the private Sandbox, including trace collision, filtering, final selection, and camera behavior.
Inspect packaged config staging and registration only when the corresponding deployment environment is available.

Picker visibility, Blueprint execution, packaged registration, and the private Sandbox workflow remain separate manual verification, not consequences proved by the validator or UBT.