1
2

// 간단한 경우에 한함
	AbilitySystemComponent->InitAbilityActorInfo(this, this);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// Owner 클래스
AABGASPlayerState::AABGASPlayerState()
{
	AbilitySystemComponent = CreateDefaultSubobject<UAbilitySystemComponent>(TEXT("AbiltiySystemComponent"));
	// AbilitySystemComponent->SetIsReplicated(true);
}

UAbilitySystemComponent* AABGASPlayerState::GetAbilitySystemComponent() const
{
	return AbilitySystemComponent;
}

// Avatar 클래스
AABGASCharacterPlayer::AABGASCharacterPlayer()
{
	AbilitySystemComponent = nullptr;
	//AbilitySystemComponent->SetIsReplicated(true);
}

UAbilitySystemComponent* AABGASCharacterPlayer::GetAbilitySystemComponent() const
{
	return AbilitySystemComponent;
}

void AABGASCharacterPlayer::PossessedBy(AController* NewController)
{
	Super::PossessedBy(NewController);

	auto _PlayerState = GetPlayerState<AABGASPlayerState>();
	if(_PlayerState->IsValidLowLevelFast())
	{
		// 아바타에도 어빌리티 시스템 컴포넌트가 있지만, Owner의 컴포넌트에 대한 참조일 뿐이다.
		AbilitySystemComponent = _PlayerState->GetAbilitySystemComponent();
		AbilitySystemComponent->InitAbilityActorInfo(_PlayerState, this);
		// do sth...
		
// NOTE : 멀티플레이 게임에서는 InitAbilityActorInfo 위치가 바뀌어야 함!
// (PossessedBy 메서드는 서버에서만 불리기 때문)
// 일단은 싱글플레이 예시이기 때문에 컨트롤러가 pawn을 possess할 때
// 어빌리티 시스템의 InitAbilityActorInfo를 호출하는 것으로 설정

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// 어빌리티 시스템 컴포넌트에 어빌리티 부여
	for (auto Element : Abilities)
	{
		FGameplayAbilitySpec Spec(Element);
		AbilitySystemComponent->GiveAbility(Spec);
	}
    
// FGameplayAbilitySpec 선언부 중 일부
USTRUCT(BlueprintType)
struct GAMEPLAYABILITIES_API FGameplayAbilitySpec : public FFastArraySerializerItem
{
    GENERATED_USTRUCT_BODY()
    
    FGameplayAbilitySpec()
    : Ability(nullptr), Level(1), InputID(INDEX_NONE), SourceObject(nullptr), ActiveCount(0), InputPressed(false), RemoveAfterActivation(false), PendingRemove(false), bActivateOnce(false)
    { }
    
    /** Version that takes an ability class */
    FGameplayAbilitySpec(TSubclassOf<UGameplayAbility> InAbilityClass, int32 InLevel = 1, int32 InInputID = INDEX_NONE, UObject* InSourceObject = nullptr);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// AbilitySystemComponent.h
    UPROPERTY(ReplicatedUsing=OnRep_ActivateAbilities, BlueprintReadOnly, Category = "Abilities")
    FGameplayAbilitySpecContainer ActivatableAbilities;
    
    /** Returns the list of all activatable abilities. Read-only. */
    const TArray<FGameplayAbilitySpec>& GetActivatableAbilities() const
    {
    return ActivatableAbilities.Items;
    }
    
    /** Returns the list of all activatable abilities. */
    TArray<FGameplayAbilitySpec>& GetActivatableAbilities()
    {
    return ActivatableAbilities.Items;
    }

1
2
3
4

    FGameplayAbilitySpecHandle GiveAbility(const FGameplayAbilitySpec& AbilitySpec);
    
    UFUNCTION(BlueprintCallable, Category = "Abilities")
    bool TryActivateAbility(FGameplayAbilitySpecHandle AbilityToActivate, bool bAllowRemoteActivation = true);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

/** Handle that points to a specific granted ability. These are globally unique */
USTRUCT(BlueprintType)
struct FGameplayAbilitySpecHandle
{
	GENERATED_USTRUCT_BODY()

	FGameplayAbilitySpecHandle()
		: Handle(INDEX_NONE)
	{
	}

	/** True if GenerateNewHandle was called on this handle */
	bool IsValid() const
	{
		return Handle != INDEX_NONE;
	}
    
// 중략

private:

	UPROPERTY()
	int32 Handle;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

void AABGASCharacterPlayer::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	Super::SetupPlayerInputComponent(PlayerInputComponent);

	SetupGASInputComponent();
}

void AABGASCharacterPlayer::SetupGASInputComponent()
{
	if(IsValid(AbilitySystemComponent) && IsValid(InputComponent))
	{
		auto EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(InputComponent);

		EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Triggered, this, &ThisClass::OnGASInputPressed, (int32)EPLAYERGASINPUTTYPE::JUMP);
		EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Completed, this, &ThisClass::OnGASInputReleased, (int32)EPLAYERGASINPUTTYPE::JUMP);
		EnhancedInputComponent->BindAction(AttackAction, ETriggerEvent::Triggered, this, &ThisClass::OnGASInputPressed, (int32)EPLAYERGASINPUTTYPE::ATTACK);
		EnhancedInputComponent->BindAction(AttackAction, ETriggerEvent::Completed, this, &ThisClass::OnGASInputReleased, (int32)EPLAYERGASINPUTTYPE::ATTACK);
	}
}

void AABGASCharacterPlayer::OnGASInputPressed(int32 InputID)
{
	auto Spec = AbilitySystemComponent->FindAbilitySpecFromInputID(InputID);
	if(Spec)
	{
		Spec->InputPressed = true;
		if (Spec->IsActive())
		{
			AbilitySystemComponent->AbilitySpecInputPressed(*Spec);
		}
		else
		{
			AbilitySystemComponent->TryActivateAbility(Spec->Handle);
		}
	}
}

void AABGASCharacterPlayer::OnGASInputReleased(int32 InputID)
{
	auto Spec = AbilitySystemComponent->FindAbilitySpecFromInputID(InputID);
	if(Spec)
	{
		Spec->InputPressed = false;
		if (Spec->IsActive())
		{
			AbilitySystemComponent->AbilitySpecInputReleased(*Spec);
		}
	}
}

1
2
3
4
5
6

UGameplayAbility_CharacterJump::UGameplayAbility_CharacterJump(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	NetExecutionPolicy = EGameplayAbilityNetExecutionPolicy::LocalPredicted;
	InstancingPolicy = EGameplayAbilityInstancingPolicy::NonInstanced;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

UENUM(BlueprintType)
namespace EGameplayAbilityInstancingPolicy
{
	/**
	 *	How the ability is instanced when executed. This limits what an ability can do in its implementation. For example, a NonInstanced
	 *	Ability cannot have state. It is probably unsafe for an InstancedPerActor ability to have latent actions, etc.
	 */
	enum Type : int
	{
		// This ability is never instanced. Anything that executes the ability is operating on the CDO.
		NonInstanced,

		// Each actor gets their own instance of this ability. State can be saved, replication is possible.
		InstancedPerActor,

		// We instance this ability each time it is executed. Replication possible but not recommended.
		InstancedPerExecution,
	};
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

void UABGA_Attack::ActivateAbility(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo,
	const FGameplayAbilityActivationInfo ActivationInfo, const FGameplayEventData* TriggerEventData)
{
    Super::ActivateAbility(Handle, ActorInfo, ActivationInfo, TriggerEventData);
    
    auto Character = CastChecked<AABCharacterBase>(ActorInfo->AvatarActor.Get());
    Character->GetCharacterMovement()->SetMovementMode(EMovementMode::MOVE_None);
    
    // Ability Task를 이용해 애니메이션 재생시켜보기
    UAbilityTask_PlayMontageAndWait* PlayerAttackTask = UAbilityTask_PlayMontageAndWait::CreatePlayMontageAndWaitProxy(
        this,
        FName("PlayAttack"),
        Character->GetComboActionMontage()
    );
    PlayerAttackTask->OnCompleted.AddDynamic(this, &ThisClass::OnActionComplete);
    PlayerAttackTask->OnCompleted.AddDynamic(this, &ThisClass::OnActionInterrupted);
    PlayerAttackTask->ReadyForActivation();
}

void UABGA_Attack::EndAbility(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo,
    const FGameplayAbilityActivationInfo ActivationInfo, bool bReplicateEndAbility, bool bWasCancelled)
{
    Super::EndAbility(Handle, ActorInfo, ActivationInfo, bReplicateEndAbility, bWasCancelled);
    
    auto Character = CastChecked<AABCharacterBase>(ActorInfo->AvatarActor.Get());
    Character->GetCharacterMovement()->SetMovementMode(EMovementMode::MOVE_Walking);

}

void UABGA_Attack::OnActionComplete()
{
    EndAbility(CurrentSpecHandle, CurrentActorInfo, CurrentActivationInfo, true, false);
}

void UABGA_Attack::OnActionInterrupted()
{
    EndAbility(CurrentSpecHandle, CurrentActorInfo, CurrentActivationInfo, true, true);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

void AABGASCharacterPlayer::PossessedBy(AController* NewController)
{
    Super::PossessedBy(NewController);
    // 중략

#if WITH_EDITOR
    auto PlayerController = CastChecked<APlayerController>(NewController);
    if(IsLocallyControlled())
        PlayerController->ConsoleCommand(TEXT("showdebug abilitysystem"));
#endif
}