ed/Cog
1
0
Fork 0
mirror of https://github.com/Ed94/Cog.git synced 2026-06-13 00:01:37 -07:00
Code Issues Packages Projects Releases Wiki Activity

CogAbility: Change the way CogAbilityReplicator apply the tweaks to newly spawned actor. Now needs to be called manually.

Browse Source
This commit is contained in:
Arnaud Jamin
2024-01-08 14:18:53 -05:00
parent 7768cfd38f
commit ee42b2a238
6 changed files with 85 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Plugins/CogAbility/Source/CogAbility/Private/CogAbilityReplicator.cpp
+45 -66
View File
@@ -26,9 +26,9 @@ ACogAbilityReplicator* ACogAbilityReplicator::Spawn(APlayerController* Controlle
}
//--------------------------------------------------------------------------------------------------------------------------
ACogAbilityReplicator* ACogAbilityReplicator::GetLocalReplicator(UWorld& World)
ACogAbilityReplicator* ACogAbilityReplicator::GetFirstReplicator(const UWorld& World)
{
for (TActorIterator<ACogAbilityReplicator> It(&World, ACogAbilityReplicator::StaticClass()); It; ++It)
for (TActorIterator<ACogAbilityReplicator> It(&World, StaticClass()); It; ++It)
{
ACogAbilityReplicator* Replicator = *It;
return Replicator;
@@ -38,9 +38,9 @@ ACogAbilityReplicator* ACogAbilityReplicator::GetLocalReplicator(UWorld& World)
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::GetRemoteReplicators(UWorld& World, TArray<ACogAbilityReplicator*>& Replicators)
void ACogAbilityReplicator::GetReplicators(const UWorld& World, TArray<ACogAbilityReplicator*>& Replicators)
{
for (TActorIterator<ACogAbilityReplicator> It(&World, ACogAbilityReplicator::StaticClass()); It; ++It)
for (TActorIterator<ACogAbilityReplicator> It(&World, StaticClass()); It; ++It)
{
ACogAbilityReplicator* Replicator = Cast<ACogAbilityReplicator>(*It);
Replicators.Add(Replicator);
@@ -81,8 +81,6 @@ void ACogAbilityReplicator::BeginPlay()
OwnerPlayerController = Cast<APlayerController>(GetOwner());
OnAnyActorSpawnedHandle = GetWorld()->AddOnActorSpawnedHandler(FOnActorSpawned::FDelegate::CreateUObject(this, &ACogAbilityReplicator::OnAnyActorSpawned));
ApplyAllTweaksOnAllActors();
}
@@ -94,12 +92,6 @@ void ACogAbilityReplicator::EndPlay(const EEndPlayReason::Type EndPlayReason)
Super::EndPlay(EndPlayReason);
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::ApplyCheat(AActor* CheatInstigator, const TArray<AActor*>& Targets, const FCogAbilityCheat& Cheat)
{
Server_ApplyCheat(CheatInstigator, Targets, Cheat);
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::Server_ApplyCheat_Implementation(const AActor* CheatInstigator, const TArray<AActor*>& Targets, const FCogAbilityCheat& Cheat) const
{
@@ -127,7 +119,7 @@ void ACogAbilityReplicator::Server_ApplyCheat_Implementation(const AActor* Cheat
ContextHandle.AddSourceObject(InstigatorAbilitySystem);
FGameplayEffectSpecHandle SpecHandle = InstigatorAbilitySystem->MakeOutgoingSpec(Cheat.Effect, 1, ContextHandle);
if (FGameplayEffectSpec* EffectSpec = SpecHandle.Data.Get())
if (const FGameplayEffectSpec* EffectSpec = SpecHandle.Data.Get())
{
FHitResult HitResult;
HitResult.HitObjectHandle = FActorInstanceHandle(Target);
@@ -152,7 +144,7 @@ bool ACogAbilityReplicator::IsCheatActive(const AActor* EffectTarget, const FCog
return false;
}
UAbilitySystemComponent* AbilitySystem = UAbilitySystemGlobals::GetAbilitySystemComponentFromActor(EffectTarget, true);
const UAbilitySystemComponent* AbilitySystem = UAbilitySystemGlobals::GetAbilitySystemComponentFromActor(EffectTarget, true);
if (AbilitySystem == nullptr)
{
return false;
@@ -162,12 +154,6 @@ bool ACogAbilityReplicator::IsCheatActive(const AActor* EffectTarget, const FCog
return Count > 0;
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::GiveAbility(AActor* Target, TSubclassOf<UGameplayAbility> AbilityClass) const
{
Server_GiveAbility(Target, AbilityClass);
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::Server_GiveAbility_Implementation(AActor* TargetActor, TSubclassOf<UGameplayAbility> AbilityClass) const
{
@@ -192,12 +178,6 @@ void ACogAbilityReplicator::Server_GiveAbility_Implementation(AActor* TargetActo
AbilitySystem->GiveAbility(Spec);
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::RemoveAbility(AActor* TargetActor, const FGameplayAbilitySpecHandle& Handle) const
{
Server_RemoveAbility(TargetActor, Handle);
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::Server_RemoveAbility_Implementation(AActor* TargetActor, const FGameplayAbilitySpecHandle& Handle) const
{
@@ -221,11 +201,6 @@ void ACogAbilityReplicator::Server_RemoveAbility_Implementation(AActor* TargetAc
AbilitySystem->SetRemoveAbilityOnEnd(Handle);
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::ResetAllTweaks()
{
Server_ResetAllTweaks();
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::Server_ResetAllTweaks_Implementation()
@@ -234,35 +209,46 @@ void ACogAbilityReplicator::Server_ResetAllTweaks_Implementation()
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::OnAnyActorSpawned(AActor* Actor)
void ACogAbilityReplicator::TryApplyAllTweaksOnActor(const AActor* Actor)
{
if (AbilityAsset == nullptr)
if (Actor == nullptr)
{
return;
}
if (AbilityAsset->ActorRootClass != nullptr && Actor->GetClass()->IsChildOf(AbilityAsset->ActorRootClass) == false)
ACogAbilityReplicator* Replicator = GetFirstReplicator(*Actor->GetWorld());
if (Replicator == nullptr)
{
return;
}
const int32 TweakCategoryIndex = FindTweakCategoryFromActor(Actor);
if (TweakCategoryIndex == INDEX_NONE)
{
return;
}
ApplyAllTweaksOnActor(TweakCategoryIndex, Actor);
Replicator->ApplyAllTweaksOnActor(Actor);
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::SetTweakValue(int32 TweakIndex, int32 TweakCategoryIndex, float Value)
void ACogAbilityReplicator::ApplyAllTweaksOnActor(const AActor* Actor)
{
Server_SetTweakValue(TweakIndex, TweakCategoryIndex, Value);
if (AbilityAsset == nullptr)
{
return;
}
if (AbilityAsset->ActorRootClass != nullptr && Actor->GetClass()->IsChildOf(AbilityAsset->ActorRootClass) == false)
{
return;
}
const int32 TweakCategoryIndex = FindTweakCategoryFromActor(Actor);
if (TweakCategoryIndex == INDEX_NONE)
{
return;
}
ApplyAllTweaksOnActor(TweakCategoryIndex, Actor);
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::Server_SetTweakValue_Implementation(int32 TweakIndex, int32 TweakCategoryIndex, float Value)
void ACogAbilityReplicator::Server_SetTweakValue_Implementation(const int32 TweakIndex, const int32 TweakCategoryIndex, const float Value)
{
if (AbilityAsset == nullptr)
{
@@ -285,14 +271,14 @@ void ACogAbilityReplicator::Server_SetTweakValue_Implementation(int32 TweakIndex
TArray<AActor*> Actors;
FindActorsFromTweakCategory(TweakCategoryIndex, Actors);
for (AActor* Actor : Actors)
for (const AActor* Actor : Actors)
{
ApplyTweakOnActor(Actor, Tweak, Value, AbilityAsset->SetByCallerMagnitudeTag);
}
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::ApplyAllTweaksOnActor(int32 TweakCategoryIndex, AActor* Actor)
void ACogAbilityReplicator::ApplyAllTweaksOnActor(const int32 TweakCategoryIndex, const AActor* Actor)
{
if (AbilityAsset == nullptr)
{
@@ -314,7 +300,7 @@ void ACogAbilityReplicator::ApplyAllTweaksOnActor(int32 TweakCategoryIndex, AAct
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::ApplyTweakOnActor(AActor* Actor, const FCogAbilityTweak& Tweak, float Value, const FGameplayTag& SetByCallerMagnitudeTag)
void ACogAbilityReplicator::ApplyTweakOnActor(const AActor* Actor, const FCogAbilityTweak& Tweak, const float Value, const FGameplayTag& SetByCallerMagnitudeTag)
{
UAbilitySystemComponent* AbilitySystem = UAbilitySystemGlobals::GetAbilitySystemComponentFromActor(Actor, true);
if (AbilitySystem == nullptr)
@@ -326,7 +312,7 @@ void ACogAbilityReplicator::ApplyTweakOnActor(AActor* Actor, const FCogAbilityTw
if (Value != 0.0f)
{
FGameplayEffectSpecHandle SpecHandle = AbilitySystem->MakeOutgoingSpec(Tweak.Effect, 1, AbilitySystem->MakeEffectContext());
const FGameplayEffectSpecHandle SpecHandle = AbilitySystem->MakeOutgoingSpec(Tweak.Effect, 1, AbilitySystem->MakeEffectContext());
if (FGameplayEffectSpec* EffectSpec = SpecHandle.Data.Get())
{
@@ -337,9 +323,9 @@ void ACogAbilityReplicator::ApplyTweakOnActor(AActor* Actor, const FCogAbilityTw
}
//--------------------------------------------------------------------------------------------------------------------------
float ACogAbilityReplicator::GetTweakCurrentValue(int32 TweakIndex, int32 TweakCategoryIndex)
float ACogAbilityReplicator::GetTweakCurrentValue(const int32 TweakIndex, const int32 TweakCategoryIndex)
{
float* Value = GetTweakCurrentValuePtr(TweakIndex, TweakCategoryIndex);
const float* Value = GetTweakCurrentValuePtr(TweakIndex, TweakCategoryIndex);
if (Value == nullptr)
{
return 0.0f;
@@ -349,7 +335,7 @@ float ACogAbilityReplicator::GetTweakCurrentValue(int32 TweakIndex, int32 TweakC
}
//--------------------------------------------------------------------------------------------------------------------------
float* ACogAbilityReplicator::GetTweakCurrentValuePtr(int32 TweakIndex, int32 TweakCategoryIndex)
float* ACogAbilityReplicator::GetTweakCurrentValuePtr(const int32 TweakIndex, const int32 TweakCategoryIndex)
{
if (AbilityAsset == nullptr)
{
@@ -369,7 +355,7 @@ float* ACogAbilityReplicator::GetTweakCurrentValuePtr(int32 TweakIndex, int32 Tw
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::SetTweakCurrentValue(int32 TweakIndex, int32 TweakCategoryIndex, float Value)
void ACogAbilityReplicator::SetTweakCurrentValue(const int32 TweakIndex, const int32 TweakCategoryIndex, const float Value)
{
if (AbilityAsset == nullptr)
{
@@ -388,12 +374,6 @@ void ACogAbilityReplicator::SetTweakCurrentValue(int32 TweakIndex, int32 TweakCa
MARK_PROPERTY_DIRTY_FROM_NAME(ACogAbilityReplicator, TweakCurrentValues, this);
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::SetTweakProfile(int32 ProfileIndex)
{
Server_SetTweakProfile(ProfileIndex);
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::Server_SetTweakProfile_Implementation(int32 ProfileIndex)
{
@@ -410,7 +390,7 @@ void ACogAbilityReplicator::Server_SetTweakProfile_Implementation(int32 ProfileI
TweakProfileIndex = ProfileIndex;
MARK_PROPERTY_DIRTY_FROM_NAME(ACogAbilityReplicator, TweakProfileIndex, this);
ResetAllTweaks();
Server_ResetAllTweaks();
if (AbilityAsset->TweakProfiles.IsValidIndex(TweakProfileIndex))
{
@@ -444,7 +424,7 @@ void ACogAbilityReplicator::ApplyAllTweaksOnAllActors()
TArray<AActor*> Actors;
FindActorsFromTweakCategory(TweakCategoryIndex, Actors);
for (AActor* Actor : Actors)
for (const AActor* Actor : Actors)
{
ApplyAllTweaksOnActor(TweakCategoryIndex, Actor);
}
@@ -452,7 +432,7 @@ void ACogAbilityReplicator::ApplyAllTweaksOnAllActors()
}
//--------------------------------------------------------------------------------------------------------------------------
void ACogAbilityReplicator::FindActorsFromTweakCategory(int32 TweakCategoryIndex, TArray<AActor*>& Actors)
void ACogAbilityReplicator::FindActorsFromTweakCategory(const int32 TweakCategoryIndex, TArray<AActor*>& Actors) const
{
if (AbilityAsset == nullptr)
{
@@ -466,10 +446,10 @@ void ACogAbilityReplicator::FindActorsFromTweakCategory(int32 TweakCategoryIndex
const FCogAbilityTweakCategory& TweakCategory = AbilityAsset->TweaksCategories[TweakCategoryIndex];
for (TActorIterator<AActor> It(GetWorld(), TweakCategory.ActorClass); It; ++It)
for (TActorIterator It(GetWorld(), TweakCategory.ActorClass); It; ++It)
{
AActor* Actor = *It;
if (UAbilitySystemComponent* AbilitySystem = UAbilitySystemGlobals::GetAbilitySystemComponentFromActor(Actor, true))
if (const UAbilitySystemComponent* AbilitySystem = UAbilitySystemGlobals::GetAbilitySystemComponentFromActor(Actor, true))
{
const bool bHasRequiredTags = AbilitySystem->HasAllMatchingGameplayTags(TweakCategory.RequiredTags);
const bool bHasIgnoredTags = AbilitySystem->HasAnyMatchingGameplayTags(TweakCategory.IgnoredTags);
@@ -482,9 +462,9 @@ void ACogAbilityReplicator::FindActorsFromTweakCategory(int32 TweakCategoryIndex
}
//--------------------------------------------------------------------------------------------------------------------------
int32 ACogAbilityReplicator::FindTweakCategoryFromActor(AActor* Actor)
int32 ACogAbilityReplicator::FindTweakCategoryFromActor(const AActor* Actor) const
{
UAbilitySystemComponent* AbilitySystem = UAbilitySystemGlobals::GetAbilitySystemComponentFromActor(Actor, true);
const UAbilitySystemComponent* AbilitySystem = UAbilitySystemGlobals::GetAbilitySystemComponentFromActor(Actor, true);
if (AbilitySystem == nullptr)
{
return INDEX_NONE;
@@ -493,7 +473,6 @@ int32 ACogAbilityReplicator::FindTweakCategoryFromActor(AActor* Actor)
for (int32 i = 0; i < AbilityAsset->TweaksCategories.Num(); ++i)
{
const FCogAbilityTweakCategory& TweakCategory = AbilityAsset->TweaksCategories[i];
if (IsActorMatchingTweakCategory(Actor, AbilitySystem, TweakCategory))
{
return i;
Plugins/CogAbility/Source/CogAbility/Private/CogAbilityWindow_Abilities.cpp
+4 -4
View File
@@ -135,9 +135,9 @@ void FCogAbilityWindow_Abilities::RenderAbiltiesMenu(AActor* Selection)
if (ImGui::MenuItem(TCHAR_TO_ANSI(*GetNameSafe(AbilityClass))))
{
if (ACogAbilityReplicator* Replicator = ACogAbilityReplicator::GetLocalReplicator(*GetWorld()))
if (ACogAbilityReplicator* Replicator = ACogAbilityReplicator::GetFirstReplicator(*GetWorld()))
{
Replicator->GiveAbility(Selection, AbilityClass);
Replicator->Server_GiveAbility(Selection, AbilityClass);
}
}
@@ -561,9 +561,9 @@ void FCogAbilityWindow_Abilities::GameTick(float DeltaTime)
{
if (AActor* Selection = GetSelection())
{
if (ACogAbilityReplicator* Replicator = ACogAbilityReplicator::GetLocalReplicator(*GetWorld()))
if (ACogAbilityReplicator* Replicator = ACogAbilityReplicator::GetFirstReplicator(*GetWorld()))
{
Replicator->RemoveAbility(Selection, AbilityHandleToRemove);
Replicator->Server_RemoveAbility(Selection, AbilityHandleToRemove);
}
}
Plugins/CogAbility/Source/CogAbility/Private/CogAbilityWindow_Cheats.cpp
+4 -4
View File
@@ -90,7 +90,7 @@ void FCogAbilityWindow_Cheats::TryReapplyCheats()
return;
}
ACogAbilityReplicator* Replicator = ACogAbilityReplicator::GetLocalReplicator(*GetWorld());
ACogAbilityReplicator* Replicator = ACogAbilityReplicator::GetFirstReplicator(*GetWorld());
if (Replicator == nullptr)
{
return;
@@ -105,7 +105,7 @@ void FCogAbilityWindow_Cheats::TryReapplyCheats()
if (const FCogAbilityCheat* Cheat = Asset->PersistentEffects.FindByPredicate(
[AppliedCheatName](const FCogAbilityCheat& Cheat) { return Cheat.Name == AppliedCheatName; }))
{
Replicator->ApplyCheat(LocalPawn, Targets, *Cheat);
Replicator->Server_ApplyCheat(LocalPawn, Targets, *Cheat);
}
else
{
@@ -329,8 +329,8 @@ void FCogAbilityWindow_Cheats::RequestCheat(AActor* ControlledActor, AActor* Sel
Actors.Add(SelectedActor);
}
if (ACogAbilityReplicator* Replicator = ACogAbilityReplicator::GetLocalReplicator(*GetWorld()))
if (ACogAbilityReplicator* Replicator = ACogAbilityReplicator::GetFirstReplicator(*GetWorld()))
{
Replicator->ApplyCheat(ControlledActor, Actors, Cheat);
Replicator->Server_ApplyCheat(ControlledActor, Actors, Cheat);
}
}
Plugins/CogAbility/Source/CogAbility/Private/CogAbilityWindow_Tweaks.cpp
+5 -5
View File
@@ -37,7 +37,7 @@ void FCogAbilityWindow_Tweaks::RenderContent()
return;
}
ACogAbilityReplicator* Replicator = ACogAbilityReplicator::GetLocalReplicator(*GetWorld());
ACogAbilityReplicator* Replicator = ACogAbilityReplicator::GetFirstReplicator(*GetWorld());
if (Replicator == nullptr)
{
ImGui::TextDisabled("Invalid Replicator");
@@ -48,7 +48,7 @@ void FCogAbilityWindow_Tweaks::RenderContent()
{
if (ImGui::MenuItem("Reset"))
{
Replicator->ResetAllTweaks();
Replicator->Server_ResetAllTweaks();
}
ImGui::EndMenuBar();
@@ -67,7 +67,7 @@ void FCogAbilityWindow_Tweaks::RenderContent()
const bool IsSelected = CurrentTweakProfileIndex == INDEX_NONE;
if (ImGui::Selectable("None", IsSelected))
{
Replicator->SetTweakProfile(INDEX_NONE);
Replicator->Server_SetTweakProfile(INDEX_NONE);
}
}
@@ -78,7 +78,7 @@ void FCogAbilityWindow_Tweaks::RenderContent()
if (ImGui::Selectable(TCHAR_TO_ANSI(*TweakProfile.Name.ToString()), IsSelected))
{
Replicator->SetTweakProfile(TweakProfileIndex);
Replicator->Server_SetTweakProfile(TweakProfileIndex);
}
}
ImGui::EndCombo();
@@ -161,6 +161,6 @@ void FCogAbilityWindow_Tweaks::DrawTweak(ACogAbilityReplicator* Replicator, int3
if (bUpdateValue)
{
Replicator->SetTweakValue(TweakIndex, TweakCategoryIndex, *Value);
Replicator->Server_SetTweakValue(TweakIndex, TweakCategoryIndex, *Value);
}
}
Plugins/CogAbility/Source/CogAbility/Public/CogAbilityReplicator.h
+22 -32
View File
@@ -21,9 +21,11 @@ public:
static ACogAbilityReplicator* Spawn(APlayerController* Controller);
static ACogAbilityReplicator* GetLocalReplicator(UWorld& World);
static ACogAbilityReplicator* GetFirstReplicator(const UWorld& World);
static void GetRemoteReplicators(UWorld& World, TArray<ACogAbilityReplicator*>& Replicators);
static void TryApplyAllTweaksOnActor(const AActor* Actor);
static void GetReplicators(const UWorld& World, TArray<ACogAbilityReplicator*>& Replicators);
virtual void BeginPlay() override;
@@ -31,34 +33,11 @@ public:
APlayerController* GetPlayerController() const { return OwnerPlayerController.Get(); }
void ApplyCheat(AActor* CheatInstigator, const TArray<AActor*>& Targets, const FCogAbilityCheat& Cheat);
static bool IsCheatActive(const AActor* EffectTarget, const FCogAbilityCheat& Cheat);
void GiveAbility(AActor* TargetActor, TSubclassOf<UGameplayAbility> AbilityClass) const;
void RemoveAbility(AActor* TargetActor, const FGameplayAbilitySpecHandle& Handle) const;
void ResetAllTweaks();
void SetTweakValue(int32 TweakIndex, int32 CategoryIndex, float Value);
void SetTweakProfile(int32 ProfileIndex);
int32 GetTweakProfileIndex() const { return TweakProfileIndex; }
float GetTweakCurrentValue(int32 TweakIndex, int32 CategoryIndex);
float* GetTweakCurrentValuePtr(int32 TweakIndex, int32 CategoryIndex);
private:
UFUNCTION()
void OnAnyActorSpawned(AActor* Actor);
UFUNCTION(Reliable, Server)
void Server_ApplyCheat(const AActor* CheatInstigator, const TArray<AActor*>& TargetActors, const FCogAbilityCheat& Cheat) const;
static bool IsCheatActive(const AActor* EffectTarget, const FCogAbilityCheat& Cheat);
UFUNCTION(Reliable, Server)
void Server_GiveAbility(AActor* TargetActor, TSubclassOf<UGameplayAbility> AbilityClass) const;
@@ -74,17 +53,27 @@ private:
UFUNCTION(Reliable, Server)
void Server_SetTweakProfile(int32 ProfileIndex);
void SetTweakCurrentValue(int32 TweakIndex, int32 CategoryIndex, float Value);
int32 GetTweakProfileIndex() const { return TweakProfileIndex; }
float GetTweakCurrentValue(int32 TweakIndex, int32 CategoryIndex);
float* GetTweakCurrentValuePtr(int32 TweakIndex, int32 TweakCategoryIndex);
protected:
void SetTweakCurrentValue(int32 TweakIndex, int32 TweakCategoryIndex, float Value);
static void ApplyTweakOnActor(const AActor* Actor, const FCogAbilityTweak& Tweak, float Value, const FGameplayTag& SetByCallerMagnitudeTag);
void ApplyAllTweaksOnAllActors();
void ApplyTweakOnActor(AActor* Actor, const FCogAbilityTweak& Tweak, float Value, const FGameplayTag& SetByCallerMagnitudeTag);
void ApplyAllTweaksOnActor(const AActor* Actor);
void ApplyAllTweaksOnActor(int32 TweakCategoryIndex, AActor* Actor);
void ApplyAllTweaksOnActor(int32 TweakCategoryIndex, const AActor* Actor);
void FindActorsFromTweakCategory(int32 CategoryIndex, TArray<AActor*>& Actors);
void FindActorsFromTweakCategory(int32 TweakCategoryIndex, TArray<AActor*>& Actors) const;
int32 FindTweakCategoryFromActor(AActor* Actor);
int32 FindTweakCategoryFromActor(const AActor* Actor) const;
static bool IsActorMatchingTweakCategory(const AActor* Actor, const UAbilitySystemComponent* ActorAbilitySystem, const FCogAbilityTweakCategory& TweakCategory);
@@ -97,6 +86,7 @@ private:
UPROPERTY(Config)
TArray<FString> AppliedCheatsOnLocalPawn;
UPROPERTY()
TObjectPtr<APlayerController> OwnerPlayerController;
FDelegateHandle OnAnyActorSpawnedHandle;
Source/CogSample/CogSampleCharacter.cpp
+5 -2
View File
@@ -10,7 +10,6 @@
#include "CogSampleFunctionLibrary_Team.h"
#include "CogSampleGameplayAbility.h"
#include "CogSampleLogCategories.h"
#include "CogSamplePlayerController.h"
#include "CogSampleRootMotionParams.h"
#include "Components/CapsuleComponent.h"
#include "Components/InputComponent.h"
@@ -26,7 +25,7 @@
#include "Net/UnrealNetwork.h"
#if ENABLE_COG
#include "CogDebugDraw.h"
#include "CogAbilityReplicator.h"
#include "CogDebugMetric.h"
#include "CogDebugPlot.h"
#endif //ENABLE_COG
@@ -352,6 +351,10 @@ void ACogSampleCharacter::TryFinishInitialize()
return;
}
#if ENABLE_COG
ACogAbilityReplicator::TryApplyAllTweaksOnActor(this);
#endif //ENABLE_COG
RegisterToAbilitySystemEvents();
bIsInitialized = true;