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

Plugins/CogAbility/Source/CogAbility/Private/CogAbilityReplicator.cpp

@@ -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);
+    Replicator->ApplyAllTweaksOnActor(Actor);
-    if (TweakCategoryIndex == INDEX_NONE)
-    {
-        return;
-    }
-
-    ApplyAllTweaksOnActor(TweakCategoryIndex, 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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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;