Targeting Styles Reference

Complete reference for all targeting styles and their configuration options.

Quick Comparison

Hard Lock vs Soft Lock

Hard Lock (Souls, GoW, Zelda)

Player explicitly controls lock state:

• Press input to lock
• Press again to release or switch
• Camera centers on target
• UI shows clear lock indicator
• Target persists until released or invalid

Soft Lock (Freeflow)

System manages target automatically:

• Game code calls TriggerSoftLockUpdate() on attack
• Target changes per-attack based on input direction
• No persistent lock indicator
• More fluid, cinematic combat

Validation & Relock

These four properties decide what happens to an existing lock over time and on re-press. They are easy to confuse, so here is exactly what each one does.

ValidationPolicy — how the locked target is re-checked on a timer

ValidationTickInterval controls how often the timer fires (e.g. 0.2).

ValidationFailAction — what happens when the locked target fails validation

GracePeriod — hold the lock through brief invalidity

Seconds the lock is held after the target first fails validation (e.g. ducking behind a wall, edge of max distance). 0 = instant break. If the target becomes valid again within the window, the lock is kept; otherwise ValidationFailAction runs at expiry. Applies to LOS/distance failures — death is always instant (no grace).

RelockAction & RelockFallback — pressing Lock while already locked

Souls Style

Tag: Agentic.Targeting.Style.Souls

Classic Dark Souls targeting. Toggle hard lock that stays on target until manually released or a different target is found.

Properties

Behavior Flow

When Target Becomes Invalid

1. Target dies, goes out of range, or loses LOS
2. Grace period (0.5s) starts
3. If still invalid after grace: ValidationFailAction = TrySwitch
4. Find next best target and switch, or release if none

Code Example

// Set Souls style
TargetingComponent->SetStyleByTag(
    FGameplayTag::RequestGameplayTag("Agentic.Targeting.Style.Souls")
);

// Lock on (toggle)
TargetingComponent->Lock();

God of War Style

Tag: Agentic.Targeting.Style.GoW

Same as Souls but more forgiving. Longer grace period prevents frustrating lock breaks during high-mobility combat.

Properties

When to Use

• Fast-paced action with high mobility
• Combat where targets frequently go behind cover
• Games with aggressive enemy movement
• Any situation where 0.5s grace feels too punishing

Code Example

TargetingComponent->SetStyleByTag(
    FGameplayTag::RequestGameplayTag("Agentic.Targeting.Style.GoW")
);

Zelda Style

Tag: Agentic.Targeting.Style.Zelda

Classic Z-targeting. Toggle cycles through targets instead of releasing, making it easy to manage multiple enemies.

Properties

Key Difference: Cycle vs TryDifferent

Behavior Flow

Code Example

TargetingComponent->SetStyleByTag(
    FGameplayTag::RequestGameplayTag("Agentic.Targeting.Style.Zelda")
);

// First press: lock to target
TargetingComponent->Lock();

// Second press: cycle to next (not release!)
TargetingComponent->Lock();

Freeflow Style

Tag: Agentic.Targeting.Style.Freeflow

Arkham/Spider-Man style freeflow combat. Event-based soft lock that automatically targets based on attack direction.

Properties

Integration Required

Freeflow style requires your game code to trigger updates:

// In your attack system
void AMyCharacter::OnAttackStarted()
{
    // This triggers the soft lock to re-query and pick best target
    TargetingComponent->TriggerSoftLockUpdate();

    // Get the selected target for your attack
    AActor* Target = TargetingComponent->GetCurrentTarget();
    if (Target)
    {
        // Lunge toward target, play hit reaction, etc.
        PerformAttackOn(Target);
    }
}

Why No Validation?

Soft lock styles don't need validation timers because:

1. Target is re-queried every attack
2. Dead/invalid targets naturally filtered out
3. Each attack picks the best current target

Code Example

TargetingComponent->SetStyleByTag(
    FGameplayTag::RequestGameplayTag("Agentic.Targeting.Style.Freeflow")
);

// Don't call Lock() directly - trigger from attacks
void OnPlayerAttack()
{
    TargetingComponent->TriggerSoftLockUpdate();
}

When to Use Freeflow vs TwinStick

TwinStick Style

Tag: Agentic.Targeting.Style.TwinStick

HELLDIVERS-style continuous auto-targeting. Timer-based soft lock that constantly evaluates and acquires the best target without player input.

Properties

How It Works

Unlike Freeflow (event-based per attack), TwinStick continuously evaluates:

1. Every 100ms, query for best target
2. Automatically acquire/switch to best target
3. Fires OnBecameTarget/OnLostTarget for UI updates
4. No player input required - just aims at best target

When to Use

• Twin-stick shooters - Geometry Wars, Enter the Gungeon
• Top-down shooters - HELLDIVERS, Alien Swarm
• Auto-aim systems - When player aims with stick, system picks target
• Companion AI - NPCs that auto-target threats

Behavior Flow

Code Example

// Set TwinStick style
TargetingComponent->SetStyleByTag(
    FGameplayTag::RequestGameplayTag("Agentic.Targeting.Style.TwinStick")
);

// No Lock() calls needed - targeting runs automatically
// Just read the current target when needed:
AActor* Target = TargetingComponent->GetCurrentTarget();
if (Target)
{
    // Aim weapon, show indicator, etc.
}

TwinStick vs Freeflow

MultiLock Style (BETA)

Tag: Agentic.Targeting.Style.MultiLock

Lock onto multiple targets simultaneously. Each Lock() call adds the next best target until max capacity, then releases all. Perfect for missile systems, mark-and-execute, or cleave attacks.

Properties

How It Works

1. First Lock(): Locks onto best target
2. Subsequent Lock(): Adds next best unlocked target
3. At MaxLockedTargets: Next Lock() releases all

Behavior Flow

Multi-Lock API

// Get all locked targets
TArray<AActor*> Targets = TargetingComponent->GetLockedTargets();

// Check if specific target is locked
bool bLocked = TargetingComponent->HasLockedTarget(EnemyActor);

// Manually add/remove targets
TargetingComponent->AddLockedTarget(BossActor);
TargetingComponent->RemoveLockedTarget(DeadEnemy);

// Check capacity
bool bCanAdd = TargetingComponent->CanAddMoreLockedTargets();
int32 Count = TargetingComponent->GetLockedTargetCount();

Use Case: Multi-Lock Missiles

void AMyCharacter::FireMultiLockMissiles()
{
    TArray<AActor*> LockedTargets = TargetingComponent->GetLockedTargets();

    for (AActor* Target : LockedTargets)
    {
        SpawnHomingMissile(Target);
    }

    // Clear locks after firing
    TargetingComponent->ReleaseLock();
}

Use Case: Mark-and-Execute

void AMyCharacter::ExecuteMarkedTargets()
{
    TArray<AActor*> LockedTargets = TargetingComponent->GetLockedTargets();

    // Instant kill all marked targets (Splinter Cell style)
    for (AActor* Target : LockedTargets)
    {
        ApplyInstantKill(Target);
    }

    TargetingComponent->ReleaseLock();
}

Blueprint Setup

Same as single-lock styles - use Lock() button. Each press adds a target:

1. Press 1: Lock target A
2. Press 2: Lock target B (A stays locked)
3. Press 3: Lock target C (A, B stay locked)
4. Press 4: Lock target D
5. Press 5: Lock target E (at max)
6. Press 6: Release all (A-E unlocked)

Style Properties Reference

LockCapacity

SoftLockUpdatePolicy

ValidationPolicy

ValidationFailAction

RelockAction

RelockFallback

Switching Styles at Runtime

Change styles dynamically based on game state:

void AMyCharacter::OnCombatModeChanged(ECombatMode NewMode)
{
    switch (NewMode)
    {
    case ECombatMode::Melee:
        // Traditional lock-on for 1v1
        TargetingComponent->SetStyleByTag(
            FGameplayTag::RequestGameplayTag("Agentic.Targeting.Style.Souls"));
        TargetingComponent->SetPresetByTag(
            FGameplayTag::RequestGameplayTag("Agentic.Targeting.Preset.Melee"));
        break;

    case ECombatMode::Crowd:
        // Freeflow for group fights
        TargetingComponent->SetStyleByTag(
            FGameplayTag::RequestGameplayTag("Agentic.Targeting.Style.Freeflow"));
        TargetingComponent->SetPresetByTag(
            FGameplayTag::RequestGameplayTag("Agentic.Targeting.Preset.Freeflow"));
        break;

    case ECombatMode::Ranged:
        // Souls with ranged preset
        TargetingComponent->SetStyleByTag(
            FGameplayTag::RequestGameplayTag("Agentic.Targeting.Style.Souls"));
        TargetingComponent->SetPresetByTag(
            FGameplayTag::RequestGameplayTag("Agentic.Targeting.Preset.Ranged"));
        break;
    }
}

Creating Custom Styles

1. Content Browser -> Right-click -> Miscellaneous -> Data Asset
2. Pick Agentic Targeting Style

3. Fill in the properties:
   • Style Tag - Unique tag for this style
   • Lock Capacity - Single or Multi
   • Validation Policy - How to validate locked target
   • Grace Period - Delay before lock breaks
   • Relock Action - What happens on toggle while locked

That's it. Your style is ready to use.

TargetingComponent->SetStyleByTag(
    FGameplayTag::RequestGameplayTag("Agentic.Targeting.Style.MyCustom")
);

Style + Preset Combinations

See Targeting Recipes for recommended Style + Preset combinations for common game scenarios.