### Configure Startup Ability Sets for Default Abilities

Source: https://context7.com/bohdon/extendedgameplayabilitiesplugin/llms.txt

This setup allows for the automatic granting of default abilities, effects, and attributes when the ability system initializes. Configuration is done within the ability system component's defaults, where you can specify startup ability sets and default gameplay tags. This simplifies the initial setup of character capabilities.

```cpp
// Configure in ability system component defaults
UCLASS()
class AMyCharacter : public AAbilityCharacter
{
    GENERATED_BODY()

    UPROPERTY(EditDefaultsOnly)
    UExtendedAbilitySystemComponent* AbilitySystemComponent;
};

// In component defaults (editor or constructor):
// StartupAbilitySets - Add ability sets to grant at initialization
// DefaultTags - Add loose gameplay tags (e.g., "Character.Type.Player")

// Example in constructor:
AMyCharacter::AMyCharacter(const FObjectInitializer& ObjectInitializer)
    : Super(ObjectInitializer)
{
    AbilitySystemComponent = CreateDefaultSubobject<UExtendedAbilitySystemComponent>(TEXT("AbilitySystem"));
    AbilitySystemComponent->DefaultTags.AddTag(FGameplayTag::RequestGameplayTag("Character.Type.Player"));
    // StartupAbilitySets configured in editor with ability set assets
}

```

--------------------------------

### Activating Abilities with Gameplay Tag Input - C++

Source: https://context7.com/bohdon/extendedgameplayabilitiesplugin/llms.txt

Shows how to map Enhanced Input actions to gameplay tags for flexible ability activation in C++. This setup involves binding input to the ability system via tags in the character's `SetupPlayerInputComponent` and specifying the activation input tag within the gameplay ability itself.

```cpp
// Setup in your character class
void AMyCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);

    UPawnAbilityInputComponent* AbilityInput = GetPawnAbilityInputComponent();
    if (AbilityInput && InputMapping)
    {
        // Bind Enhanced Input to ability system via tags
        AbilityInput->BindAbilityInputToTags(PlayerInputComponent, InputMapping);
    }
}

// In your ability class, specify the input tag
void UMyGameplayAbility::ActivateAbility(const FGameplayAbilitySpecHandle Handle,
    const FGameplayAbilityActorInfo* ActorInfo,
    const FGameplayAbilityActivationInfo ActivationInfo,
    const FGameplayEventData* TriggerEventData)
{
    // This ability activates when InputTag.Ability.Attack is pressed
    // Set in the ability set: InputTag = "InputTag.Ability.Attack"
}
```

--------------------------------

### Handle Character Health and Death (C++)

Source: https://context7.com/bohdon/extendedgameplayabilitiesplugin/llms.txt

A component designed to monitor health attributes and trigger death events when health reaches zero. It can be set up in the character constructor and provides delegates for handling the start and end of the death process. Requires a health attribute set and gameplay tags for messages.

```cpp
// Setup health component in character constructor
AMyCharacter::AMyCharacter(const FObjectInitializer& ObjectInitializer)
    : Super(ObjectInitializer)
{
    HealthComponent = CreateDefaultSubobject<UCommonHealthComponent>(TEXT("HealthComponent"));
    HealthComponent->HealthAttribute = UHPAttributeSet::GetHealthAttribute();
    HealthComponent->bAutoRegisterAbilitySystem = true;
    HealthComponent->bSendGameplayMessage = true;
    HealthComponent->GameplayMessageChannel = TAG_GameplayMessage_Death;

    // Bind to death events
    HealthComponent->OnDeathStartedEvent.AddDynamic(this, &AMyCharacter::OnDeathStarted);
    HealthComponent->OnDeathFinishedEvent.AddDynamic(this, &AMyCharacter::OnDeathFinished);
}

void AMyCharacter::OnDeathStarted(AActor* OwningActor)
{
    // Disable input, start death animation, etc.
    DisableInput(nullptr);
}

void AMyCharacter::OnDeathFinished(AActor* OwningActor)
{
    // Destroy actor, respawn, etc.
    Destroy();
}

```

--------------------------------

### Manage Game Phases with Abilities (C++)

Source: https://context7.com/bohdon/extendedgameplayabilitiesplugin/llms.txt

A component for managing distinct game phases (e.g., pre-game, playing, post-game) using gameplay abilities and tags. It's typically added to the GameState and can be used to control game flow by starting, stopping, and checking the active phase. Requires an AbilitySystemComponent and a GamePhase component.

```cpp
// Add to GameState
UCLASS()
class AMyGameState : public AGameStateBase
{
    GENERATED_BODY()

    UPROPERTY(VisibleAnywhere)
    UAbilityGamePhaseComponent* PhaseComponent;

    UPROPERTY(VisibleAnywhere)
    UAbilitySystemComponent* AbilitySystem;

    virtual void PostInitializeComponents() override
    {
        Super::PostInitializeComponents();
        PhaseComponent->SetAbilitySystem(AbilitySystem);
    }
};

// Start a game phase
void AMyGameMode::StartMatch()
{
    AMyGameState* GS = GetGameState<AMyGameState>();
    GS->PhaseComponent->StartPhase(UGamePhaseAbility_Playing::StaticClass());
}

// Check if phase is active
bool bIsPlaying = GameState->PhaseComponent->IsPhaseActive(
    FGameplayTag::RequestGameplayTag("GamePhase.Playing")
);

```

--------------------------------

### Manage Pawn Initialization States (C++)

Source: https://context7.com/bohdon/extendedgameplayabilitiesplugin/llms.txt

A component that orchestrates asynchronous initialization for pawns, ensuring that the controller, player state, and input component are ready before proceeding. This is typically added in the character's constructor and can be waited upon using an async action.

```cpp
// Add to your character in constructor
AMyCharacter::AMyCharacter(const FObjectInitializer& ObjectInitializer)
    : Super(ObjectInitializer)
{
    PawnInitStateComponent = CreateDefaultSubobject<UPawnInitStateComponent>(TEXT("PawnInitState"));
    PawnInitStateComponent->bWaitForController = true;
    PawnInitStateComponent->bWaitForInputComponent = true;
}

// Wait for initialization in blueprints or async code
UAsyncAction_WaitForInitState* WaitAction = UAsyncAction_WaitForInitState::WaitForInitState(
    Character,
    TAG_InitState_DataInitialized
);
WaitAction->OnStateReached.AddDynamic(this, &AMyClass::OnPawnReady);
WaitAction->Activate();

```

--------------------------------

### Applying Multiple Gameplay Effects as a Set - C++

Source: https://context7.com/bohdon/extendedgameplayabilitiesplugin/llms.txt

Illustrates how to group and apply multiple gameplay effects simultaneously using a `FGameplayEffectSet`. This includes defining the set with specific effects and set-by-caller magnitudes, then applying the entire set to a target ability system component in C++.

```cpp
// Define an effect set (typically in a data asset or ability)
FGameplayEffectSet EffectSet;
EffectSet.Effects.Add(UDamageEffect::StaticClass());
EffectSet.Effects.Add(USlowEffect::StaticClass());
EffectSet.SetByCallerMagnitudes.Add(
    FGameplayTag::RequestGameplayTag("Data.Damage"),
    FScalableFloat(50.0f)
);

// Apply the effect set to a target
UExtendedAbilitySystemComponent* SourceASC = Cast<UExtendedAbilitySystemComponent>(GetAbilitySystemComponent());
FGameplayEffectSpecSet SpecSet = SourceASC->MakeEffectSpecSet(EffectSet, 1.0f);

// Apply all effects to target
UAbilitySystemComponent* TargetASC = Target->GetAbilitySystemComponent();
for (const FGameplayEffectSpecHandle& SpecHandle : SpecSet.EffectSpecs)
{
    SourceASC->ApplyGameplayEffectSpecToTarget(*SpecHandle.Data.Get(), TargetASC);
}
```

--------------------------------

### Create Character with Ability System Support (C++)

Source: https://context7.com/bohdon/extendedgameplayabilitiesplugin/llms.txt

Defines a base character class that integrates with the ability system, handling initialization and cleanup of ability sets for player characters. Requires the ability system component and an ability set asset.

```cpp
// Define your character class
UCLASS()
class AMyGameCharacter : public AAbilityCharacter
{
    GENERATED_BODY()

protected:
    virtual void OnInitializeAbilitySystem() override
    {
        Super::OnInitializeAbilitySystem();

        UAbilitySystemComponent* ASC = GetAbilitySystemComponent();
        if (ASC && DefaultAbilitySet)
        {
            // Grant default abilities when ability system initializes
            AbilitySetHandles = DefaultAbilitySet->GiveToAbilitySystem(ASC, this);
        }
    }

    virtual void OnUninitializeAbilitySystem() override
    {
        if (UAbilitySystemComponent* ASC = GetAbilitySystemComponent())
        {
            DefaultAbilitySet->RemoveFromAbilitySystem(ASC, AbilitySetHandles);
        }

        Super::OnUninitializeAbilitySystem();
    }

    UPROPERTY(EditDefaultsOnly)
    UExtendedAbilitySet* DefaultAbilitySet;

    FExtendedAbilitySetHandles AbilitySetHandles;
};

```

--------------------------------

### Activate Gameplay Abilities from AI Behavior Trees

Source: https://context7.com/bohdon/extendedgameplayabilitiesplugin/llms.txt

This task allows AI behavior trees to activate gameplay abilities on AI-controlled characters. It can be configured to activate abilities by class or by tags, and requires the AI controller's pawn to implement the IAbilitySystemInterface. The task offers options to control whether it waits for ability completion, restarts the ability if already active, or fails if the ability is canceled.

```cpp
// Create behavior tree task in editor: BTTask_ActivateAbility
// Configure:
//   - AbilityClass: Set to your ability (e.g., UAbility_AIAttack)
//   - bWaitForAbilityEnd: true (task waits for ability to complete)
//   - bRestartAbility: false (don't cancel if already active)
//   - bFailOnAbilityCancel: true (task fails if ability is canceled)

// Alternative: Activate by tags instead of class
//   - AbilityTags: Set to "Ability.AI.Attack"
//   - Activates first ability with all matching tags

// The AI controller's pawn must implement IAbilitySystemInterface
UCLASS()
class AMyAICharacter : public ACharacter, public IAbilitySystemInterface
{
    GENERATED_BODY()

    UPROPERTY(VisibleAnywhere)
    UAbilitySystemComponent* AbilitySystem;

    virtual UAbilitySystemComponent* GetAbilitySystemComponent() const override
    {
        return AbilitySystem;
    }
};

```

--------------------------------

### Granting and Removing Ability Sets - C++

Source: https://context7.com/bohdon/extendedgameplayabilitiesplugin/llms.txt

Demonstrates how to grant and remove an ability set, which is a data asset grouping abilities, gameplay effects, and attribute sets, to an ability system component in C++. It shows the use of `GiveToAbilitySystem` and `RemoveFromAbilitySystem`, including parameters for overriding level, ending immediately, and keeping attribute sets.

```cpp
// Create an ability set data asset in the editor, then grant it to an ability system
UExtendedAbilitySet* MyAbilitySet; // Set in editor with abilities, effects, and attributes
UAbilitySystemComponent* ASC = Character->GetAbilitySystemComponent();

// Grant the ability set
FExtendedAbilitySetHandles Handles = MyAbilitySet->GiveToAbilitySystem(
    ASC,
    Character,  // Source object
    5          // Override level (optional, -1 uses default)
);

// Later, remove the ability set
MyAbilitySet->RemoveFromAbilitySystem(
    ASC,
    Handles,
    false,  // bEndImmediately - false means abilities end naturally
    false   // bKeepAttributeSets - false removes attribute sets too
);
```

--------------------------------

### Apply Gameplay Tags During Animation (C++)

Source: https://context7.com/bohdon/extendedgameplayabilitiesplugin/llms.txt

An animation notify state that dynamically applies gameplay tags to the ability system component while a specific section of an animation is playing. This allows for contextual logic based on animation events, such as enabling attacks during an 'Attacking' animation.

```cpp
// In animation blueprint or montage, add AnimNotifyState_GameplayTag
// Set GameplayTag to "Character.State.Attacking"

// In your ability or character code, check for the tag
void UMyGameplayAbility::TickAbility(float DeltaTime)
{
    if (GetAbilitySystemComponentFromActorInfo()->HasMatchingGameplayTag(
        FGameplayTag::RequestGameplayTag("Character.State.Attacking")))
    {
        // Character is in attacking animation section
        // Enable weapon collision, damage calculation, etc.
    }
}

// The tag is automatically removed when the notify state ends

```

--------------------------------

### Manage Teams and Attitude in GameState

Source: https://context7.com/bohdon/extendedgameplayabilitiesplugin/llms.txt

This component, integrated into the GameState, manages team assignments and determines the attitude between different game objects. It allows for assigning players to teams, checking relationships (e.g., hostile, friendly), and comparing team affiliations directly. This is crucial for implementing mechanics like friendly fire or targeting specific enemy types.

```cpp
// Setup teams in GameState
UCLASS()
class AMyGameState : public AGameStateBase
{
    UPROPERTY(VisibleAnywhere)
    UCommonTeamsComponent* TeamsComponent;
};

// Assign player to team
void AMyGameMode::PostLogin(APlayerController* NewPlayer)
{
    Super::PostLogin(NewPlayer);

    AMyGameState* GS = GetGameState<AMyGameState>();
    GS->TeamsComponent->SetObjectTeam(NewPlayer->PlayerState, 1); // Team 1
}

// Check team relationships
ETeamAttitude::Type Attitude = TeamsComponent->GetAttitude(Player1, Player2);
if (Attitude == ETeamAttitude::Hostile)
{
    // Enable friendly fire or target enemy
}

// Compare teams directly
ECommonTeamComparison Comparison = TeamsComponent->CompareTeams(Actor1, Actor2);
if (Comparison == ECommonTeamComparison::SameTeam)
{
    // Same team logic
}

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.